Attachment #79587 for bug #201758

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




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;

	protected Button fDefaultButton;
	
	/**
	 * Constructs a new wizard page with the given name.
	 * 
	 * @param pageName page name
	 */
	VMLibraryBlock() {
		super("JRE System Libraries");
	}	

	/* (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;
			}
		}
		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.launching.IVMInstallChangedListener#defaultVMInstallChanged(org.eclipse.jdt.launching.IVMInstall, org.eclipse.jdt.launching.IVMInstall)
	 */
	public void defaultVMInstallChanged(IVMInstall previous, IVMInstall current) {
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.launching.IVMInstallChangedListener#vmAdded(org.eclipse.jdt.launching.IVMInstall)
	 */
	public void vmAdded(IVMInstall vm) {
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.launching.IVMInstallChangedListener#vmRemoved(org.eclipse.jdt.launching.IVMInstall)
	 */
	public void vmRemoved(IVMInstall vm) {
	}
		
}

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 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 VMWizardDialog(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 VMWizardDialog(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 VMWizardDialog(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	}




JREsPreferencePage_14=Conflicting compliance settings can be changed on the <a>Compiler</a> page.

addVMDialog_duplicateName=The JRE name is already in use.
addVMDialog_enterLocation=Enter the home directory of the JRE.
addVMDialog_enterName=Enter a name for the JRE.
addVMDialog_jreHome=&JRE home:
addVMDialog_jreName=JRE &name:
addVMDialog_jreType=JRE &type:
addVMDialog_locationNotExists=The home directory does not exist.
addVMDialog_pickJRERootDialog_message=Select the root directory of the JRE installation:
AddVMDialog_JRE_system_libraries__1=JRE system libraries:
AddVMDialog_JRE_name_must_be_a_valid_file_name___0__1=JRE name must be a valid file name: {0}
AddVMDialog_21=Definition &File...
AddVMDialog_22=Direct&ory...
AddVMDialog_23=Default &VM Arguments:

JREsUpdater_0=Save VM Definitions




/*******************************************************************************
 * 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);
	}
    
}

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>

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$




/*******************************************************************************
 * 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 curretly existing VMs, used for name validation
	 */
	public AddVMInstallWizard(IVMInstall[] currentInstalls) {
		super(null, currentInstalls);
		setForcePreviousAndNextButtons(true);
		setWindowTitle("Add JRE");
	}

	/* (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.HashSet;
import java.util.Iterator;
import java.util.Set;

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.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.util.IPropertyChangeListener;
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 fStandardPage;
	
	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("Select JRE Type");
		setDescription("Select the type of installed JRE to add.");
		setTitle("Add Installed JRE");
	}
	
	
	/* (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.removePropertyChangeListener((IPropertyChangeListener) getWizard());
			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, "Installed JRE &Types:", 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);
		
		fStandardPage = new StandardVMPage();
		fStandardPage.setWizard(getWizard());
		fNextPage = fStandardPage;
		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 = getPage(installType);
				page.addPropertyChangeListener((IPropertyChangeListener) getWizard());
				VMStandin standin = new VMStandin(installType, StandardVMPage.createUniqueId(installType));
				standin.setName("");
				page.setSelection(standin);
				fNextPage = page;
				fPages.add(page);
			}
		}		
	}
	
	/**
	 * Returns a page to use for editing a VM install type
	 * 
	 * @param type
	 * @return
	 */
	private 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");
					page.setWizard(getWizard());
					return page;
				} catch (CoreException e) {
					JDIDebugUIPlugin.log(e);
				}
			}
		}
		return fStandardPage;
	}

}




/*******************************************************************************
 * 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.debug.core.DebugPlugin;
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.IVMInstall;
import org.eclipse.jdt.launching.IVMInstall2;
import org.eclipse.jdt.launching.IVMInstallType;
import org.eclipse.jdt.launching.VMStandin;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.IMessageProvider;
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("Add Standard VM");
		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()) {
			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() {
		fireNameChange(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("Define Installed JRE");
		setDescription("Specify attributes for an installed JRE");
	}
	
	/**
	 * 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);
			}			
		}
	}
	
	/**
	 * 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());
		}
		if (fVM instanceof IVMInstall2) {
			IVMInstall2 vm2 = (IVMInstall2) fVM;
			String vmArgs = vm2.getVMArgs();
			if (vmArgs != null) {
				fVMArgs.setText(vmArgs);
			}
		} else {
			String[] vmArgs = fVM.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());
			}				
		}
		validateVMName();
		validateJRELocation();
	}	
	
	/**
	 * Sets the status of the JRE location field.
	 * 
	 * @param status JRE location status
	 */
	private void setJRELocationStatus(IStatus status) {
		fFieldStatus[0] = status;
	}
	
	private void updatePageStatus() {
		IStatus max = Status.OK_STATUS;
		for (int i = 0; i < fFieldStatus.length; i++) {
			IStatus status = fFieldStatus[i];
			if (status.getSeverity() > max.getSeverity()) {
				max = status;
			}
		}
		if (max.isOK()) {
			setMessage(null, IMessageProvider.NONE);
			setPageComplete(true);
		} else {
			setStatusMessage(max);
			setPageComplete(false);
		}
	}

	/* (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;
	}
	
	
}




/*******************************************************************************
 * 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.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.debug.ui.launchConfigurations.AbstractVMInstallPage;
import org.eclipse.jdt.internal.debug.ui.JDIDebugUIPlugin;
import org.eclipse.jdt.launching.IVMInstall;
import org.eclipse.jdt.launching.VMStandin;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.wizard.Wizard;

import com.ibm.icu.text.MessageFormat;

/**
 * 
 */
