Attachment #82330 for bug #204347




/*******************************************************************************
 * 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.equinox.internal.p2.target;

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.equinox.frameworkadmin.*;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.pde.ui.IProvisionerWizard;
import org.osgi.framework.Filter;
import org.osgi.framework.InvalidSyntaxException;
import org.osgi.util.tracker.ServiceTracker;

public class EquinoxAdminWizard extends Wizard implements IProvisionerWizard {

	private final static String FILTER_OBJECTCLASS = "(" + org.osgi.framework.Constants.OBJECTCLASS + "=" + FrameworkAdmin.class.getName() + ")";
	private final static String filterFwName = "(" + FrameworkAdmin.SERVICE_PROP_KEY_FW_NAME + "=Equinox)";
	private final static String filterLauncherName = "(" + FrameworkAdmin.SERVICE_PROP_KEY_LAUNCHER_NAME + "=Eclipse.exe)";
	private final static String filterFwAdmin = "(&" + FILTER_OBJECTCLASS + filterFwName + filterLauncherName + ")";
	private ServiceTracker fwAdminTracker;

	private DirectorySelectionPage fPage;
	private File[] files;

	public File[] getLocations() {
		return files;
	}

	public boolean performFinish() {
		File[] installFolders = fPage.getLocations();
		if (installFolders.length == 0)
			return true;

		FrameworkAdmin admin = getFrameworkAdmin();
		Manipulator manipulator = admin.getManipulator();

		LauncherData launcherData = manipulator.getLauncherData();
		launcherData.setLauncher(new File(installFolders[0], "eclipse")); //TODO This should likely be customized as part of the values entered in the wizard.
		launcherData.setFwConfigLocation(new File(installFolders[0], "configuration"));
		try {
			manipulator.load();
		} catch (IllegalStateException e2) {
			return false;
		} catch (FrameworkAdminRuntimeException e2) {
			return false;
		} catch (IOException e2) {
			return false;
		}
		BundleInfo[] bundles = manipulator.getConfigData().getBundles();
		List collectedValues = new ArrayList(bundles.length);
		for (int i = 0; i < bundles.length; i++) {
			try {
				collectedValues.add(new File(new URL(bundles[i].getLocation()).getFile()));
			} catch (MalformedURLException e) {
				//Ignore
			}
		}
		files = (File[]) collectedValues.toArray(new File[collectedValues.size()]);
		return true;
	}

	private FrameworkAdmin getFrameworkAdmin() {
		if (fwAdminTracker == null) {
			Filter filter;
			try {
				filter = Activator.getContext().createFilter(filterFwAdmin);
				fwAdminTracker = new ServiceTracker(Activator.getContext(), filter, null);
				fwAdminTracker.open();
			} catch (InvalidSyntaxException e) {
				// never happens
				e.printStackTrace();
			}
		}
		return (FrameworkAdmin) fwAdminTracker.getService();
	}

	public void addPages() {
		fPage = new DirectorySelectionPage("file system"); //$NON-NLS-1$
		addPage(fPage);
		super.addPages();
	}
}




/*******************************************************************************
 * Copyright (c) 2006 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.equinox.internal.p2.target;

//THIS IS A COPY OF THE CLASS OF THE SAME NAME CONTAINED IN PDE UI
import java.io.File;
import java.util.ArrayList;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.viewers.*;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.pde.internal.ui.IHelpContextIds;
import org.eclipse.pde.internal.ui.PDEUIMessages;
import org.eclipse.pde.internal.ui.util.SWTUtil;
import org.eclipse.pde.internal.ui.util.SharedLabelProvider;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.*;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.*;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.PlatformUI;

public class DirectorySelectionPage extends WizardPage {

	private static final Image fFolderImage = PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_OBJ_FOLDER).createImage();
	private static final String LAST_LOCATION = "last_location"; //$NON-NLS-1$

	class FolderLabelProvider extends SharedLabelProvider {

		public Image getImage(Object obj) {
			return fFolderImage;
		}
	}

	Text fDir = null;
	private TableViewer fTableViewer = null;
	private ArrayList fElements = new ArrayList();
	private Button fAddButton = null;
	private Button fRemoveButton = null;
	private String fLastLocation = null;

	protected DirectorySelectionPage(String pageName) {
		super(pageName);
		setTitle(PDEUIMessages.DirectorySelectionPage_title);
		setDescription(PDEUIMessages.DirectorySelectionPage_description);
		setPageComplete(false);
//		Preferences pref = PDECore.getDefault().getPluginPreferences();
//		fLastLocation = pref.getString(LAST_LOCATION);
//		if (fLastLocation.length() == 0)
//			fLastLocation = pref.getString(ICoreConstants.PLATFORM_PATH);
	}

	public void createControl(Composite parent) {
		Composite client = new Composite(parent, SWT.NONE);
		GridLayout layout = new GridLayout();
		layout.marginWidth = 2;
		layout.numColumns = 2;
		client.setLayout(layout);
		client.setLayoutData(new GridData(GridData.FILL_BOTH));

		Label label = new Label(client, SWT.None);
		label.setText(PDEUIMessages.DirectorySelectionPage_label);
		GridData gd = new GridData();
		gd.horizontalSpan = 2;
		label.setLayoutData(gd);

		fTableViewer = new TableViewer(client);
		fTableViewer.setLabelProvider(new FolderLabelProvider());
		fTableViewer.setContentProvider(new ArrayContentProvider());
		fTableViewer.setInput(fElements);
		gd = new GridData(GridData.FILL_BOTH);
		gd.verticalSpan = 3;
		fTableViewer.getControl().setLayoutData(gd);

		fTableViewer.addSelectionChangedListener(new ISelectionChangedListener() {

			public void selectionChanged(SelectionChangedEvent event) {
				updateButtons();
			}

		});
		fTableViewer.getTable().addKeyListener(new KeyAdapter() {
			public void keyPressed(KeyEvent event) {
				if (event.character == SWT.DEL && event.stateMask == 0) {
					handleRemove();
				}
			}
		});
		Dialog.applyDialogFont(fTableViewer.getControl());
		Dialog.applyDialogFont(label);

		createButtons(client);
		PlatformUI.getWorkbench().getHelpSystem().setHelp(client, IHelpContextIds.FILE_SYSTEM_PROVISIONING_PAGE);

		setControl(client);
	}

	protected void createButtons(Composite parent) {
		fAddButton = new Button(parent, SWT.PUSH);
		fAddButton.setText(PDEUIMessages.DirectorySelectionPage_add);
		fAddButton.setLayoutData(new GridData(GridData.VERTICAL_ALIGN_BEGINNING));
		SWTUtil.setButtonDimensionHint(fAddButton);
		fAddButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				handleAdd();
			}
		});

		fRemoveButton = new Button(parent, SWT.PUSH);
		fRemoveButton.setText(PDEUIMessages.DirectorySelectionPage_remove);
		fRemoveButton.setLayoutData(new GridData(GridData.VERTICAL_ALIGN_BEGINNING));
		SWTUtil.setButtonDimensionHint(fRemoveButton);
		fRemoveButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				handleRemove();
			}
		});
		updateButtons();
	}

	private void handleAdd() {
		DirectoryDialog dialog = new DirectoryDialog(getShell());
		dialog.setMessage(PDEUIMessages.DirectorySelectionPage_message);
		dialog.setFilterPath(fLastLocation);
		String path = dialog.open();
		if (path != null) {
			fLastLocation = path;
			File newDirectory = new File(path);
			fElements.add(newDirectory);
			fTableViewer.add(newDirectory);
			setPageComplete(true);
		}
	}

	private void handleRemove() {
		Object[] elements = ((IStructuredSelection) fTableViewer.getSelection()).toArray();
		for (int i = 0; i < elements.length; i++)
			fElements.remove(elements[i]);

		Table table = fTableViewer.getTable();
		int index = table.getSelectionIndex() - fElements.size();
		if (index > fElements.size())
			index = fElements.size() - 1;

		fTableViewer.remove(elements);
		table.setSelection(index);

		updateButtons();
		setPageComplete(!fElements.isEmpty());
	}

	protected void updateButtons() {
		int num = fTableViewer.getTable().getSelectionCount();
		fRemoveButton.setEnabled(num > 0);
	}

	public File[] getLocations() {
//		Preferences pref = PDECore.getDefault().getPluginPreferences();
//		pref.setValue(LAST_LOCATION, fLastLocation);
		return (File[]) fElements.toArray(new File[fElements.size()]);
	}
}




<plugin>
   <extension
         point="org.eclipse.ui.commands">
      <command
            defaultHandler="org.eclipse.equinox.internal.p2.target.menu.CreateNewP2TargetDefinitionHandler"
            id="org.eclipse.equinox.p2.target.createTargetDefinition"
            name="Create new p2 target definition">
      </command>
      <command
            defaultHandler="org.eclipse.equinox.internal.p2.target.menu.LoadTargetDefinitionHandler"
            id="org.eclipse.equinox.p2.target.loadTargetDefinition"
            name="Load Target Definition">
      </command>
      <command
            defaultHandler="org.eclipse.equinox.internal.p2.target.menu.OpenTargetDefinitionHandler"
            id="org.eclipse.equinox.p2.target.openTargetDefinition"
            name="Open Target Definition">
      </command>
   </extension>
   <extension
         point="org.eclipse.ui.menus">
      <menuContribution
            locationURI="menu:org.eclipse.ui.main.menu">
         <menu
               id="org.eclipse.equinox.p2.target.p2SelfHostMenu"
               label="P2 Self Hosting"
               mnemonic="P">
            <command
                  commandId="org.eclipse.equinox.p2.target.createTargetDefinition"
                  label="Create new target definition..."
                  mnemonic="C">
            </command>
            <menu
                  id="org.eclipse.equinox.p2.target.p2LoadTargetMenu"
                  label="Load Target Definition">
               <dynamic
                     class="org.eclipse.equinox.internal.p2.target.menu.LoadTargetDefinitionSubMenu"
                     id="org.eclipse.equinox.p2.target.loadTargetFromDefinition">
               </dynamic>
               <separator
                     name="org.eclipse.equinox.p2.target.separator1"
                     visible="true">
               </separator>
               <command
                     commandId="org.eclipse.equinox.p2.target.loadTargetDefinition"
                     label="Load Target Definition..."
                     style="push">
               </command>
            </menu>
            <menu
                  id="org.eclipse.equinox.p2.target.p2OpenTargetDefinitionMenu"
                  label="Open Target Definition">
               <dynamic
                     class="org.eclipse.equinox.internal.p2.target.menu.OpenTargetDefinitionSubMenu"
                     id="org.eclipse.equinox.p2.target.openTargetDefinition">
               </dynamic>
               <separator
                     name="org.eclipse.equinox.p2.target.separator2"
                     visible="true">
               </separator>
               <command
                     commandId="org.eclipse.equinox.p2.target.openTargetDefinition"
                     label="Open Target Definition..."
                     style="push">
               </command>
            </menu>
         </menu>
      </menuContribution>
   </extension>
</plugin>

Lines 9-15 Link Here

(-)META-INF/MANIFEST.MF (-1 / +4 lines)
9	org.eclipse.equinox.frameworkadmin,	9	org.eclipse.equinox.frameworkadmin,
10	org.eclipse.jface,	10	org.eclipse.jface,
11	org.eclipse.ui,	11	org.eclipse.ui,
12	org.eclipse.osgi	12	org.eclipse.osgi,
		13	org.eclipse.core.runtime,
		14	org.eclipse.core.resources,
		15	org.eclipse.ui.ide
13	Bundle-Activator: org.eclipse.equinox.internal.p2.target.Activator	16	Bundle-Activator: org.eclipse.equinox.internal.p2.target.Activator
14	Eclipse-LazyStart: true	17	Eclipse-LazyStart: true
15	Export-Package: org.eclipse.equinox.internal.p2.target;x-internal:=true	18	Export-Package: org.eclipse.equinox.internal.p2.target;x-internal:=true




package org.eclipse.equinox.internal.p2.target.menu;
import java.lang.reflect.InvocationTargetException;

import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.equinox.internal.p2.target.P2TargetDefinitionManager;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.window.Window;
import org.eclipse.pde.internal.core.LoadTargetOperation;
import org.eclipse.pde.internal.core.itarget.ITargetModel;
import org.eclipse.pde.internal.core.target.WorkspaceTargetModel;
import org.eclipse.pde.internal.ui.IPDEUIConstants;
import org.eclipse.pde.internal.ui.PDEPlugin;
import org.eclipse.pde.internal.ui.PDEUIMessages;
import org.eclipse.pde.internal.ui.editor.target.TargetErrorDialog;
import org.eclipse.pde.internal.ui.util.FileExtensionFilter;
import org.eclipse.pde.internal.ui.util.FileValidator;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.dialogs.ElementTreeSelectionDialog;
import org.eclipse.ui.ide.IDE;
import org.eclipse.ui.model.WorkbenchContentProvider;
import org.eclipse.ui.model.WorkbenchLabelProvider;
import org.eclipse.ui.part.ISetSelectionTarget;
import org.eclipse.ui.progress.IProgressService;


public class LoadTargetDefinitionHandler extends AbstractHandler {

	public Object execute(ExecutionEvent arg0) throws ExecutionException {
		ElementTreeSelectionDialog dialog =
			new ElementTreeSelectionDialog(PDEPlugin.getActiveWorkbenchShell(),
				new WorkbenchLabelProvider(),
				new WorkbenchContentProvider());
				
		dialog.setValidator(new FileValidator());
		dialog.setAllowMultiple(false);
		dialog.setTitle(PDEUIMessages.TargetPlatformPreferencePage_FileSelectionTitle); 
		dialog.setMessage(PDEUIMessages.TargetPlatformPreferencePage_FileSelectionMessage); 
		dialog.addFilter(new FileExtensionFilter("target"));  //$NON-NLS-1$
		dialog.setInput(PDEPlugin.getWorkspace().getRoot());

		if (dialog.open() == Window.OK) {
			final IFile file = (IFile)dialog.getFirstResult();
			final ITargetModel targetModel = new WorkspaceTargetModel(file, false);
			try{	
				targetModel.load();
			} catch (CoreException e){
				MessageDialog.openError(PDEPlugin.getActiveWorkbenchShell(), PDEUIMessages.TargetPlatformPreferencePage_invalidTitle, "Could not load the target definition specified: " + e.getMessage());
			}
			IRunnableWithProgress run = new IRunnableWithProgress() {
				public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
					try {
						if (!targetModel.isLoaded()) {
							MessageDialog.openError(PDEPlugin.getActiveWorkbenchShell(), PDEUIMessages.TargetPlatformPreferencePage_invalidTitle, PDEUIMessages.TargetPlatformPreferencePage_invalidDescription);
							monitor.done();
							return;
						}
						LoadTargetOperation op = new LoadTargetOperation(targetModel.getTarget(), file.getFullPath());
						PDEPlugin.getWorkspace().run(op, monitor);
						Object[] features = op.getMissingFeatures();
						Object[] plugins = op.getMissingPlugins();
						if (plugins.length + features.length > 0)
							TargetErrorDialog.showDialog(PDEPlugin.getActiveWorkbenchShell(), features, plugins);
					} catch (CoreException e) {
						throw new InvocationTargetException(e);
					} catch (OperationCanceledException e) {
						throw new InterruptedException(e.getMessage());
					} finally {
						monitor.done();
					}
				}
			};
			IProgressService service = PlatformUI.getWorkbench().getProgressService();
			try {
				service.runInUI(service, run, PDEPlugin.getWorkspace().getRoot());
			} catch (InvocationTargetException e) {
			} catch (InterruptedException e) {
			}
			
			P2TargetDefinitionManager.getDefault().addTarget(file.getFullPath());
			
		}
		
		return null;
	}

}




/*******************************************************************************
 * Copyright (c) 2005, 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.equinox.internal.p2.target;

import java.io.File;

import org.eclipse.core.resources.IFile;
import org.eclipse.pde.internal.core.itarget.IAdditionalLocation;
import org.eclipse.pde.internal.core.itarget.ILocationInfo;
import org.eclipse.pde.internal.core.itarget.ITarget;
import org.eclipse.pde.internal.core.itarget.ITargetModel;
import org.eclipse.pde.internal.core.itarget.ITargetPlugin;
import org.eclipse.pde.internal.ui.wizards.target.BaseTargetDefinitionOperation;

public class P2TargetDefinitionCreationOperation extends BaseTargetDefinitionOperation {

	private File[] fLocations;
	private String[] fBundles;
	private String fDefinitionName;
	
	public P2TargetDefinitionCreationOperation(IFile definitionFile, String definitionName, File[] locations, String[] bundles){
		super(definitionFile);
		fDefinitionName = definitionName;
		fLocations = locations;
		fBundles = bundles;
	}
	
	protected void initializeTarget(ITargetModel model) {
		ITarget target = model.getTarget();
		
		if (fDefinitionName != null && fDefinitionName.length() > 0){
			target.setName(fDefinitionName);
		}
		
		if (fLocations == null || fLocations.length <= 0){
			// TODO This is a problem, how to handle it?
		} else {
			ILocationInfo info = model.getFactory().createLocation();
			info.setPath(fLocations[0].getPath());
			info.setDefault(false);
			target.setLocationInfo(info);
			
			IAdditionalLocation[] locations = new IAdditionalLocation[fLocations.length-1];
			for (int i = 0; i < locations.length; i++) {
				IAdditionalLocation location = model.getFactory().createAdditionalLocation();
				location.setPath(fLocations[i+1].getPath());
				locations[i] = location;
			}
			target.addAdditionalDirectories(locations);
		}
		
		if (fBundles == null){
			target.setUseAllPlugins(true);
		} else if (fBundles.length > 0) {
			ITargetPlugin[] plugins = new ITargetPlugin[fBundles.length];
			for (int i = 0; i < plugins.length; i++) {
				ITargetPlugin plugin = model.getFactory().createPlugin();
				plugin.setId(fBundles[i]);
				plugins[i] = plugin;
			}
			target.addPlugins(plugins);
		}
	}

}




/*******************************************************************************
 * 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.equinox.internal.p2.target;

import java.io.File;
import java.lang.reflect.InvocationTargetException;

import org.eclipse.core.runtime.IPath;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.pde.internal.ui.PDEPlugin;
import org.eclipse.pde.internal.ui.PDEPluginImages;
import org.eclipse.pde.internal.ui.PDEUIMessages;
import org.eclipse.pde.internal.ui.wizards.PDEWizardNewFileCreationPage;

public class P2TargetDefinitionWizard extends Wizard {

	private PDEWizardNewFileCreationPage fPage1;
	private P2TargetDefinitionWizardPage fPage2;
	private IPath fFilePath;

	public P2TargetDefinitionWizard(){
		setWindowTitle("New P2 self-hosting target definition"); 
		setDefaultPageImageDescriptor(PDEPluginImages.DESC_TARGET_WIZ);
		setNeedsProgressMonitor(true);
	}
		
	public void addPages() {
		fPage1 = new PDEWizardNewFileCreationPage("Target Definition Location Page", StructuredSelection.EMPTY);
		fPage1.setFileExtension("target");
		fPage1.setTitle("p2 Target Definition");
		fPage1.setDescription("Choose a location for the target definition");
		addPage(fPage1);
		fPage2 = new P2TargetDefinitionWizardPage("p2 Target Definition Page"); //$NON-NLS-1$
		fPage2.setTitle("p2 Target Definition");
		fPage2.setDescription("Choose a p2 install for the target definition");
		addPage(fPage2);
		super.addPages();
	}
	
	public boolean canFinish() {
		return fPage1.isPageComplete() && fPage2.isPageComplete();
	}
		
	public boolean performFinish() {
		try {
			getContainer().run(false, true, new P2TargetDefinitionCreationOperation(fPage1.createNewFile(), fPage2.getDefinitionName(), fPage2.getDirectories(), fPage2.getBundles()));
			fFilePath = fPage1.getContainerFullPath().append(fPage1.getFileName());
		} catch (InvocationTargetException e) {
			PDEPlugin.logException(e);
			return false;
		} catch (InterruptedException e) {
			return false;
		}
		return true;
	}
		
	public IPath getTargetDefinition() {
		return fFilePath;
	}

}




package org.eclipse.equinox.internal.p2.target;

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

import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Preferences;
import org.eclipse.pde.internal.core.PDECore;
import org.eclipse.pde.internal.ui.PDEPlugin;

public class P2TargetDefinitionManager {

	private static P2TargetDefinitionManager fDefault;
	private List fTargets = new ArrayList();
	
	public final String KNOWN_P2_TARGET_DEFINITIONS = "target.knownTargetDefinitions";
	
	protected P2TargetDefinitionManager() {}
	
	public static P2TargetDefinitionManager getDefault(){
		if (fDefault == null){
			fDefault = new P2TargetDefinitionManager();
			fDefault.initializeFromPreferences();
		}
		return fDefault;
	}
	
	public List getTargets(){
		return fTargets;
	}
	
	public void addTarget(IPath targetDefinitionFile){
		if (!fTargets.contains(targetDefinitionFile)){
			fTargets.add(targetDefinitionFile);
			persistTargets();
		}
	}
	
	private void initializeFromPreferences(){
		Preferences prefs = PDECore.getDefault().getPluginPreferences();
		String locationString = prefs.getString(KNOWN_P2_TARGET_DEFINITIONS);
		String[] locations = locationString.split(",");
		boolean needToWriteOutPreferences = false;
		for (int i = 0; i < locations.length; i++) {
			if (locations[i].length() > 0){
				IPath path = Path.fromPortableString(locations[i]);
				IFile file = PDEPlugin.getWorkspace().getRoot().getFile(path);
				if (file.exists() && !fTargets.contains(path)){
					fTargets.add(path);
				} else {
					needToWriteOutPreferences = true;
				}
			}
		}
		if (needToWriteOutPreferences){
			persistTargets();
		}
	}
	
	private void persistTargets(){
		Preferences prefs = PDECore.getDefault().getPluginPreferences();
		StringBuffer locationString = new StringBuffer();
		for (Iterator iterator = fTargets.iterator(); iterator.hasNext();) {
			IPath target = (IPath) iterator.next();
			locationString.append(target.toPortableString());
			if (iterator.hasNext()){
				locationString.append(',');
			}
		}
		prefs.setValue(KNOWN_P2_TARGET_DEFINITIONS, locationString.toString());
	}
	
	
}




package org.eclipse.equinox.internal.p2.target.menu;
import java.io.File;

import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.equinox.internal.p2.target.P2TargetDefinitionManager;
import org.eclipse.equinox.internal.p2.target.P2TargetDefinitionWizard;
import org.eclipse.jface.wizard.WizardDialog;
import org.eclipse.pde.internal.ui.PDEPlugin;
import org.eclipse.pde.internal.ui.util.SWTUtil;
import org.eclipse.pde.internal.ui.wizards.provisioner.AddTargetPluginsWizard;


public class CreateNewP2TargetDefinitionHandler extends AbstractHandler {

	public Object execute(ExecutionEvent event) throws ExecutionException {
		P2TargetDefinitionWizard wizard = new P2TargetDefinitionWizard();
		WizardDialog dialog = new WizardDialog(PDEPlugin.getActiveWorkbenchShell(), wizard);
		dialog.create();
		dialog.open();
		
		P2TargetDefinitionManager.getDefault().addTarget(wizard.getTargetDefinition());
				
		return 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.equinox.internal.p2.target;

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashSet;
import java.util.Set;
import java.util.Stack;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.equinox.frameworkadmin.BundleInfo;
import org.eclipse.equinox.frameworkadmin.FrameworkAdmin;
import org.eclipse.equinox.frameworkadmin.FrameworkAdminRuntimeException;
import org.eclipse.equinox.frameworkadmin.LauncherData;
import org.eclipse.equinox.frameworkadmin.Manipulator;
import org.eclipse.jface.dialogs.IMessageProvider;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.pde.internal.ui.PDEPlugin;
import org.eclipse.swt.SWT;
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.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.DirectoryDialog;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.swt.widgets.Text;
import org.osgi.framework.Filter;
import org.osgi.framework.InvalidSyntaxException;
import org.osgi.util.tracker.ServiceTracker;

/**
 * Page used to select an equinox install configuration to load bundles from.
 * 
 * @since 3.4
 */
