Changeset 2719


Ignore:
Timestamp:
Apr 19, 2007, 9:51:09 PM (14 years ago)
Author:
orlov
Message:
  • Almost working launch config.
Location:
devel-tools/trunk/eclipse/org.refal.plus.rfpdt.launch
Files:
2 deleted
6 edited
1 moved

Legend:

Unmodified
Added
Removed
  • devel-tools/trunk/eclipse/org.refal.plus.rfpdt.launch/META-INF/MANIFEST.MF

    r2691 r2719  
    1818 org.refal.plus.rfpdt.editor,
    1919 org.eclipse.ui.editors,
    20  org.eclipse.ui.workbench.texteditor
     20 org.eclipse.ui.workbench.texteditor,
     21 org.eclipse.update.configurator
    2122Eclipse-LazyStart: true
    2223Bundle-Vendor: Program Systems Institute, Pereslavl-Zalessky
  • devel-tools/trunk/eclipse/org.refal.plus.rfpdt.launch/src/org/refal/plus/rfpdt/launch/IRfpLaunchConfigurationConstants.java

    r2691 r2719  
    88 * Constant definitions only; not to be implemented.
    99 */
    10 public interface IRfpLaunchConfigurationConstants extends IJavaLaunchConfigurationConstants {
     10public interface IRfpLaunchConfigurationConstants /*extends IJavaLaunchConfigurationConstants*/ {
    1111
    12         /**
    13          * Launch configuration attribute key. The value is a string specifying
    14          * the module to be run by the Jython interpreter.
    15          */
    16         public static final String ATTR_MODULE = "Rfp.MODULE";
     12        public static final String ATTR_PROJECT_NAME = "org.refal.plus.rfpdt.launch.project_name";
    1713
    18         /**
    19          * Launch configuration attribute key. The value is a string specifying
    20          * the arguments to be passed to a module when run by the Jython interpreter.
    21          */
    22         public static final String ATTR_MODULE_ARGUMENTS = "Rfp.MODULE_ARGUMENTS";
     14        public static final String ATTR_MODULE_NAME = IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME;
    2315
    2416}
  • devel-tools/trunk/eclipse/org.refal.plus.rfpdt.launch/src/org/refal/plus/rfpdt/launch/RfpClasspathProvider.java

    r2691 r2719  
    99package org.refal.plus.rfpdt.launch;
    1010
     11import java.io.IOException;
    1112import java.util.ArrayList;
    1213import java.util.Iterator;
     
    1415
    1516import org.eclipse.core.runtime.CoreException;
     17import org.eclipse.core.runtime.FileLocator;
    1618import org.eclipse.core.runtime.IPath;
    1719import org.eclipse.core.runtime.Path;
     20import org.eclipse.core.runtime.Platform;
    1821import org.eclipse.debug.core.ILaunchConfiguration;
    1922import org.eclipse.jdt.core.IClasspathContainer;
     
    2528import org.eclipse.jdt.launching.JavaRuntime;
    2629import org.eclipse.jdt.launching.StandardClasspathProvider;
     30import org.osgi.framework.Bundle;
    2731
    2832public class RfpClasspathProvider extends StandardClasspathProvider {
     
    3943        }
    4044
    41         /**
    42          * The default user classpath includes jython.jar and the entries on the
    43          * project's class path.
    44          *
    45          * @return List of IRuntimeClasspathEntry
    46          */
    4745        protected List defaultUserClassPath(ILaunchConfiguration configuration) throws CoreException {
    48 //              String jythonJarLocation = JyDTPreferences.current().getJythonJarString();
    4946                List paths = new ArrayList();
    50 //              String projectName = configuration.getAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, (String) null);
     47                //String projectName = configuration.getAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, (String) null);
    5148//              if (projectName != null) {
    5249//                      JythonProject project = JythonProject.forProject(CorePlugin.getWorkspace().getRoot().getProject(projectName));
    5350//                      paths.addAll(project.getClassPath().getComposedPath());
    5451//              }
    55 //              if (jythonJarLocation.length() > 0)
    56 //                      paths.add(0, new Path(jythonJarLocation));
    57                 paths.add(new Path("C:/Yura/Refal/java/RefalPlus.jar"));
    58                 paths.add(new Path("/"));
     52                //paths.add(new Path(projectName));
     53                Bundle b = Platform.getBundle("org.refal.plus.rfpdt.extcomp");
     54                try {
     55                        paths.add(new Path(FileLocator.resolve(b.getEntry("RefalPlus.jar")).getPath()));
     56                } catch (IOException _) {
     57                }
    5958                List classpathEntries = new ArrayList();
    6059                for (Iterator iter = paths.iterator(); iter.hasNext();) {
  • devel-tools/trunk/eclipse/org.refal.plus.rfpdt.launch/src/org/refal/plus/rfpdt/launch/RfpLaunchConfigurationDelegate.java

    r2691 r2719  
    99package org.refal.plus.rfpdt.launch;
    1010
    11 import java.util.ArrayList;
    12 import java.util.List;
    13 import java.util.Map;
    14 
    1511import org.eclipse.core.runtime.CoreException;
    1612import org.eclipse.core.runtime.IProgressMonitor;
    1713import org.eclipse.debug.core.DebugPlugin;
    18 import org.eclipse.debug.core.ILaunch;
    1914import org.eclipse.debug.core.ILaunchConfiguration;
    2015import org.eclipse.debug.core.ILaunchManager;
    2116import org.eclipse.debug.core.IStatusHandler;
    2217import org.eclipse.debug.core.model.IBreakpoint;
    23 import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
    24 import org.eclipse.jdt.launching.IRuntimeClasspathEntry;
    25 import org.eclipse.jdt.launching.IVMInstall;
    2618import org.eclipse.jdt.launching.JavaLaunchDelegate;
    27 import org.eclipse.jdt.launching.JavaRuntime;
    2819
    2920/**
     
    3829public class RfpLaunchConfigurationDelegate extends JavaLaunchDelegate {
    3930
    40         public void launch(ILaunchConfiguration configuration, String mode, ILaunch launch, IProgressMonitor monitor) throws CoreException {
    41                 String workingDirectory = configuration.getAttribute(IJavaLaunchConfigurationConstants.ATTR_WORKING_DIRECTORY, "");
    42                 launch.setAttribute(IJavaLaunchConfigurationConstants.ATTR_WORKING_DIRECTORY, workingDirectory);
    43                 super.launch(configuration, mode, launch, monitor);
    44         }
    45 
    46         public IVMInstall getVMInstall(ILaunchConfiguration configuration) throws CoreException {
    47                 // To avoid error on non-existing Java project:
    48                 return JavaRuntime.getDefaultVMInstall();
    49         }
     31//      public IVMInstall getVMInstall(ILaunchConfiguration configuration) throws CoreException {
     32//              // To avoid error on non-existing Java project:
     33//              return JavaRuntime.getDefaultVMInstall();
     34//      }
    5035
    5136        public boolean preLaunchCheck(ILaunchConfiguration configuration, String mode, IProgressMonitor monitor) throws CoreException {
     37                if (!saveBeforeLaunch(configuration, mode, monitor)) {
     38                        return false;
     39                }
    5240                if (mode.equals(ILaunchManager.RUN_MODE) && configuration.supportsMode(ILaunchManager.DEBUG_MODE)) {
    53                         IBreakpoint[] breakpoints = getBreakpoints(configuration);
    54                         if (breakpoints == null) {
    55                                 return true;
    56                         }
     41                        IBreakpoint[] breakpoints= getBreakpoints(configuration);
     42            if (breakpoints == null) {
     43                return true;
     44            }
    5745                        for (int i = 0; i < breakpoints.length; i++) {
    5846                                if (breakpoints[i].isEnabled()) {
    5947                                        IStatusHandler prompter = DebugPlugin.getDefault().getStatusHandler(promptStatus);
    6048                                        if (prompter != null) {
    61                                                 boolean launchInDebugModeInstead = ((Boolean) prompter.handleStatus(switchToDebugPromptStatus, configuration)).booleanValue();
    62                                                 if (launchInDebugModeInstead) {
    63                                                         return false; // kill this launch
    64                                                 }
     49                                                boolean launchInDebugModeInstead = ((Boolean)prompter.handleStatus(switchToDebugPromptStatus, configuration)).booleanValue();
     50                                                if (launchInDebugModeInstead) { 
     51                                                        return false; //kill this launch
     52                                                } 
    6553                                        }
    66                                         // if no user prompt, or user says to continue (no need to
    67                                         // check other breakpoints)
     54                                        // if no user prompt, or user says to continue (no need to check other breakpoints)
    6855                                        return true;
    6956                                }
    7057                        }
    71                 }
     58                }       
    7259                // no enabled breakpoints... continue launch
    7360                return true;
    7461        }
    7562
    76         public Map getVMSpecificAttributesMap(ILaunchConfiguration configuration) throws CoreException {
    77                 return null;
    78         }
    79 
    80         public String[] getClasspath(ILaunchConfiguration configuration) throws CoreException {
    81                 IRuntimeClasspathEntry[] entries = new RfpClasspathProvider().computeUnresolvedClasspath(configuration);
    82                 entries = JavaRuntime.resolveRuntimeClasspath(entries, configuration);
    83                 List userEntries = new ArrayList(entries.length);
    84                 for (int i = 0; i < entries.length; i++) {
    85                         if (entries[i].getClasspathProperty() == IRuntimeClasspathEntry.USER_CLASSES) {
    86                                 String location = entries[i].getLocation();
    87                                 if (location != null) {
    88                                         userEntries.add(location);
    89                                 }
    90                         }
    91                 }
    92                 return (String[]) userEntries.toArray(new String[userEntries.size()]);
    93         }
    94 
    95         public String[] getBootpath(ILaunchConfiguration configuration) throws CoreException {
    96                 return new String[0];
    97         }
    98 
    9963}
  • devel-tools/trunk/eclipse/org.refal.plus.rfpdt.launch/src/org/refal/plus/rfpdt/launch/ui/RfpLaunchShortcut.java

    r2695 r2719  
    3333import org.eclipse.ui.IEditorPart;
    3434import org.eclipse.ui.dialogs.ElementListSelectionDialog;
    35 //import org.refal.plus.rfpdt.core.RfpCorePlugin;
    36 //import org.refal.plus.rfpdt.editor.RfpEditor;
    3735import org.refal.plus.rfpdt.launch.IRfpLaunchConfigurationConstants;
    3836import org.refal.plus.rfpdt.launch.LaunchingPlugin;
     
    105103                        for (int i = 0; i < configs.length; i++) {
    106104                                ILaunchConfiguration config = configs[i];
    107                                 if (config.getAttribute(IRfpLaunchConfigurationConstants.ATTR_MODULE, "").equals(module.getName())
    108                                                 && config.getAttribute(IJavaLaunchConfigurationConstants.ATTR_WORKING_DIRECTORY, "").equals(this.getWorkingDirectory(module))) {
    109                                         candidateConfigs.add(config);
    110                                 }
     105//                              if (config.getAttribute(IRfpLaunchConfigurationConstants.ATTR_MODULE, "").equals(module.getName())
     106//                                              && config.getAttribute(IJavaLaunchConfigurationConstants.ATTR_WORKING_DIRECTORY, "").equals(this.getWorkingDirectory(module))) {
     107//                                      candidateConfigs.add(config);
     108//                              }
    111109                        }
    112110                } catch (CoreException e) {
     
    176174                try {
    177175                        //if (project != null)
    178                                 configuration.setAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, "Project Name"/*RfpCorePlugin.getPluginId()*//*getProject().getName()*/);
     176                                configuration.setAttribute(IRfpLaunchConfigurationConstants.ATTR_PROJECT_NAME, ""/*RfpCorePlugin.getPluginId()*//*getProject().getName()*/);
    179177                        IRuntimeClasspathEntry[] entries = new RfpClasspathProvider().computeUnresolvedClasspath(configuration);
    180178                        // Set ATTR_DEFAULT_CLASSPATH to false here, because we want to use
     
    213211                }
    214212                // TODO do not hardcode the string in 2 places (see JythonJavaMainTab)
    215                 wc.setAttribute(IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, "org.python.util.jython");
     213                wc.setAttribute(IRfpLaunchConfigurationConstants.ATTR_PROJECT_NAME, "");
     214                wc.setAttribute(IRfpLaunchConfigurationConstants.ATTR_MODULE_NAME, "");
    216215                //wc.setAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, module.getProject().getName());
    217                 wc.setAttribute(IRfpLaunchConfigurationConstants.ATTR_MODULE, module.getName());
     216//              wc.setAttribute(IRfpLaunchConfigurationConstants.ATTR_MODULE, module.getName());
    218217                wc.setAttribute(IJavaLaunchConfigurationConstants.ATTR_PROGRAM_ARGUMENTS, module.getName());
    219218                //JythonProject project = JythonProject.forProject(module.getProject());
  • devel-tools/trunk/eclipse/org.refal.plus.rfpdt.launch/src/org/refal/plus/rfpdt/launch/ui/RfpRefalMainTab.java

    r2718 r2719  
    1 /*******************************************************************************
    2  * This program and the accompanying materials are made available under the
    3  * terms of the Common Public License v1.0 which accompanies this distribution,
    4  * and is available at http://www.opensource.org/licenses/cpl1.0.php
    5  *
    6  * Contributors:
    7  *     Red Robin - initial API and implementation
    8  *******************************************************************************/
    91package org.refal.plus.rfpdt.launch.ui;
    10 
    11 //import net.redrobin.eclipse.jydt.core.CorePlugin;
    122
    133import org.eclipse.core.runtime.CoreException;
     
    2616import org.eclipse.swt.layout.GridLayout;
    2717import org.eclipse.swt.widgets.Composite;
    28 import org.eclipse.swt.widgets.Label;
     18import org.eclipse.swt.widgets.Group;
    2919import org.eclipse.swt.widgets.Text;
     20import org.refal.plus.rfpdt.launch.IRfpLaunchConfigurationConstants;
    3021
    3122
    32 /**
    33  * The "Java Main" tab in a JythonTabGroup.
    34  * The tab page contains a field to enter the fully qualified name
    35  * of the jython interpreter class. By default, this is
    36  * org.python.util.jython, but advanced users, using a custom
    37  * Jython implementation, may enter other class names, as long as
    38  * they are included in a jar on the class path of the launch
    39  * configuration.
    40  *
    41  * @see RfpTabGroup
    42  */
    43 public class RfpJavaMainTab extends AbstractLaunchConfigurationTab {
     23public class RfpRefalMainTab extends AbstractLaunchConfigurationTab {
    4424
    45         protected Label fMainLabel;
    46         protected Text fMainText;
     25        protected Text fProjectText;
     26        protected Text fModuleText;
    4727                       
    48         protected static final String EMPTY_STRING = "";
    49        
    5028        public void createControl(Composite parent) {
    51                 Font font = parent.getFont();
    52                
    5329                Composite comp = new Composite(parent, SWT.NONE);
    5430                setControl(comp);
    5531                GridLayout topLayout = new GridLayout();
    5632                comp.setLayout(topLayout);             
    57                 GridData gd;
    58                
    59                 createVerticalSpacer(comp, 1);
     33                createProjectEditor(comp);
     34                createModuleEditor(comp);
     35//              GridData gd;
     36//             
     37//              createVerticalSpacer(comp, 1);
     38//
     39//              Composite mainComp = new Composite(comp, SWT.NONE);
     40//              GridLayout mainLayout = new GridLayout();
     41//              mainLayout.numColumns = 2;
     42//              mainLayout.marginHeight = 0;
     43//              mainLayout.marginWidth = 0;
     44//              mainComp.setLayout(mainLayout);
     45//              gd = new GridData(GridData.FILL_HORIZONTAL);
     46//              mainComp.setLayoutData(gd);
     47//              mainComp.setFont(font);
     48//             
     49//              fMainLabel = new Label(mainComp, SWT.NONE);
     50//              fMainLabel.setText("Refal module (qualified name):");
     51//              gd = new GridData();
     52//              gd.horizontalSpan = 2;
     53//              fMainLabel.setLayoutData(gd);
     54//              fMainLabel.setFont(font);
     55//
     56//              fMainText = new Text(mainComp, SWT.SINGLE | SWT.BORDER);
     57//              gd = new GridData(GridData.FILL_HORIZONTAL);
     58//              fMainText.setLayoutData(gd);
     59//              fMainText.setFont(font);
     60//              fMainText.addModifyListener(new ModifyListener() {
     61//                      public void modifyText(ModifyEvent evt) {
     62//                              updateLaunchConfigurationDialog();
     63//                      }
     64//              });     
     65//             
     66        }
    6067
    61                 Composite mainComp = new Composite(comp, SWT.NONE);
    62                 GridLayout mainLayout = new GridLayout();
    63                 mainLayout.numColumns = 2;
    64                 mainLayout.marginHeight = 0;
    65                 mainLayout.marginWidth = 0;
    66                 mainComp.setLayout(mainLayout);
     68        private void createProjectEditor(Composite parent) {
     69                Font font= parent.getFont();
     70                Group group= new Group(parent, SWT.NONE);
     71                group.setText("Refal project");
     72                GridData gd = new GridData(GridData.FILL_HORIZONTAL);
     73                group.setLayoutData(gd);
     74                GridLayout layout = new GridLayout();
     75                layout.numColumns = 2;
     76                group.setLayout(layout);
     77                group.setFont(font);
     78                fProjectText = new Text(group, SWT.SINGLE | SWT.BORDER);
    6779                gd = new GridData(GridData.FILL_HORIZONTAL);
    68                 mainComp.setLayoutData(gd);
    69                 mainComp.setFont(font);
    70                
    71                 fMainLabel = new Label(mainComp, SWT.NONE);
    72                 fMainLabel.setText("Main class (Jython interpreter):");
    73                 gd = new GridData();
    74                 gd.horizontalSpan = 2;
    75                 fMainLabel.setLayoutData(gd);
    76                 fMainLabel.setFont(font);
    77 
    78                 fMainText = new Text(mainComp, SWT.SINGLE | SWT.BORDER);
    79                 gd = new GridData(GridData.FILL_HORIZONTAL);
    80                 fMainText.setLayoutData(gd);
    81                 fMainText.setFont(font);
    82                 fMainText.addModifyListener(new ModifyListener() {
     80                fProjectText.setLayoutData(gd);
     81                fProjectText.setFont(font);
     82                fProjectText.addModifyListener(new ModifyListener() {
    8383                        public void modifyText(ModifyEvent evt) {
    8484                                updateLaunchConfigurationDialog();
    8585                        }
    8686                });     
    87                
    88         }
    89                
     87                //fProjButton = createPushButton(group, LauncherMessages.AbstractJavaMainTab_1, null);
     88                //fProjButton.addSelectionListener(fListener);
     89        }       
     90        private void createModuleEditor(Composite parent) {
     91                Font font= parent.getFont();
     92                Group group= new Group(parent, SWT.NONE);
     93                group.setText("Refal module (qualified name)");
     94                GridData gd = new GridData(GridData.FILL_HORIZONTAL);
     95                group.setLayoutData(gd);
     96                GridLayout layout = new GridLayout();
     97                layout.numColumns = 2;
     98                group.setLayout(layout);
     99                group.setFont(font);
     100                fModuleText = new Text(group, SWT.SINGLE | SWT.BORDER);
     101                gd = new GridData(GridData.FILL_HORIZONTAL);
     102                fModuleText.setLayoutData(gd);
     103                fModuleText.setFont(font);
     104                fModuleText.addModifyListener(new ModifyListener() {
     105                        public void modifyText(ModifyEvent evt) {
     106                                updateLaunchConfigurationDialog();
     107                        }
     108                });     
     109                //fProjButton = createPushButton(group, LauncherMessages.AbstractJavaMainTab_1, null);
     110                //fProjButton.addSelectionListener(fListener);
     111        }       
     112       
    90113        public void initializeFrom(ILaunchConfiguration config) {
    91                 String mainTypeName = "";
     114                String projectName = "";
     115                String moduleName = "";
    92116                try {
    93                         mainTypeName = config.getAttribute(IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, EMPTY_STRING);
     117                        projectName = config.getAttribute(IRfpLaunchConfigurationConstants.ATTR_PROJECT_NAME, "");
     118                        moduleName = config.getAttribute(IRfpLaunchConfigurationConstants.ATTR_MODULE_NAME, "");
    94119                } catch (CoreException ce) {
    95120                        //CorePlugin.log(ce);   
    96121                }       
    97                 fMainText.setText(mainTypeName);       
     122                fProjectText.setText(projectName);     
     123                fModuleText.setText(moduleName);       
    98124        }
    99125               
    100126        public void performApply(ILaunchConfigurationWorkingCopy config) {
    101                 config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, (String)fMainText.getText());
     127                config.setAttribute(IRfpLaunchConfigurationConstants.ATTR_PROJECT_NAME, (String)fProjectText.getText());
     128                config.setAttribute(IRfpLaunchConfigurationConstants.ATTR_MODULE_NAME, (String)fModuleText.getText());
    102129        }
    103130                       
     
    110137                setMessage(null);
    111138               
    112                 String name = fMainText.getText().trim();
     139                String name = fProjectText.getText().trim();
    113140                if (name.length() == 0) {
    114                         setErrorMessage("Main type not specified");
     141                        setErrorMessage("Project name not specified");
     142                        return false;
     143                }
     144                name = fModuleText.getText().trim();
     145                if (name.length() == 0) {
     146                        setErrorMessage("Main module name not specified");
    115147                        return false;
    116148                }
     
    120152
    121153        public void setDefaults(ILaunchConfigurationWorkingCopy config) {
    122                 config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, "org.python.util.jython");
     154                config.setAttribute(IRfpLaunchConfigurationConstants.ATTR_PROJECT_NAME, "");
     155                config.setAttribute(IRfpLaunchConfigurationConstants.ATTR_MODULE_NAME, "");
    123156        }
    124157
    125158        public String getName() {
    126                 return "Java Main";
     159                return "Refal Main";
    127160        }
    128161
  • devel-tools/trunk/eclipse/org.refal.plus.rfpdt.launch/src/org/refal/plus/rfpdt/launch/ui/RfpTabGroup.java

    r2695 r2719  
    1818import org.eclipse.debug.ui.ILaunchConfigurationTab;
    1919import org.eclipse.debug.ui.sourcelookup.SourceLookupTab;
     20import org.eclipse.jdt.debug.ui.launchConfigurations.JavaArgumentsTab;
    2021import org.eclipse.jdt.debug.ui.launchConfigurations.JavaClasspathTab;
    2122import org.eclipse.jdt.debug.ui.launchConfigurations.JavaJRETab;
     
    2425import org.eclipse.jface.viewers.IStructuredSelection;
    2526import org.eclipse.ui.IWorkbenchPage;
    26 //import org.refal.plus.rfpdt.core.RfpCorePlugin;
    2727import org.refal.plus.rfpdt.launch.LaunchingPlugin;
    2828
     
    4242        public void createTabs(ILaunchConfigurationDialog dialog, String mode) {
    4343                ILaunchConfigurationTab[] tabs = new ILaunchConfigurationTab[] {
    44                                 new RfpMainTab(), new RfpJavaMainTab(),
    45                                 new RfpArgumentsTab(), new JavaJRETab(),
     44                                new RfpRefalMainTab(),
     45                                new JavaArgumentsTab(), new JavaJRETab(),
    4646                                new JavaClasspathTab(), new SourceLookupTab(),
    4747                                new EnvironmentTab(), new CommonTab() };
     
    7373                // are run
    7474                String moduleArguments = "";
    75                 RfpMainTab.apply(pyFilename, moduleArguments, config);
    7675                //TODO remove code duplication. See JythonLaunchShortcut#createConfiguration
    7776//              String jythonHome = JyDTPreferences.current().getJythonHomeString();
Note: See TracChangeset for help on using the changeset viewer.