public abstract class VMInstallWizard extends Wizard implements IPropertyChangeListener {
	
	private IStatus fNameStatus = Status.OK_STATUS;
	
	private VMStandin fEditVM;
	private IVMInstall[] fInstalls;
	
	/**
	 * 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;
		fInstalls = currentInstalls;
	}
	
	/**
	 * 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;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.util.IPropertyChangeListener#propertyChange(org.eclipse.jface.util.PropertyChangeEvent)
	 */
	public void propertyChange(PropertyChangeEvent event) {
		if (AbstractVMInstallPage.P_JRE_NAME.equals(event.getProperty())) {
			fNameStatus = Status.OK_STATUS;
			String name = (String) event.getNewValue();
			if (name == null || name.trim().length() == 0) {
				fNameStatus = new Status(IStatus.INFO, JDIDebugUIPlugin.getUniqueIdentifier(), JREMessages.addVMDialog_enterName);
			} else {
				if (isDuplicateName(name)) {
					fNameStatus = new Status(IStatus.ERROR, JDIDebugUIPlugin.getUniqueIdentifier(), JREMessages.addVMDialog_duplicateName); 
				} else {
					IStatus s = ResourcesPlugin.getWorkspace().validateName(name, 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()})); 
					}
				}
			}
		}	
		getContainer().updateMessage();
		getContainer().updateButtons();
	}
	
	/**
	 * 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) {
		for (int i = 0; i < fInstalls.length; i++) {
			IVMInstall vm = fInstalls[i];
			if (name.equals(vm.getName())) {
				// don't consider VM being edited
				if (!vm.equals(fEditVM)) {
					return true;
				}
			}
		}
		return false;
	}

	/**
	 * Returns a status describing the status of the current name of the VM being edited/created.
	 * 
	 * @return status
	 */
	protected IStatus getNameStatus() {
		return fNameStatus;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.wizard.Wizard#canFinish()
	 */
	public boolean canFinish() {
		return getNameStatus().isOK() && super.canFinish();
	}
	
	/**
	 * 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;
	}

}




/*******************************************************************************
 * 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.runtime.IStatus;
import org.eclipse.core.runtime.ListenerList;
import org.eclipse.jdt.launching.VMStandin;
import org.eclipse.jface.dialogs.IMessageProvider;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.wizard.IWizardPage;
import org.eclipse.jface.wizard.WizardPage;

/**
 * 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.
 * 
 * @since 3.4
 */
public abstract class AbstractVMInstallPage extends WizardPage {
	
	/**
     * Property name constant (value <code>"org.eclipse.jdt.debug.ui.jre.name"</code>)
     * for a JRE's name.
	 */
	public static final String P_JRE_NAME = "org.eclipse.jdt.debug.ui.jre.name"; //$NON-NLS-1$	
	
	/**
	 * Name of the original VM being edited, or <code>null</code> if none.
	 */
	private String fOriginalName = null;
	
	/**
	 * Property change listeners
	 */
	private ListenerList fListeners = new ListenerList();
		
	/**
	 * 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);
	}

	/**
	 * Adds the specified property change listener to this page. Listeners
	 * are notified when the properties defined by this interface change.
	 * For example, when the name of a JRE changes.
	 * <p>
	 * Has no effect if an identical listener is already registered.
	 * </p>
	 * @param listener property change listener
	 */
	public void addPropertyChangeListener(IPropertyChangeListener listener) {
		fListeners.add(listener);
	}

	/**
	 * 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();

	/**
	 * Removes the specified property change listener.
	 * <p>
	 * Has no effect if the listener is not already registered.
	 * </p>
	 * @param listener property change listener
	 */
	public void removePropertyChangeListener(IPropertyChangeListener listener) {
		fListeners.remove(listener);
	}

	/**
	 * Sets the VM install to be edited. 
	 * 
	 * @param vm the VM install to edit
	 */
	public void setSelection(VMStandin vm) {
		fOriginalName = vm.getName();
	}
	
	/**
	 * Fires a name change event specifying the new name.
	 * 
	 * @param newName
	 */
	protected void fireNameChange(String newName) {
		fireChangeEvent(new PropertyChangeEvent(this, P_JRE_NAME, fOriginalName, newName));
	}
	
	/**
	 * Fires the event to all listeners.
	 * 
	 * @param event event to fire
	 */
	protected void fireChangeEvent(PropertyChangeEvent event) {
		Object[] listeners = fListeners.getListeners();
		for (int i = 0; i < listeners.length; i++) {
			IPropertyChangeListener listener = (IPropertyChangeListener) listeners[i];
			listener.propertyChange(event);
		}
	}

	/* (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;
			}
		}
	}	
}




/*******************************************************************************
 * 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.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.debug.core.DebugPlugin;
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.IVMInstall;
import org.eclipse.jdt.launching.IVMInstall2;
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.jface.dialogs.IMessageProvider;
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.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;
// the VM install's javadoc location
	private URL fJavadocLocation = null;
	private boolean fAutoDetectAttributes = false;
	private IStatus[] fFieldStatus = new IStatus[1];
	
	/**
	 * 
	 */
	public EEVMPage() {
		super("Add EE VM");
		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, "&Definition File:", 1);
		fEEFile = SWTFactory.createSingleText(composite, 1);
		Button folders = SWTFactory.createPushButton(composite, "F&ile...", 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();
			}
		});
		fEEFile.addModifyListener(new ModifyListener() {
			public void modifyText(ModifyEvent e) {
				validateDefinitionFile();
			}
		});
		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 = new File(fEEFile.getText());
				String text = fEEFile.getText();
				if (file.isFile()) {
					text = file.getParentFile().getAbsolutePath();
				}
				dialog.setFileName(text); 
				String newPath = dialog.open();
				if (newPath != null) {
					fEEFile.setText(newPath);
				}
			}
		});
		Dialog.applyDialogFont(composite);
		setControl(composite);
		initializeFields();
	}	
	
	/**
	 * Validates the JRE location
	 * @return the status after validating the JRE location
	 */
	private void validateDefinitionFile() {
		String locationName = fEEFile.getText();
		IStatus s = null;
		File file = null;
		if (locationName.length() == 0) {
			s = new StatusInfo(IStatus.INFO, "Enter definition file"); 
		} 
		else {
			file = new File(locationName);
			if (!file.exists()) {
				s = new StatusInfo(IStatus.ERROR, "Definition file does not exist"); 
			} 
			else {
				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()) {
			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);
				}
				fVMName.setText(fileName);
			}
		}
		detectJavadocLocation();
		setJRELocationStatus(s);
		fLibraryBlock.setSelection(fVM);
		String args = fVM.getVMArgs();
		if (args != null) {
			fVMArgs.setText(args);
		}
		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(fEEFile.getText());
	}	

	/**
	 * Validates the entered name of the VM
	 * @return the status of the name validation
	 */
	private void validateVMName() {
		fireNameChange(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("Define Installed JRE");
		setDescription("Specify attributes for an installed JRE");
	}
	
	/**
	 * initialize fields to the specified VM
	 * @param vm the VM to initialize from
	 */
	protected void setFieldValuesToVM(IVMInstall vm) {
		File dir = new File(fEEFile.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);
			}			
		}
	}
	
	/**
	 * 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());
//		String eePath = fVM.getAttribute(EEVMInstall.ATTR_DEFINITION_FILE);
//		if (eePath != null) {
//			fEEFile.setText(eePath);
//		}
		if (fVM instanceof IVMInstall2) {
			IVMInstall2 vm2 = (IVMInstall2) fVM;
			String vmArgs = vm2.getVMArgs();
			if (vmArgs != null) {
				fVMArgs.setText(vmArgs);
			}
		} else {
			String[] vmArgs = fVM.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());
			}				
		}
		validateVMName();
		validateDefinitionFile();
	}	
	
	/**
	 * Sets the status of the JRE location field.
	 * 
	 * @param status JRE location status
	 */
	private void setJRELocationStatus(IStatus status) {
		fFieldStatus[0] = status;
	}
	
	private void updatePageStatus() {
		IStatus max = Status.OK_STATUS;
		for (int i = 0; i < fFieldStatus.length; i++) {
			IStatus status = fFieldStatus[i];
			if (status.getSeverity() > max.getSeverity()) {
				max = status;
			}
		}
		if (max.isOK()) {
			setMessage(null, IMessageProvider.NONE);
			setPageComplete(true);
		} else {
			setStatusMessage(max);
			setPageComplete(false);
		}
	}

	/* (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;
	}
	
	
}




/*******************************************************************************
 * 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.core.runtime.IStatus;
import org.eclipse.jface.dialogs.IMessageProvider;
import org.eclipse.jface.wizard.WizardDialog;
import org.eclipse.swt.widgets.Shell;

/**
 * @since 3.4
 */