public class P2TargetDefinitionWizardPage extends WizardPage {
	
	// TODO Get this from the plugin class
	private static final String PLUGIN_ID = "org.eclipse.equinox.p2.target";
	
	private final static String FILTER_OBJECTCLASS = "(" + org.osgi.framework.Constants.OBJECTCLASS + "=" + FrameworkAdmin.class.getName() + ")";
	private final static String filterFwName = "(" + FrameworkAdmin.SERVICE_PROP_KEY_FW_NAME + "=Equinox)";
	private final static String filterLauncherName = "(" + FrameworkAdmin.SERVICE_PROP_KEY_LAUNCHER_NAME + "=Eclipse.exe)";
	private final static String filterFwAdmin = "(&" + FILTER_OBJECTCLASS + filterFwName + filterLauncherName + ")";
	private ServiceTracker fwAdminTracker;

	private Text fInstallLocation;
	private Text fTargetDefinitionName;
	private Table fBundleTable;
	
	private File[] fBundleDirs;
	private String[] fBundleIDs;
	
//	private IStatus fNameStatus;
	private IStatus fInstallStatus;
	
	public P2TargetDefinitionWizardPage(String pageName) {
		super(pageName);
		setPageComplete(false);
		// TODO Determine this from entries in wizard
	}
	
//	/* (non-Javadoc)
//	 * @see org.eclipse.jface.dialogs.IDialogPage#getImage()
//	 */
//	public Image getImage() {
//		// TODO Get an image for this wizard
//		return null;
//	}	
	
