Attachment #79685 for bug #201758

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 40-45 Link Here

(-)launching/org/eclipse/jdt/internal/launching/LaunchingMessages.java (+6 lines)
40		40
41	public static String EEVMType_1;	41	public static String EEVMType_1;
42		42
		43	public static String EEVMType_2;
		44
		45	public static String EEVMType_3;
		46
43	public static String JavaLocalApplicationLaunchConfigurationDelegate_Verifying_launch_attributes____1;	47	public static String JavaLocalApplicationLaunchConfigurationDelegate_Verifying_launch_attributes____1;
44	public static String JavaLocalApplicationLaunchConfigurationDelegate_Creating_source_locator____2;	48	public static String JavaLocalApplicationLaunchConfigurationDelegate_Creating_source_locator____2;
45	public static String JavaLocalApplicationLaunchConfigurationDelegate_0;	49	public static String JavaLocalApplicationLaunchConfigurationDelegate_0;
Lines 53-58 Link Here
53	public static String JavaRemoteApplicationLaunchConfigurationDelegate_Verifying_launch_attributes____1;	57	public static String JavaRemoteApplicationLaunchConfigurationDelegate_Verifying_launch_attributes____1;
54	public static String JavaRemoteApplicationLaunchConfigurationDelegate_Creating_source_locator____2;	58	public static String JavaRemoteApplicationLaunchConfigurationDelegate_Creating_source_locator____2;
55		59
		60	public static String JavaRuntime_24;
		61
56	public static String JavaRuntime_25;	62	public static String JavaRuntime_25;
57		63
58	public static String JavaRuntime_badFormat;	64	public static String JavaRuntime_badFormat;

Lines 171-181 Link Here

(-)launching/org/eclipse/jdt/internal/launching/StandardVMRunner.java (-2 / +8 lines)
171		171
172	// If no java command was specified, use default executable	172	// If no java command was specified, use default executable
173	if (command == null) {	173	if (command == null) {
174	File exe = StandardVMType.findJavaExecutable(fVMInstance.getInstallLocation());	174	File exe = null;
		175	if (fVMInstance instanceof StandardVM) {
		176	exe = ((StandardVM)fVMInstance).getJavaExecutable();
		177	} else {
		178	exe = StandardVMType.findJavaExecutable(fVMInstance.getInstallLocation());
		179	}
175	if (exe == null) {	180	if (exe == null) {
176	abort(MessageFormat.format(LaunchingMessages.StandardVMRunner_Unable_to_locate_executable_for__0__1, new String[]{fVMInstance.getName()}), null, IJavaLaunchConfigurationConstants.ERR_INTERNAL_ERROR);	181	abort(MessageFormat.format(LaunchingMessages.StandardVMRunner_Unable_to_locate_executable_for__0__1, new String[]{fVMInstance.getName()}), null, IJavaLaunchConfigurationConstants.ERR_INTERNAL_ERROR);
		182	} else {
		183	return exe.getAbsolutePath();
177	}	184	}
178	return exe.getAbsolutePath();
179	}	185	}
180		186
181	// Build the path to the java executable. First try 'bin', and if that	187	// Build the path to the java executable. First try 'bin', and if that




        StandardVMType installType = (StandardVMType) getVMInstallType();
        File installLocation = getInstallLocation();
        if (installLocation != null) {
            File executable = getJavaExecutable();
        		return EEVMType.getJavaVersion(installLocation);
        	}
            File executable = StandardVMType.findJavaExecutable(installLocation);
            if (executable != null) {
                String vmVersion = installType.getVMVersion(installLocation, executable);
                // strip off extra info

        }
        return null;
    }
    
    /**
     * Returns the java executable for this VM or <code>null</code> if cannot be found
     * 
     * @return executable for this VM or <code>null</code> if none
     */
    File getJavaExecutable() {
    	File installLocation = getInstallLocation();
        if (installLocation != null) {
            return StandardVMType.findJavaExecutable(installLocation);
        }
        return null;
    }
    
    
}

Lines 28-33 Link Here

(-)launching/org/eclipse/jdt/internal/launching/EEVMType.java (-45 / +114 lines)
28	import org.eclipse.core.runtime.IStatus;	28	import org.eclipse.core.runtime.IStatus;
29	import org.eclipse.core.runtime.Path;	29	import org.eclipse.core.runtime.Path;
30	import org.eclipse.core.runtime.Status;	30	import org.eclipse.core.runtime.Status;
		31	import org.eclipse.jdt.launching.AbstractVMInstall;
		32	import org.eclipse.jdt.launching.AbstractVMInstallType;
		33	import org.eclipse.jdt.launching.IVMInstall;
31	import org.eclipse.jdt.launching.LibraryLocation;	34	import org.eclipse.jdt.launching.LibraryLocation;
32		35
33	import com.ibm.icu.text.MessageFormat;	36	import com.ibm.icu.text.MessageFormat;
Lines 38-44 Link Here
38	*	41	*
39	* @since 3.4	42	* @since 3.4
40	*/	43	*/
41	public class EEVMType {	44	public class EEVMType extends AbstractVMInstallType {
		45
		46	/**
		47	* VM Type id
		48	*/
		49	public static final String ID_EE_VM_TYPE = "org.eclipse.jdt.launching.EEVMType"; //$NON-NLS-1$
42		50
43	/**	51	/**
44	* Map of {EE File -> {Map of {PropertyName -> PropertyValue}}	52	* Map of {EE File -> {Map of {PropertyName -> PropertyValue}}
Lines 58-112 Link Here
58	public static final String PROP_CLASS_LIB_LEVEL = "-Dee.class.library.level"; //$NON-NLS-1$	66	public static final String PROP_CLASS_LIB_LEVEL = "-Dee.class.library.level"; //$NON-NLS-1$
59	public static final String PROP_EXECUTABLE = "-Dee.executable"; //$NON-NLS-1$	67	public static final String PROP_EXECUTABLE = "-Dee.executable"; //$NON-NLS-1$
60	public static final String PROP_EXECUTABLE_CONSOLE = "-Dee.executable.console"; //$NON-NLS-1$	68	public static final String PROP_EXECUTABLE_CONSOLE = "-Dee.executable.console"; //$NON-NLS-1$
		69	public static final String PROP_JAVA_HOME = "-Djava.home"; //$NON-NLS-1$
61		70
62	private static final String[] REQUIRED_PROPERTIES = new String[]{PROP_EXECUTABLE, PROP_BOOT_CLASS_PATH, PROP_LANGUAGE_LEVEL};	71	private static final String[] REQUIRED_PROPERTIES = new String[]{PROP_EXECUTABLE, PROP_BOOT_CLASS_PATH, PROP_LANGUAGE_LEVEL, PROP_JAVA_HOME};
63		72
64	/**	73	/**
65	* Returns whether the given install location corresponds to an .ee file.	74	* Returns the library locations defined in the given definition file.
66	*	75	*
67	* @param installLocation	76	* @param eeFile definition file
68	* @return whether the given install location corresponds to an .ee file.	77	* @return library locations defined in the file or an empty collection if none
69	*/	78	*/
70	public static boolean isEEInstall(File installLocation) {	79	public static LibraryLocation[] getLibraryLocations(File eeFile) {
71	if (installLocation.isFile()) {
72	String name = installLocation.getName();
73	if (name.endsWith(".ee")) { //$NON-NLS-1$
74	return true;
75	}
76	}
77	return false;
78	}
79
80	/* (non-Javadoc)
81	* @see org.eclipse.jdt.launching.IVMInstallType#getDefaultLibraryLocations(java.io.File)
82	*/
83	public static LibraryLocation[] getDefaultLibraryLocations(File installLocation) {
84		80
85	Map properties = getProperties(installLocation);	81	Map properties = getProperties(eeFile);
86	if (properties == null) {	82	if (properties == null) {
87	return new LibraryLocation[]{};	83	return new LibraryLocation[]{};
88	}	84	}
89		85
90	List allLibs = new ArrayList();	86	List allLibs = new ArrayList();
91		87
92	String dirs = getProperty(PROP_ENDORSED_DIRS, installLocation);	88	String dirs = getProperty(PROP_ENDORSED_DIRS, eeFile);
93	if (dirs != null) {	89	if (dirs != null) {
94	// Add all endorsed libraries - they are first, as they replace	90	// Add all endorsed libraries - they are first, as they replace
95	allLibs.addAll(StandardVMType.gatherAllLibraries(resolvePaths(dirs, installLocation)));	91	allLibs.addAll(StandardVMType.gatherAllLibraries(resolvePaths(dirs, eeFile)));
96	}	92	}
97		93
98	// next is the bootpath libraries	94	// next is the bootpath libraries
99	dirs = getProperty(PROP_BOOT_CLASS_PATH, installLocation);	95	dirs = getProperty(PROP_BOOT_CLASS_PATH, eeFile);
100	if (dirs != null) {	96	if (dirs != null) {
101	String[] bootpath = resolvePaths(dirs, installLocation);	97	String[] bootpath = resolvePaths(dirs, eeFile);
102	List boot = new ArrayList(bootpath.length);	98	List boot = new ArrayList(bootpath.length);
103	URL url = getDefaultJavadocLocation(installLocation);	99	URL url = getJavadocLocation(eeFile);
104	for (int i = 0; i < bootpath.length; i++) {	100	for (int i = 0; i < bootpath.length; i++) {
105	IPath path = new Path(bootpath[i]);	101	IPath path = new Path(bootpath[i]);
106	File lib = path.toFile();	102	File lib = path.toFile();
107	if (lib.exists() && lib.isFile()) {	103	if (lib.exists() && lib.isFile()) {
108	LibraryLocation libraryLocation = new LibraryLocation(path,	104	LibraryLocation libraryLocation = new LibraryLocation(path,
109	getDefaultSourceLocation(installLocation),	105	getDefaultSourceLocation(eeFile),
110	Path.EMPTY,	106	Path.EMPTY,
111	url);	107	url);
112	boot.add(libraryLocation);	108	boot.add(libraryLocation);
Lines 116-124 Link Here
116	}	112	}
117		113
118	// Add all extension libraries	114	// Add all extension libraries
119	dirs = getProperty(PROP_EXTENSION_DIRS, installLocation);	115	dirs = getProperty(PROP_EXTENSION_DIRS, eeFile);
120	if (dirs != null) {	116	if (dirs != null) {
121	allLibs.addAll(StandardVMType.gatherAllLibraries(resolvePaths(dirs, installLocation)));	117	allLibs.addAll(StandardVMType.gatherAllLibraries(resolvePaths(dirs, eeFile)));
122	}	118	}
123		119
124		120
Lines 135-158 Link Here
135	return (LibraryLocation[])allLibs.toArray(new LibraryLocation[allLibs.size()]);	131	return (LibraryLocation[])allLibs.toArray(new LibraryLocation[allLibs.size()]);
136	}	132	}
137		133
138	/* (non-Javadoc)	134
139	* @see org.eclipse.jdt.launching.AbstractVMInstallType#getDefaultJavadocLocation(java.io.File)	135	/**
		136	* Returns the javadoc location specified in the definition file or <code>null</code>
		137	* if none.
		138	*
		139	* @param eeFile definition file
		140	* @return javadoc location specified in the definition file or <code>null</code> if none
140	*/	141	*/
141	public static URL getDefaultJavadocLocation(File installLocation) {	142	public static URL getJavadocLocation(File eeFile) {
142	String version = getProperty(PROP_LANGUAGE_LEVEL, installLocation);	143	String version = getProperty(PROP_LANGUAGE_LEVEL, eeFile);
143	if (version != null) {	144	if (version != null) {
144	return StandardVMType.getDefaultJavadocLocation(version);	145	return StandardVMType.getDefaultJavadocLocation(version);
145	}	146	}
146	return null;	147	return null;
147	}	148	}
148		149
149	/* (non-Javadoc)	150	/**
150	* @see org.eclipse.jdt.launching.AbstractVMInstallType#getDefaultVMArguments(java.io.File)	151	* Returns the definition file associated with the given VM or <code>null</code>
		152	* if none.
		153	*
		154	* @param vm VM install
		155	* @return definition file or <code>null</code> if none. The file may/may not exist.
		156	*/
		157	public static File getDefinitionFile(IVMInstall vm) {
		158	if (vm instanceof AbstractVMInstall) {
		159	AbstractVMInstall avm = (AbstractVMInstall) vm;
		160	String path = avm.getAttribute(EEVMInstall.ATTR_DEFINITION_FILE);
		161	if (path != null) {
		162	return new File(path);
		163	}
		164	}
		165	return null;
		166	}
		167
		168	/**
		169	* Returns VM arguments defined in the given definition file or <code>null</code> if none.
		170	*
		171	* @param eeFile definition file
		172	* @return VM arguments or <code>null</code> if none
151	*/	173	*/
152	public static String getDefaultVMArguments(File installLocation) {	174	public static String getVMArguments(File eeFile) {
153	Map properties = getProperties(installLocation);	175	Map properties = getProperties(eeFile);
154	if (properties != null) {	176	if (properties != null) {
155	List args = (List) fgArguments.get(installLocation);	177	List args = (List) fgArguments.get(eeFile);
156	StringBuffer buf = new StringBuffer();	178	StringBuffer buf = new StringBuffer();
157	Iterator iterator = args.iterator();	179	Iterator iterator = args.iterator();
158	while (iterator.hasNext()) {	180	while (iterator.hasNext()) {
Lines 185-204 Link Here
185	return Path.EMPTY;	207	return Path.EMPTY;
186	}	208	}
187		209
188	/* (non-Javadoc)	210	/**
189	* @see org.eclipse.jdt.launching.IVMInstallType#validateInstallLocation(java.io.File)	211	* Returns a status indicating if the given definition file is valid.
		212	*
		213	* @param eeFile definition file
		214	* @return status indicating if the given definition file is valid
190	*/	215	*/
191	public static IStatus validateInstallLocation(File installLocation) {	216	public static IStatus validateDefinitionFile(File eeFile) {
192	Map properties = getProperties(installLocation);	217	Map properties = getProperties(eeFile);
193	if (properties == null) {	218	if (properties == null) {
194	return new Status(IStatus.ERROR, LaunchingPlugin.getUniqueIdentifier(), MessageFormat.format(LaunchingMessages.EEVMType_0, new String[]{installLocation.getName()} ));	219	return new Status(IStatus.ERROR, LaunchingPlugin.getUniqueIdentifier(), MessageFormat.format(LaunchingMessages.EEVMType_0, new String[]{eeFile.getName()} ));
195	}	220	}
196	// validate required properties	221	// validate required properties
197	for (int i = 0; i < REQUIRED_PROPERTIES.length; i++) {	222	for (int i = 0; i < REQUIRED_PROPERTIES.length; i++) {
198	String key = REQUIRED_PROPERTIES[i];	223	String key = REQUIRED_PROPERTIES[i];
199	String property = (String) properties.get(key);	224	String property = (String) properties.get(key);
200	if (property == null) {	225	if (property == null) {
201	return new Status(IStatus.ERROR, LaunchingPlugin.getUniqueIdentifier(), MessageFormat.format(LaunchingMessages.EEVMType_1, new String[]{installLocation.getName(), key} ));	226	return new Status(IStatus.ERROR, LaunchingPlugin.getUniqueIdentifier(), MessageFormat.format(LaunchingMessages.EEVMType_1, new String[]{eeFile.getName(), key} ));
202	}	227	}
203	}	228	}
204	return Status.OK_STATUS;	229	return Status.OK_STATUS;
Lines 209-215 Link Here
209	* is considered first.	234	* is considered first.
210	*	235	*
211	* @param installLocation ee file	236	* @param installLocation ee file
212	* @return standard executable	237	* @return standard executable or <code>null</code> if none
213	*/	238	*/
214	public static File getExecutable(File installLocation) {	239	public static File getExecutable(File installLocation) {
215	String property = getProperty(PROP_EXECUTABLE, installLocation);	240	String property = getProperty(PROP_EXECUTABLE, installLocation);
Lines 320-323 Link Here
320	}	345	}
321	return null;	346	return null;
322	}	347	}
		348
		349	/* (non-Javadoc)
		350	* @see org.eclipse.jdt.launching.AbstractVMInstallType#doCreateVMInstall(java.lang.String)
		351	*/
		352	protected IVMInstall doCreateVMInstall(String id) {
		353	return new EEVMInstall(this, id);
		354	}
		355
		356	/* (non-Javadoc)
		357	* @see org.eclipse.jdt.launching.IVMInstallType#detectInstallLocation()
		358	*/
		359	public File detectInstallLocation() {
		360	return null;
		361	}
		362
		363	/* (non-Javadoc)
		364	* @see org.eclipse.jdt.launching.IVMInstallType#getDefaultLibraryLocations(java.io.File)
		365	*/
		366	public LibraryLocation[] getDefaultLibraryLocations(File installLocationOrDefinitionFile) {
		367	return new LibraryLocation[0];
		368	}
		369
		370	/* (non-Javadoc)
		371	* @see org.eclipse.jdt.launching.IVMInstallType#getName()
		372	*/
		373	public String getName() {
		374	return LaunchingMessages.EEVMType_2;
		375	}
		376
		377	/* (non-Javadoc)
		378	* @see org.eclipse.jdt.launching.IVMInstallType#validateInstallLocation(java.io.File)
		379	*/
		380	public IStatus validateInstallLocation(File installLocationOrDefinitionFile) {
		381	return new Status(IStatus.INFO, LaunchingPlugin.getUniqueIdentifier(), LaunchingMessages.EEVMType_3);
		382	}
		383
		384	/**
		385	* Clears any cached properties for the given file.
		386	*
		387	* @param eeFile
		388	*/
		389	public synchronized static void clearProperties(File eeFile) {
		390	fgProperites.remove(eeFile);
		391	}
323	}	392	}




	 * <code>null</code>.
	 */
	public static File findJavaExecutable(File vmInstallLocation) {
		if (EEVMType.isEEInstall(vmInstallLocation)) {
			return EEVMType.getExecutable(vmInstallLocation);
		}
		// Try each candidate in order.  The first one found wins.  Thus, the order
		// of fgCandidateJavaLocations and fgCandidateJavaFiles is significant.
		for (int i = 0; i < fgCandidateJavaFiles.length; i++) {

	 * @see org.eclipse.jdt.launching.IVMInstallType#getDefaultLibraryLocations(File)
	 */
	public LibraryLocation[] getDefaultLibraryLocations(File installLocation) {
		if (EEVMType.isEEInstall(installLocation)) {
			return EEVMType.getDefaultLibraryLocations(installLocation);
		}

		// Determine the java executable that corresponds to the specified install location
		// and use this to generate library information.  If no java executable was found, 
		// the 'standard' libraries will be returned.

	 * @see org.eclipse.jdt.launching.IVMInstallType#validateInstallLocation(java.io.File)
	 */
	public IStatus validateInstallLocation(File javaHome) {
		if (EEVMType.isEEInstall(javaHome)) {
			return EEVMType.validateInstallLocation(javaHome);
		}
		IStatus status = null;
		if (Platform.getOS().equals(Constants.OS_MACOSX)) {
			status = new Status(IStatus.ERROR, LaunchingPlugin.getUniqueIdentifier(), 0, LaunchingMessages.StandardVMType_Standard_VM_not_supported_on_MacOS__1, null); 

	 * @see org.eclipse.jdt.launching.AbstractVMInstallType#getDefaultJavadocLocation(java.io.File)
	 */
	public URL getDefaultJavadocLocation(File installLocation) {
		File javaExecutable = findJavaExecutable(installLocation);
		if (javaExecutable != null) {
			LibraryInfo libInfo = getLibraryInfo(installLocation, javaExecutable);
			if (libInfo != null) {
				String version = libInfo.getVersion();
				return getDefaultJavadocLocation(version);
				if (libInfo != null) {
					String version = libInfo.getVersion();
					return getDefaultJavadocLocation(version);
				}
			}
			return null;
		}
		return null;

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.launching.AbstractVMInstallType#getDefaultVMArguments(java.io.File)
	 */
	public String getDefaultVMArguments(File installLocation) {
		if (EEVMType.isEEInstall(installLocation)) {
			return EEVMType.getDefaultVMArguments(installLocation);
		}
		return super.getDefaultVMArguments(installLocation);
	}

	/**




import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Status;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.jdt.launching.AbstractVMInstall;
import org.eclipse.jdt.launching.IVMInstall;
import org.eclipse.jdt.launching.IVMInstall2;
import org.eclipse.jdt.launching.IVMInstallType;

			}
			vmList.add(vm);
			File installLocation = vm.getInstallLocation();
			if (installLocation == null || vmInstallType.validateInstallLocation(installLocation).getSeverity() == IStatus.ERROR) {
				fInvalidVMList.add(vm);
			}
			fVMList.add(vm);

			}
		}
		
		// vm attributes
		if (vm instanceof AbstractVMInstall) {
			Map attributes = ((AbstractVMInstall)vm).getAttributes();
			if (!attributes.isEmpty()) {
				Element attrElement = doc.createElement("attributeMap"); //$NON-NLS-1$
				Iterator iterator = attributes.entrySet().iterator();
				while (iterator.hasNext()) {
					Entry entry = (Entry) iterator.next();
					Element entryElement = doc.createElement("entry"); //$NON-NLS-1$
					entryElement.setAttribute("key", (String)entry.getKey()); //$NON-NLS-1$
					entryElement.setAttribute("value", (String)entry.getValue()); //$NON-NLS-1$
					attrElement.appendChild(entryElement);
				}
				element.appendChild(attrElement);
			}
		}
		
		return element;
	}
	

					if (subElementName.equals("libraryLocation")) { //$NON-NLS-1$
						LibraryLocation loc = getLibraryLocation(subElement);
						vmStandin.setLibraryLocations(new LibraryLocation[]{loc});
						break;
					} else if (subElementName.equals("libraryLocations")) { //$NON-NLS-1$
						setLibraryLocations(vmStandin, subElement);
					} else if (subElementName.equals("attributeMap")) { //$NON-NLS-1$
						NodeList entries = subElement.getElementsByTagName("entry"); //$NON-NLS-1$
						for (int j = 0; j < entries.getLength(); j++) {
							Node entryNode = entries.item(j);
							if (entryNode instanceof Element) {
								Element entryElement = (Element) entryNode;
								String key = entryElement.getAttribute("key"); //$NON-NLS-1$
								String value = entryElement.getAttribute("value"); //$NON-NLS-1$
								if (key != null && value != null) {
									vmStandin.setAttribute(key, value);
								}
							}
						}
					}
				}
			}

Lines 55-60 Link Here

(-)launching/org/eclipse/jdt/launching/AbstractVMInstall.java (+57 lines)
55	private LibraryLocation[] fSystemLibraryDescriptions;	55	private LibraryLocation[] fSystemLibraryDescriptions;
56	private URL fJavadocLocation;	56	private URL fJavadocLocation;
57	private String fVMArgs;	57	private String fVMArgs;
		58	/**
		59	* Map VM specific attributes that are persisted restored with a VM install.
		60	* @since 3.4
		61	*/
		62	private Map fAttributeMap = new HashMap();
		63
58	// system properties are cached in user preferences prefixed with this key, followed	64	// system properties are cached in user preferences prefixed with this key, followed
59	// by vm type, vm id, and system property name	65	// by vm type, vm id, and system property name
60	private static final String PREF_VM_INSTALL_SYSTEM_PROPERTY = "PREF_VM_INSTALL_SYSTEM_PROPERTY"; //$NON-NLS-1$	66	private static final String PREF_VM_INSTALL_SYSTEM_PROPERTY = "PREF_VM_INSTALL_SYSTEM_PROPERTY"; //$NON-NLS-1$
Lines 484-488 Link Here
484	throw new CoreException(new Status(IStatus.ERROR, LaunchingPlugin	490	throw new CoreException(new Status(IStatus.ERROR, LaunchingPlugin
485	.getUniqueIdentifier(), code, message, exception));	491	.getUniqueIdentifier(), code, message, exception));
486	}	492	}
		493
		494	/**
		495	* Sets a VM specific attribute. Attributes are persisted and restored with VM installs.
		496	* Specifying a value of <code>null</code> as a value removes the attribute. Change
		497	* notification is provided to {@link IVMInstallChangedListener} for VM attributes.
		498	*
		499	* @param key attribute key, cannot be <code>null</code>
		500	* @param value attribute value or <code>null</code> to remove the attribute
		501	* @since 3.4
		502	*/
		503	public void setAttribute(String key, String value) {
		504	String prevValue = (String) fAttributeMap.remove(key);
		505	boolean notify = false;
		506	if (value == null) {
		507	if (prevValue != null && fNotify) {
		508	notify = true;
		509	}
		510	} else {
		511	fAttributeMap.put(key, value);
		512	if (fNotify && (prevValue == null \|\| !prevValue.equals(value))) {
		513	notify = true;
		514	}
		515	}
		516	if (notify) {
		517	PropertyChangeEvent event = new PropertyChangeEvent(this, key, prevValue, value);
		518	JavaRuntime.fireVMChanged(event);
		519	}
		520	}
487		521
		522	/**
		523	* Returns a VM specific attribute associated with the given key or <code>null</code>
		524	* if none.
		525	*
		526	* @param key attribute key, cannot be <code>null</code>
		527	* @return attribute value, or <code>null</code> if none
		528	* @since 3.4
		529	*/
		530	public String getAttribute(String key) {
		531	return (String) fAttributeMap.get(key);
		532	}
		533
		534	/**
		535	* Returns a map of VM specific attributes stored with this VM install. Keys
		536	* and values are strings. Modifying the map does not modify the attributes
		537	* associated with this VM install.
		538	*
		539	* @return map of VM attributes
		540	* @since 3.4
		541	*/
		542	public Map getAttributes() {
		543	return new HashMap(fAttributeMap);
		544	}
488	}	545	}




	void setName(String name);
	/**
	 * Returns the root directory of the install location of this VM.
	 * 
	 * Since 3.4, this may also be a file describing a VM install.
	 * For example, the standard VM installs support execution
	 * environment description files, as described by
	 * <code>http://wiki.eclipse.org/index.php/Execution_Environment_Descriptions</code>.
	 * </p>
	 * @return the root directory of this VM installation. May
	 * 			return <code>null</code>.
	 */
	File getInstallLocation();
	/**
	 * Sets the root directory of the install location of this VM.
	 * 
	 * @param installLocation the root directory of this VM installation
	 * For example, the standard VM installs support execution
	 * environment description files, as described by
	 * <code>http://wiki.eclipse.org/index.php/Execution_Environment_Descriptions</code>.
	 * </p>
	 * @param installLocationOrDefinitionFile the root directory or definition file for
	 * 	this VM installation
	 */
	void setInstallLocation(File installLocation);
		
	/**
	 * Returns the VM type of this VM.




	/**
	 * Validates the given location of a VM installation.
	 * <p>
	 * Since 3.4, the given installLocation may be a file (rather than a home
	 * directory). For example, the standard VM install type accepts execution
	 * environment description files, as described by
	 * <code>http://wiki.eclipse.org/index.php/Execution_Environment_Descriptions</code>.
	 * </p> 
	 * <p>
	 * For example, an implementation might check whether the VM executable 
	 * is present.
	 * </p>
	 * 
	 * @param installLocation the root directory of a potential installation for
	 *   this type of VM
	 * @return a status object describing whether the install location is valid
	 */
	IStatus validateInstallLocation(File installLocation);
	
	/**
	 * Tries to detect an installed VM that matches this VM install type.

	 * at the given <code>installLocation</code>.
	 * The returned <code>LibraryLocation</code>s may not exist if the
	 * <code>installLocation</code> is not a valid install location.
	 * 
	 * @param installLocation home location
	 * directory). For example, the standard VM install type accepts execution
	 * environment description files, as described by
	 * <code>http://wiki.eclipse.org/index.php/Execution_Environment_Descriptions</code>.
	 * </p> 
	 * @param installLocationOrDefinitionFile home directory or since 3.4, a file
	 * 	describing an installation
	 * @see LibraryLocation
	 * @see IVMInstallType#validateInstallLocation(File)
	 * 
	 * @return default library locations based on the given <code>installLocation</code>.
	 * @since 2.0
	 */
	LibraryLocation[] getDefaultLibraryLocations(File installLocation);	
}

Lines 59-64 Link Here

(-)launching/org/eclipse/jdt/launching/JavaRuntime.java (-61 / +112 lines)
59	import org.eclipse.jdt.internal.launching.CompositeId;	59	import org.eclipse.jdt.internal.launching.CompositeId;
60	import org.eclipse.jdt.internal.launching.DefaultEntryResolver;	60	import org.eclipse.jdt.internal.launching.DefaultEntryResolver;
61	import org.eclipse.jdt.internal.launching.DefaultProjectClasspathEntry;	61	import org.eclipse.jdt.internal.launching.DefaultProjectClasspathEntry;
		62	import org.eclipse.jdt.internal.launching.EEVMInstall;
		63	import org.eclipse.jdt.internal.launching.EEVMType;
62	import org.eclipse.jdt.internal.launching.JREContainerInitializer;	64	import org.eclipse.jdt.internal.launching.JREContainerInitializer;
63	import org.eclipse.jdt.internal.launching.JavaSourceLookupUtil;	65	import org.eclipse.jdt.internal.launching.JavaSourceLookupUtil;
64	import org.eclipse.jdt.internal.launching.LaunchingMessages;	66	import org.eclipse.jdt.internal.launching.LaunchingMessages;
Lines 1465-1472 Link Here
1465	}	1467	}
1466	String javadoc = element.getAttribute("javadocURL"); //$NON-NLS-1$	1468	String javadoc = element.getAttribute("javadocURL"); //$NON-NLS-1$
1467	String vmArgs = element.getAttribute("vmArgs"); //$NON-NLS-1$	1469	String vmArgs = element.getAttribute("vmArgs"); //$NON-NLS-1$
1468	VMStandin standin = new VMStandin(installType, id);	1470	VMStandin standin = null;
1469	standin.setName(name);
1470	home = substitute(home);	1471	home = substitute(home);
1471	File homeDir = new File(home);	1472	File homeDir = new File(home);
1472	if (homeDir.exists()) {	1473	if (homeDir.exists()) {
Lines 1477-1543 Link Here
1477	} catch (IOException e) {	1478	} catch (IOException e) {
1478	}	1479	}
1479	}	1480	}
1480	IStatus status = installType.validateInstallLocation(homeDir);	1481	if (EEVMType.ID_EE_VM_TYPE.equals(installType.getId())) {
1481	if (!status.isOK()) {	1482	standin = createVMFromDefinitionFile(homeDir, name, id);
1482	abort(MessageFormat.format("Illegal install location {0} for vmInstall {1} contributed by {2}: {3}", //$NON-NLS-1$	1483	} else {
1483	new String[]{home, id, element.getContributor().getName(), status.getMessage()}), null);	1484	standin = new VMStandin(installType, id);
1484	}	1485	standin.setName(name);
1485	standin.setInstallLocation(homeDir);	1486	IStatus status = installType.validateInstallLocation(homeDir);
1486	if (javadoc != null) {	1487	if (!status.isOK()) {
1487	try {	1488	abort(MessageFormat.format("Illegal install location {0} for vmInstall {1} contributed by {2}: {3}", //$NON-NLS-1$
1488	standin.setJavadocLocation(new URL(javadoc));	1489	new String[]{home, id, element.getContributor().getName(), status.getMessage()}), null);
1489	} catch (MalformedURLException e) {	1490	}
1490	abort(MessageFormat.format("Illegal javadocURL attribute for vmInstall {0} contributed by {1}", //$NON-NLS-1$	1491	standin.setInstallLocation(homeDir);
1491	new String[]{id, element.getContributor().getName()}), e);	1492	if (javadoc != null) {
		1493	try {
		1494	standin.setJavadocLocation(new URL(javadoc));
		1495	} catch (MalformedURLException e) {
		1496	abort(MessageFormat.format("Illegal javadocURL attribute for vmInstall {0} contributed by {1}", //$NON-NLS-1$
		1497	new String[]{id, element.getContributor().getName()}), e);
		1498	}
1492	}	1499	}
1493	}	1500	// allow default arguments to be specified by vm install type if no explicit arguments
1494	// allow default arguments to be specified by vm install type if no explicit arguments	1501	if (vmArgs == null) {
1495	if (vmArgs == null) {	1502	if (installType instanceof AbstractVMInstallType) {
1496	if (installType instanceof AbstractVMInstallType) {	1503	AbstractVMInstallType type = (AbstractVMInstallType) installType;
1497	AbstractVMInstallType type = (AbstractVMInstallType) installType;	1504	vmArgs = type.getDefaultVMArguments(homeDir);
1498	vmArgs = type.getDefaultVMArguments(homeDir);	1505	}
1499	}	1506	}
		1507	if (vmArgs != null) {
		1508	standin.setVMArgs(vmArgs);
		1509	}
		1510	IConfigurationElement[] libraries = element.getChildren("library"); //$NON-NLS-1$
		1511	LibraryLocation[] locations = null;
		1512	if (libraries.length > 0) {
		1513	locations = new LibraryLocation[libraries.length];
		1514	for (int j = 0; j < libraries.length; j++) {
		1515	IConfigurationElement library = libraries[j];
		1516	String libPathStr = library.getAttribute("path"); //$NON-NLS-1$
		1517	if (libPathStr == null) {
		1518	abort(MessageFormat.format("library for vmInstall {0} contributed by {1} missing required attribute libPath", //$NON-NLS-1$
		1519	new String[]{id, element.getContributor().getName()}), null);
		1520	}
		1521	String sourcePathStr = library.getAttribute("sourcePath"); //$NON-NLS-1$
		1522	String packageRootStr = library.getAttribute("packageRootPath"); //$NON-NLS-1$
		1523	String javadocOverride = library.getAttribute("javadocURL"); //$NON-NLS-1$
		1524	URL url = null;
		1525	if (javadocOverride != null) {
		1526	try {
		1527	url = new URL(javadocOverride);
		1528	} catch (MalformedURLException e) {
		1529	abort(MessageFormat.format("Illegal javadocURL attribute specified for library {0} for vmInstall {1} contributed by {2}" //$NON-NLS-1$
		1530	,new String[]{libPathStr, id, element.getContributor().getName()}), e);
		1531	}
		1532	}
		1533	IPath homePath = new Path(home);
		1534	IPath libPath = homePath.append(substitute(libPathStr));
		1535	IPath sourcePath = Path.EMPTY;
		1536	if (sourcePathStr != null) {
		1537	sourcePath = homePath.append(substitute(sourcePathStr));
		1538	}
		1539	IPath packageRootPath = Path.EMPTY;
		1540	if (packageRootStr != null) {
		1541	packageRootPath = new Path(substitute(packageRootStr));
		1542	}
		1543	locations[j] = new LibraryLocation(libPath, sourcePath, packageRootPath, url);
		1544	}
		1545	}
		1546	standin.setLibraryLocations(locations);
1500	}	1547	}
1501	if (vmArgs != null) {
1502	standin.setVMArgs(vmArgs);
1503	}
1504	IConfigurationElement[] libraries = element.getChildren("library"); //$NON-NLS-1$
1505	LibraryLocation[] locations = null;
1506	if (libraries.length > 0) {
1507	locations = new LibraryLocation[libraries.length];
1508	for (int j = 0; j < libraries.length; j++) {
1509	IConfigurationElement library = libraries[j];
1510	String libPathStr = library.getAttribute("path"); //$NON-NLS-1$
1511	if (libPathStr == null) {
1512	abort(MessageFormat.format("library for vmInstall {0} contributed by {1} missing required attribute libPath", //$NON-NLS-1$
1513	new String[]{id, element.getContributor().getName()}), null);
1514	}
1515	String sourcePathStr = library.getAttribute("sourcePath"); //$NON-NLS-1$
1516	String packageRootStr = library.getAttribute("packageRootPath"); //$NON-NLS-1$
1517	String javadocOverride = library.getAttribute("javadocURL"); //$NON-NLS-1$
1518	URL url = null;
1519	if (javadocOverride != null) {
1520	try {
1521	url = new URL(javadocOverride);
1522	} catch (MalformedURLException e) {
1523	abort(MessageFormat.format("Illegal javadocURL attribute specified for library {0} for vmInstall {1} contributed by {2}" //$NON-NLS-1$
1524	,new String[]{libPathStr, id, element.getContributor().getName()}), e);
1525	}
1526	}
1527	IPath homePath = new Path(home);
1528	IPath libPath = homePath.append(substitute(libPathStr));
1529	IPath sourcePath = Path.EMPTY;
1530	if (sourcePathStr != null) {
1531	sourcePath = homePath.append(substitute(sourcePathStr));
1532	}
1533	IPath packageRootPath = Path.EMPTY;
1534	if (packageRootStr != null) {
1535	packageRootPath = new Path(substitute(packageRootStr));
1536	}
1537	locations[j] = new LibraryLocation(libPath, sourcePath, packageRootPath, url);
1538	}
1539	}
1540	standin.setLibraryLocations(locations);
1541	// in case the contributed JRE attributes changed, remove it first, then add	1548	// in case the contributed JRE attributes changed, remove it first, then add
1542	vmDefs.removeVM(standin);	1549	vmDefs.removeVM(standin);
1543	vmDefs.addVM(standin);	1550	vmDefs.addVM(standin);
Lines 1592-1598 Link Here
1592	LibraryLocation[] locations= vm.getLibraryLocations();	1599	LibraryLocation[] locations= vm.getLibraryLocations();
1593	if (locations == null) {	1600	if (locations == null) {
1594	URL defJavaDocLocation = vm.getJavadocLocation();	1601	URL defJavaDocLocation = vm.getJavadocLocation();
1595	LibraryLocation[] dflts= vm.getVMInstallType().getDefaultLibraryLocations(vm.getInstallLocation());	1602	File installLocation = vm.getInstallLocation();
		1603	if (installLocation == null) {
		1604	return new LibraryLocation[0];
		1605	}
		1606	LibraryLocation[] dflts= vm.getVMInstallType().getDefaultLibraryLocations(installLocation);
1596	libraryPaths = new IPath[dflts.length];	1607	libraryPaths = new IPath[dflts.length];
1597	sourcePaths = new IPath[dflts.length];	1608	sourcePaths = new IPath[dflts.length];
1598	sourceRootPaths = new IPath[dflts.length];	1609	sourceRootPaths = new IPath[dflts.length];
Lines 2654-2658 Link Here
2654	}	2665	}
2655	}	2666	}
2656	}	2667	}
		2668
		2669	/**
		2670	* Creates a new VM based on the attributes specified in the given execution
		2671	* environment description file. The format of the file is defined by
		2672	* <code>http://wiki.eclipse.org/index.php/Execution_Environment_Descriptions</code>.
		2673	*
		2674	* @param eeFile VM definition file
		2675	* @param name name for the VM
		2676	* @param id id to assign to the new VM
		2677	* @return VM standin
		2678	* @exception CoreException if unable to create a VM from the given definition file
		2679	* @since 3.4
		2680	*/
		2681	public static VMStandin createVMFromDefinitionFile(File eeFile, String name, String id) throws CoreException {
		2682	IStatus status = EEVMType.validateDefinitionFile(eeFile);
		2683	if (status.isOK()) {
		2684	VMStandin standin = new VMStandin(getVMInstallType(EEVMType.ID_EE_VM_TYPE), id);
		2685	standin.setName(name);
		2686	String home = EEVMType.getProperty(EEVMType.PROP_JAVA_HOME, eeFile);
		2687	standin.setInstallLocation(new File(home));
		2688	standin.setLibraryLocations(EEVMType.getLibraryLocations(eeFile));
		2689	standin.setVMArgs(EEVMType.getVMArguments(eeFile));
		2690	standin.setJavadocLocation(EEVMType.getJavadocLocation(eeFile));
		2691	standin.setAttribute(EEVMInstall.ATTR_EXECUTION_ENVIRONMENT_ID, EEVMType.getProperty(EEVMType.PROP_CLASS_LIB_LEVEL, eeFile));
		2692	File exe = EEVMType.getExecutable(eeFile);
		2693	if (exe != null) {
		2694	try {
		2695	standin.setAttribute(EEVMInstall.ATTR_JAVA_EXE, exe.getCanonicalPath());
		2696	} catch (IOException e) {
		2697	throw new CoreException(new Status(IStatus.ERROR, LaunchingPlugin.getUniqueIdentifier(),
		2698	LaunchingMessages.JavaRuntime_24, e));
		2699	}
		2700	}
		2701	standin.setAttribute(EEVMInstall.ATTR_JAVA_VERSION, EEVMType.getJavaVersion(eeFile));
		2702	standin.setAttribute(EEVMInstall.ATTR_DEFINITION_FILE, eeFile.getPath());
		2703	return standin;
		2704	} else {
		2705	throw new CoreException(status);
		2706	}
		2707	}