public class VMWizardDialog extends WizardDialog {

	/**
	 * @param parentShell
	 * @param newWizard
	 */
	public VMWizardDialog(Shell parentShell, VMInstallWizard newWizard) {
		super(parentShell, newWizard);
	}

	public void updateMessage() {
		VMInstallWizard wizard = (VMInstallWizard) getWizard();
		IStatus status = wizard.getNameStatus();
		if (status.isOK()) {
			super.updateMessage();
		} 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;
			}
		}
	}

	
}




/*******************************************************************************
 * 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("Edit JRE");
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.wizard.Wizard#dispose()
	 */
	public void dispose() {
		fEditPage.removePropertyChangeListener(this);
		super.dispose();
	}



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

	/**
	 * @return
	 */
	private AbstractVMInstallPage getEditPage() {
		// TODO: based on extension
		return new StandardVMPage();
	}

	/* (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();
	}

	
}




<?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>
         [Enter extension point usage example here.]
      </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>





import java.io.File;

import org.eclipse.core.runtime.CoreException;
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.jdt.debug.testplugin.JavaTestPlugin;
import org.eclipse.jdt.debug.tests.AbstractDebugTest;
import org.eclipse.jdt.internal.launching.EEVMType;
import org.eclipse.jdt.launching.IVMInstall;
import org.eclipse.jdt.launching.IVMInstallType;
import org.eclipse.jdt.launching.JavaRuntime;

	}
	
	/**
	 * Tests that the EE file is a valid file
	 */
	public void testValidateDefinitionFile() {
		File file = getEEFile();
		IVMInstallType vmType = getStandardVMInstallType();
		assertNotNull("Missing EE file", file);
		IStatus status = EEVMType.validateDefinitionFile(file);
		IStatus status = vmType.validateInstallLocation(file);
		assertTrue("Invalid install location", status.isOK());
	}
	
	/**
	 * Tests that the EE install location validation returns an INFO status.
	 */
	public void testValidateInstallLocation() {
		File file = getEEFile();
		IVMInstallType vmType = getVMInstallType();
		assertNotNull("Missing EE file", file);
		assertNotNull("Missing EE VM type", vmType);
		IStatus status = vmType.validateInstallLocation(file);
		assertTrue("Invalid install location", status.getSeverity() == IStatus.INFO);
	}	
	
	/**
	 * Tests libraries for the EE file
	 */
	public void testLibraries() {
		File file = getEEFile();
		assertNotNull("Missing EE file", file);
		LibraryLocation[] libs = EEVMType.getLibraryLocations(file);
		String[] expected = new String[]{"end.jar", "classes.txt", "others.txt", "ext1.jar", "ext2.jar", "opt-ext.jar"};
		assertEquals("Wrong number of libraries", expected.length, libs.length);
		for (int i = 0; i < expected.length; i++) {

	}
	
	/**
	 * Tests default libraries for an EE VM type are empty.
	 */
	public void testDefaultLibraries() {
		File file = getEEFile();
		IVMInstallType vmType = getVMInstallType();
		assertNotNull("Missing EE file", file);
		assertNotNull("Missing EE VM type", vmType);
		LibraryLocation[] libs = vmType.getDefaultLibraryLocations(file);
		assertEquals("Wrong number of libraries", 0, libs.length);
	}	
	
	/**
	 * Tests default VM arguments. All arguments from the EE file should get passed through in the
	 * same order to the command line.
	 */
	public void testVMArguments() {
		File file = getEEFile();
		StandardVMType vmType = (StandardVMType) getStandardVMInstallType();
		assertNotNull("Missing EE file", file);
		String defaultVMArguments = EEVMType.getVMArguments(file);
		String defaultVMArguments = vmType.getDefaultVMArguments(file);
		String[] expected = new String[] {
				"-Dee.executable",
				"-Dee.executable.console",

	/**
	 * Test compatible environments
	 */
	public void testCompatibleEEs() throws CoreException {
		IVMInstall install = null;
		EEVMType vmType = (EEVMType) getVMInstallType();
		try {
			File file = getEEFile();
			assertNotNull("Missing EE file", file);
			assertNotNull("Missing EE VM type", vmType);
			VMStandin standin = JavaRuntime.createVMFromDefinitionFile(file, "test-ee-file", "test-ee-file-id");
			install = standin.convertToRealVM();
			vm.setName("test-ee-file");
			vm.setVMArgs(vmType.getDefaultVMArguments(file));
			install = vm.convertToRealVM();
			
			IExecutionEnvironmentsManager manager = JavaRuntime.getExecutionEnvironmentsManager();
			IExecutionEnvironment[] envs = manager.getExecutionEnvironments();

				IExecutionEnvironment env = envs[i];
				if (env.getId().equals("CDC-1.1/Foundation-1.1")) {
					found11 = true;
					assertTrue("Should be strictly compatible with " + env.getId(), env.isStrictlyCompatible(install));
				} else if (env.getId().indexOf("jdt.debug.tests") < 0) {
					assertFalse("Should *not* be strictly compatible with " + env.getId(), env.isStrictlyCompatible(install));
				}
			}
			assertTrue("Did not find foundation 1.1 environment", found11);

		return JavaTestPlugin.getDefault().getFileInPlugin(TEST_EE_FILE);
	}
	
	protected IVMInstallType getVMInstallType() {
		return JavaRuntime.getVMInstallType(EEVMType.ID_EE_VM_TYPE);
	}
}

Lines 25-30 Link Here

(-)testfiles/test-jre/bin/test-foundation11.ee (+1 lines)
25	-Dee.name=Eclipse JDT Test JRE Definition	25	-Dee.name=Eclipse JDT Test JRE Definition
26	-Dee.description=Foundation Specification v1.1	26	-Dee.description=Foundation Specification v1.1
27	-Dee.copyright=(c) Copyright IBM Corp. 2007 All Rights Reserved	27	-Dee.copyright=(c) Copyright IBM Corp. 2007 All Rights Reserved
		28	-Djava.home=..
28		29
29	# all args should get passed through to command line	30	# all args should get passed through to command line
30	-XspecialArg:123	31	-XspecialArg:123

Lines 25-30 Link Here

(-)testfiles/test-jre/bin/test-foundation11-win32.ee (+1 lines)
25	-Dee.name=Eclipse JDT Test JRE Definition	25	-Dee.name=Eclipse JDT Test JRE Definition
26	-Dee.description=Foundation Specification v1.1	26	-Dee.description=Foundation Specification v1.1
27	-Dee.copyright=(c) Copyright IBM Corp. 2007 All Rights Reserved	27	-Dee.copyright=(c) Copyright IBM Corp. 2007 All Rights Reserved
		28	-Djava.home=..
28		29
29	# all args should get passed through to command line	30	# all args should get passed through to command line
30	-XspecialArg:123	31	-XspecialArg:123

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">




        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 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




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 28-33 Link Here

(-)launching/org/eclipse/jdt/internal/launching/EEVMType.java (-45 / +106 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	// TODO:
		375	return "Execution Environment Description";
		376	}
		377
		378	/* (non-Javadoc)
		379	* @see org.eclipse.jdt.launching.IVMInstallType#validateInstallLocation(java.io.File)
		380	*/
		381	public IStatus validateInstallLocation(File installLocationOrDefinitionFile) {
		382	return new Status(IStatus.INFO, LaunchingPlugin.getUniqueIdentifier(), "Unable to validate install location.");
		383	}
323	}	384	}




	 * <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);
	}

	/**




	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.




	 * 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);




	/**
	 * 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 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	}

Lines 59-64 Link Here

(-)launching/org/eclipse/jdt/launching/JavaRuntime.java (-1 / +48 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 1592-1598 Link Here
1592	LibraryLocation[] locations= vm.getLibraryLocations();	1594	LibraryLocation[] locations= vm.getLibraryLocations();
1593	if (locations == null) {	1595	if (locations == null) {
1594	URL defJavaDocLocation = vm.getJavadocLocation();	1596	URL defJavaDocLocation = vm.getJavadocLocation();
1595	LibraryLocation[] dflts= vm.getVMInstallType().getDefaultLibraryLocations(vm.getInstallLocation());	1597	File installLocation = vm.getInstallLocation();
		1598	if (installLocation == null) {
		1599	return new LibraryLocation[0];
		1600	}
		1601	LibraryLocation[] dflts= vm.getVMInstallType().getDefaultLibraryLocations(installLocation);
1596	libraryPaths = new IPath[dflts.length];	1602	libraryPaths = new IPath[dflts.length];
1597	sourcePaths = new IPath[dflts.length];	1603	sourcePaths = new IPath[dflts.length];
1598	sourceRootPaths = new IPath[dflts.length];	1604	sourceRootPaths = new IPath[dflts.length];
Lines 2654-2658 Link Here
2654	}	2660	}
2655	}	2661	}
2656	}	2662	}
		2663
		2664	/**
		2665	* Creates a new VM based on the attributes specified in the given execution
		2666	* environment description file. The format of the file is defined by
		2667	* <code>http://wiki.eclipse.org/index.php/Execution_Environment_Descriptions</code>.
		2668	*
		2669	* @param eeFile VM definition file
		2670	* @param name name for the VM
		2671	* @param id id to assign to the new VM
		2672	* @return VM standin
		2673	* @exception CoreException if unable to create a VM from the given definition file
		2674	* @since 3.4
		2675	*/
		2676	public static VMStandin createVMFromDefinitionFile(File eeFile, String name, String id) throws CoreException {
		2677	IStatus status = EEVMType.validateDefinitionFile(eeFile);
		2678	if (status.isOK()) {
		2679	VMStandin standin = new VMStandin(getVMInstallType(EEVMType.ID_EE_VM_TYPE), id);
		2680	standin.setName(name);
		2681	String home = EEVMType.getProperty(EEVMType.PROP_JAVA_HOME, eeFile);
		2682	standin.setInstallLocation(new File(home));
		2683	standin.setLibraryLocations(EEVMType.getLibraryLocations(eeFile));
		2684	standin.setVMArgs(EEVMType.getVMArguments(eeFile));
		2685	standin.setJavadocLocation(EEVMType.getJavadocLocation(eeFile));
		2686	standin.setAttribute(EEVMInstall.ATTR_EXECUTION_ENVIRONMENT_ID, EEVMType.getProperty(EEVMType.PROP_CLASS_LIB_LEVEL, eeFile));
		2687	File exe = EEVMType.getExecutable(eeFile);
		2688	if (exe != null) {
		2689	try {
		2690	standin.setAttribute(EEVMInstall.ATTR_JAVA_EXE, exe.getCanonicalPath());
		2691	} catch (IOException e) {
		2692	throw new CoreException(new Status(IStatus.ERROR, LaunchingPlugin.getUniqueIdentifier(),
		2693	"Failed to create VM install", e));
		2694	}
		2695	}
		2696	standin.setAttribute(EEVMInstall.ATTR_JAVA_VERSION, EEVMType.getJavaVersion(eeFile));
		2697	standin.setAttribute(EEVMInstall.ATTR_DEFINITION_FILE, eeFile.getPath());
		2698	standin.setVMArgs(EEVMType.getVMArguments(eeFile));
		2699	return standin;
		2700	} else {
		2701	throw new CoreException(status);
		2702	}
		2703	}