	public File[] getDirectories(){
		return fBundleDirs;
	}
	
	public String[] getBundles(){
		return fBundleIDs;
	}
	
	public String getDefinitionName(){
		return fTargetDefinitionName.getText().trim();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets.Composite)
	 */
	public void createControl(Composite parent) {
		// create a composite with standard margins and spacing
		Composite composite = new Composite(parent, SWT.NONE);
		GridLayout layout = new GridLayout();
		layout.numColumns = 3;
		composite.setLayout(layout);
		composite.setLayoutData(new GridData(GridData.FILL_BOTH));
		
		Label label = new Label(composite, SWT.NONE);
		label.setText("Target Name:");
		GridData gd = new GridData(GridData.FILL_HORIZONTAL);
		gd.horizontalSpan = 1;
		gd.grabExcessHorizontalSpace = false;
		label.setLayoutData(gd);
		
		fTargetDefinitionName = new Text(composite, SWT.SINGLE | SWT.BORDER);
		fTargetDefinitionName.setFont(composite.getFont());
    	gd = new GridData(GridData.FILL_HORIZONTAL);
    	gd.horizontalSpan = 2;
    	fTargetDefinitionName.setLayoutData(gd);
		
    	label = new Label(composite, SWT.NONE);
		label.setText("Install Location:");
		gd = new GridData(GridData.FILL_HORIZONTAL);
		gd.horizontalSpan = 1;
		gd.grabExcessHorizontalSpace = false;
		label.setLayoutData(gd);
    	
		fInstallLocation = new Text(composite, SWT.SINGLE | SWT.BORDER);
		fInstallLocation.setFont(composite.getFont());
    	gd = new GridData(GridData.FILL_HORIZONTAL);
    	gd.horizontalSpan = 1;
    	fInstallLocation.setLayoutData(gd);
    	
    	Button folders = new Button(composite, SWT.PUSH);
    	folders.setFont(composite.getFont());
    	folders.setText("Browse...");
		gd = new GridData();
		gd.horizontalSpan = 1;
		gd.horizontalAlignment = GridData.END;
		folders.setLayoutData(gd);	
    	
		label = new Label(composite, SWT.NONE);
		label.setText("Target Bundles:");
		gd = new GridData(GridData.FILL_HORIZONTAL);
		gd.horizontalSpan = 1;
		gd.grabExcessHorizontalSpace = false;
		label.setLayoutData(gd);
		
    	fBundleTable = new Table(composite, SWT.BORDER);
    	gd = new GridData(GridData.FILL_BOTH);
    	gd.horizontalSpan = 3;
    	fBundleTable.setLayoutData(gd);
	
	
	//add the listeners now to prevent them from monkeying with initialized settings
//    	fTargetDefinitionName.addModifyListener(new ModifyListener() {
//			public void modifyText(ModifyEvent e) {
//				validateTargetName();
//			}
//		});
    	fInstallLocation.addModifyListener(new ModifyListener() {
			public void modifyText(ModifyEvent e) {
				validateEquinoxInstallLocation();
			}
		});
		folders.addSelectionListener(new SelectionListener() {
			public void widgetDefaultSelected(SelectionEvent e) {}
			public void widgetSelected(SelectionEvent e) {
				DirectoryDialog dialog = new DirectoryDialog(getShell());
				File file = new File(fInstallLocation.getText());
				String text = fInstallLocation.getText();
				if (file.isFile()) {
					text = file.getParentFile().getAbsolutePath();
				}
				dialog.setFilterPath(text);
				dialog.setMessage("Select a p2 install directory"); 
				String newPath = dialog.open();
				if (newPath != null) {
					fInstallLocation.setText(newPath);
				}
			}
		});
			
		setControl(composite);
//		fNameStatus = new Status(IStatus.WARNING, PLUGIN_ID, "Enter a name for this target definition");
		fInstallStatus = new Status(IStatus.WARNING, PLUGIN_ID, "Enter a valid p2 install directory"); 
		
	}
	
//	private void validateTargetName() {
//		if (fTargetDefinitionName.getText().trim().length() > 0){
//			fNameStatus = Status.OK_STATUS;
//		} else {
//			fNameStatus = new Status(IStatus.WARNING, PLUGIN_ID, "Enter a name for this target definition");
//		}
//		updatePageStatus();
//	}
	