2657		2708
2658	}	2709	}




	 * implementation returns <code>null</code>, subclasses must override as
	 * appropriate.
	 * <p>
	 * Since 3.4, the argument may also be a file describing a VM install.
	 * For example, the standard VM installs support execution
	 * environment description files, as described by
	 * <code>http://wiki.eclipse.org/index.php/Execution_Environment_Descriptions</code>.
	 * </p>
	 * <p>
	 * Note, this method would ideally be added to <code>IVMInstallType</code>,
	 * but it would have been a breaking API change between 2.0 and 2.1. Thus,
	 * it has been added to the abstract base class that VM install types should
	 * subclass.
	 * </p>
	 * 
	 * @param installLocationOrDefinitionFile home location
	 * @return default javadoc location or <code>null</code>
	 * @since 2.1
	 */
	public URL getDefaultJavadocLocation(File installLocation) {
		return null;		
	}
	
	/**
	 * Returns a string of default VM arguments for a VM installed at the
	 * given home location, or <code>null</code> if none.
	 * The default implementation returns <code>null</code>, subclasses must override
	 * as appropriate.
	 * <p>

	 * it has been added to the abstract base class that VM install types should
	 * subclass.
	 * </p>
	 * @param installLocation home location
	 * @return default VM arguments or <code>null</code> if none
	 * @since 3.4
	 */
	public String getDefaultVMArguments(File installLocation) {
		return null;
	}
}

Lines 10-15 Link Here