2657		2704
2658	}	2705	}

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	}




/*******************************************************************************
 * 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;
	}
	
	

}

Return to bug 201758

Lines 58-74 Link Here

(-)ui/org/eclipse/jdt/internal/debug/ui/jres/JREMessages.properties (-4 / +4 lines)
58	JREsPreferencePage_14=Conflicting compliance settings can be changed on the <a>Compiler</a> page.	58	JREsPreferencePage_14=Conflicting compliance settings can be changed on the <a>Compiler</a> page.
59		59
60	addVMDialog_duplicateName=The JRE name is already in use.	60	addVMDialog_duplicateName=The JRE name is already in use.
61	addVMDialog_enterLocation=Enter the location of the JRE.	61	addVMDialog_enterLocation=Enter the home directory of the JRE.
62	addVMDialog_enterName=Enter a name for the JRE.	62	addVMDialog_enterName=Enter a name for the JRE.
63	addVMDialog_jreHome=&JRE location:	63	addVMDialog_jreHome=&JRE home:
64	addVMDialog_jreName=JRE &name:	64	addVMDialog_jreName=JRE &name:
65	addVMDialog_jreType=JRE &type:	65	addVMDialog_jreType=JRE &type:
66	addVMDialog_locationNotExists=The location does not exist.	66	addVMDialog_locationNotExists=The home directory does not exist.
67	addVMDialog_pickJRERootDialog_message=Select the root directory of the JRE installation:	67	addVMDialog_pickJRERootDialog_message=Select the root directory of the JRE installation:
68	AddVMDialog_JRE_system_libraries__1=JRE system libraries:	68	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}	69	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...	70	AddVMDialog_21=Definition &File...
71	AddVMDialog_22=H&ome Directory...	71	AddVMDialog_22=Direct&ory...
72	AddVMDialog_23=Default &VM Arguments:	72	AddVMDialog_23=Default &VM Arguments:
73		73
74	JREsUpdater_0=Save VM Definitions	74	JREsUpdater_0=Save VM Definitions

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

(-)ui/org/eclipse/jdt/internal/debug/ui/jres/AddVMInstallWizard.java (+77 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.debug.ui.jres;
12
13	import org.eclipse.jdt.debug.ui.launchConfigurations.AbstractVMInstallPage;
14	import org.eclipse.jdt.launching.IVMInstall;
15	import org.eclipse.jdt.launching.VMStandin;
16	import org.eclipse.jface.wizard.IWizardPage;
17
18	/**
19	* @since 3.4
20	*/
21	public class AddVMInstallWizard extends VMInstallWizard {
22
23	private IWizardPage fTypePage = null;
24
25	private VMStandin fResult = null;
26
27	/**
28	* Constructs a wizard to add a new VM install.
29	*
30	* @param currentInstalls curretly existing VMs, used for name validation
31	*/
32	public AddVMInstallWizard(IVMInstall[] currentInstalls) {
33	super(null, currentInstalls);
34	setForcePreviousAndNextButtons(true);
35	setWindowTitle("Add JRE");
36	}
37
38	/* (non-Javadoc)
39	* @see org.eclipse.jface.wizard.Wizard#addPages()
40	*/
41	public void addPages() {
42	fTypePage = new VMTypePage();
43	addPage(fTypePage);
44	}
45
46	/* (non-Javadoc)
47	* @see org.eclipse.jdt.internal.debug.ui.jres.VMInstallWizard#getResult()
48	*/
49	protected VMStandin getResult() {
50	return fResult;
51	}
52
53	/* (non-Javadoc)
54	* @see org.eclipse.jdt.internal.debug.ui.jres.VMInstallWizard#canFinish()
55	*/
56	public boolean canFinish() {
57	IWizardPage currentPage = getContainer().getCurrentPage();
58	return currentPage != fTypePage && super.canFinish() && currentPage.isPageComplete();
59	}
60
61	/* (non-Javadoc)
62	* @see org.eclipse.jdt.internal.debug.ui.jres.VMInstallWizard#performFinish()
63	*/
64	public boolean performFinish() {
65	IWizardPage currentPage = getContainer().getCurrentPage();
66	if (currentPage instanceof AbstractVMInstallPage) {
67	AbstractVMInstallPage page = (AbstractVMInstallPage) currentPage;
68	boolean finish = page.finish();
69	fResult = page.getSelection();
70	return finish;
71	}
72	return false;
73	}
74
75
76
77	}