	private void validateEquinoxInstallLocation() {
		String locationName = fInstallLocation.getText().trim();
		fBundleTable.removeAll();
		fInstallStatus = Status.OK_STATUS;
		File installDir = null;
		File configurationFolder = null;
		File eclipseLauncher = null;
		if (locationName.length() == 0) {
			fInstallStatus = new Status(IStatus.WARNING, PLUGIN_ID, "Enter a valid p2 install directory"); 
		} 
		else {
			installDir = new File(locationName);
			if (!installDir.exists()) {
				fInstallStatus = new Status(IStatus.WARNING, PLUGIN_ID, "The entered location does not exist"); 
			} 
			else {
				// TODO We should let the user choose these values
				configurationFolder = new File(installDir, "configuration");
				if (!configurationFolder.exists()){
					fInstallStatus = new Status(IStatus.WARNING, PLUGIN_ID, "A configuration folder could not be found at: " + configurationFolder); 
				} else{
					eclipseLauncher = new File(installDir, "eclipse");
//					if (!eclipseLauncher.exists()){
//						s = new Status(IStatus.WARNING, PLUGIN_ID, "The launcher could not be found at: " + eclipseLauncher);
//					} else {
//					}
				}
			}
		}
		if (fInstallStatus.isOK()) {
			
			FrameworkAdmin admin = getFrameworkAdmin();
			
			if (admin != null){
			
				Manipulator manipulator = admin.getManipulator();
	
				LauncherData launcherData = manipulator.getLauncherData();
				launcherData.setLauncher(eclipseLauncher); 
				launcherData.setFwConfigLocation(configurationFolder);
				try {
					manipulator.load();
				} catch (IllegalStateException e) {
					fInstallStatus = new Status(IStatus.WARNING, PLUGIN_ID, "Problem loading manipulator: " + e);
				} catch (FrameworkAdminRuntimeException e) {
					fInstallStatus = new Status(IStatus.WARNING, PLUGIN_ID, "Problem loading manipulator: " + e);
				} catch (IOException e) {
					fInstallStatus = new Status(IStatus.WARNING, PLUGIN_ID, "Problem loading manipulator: " + e);
				}
				if (fInstallStatus.isOK()){
					BundleInfo[] bundles = manipulator.getConfigData().getBundles();
					Set bundleNames = new HashSet(bundles.length);
					Set bundleDirs = new HashSet();
					for (int i = 0; i < bundles.length; i++) {
						try {
							String bundleID = bundles[i].getSymbolicName();
							File bundleLocation = new File(new URL(bundles[i].getLocation()).getFile());
							File parentDir = bundleLocation.getParentFile();
							if (parentDir.isDirectory()){
								bundleDirs.add(parentDir);
							}
							bundleNames.add(bundleID);
						} catch (MalformedURLException e) {
							//Ignore
						}
					}
					fBundleDirs = (File[]) bundleDirs.toArray(new File[bundleDirs.size()]);
					fBundleIDs = (String[]) bundleNames.toArray(new String[bundleNames.size()]);
					System.out.println("Success! " + fBundleIDs);
					for (int i = 0; i < fBundleIDs.length; i++) {
						TableItem tableItem= new TableItem(fBundleTable, SWT.NONE);
						tableItem.setText(0, fBundleIDs[i]);
					}
				}
			} else {
				fInstallStatus = new Status(IStatus.WARNING, PLUGIN_ID, "Framework Admin is not available, unable to load install"); 
			}
		}
		updatePageStatus();
	}
	