(-)launching/org/eclipse/jdt/launching/VMStandin.java (-1 / +20 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.jdt.launching;	11	package org.eclipse.jdt.launching;
12		12
		13	import java.util.Iterator;
		14	import java.util.Map;
		15	import java.util.Map.Entry;
		16
13		17
14		18
15	/**	19	/**
Lines 93-98 Link Here
93	setVMArguments(realVM.getVMArguments());	97	setVMArguments(realVM.getVMArguments());
94	fJavaVersion = null;	98	fJavaVersion = null;
95	}	99	}
		100	if (realVM instanceof AbstractVMInstall) {
		101	AbstractVMInstall vm2 = (AbstractVMInstall) realVM;
		102	Map attributes = vm2.getAttributes();
		103	Iterator iterator = attributes.entrySet().iterator();
		104	while (iterator.hasNext()) {
		105	Entry entry = (Entry) iterator.next();
		106	setAttribute((String)entry.getKey(), (String)entry.getValue());
		107	}
		108	}
96	}	109	}
97		110
98	/**	111	/**
Lines 126-132 Link Here
126	}	139	}
127		140
128	if (realVM instanceof AbstractVMInstall) {	141	if (realVM instanceof AbstractVMInstall) {
129	((AbstractVMInstall)realVM).setNotify(true);	142	AbstractVMInstall avm = (AbstractVMInstall) realVM;
		143	Iterator iterator = getAttributes().entrySet().iterator();
		144	while (iterator.hasNext()) {
		145	Entry entry = (Entry) iterator.next();
		146	avm.setAttribute((String)entry.getKey(), (String)entry.getValue());
		147	}
		148	avm.setNotify(true);
130	}	149	}
131	if (!notify) {	150	if (!notify) {
132	JavaRuntime.fireVMAdded(realVM);	151	JavaRuntime.fireVMAdded(realVM);

Lines 18-23 Link Here

(-)launching/org/eclipse/jdt/internal/launching/environments/ExecutionEnvironmentAnalyzer.java (-2 / +3 lines)
18		18
19	import org.eclipse.core.runtime.CoreException;	19	import org.eclipse.core.runtime.CoreException;
20	import org.eclipse.core.runtime.IProgressMonitor;	20	import org.eclipse.core.runtime.IProgressMonitor;
		21	import org.eclipse.jdt.internal.launching.EEVMInstall;
21	import org.eclipse.jdt.internal.launching.EEVMType;	22	import org.eclipse.jdt.internal.launching.EEVMType;
22	import org.eclipse.jdt.launching.IVMInstall;	23	import org.eclipse.jdt.launching.IVMInstall;
23	import org.eclipse.jdt.launching.IVMInstall2;	24	import org.eclipse.jdt.launching.IVMInstall2;
Lines 72-79 Link Here
72	return new CompatibleEnvironment[0];	73	return new CompatibleEnvironment[0];
73	IVMInstall2 vm2 = (IVMInstall2) vm;	74	IVMInstall2 vm2 = (IVMInstall2) vm;
74	List types = null;	75	List types = null;
75	if (EEVMType.isEEInstall(vm.getInstallLocation())) {	76	if (EEVMType.ID_EE_VM_TYPE.equals(vm.getVMInstallType().getId())) {
76	String eeId = EEVMType.getProperty(EEVMType.PROP_CLASS_LIB_LEVEL, vm.getInstallLocation());	77	String eeId = ((EEVMInstall)vm).getAttribute(EEVMInstall.ATTR_EXECUTION_ENVIRONMENT_ID);
77	if (eeId != null) {	78	if (eeId != null) {
78	types = getTypes(eeId);	79	types = getTypes(eeId);
79	}	80	}

Lines 23-28 Link Here

(-)plugin.xml (+4 lines)
23	class="org.eclipse.jdt.internal.launching.Standard11xVMType"	23	class="org.eclipse.jdt.internal.launching.Standard11xVMType"
24	id="org.eclipse.jdt.launching.Standard11xVMType">	24	id="org.eclipse.jdt.launching.Standard11xVMType">
25	</vmInstallType>	25	</vmInstallType>
		26	<vmInstallType
		27	class="org.eclipse.jdt.internal.launching.EEVMType"
		28	id="org.eclipse.jdt.launching.EEVMType">
		29	</vmInstallType>
26	</extension>	30	</extension>
27	<extension	31	<extension
28	point="org.eclipse.debug.core.launchConfigurationTypes">	32	point="org.eclipse.debug.core.launchConfigurationTypes">




      </complexType>
   </element>


   <annotation>
      <appInfo>
         <meta.section type="examples"/>

      </documentation>
   </annotation>


   <annotation>
      <appInfo>
         <meta.section type="implementation"/>
      </appInfo>
      <documentation>
         Abstract implementations of IVMInstall and IVMInstallType are provided.  The Java Development Tools Launching Support plug-in defines a VM
install type for the standard 1.1.* level JRE, and an install type for JREs conforming to standard command line options (1.2, 1.3, 1.4, 5.0, 6.0, and 7.0 level JREs). As well an install type is provided for JREs defined by an &lt;a href=&quot; http://wiki.eclipse.org/index.php/Execution_Environment_Descriptions&quot;&gt;execution environment description&lt;/a&gt; file.
      </documentation>
   </annotation>





         <attribute name="home" type="string" use="required">
            <annotation>
               <documentation>
                  Path to the home installation directory for this VM install. Paths must be absolute and may use string substitution variables such as ${eclipse_home}. Since 3.4, this attribute may reference a VM definition file in addition to a home directory. The Execution Environment VM type included with the SDK supports &lt;a href=&quot; http://wiki.eclipse.org/index.php/Execution_Environment_Descriptions&quot;&gt;execution environment descriptions&lt;/a&gt;. When an execution environment description file is specified, any library elements are ignored. In this case, libraries are defined by the execution environment description file.
               </documentation>
            </annotation>
         </attribute>

&lt;/extension&gt; 
&lt;/pre&gt;
&lt;/p&gt;
&lt;p&gt;
The following example will create a JRE definition based on the contents of the specified execution environment description file. When an execution environment description file is provided as the home location the &quot;Execution Environment Description&quot; VM type must be specified for the &lt;code&gt;vmInstallType&lt;/code&gt; attribute.
&lt;/p&gt;
&lt;p&gt;
&lt;pre&gt;
&lt;extension point=&quot;org.eclipse.jdt.launching.vmInstalls&quot;&gt;
 &lt;vmInstall
  home=&quot;${eclipse_home}/jre-def.ee&quot;
  id=&quot;com.example.ee.id&quot;
  name=&quot;Default JRE&quot;
  vmInstallType=&quot;org.eclipse.jdt.launching.EEVMType&quot;/&gt;
&lt;/extension&gt; 
&lt;/pre&gt;
&lt;/p&gt;
      </documentation>
   </annotation>





/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.launching;

import java.io.File;

import org.eclipse.jdt.launching.IVMInstallType;

/**
 * A VM install created from an execution environment description file.
 * 
 * @since 3.4
 */
public class EEVMInstall extends StandardVM {
	
	/**
	 * Attribute key for Java version property
	 */
	public static final String ATTR_JAVA_VERSION = "ATTR_JAVA_VERSION"; //$NON-NLS-1$
	
	/**
	 * Attribute key for supported execution environment by this runtime
	 */
	public static final String ATTR_EXECUTION_ENVIRONMENT_ID = "ATTR_EXECUTION_ENVIRONMENT_ID"; //$NON-NLS-1$
	
	/**
	 * Attribute key for Java executable used by this VM
	 */
	public static final String ATTR_JAVA_EXE = "ATTR_JAVA_EXE"; //$NON-NLS-1$

	/**
	 * Path to file used to define the JRE
	 */
	public static final String ATTR_DEFINITION_FILE = "ATTR_DEFINITION_FILE"; //$NON-NLS-1$
	
	/**
	 * Constructs a VM install.
	 * 
	 * @param type vm type
	 * @param id unique id
	 */
	EEVMInstall(IVMInstallType type, String id) {
		super(type, id);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.internal.launching.StandardVM#getJavaVersion()
	 */
	public String getJavaVersion() {
    	return getAttribute(ATTR_JAVA_VERSION);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.internal.launching.StandardVM#getJavaExecutable()
	 */
	File getJavaExecutable() {
		String exe = getAttribute(ATTR_JAVA_EXE);
		if (exe != null) {
			return new File(exe);
		}
		return null;
	}
	
	

}





<h3>Support for Execution Environment Descriptions</h3>
<p>An installed JRE can be defined by an <a href="http://wiki.eclipse.org/index.php/Execution_Environment_Descriptions">execution 
  environment description file</a>. A new 'Execution Environment Description' 
  VM install type shipped with the Eclipse SDK supports standard &quot;.ee&quot; 
  files.</p>
<p>API has been added to <code>JavaRuntime</code> to create a VM from an execution 
  environment description file. A name and unique identifier must be provided 
  to create a new JRE.</p>
<ul>
  <li><code>public VMStandin createVMFromDefinitionFile(File eeFile, String name, 
    String id)</code></li>
</ul>
<p>This change effects the following methods in <code>IVMInstall</code>, which 
  can now accept/return a file as well as home directory.</p>
<ul>
  <li><code>public File getInstallLocation()</code></li>
  <li><code>public void setInstallLocation(File installLocation)</code></li>
</ul>
<p>A new method has been added to <code>AbstractVMInstallType</code> to allow 
  default arguments to be provided for newly created VM installs. Ideally, this 

<ul>
  <li><code>public String getDefaultVMArguments(File installLocation)</code></li>
</ul>
<h3>Support for custom wizard pages used to edit VM installs</h3>
<p>An new extension point (<code>org.eclipse.jdt.debug.ui.vmInstallPages</code>) 
  allows a wizard page to be contributed for editing the properties of an <code>IVMInstall</code>. 
  The page is used when adding or editing an installed JRE via user preference. 
  A standard page is provided based on the <code>IVMInstallType</code> and <code>IVMInstall</code> 
  interfaces. JDT contributes a page for editing a JRE based on an execution environment 
  description file.</p>
<h3>Support for setting a range of values in array objects</h3>
<p>API has been added to <code>IJavaArray</code> to support setting ranges of 
  values in the arrays. It is more efficient to set a range of values at once 

Lines 142-148 Link Here

(-)ui/org/eclipse/jdt/internal/debug/ui/jres/LibraryContentProvider.java (-1 / +3 lines)
142	for (int i = 0; i < libs.length; i++) {	142	for (int i = 0; i < libs.length; i++) {
143	fLibraries[i] = new LibraryStandin(libs[i]);	143	fLibraries[i] = new LibraryStandin(libs[i]);
144	}	144	}
145	fViewer.refresh();	145	if (fViewer != null) {
		146	fViewer.refresh();
		147	}
146	}	148	}
147		149
148	/**	150	/**

Lines 15-20 Link Here

(-)ui/org/eclipse/jdt/internal/debug/ui/jres/JREMessages.properties (-5 / +21 lines)
15	AbstractJavaCommandTab_4=&Alternate	15	AbstractJavaCommandTab_4=&Alternate
16	AbstractJavaCommandTab_Java_executable_must_be_specified_5=Java executable must be specified	16	AbstractJavaCommandTab_Java_executable_must_be_specified_5=Java executable must be specified
17		17
		18	AddVMInstallWizard_0=Add JRE
18	BuildJREDescriptor_0=Workspace &default JRE ({0})	19	BuildJREDescriptor_0=Workspace &default JRE ({0})
19		20
20	InstalledJREsBlock_0=Name	21	InstalledJREsBlock_0=Name
Lines 46-51 Link Here
46	JREsComboBlock_0=No JREs defined in workspace	47	JREsComboBlock_0=No JREs defined in workspace
47	JREsComboBlock_4=E&xecution Environment:	48	JREsComboBlock_4=E&xecution Environment:
48	JREsComboBlock_5=No execution environments defined in workspace	49	JREsComboBlock_5=No execution environments defined in workspace
		50	StandardVMPage_0=Add Standard VM
		51	StandardVMPage_1=JRE Definition
		52	StandardVMPage_2=Specify attributes for a JRE
49	JREContainerWizardPage_JRE_System_Library_1=JRE System Library	53	JREContainerWizardPage_JRE_System_Library_1=JRE System Library
50	JREContainerWizardPage_4=Select JRE for the project build path.	54	JREContainerWizardPage_4=Select JRE for the project build path.
51	JREContainerWizardPage_3=System library	55	JREContainerWizardPage_3=System library
Lines 58-74 Link Here
58	JREsPreferencePage_14=Conflicting compliance settings can be changed on the <a>Compiler</a> page.	62	JREsPreferencePage_14=Conflicting compliance settings can be changed on the <a>Compiler</a> page.
59		63
60	addVMDialog_duplicateName=The JRE name is already in use.	64	addVMDialog_duplicateName=The JRE name is already in use.
61	addVMDialog_enterLocation=Enter the location of the JRE.	65	addVMDialog_enterLocation=Enter the home directory of the JRE.
62	addVMDialog_enterName=Enter a name for the JRE.	66	addVMDialog_enterName=Enter a name for the JRE.
63	addVMDialog_jreHome=&JRE location:	67	EditVMInstallWizard_0=Edit JRE
		68	addVMDialog_jreHome=&JRE home:
64	addVMDialog_jreName=JRE &name:	69	addVMDialog_jreName=JRE &name:
65	addVMDialog_jreType=JRE &type:	70	addVMDialog_jreType=JRE &type:
66	addVMDialog_locationNotExists=The location does not exist.	71	addVMDialog_locationNotExists=The home directory does not exist.
67	addVMDialog_pickJRERootDialog_message=Select the root directory of the JRE installation:	72	addVMDialog_pickJRERootDialog_message=Select the root directory of the JRE installation:
68	AddVMDialog_JRE_system_libraries__1=JRE system libraries:	73	AddVMDialog_JRE_system_libraries__1=JRE system libraries:
69	AddVMDialog_JRE_name_must_be_a_valid_file_name___0__1=JRE name must be a valid file name: {0}	74	AddVMDialog_JRE_name_must_be_a_valid_file_name___0__1=JRE name must be a valid file name: {0}
70	AddVMDialog_21=Definition &File...	75	AddVMDialog_21=Definition &File...
71	AddVMDialog_22=H&ome Directory...	76	AddVMDialog_22=Direct&ory...
72	AddVMDialog_23=Default &VM Arguments:	77	AddVMDialog_23=Default &VM Arguments:
73		78
74	JREsUpdater_0=Save VM Definitions	79	JREsUpdater_0=Save VM Definitions
Lines 76-82 Link Here
76	VMLibraryBlock_1=(none)	81	VMLibraryBlock_1=(none)
77	VMLibraryBlock_10=Jar Selection	82	VMLibraryBlock_10=Jar Selection
78	VMDetailsDialog_0=JRE Details	83	VMDetailsDialog_0=JRE Details
79	VMLibraryBlock_2=Javadoc location:	84	VMLibraryBlock_2=JRE System Libraries
80	VMLibraryBlock_11=Source &Attachment...	85	VMLibraryBlock_11=Source &Attachment...
81	VMLibraryBlock_16=Select to add an external JAR to the list	86	VMLibraryBlock_16=Select to add an external JAR to the list
82	VMLibraryBlock_17=Select to add a JavaDoc location to the selected library	87	VMLibraryBlock_17=Select to add a JavaDoc location to the selected library
Lines 101-103 Link Here
101	MacVMSearch_0=Searching for installed JREs	106	MacVMSearch_0=Searching for installed JREs
102	MacVMSearch_1=JVM {0} (MacOS X Default)	107	MacVMSearch_1=JVM {0} (MacOS X Default)
103	MacVMSearch_2=JVM {0}	108	MacVMSearch_2=JVM {0}
		109	EEVMPage_0=Add EE VM
		110	EEVMPage_1=&Definition File:
		111	EEVMPage_2=F&ile...
		112	EEVMPage_4=Enter definition file
		113	EEVMPage_5=Definition file does not exist
		114	EEVMPage_6=JRE Definition
		115	EEVMPage_7=Specify attributes for a JRE
		116	VMTypePage_0=Select JRE Type
		117	VMTypePage_1=Select the type of JRE to add to the workspace.
		118	VMTypePage_2=JRE Type
		119	VMTypePage_3=Installed JRE &Types:

Lines 25-30 Link Here

(-)ui/org/eclipse/jdt/internal/debug/ui/jres/JREMessages.java (+33 lines)
25		25
26	public static String AddVMDialog_22;	26	public static String AddVMDialog_22;
27		27
		28	public static String AddVMInstallWizard_0;
		29
28	public static String BuildJREDescriptor_0;	30	public static String BuildJREDescriptor_0;
29		31
30	public static String InstalledJREsBlock_0;	32	public static String InstalledJREsBlock_0;
Lines 70-75 Link Here
70	public static String addVMDialog_duplicateName;	72	public static String addVMDialog_duplicateName;
71	public static String addVMDialog_enterLocation;	73	public static String addVMDialog_enterLocation;
72	public static String addVMDialog_enterName;	74	public static String addVMDialog_enterName;
		75
		76	public static String EditVMInstallWizard_0;
73	public static String addVMDialog_jreHome;	77	public static String addVMDialog_jreHome;
74	public static String addVMDialog_jreName;	78	public static String addVMDialog_jreName;
75	public static String addVMDialog_jreType;	79	public static String addVMDialog_jreType;
Lines 100-107 Link Here
100	public static String VMLibraryBlock_18;	104	public static String VMLibraryBlock_18;
101		105
102	public static String JREsUpdater_0;	106	public static String JREsUpdater_0;
		107
		108	public static String EEVMPage_0;
		109
		110	public static String EEVMPage_1;
		111
		112	public static String EEVMPage_2;
		113
		114	public static String EEVMPage_4;
		115
		116	public static String EEVMPage_5;
		117
		118	public static String EEVMPage_6;
		119
		120	public static String EEVMPage_7;
		121
		122	public static String VMTypePage_0;
		123
		124	public static String VMTypePage_1;
		125
		126	public static String VMTypePage_2;
		127
		128	public static String VMTypePage_3;
103	public static String VMLibraryBlock_0;	129	public static String VMLibraryBlock_0;
104	public static String VMLibraryBlock_1;	130	public static String VMLibraryBlock_1;
		131
105	public static String VMLibraryBlock_2;	132	public static String VMLibraryBlock_2;
106	public static String VMLibraryBlock_3;	133	public static String VMLibraryBlock_3;
107	public static String VMLibraryBlock_4;	134	public static String VMLibraryBlock_4;
Lines 123-128 Link Here
123		150
124	public static String JREsComboBlock_5;	151	public static String JREsComboBlock_5;
125		152
		153	public static String StandardVMPage_0;
		154
		155	public static String StandardVMPage_1;
		156
		157	public static String StandardVMPage_2;
		158
126	public static String JREProfilesPreferencePage_0;	159	public static String JREProfilesPreferencePage_0;
127		160
128	public static String JREProfilesPreferencePage_1;	161	public static String JREProfilesPreferencePage_1;

Lines 56-61 Link Here

(-)ui/org/eclipse/jdt/internal/debug/ui/jres/InstalledJREsBlock.java (-20 / +42 lines)
56	import org.eclipse.jface.viewers.Viewer;	56	import org.eclipse.jface.viewers.Viewer;
57	import org.eclipse.jface.viewers.ViewerComparator;	57	import org.eclipse.jface.viewers.ViewerComparator;
58	import org.eclipse.jface.window.Window;	58	import org.eclipse.jface.window.Window;
		59	import org.eclipse.jface.wizard.WizardDialog;
59	import org.eclipse.swt.SWT;	60	import org.eclipse.swt.SWT;
60	import org.eclipse.swt.events.KeyAdapter;	61	import org.eclipse.swt.events.KeyAdapter;
61	import org.eclipse.swt.events.KeyEvent;	62	import org.eclipse.swt.events.KeyEvent;
Lines 129-134 Link Here
129	// happen very quickly	130	// happen very quickly
130	private static String fgLastUsedID;	131	private static String fgLastUsedID;
131		132
		133	/**
		134	* VM install type id for OSX VMs
		135	*/
		136	public static final String MACOSX_VM_TYPE_ID = "org.eclipse.jdt.internal.launching.macosx.MacOSXType"; //$NON-NLS-1$
		137
132	/**	138	/**
133	* Content provider to show a list of JREs	139	* Content provider to show a list of JREs
134	*/	140	*/
Lines 357-373 Link Here
357	ArrayList newEntries = new ArrayList();	363	ArrayList newEntries = new ArrayList();
358	while (it.hasNext()) {	364	while (it.hasNext()) {
359	IVMInstall selectedVM = (IVMInstall) it.next();	365	IVMInstall selectedVM = (IVMInstall) it.next();
360
361	// duplicate & add vm	366	// duplicate & add vm
362	VMStandin standin = new VMStandin(selectedVM, createUniqueId(selectedVM.getVMInstallType()));	367	VMStandin standin = new VMStandin(selectedVM, createUniqueId(selectedVM.getVMInstallType()));
363	standin.setName(generateName(selectedVM.getName()));	368	standin.setName(generateName(selectedVM.getName()));
364	AddVMDialog dialog = new AddVMDialog(this, getShell(), JavaRuntime.getVMInstallTypes(), standin);	369	EditVMInstallWizard wizard = new EditVMInstallWizard(standin, (IVMInstall[]) fVMs.toArray(new IVMInstall[fVMs.size()]));
365	dialog.setTitle(JREMessages.InstalledJREsBlock_18);	370	WizardDialog dialog = new WizardDialog(getShell(), wizard);
366	if (dialog.open() != Window.OK) {	371	if (dialog.open() == Window.OK) {
367	return;	372	VMStandin result = wizard.getResult();
368	}	373	if (result != null) {
369	newEntries.add(standin);	374	// add the new VM
370	fVMs.add(standin);	375	fVMs.add(result);
		376	fVMList.refresh();
		377	fVMList.setSelection(new StructuredSelection(result));
		378	}
		379	}
371	}	380	}
372	fVMList.refresh();	381	fVMList.refresh();
373	fVMList.setSelection(new StructuredSelection(newEntries.toArray()));	382	fVMList.setSelection(new StructuredSelection(newEntries.toArray()));
Lines 543-557 Link Here
543	}	552	}
544		553
545	/**	554	/**
546	* Bring up a dialog that lets the user create a new VM definition.	555	* Bring up a wizard that lets the user create a new VM definition.
547	*/	556	*/
548	private void addVM() {	557	private void addVM() {
549	AddVMDialog dialog= new AddVMDialog(this, getShell(), JavaRuntime.getVMInstallTypes(), null);	558	AddVMInstallWizard wizard = new AddVMInstallWizard((IVMInstall[]) fVMs.toArray(new IVMInstall[fVMs.size()]));
550	dialog.setTitle(JREMessages.InstalledJREsBlock_7);	559	WizardDialog dialog = new WizardDialog(getShell(), wizard);
551	if (dialog.open() != Window.OK) {	560	if (dialog.open() == Window.OK) {
552	return;	561	VMStandin result = wizard.getResult();
		562	if (result != null) {
		563	fVMs.add(result);
		564	fVMList.refresh();
		565	fVMList.setSelection(new StructuredSelection(result));
		566	}
553	}	567	}
554	fVMList.refresh();
555	}	568	}
556		569
557	/**	570	/**
Lines 580-586 Link Here
580	*/	593	*/
581	private void editVM() {	594	private void editVM() {
582	IStructuredSelection selection= (IStructuredSelection)fVMList.getSelection();	595	IStructuredSelection selection= (IStructuredSelection)fVMList.getSelection();
583	IVMInstall vm= (IVMInstall)selection.getFirstElement();	596	VMStandin vm= (VMStandin)selection.getFirstElement();
584	if (vm == null) {	597	if (vm == null) {
585	return;	598	return;
586	}	599	}
Lines 588-600 Link Here
588	VMDetailsDialog dialog= new VMDetailsDialog(getShell(), vm);	601	VMDetailsDialog dialog= new VMDetailsDialog(getShell(), vm);
589	dialog.open();	602	dialog.open();
590	} else {	603	} else {
591	AddVMDialog dialog= new AddVMDialog(this, getShell(), JavaRuntime.getVMInstallTypes(), vm);	604	EditVMInstallWizard wizard = new EditVMInstallWizard(vm, (IVMInstall[]) fVMs.toArray(new IVMInstall[fVMs.size()]));
592	dialog.setTitle(JREMessages.InstalledJREsBlock_8);	605	WizardDialog dialog = new WizardDialog(getShell(), wizard);
593	if (dialog.open() != Window.OK) {	606	if (dialog.open() == Window.OK) {
594	return;	607	VMStandin result = wizard.getResult();
		608	if (result != null) {
		609	// replace with the edited VM
		610	int index = fVMs.indexOf(vm);
		611	fVMs.remove(index);
		612	fVMs.add(index, result);
		613	fVMList.refresh();
		614	fVMList.setSelection(new StructuredSelection(result));
		615	}
595	}	616	}
596	fVMList.refresh(vm);
597	}	617	}
		618
		619
598	}	620	}
599		621
600	/**	622	/**

Lines 91-97 Link Here

(-)ui/org/eclipse/jdt/internal/debug/ui/jres/MacVMSearch.java (-1 / +1 lines)
91	IVMInstallType[] types = JavaRuntime.getVMInstallTypes();	91	IVMInstallType[] types = JavaRuntime.getVMInstallTypes();
92	for (int i = 0; i < types.length; i++) {	92	for (int i = 0; i < types.length; i++) {
93	IVMInstallType installType = types[i];	93	IVMInstallType installType = types[i];
94	if (installType.getId().equals(AddVMDialog.MACOSX_VM_TYPE_ID)) {	94	if (installType.getId().equals(InstalledJREsBlock.MACOSX_VM_TYPE_ID)) {
95	return installType;	95	return installType;
96	}	96	}
97	}	97	}




/*******************************************************************************
 * Copyright (c) 2000, 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.debug.ui.jres;


import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.Arrays;
import java.util.Comparator;

import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.jdt.internal.debug.ui.IJavaDebugHelpContextIds;
import org.eclipse.jdt.internal.debug.ui.JDIDebugUIPlugin;
import org.eclipse.jdt.internal.debug.ui.SWTFactory;
import org.eclipse.jdt.internal.debug.ui.StatusInfo;
import org.eclipse.jdt.internal.launching.StandardVMType;
import org.eclipse.jdt.launching.AbstractVMInstallType;
import org.eclipse.jdt.launching.IVMInstall;
import org.eclipse.jdt.launching.IVMInstall2;
import org.eclipse.jdt.launching.IVMInstallType;
import org.eclipse.jdt.launching.VMStandin;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.dialogs.StatusDialog;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.DirectoryDialog;
import org.eclipse.swt.widgets.FileDialog;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.PlatformUI;

import com.ibm.icu.text.MessageFormat;

/**
 * Provides the Add VM dialog
 */
public class AddVMDialog extends StatusDialog {
	
	/**
	 * VM install type id for OSX VMs
	 */
	public static final String MACOSX_VM_TYPE_ID = "org.eclipse.jdt.internal.launching.macosx.MacOSXType"; //$NON-NLS-1$
	
	private IAddVMDialogRequestor fRequestor;
	private IVMInstall fEditedVM;
	private IVMInstallType[] fVMTypes;
	private IVMInstallType fSelectedVMType;
	private Combo fVMCombo;
	private Text fVMName;
	private Text fVMArgs;
	private Text fJRERoot;
	private Button fFileButton;
	private VMLibraryBlock fLibraryBlock;
// the VM install's javadoc location
	private URL fJavadocLocation = null;
	private boolean fAutoDetectAttributes = false;
	private IStatus[] fStatus;
	private int fPrevIndex = -1;
		
	/**
	 * Constructor
	 * @param requestor dialog validation requester
	 * @param shell the parent shell 
	 * @param vmInstallTypes the types of VM installs
	 * @param editedVM the editedVM
	 */
	public AddVMDialog(IAddVMDialogRequestor requestor, Shell shell, IVMInstallType[] vmInstallTypes, IVMInstall editedVM) {
		super(shell);
		setShellStyle(getShellStyle() | SWT.RESIZE);
		fRequestor = requestor;
		fStatus = new IStatus[5];
		for (int i= 0; i < fStatus.length; i++) {
			fStatus[i] = new StatusInfo();
		}
		fVMTypes = vmInstallTypes;
		sortVMTypes();
		int typeIndex = 0;
		if (Platform.OS_MACOSX.equals(Platform.getOS())) {
			// select OSX VM type by default
			for (int i = 0; i < fVMTypes.length; i++) {
				IVMInstallType type = fVMTypes[i];
				if (type.getId().equals(MACOSX_VM_TYPE_ID)) {
					typeIndex = i;
					break;
				}
			}
		}
		fSelectedVMType = editedVM != null ? editedVM.getVMInstallType() : vmInstallTypes[typeIndex];
		fEditedVM = editedVM;
	//only detect the javadoc location if not already set
		fAutoDetectAttributes = fEditedVM == null || fEditedVM.getJavadocLocation() == null;
	}