Added Link Here

(-)ui/org/eclipse/jdt/debug/ui/launchConfigurations/AbstractVMInstallPage.java (+175 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.runtime.IStatus;
14	import org.eclipse.core.runtime.ListenerList;
15	import org.eclipse.jdt.launching.VMStandin;
16	import org.eclipse.jface.dialogs.IMessageProvider;
17	import org.eclipse.jface.resource.ImageDescriptor;
18	import org.eclipse.jface.util.IPropertyChangeListener;
19	import org.eclipse.jface.util.PropertyChangeEvent;
20	import org.eclipse.jface.wizard.IWizardPage;
21	import org.eclipse.jface.wizard.WizardPage;
22
23	/**
24	* A wizard page used to edit the attributes of an installed JRE. A page is
25	* provided by JDT to edit standard JREs, but clients may contribute a custom
26	* page for a VM install type if required.
27	*
28	* @since 3.4
29	*/
30	public abstract class AbstractVMInstallPage extends WizardPage {
31
32	/**
33	* Property name constant (value <code>"org.eclipse.jdt.debug.ui.jre.name"</code>)
34	* for a JRE's name.
35	*/
36	public static final String P_JRE_NAME = "org.eclipse.jdt.debug.ui.jre.name"; //$NON-NLS-1$
37
38	/**
39	* Name of the original VM being edited, or <code>null</code> if none.
40	*/
41	private String fOriginalName = null;
42
43	/**
44	* Property change listeners
45	*/
46	private ListenerList fListeners = new ListenerList();
47
48	/**
49	* Constructs a new page with the given page name.
50	*
51	* @param pageName the name of the page
52	*/
53	protected AbstractVMInstallPage(String pageName) {
54	super(pageName);
55	}
56
57	/**
58	* Creates a new wizard page with the given name, title, and image.
59	*
60	* @param pageName the name of the page
61	* @param title the title for this wizard page,
62	* or <code>null</code> if none
63	* @param titleImage the image descriptor for the title of this wizard page,
64	* or <code>null</code> if none
65	*/
66	protected AbstractVMInstallPage(String pageName, String title, ImageDescriptor titleImage) {
67	super(pageName, title, titleImage);
68	}
69
70	/**
71	* Adds the specified property change listener to this page. Listeners
72	* are notified when the properties defined by this interface change.
73	* For example, when the name of a JRE changes.
74	* <p>
75	* Has no effect if an identical listener is already registered.
76	* </p>
77	* @param listener property change listener
78	*/
79	public void addPropertyChangeListener(IPropertyChangeListener listener) {
80	fListeners.add(listener);
81	}
82
83	/**
84	* Called when the VM install page wizard is closed by selecting
85	* the finish button. Implementers typically override this method to
86	* store the page result (new/changed vm install returned in
87	* getSelection) into its model.
88	*
89	* @return if the operation was successful. Only when returned
90	* <code>true</code>, the wizard will close.
91	*/
92	public abstract boolean finish();
93
94	/**
95	* Returns the edited or created VM install. This method
96	* may return <code>null</code> if no VM install exists.
97	*
98	* @return the edited or created VM install.
99	*/
100	public abstract VMStandin getSelection();
101
102	/**
103	* Removes the specified property change listener.
104	* <p>
105	* Has no effect if the listener is not already registered.
106	* </p>
107	* @param listener property change listener
108	*/
109	public void removePropertyChangeListener(IPropertyChangeListener listener) {
110	fListeners.remove(listener);
111	}
112
113	/**
114	* Sets the VM install to be edited.
115	*
116	* @param vm the VM install to edit
117	*/
118	public void setSelection(VMStandin vm) {
119	fOriginalName = vm.getName();
120	}
121
122	/**
123	* Fires a name change event specifying the new name.
124	*
125	* @param newName
126	*/
127	protected void fireNameChange(String newName) {
128	fireChangeEvent(new PropertyChangeEvent(this, P_JRE_NAME, fOriginalName, newName));
129	}
130
131	/**
132	* Fires the event to all listeners.
133	*
134	* @param event event to fire
135	*/
136	protected void fireChangeEvent(PropertyChangeEvent event) {
137	Object[] listeners = fListeners.getListeners();
138	for (int i = 0; i < listeners.length; i++) {
139	IPropertyChangeListener listener = (IPropertyChangeListener) listeners[i];
140	listener.propertyChange(event);
141	}
142	}
143
144	/* (non-Javadoc)
145	* @see org.eclipse.jface.wizard.WizardPage#getNextPage()
146	*/
147	public IWizardPage getNextPage() {
148	return null;
149	}
150
151	/**
152	* Sets this page's message based on the status severity.
153	*
154	* @param status status with message and severity
155	*/
156	protected void setStatusMessage(IStatus status) {
157	if (status.isOK()) {
158	setMessage(status.getMessage());
159	} else {
160	switch (status.getSeverity()) {
161	case IStatus.ERROR:
162	setMessage(status.getMessage(), IMessageProvider.ERROR);
163	break;
164	case IStatus.INFO:
165	setMessage(status.getMessage(), IMessageProvider.INFORMATION);
166	break;
167	case IStatus.WARNING:
168	setMessage(status.getMessage(), IMessageProvider.WARNING);
169	break;
170	default:
171	break;
172	}
173	}
174	}
175	}

Added Link Here

(-)schema/vmInstallPages.exsd (+121 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	[Enter extension point usage example here.]
87	</documentation>
88	</annotation>
89
90	<annotation>
91	<appInfo>
92	<meta.section type="apiInfo"/>
93	</appInfo>
94	<documentation>
95	A wizard page must be a subclass of <code>org.eclipse.jdt.debug.ui.launchConfigurations.AbstractVMInstallPage</code>.
96	</documentation>
97	</annotation>
98
99	<annotation>
100	<appInfo>
101	<meta.section type="implementation"/>
102	</appInfo>
103	<documentation>
104	JDT provides a default implementation of a wizard page for VMs that do not contribute one.
105	</documentation>
106	</annotation>
107
108	<annotation>
109	<appInfo>
110	<meta.section type="copyright"/>
111	</appInfo>
112	<documentation>
113	Copyright (c) 2007 IBM Corporation and others.<br>
114	All rights reserved. This program and the accompanying materials are made
115	available under the terms of the Eclipse Public License v1.0 which
116	accompanies this distribution, and is available at
117	<a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
118	</documentation>
119	</annotation>
120
121	</schema>

Lines 12-24 Link Here

(-)tests/org/eclipse/jdt/debug/tests/core/EEDefinitionTests.java (-27 / +43 lines)
12		12
13	import java.io.File;	13	import java.io.File;
14		14
		15	import org.eclipse.core.runtime.CoreException;
15	import org.eclipse.core.runtime.IPath;	16	import org.eclipse.core.runtime.IPath;
16	import org.eclipse.core.runtime.IStatus;	17	import org.eclipse.core.runtime.IStatus;
17	import org.eclipse.core.runtime.Path;	18	import org.eclipse.core.runtime.Path;
18	import org.eclipse.core.runtime.Platform;	19	import org.eclipse.core.runtime.Platform;
19	import org.eclipse.jdt.debug.testplugin.JavaTestPlugin;	20	import org.eclipse.jdt.debug.testplugin.JavaTestPlugin;
20	import org.eclipse.jdt.debug.tests.AbstractDebugTest;	21	import org.eclipse.jdt.debug.tests.AbstractDebugTest;
21	import org.eclipse.jdt.internal.launching.StandardVMType;	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.IVMInstallType;	24	import org.eclipse.jdt.launching.IVMInstallType;
24	import org.eclipse.jdt.launching.JavaRuntime;	25	import org.eclipse.jdt.launching.JavaRuntime;
Lines 46-71 Link Here
46	}	47	}
47		48
48	/**	49	/**
49	* Tests that the EE file is a valid install location	50	* Tests that the EE file is a valid file
50	*/	51	*/
51	public void testValidateInstallLocation() {	52	public void testValidateDefinitionFile() {
52	File file = getEEFile();	53	File file = getEEFile();
53	IVMInstallType vmType = getStandardVMInstallType();
54	assertNotNull("Missing EE file", file);	54	assertNotNull("Missing EE file", file);
55	assertNotNull("Missing standard VM type", vmType);	55	IStatus status = EEVMType.validateDefinitionFile(file);
56	IStatus status = vmType.validateInstallLocation(file);
57	assertTrue("Invalid install location", status.isOK());	56	assertTrue("Invalid install location", status.isOK());
58	}	57	}
59		58
60	/**	59	/**
61	* Tests default libraries for the EE file	60	* Tests that the EE install location validation returns an INFO status.
62	*/	61	*/
63	public void testDefaultLibraries() {	62	public void testValidateInstallLocation() {
64	File file = getEEFile();	63	File file = getEEFile();
65	IVMInstallType vmType = getStandardVMInstallType();	64	IVMInstallType vmType = getVMInstallType();
66	assertNotNull("Missing EE file", file);	65	assertNotNull("Missing EE file", file);
67	assertNotNull("Missing standard VM type", vmType);	66	assertNotNull("Missing EE VM type", vmType);
68	LibraryLocation[] libs = vmType.getDefaultLibraryLocations(file);	67	IStatus status = vmType.validateInstallLocation(file);
		68	assertTrue("Invalid install location", status.getSeverity() == IStatus.INFO);
		69	}
		70
		71	/**
		72	* Tests libraries for the EE file
		73	*/
		74	public void testLibraries() {
		75	File file = getEEFile();
		76	assertNotNull("Missing EE file", file);
		77	LibraryLocation[] libs = EEVMType.getLibraryLocations(file);
69	String[] expected = new String[]{"end.jar", "classes.txt", "others.txt", "ext1.jar", "ext2.jar", "opt-ext.jar"};	78	String[] expected = new String[]{"end.jar", "classes.txt", "others.txt", "ext1.jar", "ext2.jar", "opt-ext.jar"};
70	assertEquals("Wrong number of libraries", expected.length, libs.length);	79	assertEquals("Wrong number of libraries", expected.length, libs.length);
71	for (int i = 0; i < expected.length; i++) {	80	for (int i = 0; i < expected.length; i++) {
Lines 87-101 Link Here
87	}	96	}
88		97
89	/**	98	/**
		99	* Tests default libraries for an EE VM type are empty.
		100	*/
		101	public void testDefaultLibraries() {
		102	File file = getEEFile();
		103	IVMInstallType vmType = getVMInstallType();
		104	assertNotNull("Missing EE file", file);
		105	assertNotNull("Missing EE VM type", vmType);
		106	LibraryLocation[] libs = vmType.getDefaultLibraryLocations(file);
		107	assertEquals("Wrong number of libraries", 0, libs.length);
		108	}
		109
		110	/**
90	* Tests default VM arguments. All arguments from the EE file should get passed through in the	111	* Tests default VM arguments. All arguments from the EE file should get passed through in the
91	* same order to the command line.	112	* same order to the command line.
92	*/	113	*/
93	public void testDefaultVMArguments() {	114	public void testVMArguments() {
94	File file = getEEFile();	115	File file = getEEFile();
95	StandardVMType vmType = (StandardVMType) getStandardVMInstallType();
96	assertNotNull("Missing EE file", file);	116	assertNotNull("Missing EE file", file);
97	assertNotNull("Missing standard VM type", vmType);	117	String defaultVMArguments = EEVMType.getVMArguments(file);
98	String defaultVMArguments = vmType.getDefaultVMArguments(file);
99	String[] expected = new String[] {	118	String[] expected = new String[] {
100	"-Dee.executable",	119	"-Dee.executable",
101	"-Dee.executable.console",	120	"-Dee.executable.console",
Lines 123-140 Link Here
123	/**	142	/**
124	* Test compatible environments	143	* Test compatible environments
125	*/	144	*/
126	public void testCompatibleEEs() {	145	public void testCompatibleEEs() throws CoreException {
127	IVMInstall install = null;	146	IVMInstall install = null;
128	StandardVMType vmType = (StandardVMType) getStandardVMInstallType();	147	EEVMType vmType = (EEVMType) getVMInstallType();
129	try {	148	try {
130	File file = getEEFile();	149	File file = getEEFile();
131	assertNotNull("Missing EE file", file);	150	assertNotNull("Missing EE file", file);
132	assertNotNull("Missing standard VM type", vmType);	151	assertNotNull("Missing EE VM type", vmType);
133	VMStandin vm = new VMStandin(vmType, "test-ee-file-id");	152	VMStandin standin = JavaRuntime.createVMFromDefinitionFile(file, "test-ee-file", "test-ee-file-id");
134	vm.setInstallLocation(file);	153	install = standin.convertToRealVM();
135	vm.setName("test-ee-file");
136	vm.setVMArgs(vmType.getDefaultVMArguments(file));
137	install = vm.convertToRealVM();
138		154
139	IExecutionEnvironmentsManager manager = JavaRuntime.getExecutionEnvironmentsManager();	155	IExecutionEnvironmentsManager manager = JavaRuntime.getExecutionEnvironmentsManager();
140	IExecutionEnvironment[] envs = manager.getExecutionEnvironments();	156	IExecutionEnvironment[] envs = manager.getExecutionEnvironments();
Lines 143-151 Link Here
143	IExecutionEnvironment env = envs[i];	159	IExecutionEnvironment env = envs[i];
144	if (env.getId().equals("CDC-1.1/Foundation-1.1")) {	160	if (env.getId().equals("CDC-1.1/Foundation-1.1")) {
145	found11 = true;	161	found11 = true;
146	assertTrue("Should be strictly compatible with " + env.getId(), env.isStrictlyCompatible(vm));	162	assertTrue("Should be strictly compatible with " + env.getId(), env.isStrictlyCompatible(install));
147	} else if (env.getId().indexOf("jdt.debug.tests") < 0) {	163	} else if (env.getId().indexOf("jdt.debug.tests") < 0) {
148	assertFalse("Should not be strictly compatible with " + env.getId(), env.isStrictlyCompatible(vm));	164	assertFalse("Should not be strictly compatible with " + env.getId(), env.isStrictlyCompatible(install));
149	}	165	}
150	}	166	}
151	assertTrue("Did not find foundation 1.1 environment", found11);	167	assertTrue("Did not find foundation 1.1 environment", found11);
Lines 160-166 Link Here
160	return JavaTestPlugin.getDefault().getFileInPlugin(TEST_EE_FILE);	176	return JavaTestPlugin.getDefault().getFileInPlugin(TEST_EE_FILE);
161	}	177	}
162		178
163	protected IVMInstallType getStandardVMInstallType() {	179	protected IVMInstallType getVMInstallType() {
164	return JavaRuntime.getVMInstallType(StandardVMType.ID_STANDARD_VM_TYPE);	180	return JavaRuntime.getVMInstallType(EEVMType.ID_EE_VM_TYPE);
165	}	181	}
166	}	182	}

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 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 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 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 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 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	}