	private FrameworkAdmin getFrameworkAdmin() {
		if (fwAdminTracker == null) {
			Filter filter;
			try {
				filter = PDEPlugin.getDefault().getBundleContext().createFilter(filterFwAdmin);
				fwAdminTracker = new ServiceTracker(PDEPlugin.getDefault().getBundleContext(), filter, null);
				fwAdminTracker.open();
			} catch (InvalidSyntaxException e) {
				// never happens
				e.printStackTrace();
			}
		}
		return (FrameworkAdmin) fwAdminTracker.getService();
	}
	
	/**
	 * Updates the status message on the page, based on the status of the VM and other
	 * status provided by the page.
	 */
	protected void updatePageStatus() {
		IStatus max = Status.OK_STATUS;
		if (/*fNameStatus == null ||*/ fInstallStatus == null){
			return;
		}
//		if (fNameStatus.getSeverity() > max.getSeverity()) {
//			max = fNameStatus;
//		}
		if (fInstallStatus.getSeverity() > max.getSeverity()) {
			max = fInstallStatus;
		}
		if (max.isOK()) {
			setMessage(null, IMessageProvider.NONE);
		} else {
			setStatusMessage(max);
		}
		setPageComplete(max.isOK() || max.getSeverity() == IStatus.INFO);
	}	
	