	/**
	 * This method is used to sort the array of VM install types, placing 
	 * the 'Standard VM' type first, if it exists
	 * 
	 * @since 3.3.0
	 */
	private void sortVMTypes() {
		Comparator compare = new Comparator() {
			public int compare(Object o1, Object o2) {
				if(o1 instanceof IVMInstallType && o2 instanceof IVMInstallType) {
					return ((IVMInstallType) o1).getName().compareTo(((IVMInstallType) o2).getName());
				}
				return 0;
			}
		};
		//first find the 'Standard VM' and set it at position 0
		for(int i = 0; i < fVMTypes.length; i++) {
			if(fVMTypes[i].getId().equals("org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType")) { //$NON-NLS-1$
				if(i > 0) {
					IVMInstallType tmp = fVMTypes[0];
					fVMTypes[0] = fVMTypes[i];
					fVMTypes[i] = tmp;
					break;
				}
				else {
					break;
				}
			}
		}
		if(fVMTypes[0].getId().equals("org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType")) { //$NON-NLS-1$
			Arrays.sort(fVMTypes, 1, fVMTypes.length, compare);
		}
		else {
			Arrays.sort(fVMTypes, compare);
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.dialogs.StatusDialog#configureShell(org.eclipse.swt.widgets.Shell)
	 */
	protected void configureShell(Shell newShell) {
		super.configureShell(newShell);
		PlatformUI.getWorkbench().getHelpSystem().setHelp(newShell, IJavaDebugHelpContextIds.EDIT_JRE_DIALOG);
	}		
	
	/**
	 * Returns the VM name from the text control
	 * @return
	 */
	protected String getVMName() {
		return fVMName.getText();
	}
		
	/**
	 * Returns the installation location as a file from the JRE root text control
	 * @return the installation location as a file
	 */
	protected File getInstallLocation() {
		return new File(fJRERoot.getText());
	}
		
	/* (non-Javadoc)
	 * @see org.eclipse.jface.dialogs.Dialog#createDialogArea(org.eclipse.swt.widgets.Composite)
	 */
	protected Control createDialogArea(Composite ancestor) {
		Composite parent = (Composite)super.createDialogArea(ancestor);
		((GridLayout)parent.getLayout()).numColumns = 3;
	//VM type
		SWTFactory.createLabel(parent, JREMessages.addVMDialog_jreType, 1);
		fVMCombo = SWTFactory.createCombo(parent, SWT.READ_ONLY, 2, getVMTypeNames());
	// VM location
		SWTFactory.createLabel(parent, JREMessages.addVMDialog_jreHome, 1);
		fJRERoot = SWTFactory.createSingleText(parent, 2);
		Composite buttons = SWTFactory.createComposite(parent, parent.getFont(), 2, 4, GridData.HORIZONTAL_ALIGN_END, 0, 0);
		Button folders = SWTFactory.createPushButton(buttons, JREMessages.AddVMDialog_22, null);
		GridData data = (GridData) folders.getLayoutData();
		data.horizontalAlignment = GridData.END;
		fFileButton = SWTFactory.createPushButton(buttons, JREMessages.AddVMDialog_21, null);
		data = (GridData) fFileButton.getLayoutData();
		data.horizontalAlignment = GridData.END;
	//VM name
		SWTFactory.createLabel(parent, JREMessages.addVMDialog_jreName, 1);
		fVMName = SWTFactory.createSingleText(parent, 2);
	//VM arguments
		SWTFactory.createLabel(parent, JREMessages.AddVMDialog_23, 1);
		fVMArgs = SWTFactory.createSingleText(parent, 2);
	//VM libraries block 
		SWTFactory.createLabel(parent, JREMessages.AddVMDialog_JRE_system_libraries__1, 3);
		fLibraryBlock = new VMLibraryBlock(this);
		Control block = fLibraryBlock.createControl(parent);
		GridData gd = new GridData(GridData.FILL_BOTH);
		gd.horizontalSpan = 3;
		block.setLayoutData(gd);
	
	//initialize the fields
		initializeFields();
		
	//add the listeners now to prevent them from monkeying with initialized settings
		fVMCombo.addSelectionListener(new SelectionListener() {
			public void widgetDefaultSelected(SelectionEvent e) {}
			public void widgetSelected(SelectionEvent e) {
				updateVMType();
			}
		});
		fVMName.addModifyListener(new ModifyListener() {
			public void modifyText(ModifyEvent e) {
				validateVMName();
				updateStatusLine();	
			}
		});
		fJRERoot.addModifyListener(new ModifyListener() {
			public void modifyText(ModifyEvent e) {
				validateJRELocation();
				updateStatusLine();
			}
		});
		folders.addSelectionListener(new SelectionListener() {
			public void widgetDefaultSelected(SelectionEvent e) {}
			public void widgetSelected(SelectionEvent e) {
				DirectoryDialog dialog = new DirectoryDialog(getShell());
				File file = new File(fJRERoot.getText());
				String text = fJRERoot.getText();
				if (file.isFile()) {
					text = file.getParentFile().getAbsolutePath();
				}
				dialog.setFilterPath(text);
				dialog.setMessage(JREMessages.addVMDialog_pickJRERootDialog_message); 
				String newPath = dialog.open();
				if (newPath != null) {
					fJRERoot.setText(newPath);
				}
			}
		});
		fFileButton.addSelectionListener(new SelectionListener() {
			public void widgetDefaultSelected(SelectionEvent e) {}
			public void widgetSelected(SelectionEvent e) {
				FileDialog dialog = new FileDialog(getShell());
				dialog.setFilterExtensions(new String[]{"*.ee"}); //$NON-NLS-1$
				dialog.setFilterPath(fJRERoot.getText());
				String newPath = dialog.open();
				if (newPath != null) {
					fJRERoot.setText(newPath);
				}
			}
		});		
		applyDialogFont(parent);
		return parent;
	}
	
	/**
	 * Updates the JRE location status and initializes the library block
	 */
	private void updateVMType() {
		int selIndex = fVMCombo.getSelectionIndex();
		if (selIndex == fPrevIndex) {
			return;
		}
		fPrevIndex = selIndex;
		if (selIndex >= 0 && selIndex < fVMTypes.length) {
			fSelectedVMType= fVMTypes[selIndex];
		}
		validateJRELocation();
		fLibraryBlock.initializeFrom(fEditedVM, fSelectedVMType);
		updateFileButton();
		updateStatusLine();
	}	
	
	/**
	 * Updates enabled state of the "Definition File..." button.
	 */
	private void updateFileButton() {
		fFileButton.setEnabled(fSelectedVMType.getId().equals(StandardVMType.ID_STANDARD_VM_TYPE));
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.dialogs.StatusDialog#create()
	 */
	public void create() {
		super.create();
		if (fJRERoot.getText().length() == 0) {
			fJRERoot.setFocus();
		} else {
			fVMName.setFocus();
		}
		selectVMType();  
	}
	
	/**
	 * Returns the VM type names
	 * @return an array of strings with the names of the applicable VMs
	 */
	private String[] getVMTypeNames() {
		String[] names =  new String[fVMTypes.length];
		for (int i = 0; i < fVMTypes.length; i++) {
			names[i]= fVMTypes[i].getName();
		}
		return names;
	}
	
	/**
	 * Selects the corresponding VM for fSelectedVMType
	 */
	private void selectVMType() {
		for (int i= 0; i < fVMTypes.length; i++) {
			if (fSelectedVMType == fVMTypes[i]) {
				if(i < fVMCombo.getItemCount()) {
					fVMCombo.select(i);
					return;
				}
			}
		}
	}
	
	/**
	 * Initialize the dialogs fields
	 */
	private void initializeFields() {
		if (fEditedVM == null) {
			fVMName.setText(""); //$NON-NLS-1$
			fJRERoot.setText(""); //$NON-NLS-1$
			fLibraryBlock.initializeFrom(null, fSelectedVMType);
			fVMArgs.setText(""); //$NON-NLS-1$	
		} else {
			fVMCombo.setEnabled(false);
			fVMName.setText(fEditedVM.getName());
			fJRERoot.setText(fEditedVM.getInstallLocation().getAbsolutePath());
			fLibraryBlock.initializeFrom(fEditedVM, fSelectedVMType);
			if (fEditedVM instanceof IVMInstall2) {
				IVMInstall2 vm2 = (IVMInstall2) fEditedVM;
				String vmArgs = vm2.getVMArgs();
				if (vmArgs != null) {
					fVMArgs.setText(vmArgs);
				}
			} else {
				String[] vmArgs = fEditedVM.getVMArguments();
				if (vmArgs != null) {
					StringBuffer buffer = new StringBuffer();
					int length= vmArgs.length;
					if (length > 0) {
						buffer.append(vmArgs[0]);
						for (int i = 1; i < length; i++) {
							buffer.append(' ').append(vmArgs[i]);
						}
					}
					fVMArgs.setText(buffer.toString());
				}				
			}
		}
		updateFileButton();
		validateVMName();
		updateStatusLine();
	}
	
	/**
	 * Validates the JRE location
	 * @return the status after validating the JRE location
	 */
	private IStatus validateJRELocation() {
		String locationName = fJRERoot.getText();
		IStatus s = null;
		File file = null;
		if (locationName.length() == 0) {
			s = new StatusInfo(IStatus.INFO, JREMessages.addVMDialog_enterLocation); 
		} 
		else {
			file = new File(locationName);
			if (!file.exists()) {
				s = new StatusInfo(IStatus.ERROR, JREMessages.addVMDialog_locationNotExists); 
			} 
			else {
				final IStatus[] temp = new IStatus[1];
				final File tempFile = file; 
				Runnable r = new Runnable() {
					public void run() {
						temp[0] = fSelectedVMType.validateInstallLocation(tempFile);
					}
				};
				BusyIndicator.showWhile(getShell().getDisplay(), r);
				s = temp[0];
			}
		}
		if (s.isOK()) {
			fLibraryBlock.setHomeDirectory(file);
			String name = fVMName.getText();
			if (name == null || name.trim().length() == 0) {
				// auto-generate VM name
				if (file.isFile()) {
					String fileName = file.getName();
					int index = fileName.lastIndexOf(".ee"); //$NON-NLS-1$
					if (index > 0) {
						fileName = fileName.substring(0, index);
					}
					fVMName.setText(fileName);
				} else {
					try {
						String genName = null;
						IPath path = new Path(file.getCanonicalPath());
						int segs = path.segmentCount();
						if (segs == 1) {
							genName = path.segment(0);
						} 
						else if (segs >= 2) {
							String last = path.lastSegment();
							if ("jre".equalsIgnoreCase(last)) { //$NON-NLS-1$
								genName = path.segment(segs - 2);
							} 
							else {
								genName = last;
							}
						}
						if (genName != null) {
							fVMName.setText(genName);
						}
					} catch (IOException e) {}
				}
			}
		} else {
			fLibraryBlock.setHomeDirectory(null);
		}
		fLibraryBlock.restoreDefaultLibraries();
		detectJavadocLocation();
		fStatus[1] = s;
		return s;
	}
	
	/**
	 * Auto-detects the default javadoc location
	 */
	private void detectJavadocLocation() {
		if (fAutoDetectAttributes) {
			if (fSelectedVMType instanceof AbstractVMInstallType) {
				AbstractVMInstallType type = (AbstractVMInstallType)fSelectedVMType;
				fJavadocLocation = type.getDefaultJavadocLocation(getInstallLocation());
				String args = type.getDefaultVMArguments(getInstallLocation());
				if (args != null) {
					fVMArgs.setText(args);
				}
			}
		} else {
			fJavadocLocation = fEditedVM.getJavadocLocation();
		}
	}

	/**
	 * Validates the entered name of the VM
	 * @return the status of the name validation
	 */
	private IStatus validateVMName() {
		StatusInfo status= new StatusInfo();
		String name= fVMName.getText();
		if (name == null || name.trim().length() == 0) {
			status.setInfo(JREMessages.addVMDialog_enterName); 
		} else {
			if (fRequestor.isDuplicateName(name) && (fEditedVM == null || !name.equals(fEditedVM.getName()))) {
				status.setError(JREMessages.addVMDialog_duplicateName); 
			} else {
				IStatus s = ResourcesPlugin.getWorkspace().validateName(name, IResource.FILE);
				if (!s.isOK()) {
					status.setError(MessageFormat.format(JREMessages.AddVMDialog_JRE_name_must_be_a_valid_file_name___0__1, new String[]{s.getMessage()})); 
				}
			}
		}
		fStatus[0] = status;
		return status;
	}
	
	/**
	 * Updates the status line to show/hide messages to the user 
	 */
	protected void updateStatusLine() {
		IStatus max= null;
		for (int i = 0; i < fStatus.length; i++) {
			IStatus curr = fStatus[i];
			if (curr.matches(IStatus.ERROR)) {
				updateStatus(curr);
				return;
			}
			if (max == null || curr.getSeverity() > max.getSeverity()) {
				max = curr;
			}
		}
		updateStatus(max);
	}
	
	/**
	 * Returns the URL for the javadoc location
	 * @return the URL for the javadoc location
	 */
	protected URL getURL() {
		return fJavadocLocation;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.dialogs.Dialog#okPressed()
	 */
	protected void okPressed() {
		if (fEditedVM == null) {
			IVMInstall vm = new VMStandin(fSelectedVMType, createUniqueId(fSelectedVMType));
			setFieldValuesToVM(vm);
			fRequestor.vmAdded(vm);
		} else {
			setFieldValuesToVM(fEditedVM);
		}
		super.okPressed();
	}
	
	/**
	 * Creates a unique name for the VMInstallType
	 * @param vmType the vm install type
	 * @return a unique name
	 */
	private String createUniqueId(IVMInstallType vmType) {
		String id = null;
		do {
			id = String.valueOf(System.currentTimeMillis());
		} while (vmType.findVMInstall(id) != null);
		return id;
	}
	
	/**
	 * initialize fields to the specified VM
	 * @param vm the VM to initialize from
	 */
	protected void setFieldValuesToVM(IVMInstall vm) {
		File dir = new File(fJRERoot.getText());
		try {
			vm.setInstallLocation(dir.getCanonicalFile());
		} 
		catch (IOException e) {
			vm.setInstallLocation(dir.getAbsoluteFile());
		}
		vm.setName(fVMName.getText());
		vm.setJavadocLocation(getURL());
		
		String argString = fVMArgs.getText().trim();
		if (vm instanceof IVMInstall2) {
			IVMInstall2 vm2 = (IVMInstall2) vm;
			if (argString != null && argString.length() > 0) {
				vm2.setVMArgs(argString);			
			} 
			else {
				vm2.setVMArgs(null);
			}
		} 
		else {
			if (argString != null && argString.length() > 0) {
				vm.setVMArguments(DebugPlugin.parseArguments(argString));			
			} 
			else {
				vm.setVMArguments(null);
			}			
		}
		fLibraryBlock.performApply(vm);
	}
	
	/**
	 * returns an absolute file or an empty file if the path is either null or zero length
	 * @param path the path to the file
	 * @return a new file
	 */
	protected File getAbsoluteFileOrEmpty(String path) {
		if (path == null || path.length() == 0) {
			return new File(""); //$NON-NLS-1$
		}
		return new File(path).getAbsoluteFile();
	}
	
	/**
	 * @return the status of the system library 
	 */
	protected IStatus getSystemLibraryStatus() {
		return fStatus[3];
	}
	
	/**
	 * Allows the VM page to set the status of the current system library
	 * @param status the specified status
	 */
	protected void setSystemLibraryStatus(IStatus status) {
		fStatus[3] = status;
	}
	
	/**
	 * Updates the status of the OK button to reflect the given status.
	 * Subclasses may override this method to update additional buttons.
	 * @param status the status.
	 */
	protected void updateButtonsEnableState(IStatus status) {
		Button ok = getButton(IDialogConstants.OK_ID);
		if (ok != null && !ok.isDisposed())
			ok.setEnabled(status.getSeverity() == IStatus.OK);
	}	
	
	/**
	 * Returns the name of the section that this dialog stores its settings in
	 * 
	 * @return String
	 */
	protected String getDialogSettingsSectionName() {
		return "ADD_VM_DIALOG_SECTION"; //$NON-NLS-1$
	}
	
	 /* (non-Javadoc)
     * @see org.eclipse.jface.dialogs.Dialog#getDialogBoundsSettings()
     */
    protected IDialogSettings getDialogBoundsSettings() {
    	 IDialogSettings settings = JDIDebugUIPlugin.getDefault().getDialogSettings();
         IDialogSettings section = settings.getSection(getDialogSettingsSectionName());
         if (section == null) {
             section = settings.addNewSection(getDialogSettingsSectionName());
         } 
         return section;
    }
    
	/* (non-Javadoc)
	 * @see org.eclipse.jface.dialogs.Dialog#getInitialSize()
	 */
	protected Point getInitialSize() {
		IDialogSettings settings = getDialogBoundsSettings();
		if(settings != null) {
			try {
				int width = settings.getInt("DIALOG_WIDTH"); //$NON-NLS-1$
				int height = settings.getInt("DIALOG_HEIGHT"); //$NON-NLS-1$
				if(width > 0 & height > 0) {
					return new Point(width, height);
				}
			}
			catch (NumberFormatException nfe) {
				return new Point(500, 570);
			}
		}
		return new Point(500, 570);
	}

	protected void setButtonLayoutData(Button button) {
		super.setButtonLayoutData(button);
	}
    
}




import org.eclipse.core.runtime.Status;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.debug.ui.IJavaDebugUIConstants;
import org.eclipse.jdt.debug.ui.launchConfigurations.AbstractVMInstallPage;
import org.eclipse.jdt.internal.debug.ui.JDIDebugUIPlugin;
import org.eclipse.jdt.internal.debug.ui.SWTFactory;
import org.eclipse.jdt.internal.debug.ui.jres.LibraryContentProvider.SubElement;
import org.eclipse.jdt.internal.launching.EEVMType;
import org.eclipse.jdt.launching.IRuntimeClasspathEntry;
import org.eclipse.jdt.launching.IVMInstall;
import org.eclipse.jdt.launching.IVMInstallType;
import org.eclipse.jdt.launching.JavaRuntime;
import org.eclipse.jdt.launching.LibraryLocation;
import org.eclipse.jdt.launching.VMStandin;
import org.eclipse.jdt.ui.wizards.BuildPathDialogAccess;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.viewers.DoubleClickEvent;

import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.FileDialog;
 
/**
 * Control used to edit the libraries associated with a VM install
 */
public class VMLibraryBlock extends AbstractVMInstallPage implements SelectionListener, ISelectionChangedListener {

	/**
	 * Attribute name for the last path used to open a file/directory chooser
	 * dialog.

	protected static final String DIALOG_SETTINGS_PREFIX = "VMLibraryBlock"; //$NON-NLS-1$
	
	protected boolean fInCallback = false;
	protected VMStandin fVmInstall;
	protected IVMInstallType fVmInstallType;
	protected File fHome;
	
	//widgets
	protected LibraryContentProvider fLibraryContentProvider;
	protected AddVMDialog fDialog = null;
	protected TreeViewer fLibraryViewer;
	private Button fUpButton;
	private Button fDownButton;

	private Button fSourceButton;
	protected Button fDefaultButton;
	
	private IStatus[] fLibStatus;
	
	/**
	 * Constructs a new wizard page with the given name.
	 * 
	 * @param pageName page name
	 */
	VMLibraryBlock() {
		super(JREMessages.VMLibraryBlock_2);
		fLibStatus = new IStatus[]{Status.OK_STATUS};
	}	

	/* (non-Javadoc)
	 * @see org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets.Composite)
	 * 
	 * @param parent the parent widget of this control
	 */
	public void createControl(Composite parent) {
		Font font = parent.getFont();
		
		Composite comp = SWTFactory.createComposite(parent, font, 2, 1, GridData.FILL_BOTH, 0, 0);

		fDefaultButton = SWTFactory.createPushButton(pathButtonComp, JREMessages.VMLibraryBlock_9, JREMessages.VMLibraryBlock_15, null);
		fDefaultButton.addSelectionListener(this);
		
		setControl(comp);
	}

	/**
	 * The "default" button has been toggled
	 */
	private void restoreDefaultLibraries() {
		LibraryLocation[] libs = null;
		File installLocation = null;
		if (fVmInstall != null) {
			if (EEVMType.ID_EE_VM_TYPE.equals(fVmInstall.getVMInstallType().getId())) {
				File definitionFile = EEVMType.getDefinitionFile(fVmInstall);
				if (definitionFile != null) {
					libs = EEVMType.getLibraryLocations(definitionFile);
				} else {
					libs = new LibraryLocation[0];
				}
			} else {
				installLocation = fVmInstall.getInstallLocation();
				if (installLocation == null) {
					libs = new LibraryLocation[0];
				} else {
					libs = fVmInstall.getVMInstallType().getDefaultLibraryLocations(installLocation);
				}
			}
		}
		fLibraryContentProvider.setLibraries(libs);
		update();
	}
	
	/**
	 * Initializes this control based on the settings in the given
	 * vm install and type.
	 * 
	 * @param vm vm or <code>null</code> if none
	 * @param type type of vm install
	 */
	public void initializeFrom(IVMInstall vm, IVMInstallType type) {
		fVmInstall = vm;
		fVmInstallType = type;
		if (vm != null) {
			setHomeDirectory(vm.getInstallLocation());
			fLibraryContentProvider.setLibraries(JavaRuntime.getLibraryLocations(getVMInstall()));
		}
		update();
	}
	
	/**
	 * Sets the home directory of the VM Install the user has chosen
	 */
	public void setHomeDirectory(File file) {
		fHome = file;
	}
	
	/**
	 * Returns the home directory
	 */
	protected File getHomeDirectory() {
		return fHome;
	}
	
	/**
	 * Updates buttons and status based on current libraries
	 */
	private void update() {
		updateButtons();
		IStatus status = Status.OK_STATUS;
		if (fLibraryContentProvider.getLibraries().length == 0) {
			status = new Status(IStatus.ERROR, JDIDebugUIPlugin.getUniqueIdentifier(), IJavaDebugUIConstants.INTERNAL_ERROR, "Libraries cannot be empty.", null); //$NON-NLS-1$
		}
		LibraryStandin[] standins = fLibraryContentProvider.getStandins();

				break;
			}
		}
		fLibStatus[0] = status;
		if (status.isOK()) {
			setErrorMessage(null);
			setPageComplete(true);
	/**
	 * Saves settings in the given working copy
	 */
	public void performApply(IVMInstall vm) {
		if (isDefaultLocations(vm)) {
			vm.setLibraryLocations(null);
		} else {
			setErrorMessage(status.getMessage());
			setPageComplete(false);
		}
		// must force since this page is a 'sub-page' and may not be considered the current page
		if (getContainer().getCurrentPage() != this) {
			getContainer().updateMessage();
			getContainer().updateButtons();
		}
	}
	
	/**
	 * Determines if the current libraries displayed to the user are the default location

		}
		File installLocation = vm.getInstallLocation();
		if (installLocation != null) {
			LibraryLocation[] def = vm.getVMInstallType().getDefaultLibraryLocations(installLocation);
			if (def.length == libraryLocations.length) {
				for (int i = 0; i < def.length; i++) {
					if (!def[i].equals(libraryLocations[i])) {

		}
		return false;
	}
	
	/**
	 * Returns the vm install associated with this library block.
	 * 
	 * @return vm install
	 */
	protected IVMInstall getVMInstall() {
		return fVmInstall;
	}	
	
	/**
	 * Returns the vm install type associated with this library block.
	 * 
	 * @return vm install
	 */
	protected IVMInstallType getVMInstallType() {
		return fVmInstallType;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.swt.events.SelectionListener#widgetSelected(org.eclipse.swt.events.SelectionEvent)

		fJavadocButton.setEnabled(!selection.isEmpty() && (allJavadoc || allRoots));
		fSourceButton.setEnabled(!selection.isEmpty() && (allSource || allRoots));
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.debug.ui.launchConfigurations.AbstractVMInstallPage#finish()
	 */
	public boolean finish() {
		if (fVmInstall != null) {
			if (isDefaultLocations(fVmInstall)) {
				fVmInstall.setLibraryLocations(null);
			} else {
				LibraryLocation[] libs = fLibraryContentProvider.getLibraries();
				fVmInstall.setLibraryLocations(libs);
			}
		}
		return true;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.debug.ui.launchConfigurations.AbstractVMInstallPage#getSelection()
	 */
	public VMStandin getSelection() {
		return fVmInstall;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.debug.ui.launchConfigurations.AbstractVMInstallPage#setSelection(org.eclipse.jdt.launching.VMStandin)
	 */
	public void setSelection(VMStandin vm) {
		super.setSelection(vm);
		LibraryLocation[] libraryLocations = null;
		if (vm == null) {
			libraryLocations = new LibraryLocation[0];
		} else {
			libraryLocations = JavaRuntime.getLibraryLocations(vm);
		}
		fVmInstall = vm;
		fLibraryContentProvider.setLibraries(libraryLocations);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jdt.debug.ui.launchConfigurations.AbstractVMInstallPage#getVMStatus()
	 */
	protected IStatus[] getVMStatus() {
		return fLibStatus;
	}	
		
}

Lines 32-37 Link Here

(-)ui/org/eclipse/jdt/debug/ui/IJavaDebugUIConstants.java (+8 lines)
32	public static final String EXTENSION_POINT_VM_INSTALL_TYPE_PAGE = "vmInstallTypePage"; //$NON-NLS-1$	32	public static final String EXTENSION_POINT_VM_INSTALL_TYPE_PAGE = "vmInstallTypePage"; //$NON-NLS-1$
33		33
34	/**	34	/**
		35	* Extension point identifier for contributions of a wizard page that for a VMInstallType
		36	* (value <code>"vmInstallPages"</code>).
		37	*
		38	* @since 3.4
		39	*/
		40	public static final String EXTENSION_POINT_VM_INSTALL_PAGES = "vmInstallPages"; //$NON-NLS-1$
		41
		42	/**
35	* Display view identifier (value <code>"org.eclipse.jdt.debug.ui.DisplayView"</code>).	43	* Display view identifier (value <code>"org.eclipse.jdt.debug.ui.DisplayView"</code>).
36	*/	44	*/
37	public static final String ID_DISPLAY_VIEW= PLUGIN_ID + ".DisplayView"; //$NON-NLS-1$	45	public static final String ID_DISPLAY_VIEW= PLUGIN_ID + ".DisplayView"; //$NON-NLS-1$

Lines 5-10 Link Here

(-)plugin.xml (+8 lines)
5		5
6	<!-- Extensions Points -->	6	<!-- Extensions Points -->
7	<extension-point id="vmInstallTypePage" name="%vmInstallTypePage" schema="schema/vmInstallTypePage.exsd"/>	7	<extension-point id="vmInstallTypePage" name="%vmInstallTypePage" schema="schema/vmInstallTypePage.exsd"/>
		8	<extension-point id="vmInstallPages" name="VM Install Page" schema="schema/vmInstallPages.exsd"/>
8		9
9	<!-- Extensions -->	10	<!-- Extensions -->
10	<extension	11	<extension
Lines 3369-3372 Link Here
3369	targetId="org.eclipse.jdt.ui.javaCode">	3370	targetId="org.eclipse.jdt.ui.javaCode">
3370	</hyperlinkDetector>	3371	</hyperlinkDetector>
3371	</extension>	3372	</extension>
		3373	<extension
		3374	point="org.eclipse.jdt.debug.ui.vmInstallPages">
		3375	<vmInstallPage
		3376	class="org.eclipse.jdt.internal.debug.ui.jres.EEVMPage"
		3377	vmInstallType="org.eclipse.jdt.launching.EEVMType">
		3378	</vmInstallPage>
		3379	</extension>
3372	</plugin>	3380	</plugin>




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.debug.ui.jres;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import org.eclipse.jdt.debug.ui.launchConfigurations.AbstractVMInstallPage;
import org.eclipse.jdt.internal.debug.ui.JavaDebugImages;
import org.eclipse.jdt.internal.debug.ui.SWTFactory;
import org.eclipse.jdt.internal.launching.StandardVMType;
import org.eclipse.jdt.launching.IVMInstallType;
import org.eclipse.jdt.launching.JavaRuntime;
import org.eclipse.jdt.launching.VMStandin;
import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.CheckboxTableViewer;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.ViewerComparator;
import org.eclipse.jface.wizard.IWizardPage;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;

/**
 * Wizard page used to select a VM type.
 * 
 * @since 3.4
 */
public class VMTypePage extends WizardPage {
	
	private CheckboxTableViewer fTypesViewer;
	
	private AbstractVMInstallPage fNextPage;
	
	/**
	 * Keep track of pages created, so we can dispose of them.
	 */
	private Set fPages = new HashSet();
	
	/**
	 * Label provider for VM types
	 */
	private class TypeLabelProvider extends LabelProvider {

		/* (non-Javadoc)
		 * @see org.eclipse.jface.viewers.LabelProvider#getText(java.lang.Object)
		 */
		public String getText(Object element) {
			if (element instanceof IVMInstallType) {
				IVMInstallType type = (IVMInstallType) element;
				return type.getName();
			}
			return super.getText(element);
		}
		
	}
	
	/**
	 * Constructs a VM type selection page
	 */
	public VMTypePage() {
		super(JREMessages.VMTypePage_0);
		setDescription(JREMessages.VMTypePage_1);
		setTitle(JREMessages.VMTypePage_2);
	}
	
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.dialogs.DialogPage#dispose()
	 */
	public void dispose() {
		super.dispose();
		Iterator iterator = fPages.iterator();
		while (iterator.hasNext()) {
			AbstractVMInstallPage page = (AbstractVMInstallPage)iterator.next();
			page.dispose();
		}
	}


	/* (non-Javadoc)
	 * @see org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets.Composite)
	 */
	public void createControl(Composite parent) {
		Composite composite = new Composite(parent, SWT.NONE);
		GridLayout layout = new GridLayout();
		layout.numColumns = 1;
		composite.setLayout(layout);
		composite.setLayoutData(new GridData(GridData.FILL_BOTH));
		
		SWTFactory.createLabel(composite, JREMessages.VMTypePage_3, 1);
		
		fTypesViewer = CheckboxTableViewer.newCheckList(composite, SWT.SINGLE | SWT.BORDER);
		GridData data = new GridData(GridData.FILL_BOTH);
        data.heightHint = 250;
        data.widthHint = 300;
        fTypesViewer.getTable().setLayoutData(data);
        fTypesViewer.setContentProvider(new ArrayContentProvider());
        fTypesViewer.setLabelProvider(new TypeLabelProvider());
		fTypesViewer.setComparator(new ViewerComparator());
		fTypesViewer.addCheckStateListener(new ICheckStateListener() {
			public void checkStateChanged(CheckStateChangedEvent event) {
				if (event.getChecked()) {
					// only check one element
					fTypesViewer.setCheckedElements(new Object[]{event.getElement()});
					setPageComplete(true);
					updateNextPage();
				} else {
					setPageComplete(false);
				}
			}
		});
		fTypesViewer.setInput(JavaRuntime.getVMInstallTypes());
		setControl(composite);
		
		fTypesViewer.setChecked(JavaRuntime.getVMInstallType(StandardVMType.ID_STANDARD_VM_TYPE), true);
		updateNextPage();
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.dialogs.IDialogPage#getImage()
	 */
	public Image getImage() {
		return JavaDebugImages.get(JavaDebugImages.IMG_WIZBAN_LIBRARY);
	}	
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.wizard.WizardPage#getNextPage()
	 */
	public IWizardPage getNextPage() {
		return fNextPage;
	}
	
	private void updateNextPage() {
		if (isPageComplete()) {
			Object[] checkedElements = fTypesViewer.getCheckedElements();
			if (checkedElements.length == 1) {
				IVMInstallType installType = (IVMInstallType)checkedElements[0];
				AbstractVMInstallPage page = ((VMInstallWizard)getWizard()).getPage(installType);
				page.setWizard(getWizard());
				VMStandin standin = new VMStandin(installType, StandardVMPage.createUniqueId(installType));
				standin.setName(""); //$NON-NLS-1$
				page.setSelection(standin);
				fNextPage = page;
				fPages.add(page);
			}
		}		
	}

}




<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.eclipse.jdt.debug.ui">
<annotation>
      <appInfo>
         <meta.schema plugin="org.eclipse.jdt.debug.ui" id="vmInstallPages" name="VM Install Pages"/>
      </appInfo>
      <documentation>
         This extension point allows a wizard page to be contributed for VM installs that require custom editing controls.
      </documentation>
   </annotation>

   <element name="extension">
      <complexType>
         <sequence minOccurs="1" maxOccurs="unbounded">
            <element ref="vmInstallPage"/>
         </sequence>
         <attribute name="point" type="string" use="required">
            <annotation>
               <documentation>
                  
               </documentation>
            </annotation>
         </attribute>
         <attribute name="id" type="string">
            <annotation>
               <documentation>
                  
               </documentation>
            </annotation>
         </attribute>
         <attribute name="name" type="string">
            <annotation>
               <documentation>
                  
               </documentation>
               <appInfo>
                  <meta.attribute translatable="true"/>
               </appInfo>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <element name="vmInstallPage">
      <annotation>
         <documentation>
            Contributes a wizard page for a specific VM install type.
         </documentation>
      </annotation>
      <complexType>
         <attribute name="vmInstallType" type="string" use="required">
            <annotation>
               <documentation>
                  Specifies the VM install type this wizard page is to be used for. Unique identifier corresponding to an &lt;code&gt;IVMInstallType&lt;/code&gt;&apos;s id.
               </documentation>
            </annotation>
         </attribute>
         <attribute name="class" type="string" use="required">
            <annotation>
               <documentation>
                  Wizard page implementation. Must be a subclass of &lt;code&gt;org.eclipse.jdt.debug.ui.launchConfigurations.AbstractVMInstallPage&lt;/code&gt;.
               </documentation>
               <appInfo>
                  <meta.attribute kind="java" basedOn="org.eclipse.jdt.debug.ui.launchConfigurations.AbstractVMInstallPage:"/>
               </appInfo>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <annotation>
      <appInfo>
         <meta.section type="since"/>
      </appInfo>
      <documentation>
         3.4
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="examples"/>
      </appInfo>
      <documentation>
         Following is an example definition of a VM install page.
&lt;p&gt;
&lt;pre&gt;
&lt;extension point=&quot;org.eclipse.jdt.debug.ui.vmInstallPages&quot;&gt;
  &lt;vmInstallPage 
     vmInstallType=&quot;org.eclipse.jdt.launching.EEVMType&quot;
     class=&quot;org.eclipse.jdt.internal.debug.ui.jres.EEVMPage&quot;&gt;
  &lt;/vmInstallPage&gt;
&lt;/extension&gt;
&lt;/pre&gt;
&lt;/p&gt;
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="apiInfo"/>
      </appInfo>
      <documentation>
         A wizard page must be a subclass of &lt;code&gt;org.eclipse.jdt.debug.ui.launchConfigurations.AbstractVMInstallPage&lt;/code&gt;.
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="implementation"/>
      </appInfo>
      <documentation>
         JDT provides a default implementation of a wizard page for VMs that do not contribute one.
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="copyright"/>
      </appInfo>
      <documentation>
         Copyright (c) 2007 IBM Corporation and others.&lt;br&gt;
All rights reserved. This program and the accompanying materials are made 
available under the terms of the Eclipse Public License v1.0 which 
accompanies this distribution, and is available at 
&lt;a href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
      </documentation>
   </annotation>

</schema>




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.debug.ui.jres;

import java.io.File;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.jdt.debug.ui.launchConfigurations.AbstractVMInstallPage;
import org.eclipse.jdt.internal.debug.ui.JavaDebugImages;
import org.eclipse.jdt.internal.debug.ui.SWTFactory;
import org.eclipse.jdt.internal.debug.ui.StatusInfo;
import org.eclipse.jdt.internal.launching.EEVMInstall;
import org.eclipse.jdt.internal.launching.EEVMType;
import org.eclipse.jdt.launching.IVMInstallType;
import org.eclipse.jdt.launching.JavaRuntime;
import org.eclipse.jdt.launching.VMStandin;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.FileDialog;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Text;

/**
 * Page used to edit an 'EE' VM.
 * 
 * @since 3.4
 */
public class EEVMPage extends AbstractVMInstallPage {
	
	// VM being edited or created
	private VMStandin fVM;
	private Text fVMName;
	private Text fVMArgs;
	private Text fEEFile;
	private VMLibraryBlock fLibraryBlock;
	private IStatus[] fFieldStatus = new IStatus[1];
	private boolean fIgnoreCallbacks = false;
	
	/**
	 * 
	 */
	public EEVMPage() {
		super(JREMessages.EEVMPage_0);
		for (int i = 0; i < fFieldStatus.length; i++) {
			fFieldStatus[i] = Status.OK_STATUS;
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.dialogs.IDialogPage#getImage()
	 */
	public Image getImage() {
		return JavaDebugImages.get(JavaDebugImages.IMG_WIZBAN_LIBRARY);
	}	

	/* (non-Javadoc)
	 * @see org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets.Composite)
	 */
	public void createControl(Composite p) {
		// create a composite with standard margins and spacing
		Composite composite = new Composite(p, SWT.NONE);
		GridLayout layout = new GridLayout();
		layout.numColumns = 3;
		composite.setLayout(layout);
		composite.setLayoutData(new GridData(GridData.FILL_BOTH));
		
	// VM location
		SWTFactory.createLabel(composite, JREMessages.EEVMPage_1, 1);
		fEEFile = SWTFactory.createSingleText(composite, 1);
		Button folders = SWTFactory.createPushButton(composite, JREMessages.EEVMPage_2, null);
		GridData data = (GridData) folders.getLayoutData();
		data.horizontalAlignment = GridData.END;
	//VM name
		SWTFactory.createLabel(composite, JREMessages.addVMDialog_jreName, 1);
		fVMName = SWTFactory.createSingleText(composite, 2);
	//VM arguments
		Label label = SWTFactory.createLabel(composite, JREMessages.AddVMDialog_23, 1);
		GridData gd = (GridData) label.getLayoutData();
		gd.verticalAlignment = SWT.BEGINNING;
		fVMArgs = SWTFactory.createText(composite, SWT.BORDER | SWT.V_SCROLL | SWT.WRAP, 2, ""); //$NON-NLS-1$
		gd = (GridData) fVMArgs.getLayoutData();
		gd.widthHint = 200;
		gd.heightHint = 50;
	//VM libraries block 
		SWTFactory.createLabel(composite, JREMessages.AddVMDialog_JRE_system_libraries__1, 3);
		fLibraryBlock = new VMLibraryBlock();
		fLibraryBlock.setWizard(getWizard());
		fLibraryBlock.createControl(composite);
		Control libControl = fLibraryBlock.getControl();
		gd = new GridData(GridData.FILL_BOTH);
		gd.horizontalSpan = 3;
		libControl.setLayoutData(gd);
		
		initializeFields();
	//add the listeners now to prevent them from monkeying with initialized settings
		fVMName.addModifyListener(new ModifyListener() {
			public void modifyText(ModifyEvent e) {
				if (!fIgnoreCallbacks) {
					validateVMName();
				}
			}
		});
		fEEFile.addModifyListener(new ModifyListener() {
			public void modifyText(ModifyEvent e) {
				if (!fIgnoreCallbacks) {
					if (validateDefinitionFile().isOK()) {
						reloadDefinitionFile();
					}
				}
			}
		});
		folders.addSelectionListener(new SelectionListener() {
			public void widgetDefaultSelected(SelectionEvent e) {}
			public void widgetSelected(SelectionEvent e) {
				FileDialog dialog = new FileDialog(getShell());
				dialog.setFilterExtensions(new String[]{"*.ee"}); //$NON-NLS-1$
				File file = getDefinitionFile();
				String text = fEEFile.getText();
				if (file != null && file.isFile()) {
					text = file.getParentFile().getAbsolutePath();
				}
				dialog.setFileName(text); 
				String newPath = dialog.open();
				if (newPath != null) {
					fEEFile.setText(newPath);
				}
			}
		});
		Dialog.applyDialogFont(composite);
		setControl(composite);
	}	
	
	/**
	 * Validates the JRE location
	 * @return the status after validating the JRE location
	 */
	private IStatus validateDefinitionFile() {
		String locationName = fEEFile.getText();
		IStatus s = null;
		File file = null;
		if (locationName.length() == 0) {
			s = new StatusInfo(IStatus.INFO, JREMessages.EEVMPage_4); 
		}  else {
			file = new File(locationName);
			if (!file.exists()) {
				s = new StatusInfo(IStatus.ERROR, JREMessages.EEVMPage_5); 
			} else {
				EEVMType.clearProperties(file);
				final IStatus[] temp = new IStatus[1];
				final VMStandin[] vm = new VMStandin[1];
				final File tempFile = file; 
				Runnable r = new Runnable() {
					public void run() {
						try {
							vm[0] = JavaRuntime.createVMFromDefinitionFile(tempFile, fVM.getName(), fVM.getId());
							temp[0] = Status.OK_STATUS;
						} catch (CoreException e) {
							temp[0] = e.getStatus();
						}
					}
				};
				BusyIndicator.showWhile(getShell().getDisplay(), r);
				s = temp[0];
			}
		}
		setDefinitionFileStatus(s);
		updatePageStatus();
		return s;
	}
	
	/**
	 * Initializes the JRE attributes from the definition file
	 */
	private void reloadDefinitionFile() {
		IStatus s = Status.OK_STATUS;
		File file = getDefinitionFile();
		if (file != null && file.exists()) {
			final IStatus[] temp = new IStatus[1];
			final VMStandin[] vm = new VMStandin[1];
			final File tempFile = file; 
			Runnable r = new Runnable() {
				public void run() {
					try {
						vm[0] = JavaRuntime.createVMFromDefinitionFile(tempFile, fVM.getName(), fVM.getId());
						temp[0] = Status.OK_STATUS;
					} catch (CoreException e) {
						temp[0] = e.getStatus();
					}
				}
			};
			BusyIndicator.showWhile(getShell().getDisplay(), r);
			s = temp[0];
			if (s.isOK()) {
				fVM = vm[0];
			}
		}
		if (s.isOK() && file != null) {
			String name = fVMName.getText();
			if (name == null || name.trim().length() == 0) {
				// auto-generate VM name
				String fileName = file.getName();
				int index = fileName.lastIndexOf("."); //$NON-NLS-1$
				if (index > 0) {
					fileName = fileName.substring(0, index);
				}
				fVM.setName(fileName);
			}
			initializeFields();
		}
		setDefinitionFileStatus(s);
	}	

	/**
	 * Validates the entered name of the VM
	 * @return the status of the name validation
	 */
	private void validateVMName() {
		nameChanged(fVMName.getText());
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jdt.debug.ui.launchConfigurations.AbstractVMInstallPage#finish()
	 */
	public boolean finish() {
		setFieldValuesToVM(fVM);
		fLibraryBlock.finish();
		return true;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.debug.ui.launchConfigurations.AbstractVMInstallPage#getSelection()
	 */
	public VMStandin getSelection() {
		return fVM;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jdt.debug.ui.launchConfigurations.AbstractVMInstallPage#setSelection(org.eclipse.jdt.launching.VMStandin)
	 */
	public void setSelection(VMStandin vm) {
		super.setSelection(vm);
		fVM = vm;
		setTitle(JREMessages.EEVMPage_6);
		setDescription(JREMessages.EEVMPage_7);
	}
	
	/**
	 * initialize fields to the specified VM
	 * @param vm the VM to initialize from
	 */
	protected void setFieldValuesToVM(VMStandin vm) {
		File eeFile = getDefinitionFile();
		File home = null;
		if (eeFile != null) {
			vm.setAttribute(EEVMInstall.ATTR_DEFINITION_FILE, eeFile.getPath());
			String homePath = EEVMType.getProperty(EEVMType.PROP_JAVA_HOME, eeFile);
			if (homePath != null) {
				home = new File(homePath);
			}
		}
		vm.setInstallLocation(home);
		vm.setName(fVMName.getText());
		
		String argString = fVMArgs.getText().trim();
		if (argString != null && argString.length() > 0) {
			vm.setVMArgs(argString);			
		} else {
			vm.setVMArgs(null);
		}
	}
	
	/**
	 * Returns the definition file from the text control or <code>null</code>
	 * if none.
	 * 
	 * @return definition file or <code>null</code>
	 */
	private File getDefinitionFile() {
		String path = fEEFile.getText().trim();
		if (path.length() > 0) {
			return new File(path);
		} else {
			return null;
		}
	}
	
	/**
	 * Creates a unique name for the VMInstallType
	 * @param vmType the vm install type
	 * @return a unique name
	 */
	protected static String createUniqueId(IVMInstallType vmType) {
		String id = null;
		do {
			id = String.valueOf(System.currentTimeMillis());
		} while (vmType.findVMInstall(id) != null);
		return id;
	}	
	
	/**
	 * Initialize the dialogs fields
	 */
	private void initializeFields() {
		try {
			fIgnoreCallbacks = true;
			fLibraryBlock.setSelection(fVM);
			fVMName.setText(fVM.getName());
			String eePath = fVM.getAttribute(EEVMInstall.ATTR_DEFINITION_FILE);
			if (eePath != null) {
				fEEFile.setText(eePath);
			}
			String vmArgs = fVM.getVMArgs();
			if (vmArgs != null) {
				fVMArgs.setText(vmArgs);
			}
			validateVMName();
			validateDefinitionFile();
		} finally {
			fIgnoreCallbacks = false;
		}
	}	
	
	/**
	 * Sets the status of the definition file.
	 * 
	 * @param status definition file status
	 */
	private void setDefinitionFileStatus(IStatus status) {
		fFieldStatus[0] = status;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.dialogs.DialogPage#getErrorMessage()
	 */
	public String getErrorMessage() {
		String message = super.getErrorMessage();
		if (message == null) {
			return fLibraryBlock.getErrorMessage();
		}
		return message;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.wizard.WizardPage#isPageComplete()
	 */
	public boolean isPageComplete() {
		boolean complete = super.isPageComplete();
		if (complete) {
			return fLibraryBlock.isPageComplete();
		}
		return complete;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.debug.ui.launchConfigurations.AbstractVMInstallPage#getVMStatus()
	 */
	protected IStatus[] getVMStatus() {
		return fFieldStatus;
	}
	
	
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.debug.ui.jres;

import java.io.File;
import java.io.IOException;
import java.net.URL;

import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Status;
import org.eclipse.jdt.debug.ui.launchConfigurations.AbstractVMInstallPage;
import org.eclipse.jdt.internal.debug.ui.JavaDebugImages;
import org.eclipse.jdt.internal.debug.ui.SWTFactory;
import org.eclipse.jdt.internal.debug.ui.StatusInfo;
import org.eclipse.jdt.launching.AbstractVMInstallType;
import org.eclipse.jdt.launching.IVMInstallType;
import org.eclipse.jdt.launching.VMStandin;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.DirectoryDialog;
import org.eclipse.swt.widgets.Text;

/**
 * Page used to edit a standard VM.
 * 
 * @since 3.4
 */
public class StandardVMPage extends AbstractVMInstallPage {
	
	// VM being edited or created
	private VMStandin fVM;
	private Text fVMName;
	private Text fVMArgs;
	private Text fJRERoot;
	private VMLibraryBlock fLibraryBlock;
// the VM install's javadoc location
	private URL fJavadocLocation = null;
	private boolean fAutoDetectAttributes = false;
	private IStatus[] fFieldStatus = new IStatus[1];
	
	/**
	 * 
	 */
	public StandardVMPage() {
		super(JREMessages.StandardVMPage_0);
		for (int i = 0; i < fFieldStatus.length; i++) {
			fFieldStatus[i] = Status.OK_STATUS;
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.dialogs.IDialogPage#getImage()
	 */
	public Image getImage() {
		return JavaDebugImages.get(JavaDebugImages.IMG_WIZBAN_LIBRARY);
	}	

	/* (non-Javadoc)
	 * @see org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets.Composite)
	 */
	public void createControl(Composite p) {
		// create a composite with standard margins and spacing
		Composite composite = new Composite(p, SWT.NONE);
		GridLayout layout = new GridLayout();
		layout.numColumns = 3;
		composite.setLayout(layout);
		composite.setLayoutData(new GridData(GridData.FILL_BOTH));
		
	// VM location
		SWTFactory.createLabel(composite, JREMessages.addVMDialog_jreHome, 1);
		fJRERoot = SWTFactory.createSingleText(composite, 1);
		Button folders = SWTFactory.createPushButton(composite, JREMessages.AddVMDialog_22, null);
		GridData data = (GridData) folders.getLayoutData();
		data.horizontalAlignment = GridData.END;
	//VM name
		SWTFactory.createLabel(composite, JREMessages.addVMDialog_jreName, 1);
		fVMName = SWTFactory.createSingleText(composite, 2);
	//VM arguments
		SWTFactory.createLabel(composite, JREMessages.AddVMDialog_23, 1);
		fVMArgs = SWTFactory.createSingleText(composite, 2);
	//VM libraries block 
		SWTFactory.createLabel(composite, JREMessages.AddVMDialog_JRE_system_libraries__1, 3);
		fLibraryBlock = new VMLibraryBlock();
		fLibraryBlock.setWizard(getWizard());
		fLibraryBlock.createControl(composite);
		Control libControl = fLibraryBlock.getControl();
		GridData gd = new GridData(GridData.FILL_BOTH);
		gd.horizontalSpan = 3;
		libControl.setLayoutData(gd);
		
	
	//add the listeners now to prevent them from monkeying with initialized settings
		fVMName.addModifyListener(new ModifyListener() {
			public void modifyText(ModifyEvent e) {
				validateVMName();
			}
		});
		fJRERoot.addModifyListener(new ModifyListener() {
			public void modifyText(ModifyEvent e) {
				validateJRELocation();
			}
		});
		folders.addSelectionListener(new SelectionListener() {
			public void widgetDefaultSelected(SelectionEvent e) {}
			public void widgetSelected(SelectionEvent e) {
				DirectoryDialog dialog = new DirectoryDialog(getShell());
				File file = new File(fJRERoot.getText());
				String text = fJRERoot.getText();
				if (file.isFile()) {
					text = file.getParentFile().getAbsolutePath();
				}
				dialog.setFilterPath(text);
				dialog.setMessage(JREMessages.addVMDialog_pickJRERootDialog_message); 
				String newPath = dialog.open();
				if (newPath != null) {
					fJRERoot.setText(newPath);
				}
			}
		});
		Dialog.applyDialogFont(composite);
		setControl(composite);
		initializeFields();
	}	
	
	/**
	 * Validates the JRE location
	 * @return the status after validating the JRE location
	 */
	private void validateJRELocation() {
		String locationName = fJRERoot.getText();
		IStatus s = null;
		File file = null;
		if (locationName.length() == 0) {
			s = new StatusInfo(IStatus.INFO, JREMessages.addVMDialog_enterLocation); 
		} 
		else {
			file = new File(locationName);
			if (!file.exists()) {
				s = new StatusInfo(IStatus.ERROR, JREMessages.addVMDialog_locationNotExists); 
			} 
			else {
				final IStatus[] temp = new IStatus[1];
				final File tempFile = file; 
				Runnable r = new Runnable() {
					public void run() {
						temp[0] = fVM.getVMInstallType().validateInstallLocation(tempFile);
					}
				};
				BusyIndicator.showWhile(getShell().getDisplay(), r);
				s = temp[0];
			}
		}
		if (file != null) {
			fVM.setInstallLocation(file);
		}
		if (s.isOK() && file != null) {
			String name = fVMName.getText();
			if (name == null || name.trim().length() == 0) {
				// auto-generate VM name
				if (file.isFile()) {
					String fileName = file.getName();
					int index = fileName.lastIndexOf(".ee"); //$NON-NLS-1$
					if (index > 0) {
						fileName = fileName.substring(0, index);
					}
					fVMName.setText(fileName);
				} else {
					try {
						String genName = null;
						IPath path = new Path(file.getCanonicalPath());
						int segs = path.segmentCount();
						if (segs == 1) {
							genName = path.segment(0);
						} 
						else if (segs >= 2) {
							String last = path.lastSegment();
							if ("jre".equalsIgnoreCase(last)) { //$NON-NLS-1$
								genName = path.segment(segs - 2);
							} 
							else {
								genName = last;
							}
						}
						if (genName != null) {
							fVMName.setText(genName);
						}
					} catch (IOException e) {}
				}
			}
		}
		detectJavadocLocation();
		setJRELocationStatus(s);
		fLibraryBlock.setSelection(fVM);
		updatePageStatus();
	}
	
	/**
	 * Auto-detects the default javadoc location
	 */
	private void detectJavadocLocation() {
		if (fAutoDetectAttributes) {
			IVMInstallType type = fVM.getVMInstallType();
			if (type instanceof AbstractVMInstallType) {
				AbstractVMInstallType atype = (AbstractVMInstallType)type;
				fJavadocLocation = atype.getDefaultJavadocLocation(getInstallLocation());
				String args = atype.getDefaultVMArguments(getInstallLocation());
				if (args != null) {
					fVMArgs.setText(args);
				}
			}
		} else {
			fJavadocLocation = fVM.getJavadocLocation();
		}
	}
	
	/**
	 * Returns the installation location as a file from the JRE root text control
	 * @return the installation location as a file
	 */
	protected File getInstallLocation() {
		return new File(fJRERoot.getText());
	}	

	/**
	 * Validates the entered name of the VM
	 * @return the status of the name validation
	 */
	private void validateVMName() {
		nameChanged(fVMName.getText());
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jdt.debug.ui.launchConfigurations.AbstractVMInstallPage#finish()
	 */
	public boolean finish() {
		setFieldValuesToVM(fVM);
		fLibraryBlock.finish();
		return true;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.debug.ui.launchConfigurations.AbstractVMInstallPage#getSelection()
	 */
	public VMStandin getSelection() {
		return fVM;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jdt.debug.ui.launchConfigurations.AbstractVMInstallPage#setSelection(org.eclipse.jdt.launching.VMStandin)
	 */
	public void setSelection(VMStandin vm) {
		super.setSelection(vm);
		fVM = vm;
		fAutoDetectAttributes = vm.getJavadocLocation() == null;
		setTitle(JREMessages.StandardVMPage_1);
		setDescription(JREMessages.StandardVMPage_2);
	}
	
	/**
	 * initialize fields to the specified VM
	 * @param vm the VM to initialize from
	 */
	protected void setFieldValuesToVM(VMStandin vm) {
		File dir = new File(fJRERoot.getText());
		try {
			vm.setInstallLocation(dir.getCanonicalFile());
		} 
		catch (IOException e) {
			vm.setInstallLocation(dir.getAbsoluteFile());
		}
		vm.setName(fVMName.getText());
		vm.setJavadocLocation(getURL());
		
		String argString = fVMArgs.getText().trim();
		if (argString != null && argString.length() > 0) {
			vm.setVMArgs(argString);			
		} 
		else {
			vm.setVMArgs(null);
		} 
	}
	
	/**
	 * Returns the URL for the javadoc location
	 * @return the URL for the javadoc location
	 */
	protected URL getURL() {
		return fJavadocLocation;
	}
	
	/**
	 * Creates a unique name for the VMInstallType
	 * @param vmType the vm install type
	 * @return a unique name
	 */
	protected static String createUniqueId(IVMInstallType vmType) {
		String id = null;
		do {
			id = String.valueOf(System.currentTimeMillis());
		} while (vmType.findVMInstall(id) != null);
		return id;
	}	
	
	/**
	 * Initialize the dialogs fields
	 */
	private void initializeFields() {
		fLibraryBlock.setSelection(fVM);
		fVMName.setText(fVM.getName());
		File installLocation = fVM.getInstallLocation();
		if (installLocation != null) {
			fJRERoot.setText(installLocation.getAbsolutePath());
		}
		String vmArgs = fVM.getVMArgs();
		if (vmArgs != null) {
			fVMArgs.setText(vmArgs);
		}
		validateVMName();
		validateJRELocation();
	}	
	
	/**
	 * Sets the status of the JRE location field.
	 * 
	 * @param status JRE location status
	 */
	private void setJRELocationStatus(IStatus status) {
		fFieldStatus[0] = status;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.dialogs.DialogPage#getErrorMessage()
	 */
	public String getErrorMessage() {
		String message = super.getErrorMessage();
		if (message == null) {
			return fLibraryBlock.getErrorMessage();
		}
		return message;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.wizard.WizardPage#isPageComplete()
	 */
	public boolean isPageComplete() {
		boolean complete = super.isPageComplete();
		if (complete) {
			return fLibraryBlock.isPageComplete();
		}
		return complete;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.debug.ui.launchConfigurations.AbstractVMInstallPage#getVMStatus()
	 */
	protected IStatus[] getVMStatus() {
		return fFieldStatus;
	}
	
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.debug.ui.launchConfigurations;

import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.jdt.internal.debug.ui.JDIDebugUIPlugin;
import org.eclipse.jdt.internal.debug.ui.jres.JREMessages;
import org.eclipse.jdt.launching.VMStandin;
import org.eclipse.jface.dialogs.IMessageProvider;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.wizard.IWizardPage;
import org.eclipse.jface.wizard.WizardPage;

import com.ibm.icu.text.MessageFormat;

/**
 * A wizard page used to edit the attributes of an installed JRE. A page is 
 * provided by JDT to edit standard JREs, but clients may contribute a custom
 * page for a VM install type if required.
 * <p>
 * A VM install page is contributed via the <code>vmInstallPages</code> extension
 * point. Following is an example definition of a VM install page.
 * <pre>
 * &lt;extension point="org.eclipse.jdt.debug.ui.vmInstallPages"&gt;
 *   &lt;vmInstallPage 
 *      vmInstallType="org.eclipse.jdt.launching.EEVMType"
 *      class="org.eclipse.jdt.internal.debug.ui.jres.EEVMPage"&gt;
 *   &lt;/vmInstallPage&gt;
 * &lt;/extension&gt;
 * </pre>
 * The attributes are specified as follows:
 * <ul>
 * <li><code>vmInstallType</code> Specifies the VM install type this wizard page is to be used for.
 * 	Unique identifier corresponding to an <code>IVMInstallType</code>'s id.</li>
 * <li><code>class</code> Wizard page implementation. Must be a subclass of
 *  <code>org.eclipse.jdt.debug.ui.launchConfigurations.AbstractVMInstallPage</code>.</li>
 * </ul>
 * </p>
 * <p>
 * Clients contributing a custom VM install page via the <code>vmInstallPages</code> 
 * extension point must subclass this class.
 * </p>
 * @since 3.4
 */
public abstract class AbstractVMInstallPage extends WizardPage {
	
	/**
	 * Name of the original VM being edited, or <code>null</code> if none.
	 */
	private String fOriginalName = null;
	
	/**
	 * Status of VM name (to notify of name already in use)
	 */
	private IStatus fNameStatus = Status.OK_STATUS;
	
	private String[] fExistingNames;
		
	/**
	 * Constructs a new page with the given page name.
	 * 
	 * @param pageName the name of the page
	 */
	protected AbstractVMInstallPage(String pageName) {
		super(pageName);
	}

	/**
     * Creates a new wizard page with the given name, title, and image.
     *
     * @param pageName the name of the page
     * @param title the title for this wizard page,
     *   or <code>null</code> if none
     * @param titleImage the image descriptor for the title of this wizard page,
     *   or <code>null</code> if none
     */
	protected AbstractVMInstallPage(String pageName, String title, ImageDescriptor titleImage) {
		super(pageName, title, titleImage);
	}

	/**
	 * Called when the VM install page wizard is closed by selecting 
	 * the finish button. Implementers typically override this method to 
	 * store the page result (new/changed vm install returned in 
	 * getSelection) into its model.
	 * 
	 * @return if the operation was successful. Only when returned
	 * <code>true</code>, the wizard will close.
	 */
	public abstract boolean finish();
	
	/**
	 * Returns the edited or created VM install. This method
	 * may return <code>null</code> if no VM install exists.
	 * 
	 * @return the edited or created VM install.
	 */
	public abstract VMStandin getSelection();

	/**
	 * Sets the VM install to be edited. 
	 * 
	 * @param vm the VM install to edit
	 */
	public void setSelection(VMStandin vm) {
		fOriginalName = vm.getName();
	}
	
	/**
	 * Updates the name status based on the new name. This method should be called
	 * by the page each time the VM name changes.
	 * 
	 * @param newName new name of VM
	 */
	protected void nameChanged(String newName) {
		fNameStatus = Status.OK_STATUS;
		if (newName == null || newName.trim().length() == 0) {
			int sev = IStatus.ERROR;
			if (fOriginalName == null || fOriginalName.length() == 0) {
				sev = IStatus.INFO;
			}
			fNameStatus = new Status(sev, JDIDebugUIPlugin.getUniqueIdentifier(), JREMessages.addVMDialog_enterName);
		} else {
			if (isDuplicateName(newName)) {
				fNameStatus = new Status(IStatus.ERROR, JDIDebugUIPlugin.getUniqueIdentifier(), JREMessages.addVMDialog_duplicateName); 
			} else {
				IStatus s = ResourcesPlugin.getWorkspace().validateName(newName, IResource.FILE);
				if (!s.isOK()) {
					fNameStatus = new Status(IStatus.ERROR, JDIDebugUIPlugin.getUniqueIdentifier(), MessageFormat.format(JREMessages.AddVMDialog_JRE_name_must_be_a_valid_file_name___0__1, new String[]{s.getMessage()})); 
				}
			}
		}
		updatePageStatus();
	}
	
	/**
	 * Returns whether the name is already in use by an existing VM
	 * 
	 * @param name new name
	 * @return whether the name is already in use
	 */
	private boolean isDuplicateName(String name) {
		if (fExistingNames != null) {
			for (int i = 0; i < fExistingNames.length; i++) {
				if (name.equals(fExistingNames[i])) {
					return true;
				}
			}
		}
		return false;
	}	
	
	/**
	 * Sets the names of existing VMs, not including the VM being edited. This method
	 * is called by the wizard and clients should not call this method.
	 * 
	 * @param names existing VM names or an empty array
	 */
	public void setExistingNames(String[] names) {
		fExistingNames = names;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.wizard.WizardPage#getNextPage()
	 */
	public IWizardPage getNextPage() {
		return null;
	}
	
	/**
	 * Sets this page's message based on the status severity.
	 * 
	 * @param status status with message and severity
	 */
	protected void setStatusMessage(IStatus status) {
		if (status.isOK()) {
			setMessage(status.getMessage());
		} else {
			switch (status.getSeverity()) {
			case IStatus.ERROR:
				setMessage(status.getMessage(), IMessageProvider.ERROR);
				break;
			case IStatus.INFO:
				setMessage(status.getMessage(), IMessageProvider.INFORMATION);
				break;
			case IStatus.WARNING:
				setMessage(status.getMessage(), IMessageProvider.WARNING);
				break;
			default:
				break;
			}
		}
	}	
	
	/**
	 * Returns the current status of the name being used for the VM.
	 * 
	 * @return status of current VM name
	 */
	protected IStatus getNameStatus() {
		return fNameStatus;
	}
	
	/**
	 * Updates the status message on the page, based on the status of the VM and other
	 * status provided by the page.
	 */
	protected void updatePageStatus() {
		IStatus max = Status.OK_STATUS;
		IStatus[] vmStatus = getVMStatus();
		for (int i = 0; i < vmStatus.length; i++) {
			IStatus status = vmStatus[i];
			if (status.getSeverity() > max.getSeverity()) {
				max = status;
			}
		}
		if (fNameStatus.getSeverity() > max.getSeverity()) {
			max = fNameStatus;
		}
		if (max.isOK()) {
			setMessage(null, IMessageProvider.NONE);
			setPageComplete(true);
		} else {
			setStatusMessage(max);
			setPageComplete(false);
		}
	}	
	
	/**
	 * Returns a collection of status messages pertaining to the current edit
	 * status of the VM on this page. An empty collection or a collection of
	 * OK status objects indicates all is well.
	 * 
	 * @return collection of status objects for this page
	 */
	protected abstract IStatus[] getVMStatus();
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.debug.ui.jres;

import org.eclipse.jdt.debug.ui.launchConfigurations.AbstractVMInstallPage;
import org.eclipse.jdt.launching.IVMInstall;
import org.eclipse.jdt.launching.VMStandin;

/**
 * @since 3.4
 */
public class EditVMInstallWizard extends VMInstallWizard {
	
	private AbstractVMInstallPage fEditPage;
	
	/**
	 * Constructs a wizard to edit the given vm.
	 * 
	 * @param vm vm to edit
	 * @param allVMs all VMs being edited
	 */
	public EditVMInstallWizard(VMStandin vm, IVMInstall[] allVMs) {
		super(vm, allVMs);
		setWindowTitle(JREMessages.EditVMInstallWizard_0);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.wizard.Wizard#addPages()
	 */
	public void addPages() {
		fEditPage = getPage(getVMInstall().getVMInstallType());
		fEditPage.setSelection(new VMStandin(getVMInstall()));
		addPage(fEditPage);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.wizard.Wizard#performFinish()
	 */
	public boolean performFinish() {
		if (fEditPage.finish()) {
			return super.performFinish();
		}
		return false;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.internal.debug.ui.jres.VMInstallWizard#getResult()
	 */
	protected VMStandin getResult() {
		return fEditPage.getSelection();
	}

	
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.debug.ui.jres;

import org.eclipse.jdt.debug.ui.launchConfigurations.AbstractVMInstallPage;
import org.eclipse.jdt.launching.IVMInstall;
import org.eclipse.jdt.launching.VMStandin;
import org.eclipse.jface.wizard.IWizardPage;

/**
 * @since 3.4
 */
public class AddVMInstallWizard extends VMInstallWizard {
	
	private IWizardPage fTypePage = null;
	
	private VMStandin fResult = null;

	/**
	 * Constructs a wizard to add a new VM install.
	 * 
	 * @param currentInstalls currently existing VMs, used for name validation
	 */
	public AddVMInstallWizard(IVMInstall[] currentInstalls) {
		super(null, currentInstalls);
		setForcePreviousAndNextButtons(true);
		setWindowTitle(JREMessages.AddVMInstallWizard_0);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.wizard.Wizard#addPages()
	 */
	public void addPages() {
		fTypePage = new VMTypePage();
		addPage(fTypePage);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.internal.debug.ui.jres.VMInstallWizard#getResult()
	 */
	protected VMStandin getResult() {
		return fResult;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.internal.debug.ui.jres.VMInstallWizard#canFinish()
	 */
	public boolean canFinish() {
		IWizardPage currentPage = getContainer().getCurrentPage();
		return currentPage != fTypePage && super.canFinish() && currentPage.isPageComplete();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.internal.debug.ui.jres.VMInstallWizard#performFinish()
	 */
	public boolean performFinish() {
		IWizardPage currentPage = getContainer().getCurrentPage();
		if (currentPage instanceof AbstractVMInstallPage) {
			AbstractVMInstallPage page = (AbstractVMInstallPage) currentPage;
			boolean finish = page.finish();
			fResult = page.getSelection();
			return finish;
		}
		return false;
	}

	
	
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.debug.ui.jres;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jdt.debug.ui.IJavaDebugUIConstants;
import org.eclipse.jdt.debug.ui.launchConfigurations.AbstractVMInstallPage;
import org.eclipse.jdt.internal.debug.ui.JDIDebugUIPlugin;
import org.eclipse.jdt.launching.IVMInstall;
import org.eclipse.jdt.launching.IVMInstallType;
import org.eclipse.jdt.launching.VMStandin;
import org.eclipse.jface.wizard.Wizard;

/**
 * 
 */
public abstract class VMInstallWizard extends Wizard {
	
	private VMStandin fEditVM;
	private String[] fExistingNames;
	
	/**
	 * Constructs a new wizard to add/edit a vm install.
	 * 
	 * @param editVM the VM being edited, or <code>null</code> if none
	 * @param currentInstalls current VM installs used to validate name changes
	 */
	public VMInstallWizard(VMStandin editVM, IVMInstall[] currentInstalls) {
		fEditVM = editVM;
		List names = new ArrayList(currentInstalls.length);
		for (int i = 0; i < currentInstalls.length; i++) {
			IVMInstall install = currentInstalls[i];
			if (!install.equals(editVM)) {
				names.add(install.getName());
			}
		}
		fExistingNames = (String[]) names.toArray(new String[names.size()]);
	}
	
	/**
	 * Returns the VM to edit, or <code>null</code> if creating a VM
	 * 
	 * @return vm to edit or <code>null</code>
	 */
	protected VMStandin getVMInstall() {
		return fEditVM;
	}
	
	/**
	 * Returns the resulting VM after edit or creation or <code>null</code> if none.
	 * 
	 * @return resulting VM
	 */
	protected abstract VMStandin getResult();

	/* (non-Javadoc)
	 * @see org.eclipse.jface.wizard.Wizard#performFinish()
	 */
	public boolean performFinish() {
		return getResult() != null;
	}
	
	/**
	 * Returns a page to use for editing a VM install type
	 * 
	 * @param type
	 * @return
	 */
	public AbstractVMInstallPage getPage(IVMInstallType type) {
		IExtensionPoint extensionPoint = Platform.getExtensionRegistry().getExtensionPoint(JDIDebugUIPlugin.getUniqueIdentifier(), IJavaDebugUIConstants.EXTENSION_POINT_VM_INSTALL_PAGES);
		IConfigurationElement[] infos= extensionPoint.getConfigurationElements();
		for (int i = 0; i < infos.length; i++) {
			IConfigurationElement element = infos[i];
			String id = element.getAttribute("vmInstallType"); //$NON-NLS-1$
			if (type.getId().equals(id)) {
				try {
					AbstractVMInstallPage page = (AbstractVMInstallPage) element.createExecutableExtension("class"); //$NON-NLS-1$
					page.setExistingNames(fExistingNames);
					return page;
				} catch (CoreException e) {
					JDIDebugUIPlugin.log(e);
				}
			}
		}
		StandardVMPage standardVMPage = new StandardVMPage();
		standardVMPage.setExistingNames(fExistingNames);
		return standardVMPage;
	}

}

Return to bug 201758

Lines 41-50 Link Here

(-)launching/org/eclipse/jdt/internal/launching/StandardVM.java (-4 / +16 lines)
41	StandardVMType installType = (StandardVMType) getVMInstallType();	41	StandardVMType installType = (StandardVMType) getVMInstallType();
42	File installLocation = getInstallLocation();	42	File installLocation = getInstallLocation();
43	if (installLocation != null) {	43	if (installLocation != null) {
44	if (EEVMType.isEEInstall(installLocation)) {	44	File executable = getJavaExecutable();
45	return EEVMType.getJavaVersion(installLocation);
46	}
47	File executable = StandardVMType.findJavaExecutable(installLocation);
48	if (executable != null) {	45	if (executable != null) {
49	String vmVersion = installType.getVMVersion(installLocation, executable);	46	String vmVersion = installType.getVMVersion(installLocation, executable);
50	// strip off extra info	47	// strip off extra info
Lines 64-67 Link Here
64	}	61	}
65	return null;	62	return null;
66	}	63	}
		64
		65	/**
		66	* Returns the java executable for this VM or <code>null</code> if cannot be found
		67	*
		68	* @return executable for this VM or <code>null</code> if none
		69	*/
		70	File getJavaExecutable() {
		71	File installLocation = getInstallLocation();
		72	if (installLocation != null) {
		73	return StandardVMType.findJavaExecutable(installLocation);
		74	}
		75	return null;
		76	}
		77
		78
67	}	79	}

Lines 49-54 Link Here

(-)launching/org/eclipse/jdt/internal/launching/LaunchingMessages.properties (+3 lines)
49	JavaRuntime_Could_not_resolve_classpath_container___0__1=Could not resolve classpath container: {0}	49	JavaRuntime_Could_not_resolve_classpath_container___0__1=Could not resolve classpath container: {0}
50	JavaRuntime_Classpath_references_non_existant_project___0__3=The project: {0} which is referenced by the classpath, does not exist.	50	JavaRuntime_Classpath_references_non_existant_project___0__3=The project: {0} which is referenced by the classpath, does not exist.
51	JavaRuntime_Classpath_references_non_existant_archive___0__4=The archive: {0} which is referenced by the classpath, does not exist.	51	JavaRuntime_Classpath_references_non_existant_archive___0__4=The archive: {0} which is referenced by the classpath, does not exist.
		52	JavaRuntime_24=Failed to create installed JRE
52	JavaRuntime_26=Referenced classpath provider does not exist: {0}	53	JavaRuntime_26=Referenced classpath provider does not exist: {0}
53	JavaRuntime_27=Referenced source lookup provider does not exist: {0}	54	JavaRuntime_27=Referenced source lookup provider does not exist: {0}
54	JavaRuntime_28=Launch configuration {0} references closed project {1}	55	JavaRuntime_28=Launch configuration {0} references closed project {1}
Lines 177-182 Link Here
177	PackageFragmentRootSourceContainerTypeDelegate_8=Missing required <packageFragmentRoot> attribute	178	PackageFragmentRootSourceContainerTypeDelegate_8=Missing required <packageFragmentRoot> attribute
178	EEVMType_0={0} is not a valid .ee property file	179	EEVMType_0={0} is not a valid .ee property file
179	EEVMType_1={0} missing required property ''{1}''	180	EEVMType_1={0} missing required property ''{1}''
		181	EEVMType_2=Execution Environment Description
		182	EEVMType_3=Unable to validate install location.
180	VMDefinitionsContainer_0=Installed JRE ''{0}'' removed due to missing VM type extension.	183	VMDefinitionsContainer_0=Installed JRE ''{0}'' removed due to missing VM type extension.
181	VMDefinitionsContainer_2=Installed JRE of type ''{0}'' removed due to missing VM type extension.	184	VMDefinitionsContainer_2=Installed JRE of type ''{0}'' removed due to missing VM type extension.
182	VMDefinitionsContainer_3=Installed JRE of type ''{0}'' removed due to missing install path and name.	185	VMDefinitionsContainer_3=Installed JRE of type ''{0}'' removed due to missing install path and name.

Lines 79-87 Link Here

(-)launching/org/eclipse/jdt/internal/launching/StandardVMType.java (-31 / +7 lines)
79	* <code>null</code>.	79	* <code>null</code>.
80	*/	80	*/
81	public static File findJavaExecutable(File vmInstallLocation) {	81	public static File findJavaExecutable(File vmInstallLocation) {
82	if (EEVMType.isEEInstall(vmInstallLocation)) {
83	return EEVMType.getExecutable(vmInstallLocation);
84	}
85	// Try each candidate in order. The first one found wins. Thus, the order	82	// Try each candidate in order. The first one found wins. Thus, the order
86	// of fgCandidateJavaLocations and fgCandidateJavaFiles is significant.	83	// of fgCandidateJavaLocations and fgCandidateJavaFiles is significant.
87	for (int i = 0; i < fgCandidateJavaFiles.length; i++) {	84	for (int i = 0; i < fgCandidateJavaFiles.length; i++) {
Lines 282-291 Link Here
282	* @see org.eclipse.jdt.launching.IVMInstallType#getDefaultLibraryLocations(File)	279	* @see org.eclipse.jdt.launching.IVMInstallType#getDefaultLibraryLocations(File)
283	*/	280	*/
284	public LibraryLocation[] getDefaultLibraryLocations(File installLocation) {	281	public LibraryLocation[] getDefaultLibraryLocations(File installLocation) {
285	if (EEVMType.isEEInstall(installLocation)) {
286	return EEVMType.getDefaultLibraryLocations(installLocation);
287	}
288
289	// Determine the java executable that corresponds to the specified install location	282	// Determine the java executable that corresponds to the specified install location
290	// and use this to generate library information. If no java executable was found,	283	// and use this to generate library information. If no java executable was found,
291	// the 'standard' libraries will be returned.	284	// the 'standard' libraries will be returned.
Lines 446-454 Link Here
446	* @see org.eclipse.jdt.launching.IVMInstallType#validateInstallLocation(java.io.File)	439	* @see org.eclipse.jdt.launching.IVMInstallType#validateInstallLocation(java.io.File)
447	*/	440	*/
448	public IStatus validateInstallLocation(File javaHome) {	441	public IStatus validateInstallLocation(File javaHome) {
449	if (EEVMType.isEEInstall(javaHome)) {
450	return EEVMType.validateInstallLocation(javaHome);
451	}
452	IStatus status = null;	442	IStatus status = null;
453	if (Platform.getOS().equals(Constants.OS_MACOSX)) {	443	if (Platform.getOS().equals(Constants.OS_MACOSX)) {
454	status = new Status(IStatus.ERROR, LaunchingPlugin.getUniqueIdentifier(), 0, LaunchingMessages.StandardVMType_Standard_VM_not_supported_on_MacOS__1, null);	444	status = new Status(IStatus.ERROR, LaunchingPlugin.getUniqueIdentifier(), 0, LaunchingMessages.StandardVMType_Standard_VM_not_supported_on_MacOS__1, null);
Lines 602-630 Link Here
602	* @see org.eclipse.jdt.launching.AbstractVMInstallType#getDefaultJavadocLocation(java.io.File)	592	* @see org.eclipse.jdt.launching.AbstractVMInstallType#getDefaultJavadocLocation(java.io.File)
603	*/	593	*/
604	public URL getDefaultJavadocLocation(File installLocation) {	594	public URL getDefaultJavadocLocation(File installLocation) {
605	if (EEVMType.isEEInstall(installLocation)) {	595	File javaExecutable = findJavaExecutable(installLocation);
606	return EEVMType.getDefaultJavadocLocation(installLocation);	596	if (javaExecutable != null) {
607	} else {	597	LibraryInfo libInfo = getLibraryInfo(installLocation, javaExecutable);
608	File javaExecutable = findJavaExecutable(installLocation);	598	if (libInfo != null) {
609	if (javaExecutable != null) {	599	String version = libInfo.getVersion();
610	LibraryInfo libInfo = getLibraryInfo(installLocation, javaExecutable);	600	return getDefaultJavadocLocation(version);
611	if (libInfo != null) {
612	String version = libInfo.getVersion();
613	return getDefaultJavadocLocation(version);
614	}
615	}	601	}
616	return null;
617	}	602	}
618	}	603	return null;
619
620	/* (non-Javadoc)
621	* @see org.eclipse.jdt.launching.AbstractVMInstallType#getDefaultVMArguments(java.io.File)
622	*/
623	public String getDefaultVMArguments(File installLocation) {
624	if (EEVMType.isEEInstall(installLocation)) {
625	return EEVMType.getDefaultVMArguments(installLocation);
626	}
627	return super.getDefaultVMArguments(installLocation);
628	}	604	}
629		605
630	/**	606	/**

Lines 23-28 Link Here

(-)launching/org/eclipse/jdt/internal/launching/VMDefinitionsContainer.java (-3 / +33 lines)
23	import java.util.List;	23	import java.util.List;
24	import java.util.Map;	24	import java.util.Map;
25	import java.util.Set;	25	import java.util.Set;
		26	import java.util.Map.Entry;
26		27
27	import javax.xml.parsers.DocumentBuilder;	28	import javax.xml.parsers.DocumentBuilder;
28	import javax.xml.parsers.DocumentBuilderFactory;	29	import javax.xml.parsers.DocumentBuilderFactory;
Lines 35-40 Link Here
35	import org.eclipse.core.runtime.Path;	36	import org.eclipse.core.runtime.Path;
36	import org.eclipse.core.runtime.Status;	37	import org.eclipse.core.runtime.Status;
37	import org.eclipse.debug.core.DebugPlugin;	38	import org.eclipse.debug.core.DebugPlugin;
		39	import org.eclipse.jdt.launching.AbstractVMInstall;
38	import org.eclipse.jdt.launching.IVMInstall;	40	import org.eclipse.jdt.launching.IVMInstall;
39	import org.eclipse.jdt.launching.IVMInstall2;	41	import org.eclipse.jdt.launching.IVMInstall2;
40	import org.eclipse.jdt.launching.IVMInstallType;	42	import org.eclipse.jdt.launching.IVMInstallType;
Lines 130-136 Link Here
130	}	132	}
131	vmList.add(vm);	133	vmList.add(vm);
132	File installLocation = vm.getInstallLocation();	134	File installLocation = vm.getInstallLocation();
133	if (installLocation == null \|\| !vmInstallType.validateInstallLocation(installLocation).isOK()) {	135	if (installLocation == null \|\| vmInstallType.validateInstallLocation(installLocation).getSeverity() == IStatus.ERROR) {
134	fInvalidVMList.add(vm);	136	fInvalidVMList.add(vm);
135	}	137	}
136	fVMList.add(vm);	138	fVMList.add(vm);
Lines 344-349 Link Here
344	}	346	}
345	}	347	}
346		348
		349	// vm attributes
		350	if (vm instanceof AbstractVMInstall) {
		351	Map attributes = ((AbstractVMInstall)vm).getAttributes();
		352	if (!attributes.isEmpty()) {
		353	Element attrElement = doc.createElement("attributeMap"); //$NON-NLS-1$
		354	Iterator iterator = attributes.entrySet().iterator();
		355	while (iterator.hasNext()) {
		356	Entry entry = (Entry) iterator.next();
		357	Element entryElement = doc.createElement("entry"); //$NON-NLS-1$
		358	entryElement.setAttribute("key", (String)entry.getKey()); //$NON-NLS-1$
		359	entryElement.setAttribute("value", (String)entry.getValue()); //$NON-NLS-1$
		360	attrElement.appendChild(entryElement);
		361	}
		362	element.appendChild(attrElement);
		363	}
		364	}
		365
347	return element;	366	return element;
348	}	367	}
349		368
Lines 534-543 Link Here
534	if (subElementName.equals("libraryLocation")) { //$NON-NLS-1$	553	if (subElementName.equals("libraryLocation")) { //$NON-NLS-1$
535	LibraryLocation loc = getLibraryLocation(subElement);	554	LibraryLocation loc = getLibraryLocation(subElement);
536	vmStandin.setLibraryLocations(new LibraryLocation[]{loc});	555	vmStandin.setLibraryLocations(new LibraryLocation[]{loc});
537	break;
538	} else if (subElementName.equals("libraryLocations")) { //$NON-NLS-1$	556	} else if (subElementName.equals("libraryLocations")) { //$NON-NLS-1$
539	setLibraryLocations(vmStandin, subElement);	557	setLibraryLocations(vmStandin, subElement);
540	break;	558	} else if (subElementName.equals("attributeMap")) { //$NON-NLS-1$
		559	NodeList entries = subElement.getElementsByTagName("entry"); //$NON-NLS-1$
		560	for (int j = 0; j < entries.getLength(); j++) {
		561	Node entryNode = entries.item(j);
		562	if (entryNode instanceof Element) {
		563	Element entryElement = (Element) entryNode;
		564	String key = entryElement.getAttribute("key"); //$NON-NLS-1$
		565	String value = entryElement.getAttribute("value"); //$NON-NLS-1$
		566	if (key != null && value != null) {
		567	vmStandin.setAttribute(key, value);
		568	}
		569	}
		570	}
541	}	571	}
542	}	572	}
543	}	573	}

Lines 68-95 Link Here

(-)launching/org/eclipse/jdt/launching/IVMInstall.java (-15 / +4 lines)
68	void setName(String name);	68	void setName(String name);
69	/**	69	/**
70	* Returns the root directory of the install location of this VM.	70	* Returns the root directory of the install location of this VM.
71	* <p>	71	*
72	* Since 3.4, this may also be a file describing a VM install.
73	* For example, the standard VM installs support execution
74	* environment description files, as described by
75	* <code>http://wiki.eclipse.org/index.php/Execution_Environment_Descriptions</code>.
76	* </p>
77	* @return the root directory of this VM installation. May	72	* @return the root directory of this VM installation. May
78	* return <code>null</code>.	73	* return <code>null</code>.
79	*/	74	*/
80	File getInstallLocation();	75	File getInstallLocation();
81	/**	76	/**
82	* Sets the root directory of the install location of this VM.	77	* Sets the root directory of the install location of this VM.
83	* <p>	78	*
84	* Since 3.4, this may also be a file describing a VM install.	79	* @param installLocation the root directory of this VM installation
85	* For example, the standard VM installs support execution
86	* environment description files, as described by
87	* <code>http://wiki.eclipse.org/index.php/Execution_Environment_Descriptions</code>.
88	* </p>
89	* @param installLocationOrDefinitionFile the root directory or definition file for
90	* this VM installation
91	*/	80	*/
92	void setInstallLocation(File installLocationOrDefinitionFile);	81	void setInstallLocation(File installLocation);
93		82
94	/**	83	/**
95	* Returns the VM type of this VM.	84	* Returns the VM type of this VM.

Lines 88-107 Link Here

(-)launching/org/eclipse/jdt/launching/IVMInstallType.java (-18 / +7 lines)
88	/**	88	/**
89	* Validates the given location of a VM installation.	89	* Validates the given location of a VM installation.
90	* <p>	90	* <p>
91	* Since 3.4, the given installLocation may be a file (rather than a home
92	* directory). For example, the standard VM install type accepts execution
93	* environment description files, as described by
94	* <code>http://wiki.eclipse.org/index.php/Execution_Environment_Descriptions</code>.
95	* </p>
96	* <p>
97	* For example, an implementation might check whether the VM executable	91	* For example, an implementation might check whether the VM executable
98	* is present.	92	* is present.
99	* </p>	93	* </p>
100	* @param installLocationOrDefinitionFile the root directory of a potential installation for	94	*
101	* this type of VM or since 3.4, a file describing an installation	95	* @param installLocation the root directory of a potential installation for
		96	* this type of VM
102	* @return a status object describing whether the install location is valid	97	* @return a status object describing whether the install location is valid
103	*/	98	*/
104	IStatus validateInstallLocation(File installLocationOrDefinitionFile);	99	IStatus validateInstallLocation(File installLocation);
105		100
106	/**	101	/**
107	* Tries to detect an installed VM that matches this VM install type.	102	* Tries to detect an installed VM that matches this VM install type.
Lines 120-138 Link Here
120	* at the given <code>installLocation</code>.	115	* at the given <code>installLocation</code>.
121	* The returned <code>LibraryLocation</code>s may not exist if the	116	* The returned <code>LibraryLocation</code>s may not exist if the
122	* <code>installLocation</code> is not a valid install location.	117	* <code>installLocation</code> is not a valid install location.
123	* <p>	118	*
124	* Since 3.4, the given installLocation may be a file (rather than a home	119	* @param installLocation home location
125	* directory). For example, the standard VM install type accepts execution
126	* environment description files, as described by
127	* <code>http://wiki.eclipse.org/index.php/Execution_Environment_Descriptions</code>.
128	* </p>
129	* @param installLocationOrDefinitionFile home directory or since 3.4, a file
130	* describing an installation
131	* @see LibraryLocation	120	* @see LibraryLocation
132	* @see IVMInstallType#validateInstallLocation(File)	121	* @see IVMInstallType#validateInstallLocation(File)
133	*	122	*
134	* @return default library locations based on the given <code>installLocation</code>.	123	* @return default library locations based on the given <code>installLocation</code>.
135	* @since 2.0	124	* @since 2.0
136	*/	125	*/
137	LibraryLocation[] getDefaultLibraryLocations(File installLocationOrDefinitionFile);	126	LibraryLocation[] getDefaultLibraryLocations(File installLocation);
138	}	127	}

Lines 157-185 Link Here

(-)launching/org/eclipse/jdt/launching/AbstractVMInstallType.java (-11 / +5 lines)
157	* implementation returns <code>null</code>, subclasses must override as	157	* implementation returns <code>null</code>, subclasses must override as
158	* appropriate.	158	* appropriate.
159	* <p>	159	* <p>
160	* Since 3.4, the argument may also be a file describing a VM install.
161	* For example, the standard VM installs support execution
162	* environment description files, as described by
163	* <code>http://wiki.eclipse.org/index.php/Execution_Environment_Descriptions</code>.
164	* </p>
165	* <p>
166	* Note, this method would ideally be added to <code>IVMInstallType</code>,	160	* Note, this method would ideally be added to <code>IVMInstallType</code>,
167	* but it would have been a breaking API change between 2.0 and 2.1. Thus,	161	* but it would have been a breaking API change between 2.0 and 2.1. Thus,
168	* it has been added to the abstract base class that VM install types should	162	* it has been added to the abstract base class that VM install types should
169	* subclass.	163	* subclass.
170	* </p>	164	* </p>
171	*	165	*
172	* @param installLocationOrDefinitionFile home location or since 3.4, a definition file	166	* @param installLocationOrDefinitionFile home location
173	* @return default javadoc location or <code>null</code>	167	* @return default javadoc location or <code>null</code>
174	* @since 2.1	168	* @since 2.1
175	*/	169	*/
176	public URL getDefaultJavadocLocation(File installLocationOrDefinitionFile) {	170	public URL getDefaultJavadocLocation(File installLocation) {
177	return null;	171	return null;
178	}	172	}
179		173
180	/**	174	/**
181	* Returns a string of default VM arguments for a VM installed at the	175	* Returns a string of default VM arguments for a VM installed at the
182	* given home location or definition file, or <code>null</code> if none.	176	* given home location, or <code>null</code> if none.
183	* The default implementation returns <code>null</code>, subclasses must override	177	* The default implementation returns <code>null</code>, subclasses must override
184	* as appropriate.	178	* as appropriate.
185	* <p>	179	* <p>
Lines 188-198 Link Here
188	* it has been added to the abstract base class that VM install types should	182	* it has been added to the abstract base class that VM install types should
189	* subclass.	183	* subclass.
190	* </p>	184	* </p>
191	* @param installLocationOrDefinitionFile home location or definition file	185	* @param installLocation home location
192	* @return default VM arguments or <code>null</code> if none	186	* @return default VM arguments or <code>null</code> if none
193	* @since 3.4	187	* @since 3.4
194	*/	188	*/
195	public String getDefaultVMArguments(File installLocationOrDefinitionFile) {	189	public String getDefaultVMArguments(File installLocation) {
196	return null;	190	return null;
197	}	191	}
198	}	192	}

Lines 65-70 Link Here

(-)schema/vmInstallTypes.exsd (-1 / +3 lines)
65	</complexType>	65	</complexType>
66	</element>	66	</element>
67		67
		68
68	<annotation>	69	<annotation>
69	<appInfo>	70	<appInfo>
70	<meta.section type="examples"/>	71	<meta.section type="examples"/>
Lines 85-97 Link Here
85	</documentation>	86	</documentation>
86	</annotation>	87	</annotation>
87		88
		89
88	<annotation>	90	<annotation>
89	<appInfo>	91	<appInfo>
90	<meta.section type="implementation"/>	92	<meta.section type="implementation"/>
91	</appInfo>	93	</appInfo>
92	<documentation>	94	<documentation>
93	Abstract implementations of IVMInstall and IVMInstallType are provided. The Java Development Tools Launching Support plug-in defines a VM	95	Abstract implementations of IVMInstall and IVMInstallType are provided. The Java Development Tools Launching Support plug-in defines a VM
94	install type for the standard 1.1.* and 1.2/1.3/1.4 level <b>JRE</b>.	96	install type for the standard 1.1.* level JRE, and an install type for JREs conforming to standard command line options (1.2, 1.3, 1.4, 5.0, 6.0, and 7.0 level JREs). As well an install type is provided for JREs defined by an <a href=" http://wiki.eclipse.org/index.php/Execution_Environment_Descriptions">execution environment description</a> file.
95	</documentation>	97	</documentation>
96	</annotation>	98	</annotation>
97		99

Lines 71-77 Link Here

(-)schema/vmInstalls.exsd (-1 / +15 lines)
71	<attribute name="home" type="string" use="required">	71	<attribute name="home" type="string" use="required">
72	<annotation>	72	<annotation>
73	<documentation>	73	<documentation>
74	Path to the home installation directory for this VM install. Paths must be absolute and may use string substitution variables such as ${eclipse_home}. Since 3.4, this attribute may reference a VM definition file in addition to a home directory. The standard VM type included with the SDK supports <a href=" http://wiki.eclipse.org/index.php/Execution_Environment_Descriptions">execution environment descriptions</a>.	74	Path to the home installation directory for this VM install. Paths must be absolute and may use string substitution variables such as ${eclipse_home}. Since 3.4, this attribute may reference a VM definition file in addition to a home directory. The Execution Environment VM type included with the SDK supports <a href=" http://wiki.eclipse.org/index.php/Execution_Environment_Descriptions">execution environment descriptions</a>. When an execution environment description file is specified, any library elements are ignored. In this case, libraries are defined by the execution environment description file.
75	</documentation>	75	</documentation>
76	</annotation>	76	</annotation>
77	</attribute>	77	</attribute>
Lines 151-156 Link Here
151	</extension>	151	</extension>
152	</pre>	152	</pre>
153	</p>	153	</p>
		154	<p>
		155	The following example will create a JRE definition based on the contents of the specified execution environment description file. When an execution environment description file is provided as the home location the "Execution Environment Description" VM type must be specified for the <code>vmInstallType</code> attribute.
		156	</p>
		157	<p>
		158	<pre>
		159	<extension point="org.eclipse.jdt.launching.vmInstalls">
		160	<vmInstall
		161	home="${eclipse_home}/jre-def.ee"
		162	id="com.example.ee.id"
		163	name="Default JRE"
		164	vmInstallType="org.eclipse.jdt.launching.EEVMType"/>
		165	</extension>
		166	</pre>
		167	</p>
154	</documentation>	168	</documentation>
155	</annotation>	169	</annotation>
156		170

Added Link Here

(-)launching/org/eclipse/jdt/internal/launching/EEVMInstall.java (+74 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jdt.internal.launching;
12
13	import java.io.File;
14
15	import org.eclipse.jdt.launching.IVMInstallType;
16
17	/**
18	* A VM install created from an execution environment description file.
19	*
20	* @since 3.4
21	*/
22	public class EEVMInstall extends StandardVM {
23
24	/**
25	* Attribute key for Java version property
26	*/
27	public static final String ATTR_JAVA_VERSION = "ATTR_JAVA_VERSION"; //$NON-NLS-1$
28
29	/**
30	* Attribute key for supported execution environment by this runtime
31	*/
32	public static final String ATTR_EXECUTION_ENVIRONMENT_ID = "ATTR_EXECUTION_ENVIRONMENT_ID"; //$NON-NLS-1$
33
34	/**
35	* Attribute key for Java executable used by this VM
36	*/
37	public static final String ATTR_JAVA_EXE = "ATTR_JAVA_EXE"; //$NON-NLS-1$
38
39	/**
40	* Path to file used to define the JRE
41	*/
42	public static final String ATTR_DEFINITION_FILE = "ATTR_DEFINITION_FILE"; //$NON-NLS-1$
43
44	/**
45	* Constructs a VM install.
46	*
47	* @param type vm type
48	* @param id unique id
49	*/
50	EEVMInstall(IVMInstallType type, String id) {
51	super(type, id);
52	}
53
54	/* (non-Javadoc)
55	* @see org.eclipse.jdt.internal.launching.StandardVM#getJavaVersion()
56	*/
57	public String getJavaVersion() {
58	return getAttribute(ATTR_JAVA_VERSION);
59	}
60
61	/* (non-Javadoc)
62	* @see org.eclipse.jdt.internal.launching.StandardVM#getJavaExecutable()
63	*/
64	File getJavaExecutable() {
65	String exe = getAttribute(ATTR_JAVA_EXE);
66	if (exe != null) {
67	return new File(exe);
68	}
69	return null;
70	}
71
72
73
74	}

Lines 42-62 Link Here

(-)buildnotes_jdt-debug.html (-19 / +15 lines)
42		42
43	<h3>Support for Execution Environment Descriptions</h3>	43	<h3>Support for Execution Environment Descriptions</h3>
44	<p>An installed JRE can be defined by an <a href="http://wiki.eclipse.org/index.php/Execution_Environment_Descriptions">execution	44	<p>An installed JRE can be defined by an <a href="http://wiki.eclipse.org/index.php/Execution_Environment_Descriptions">execution
45	environment description file</a>. The API for <code>IVMInstallType</code> and	45	environment description file</a>. A new 'Execution Environment Description'
46	<code>IVMInstall</code> have been augmented to allow for a file to be specified	46	VM install type shipped with the Eclipse SDK supports standard ".ee"
47	for an install location in addition to a home directory. The 'Standard VM Install	47	files.</p>
48	Type' shipped with the Eclipse SDK supports standard ".ee" files.</p>	48	<p>API has been added to <code>JavaRuntime</code> to create a VM from an execution
49	<p>This change effects the following methods in <code>IVMInstallType</code>, which	49	environment description file. A name and unique identifier must be provided
50	now accept the location of a description file as well as a home directory.</p>	50	to create a new JRE.</p>
51	<ul>	51	<ul>
52	<li><code>public IStatus validateInstallLocation(File installLocation)</code></li>	52	<li><code>public VMStandin createVMFromDefinitionFile(File eeFile, String name,
53	<li><code>public LibraryLocation[] getDefaultLibraryLocations(File installLocation)</code></li>	53	String id)</code></li>
54	</ul>
55	<p>This change effects the following methods in <code>IVMInstall</code>, which
56	can now accept/return a file as well as home directory.</p>
57	<ul>
58	<li><code>public File getInstallLocation()</code></li>
59	<li><code>public void setInstallLocation(File installLocation)</code></li>
60	</ul>	54	</ul>
61	<p>A new method has been added to <code>AbstractVMInstallType</code> to allow	55	<p>A new method has been added to <code>AbstractVMInstallType</code> to allow
62	default arguments to be provided for newly created VM installs. Ideally, this	56	default arguments to be provided for newly created VM installs. Ideally, this
Lines 68-78 Link Here
68	<ul>	62	<ul>
69	<li><code>public String getDefaultVMArguments(File installLocation)</code></li>	63	<li><code>public String getDefaultVMArguments(File installLocation)</code></li>
70	</ul>	64	</ul>
71	<p>As well, the specification of the following method in <code>AbstractVMInstallType</code>	65	<h3>Support for custom wizard pages used to edit VM installs</h3>
72	has been changed to allow a file to be supplied as an argument.</p>	66	<p>An new extension point (<code>org.eclipse.jdt.debug.ui.vmInstallPages</code>)
73	<ul>	67	allows a wizard page to be contributed for editing the properties of an <code>IVMInstall</code>.
74	<li><code>public URL getDefaultJavadocLocation(File installLocation)</code></li>	68	The page is used when adding or editing an installed JRE via user preference.
75	</ul>	69	A standard page is provided based on the <code>IVMInstallType</code> and <code>IVMInstall</code>
		70	interfaces. JDT contributes a page for editing a JRE based on an execution environment
		71	description file.</p>
76	<h3>Support for setting a range of values in array objects</h3>	72	<h3>Support for setting a range of values in array objects</h3>
77	<p>API has been added to <code>IJavaArray</code> to support setting ranges of	73	<p>API has been added to <code>IJavaArray</code> to support setting ranges of
78	values in the arrays. It is more efficient to set a range of values at once	74	values in the arrays. It is more efficient to set a range of values at once

Removed Link Here

(-)ui/org/eclipse/jdt/internal/debug/ui/jres/AddVMDialog.java (-659 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jdt.internal.debug.ui.jres;
12
13
14	import java.io.File;
15	import java.io.IOException;
16	import java.net.URL;
17	import java.util.Arrays;
18	import java.util.Comparator;
19
20	import org.eclipse.core.resources.IResource;
21	import org.eclipse.core.resources.ResourcesPlugin;
22	import org.eclipse.core.runtime.IPath;
23	import org.eclipse.core.runtime.IStatus;
24	import org.eclipse.core.runtime.Path;
25	import org.eclipse.core.runtime.Platform;
26	import org.eclipse.debug.core.DebugPlugin;
27	import org.eclipse.jdt.internal.debug.ui.IJavaDebugHelpContextIds;
28	import org.eclipse.jdt.internal.debug.ui.JDIDebugUIPlugin;
29	import org.eclipse.jdt.internal.debug.ui.SWTFactory;
30	import org.eclipse.jdt.internal.debug.ui.StatusInfo;
31	import org.eclipse.jdt.internal.launching.StandardVMType;
32	import org.eclipse.jdt.launching.AbstractVMInstallType;
33	import org.eclipse.jdt.launching.IVMInstall;
34	import org.eclipse.jdt.launching.IVMInstall2;
35	import org.eclipse.jdt.launching.IVMInstallType;
36	import org.eclipse.jdt.launching.VMStandin;
37	import org.eclipse.jface.dialogs.IDialogConstants;
38	import org.eclipse.jface.dialogs.IDialogSettings;
39	import org.eclipse.jface.dialogs.StatusDialog;
40	import org.eclipse.swt.SWT;
41	import org.eclipse.swt.custom.BusyIndicator;
42	import org.eclipse.swt.events.ModifyEvent;
43	import org.eclipse.swt.events.ModifyListener;
44	import org.eclipse.swt.events.SelectionEvent;
45	import org.eclipse.swt.events.SelectionListener;
46	import org.eclipse.swt.graphics.Point;
47	import org.eclipse.swt.layout.GridData;
48	import org.eclipse.swt.layout.GridLayout;
49	import org.eclipse.swt.widgets.Button;
50	import org.eclipse.swt.widgets.Combo;
51	import org.eclipse.swt.widgets.Composite;
52	import org.eclipse.swt.widgets.Control;
53	import org.eclipse.swt.widgets.DirectoryDialog;
54	import org.eclipse.swt.widgets.FileDialog;
55	import org.eclipse.swt.widgets.Shell;
56	import org.eclipse.swt.widgets.Text;
57	import org.eclipse.ui.PlatformUI;
58
59	import com.ibm.icu.text.MessageFormat;
60
61	/**
62	* Provides the Add VM dialog
63	*/
64	public class AddVMDialog extends StatusDialog {
65
66	/**
67	* VM install type id for OSX VMs
68	*/
69	public static final String MACOSX_VM_TYPE_ID = "org.eclipse.jdt.internal.launching.macosx.MacOSXType"; //$NON-NLS-1$
70
71	private IAddVMDialogRequestor fRequestor;
72	private IVMInstall fEditedVM;
73	private IVMInstallType[] fVMTypes;
74	private IVMInstallType fSelectedVMType;
75	private Combo fVMCombo;
76	private Text fVMName;
77	private Text fVMArgs;
78	private Text fJRERoot;
79	private Button fFileButton;
80	private VMLibraryBlock fLibraryBlock;
81	// the VM install's javadoc location
82	private URL fJavadocLocation = null;
83	private boolean fAutoDetectAttributes = false;
84	private IStatus[] fStatus;
85	private int fPrevIndex = -1;
86
87	/**
88	* Constructor
89	* @param requestor dialog validation requester
90	* @param shell the parent shell
91	* @param vmInstallTypes the types of VM installs
92	* @param editedVM the editedVM
93	*/
94	public AddVMDialog(IAddVMDialogRequestor requestor, Shell shell, IVMInstallType[] vmInstallTypes, IVMInstall editedVM) {
95	super(shell);
96	setShellStyle(getShellStyle() \| SWT.RESIZE);
97	fRequestor = requestor;
98	fStatus = new IStatus[5];
99	for (int i= 0; i < fStatus.length; i++) {
100	fStatus[i] = new StatusInfo();
101	}
102	fVMTypes = vmInstallTypes;
103	sortVMTypes();
104	int typeIndex = 0;
105	if (Platform.OS_MACOSX.equals(Platform.getOS())) {
106	// select OSX VM type by default
107	for (int i = 0; i < fVMTypes.length; i++) {
108	IVMInstallType type = fVMTypes[i];
109	if (type.getId().equals(MACOSX_VM_TYPE_ID)) {
110	typeIndex = i;
111	break;
112	}
113	}
114	}
115	fSelectedVMType = editedVM != null ? editedVM.getVMInstallType() : vmInstallTypes[typeIndex];
116	fEditedVM = editedVM;
117	//only detect the javadoc location if not already set
118	fAutoDetectAttributes = fEditedVM == null \|\| fEditedVM.getJavadocLocation() == null;
119	}
120
121	/**
122	* This method is used to sort the array of VM install types, placing
123	* the 'Standard VM' type first, if it exists
124	*
125	* @since 3.3.0
126	*/
127	private void sortVMTypes() {
128	Comparator compare = new Comparator() {
129	public int compare(Object o1, Object o2) {
130	if(o1 instanceof IVMInstallType && o2 instanceof IVMInstallType) {
131	return ((IVMInstallType) o1).getName().compareTo(((IVMInstallType) o2).getName());
132	}
133	return 0;
134	}
135	};
136	//first find the 'Standard VM' and set it at position 0
137	for(int i = 0; i < fVMTypes.length; i++) {
138	if(fVMTypes[i].getId().equals("org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType")) { //$NON-NLS-1$
139	if(i > 0) {
140	IVMInstallType tmp = fVMTypes[0];
141	fVMTypes[0] = fVMTypes[i];
142	fVMTypes[i] = tmp;
143	break;
144	}
145	else {
146	break;
147	}
148	}
149	}
150	if(fVMTypes[0].getId().equals("org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType")) { //$NON-NLS-1$
151	Arrays.sort(fVMTypes, 1, fVMTypes.length, compare);
152	}
153	else {
154	Arrays.sort(fVMTypes, compare);
155	}
156	}
157
158	/* (non-Javadoc)
159	* @see org.eclipse.jface.dialogs.StatusDialog#configureShell(org.eclipse.swt.widgets.Shell)
160	*/
161	protected void configureShell(Shell newShell) {
162	super.configureShell(newShell);
163	PlatformUI.getWorkbench().getHelpSystem().setHelp(newShell, IJavaDebugHelpContextIds.EDIT_JRE_DIALOG);
164	}
165
166	/**
167	* Returns the VM name from the text control
168	* @return
169	*/
170	protected String getVMName() {
171	return fVMName.getText();
172	}
173
174	/**
175	* Returns the installation location as a file from the JRE root text control
176	* @return the installation location as a file
177	*/
178	protected File getInstallLocation() {
179	return new File(fJRERoot.getText());
180	}
181
182	/* (non-Javadoc)
183	* @see org.eclipse.jface.dialogs.Dialog#createDialogArea(org.eclipse.swt.widgets.Composite)
184	*/
185	protected Control createDialogArea(Composite ancestor) {
186	Composite parent = (Composite)super.createDialogArea(ancestor);
187	((GridLayout)parent.getLayout()).numColumns = 3;
188	//VM type
189	SWTFactory.createLabel(parent, JREMessages.addVMDialog_jreType, 1);
190	fVMCombo = SWTFactory.createCombo(parent, SWT.READ_ONLY, 2, getVMTypeNames());
191	// VM location
192	SWTFactory.createLabel(parent, JREMessages.addVMDialog_jreHome, 1);
193	fJRERoot = SWTFactory.createSingleText(parent, 2);
194	Composite buttons = SWTFactory.createComposite(parent, parent.getFont(), 2, 4, GridData.HORIZONTAL_ALIGN_END, 0, 0);
195	Button folders = SWTFactory.createPushButton(buttons, JREMessages.AddVMDialog_22, null);
196	GridData data = (GridData) folders.getLayoutData();
197	data.horizontalAlignment = GridData.END;
198	fFileButton = SWTFactory.createPushButton(buttons, JREMessages.AddVMDialog_21, null);
199	data = (GridData) fFileButton.getLayoutData();
200	data.horizontalAlignment = GridData.END;
201	//VM name
202	SWTFactory.createLabel(parent, JREMessages.addVMDialog_jreName, 1);
203	fVMName = SWTFactory.createSingleText(parent, 2);
204	//VM arguments
205	SWTFactory.createLabel(parent, JREMessages.AddVMDialog_23, 1);
206	fVMArgs = SWTFactory.createSingleText(parent, 2);
207	//VM libraries block
208	SWTFactory.createLabel(parent, JREMessages.AddVMDialog_JRE_system_libraries__1, 3);
209	fLibraryBlock = new VMLibraryBlock(this);
210	Control block = fLibraryBlock.createControl(parent);
211	GridData gd = new GridData(GridData.FILL_BOTH);
212	gd.horizontalSpan = 3;
213	block.setLayoutData(gd);
214
215	//initialize the fields
216	initializeFields();
217
218	//add the listeners now to prevent them from monkeying with initialized settings
219	fVMCombo.addSelectionListener(new SelectionListener() {
220	public void widgetDefaultSelected(SelectionEvent e) {}
221	public void widgetSelected(SelectionEvent e) {
222	updateVMType();
223	}
224	});
225	fVMName.addModifyListener(new ModifyListener() {
226	public void modifyText(ModifyEvent e) {
227	validateVMName();
228	updateStatusLine();
229	}
230	});
231	fJRERoot.addModifyListener(new ModifyListener() {
232	public void modifyText(ModifyEvent e) {
233	validateJRELocation();
234	updateStatusLine();
235	}
236	});
237	folders.addSelectionListener(new SelectionListener() {
238	public void widgetDefaultSelected(SelectionEvent e) {}
239	public void widgetSelected(SelectionEvent e) {
240	DirectoryDialog dialog = new DirectoryDialog(getShell());
241	File file = new File(fJRERoot.getText());
242	String text = fJRERoot.getText();
243	if (file.isFile()) {
244	text = file.getParentFile().getAbsolutePath();
245	}
246	dialog.setFilterPath(text);
247	dialog.setMessage(JREMessages.addVMDialog_pickJRERootDialog_message);
248	String newPath = dialog.open();
249	if (newPath != null) {
250	fJRERoot.setText(newPath);
251	}
252	}
253	});
254	fFileButton.addSelectionListener(new SelectionListener() {
255	public void widgetDefaultSelected(SelectionEvent e) {}
256	public void widgetSelected(SelectionEvent e) {
257	FileDialog dialog = new FileDialog(getShell());
258	dialog.setFilterExtensions(new String[]{"*.ee"}); //$NON-NLS-1$
259	dialog.setFilterPath(fJRERoot.getText());
260	String newPath = dialog.open();
261	if (newPath != null) {
262	fJRERoot.setText(newPath);
263	}
264	}
265	});
266	applyDialogFont(parent);
267	return parent;
268	}
269
270	/**
271	* Updates the JRE location status and initializes the library block
272	*/
273	private void updateVMType() {
274	int selIndex = fVMCombo.getSelectionIndex();
275	if (selIndex == fPrevIndex) {
276	return;
277	}
278	fPrevIndex = selIndex;
279	if (selIndex >= 0 && selIndex < fVMTypes.length) {
280	fSelectedVMType= fVMTypes[selIndex];
281	}
282	validateJRELocation();
283	fLibraryBlock.initializeFrom(fEditedVM, fSelectedVMType);
284	updateFileButton();
285	updateStatusLine();
286	}
287
288	/**
289	* Updates enabled state of the "Definition File..." button.
290	*/
291	private void updateFileButton() {
292	fFileButton.setEnabled(fSelectedVMType.getId().equals(StandardVMType.ID_STANDARD_VM_TYPE));
293	}
294
295	/* (non-Javadoc)
296	* @see org.eclipse.jface.dialogs.StatusDialog#create()
297	*/
298	public void create() {
299	super.create();
300	if (fJRERoot.getText().length() == 0) {
301	fJRERoot.setFocus();
302	} else {
303	fVMName.setFocus();
304	}
305	selectVMType();
306	}
307
308	/**
309	* Returns the VM type names
310	* @return an array of strings with the names of the applicable VMs
311	*/
312	private String[] getVMTypeNames() {
313	String[] names = new String[fVMTypes.length];
314	for (int i = 0; i < fVMTypes.length; i++) {
315	names[i]= fVMTypes[i].getName();
316	}
317	return names;
318	}
319
320	/**
321	* Selects the corresponding VM for fSelectedVMType
322	*/
323	private void selectVMType() {
324	for (int i= 0; i < fVMTypes.length; i++) {
325	if (fSelectedVMType == fVMTypes[i]) {
326	if(i < fVMCombo.getItemCount()) {
327	fVMCombo.select(i);
328	return;
329	}
330	}
331	}
332	}
333
334	/**
335	* Initialize the dialogs fields
336	*/
337	private void initializeFields() {
338	if (fEditedVM == null) {
339	fVMName.setText(""); //$NON-NLS-1$
340	fJRERoot.setText(""); //$NON-NLS-1$
341	fLibraryBlock.initializeFrom(null, fSelectedVMType);
342	fVMArgs.setText(""); //$NON-NLS-1$
343	} else {
344	fVMCombo.setEnabled(false);
345	fVMName.setText(fEditedVM.getName());
346	fJRERoot.setText(fEditedVM.getInstallLocation().getAbsolutePath());
347	fLibraryBlock.initializeFrom(fEditedVM, fSelectedVMType);
348	if (fEditedVM instanceof IVMInstall2) {
349	IVMInstall2 vm2 = (IVMInstall2) fEditedVM;
350	String vmArgs = vm2.getVMArgs();
351	if (vmArgs != null) {
352	fVMArgs.setText(vmArgs);
353	}
354	} else {
355	String[] vmArgs = fEditedVM.getVMArguments();
356	if (vmArgs != null) {
357	StringBuffer buffer = new StringBuffer();
358	int length= vmArgs.length;
359	if (length > 0) {
360	buffer.append(vmArgs[0]);
361	for (int i = 1; i < length; i++) {
362	buffer.append(' ').append(vmArgs[i]);
363	}
364	}
365	fVMArgs.setText(buffer.toString());
366	}
367	}
368	}
369	updateFileButton();
370	validateVMName();
371	updateStatusLine();
372	}
373
374	/**
375	* Validates the JRE location
376	* @return the status after validating the JRE location
377	*/
378	private IStatus validateJRELocation() {
379	String locationName = fJRERoot.getText();
380	IStatus s = null;
381	File file = null;
382	if (locationName.length() == 0) {
383	s = new StatusInfo(IStatus.INFO, JREMessages.addVMDialog_enterLocation);
384	}
385	else {
386	file = new File(locationName);
387	if (!file.exists()) {
388	s = new StatusInfo(IStatus.ERROR, JREMessages.addVMDialog_locationNotExists);
389	}
390	else {
391	final IStatus[] temp = new IStatus[1];
392	final File tempFile = file;
393	Runnable r = new Runnable() {
394	public void run() {
395	temp[0] = fSelectedVMType.validateInstallLocation(tempFile);
396	}
397	};
398	BusyIndicator.showWhile(getShell().getDisplay(), r);
399	s = temp[0];
400	}
401	}
402	if (s.isOK()) {
403	fLibraryBlock.setHomeDirectory(file);
404	String name = fVMName.getText();
405	if (name == null \|\| name.trim().length() == 0) {
406	// auto-generate VM name
407	if (file.isFile()) {
408	String fileName = file.getName();
409	int index = fileName.lastIndexOf(".ee"); //$NON-NLS-1$
410	if (index > 0) {
411	fileName = fileName.substring(0, index);
412	}
413	fVMName.setText(fileName);
414	} else {
415	try {
416	String genName = null;
417	IPath path = new Path(file.getCanonicalPath());
418	int segs = path.segmentCount();
419	if (segs == 1) {
420	genName = path.segment(0);
421	}
422	else if (segs >= 2) {
423	String last = path.lastSegment();
424	if ("jre".equalsIgnoreCase(last)) { //$NON-NLS-1$
425	genName = path.segment(segs - 2);
426	}
427	else {
428	genName = last;
429	}
430	}
431	if (genName != null) {
432	fVMName.setText(genName);
433	}
434	} catch (IOException e) {}
435	}
436	}
437	} else {
438	fLibraryBlock.setHomeDirectory(null);
439	}
440	fLibraryBlock.restoreDefaultLibraries();
441	detectJavadocLocation();
442	fStatus[1] = s;
443	return s;
444	}
445
446	/**
447	* Auto-detects the default javadoc location
448	*/
449	private void detectJavadocLocation() {
450	if (fAutoDetectAttributes) {
451	if (fSelectedVMType instanceof AbstractVMInstallType) {
452	AbstractVMInstallType type = (AbstractVMInstallType)fSelectedVMType;
453	fJavadocLocation = type.getDefaultJavadocLocation(getInstallLocation());
454	String args = type.getDefaultVMArguments(getInstallLocation());
455	if (args != null) {
456	fVMArgs.setText(args);
457	}
458	}
459	} else {
460	fJavadocLocation = fEditedVM.getJavadocLocation();
461	}
462	}
463
464	/**
465	* Validates the entered name of the VM
466	* @return the status of the name validation
467	*/
468	private IStatus validateVMName() {
469	StatusInfo status= new StatusInfo();
470	String name= fVMName.getText();
471	if (name == null \|\| name.trim().length() == 0) {
472	status.setInfo(JREMessages.addVMDialog_enterName);
473	} else {
474	if (fRequestor.isDuplicateName(name) && (fEditedVM == null \|\| !name.equals(fEditedVM.getName()))) {
475	status.setError(JREMessages.addVMDialog_duplicateName);
476	} else {
477	IStatus s = ResourcesPlugin.getWorkspace().validateName(name, IResource.FILE);
478	if (!s.isOK()) {
479	status.setError(MessageFormat.format(JREMessages.AddVMDialog_JRE_name_must_be_a_valid_file_name___0__1, new String[]{s.getMessage()}));
480	}
481	}
482	}
483	fStatus[0] = status;
484	return status;
485	}
486
487	/**
488	* Updates the status line to show/hide messages to the user
489	*/
490	protected void updateStatusLine() {
491	IStatus max= null;
492	for (int i = 0; i < fStatus.length; i++) {
493	IStatus curr = fStatus[i];
494	if (curr.matches(IStatus.ERROR)) {
495	updateStatus(curr);
496	return;
497	}
498	if (max == null \|\| curr.getSeverity() > max.getSeverity()) {
499	max = curr;
500	}
501	}
502	updateStatus(max);
503	}
504
505	/**
506	* Returns the URL for the javadoc location
507	* @return the URL for the javadoc location
508	*/
509	protected URL getURL() {
510	return fJavadocLocation;
511	}
512
513	/* (non-Javadoc)
514	* @see org.eclipse.jface.dialogs.Dialog#okPressed()
515	*/
516	protected void okPressed() {
517	if (fEditedVM == null) {
518	IVMInstall vm = new VMStandin(fSelectedVMType, createUniqueId(fSelectedVMType));
519	setFieldValuesToVM(vm);
520	fRequestor.vmAdded(vm);
521	} else {
522	setFieldValuesToVM(fEditedVM);
523	}
524	super.okPressed();
525	}
526
527	/**
528	* Creates a unique name for the VMInstallType
529	* @param vmType the vm install type
530	* @return a unique name
531	*/
532	private String createUniqueId(IVMInstallType vmType) {
533	String id = null;
534	do {
535	id = String.valueOf(System.currentTimeMillis());
536	} while (vmType.findVMInstall(id) != null);
537	return id;
538	}
539
540	/**
541	* initialize fields to the specified VM
542	* @param vm the VM to initialize from
543	*/
544	protected void setFieldValuesToVM(IVMInstall vm) {
545	File dir = new File(fJRERoot.getText());
546	try {
547	vm.setInstallLocation(dir.getCanonicalFile());
548	}
549	catch (IOException e) {
550	vm.setInstallLocation(dir.getAbsoluteFile());
551	}
552	vm.setName(fVMName.getText());
553	vm.setJavadocLocation(getURL());
554
555	String argString = fVMArgs.getText().trim();
556	if (vm instanceof IVMInstall2) {
557	IVMInstall2 vm2 = (IVMInstall2) vm;
558	if (argString != null && argString.length() > 0) {
559	vm2.setVMArgs(argString);
560	}
561	else {
562	vm2.setVMArgs(null);
563	}
564	}
565	else {
566	if (argString != null && argString.length() > 0) {
567	vm.setVMArguments(DebugPlugin.parseArguments(argString));
568	}
569	else {
570	vm.setVMArguments(null);
571	}
572	}
573	fLibraryBlock.performApply(vm);
574	}
575
576	/**
577	* returns an absolute file or an empty file if the path is either null or zero length
578	* @param path the path to the file
579	* @return a new file
580	*/
581	protected File getAbsoluteFileOrEmpty(String path) {
582	if (path == null \|\| path.length() == 0) {
583	return new File(""); //$NON-NLS-1$
584	}
585	return new File(path).getAbsoluteFile();
586	}
587
588	/**
589	* @return the status of the system library
590	*/
591	protected IStatus getSystemLibraryStatus() {
592	return fStatus[3];
593	}
594
595	/**
596	* Allows the VM page to set the status of the current system library
597	* @param status the specified status
598	*/
599	protected void setSystemLibraryStatus(IStatus status) {
600	fStatus[3] = status;
601	}
602
603	/**
604	* Updates the status of the OK button to reflect the given status.
605	* Subclasses may override this method to update additional buttons.
606	* @param status the status.
607	*/
608	protected void updateButtonsEnableState(IStatus status) {
609	Button ok = getButton(IDialogConstants.OK_ID);
610	if (ok != null && !ok.isDisposed())
611	ok.setEnabled(status.getSeverity() == IStatus.OK);
612	}
613
614	/**
615	* Returns the name of the section that this dialog stores its settings in
616	*
617	* @return String
618	*/
619	protected String getDialogSettingsSectionName() {
620	return "ADD_VM_DIALOG_SECTION"; //$NON-NLS-1$
621	}
622
623	/* (non-Javadoc)
624	* @see org.eclipse.jface.dialogs.Dialog#getDialogBoundsSettings()
625	*/
626	protected IDialogSettings getDialogBoundsSettings() {
627	IDialogSettings settings = JDIDebugUIPlugin.getDefault().getDialogSettings();
628	IDialogSettings section = settings.getSection(getDialogSettingsSectionName());
629	if (section == null) {
630	section = settings.addNewSection(getDialogSettingsSectionName());
631	}
632	return section;
633	}
634
635	/* (non-Javadoc)
636	* @see org.eclipse.jface.dialogs.Dialog#getInitialSize()
637	*/
638	protected Point getInitialSize() {
639	IDialogSettings settings = getDialogBoundsSettings();
640	if(settings != null) {
641	try {
642	int width = settings.getInt("DIALOG_WIDTH"); //$NON-NLS-1$
643	int height = settings.getInt("DIALOG_HEIGHT"); //$NON-NLS-1$
644	if(width > 0 & height > 0) {
645	return new Point(width, height);
646	}
647	}
648	catch (NumberFormatException nfe) {
649	return new Point(500, 570);
650	}
651	}
652	return new Point(500, 570);
653	}
654
655	protected void setButtonLayoutData(Button button) {
656	super.setButtonLayoutData(button);
657	}
658
659	}

Added Link Here

(-)schema/vmInstallPages.exsd (+131 lines)
1	<?xml version='1.0' encoding='UTF-8'?>
2	<!-- Schema file written by PDE -->
3	<schema targetNamespace="org.eclipse.jdt.debug.ui">
4	<annotation>
5	<appInfo>
6	<meta.schema plugin="org.eclipse.jdt.debug.ui" id="vmInstallPages" name="VM Install Pages"/>
7	</appInfo>
8	<documentation>
9	This extension point allows a wizard page to be contributed for VM installs that require custom editing controls.
10	</documentation>
11	</annotation>
12
13	<element name="extension">
14	<complexType>
15	<sequence minOccurs="1" maxOccurs="unbounded">
16	<element ref="vmInstallPage"/>
17	</sequence>
18	<attribute name="point" type="string" use="required">
19	<annotation>
20	<documentation>
21
22	</documentation>
23	</annotation>
24	</attribute>
25	<attribute name="id" type="string">
26	<annotation>
27	<documentation>
28
29	</documentation>
30	</annotation>
31	</attribute>
32	<attribute name="name" type="string">
33	<annotation>
34	<documentation>
35
36	</documentation>
37	<appInfo>
38	<meta.attribute translatable="true"/>
39	</appInfo>
40	</annotation>
41	</attribute>
42	</complexType>
43	</element>
44
45	<element name="vmInstallPage">
46	<annotation>
47	<documentation>
48	Contributes a wizard page for a specific VM install type.
49	</documentation>
50	</annotation>
51	<complexType>
52	<attribute name="vmInstallType" type="string" use="required">
53	<annotation>
54	<documentation>
55	Specifies the VM install type this wizard page is to be used for. Unique identifier corresponding to an <code>IVMInstallType</code>'s id.
56	</documentation>
57	</annotation>
58	</attribute>
59	<attribute name="class" type="string" use="required">
60	<annotation>
61	<documentation>
62	Wizard page implementation. Must be a subclass of <code>org.eclipse.jdt.debug.ui.launchConfigurations.AbstractVMInstallPage</code>.
63	</documentation>
64	<appInfo>
65	<meta.attribute kind="java" basedOn="org.eclipse.jdt.debug.ui.launchConfigurations.AbstractVMInstallPage:"/>
66	</appInfo>
67	</annotation>
68	</attribute>
69	</complexType>
70	</element>
71
72	<annotation>
73	<appInfo>
74	<meta.section type="since"/>
75	</appInfo>
76	<documentation>
77	3.4
78	</documentation>
79	</annotation>
80
81	<annotation>
82	<appInfo>
83	<meta.section type="examples"/>
84	</appInfo>
85	<documentation>
86	Following is an example definition of a VM install page.
87	<p>
88	<pre>
89	<extension point="org.eclipse.jdt.debug.ui.vmInstallPages">
90	<vmInstallPage
91	vmInstallType="org.eclipse.jdt.launching.EEVMType"
92	class="org.eclipse.jdt.internal.debug.ui.jres.EEVMPage">
93	</vmInstallPage>
94	</extension>
95	</pre>
96	</p>
97	</documentation>
98	</annotation>
99
100	<annotation>
101	<appInfo>
102	<meta.section type="apiInfo"/>
103	</appInfo>
104	<documentation>
105	A wizard page must be a subclass of <code>org.eclipse.jdt.debug.ui.launchConfigurations.AbstractVMInstallPage</code>.
106	</documentation>
107	</annotation>
108
109	<annotation>
110	<appInfo>
111	<meta.section type="implementation"/>
112	</appInfo>
113	<documentation>
114	JDT provides a default implementation of a wizard page for VMs that do not contribute one.
115	</documentation>
116	</annotation>
117
118	<annotation>
119	<appInfo>
120	<meta.section type="copyright"/>
121	</appInfo>
122	<documentation>
123	Copyright (c) 2007 IBM Corporation and others.<br>
124	All rights reserved. This program and the accompanying materials are made
125	available under the terms of the Eclipse Public License v1.0 which
126	accompanies this distribution, and is available at
127	<a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
128	</documentation>
129	</annotation>
130
131	</schema>

Added Link Here

(-)ui/org/eclipse/jdt/debug/ui/launchConfigurations/AbstractVMInstallPage.java (+248 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jdt.debug.ui.launchConfigurations;
12
13	import org.eclipse.core.resources.IResource;
14	import org.eclipse.core.resources.ResourcesPlugin;
15	import org.eclipse.core.runtime.IStatus;
16	import org.eclipse.core.runtime.Status;
17	import org.eclipse.jdt.internal.debug.ui.JDIDebugUIPlugin;
18	import org.eclipse.jdt.internal.debug.ui.jres.JREMessages;
19	import org.eclipse.jdt.launching.VMStandin;
20	import org.eclipse.jface.dialogs.IMessageProvider;
21	import org.eclipse.jface.resource.ImageDescriptor;
22	import org.eclipse.jface.wizard.IWizardPage;
23	import org.eclipse.jface.wizard.WizardPage;
24
25	import com.ibm.icu.text.MessageFormat;
26
27	/**
28	* A wizard page used to edit the attributes of an installed JRE. A page is
29	* provided by JDT to edit standard JREs, but clients may contribute a custom
30	* page for a VM install type if required.
31	* <p>
32	* A VM install page is contributed via the <code>vmInstallPages</code> extension
33	* point. Following is an example definition of a VM install page.
34	* <pre>
35	* <extension point="org.eclipse.jdt.debug.ui.vmInstallPages">
36	* <vmInstallPage
37	* vmInstallType="org.eclipse.jdt.launching.EEVMType"
38	* class="org.eclipse.jdt.internal.debug.ui.jres.EEVMPage">
39	* </vmInstallPage>
40	* </extension>
41	* </pre>
42	* The attributes are specified as follows:
43	* <ul>
44	* <li><code>vmInstallType</code> Specifies the VM install type this wizard page is to be used for.
45	* Unique identifier corresponding to an <code>IVMInstallType</code>'s id.</li>
46	* <li><code>class</code> Wizard page implementation. Must be a subclass of
47	* <code>org.eclipse.jdt.debug.ui.launchConfigurations.AbstractVMInstallPage</code>.</li>
48	* </ul>
49	* </p>
50	* <p>
51	* Clients contributing a custom VM install page via the <code>vmInstallPages</code>
52	* extension point must subclass this class.
53	* </p>
54	* @since 3.4
55	*/
56	public abstract class AbstractVMInstallPage extends WizardPage {
57
58	/**
59	* Name of the original VM being edited, or <code>null</code> if none.
60	*/
61	private String fOriginalName = null;
62
63	/**
64	* Status of VM name (to notify of name already in use)
65	*/
66	private IStatus fNameStatus = Status.OK_STATUS;
67
68	private String[] fExistingNames;
69
70	/**
71	* Constructs a new page with the given page name.
72	*
73	* @param pageName the name of the page
74	*/
75	protected AbstractVMInstallPage(String pageName) {
76	super(pageName);
77	}
78
79	/**
80	* Creates a new wizard page with the given name, title, and image.
81	*
82	* @param pageName the name of the page
83	* @param title the title for this wizard page,
84	* or <code>null</code> if none
85	* @param titleImage the image descriptor for the title of this wizard page,
86	* or <code>null</code> if none
87	*/
88	protected AbstractVMInstallPage(String pageName, String title, ImageDescriptor titleImage) {
89	super(pageName, title, titleImage);
90	}
91
92	/**
93	* Called when the VM install page wizard is closed by selecting
94	* the finish button. Implementers typically override this method to
95	* store the page result (new/changed vm install returned in
96	* getSelection) into its model.
97	*
98	* @return if the operation was successful. Only when returned
99	* <code>true</code>, the wizard will close.
100	*/
101	public abstract boolean finish();
102
103	/**
104	* Returns the edited or created VM install. This method
105	* may return <code>null</code> if no VM install exists.
106	*
107	* @return the edited or created VM install.
108	*/
109	public abstract VMStandin getSelection();
110
111	/**
112	* Sets the VM install to be edited.
113	*
114	* @param vm the VM install to edit
115	*/
116	public void setSelection(VMStandin vm) {
117	fOriginalName = vm.getName();
118	}
119
120	/**
121	* Updates the name status based on the new name. This method should be called
122	* by the page each time the VM name changes.
123	*
124	* @param newName new name of VM
125	*/
126	protected void nameChanged(String newName) {
127	fNameStatus = Status.OK_STATUS;
128	if (newName == null \|\| newName.trim().length() == 0) {
129	int sev = IStatus.ERROR;
130	if (fOriginalName == null \|\| fOriginalName.length() == 0) {
131	sev = IStatus.INFO;
132	}
133	fNameStatus = new Status(sev, JDIDebugUIPlugin.getUniqueIdentifier(), JREMessages.addVMDialog_enterName);
134	} else {
135	if (isDuplicateName(newName)) {
136	fNameStatus = new Status(IStatus.ERROR, JDIDebugUIPlugin.getUniqueIdentifier(), JREMessages.addVMDialog_duplicateName);
137	} else {
138	IStatus s = ResourcesPlugin.getWorkspace().validateName(newName, IResource.FILE);
139	if (!s.isOK()) {
140	fNameStatus = new Status(IStatus.ERROR, JDIDebugUIPlugin.getUniqueIdentifier(), MessageFormat.format(JREMessages.AddVMDialog_JRE_name_must_be_a_valid_file_name___0__1, new String[]{s.getMessage()}));
141	}
142	}
143	}
144	updatePageStatus();
145	}
146
147	/**
148	* Returns whether the name is already in use by an existing VM
149	*
150	* @param name new name
151	* @return whether the name is already in use
152	*/
153	private boolean isDuplicateName(String name) {
154	if (fExistingNames != null) {
155	for (int i = 0; i < fExistingNames.length; i++) {
156	if (name.equals(fExistingNames[i])) {
157	return true;
158	}
159	}
160	}
161	return false;
162	}
163
164	/**
165	* Sets the names of existing VMs, not including the VM being edited. This method
166	* is called by the wizard and clients should not call this method.
167	*
168	* @param names existing VM names or an empty array
169	*/
170	public void setExistingNames(String[] names) {
171	fExistingNames = names;
172	}
173
174	/* (non-Javadoc)
175	* @see org.eclipse.jface.wizard.WizardPage#getNextPage()
176	*/
177	public IWizardPage getNextPage() {
178	return null;
179	}
180
181	/**
182	* Sets this page's message based on the status severity.
183	*
184	* @param status status with message and severity
185	*/
186	protected void setStatusMessage(IStatus status) {
187	if (status.isOK()) {
188	setMessage(status.getMessage());
189	} else {
190	switch (status.getSeverity()) {
191	case IStatus.ERROR:
192	setMessage(status.getMessage(), IMessageProvider.ERROR);
193	break;
194	case IStatus.INFO:
195	setMessage(status.getMessage(), IMessageProvider.INFORMATION);
196	break;
197	case IStatus.WARNING:
198	setMessage(status.getMessage(), IMessageProvider.WARNING);
199	break;
200	default:
201	break;
202	}
203	}
204	}
205
206	/**
207	* Returns the current status of the name being used for the VM.
208	*
209	* @return status of current VM name
210	*/
211	protected IStatus getNameStatus() {
212	return fNameStatus;
213	}
214
215	/**
216	* Updates the status message on the page, based on the status of the VM and other
217	* status provided by the page.
218	*/
219	protected void updatePageStatus() {
220	IStatus max = Status.OK_STATUS;
221	IStatus[] vmStatus = getVMStatus();
222	for (int i = 0; i < vmStatus.length; i++) {
223	IStatus status = vmStatus[i];
224	if (status.getSeverity() > max.getSeverity()) {
225	max = status;
226	}
227	}
228	if (fNameStatus.getSeverity() > max.getSeverity()) {
229	max = fNameStatus;
230	}
231	if (max.isOK()) {
232	setMessage(null, IMessageProvider.NONE);
233	setPageComplete(true);
234	} else {
235	setStatusMessage(max);
236	setPageComplete(false);
237	}
238	}
239
240	/**
241	* Returns a collection of status messages pertaining to the current edit
242	* status of the VM on this page. An empty collection or a collection of
243	* OK status objects indicates all is well.
244	*
245	* @return collection of status objects for this page
246	*/
247	protected abstract IStatus[] getVMStatus();
248	}