	/**
	 * 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;
			}
		}
	}	
	
}




package org.eclipse.equinox.internal.p2.target.menu;

import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.equinox.internal.p2.target.P2TargetDefinitionManager;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.ActionContributionItem;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.pde.internal.core.LoadTargetOperation;
import org.eclipse.pde.internal.core.itarget.ITargetModel;
import org.eclipse.pde.internal.core.target.WorkspaceTargetModel;
import org.eclipse.pde.internal.ui.IPDEUIConstants;
import org.eclipse.pde.internal.ui.PDEPlugin;
import org.eclipse.pde.internal.ui.PDEUIMessages;
import org.eclipse.pde.internal.ui.editor.target.TargetErrorDialog;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.actions.CompoundContributionItem;
import org.eclipse.ui.ide.IDE;
import org.eclipse.ui.part.ISetSelectionTarget;
import org.eclipse.ui.progress.IProgressService;

public class LoadTargetDefinitionSubMenu extends CompoundContributionItem {

	@Override
	protected IContributionItem[] getContributionItems() {
		List targetList = P2TargetDefinitionManager.getDefault().getTargets();
		List contributionItems = new ArrayList(targetList.size());
		for (Iterator targetIter = targetList.iterator(); targetIter.hasNext();) {
			IPath currentTarget = (IPath) targetIter.next();
			if (currentTarget != null){
				LoadTargetDefinitionAction action = new LoadTargetDefinitionAction(currentTarget);
				contributionItems.add(new ActionContributionItem(action));
			}
		}
		return (IContributionItem[])contributionItems.toArray(new IContributionItem[contributionItems.size()]);
	}
	
	class LoadTargetDefinitionAction extends Action {
		
		private IPath fTargetDefinition;
		
		public LoadTargetDefinitionAction(IPath targetDefinitionPath){
			fTargetDefinition = targetDefinitionPath;
		}
		
		public void run() {
			final IFile file = PDEPlugin.getWorkspace().getRoot().getFile(fTargetDefinition);
			final ITargetModel targetModel = new WorkspaceTargetModel(file, false);
			try{	
				targetModel.load();
			} catch (CoreException e){
				MessageDialog.openError(PDEPlugin.getActiveWorkbenchShell(), PDEUIMessages.TargetPlatformPreferencePage_invalidTitle, "Could not load the target definition specified: " + e.getMessage());
			}
			IRunnableWithProgress run = new IRunnableWithProgress() {
				public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
					try {
						if (!targetModel.isLoaded()) {
							MessageDialog.openError(PDEPlugin.getActiveWorkbenchShell(), PDEUIMessages.TargetPlatformPreferencePage_invalidTitle, PDEUIMessages.TargetPlatformPreferencePage_invalidDescription);
							monitor.done();
							return;
						}
						LoadTargetOperation op = new LoadTargetOperation(targetModel.getTarget(), fTargetDefinition);
						PDEPlugin.getWorkspace().run(op, monitor);
						Object[] features = op.getMissingFeatures();
						Object[] plugins = op.getMissingPlugins();
						if (plugins.length + features.length > 0)
							TargetErrorDialog.showDialog(PDEPlugin.getActiveWorkbenchShell(), features, plugins);
					} catch (CoreException e) {
						throw new InvocationTargetException(e);
					} catch (OperationCanceledException e) {
						throw new InterruptedException(e.getMessage());
					} finally {
						monitor.done();
					}
				}
			};
			IProgressService service = PlatformUI.getWorkbench().getProgressService();
			try {
				service.runInUI(service, run, PDEPlugin.getWorkspace().getRoot());
			} catch (InvocationTargetException e) {
			} catch (InterruptedException e) {
			}
		}
		
		public String getText() {
			return "Load " + fTargetDefinition;
		}
		
	}

}




package org.eclipse.equinox.internal.p2.target.menu;
import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.equinox.internal.p2.target.P2TargetDefinitionManager;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.window.Window;
import org.eclipse.pde.internal.ui.IPDEUIConstants;
import org.eclipse.pde.internal.ui.PDEPlugin;
import org.eclipse.pde.internal.ui.PDEUIMessages;
import org.eclipse.pde.internal.ui.util.FileExtensionFilter;
import org.eclipse.pde.internal.ui.util.FileValidator;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.dialogs.ElementTreeSelectionDialog;
import org.eclipse.ui.ide.IDE;
import org.eclipse.ui.model.WorkbenchContentProvider;
import org.eclipse.ui.model.WorkbenchLabelProvider;
import org.eclipse.ui.part.ISetSelectionTarget;


public class OpenTargetDefinitionHandler extends AbstractHandler {

	public Object execute(ExecutionEvent arg0) throws ExecutionException {
		ElementTreeSelectionDialog dialog =
			new ElementTreeSelectionDialog(PDEPlugin.getActiveWorkbenchShell(),
				new WorkbenchLabelProvider(),
				new WorkbenchContentProvider());
				
		dialog.setValidator(new FileValidator());
		dialog.setAllowMultiple(false);
		dialog.setTitle(PDEUIMessages.TargetPlatformPreferencePage_FileSelectionTitle); 
		dialog.setMessage(PDEUIMessages.TargetPlatformPreferencePage_FileSelectionMessage); 
		dialog.addFilter(new FileExtensionFilter("target"));  //$NON-NLS-1$
		dialog.setInput(PDEPlugin.getWorkspace().getRoot());

		if (dialog.open() == Window.OK) {
			IFile file = (IFile)dialog.getFirstResult();
			IWorkbenchWindow ww = PDEPlugin.getActiveWorkbenchWindow();
			if (ww == null) {
				return null;
			}
			IWorkbenchPage page = ww.getActivePage();
			if (page == null || !file.exists())
				return null;
			IWorkbenchPart focusPart = page.getActivePart();
			if (focusPart instanceof ISetSelectionTarget) {
				ISelection selection = new StructuredSelection(file);
				((ISetSelectionTarget) focusPart).selectReveal(selection);
			}
			try {
				IDE.openEditor(page, file, IPDEUIConstants.TARGET_EDITOR_ID);
			} catch (PartInitException e) {
			}
			
			P2TargetDefinitionManager.getDefault().addTarget(file.getFullPath());
			
		}
		
		return null;
	}

}




package org.eclipse.equinox.internal.p2.target.menu;

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

import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.equinox.internal.p2.target.P2TargetDefinitionManager;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.ActionContributionItem;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.pde.internal.ui.IPDEUIConstants;
import org.eclipse.pde.internal.ui.PDEPlugin;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.actions.CompoundContributionItem;
import org.eclipse.ui.ide.IDE;
import org.eclipse.ui.part.ISetSelectionTarget;

public class OpenTargetDefinitionSubMenu extends CompoundContributionItem {

	@Override
	protected IContributionItem[] getContributionItems() {
		List targetList = P2TargetDefinitionManager.getDefault().getTargets();
		List contributionItems = new ArrayList(targetList.size());
		for (Iterator targetIter = targetList.iterator(); targetIter.hasNext();) {
			IPath currentTarget = (IPath) targetIter.next();
			if (currentTarget != null){
				OpenTargetDefinitionAction action = new OpenTargetDefinitionAction(currentTarget);
				contributionItems.add(new ActionContributionItem(action));
			}
		}
		return (IContributionItem[])contributionItems.toArray(new IContributionItem[contributionItems.size()]);
	}
	
	class OpenTargetDefinitionAction extends Action {
		
		private IPath fTargetDefinition;
		
		public OpenTargetDefinitionAction(IPath targetDefinitionPath){
			fTargetDefinition = targetDefinitionPath;
		}
		
		public void run() {
			IFile file = PDEPlugin.getWorkspace().getRoot().getFile(fTargetDefinition);
			IWorkbenchWindow ww = PDEPlugin.getActiveWorkbenchWindow();
			if (ww == null) {
				return;
			}
			IWorkbenchPage page = ww.getActivePage();
			if (page == null || !file.exists())
				return;
			IWorkbenchPart focusPart = page.getActivePart();
			if (focusPart instanceof ISetSelectionTarget) {
				ISelection selection = new StructuredSelection(file);
				((ISetSelectionTarget) focusPart).selectReveal(selection);
			}
			try {
				IDE.openEditor(page, file, IPDEUIConstants.TARGET_EDITOR_ID);
			} catch (PartInitException e) {
			}
		}
		
		public String getText() {
			return "Open " + fTargetDefinition;
		}
		
	}

}

Return to bug 204347

Removed Link Here

(-)src/org/eclipse/equinox/internal/p2/target/EquinoxAdminWizard.java (-92 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 IBM Corporation and others. All rights reserved. This
3	* program and the accompanying materials are made available under the terms of
4	* the Eclipse Public License v1.0 which accompanies this distribution, and is
5	* available at http://www.eclipse.org/legal/epl-v10.html
6	*
7	* Contributors: IBM Corporation - initial API and implementation
8	******************************************************************************/
9	package org.eclipse.equinox.internal.p2.target;
10
11	import java.io.File;
12	import java.io.IOException;
13	import java.net.MalformedURLException;
14	import java.net.URL;
15	import java.util.ArrayList;
16	import java.util.List;
17	import org.eclipse.equinox.frameworkadmin.*;
18	import org.eclipse.jface.wizard.Wizard;
19	import org.eclipse.pde.ui.IProvisionerWizard;
20	import org.osgi.framework.Filter;
21	import org.osgi.framework.InvalidSyntaxException;
22	import org.osgi.util.tracker.ServiceTracker;
23
24	public class EquinoxAdminWizard extends Wizard implements IProvisionerWizard {
25
26	private final static String FILTER_OBJECTCLASS = "(" + org.osgi.framework.Constants.OBJECTCLASS + "=" + FrameworkAdmin.class.getName() + ")";
27	private final static String filterFwName = "(" + FrameworkAdmin.SERVICE_PROP_KEY_FW_NAME + "=Equinox)";
28	private final static String filterLauncherName = "(" + FrameworkAdmin.SERVICE_PROP_KEY_LAUNCHER_NAME + "=Eclipse.exe)";
29	private final static String filterFwAdmin = "(&" + FILTER_OBJECTCLASS + filterFwName + filterLauncherName + ")";
30	private ServiceTracker fwAdminTracker;
31
32	private DirectorySelectionPage fPage;
33	private File[] files;
34
35	public File[] getLocations() {
36	return files;
37	}
38
39	public boolean performFinish() {
40	File[] installFolders = fPage.getLocations();
41	if (installFolders.length == 0)
42	return true;
43
44	FrameworkAdmin admin = getFrameworkAdmin();
45	Manipulator manipulator = admin.getManipulator();
46
47	LauncherData launcherData = manipulator.getLauncherData();
48	launcherData.setLauncher(new File(installFolders[0], "eclipse")); //TODO This should likely be customized as part of the values entered in the wizard.
49	launcherData.setFwConfigLocation(new File(installFolders[0], "configuration"));
50	try {
51	manipulator.load();
52	} catch (IllegalStateException e2) {
53	return false;
54	} catch (FrameworkAdminRuntimeException e2) {
55	return false;
56	} catch (IOException e2) {
57	return false;
58	}
59	BundleInfo[] bundles = manipulator.getConfigData().getBundles();
60	List collectedValues = new ArrayList(bundles.length);
61	for (int i = 0; i < bundles.length; i++) {
62	try {
63	collectedValues.add(new File(new URL(bundles[i].getLocation()).getFile()));
64	} catch (MalformedURLException e) {
65	//Ignore
66	}
67	}
68	files = (File[]) collectedValues.toArray(new File[collectedValues.size()]);
69	return true;
70	}
71
72	private FrameworkAdmin getFrameworkAdmin() {
73	if (fwAdminTracker == null) {
74	Filter filter;
75	try {
76	filter = Activator.getContext().createFilter(filterFwAdmin);
77	fwAdminTracker = new ServiceTracker(Activator.getContext(), filter, null);
78	fwAdminTracker.open();
79	} catch (InvalidSyntaxException e) {
80	// never happens
81	e.printStackTrace();
82	}
83	}
84	return (FrameworkAdmin) fwAdminTracker.getService();
85	}
86
87	public void addPages() {
88	fPage = new DirectorySelectionPage("file system"); //$NON-NLS-1$
89	addPage(fPage);
90	super.addPages();
91	}
92	}

Removed Link Here

(-)src/org/eclipse/equinox/internal/p2/target/DirectorySelectionPage.java (-171 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 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.equinox.internal.p2.target;
12
13	//THIS IS A COPY OF THE CLASS OF THE SAME NAME CONTAINED IN PDE UI
14	import java.io.File;
15	import java.util.ArrayList;
16	import org.eclipse.jface.dialogs.Dialog;
17	import org.eclipse.jface.viewers.*;
18	import org.eclipse.jface.wizard.WizardPage;
19	import org.eclipse.pde.internal.ui.IHelpContextIds;
20	import org.eclipse.pde.internal.ui.PDEUIMessages;
21	import org.eclipse.pde.internal.ui.util.SWTUtil;
22	import org.eclipse.pde.internal.ui.util.SharedLabelProvider;
23	import org.eclipse.swt.SWT;
24	import org.eclipse.swt.events.*;
25	import org.eclipse.swt.graphics.Image;
26	import org.eclipse.swt.layout.GridData;
27	import org.eclipse.swt.layout.GridLayout;
28	import org.eclipse.swt.widgets.*;
29	import org.eclipse.ui.ISharedImages;
30	import org.eclipse.ui.PlatformUI;
31
32	public class DirectorySelectionPage extends WizardPage {
33
34	private static final Image fFolderImage = PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_OBJ_FOLDER).createImage();
35	private static final String LAST_LOCATION = "last_location"; //$NON-NLS-1$
36
37	class FolderLabelProvider extends SharedLabelProvider {
38
39	public Image getImage(Object obj) {
40	return fFolderImage;
41	}
42	}
43
44	Text fDir = null;
45	private TableViewer fTableViewer = null;
46	private ArrayList fElements = new ArrayList();
47	private Button fAddButton = null;
48	private Button fRemoveButton = null;
49	private String fLastLocation = null;
50
51	protected DirectorySelectionPage(String pageName) {
52	super(pageName);
53	setTitle(PDEUIMessages.DirectorySelectionPage_title);
54	setDescription(PDEUIMessages.DirectorySelectionPage_description);
55	setPageComplete(false);
56	// Preferences pref = PDECore.getDefault().getPluginPreferences();
57	// fLastLocation = pref.getString(LAST_LOCATION);
58	// if (fLastLocation.length() == 0)
59	// fLastLocation = pref.getString(ICoreConstants.PLATFORM_PATH);
60	}
61
62	public void createControl(Composite parent) {
63	Composite client = new Composite(parent, SWT.NONE);
64	GridLayout layout = new GridLayout();
65	layout.marginWidth = 2;
66	layout.numColumns = 2;
67	client.setLayout(layout);
68	client.setLayoutData(new GridData(GridData.FILL_BOTH));
69
70	Label label = new Label(client, SWT.None);
71	label.setText(PDEUIMessages.DirectorySelectionPage_label);
72	GridData gd = new GridData();
73	gd.horizontalSpan = 2;
74	label.setLayoutData(gd);
75
76	fTableViewer = new TableViewer(client);
77	fTableViewer.setLabelProvider(new FolderLabelProvider());
78	fTableViewer.setContentProvider(new ArrayContentProvider());
79	fTableViewer.setInput(fElements);
80	gd = new GridData(GridData.FILL_BOTH);
81	gd.verticalSpan = 3;
82	fTableViewer.getControl().setLayoutData(gd);
83
84	fTableViewer.addSelectionChangedListener(new ISelectionChangedListener() {
85
86	public void selectionChanged(SelectionChangedEvent event) {
87	updateButtons();
88	}
89
90	});
91	fTableViewer.getTable().addKeyListener(new KeyAdapter() {
92	public void keyPressed(KeyEvent event) {
93	if (event.character == SWT.DEL && event.stateMask == 0) {
94	handleRemove();
95	}
96	}
97	});
98	Dialog.applyDialogFont(fTableViewer.getControl());
99	Dialog.applyDialogFont(label);
100
101	createButtons(client);
102	PlatformUI.getWorkbench().getHelpSystem().setHelp(client, IHelpContextIds.FILE_SYSTEM_PROVISIONING_PAGE);
103
104	setControl(client);
105	}
106
107	protected void createButtons(Composite parent) {
108	fAddButton = new Button(parent, SWT.PUSH);
109	fAddButton.setText(PDEUIMessages.DirectorySelectionPage_add);
110	fAddButton.setLayoutData(new GridData(GridData.VERTICAL_ALIGN_BEGINNING));
111	SWTUtil.setButtonDimensionHint(fAddButton);
112	fAddButton.addSelectionListener(new SelectionAdapter() {
113	public void widgetSelected(SelectionEvent e) {
114	handleAdd();
115	}
116	});
117
118	fRemoveButton = new Button(parent, SWT.PUSH);
119	fRemoveButton.setText(PDEUIMessages.DirectorySelectionPage_remove);
120	fRemoveButton.setLayoutData(new GridData(GridData.VERTICAL_ALIGN_BEGINNING));
121	SWTUtil.setButtonDimensionHint(fRemoveButton);
122	fRemoveButton.addSelectionListener(new SelectionAdapter() {
123	public void widgetSelected(SelectionEvent e) {
124	handleRemove();
125	}
126	});
127	updateButtons();
128	}
129
130	private void handleAdd() {
131	DirectoryDialog dialog = new DirectoryDialog(getShell());
132	dialog.setMessage(PDEUIMessages.DirectorySelectionPage_message);
133	dialog.setFilterPath(fLastLocation);
134	String path = dialog.open();
135	if (path != null) {
136	fLastLocation = path;
137	File newDirectory = new File(path);
138	fElements.add(newDirectory);
139	fTableViewer.add(newDirectory);
140	setPageComplete(true);
141	}
142	}
143
144	private void handleRemove() {
145	Object[] elements = ((IStructuredSelection) fTableViewer.getSelection()).toArray();
146	for (int i = 0; i < elements.length; i++)
147	fElements.remove(elements[i]);
148
149	Table table = fTableViewer.getTable();
150	int index = table.getSelectionIndex() - fElements.size();
151	if (index > fElements.size())
152	index = fElements.size() - 1;
153
154	fTableViewer.remove(elements);
155	table.setSelection(index);
156
157	updateButtons();
158	setPageComplete(!fElements.isEmpty());
159	}
160
161	protected void updateButtons() {
162	int num = fTableViewer.getTable().getSelectionCount();
163	fRemoveButton.setEnabled(num > 0);
164	}
165
166	public File[] getLocations() {
167	// Preferences pref = PDECore.getDefault().getPluginPreferences();
168	// pref.setValue(LAST_LOCATION, fLastLocation);
169	return (File[]) fElements.toArray(new File[fElements.size()]);
170	}
171	}

Lines 1-13 Link Here

(-)plugin.xml (-9 / +66 lines)
1	<plugin>	1	<plugin>
2	<extension	2	<extension
3	point="org.eclipse.pde.ui.targetProvisioners">	3	point="org.eclipse.ui.commands">
4	<provisioner	4	<command
5	class="org.eclipse.equinox.internal.p2.target.EquinoxAdminWizard"	5	defaultHandler="org.eclipse.equinox.internal.p2.target.menu.CreateNewP2TargetDefinitionHandler"
6	id="org.eclipse.equinox.p2.target.equinoxadmin"	6	id="org.eclipse.equinox.p2.target.createTargetDefinition"
7	name="Equinox Admin">	7	name="Create new p2 target definition">
8	<description>	8	</command>
9	blah blah	9	<command
10	</description>	10	defaultHandler="org.eclipse.equinox.internal.p2.target.menu.LoadTargetDefinitionHandler"
11	</provisioner>	11	id="org.eclipse.equinox.p2.target.loadTargetDefinition"
		12	name="Load Target Definition">
		13	</command>
		14	<command
		15	defaultHandler="org.eclipse.equinox.internal.p2.target.menu.OpenTargetDefinitionHandler"
		16	id="org.eclipse.equinox.p2.target.openTargetDefinition"
		17	name="Open Target Definition">
		18	</command>
		19	</extension>
		20	<extension
		21	point="org.eclipse.ui.menus">
		22	<menuContribution
		23	locationURI="menu:org.eclipse.ui.main.menu">
		24	<menu
		25	id="org.eclipse.equinox.p2.target.p2SelfHostMenu"
		26	label="P2 Self Hosting"
		27	mnemonic="P">
		28	<command
		29	commandId="org.eclipse.equinox.p2.target.createTargetDefinition"
		30	label="Create new target definition..."
		31	mnemonic="C">
		32	</command>
		33	<menu
		34	id="org.eclipse.equinox.p2.target.p2LoadTargetMenu"
		35	label="Load Target Definition">
		36	<dynamic
		37	class="org.eclipse.equinox.internal.p2.target.menu.LoadTargetDefinitionSubMenu"
		38	id="org.eclipse.equinox.p2.target.loadTargetFromDefinition">
		39	</dynamic>
		40	<separator
		41	name="org.eclipse.equinox.p2.target.separator1"
		42	visible="true">
		43	</separator>
		44	<command
		45	commandId="org.eclipse.equinox.p2.target.loadTargetDefinition"
		46	label="Load Target Definition..."
		47	style="push">
		48	</command>
		49	</menu>
		50	<menu
		51	id="org.eclipse.equinox.p2.target.p2OpenTargetDefinitionMenu"
		52	label="Open Target Definition">
		53	<dynamic
		54	class="org.eclipse.equinox.internal.p2.target.menu.OpenTargetDefinitionSubMenu"
		55	id="org.eclipse.equinox.p2.target.openTargetDefinition">
		56	</dynamic>
		57	<separator
		58	name="org.eclipse.equinox.p2.target.separator2"
		59	visible="true">
		60	</separator>
		61	<command
		62	commandId="org.eclipse.equinox.p2.target.openTargetDefinition"
		63	label="Open Target Definition..."
		64	style="push">
		65	</command>
		66	</menu>
		67	</menu>
		68	</menuContribution>
12	</extension>	69	</extension>
13	</plugin>	70	</plugin>

Added Link Here

(-)src/org/eclipse/equinox/internal/p2/target/menu/LoadTargetDefinitionHandler.java (+99 lines)
1	package org.eclipse.equinox.internal.p2.target.menu;
2	import java.lang.reflect.InvocationTargetException;
3
4	import org.eclipse.core.commands.AbstractHandler;
5	import org.eclipse.core.commands.ExecutionEvent;
6	import org.eclipse.core.commands.ExecutionException;
7	import org.eclipse.core.resources.IFile;
8	import org.eclipse.core.runtime.CoreException;
9	import org.eclipse.core.runtime.IProgressMonitor;
10	import org.eclipse.core.runtime.OperationCanceledException;
11	import org.eclipse.equinox.internal.p2.target.P2TargetDefinitionManager;
12	import org.eclipse.jface.dialogs.MessageDialog;
13	import org.eclipse.jface.operation.IRunnableWithProgress;
14	import org.eclipse.jface.viewers.ISelection;
15	import org.eclipse.jface.viewers.StructuredSelection;
16	import org.eclipse.jface.window.Window;
17	import org.eclipse.pde.internal.core.LoadTargetOperation;
18	import org.eclipse.pde.internal.core.itarget.ITargetModel;
19	import org.eclipse.pde.internal.core.target.WorkspaceTargetModel;
20	import org.eclipse.pde.internal.ui.IPDEUIConstants;
21	import org.eclipse.pde.internal.ui.PDEPlugin;
22	import org.eclipse.pde.internal.ui.PDEUIMessages;
23	import org.eclipse.pde.internal.ui.editor.target.TargetErrorDialog;
24	import org.eclipse.pde.internal.ui.util.FileExtensionFilter;
25	import org.eclipse.pde.internal.ui.util.FileValidator;
26	import org.eclipse.ui.IWorkbenchPage;
27	import org.eclipse.ui.IWorkbenchPart;
28	import org.eclipse.ui.IWorkbenchWindow;
29	import org.eclipse.ui.PartInitException;
30	import org.eclipse.ui.PlatformUI;
31	import org.eclipse.ui.dialogs.ElementTreeSelectionDialog;
32	import org.eclipse.ui.ide.IDE;
33	import org.eclipse.ui.model.WorkbenchContentProvider;
34	import org.eclipse.ui.model.WorkbenchLabelProvider;
35	import org.eclipse.ui.part.ISetSelectionTarget;
36	import org.eclipse.ui.progress.IProgressService;
37
38
39	public class LoadTargetDefinitionHandler extends AbstractHandler {
40
41	public Object execute(ExecutionEvent arg0) throws ExecutionException {
42	ElementTreeSelectionDialog dialog =
43	new ElementTreeSelectionDialog(PDEPlugin.getActiveWorkbenchShell(),
44	new WorkbenchLabelProvider(),
45	new WorkbenchContentProvider());
46
47	dialog.setValidator(new FileValidator());
48	dialog.setAllowMultiple(false);
49	dialog.setTitle(PDEUIMessages.TargetPlatformPreferencePage_FileSelectionTitle);
50	dialog.setMessage(PDEUIMessages.TargetPlatformPreferencePage_FileSelectionMessage);
51	dialog.addFilter(new FileExtensionFilter("target")); //$NON-NLS-1$
52	dialog.setInput(PDEPlugin.getWorkspace().getRoot());
53
54	if (dialog.open() == Window.OK) {
55	final IFile file = (IFile)dialog.getFirstResult();
56	final ITargetModel targetModel = new WorkspaceTargetModel(file, false);
57	try{
58	targetModel.load();
59	} catch (CoreException e){
60	MessageDialog.openError(PDEPlugin.getActiveWorkbenchShell(), PDEUIMessages.TargetPlatformPreferencePage_invalidTitle, "Could not load the target definition specified: " + e.getMessage());
61	}
62	IRunnableWithProgress run = new IRunnableWithProgress() {
63	public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
64	try {
65	if (!targetModel.isLoaded()) {
66	MessageDialog.openError(PDEPlugin.getActiveWorkbenchShell(), PDEUIMessages.TargetPlatformPreferencePage_invalidTitle, PDEUIMessages.TargetPlatformPreferencePage_invalidDescription);
67	monitor.done();
68	return;
69	}
70	LoadTargetOperation op = new LoadTargetOperation(targetModel.getTarget(), file.getFullPath());
71	PDEPlugin.getWorkspace().run(op, monitor);
72	Object[] features = op.getMissingFeatures();
73	Object[] plugins = op.getMissingPlugins();
74	if (plugins.length + features.length > 0)
75	TargetErrorDialog.showDialog(PDEPlugin.getActiveWorkbenchShell(), features, plugins);
76	} catch (CoreException e) {
77	throw new InvocationTargetException(e);
78	} catch (OperationCanceledException e) {
79	throw new InterruptedException(e.getMessage());
80	} finally {
81	monitor.done();
82	}
83	}
84	};
85	IProgressService service = PlatformUI.getWorkbench().getProgressService();
86	try {
87	service.runInUI(service, run, PDEPlugin.getWorkspace().getRoot());
88	} catch (InvocationTargetException e) {
89	} catch (InterruptedException e) {
90	}
91
92	P2TargetDefinitionManager.getDefault().addTarget(file.getFullPath());
93
94	}
95
96	return null;
97	}
98
99	}

Added Link Here

(-)src/org/eclipse/equinox/internal/p2/target/P2TargetDefinitionCreationOperation.java (+73 lines)
1	/*******************************************************************************
2	* Copyright (c) 2005, 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.equinox.internal.p2.target;
12
13	import java.io.File;
14
15	import org.eclipse.core.resources.IFile;
16	import org.eclipse.pde.internal.core.itarget.IAdditionalLocation;
17	import org.eclipse.pde.internal.core.itarget.ILocationInfo;
18	import org.eclipse.pde.internal.core.itarget.ITarget;
19	import org.eclipse.pde.internal.core.itarget.ITargetModel;
20	import org.eclipse.pde.internal.core.itarget.ITargetPlugin;
21	import org.eclipse.pde.internal.ui.wizards.target.BaseTargetDefinitionOperation;
22
23	public class P2TargetDefinitionCreationOperation extends BaseTargetDefinitionOperation {
24
25	private File[] fLocations;
26	private String[] fBundles;
27	private String fDefinitionName;
28
29	public P2TargetDefinitionCreationOperation(IFile definitionFile, String definitionName, File[] locations, String[] bundles){
30	super(definitionFile);
31	fDefinitionName = definitionName;
32	fLocations = locations;
33	fBundles = bundles;
34	}
35
36	protected void initializeTarget(ITargetModel model) {
37	ITarget target = model.getTarget();
38
39	if (fDefinitionName != null && fDefinitionName.length() > 0){
40	target.setName(fDefinitionName);
41	}
42
43	if (fLocations == null \|\| fLocations.length <= 0){
44	// TODO This is a problem, how to handle it?
45	} else {
46	ILocationInfo info = model.getFactory().createLocation();
47	info.setPath(fLocations[0].getPath());
48	info.setDefault(false);
49	target.setLocationInfo(info);
50
51	IAdditionalLocation[] locations = new IAdditionalLocation[fLocations.length-1];
52	for (int i = 0; i < locations.length; i++) {
53	IAdditionalLocation location = model.getFactory().createAdditionalLocation();
54	location.setPath(fLocations[i+1].getPath());
55	locations[i] = location;
56	}
57	target.addAdditionalDirectories(locations);
58	}
59
60	if (fBundles == null){
61	target.setUseAllPlugins(true);
62	} else if (fBundles.length > 0) {
63	ITargetPlugin[] plugins = new ITargetPlugin[fBundles.length];
64	for (int i = 0; i < plugins.length; i++) {
65	ITargetPlugin plugin = model.getFactory().createPlugin();
66	plugin.setId(fBundles[i]);
67	plugins[i] = plugin;
68	}
69	target.addPlugins(plugins);
70	}
71	}
72
73	}