Attachment #74719 for bug #173793




import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.ltk.core.refactoring.TextFileChange;
import org.eclipse.osgi.service.resolver.BundleDescription;
import org.eclipse.osgi.service.resolver.ExportPackageDescription;
import org.eclipse.osgi.service.resolver.HostSpecification;

		
	}
	
	public static TextFileChange[] removeUnusedKeys(
			final IProject project,
			final IBundle bundle, 
			final IPluginModelBase modelBase) {

			localization = "plugin"; //$NON-NLS-1$
		IFile propertiesFile = project.getFile(localization + ".properties"); //$NON-NLS-1$
		if (!propertiesFile.exists())
			return new TextFileChange[0];
		
		return PDEModelUtility.changesForModelModication(new ModelModification(propertiesFile) {
			protected void modifyModel(IBaseModel model, IProgressMonitor monitor) throws CoreException {
				if (!(model instanceof IBuildModel))
					return;




 *******************************************************************************/
package org.eclipse.pde.internal.ui.wizards.tools;

import org.eclipse.ltk.ui.refactoring.RefactoringWizard;
import java.util.ArrayList;

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;

public class OrganizeManifestsWizard extends RefactoringWizard {

	private OrganizeManifestsWizardPage fMainPage;
	private ArrayList fProjects;
	
	public OrganizeManifestsWizard(OrganizeManifestsRefactor refactoring) {
		super(refactoring, RefactoringWizard.DIALOG_BASED_USER_INTERFACE);
		setNeedsProgressMonitor(true);
		setWindowTitle(PDEUIMessages.OrganizeManifestsWizard_title);
		setDialogSettings(PDEPlugin.getDefault().getDialogSettings());
		setDefaultPageImageDescriptor(PDEPluginImages.DESC_ORGANIZE_MANIFESTS);
	}

	public boolean performFinish() {
		fMainPage.preformOk();
		return super.performFinish();
			OrganizeManifestsOperation op = new OrganizeManifestsOperation(fProjects);
			op.setOperations(fMainPage.getSettings());
			getContainer().run(false, true, op);
		} catch (InvocationTargetException e) {
			PDEPlugin.log(e);
			return false;
		} catch (InterruptedException e) {
			PDEPlugin.log(e);
			return false;
		}
		return true;
	}
	protected void addUserInputPages() {
		setDefaultPageTitle( getRefactoring().getName() );
		fMainPage = new OrganizeManifestsWizardPage();
		addPage(fMainPage);
	}





import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.ltk.ui.refactoring.UserInputWizardPage;
import org.eclipse.pde.internal.ui.IHelpContextIds;
import org.eclipse.pde.internal.ui.IPreferenceConstants;
import org.eclipse.pde.internal.ui.PDEUIMessages;

import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.PlatformUI;

public class OrganizeManifestsWizardPage extends UserInputWizardPage implements IPreferenceConstants, IOrganizeManifestsSettings {
	
	private Button fRemoveUnresolved;
	private Button fCalculateUses;

	private Button fRemoveLazy;
	
	private Button[] fTopLevelButtons; // used for setting page complete state
	private Button[] fParentButtons; // parents with children that need to be dis/enabled
	
	private OrganizeManifestsProcessor fProcessor;
	
	private static String title = PDEUIMessages.OrganizeManifestsWizardPage_title;
	protected OrganizeManifestsWizardPage() {

		container.setLayout(new GridLayout());
		container.setLayoutData(new GridData(GridData.FILL_BOTH));
		
		fProcessor = (OrganizeManifestsProcessor)((OrganizeManifestsRefactor)getRefactoring()).getProcessor();
		
		createExportedPackagesGroup(container);
		createRequireImportGroup(container);
		createGeneralGroup(container);

	private void presetOptions() {
		IDialogSettings settings = getDialogSettings();
		
		boolean selection = !settings.getBoolean(PROP_ADD_MISSING);
		fAddMissing.setSelection(selection);
		fProcessor.setAddMissing(selection);
		
		selection = !settings.getBoolean(PROP_MARK_INTERNAL);
		fMarkInternal.setSelection(selection);
		fProcessor.setMarkInternal(selection);
		fModifyDependencies.setSelection(!settings.getBoolean(PROP_MODIFY_DEP));

		fRemoveImport.setSelection(!settings.getBoolean(PROP_RESOLVE_IMP_MARK_OPT));
		fOptionalImport.setSelection(settings.getBoolean(PROP_RESOLVE_IMP_MARK_OPT));

		fUnusedDependencies.setSelection(settings.getBoolean(PROP_UNUSED_DEPENDENCIES));
		fAdditonalDependencies.setSelection(settings.getBoolean(PROP_ADD_DEPENDENCIES));
		
		fRemoveLazy.setSelection(!settings.getBoolean(PROP_REMOVE_LAZY));
		
		String filter = settings.get(PROP_INTERAL_PACKAGE_FILTER);
		if (filter == null)
			filter = VALUE_DEFAULT_FILTER;
		fPackageFilter.setText(filter);
		fProcessor.setPackageFilter(filter);
		
		selection = !settings.getBoolean(PROP_REMOVE_UNRESOLVED_EX);
		fRemoveUnresolved.setSelection(selection);
		fProcessor.setRemoveUnresolved(selection);
		
		selection = settings.getBoolean(PROP_CALCULATE_USES);
		fCalculateUses.setSelection(selection);
		fProcessor.setCalculateUses(selection);
		
		selection = !settings.getBoolean(PROP_MODIFY_DEP);
		fModifyDependencies.setSelection(selection);
		fProcessor.setModifyDep(selection);

		selection = settings.getBoolean(PROP_RESOLVE_IMP_MARK_OPT);
		fRemoveImport.setSelection(!selection);
		fOptionalImport.setSelection(selection);
		fProcessor.setRemoveDependencies(!selection);

		selection = settings.getBoolean(PROP_UNUSED_DEPENDENCIES);
		fUnusedDependencies.setSelection(selection);
		fProcessor.setUnusedDependencies(selection);
		
		selection = settings.getBoolean(PROP_ADD_DEPENDENCIES);
		fAdditonalDependencies.setSelection(selection);
		fProcessor.setAddDependencies(selection);
		
		selection = !settings.getBoolean(PROP_REMOVE_LAZY);
		fRemoveLazy.setSelection(selection);
		fProcessor.setRemoveLazy(selection);
		
		selection = settings.getBoolean(PROP_NLS_PATH);
		fFixIconNLSPaths.setSelection(selection);
		fProcessor.setPrefixIconNL(selection);
		
		selection = settings.getBoolean(PROP_UNUSED_KEYS);
		fRemovedUnusedKeys.setSelection(selection);
		fProcessor.setUnusedKeys(selection);

		setEnabledStates();
		setPageComplete();

			fRemoveUnresolved, fAddMissing,	fModifyDependencies, fMarkInternal,
			fUnusedDependencies, fAdditonalDependencies, fFixIconNLSPaths, fRemovedUnusedKeys, fRemoveLazy, fCalculateUses	
		};
		fParentButtons = new Button[] {
			fMarkInternal, fModifyDependencies
		};
	}
	
	private void setPageComplete() {

	}
	
	private void hookListeners() {
		hookListener(new Button[] {fMarkInternal, fModifyDependencies}, new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				setEnabledStates();
				doProcessorSetting(e.getSource());
			}
		});
		hookListener(fTopLevelButtons, new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				setPageComplete();
				doProcessorSetting(e.getSource());
			}
		});
		hookListener(new Button[] { fRemoveImport, fOptionalImport }, new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				doProcessorSetting(e.getSource());
			}
		});
	}

	private void doProcessorSetting(Object source) {
		if (fProcessor == null)
			return;
		if (fAddMissing.equals(source))
			fProcessor.setAddMissing(fAddMissing.getSelection());
		else if (fMarkInternal.equals(source))
			fProcessor.setMarkInternal(fMarkInternal.getSelection());
		else if (fPackageFilter.equals(source))
			fProcessor.setPackageFilter(fPackageFilter.getText());
		else if (fRemoveUnresolved.equals(source))
			fProcessor.setRemoveUnresolved(fRemoveUnresolved.getSelection());
		else if (fCalculateUses.equals(source))
			fProcessor.setCalculateUses(fCalculateUses.getSelection());
		else if (fModifyDependencies.equals(source))
			fProcessor.setModifyDep(fModifyDependencies.getSelection());
		else if (fOptionalImport.equals(source))
			fProcessor.setRemoveDependencies(!fOptionalImport.getSelection());
		else if (fRemoveImport.equals(source))
			fProcessor.setRemoveDependencies(fRemoveImport.getSelection());
		else if (fUnusedDependencies.equals(source))
			fProcessor.setUnusedDependencies(fUnusedDependencies.getSelection());
		else if (fAdditonalDependencies.equals(source))
			fProcessor.setAddDependencies(fAdditonalDependencies.getSelection());
		else if (fRemoveLazy.equals(source))
			fProcessor.setRemoveLazy(fRemoveLazy.getSelection());
		else if (fFixIconNLSPaths.equals(source))
			fProcessor.setPrefixIconNL(fFixIconNLSPaths.getSelection());
		else if (fRemovedUnusedKeys.equals(source))
			fProcessor.setUnusedKeys(fRemovedUnusedKeys.getSelection());
	}
	
	private void hookListener(Button[] buttons, SelectionAdapter adapter) {
		for (int i = 0; i < buttons.length; i++) {
			buttons[i].addSelectionListener(adapter);
		}
	}
	
	protected IDialogSettings getSettings() {
		return getDialogSettings();
	}
}




import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ltk.ui.refactoring.RefactoringWizardOpenOperation;
import org.eclipse.pde.internal.core.ICoreConstants;
import org.eclipse.pde.internal.ui.PDEPlugin;
import org.eclipse.pde.internal.ui.PDEUIMessages;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkbenchWindowActionDelegate;
import org.eclipse.ui.PlatformUI;

					projects.add(proj);
			}
			if (projects.size() > 0) {
				OrganizeManifestsProcessor processor = new OrganizeManifestsProcessor(projects);
				OrganizeManifestsRefactor refactor = new OrganizeManifestsRefactor(processor);
				OrganizeManifestsWizard wizard = new OrganizeManifestsWizard(refactor);
				RefactoringWizardOpenOperation op = new RefactoringWizardOpenOperation( wizard );
				
			    try {
			      op.run( PDEPlugin.getActiveWorkbenchShell(), "" ); //$NON-NLS-1$
			    } catch( final InterruptedException irex ) {
			    }
			} else
				MessageDialog.openInformation(
						PDEPlugin.getActiveWorkbenchShell(),




/*******************************************************************************
 * 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.pde.internal.ui.wizards.tools;

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

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.osgi.util.NLS;
import org.eclipse.pde.core.IBaseModel;
import org.eclipse.pde.core.plugin.IPluginModelBase;
import org.eclipse.pde.core.plugin.ISharedExtensionsModel;
import org.eclipse.pde.internal.core.ibundle.IBundle;
import org.eclipse.pde.internal.core.ibundle.IBundlePluginModelBase;
import org.eclipse.pde.internal.ui.PDEPlugin;
import org.eclipse.pde.internal.ui.PDEUIMessages;
import org.eclipse.pde.internal.ui.search.dependencies.AddNewDependenciesOperation;
import org.eclipse.pde.internal.ui.search.dependencies.CalculateUsesOperation;
import org.eclipse.pde.internal.ui.search.dependencies.GatherUnusedDependenciesOperation;
import org.eclipse.pde.internal.ui.util.ModelModification;
import org.eclipse.pde.internal.ui.util.PDEModelUtility;

public class OrganizeManifestsOperation implements IRunnableWithProgress, IOrganizeManifestsSettings {
	
	// if operation is executed without setting operations, these defaults will be used
	protected boolean fAddMissing = true; // add all packages to export-package
	protected boolean fMarkInternal = true; // mark export-package as internal
	protected String fPackageFilter = VALUE_DEFAULT_FILTER;
	protected boolean fRemoveUnresolved = true; // remove unresolved export-package
	protected boolean fCalculateUses = false; // calculate the 'uses' directive for exported packages
	protected boolean fModifyDep = true; // modify import-package / require-bundle
	protected boolean fRemoveDependencies = true; // if true: remove, else mark optional
	protected boolean fUnusedDependencies; // find/remove unused dependencies - long running op
	protected boolean fRemoveLazy = true; // remove lazy/auto start if no activator
	protected boolean fPrefixIconNL; // prefix icon paths with $nl$
	protected boolean fUnusedKeys; // remove unused <bundle-localization>.properties keys
	protected boolean fAddDependencies;
	
	private ArrayList fProjectList;
	private IProject fCurrentProject;
	
	public OrganizeManifestsOperation(ArrayList projectList) {
		fProjectList = projectList;
	}

	public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
		monitor.beginTask(PDEUIMessages.OrganizeManifestJob_taskName, fProjectList.size());
		for (int i = 0; i < fProjectList.size() && !monitor.isCanceled(); i++)
			cleanProject((IProject)fProjectList.get(i), new SubProgressMonitor(monitor, 1));
	}
	
	private void cleanProject(IProject project, IProgressMonitor monitor) {
		fCurrentProject = project;
		monitor.beginTask(fCurrentProject.getName(), getTotalTicksPerProject());
		
		final Exception[] ee = new Exception[1];
		ModelModification modification = new ModelModification(fCurrentProject) {
			protected void modifyModel(IBaseModel model, IProgressMonitor monitor) throws CoreException {
				if (model instanceof IBundlePluginModelBase)
					try {
						runCleanup(monitor, (IBundlePluginModelBase)model);
					} catch (InvocationTargetException e) {
						ee[0] = e;
					} catch (InterruptedException e) {
						ee[0] = e;
					}
			}
		};
		PDEModelUtility.modifyModel(modification, monitor);
		if (ee[0] != null)
			PDEPlugin.log(ee[0]);
	}
	
	
	private void runCleanup(IProgressMonitor monitor, IBundlePluginModelBase modelBase) throws InvocationTargetException, InterruptedException {
		
		IBundle bundle = modelBase.getBundleModel().getBundle();
		ISharedExtensionsModel sharedExtensionsModel = modelBase.getExtensionsModel();
		IPluginModelBase extensionsModel = null;
		if (sharedExtensionsModel instanceof IPluginModelBase)
			extensionsModel = (IPluginModelBase)sharedExtensionsModel;
		
		String projectName = fCurrentProject.getName();
		
		if (fAddMissing || fRemoveUnresolved) {
			monitor.subTask(NLS.bind(PDEUIMessages.OrganizeManifestsOperation_export, projectName));
			if (!monitor.isCanceled())
				OrganizeManifest.organizeExportPackages(bundle, fCurrentProject, fAddMissing, fRemoveUnresolved);
			if (fAddMissing)
				monitor.worked(1);
			if (fRemoveUnresolved)
				monitor.worked(1);
		}
		
		if (fMarkInternal) {
			monitor.subTask(NLS.bind(PDEUIMessages.OrganizeManifestsOperation_filterInternal, projectName));
			if (!monitor.isCanceled())
				OrganizeManifest.markPackagesInternal(bundle, fPackageFilter);
			monitor.worked(1);
		}
		
		if (fModifyDep) {
			String message = fRemoveDependencies ?
					NLS.bind(PDEUIMessages.OrganizeManifestsOperation_removeUnresolved, projectName) :
						NLS.bind(PDEUIMessages.OrganizeManifestsOperation_markOptionalUnresolved, projectName);
			monitor.subTask(message);
			if (!monitor.isCanceled())
				OrganizeManifest.organizeImportPackages(bundle, fRemoveDependencies);
			monitor.worked(1);
			
			if (!monitor.isCanceled())
				OrganizeManifest.organizeRequireBundles(bundle, fRemoveDependencies);
			monitor.worked(1);
		}
		
		if (fCalculateUses) {
			// we don't set the subTask because it is done in the CalculateUsesOperation, for each package it scans
			if (!monitor.isCanceled()) {
				CalculateUsesOperation op = new CalculateUsesOperation(fCurrentProject, modelBase);
				op.run(new SubProgressMonitor(monitor, 2));
			}
		}
		
		if (fAddDependencies) {
			monitor.subTask(NLS.bind (PDEUIMessages.OrganizeManifestsOperation_additionalDeps, projectName));
			if (!monitor.isCanceled()) {
				AddNewDependenciesOperation op = new AddNewDependenciesOperation(fCurrentProject, modelBase);
				op.run(new SubProgressMonitor(monitor, 4));
			}
		}
		
		if (fUnusedDependencies) {
			monitor.subTask(NLS.bind(PDEUIMessages.OrganizeManifestsOperation_unusedDeps, projectName));
			if (!monitor.isCanceled()) {
				SubProgressMonitor submon = new SubProgressMonitor(monitor, 4);
				GatherUnusedDependenciesOperation udo = new GatherUnusedDependenciesOperation(modelBase);
				udo.run(submon);
				GatherUnusedDependenciesOperation.removeDependencies(modelBase, udo.getList().toArray());
				submon.done();
			}
		}
		
		if (fRemoveLazy) {
			monitor.subTask(NLS.bind(PDEUIMessages.OrganizeManifestsOperation_lazyStart, fCurrentProject.getName()));
			if (!monitor.isCanceled())
				OrganizeManifest.removeUnneededLazyStart(bundle);
			monitor.worked(1);
		}
		
		if (fPrefixIconNL) {
			monitor.subTask(NLS.bind(PDEUIMessages.OrganizeManifestsOperation_nlIconPath, projectName));
			if (!monitor.isCanceled())
				OrganizeManifest.prefixIconPaths(extensionsModel);
			monitor.worked(1);
		}
		
		if (fUnusedKeys) {
			monitor.subTask(NLS.bind(PDEUIMessages.OrganizeManifestsOperation_unusedKeys, projectName));
			if (!monitor.isCanceled())
				OrganizeManifest.removeUnusedKeys(fCurrentProject, bundle, extensionsModel);
			monitor.worked(1);
		}
	}

	private int getTotalTicksPerProject() {
		int ticks = 0;
		if (fAddMissing)		ticks += 1;
		if (fMarkInternal)		ticks += 1;
		if (fRemoveUnresolved)	ticks += 1;
		if (fCalculateUses)		ticks += 4;
		if (fModifyDep)			ticks += 2;
		if (fUnusedDependencies)ticks += 4;
		if (fAddDependencies)	ticks += 4;
		if (fRemoveLazy)		ticks += 1;
		if (fPrefixIconNL)		ticks += 1;
		if (fUnusedKeys)		ticks += 1;
		return ticks;
	}
	
	
	public void setOperations(IDialogSettings settings) {
		fAddMissing = !settings.getBoolean(PROP_ADD_MISSING);
		fMarkInternal = !settings.getBoolean(PROP_MARK_INTERNAL);
		fPackageFilter = settings.get(PROP_INTERAL_PACKAGE_FILTER);
		fRemoveUnresolved = !settings.getBoolean(PROP_REMOVE_UNRESOLVED_EX);
		fCalculateUses = settings.getBoolean(PROP_CALCULATE_USES);
		fModifyDep = !settings.getBoolean(PROP_MODIFY_DEP);
		fRemoveDependencies = !settings.getBoolean(PROP_RESOLVE_IMP_MARK_OPT);
		fUnusedDependencies = settings.getBoolean(PROP_UNUSED_DEPENDENCIES);
		fRemoveLazy = !settings.getBoolean(PROP_REMOVE_LAZY);
		fPrefixIconNL = settings.getBoolean(PROP_NLS_PATH);
		fUnusedKeys = settings.getBoolean(PROP_UNUSED_KEYS);
		fAddDependencies = settings.getBoolean(PROP_ADD_DEPENDENCIES);
	}
}




SchemaElementReferenceDetails_reference=Reference:
SchemaAttributeDetails_removeRestButton=Remove
SchemaElementReferenceDetails_title=Element Reference Details
SchemaAttributeDetails_defaultValue=Default Value:
SchemaDetails_translatable=Translatable:
SchemaAttributeDetails_restrictions=Restrictions:
SchemaAttributeDetails_browseButton=Browse...

DependencyAnalysisSection_noCycles=The dependency graph of this plug-in does not contain cycles.
DependencyPropertiesDialog_version=Version:
DependencyPropertiesDialog_versionRangeError=Minimum version must be less than or equal to maximum version
DependencyAnalysisSection_references=References
DependencyPropertiesDialog_properties=Properties
DependencyExtentOperation_searching=Searching for dependencies on
DependencyPropertiesDialog_optional=&Optional

<p><img href="dependencies"/> <a href="references">Find this fragment's host plug-in</a></p>\
<p><img href="search"/> <a href="unused">Find unused dependencies</a></p>\
</form>
DependencyAnalysisSection_noReferencesFound=No plug-ins reference this fragment.
DependencyAnalysisSection_fragment_notEditable=<form>\
<p><img href="dependencies"/> <a href="references">Find this fragment's host plug-in</a></p>\
</form>

PluginsTabToolBar_auto_validate=Validate {0} automatically prior to launching
PluginsView_addToJavaSearch=&Add to Java Search
PluginsView_removeFromJavaSearch=Remove &from Java Search
PluginsTabToolBar_filter_options=Filtering Options
PluginWorkingSet_setContent=Working set content:
PluginWorkingSet_selectAll_label=Select &All
PluginDevelopmentPage_extensions=&Always show the Extensions and Extension Points tabs

PluginsView_CollapseAllAction_tooltip = Collapse All
# Select all is part of a submenu "Select" hence the label is not "Select all"
PluginsView_SelectAllAction_label = &All
PluginsTabToolBar_filter_disabled=Filter disabled target {0}


PluginSection_open=Open

OrganizeManifestsOperation_nlIconPath=checking icon paths for missing $nl$ segments... {0}
OrganizeManifestsOperation_unusedKeys=checking for unused keys... {0} 
OrganizeManifestsWizardPage_addMissing=&Ensure that all packages appear in the MANIFEST.MF
OrganizeManifestsProcessor_rootMessage=Organize Manifest for {0}
OrganizeManifestsWizardPage_lazyStart=Remove unnecessary Eclipse-La&zyStart headers
OrganizeRequireBundleResolution_Description=Organize Require Bundle Header
OrganizeImportPackageResolution_Description=Organize Import Package Header
OrganizeExportPackageResolution_Description=Organize Export Package Header
OrganizeManifestsOperation_filterInternal=marking export packages matching filter as internal... {0}
OrganizeManifestsWizardPage_description=Organize and clean up plug-in projects.
OrganizeManifestsProcessor_invalidParam=Invalid parameter passed to organize manifests processor
OrganizeManifestsWizardPage_exportedGroup=Exported Packages
OrganizeManifestsWizardPage_markInternal=Mark as &internal all packages that match the following filter:
OrganizeManifestsWizardPage_packageFilter=Package &filter:




import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;

import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Status;
import org.eclipse.debug.core.ILaunchConfiguration;

import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
import org.eclipse.jface.dialogs.DialogSettings;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.osgi.util.NLS;
import org.eclipse.pde.core.plugin.IPluginModelBase;
import org.eclipse.pde.core.plugin.PluginRegistry;

import org.eclipse.pde.internal.ui.IPreferenceConstants;
import org.eclipse.pde.internal.ui.PDEPlugin;
import org.eclipse.pde.internal.ui.PDEUIMessages;
import org.eclipse.pde.internal.ui.wizards.tools.OrganizeManifestsProcessor;
import org.eclipse.pde.internal.ui.wizards.tools.OrganizeManifestsOperation;
import org.eclipse.pde.ui.launcher.IPDELauncherConstants;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;

			if (!projects.isEmpty())
				Display.getDefault().syncExec(new Runnable() {
					public void run() {
						OrganizeManifestsProcessor processor = new OrganizeManifestsProcessor(projects);
						initializeProcessor(processor);
						try {
							Change change = processor.createChange(monitor);
							change.perform(monitor);
							// update table for each project with current time stamp
							Properties table = getLastRun();
							String ts = Long.toString(System.currentTimeMillis());
							Iterator it = projects.iterator();
							while (it.hasNext()) 
								table.put(((IProject)it.next()).getName(), ts);
						} catch (OperationCanceledException e) {
						} catch (CoreException e) {
						} 
					}
				});

		} catch (CoreException e) {
		}
	}
	
	private static void initializeProcessor(OrganizeManifestsProcessor processor) {
		processor.setAddMissing(false);
		processor.setRemoveUnresolved(false);
		processor.setModifyDep(false);
		processor.setRemoveLazy(false);
		processor.setAddDependencies(true);
		processor.setCalculateUses(false);
		processor.setMarkInternal(false);
		processor.setPrefixIconNL(false);
		processor.setUnusedDependencies(false);
		processor.setUnusedKeys(false);
	}

	private static String getTimeStamp(IProject project) {




import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.actions.ActionFactory;
import org.eclipse.ui.forms.IManagedForm;
import org.eclipse.ui.forms.editor.FormEditor;
import org.eclipse.ui.forms.editor.IFormPage;
import org.eclipse.ui.forms.widgets.FormToolkit;

		editorDirtyStateChanged();
	}
	
	public void flushEdits() {
		IFormPage[] pages = getPages();
		IManagedForm mForm = pages[getActivePage()].getManagedForm();
		if (mForm != null)
			mForm.commit(false);
		for (int i = 0; i < pages.length; i++) {
			if (pages[i] instanceof PDESourcePage) {
				PDESourcePage sourcePage = (PDESourcePage)pages[i];
				sourcePage.getInputContext().flushEditorInput();
			}
		}
	}
	
	/**
	 * @return
	 */




import org.eclipse.core.filebuffers.FileBuffers;
import org.eclipse.core.filebuffers.ITextFileBuffer;
import org.eclipse.core.filebuffers.ITextFileBufferManager;
import org.eclipse.core.filebuffers.LocationKind;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.ltk.core.refactoring.TextFileChange;
import org.eclipse.pde.core.IBaseModel;
import org.eclipse.pde.core.plugin.IPluginModelBase;
import org.eclipse.pde.core.plugin.ISharedExtensionsModel;

			// open editor found, should have underlying text listeners -> apply modification
			modifyEditorModel(modification, editor, model, monitor);
		} else {
			generateModelEdits(modification, monitor, true);
		}
	}
	
	public static TextFileChange[] changesForModelModication (final ModelModification modification, final IProgressMonitor monitor) {
		final PDEFormEditor editor = getOpenEditor(modification);
		if (editor != null) {
			Display.getDefault().syncExec(new Runnable() {
				public void run() {
					if (editor.isDirty())
						editor.flushEdits();
			// @see } finally { statement
			int sc = 0;
			try {
				ITextFileBuffer[] buffers = new ITextFileBuffer[files.length];
				IDocument[] documents = new IDocument[files.length];
				for (int i = 0; i < files.length; i++) {
					if (files[i] == null || !files[i].exists())
						continue;
					manager.connect(files[i].getFullPath(), monitor);
					sc++;
					buffers[i] = manager.getTextFileBuffer(files[i].getFullPath());
					if (buffers[i].isDirty())
						buffers[i].commit(monitor, true);
					documents[i] = buffers[i].getDocument();
				}
			});
		}
		return generateModelEdits(modification, monitor, false);
	}
	
	private static TextFileChange[] generateModelEdits (final ModelModification modification, final IProgressMonitor monitor,
			boolean performEdits) {
		ArrayList edits = new ArrayList();
		// create own model, attach listeners and grab text edits
		ITextFileBufferManager manager = FileBuffers.getTextFileBufferManager();
		IFile[] files;
		if (modification.isFullBundleModification()) {
			files = new IFile[2];
			files[F_Bi] = modification.getManifestFile();
			files[F_Xi] = modification.getXMLFile();
		} else {
			files = new IFile[] { modification.getFile() };
		}
		// need to monitor number of successful buffer connections for disconnection purposes
		// @see } finally { statement
		int sc = 0;
		try {
			ITextFileBuffer[] buffers = new ITextFileBuffer[files.length];
			IDocument[] documents = new IDocument[files.length];
			for (int i = 0; i < files.length; i++) {
				if (files[i] == null || !files[i].exists())
					continue;
				manager.connect(files[i].getFullPath(), LocationKind.IFILE, monitor);
				sc++;
				buffers[i] = manager.getTextFileBuffer(files[i].getFullPath(), LocationKind.IFILE);
				if (performEdits && buffers[i].isDirty())
					buffers[i].commit(monitor, true);
				documents[i] = buffers[i].getDocument();
			}
			
			IBaseModel editModel;
			if (modification.isFullBundleModification())
				editModel = prepareBundlePluginModel(files, documents);
			else
				editModel = prepareAbstractEditingModel(files[0], documents[0]);
			
			modification.modifyModel(editModel, monitor);
			
			IModelTextChangeListener[] listeners = gatherListeners(editModel);
			for (int i = 0; i < listeners.length; i++) {
				if (listeners[i] == null)
					continue;
				TextEdit[] currentEdits = listeners[i].getTextOperations();
				if (currentEdits.length > 0) {
					MultiTextEdit multi = new MultiTextEdit();
					multi.addChildren(currentEdits);
					if (performEdits) {
						multi.apply(documents[i]);
						buffers[i].commit(monitor, true);
					}
					TextFileChange change = new TextFileChange(files[i].getName(), files[i]);
					change.setEdit(multi);
					String textType = files[i].getName().equals("plugin.xml") ? //$NON-NLS-1$
							"PLUGIN2" : files[i].getFileExtension(); //$NON-NLS-1$
					change.setTextType(textType);
					edits.add(change);
				}
			}
		} catch (CoreException e) {
			PDEPlugin.log(e);
		} catch (MalformedTreeException e) {
			PDEPlugin.log(e);
		} catch (BadLocationException e) {
			PDEPlugin.log(e);
		} finally {
			// don't want to over-disconnect in case we ran into an exception during connections
			// dc <= sc stops this from happening
			int dc = 0;
			for (int i = 0; i < files.length && dc <= sc; i++) {
				if (files[i] == null || !files[i].exists())
					continue;
				try {
					manager.disconnect(files[i].getFullPath(), LocationKind.IFILE, monitor);
					dc++;
				} catch (CoreException e) {
					PDEPlugin.log(e);
				}
			}
		}
		return (TextFileChange[])edits.toArray(new TextFileChange[edits.size()]);
	}
	
	private static void modifyEditorModel(




/*******************************************************************************
 * 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.pde.internal.ui.wizards.tools;

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

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.ltk.core.refactoring.CompositeChange;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.ltk.core.refactoring.TextFileChange;
import org.eclipse.ltk.core.refactoring.participants.CheckConditionsContext;
import org.eclipse.ltk.core.refactoring.participants.RefactoringParticipant;
import org.eclipse.ltk.core.refactoring.participants.RefactoringProcessor;
import org.eclipse.ltk.core.refactoring.participants.SharableParticipants;
import org.eclipse.osgi.util.NLS;
import org.eclipse.pde.core.IBaseModel;
import org.eclipse.pde.core.plugin.IPluginModelBase;
import org.eclipse.pde.core.plugin.ISharedExtensionsModel;
import org.eclipse.pde.internal.core.ibundle.IBundle;
import org.eclipse.pde.internal.core.ibundle.IBundlePluginModelBase;
import org.eclipse.pde.internal.ui.PDEPlugin;
import org.eclipse.pde.internal.ui.PDEUIMessages;
import org.eclipse.pde.internal.ui.search.dependencies.AddNewDependenciesOperation;
import org.eclipse.pde.internal.ui.search.dependencies.CalculateUsesOperation;
import org.eclipse.pde.internal.ui.search.dependencies.GatherUnusedDependenciesOperation;
import org.eclipse.pde.internal.ui.util.ModelModification;
import org.eclipse.pde.internal.ui.util.PDEModelUtility;

public class OrganizeManifestsProcessor extends RefactoringProcessor implements IOrganizeManifestsSettings {
	
	// if operation is executed without setting operations, these defaults will be used
	protected boolean fAddMissing = true; // add all packages to export-package
	protected boolean fMarkInternal = true; // mark export-package as internal
	protected String fPackageFilter = VALUE_DEFAULT_FILTER;
	protected boolean fRemoveUnresolved = true; // remove unresolved export-package
	protected boolean fCalculateUses = false; // calculate the 'uses' directive for exported packages
	protected boolean fModifyDep = true; // modify import-package / require-bundle
	protected boolean fRemoveDependencies = true; // if true: remove, else mark optional
	protected boolean fUnusedDependencies = false; // find/remove unused dependencies - long running op
	protected boolean fRemoveLazy = true; // remove lazy/auto start if no activator
	protected boolean fPrefixIconNL = false; // prefix icon paths with $nl$
	protected boolean fUnusedKeys = false; // remove unused <bundle-localization>.properties keys
	protected boolean fAddDependencies = false;
	
	ArrayList fProjectList;
	private IProject fCurrentProject;
	
	public OrganizeManifestsProcessor(ArrayList projects) {
		fProjectList = projects;
	}
	
	public RefactoringStatus checkFinalConditions(IProgressMonitor pm,
			CheckConditionsContext context) throws CoreException,
			OperationCanceledException {
		RefactoringStatus status = new RefactoringStatus();
		for (Iterator i = fProjectList.iterator(); i.hasNext();) {
			if (!(i.next() instanceof IProject))
				status.addFatalError(PDEUIMessages.OrganizeManifestsProcessor_invalidParam);
		}
		return status;
	}

	public RefactoringStatus checkInitialConditions(IProgressMonitor pm)
			throws CoreException, OperationCanceledException {
		return null;
	}

	public Change createChange(IProgressMonitor pm) throws CoreException,
			OperationCanceledException {
		CompositeChange change = new CompositeChange(""); //$NON-NLS-1$
		change.markAsSynthetic();
		pm.beginTask(PDEUIMessages.OrganizeManifestJob_taskName, fProjectList.size());
		for (Iterator i = fProjectList.iterator(); i.hasNext() && !pm.isCanceled();)
			change.add(cleanProject((IProject)i.next(), new SubProgressMonitor(pm, 1)));
		return change;
	}
	
	private Change cleanProject(IProject project, IProgressMonitor monitor) {
		fCurrentProject = project;
		CompositeChange change = new CompositeChange(NLS.bind(PDEUIMessages.OrganizeManifestsProcessor_rootMessage, new String[] {fCurrentProject.getName()}));
		monitor.beginTask(NLS.bind(PDEUIMessages.OrganizeManifestsProcessor_rootMessage, new String[] {fCurrentProject.getName()}), getTotalTicksPerProject());
		
		final TextFileChange[] result = { null };
		final Exception[] ee = new Exception[1];
		ModelModification modification = new ModelModification(fCurrentProject) {
			protected void modifyModel(IBaseModel model, IProgressMonitor monitor) throws CoreException {
				if (model instanceof IBundlePluginModelBase)
					try {
						runCleanup(monitor, (IBundlePluginModelBase)model, result);
					} catch (InvocationTargetException e) {
						ee[0] = e;
					} catch (InterruptedException e) {
						ee[0] = e;
					}
			}
		};
		TextFileChange[] changes = PDEModelUtility.changesForModelModication(modification, monitor);
		for (int i = 0; i < changes.length; i++)
			change.add(changes[i]);
		if (result[0] != null)
			change.add(result[0]);
		if (ee[0] != null)
			PDEPlugin.log(ee[0]);
		return change;
	}
	
	private void runCleanup(IProgressMonitor monitor, IBundlePluginModelBase modelBase,
			TextFileChange[] result) throws InvocationTargetException, InterruptedException {
		
		IBundle currentBundle = modelBase.getBundleModel().getBundle();
		ISharedExtensionsModel sharedExtensionsModel = modelBase.getExtensionsModel();
		IPluginModelBase currentExtensionsModel = null;
		if (sharedExtensionsModel instanceof IPluginModelBase)
			currentExtensionsModel = (IPluginModelBase)sharedExtensionsModel;
		
		String projectName = fCurrentProject.getName();
		
		if (fAddMissing || fRemoveUnresolved) {
			monitor.subTask(NLS.bind(PDEUIMessages.OrganizeManifestsOperation_export, projectName));
			if (!monitor.isCanceled())
				OrganizeManifest.organizeExportPackages(currentBundle, fCurrentProject, fAddMissing, fRemoveUnresolved);
			if (fAddMissing)
				monitor.worked(1);
			if (fRemoveUnresolved)
				monitor.worked(1);
		}
		
		if (fMarkInternal) {
			monitor.subTask(NLS.bind(PDEUIMessages.OrganizeManifestsOperation_filterInternal, projectName));
			if (!monitor.isCanceled())
				OrganizeManifest.markPackagesInternal(currentBundle, fPackageFilter);
			monitor.worked(1);
		}
		
		if (fModifyDep) {
			String message = fRemoveDependencies ?
					NLS.bind(PDEUIMessages.OrganizeManifestsOperation_removeUnresolved, projectName) :
						NLS.bind(PDEUIMessages.OrganizeManifestsOperation_markOptionalUnresolved, projectName);
			monitor.subTask(message);
			if (!monitor.isCanceled())
				OrganizeManifest.organizeImportPackages(currentBundle, fRemoveDependencies);
			monitor.worked(1);
			
			if (!monitor.isCanceled())
				OrganizeManifest.organizeRequireBundles(currentBundle, fRemoveDependencies);
			monitor.worked(1);
		}
		
		if (fCalculateUses) {
			// we don't set the subTask because it is done in the CalculateUsesOperation, for each package it scans
			if (!monitor.isCanceled()) {
				CalculateUsesOperation op = new CalculateUsesOperation(fCurrentProject, modelBase);
				op.run(new SubProgressMonitor(monitor, 2));
			}
		}
		
		if (fAddDependencies) {
			monitor.subTask(NLS.bind (PDEUIMessages.OrganizeManifestsOperation_additionalDeps, projectName));
			if (!monitor.isCanceled()) {
				AddNewDependenciesOperation op = new AddNewDependenciesOperation(fCurrentProject, modelBase);
				op.run(new SubProgressMonitor(monitor, 4));
			}
		}
		
		if (fUnusedDependencies) {
			monitor.subTask(NLS.bind(PDEUIMessages.OrganizeManifestsOperation_unusedDeps, projectName));
			if (!monitor.isCanceled()) {
				SubProgressMonitor submon = new SubProgressMonitor(monitor, 4);
				GatherUnusedDependenciesOperation udo = new GatherUnusedDependenciesOperation(modelBase);
				udo.run(submon);
				GatherUnusedDependenciesOperation.removeDependencies(modelBase, udo.getList().toArray());
				submon.done();
			}
		}
	
		if (fRemoveLazy) {
			monitor.subTask(NLS.bind(PDEUIMessages.OrganizeManifestsOperation_lazyStart, fCurrentProject.getName()));
			if (!monitor.isCanceled())
				OrganizeManifest.removeUnneededLazyStart(currentBundle);
			monitor.worked(1);
		}
		
		if (fPrefixIconNL) {
			monitor.subTask(NLS.bind(PDEUIMessages.OrganizeManifestsOperation_nlIconPath, projectName));
			if (!monitor.isCanceled())
				OrganizeManifest.prefixIconPaths(currentExtensionsModel);
			monitor.worked(1);
		}
		
		if (fUnusedKeys) {
			monitor.subTask(NLS.bind(PDEUIMessages.OrganizeManifestsOperation_unusedKeys, projectName));
			if (!monitor.isCanceled()) {
				TextFileChange[] results = OrganizeManifest.removeUnusedKeys(fCurrentProject, currentBundle, currentExtensionsModel);
				if (results.length > 0)
					result[0] = results[0];
			}
			monitor.worked(1);
		}
	}

	public Object[] getElements() {
		return fProjectList.toArray();
	}

	public String getIdentifier() {
		return getClass().getName();
	}

	public String getProcessorName() {
		return PDEUIMessages.OrganizeManifestsWizardPage_title;
	}

	public boolean isApplicable() throws CoreException {
		return true;
	}

	public RefactoringParticipant[] loadParticipants(RefactoringStatus status,
			SharableParticipants sharedParticipants) throws CoreException {
		return new RefactoringParticipant[0];
	}

	private int getTotalTicksPerProject() {
		int ticks = 0;
		if (fAddMissing)		ticks += 1;
		if (fMarkInternal)		ticks += 1;
		if (fRemoveUnresolved)	ticks += 1;
		if (fCalculateUses)		ticks += 4;
		if (fModifyDep)			ticks += 2;
		if (fUnusedDependencies)ticks += 4;
		if (fAddDependencies)	ticks += 4;
		if (fRemoveLazy)		ticks += 1;
		if (fPrefixIconNL)		ticks += 1;
		if (fUnusedKeys)		ticks += 1;
		return ticks;
	}
	
	public void setAddMissing(boolean addMissing) {
		fAddMissing = addMissing;
	}
	public void setMarkInternal(boolean markInternal) {
		fMarkInternal = markInternal;
	}
	public void setPackageFilter(String packageFilter) {
		fPackageFilter = packageFilter;
	}
	public void setRemoveUnresolved(boolean removeUnresolved) {
		fRemoveUnresolved = removeUnresolved;
	}
	public void setCalculateUses(boolean calculateUses) {
		fCalculateUses = calculateUses;
	}
	public void setModifyDep(boolean modifyDep) {
		fModifyDep = modifyDep;
	}
	public void setRemoveDependencies(boolean removeDependencies) {
		fRemoveDependencies = removeDependencies;
	}
	public void setUnusedDependencies(boolean unusedDependencies) {
		fUnusedDependencies = unusedDependencies;
	}
	public void setRemoveLazy(boolean removeLazy) {
		fRemoveLazy = removeLazy;
	}
	public void setPrefixIconNL(boolean prefixIconNL) {
		fPrefixIconNL = prefixIconNL;
	}
	public void setUnusedKeys(boolean unusedKeys) {
		fUnusedKeys = unusedKeys;
	}
	public void setAddDependencies(boolean addDependencies) {
		fAddDependencies = addDependencies;
	}
}




/*******************************************************************************
 * 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.pde.internal.ui.wizards.tools;

import org.eclipse.ltk.core.refactoring.participants.ProcessorBasedRefactoring;
import org.eclipse.ltk.core.refactoring.participants.RefactoringProcessor;

public class OrganizeManifestsRefactor extends ProcessorBasedRefactoring {

	OrganizeManifestsProcessor fProcessor;
	
	public OrganizeManifestsRefactor(OrganizeManifestsProcessor processor) {
		super(processor);
		fProcessor = processor;
	}

	public RefactoringProcessor getProcessor() {
		return fProcessor;
	}
}

Return to bug 173793

Lines 17-28 Link Here

(-)src/org/eclipse/pde/internal/ui/util/PDEModelUtility.java (-61 / +91 lines)
17	import org.eclipse.core.filebuffers.FileBuffers;	17	import org.eclipse.core.filebuffers.FileBuffers;
18	import org.eclipse.core.filebuffers.ITextFileBuffer;	18	import org.eclipse.core.filebuffers.ITextFileBuffer;
19	import org.eclipse.core.filebuffers.ITextFileBufferManager;	19	import org.eclipse.core.filebuffers.ITextFileBufferManager;
		20	import org.eclipse.core.filebuffers.LocationKind;
20	import org.eclipse.core.resources.IFile;	21	import org.eclipse.core.resources.IFile;
21	import org.eclipse.core.resources.IProject;	22	import org.eclipse.core.resources.IProject;
22	import org.eclipse.core.runtime.CoreException;	23	import org.eclipse.core.runtime.CoreException;
23	import org.eclipse.core.runtime.IProgressMonitor;	24	import org.eclipse.core.runtime.IProgressMonitor;
24	import org.eclipse.jface.text.BadLocationException;	25	import org.eclipse.jface.text.BadLocationException;
25	import org.eclipse.jface.text.IDocument;	26	import org.eclipse.jface.text.IDocument;
		27	import org.eclipse.ltk.core.refactoring.TextFileChange;
26	import org.eclipse.pde.core.IBaseModel;	28	import org.eclipse.pde.core.IBaseModel;
27	import org.eclipse.pde.core.plugin.IPluginModelBase;	29	import org.eclipse.pde.core.plugin.IPluginModelBase;
28	import org.eclipse.pde.core.plugin.ISharedExtensionsModel;	30	import org.eclipse.pde.core.plugin.ISharedExtensionsModel;
Lines 302-376 Link Here
302	// open editor found, should have underlying text listeners -> apply modification	304	// open editor found, should have underlying text listeners -> apply modification
303	modifyEditorModel(modification, editor, model, monitor);	305	modifyEditorModel(modification, editor, model, monitor);
304	} else {	306	} else {
305	// create own model, attach listeners and grab text edits	307	generateModelEdits(modification, monitor, true);
306	ITextFileBufferManager manager = FileBuffers.getTextFileBufferManager();	308	}
307	IFile[] files;	309	}
308	if (modification.isFullBundleModification()) {	310
309	files = new IFile[2];	311	public static TextFileChange[] changesForModelModication (final ModelModification modification, final IProgressMonitor monitor) {
310	files[F_Bi] = modification.getManifestFile();	312	final PDEFormEditor editor = getOpenEditor(modification);
311	files[F_Xi] = modification.getXMLFile();	313	if (editor != null) {
312	} else {	314	Display.getDefault().syncExec(new Runnable() {
313	files = new IFile[] { modification.getFile() };	315	public void run() {
314	}	316	if (editor.isDirty())
315	// need to monitor number of successfull buffer connections for disconnection purposes	317	editor.flushEdits();
316	// @see } finally { statement
317	int sc = 0;
318	try {
319	ITextFileBuffer[] buffers = new ITextFileBuffer[files.length];
320	IDocument[] documents = new IDocument[files.length];
321	for (int i = 0; i < files.length; i++) {
322	if (files[i] == null \|\| !files[i].exists())
323	continue;
324	manager.connect(files[i].getFullPath(), monitor);
325	sc++;
326	buffers[i] = manager.getTextFileBuffer(files[i].getFullPath());
327	if (buffers[i].isDirty())
328	buffers[i].commit(monitor, true);
329	documents[i] = buffers[i].getDocument();
330	}	318	}
331		319	});
332	IBaseModel editModel;	320	}
333	if (modification.isFullBundleModification())	321	return generateModelEdits(modification, monitor, false);
334	editModel = prepareBundlePluginModel(files, documents);	322	}
335	else	323
336	editModel = prepareAbstractEditingModel(files[0], documents[0]);	324	private static TextFileChange[] generateModelEdits (final ModelModification modification, final IProgressMonitor monitor,
337		325	boolean performEdits) {
338	modification.modifyModel(editModel, monitor);	326	ArrayList edits = new ArrayList();
339		327	// create own model, attach listeners and grab text edits
340	IModelTextChangeListener[] listeners = gatherListeners(editModel);	328	ITextFileBufferManager manager = FileBuffers.getTextFileBufferManager();
341	for (int i = 0; i < listeners.length; i++) {	329	IFile[] files;
342	if (listeners[i] == null)	330	if (modification.isFullBundleModification()) {
343	continue;	331	files = new IFile[2];
344	TextEdit[] edits = listeners[i].getTextOperations();	332	files[F_Bi] = modification.getManifestFile();
345	if (edits.length > 0) {	333	files[F_Xi] = modification.getXMLFile();
346	MultiTextEdit multi = new MultiTextEdit();	334	} else {
347	multi.addChildren(edits);	335	files = new IFile[] { modification.getFile() };
		336	}
		337	// need to monitor number of successful buffer connections for disconnection purposes
		338	// @see } finally { statement
		339	int sc = 0;
		340	try {
		341	ITextFileBuffer[] buffers = new ITextFileBuffer[files.length];
		342	IDocument[] documents = new IDocument[files.length];
		343	for (int i = 0; i < files.length; i++) {
		344	if (files[i] == null \|\| !files[i].exists())
		345	continue;
		346	manager.connect(files[i].getFullPath(), LocationKind.IFILE, monitor);
		347	sc++;
		348	buffers[i] = manager.getTextFileBuffer(files[i].getFullPath(), LocationKind.IFILE);
		349	if (performEdits && buffers[i].isDirty())
		350	buffers[i].commit(monitor, true);
		351	documents[i] = buffers[i].getDocument();
		352	}
		353
		354	IBaseModel editModel;
		355	if (modification.isFullBundleModification())
		356	editModel = prepareBundlePluginModel(files, documents);
		357	else
		358	editModel = prepareAbstractEditingModel(files[0], documents[0]);
		359
		360	modification.modifyModel(editModel, monitor);
		361
		362	IModelTextChangeListener[] listeners = gatherListeners(editModel);
		363	for (int i = 0; i < listeners.length; i++) {
		364	if (listeners[i] == null)
		365	continue;
		366	TextEdit[] currentEdits = listeners[i].getTextOperations();
		367	if (currentEdits.length > 0) {
		368	MultiTextEdit multi = new MultiTextEdit();
		369	multi.addChildren(currentEdits);
		370	if (performEdits) {
348	multi.apply(documents[i]);	371	multi.apply(documents[i]);
349	buffers[i].commit(monitor, true);	372	buffers[i].commit(monitor, true);
350	}	373	}
		374	TextFileChange change = new TextFileChange(files[i].getName(), files[i]);
		375	change.setEdit(multi);
		376	String textType = files[i].getName().equals("plugin.xml") ? //$NON-NLS-1$
		377	"PLUGIN2" : files[i].getFileExtension(); //$NON-NLS-1$
		378	change.setTextType(textType);
		379	edits.add(change);
351	}	380	}
352	} catch (CoreException e) {	381	}
353	PDEPlugin.log(e);	382	} catch (CoreException e) {
354	} catch (MalformedTreeException e) {	383	PDEPlugin.log(e);
355	PDEPlugin.log(e);	384	} catch (MalformedTreeException e) {
356	} catch (BadLocationException e) {	385	PDEPlugin.log(e);
357	PDEPlugin.log(e);	386	} catch (BadLocationException e) {
358	} finally {	387	PDEPlugin.log(e);
359	// don't want to over-disconnect in case we ran into an exception during connections	388	} finally {
360	// dc <= sc stops this from happening	389	// don't want to over-disconnect in case we ran into an exception during connections
361	int dc = 0;	390	// dc <= sc stops this from happening
362	for (int i = 0; i < files.length && dc <= sc; i++) {	391	int dc = 0;
363	if (files[i] == null \|\| !files[i].exists())	392	for (int i = 0; i < files.length && dc <= sc; i++) {
364	continue;	393	if (files[i] == null \|\| !files[i].exists())
365	try {	394	continue;
366	manager.disconnect(files[i].getFullPath(), monitor);	395	try {
367	dc++;	396	manager.disconnect(files[i].getFullPath(), LocationKind.IFILE, monitor);
368	} catch (CoreException e) {	397	dc++;
369	PDEPlugin.log(e);	398	} catch (CoreException e) {
370	}	399	PDEPlugin.log(e);
371	}	400	}
372	}	401	}
373	}	402	}
		403	return (TextFileChange[])edits.toArray(new TextFileChange[edits.size()]);
374	}	404	}
375		405
376	private static void modifyEditorModel(	406	private static void modifyEditorModel(

Lines 27-32 Link Here

(-)src/org/eclipse/pde/internal/ui/wizards/tools/OrganizeManifest.java (-3 / +4 lines)
27	import org.eclipse.jdt.core.IPackageFragmentRoot;	27	import org.eclipse.jdt.core.IPackageFragmentRoot;
28	import org.eclipse.jdt.core.JavaModelException;	28	import org.eclipse.jdt.core.JavaModelException;
29	import org.eclipse.jface.text.IDocument;	29	import org.eclipse.jface.text.IDocument;
		30	import org.eclipse.ltk.core.refactoring.TextFileChange;
30	import org.eclipse.osgi.service.resolver.BundleDescription;	31	import org.eclipse.osgi.service.resolver.BundleDescription;
31	import org.eclipse.osgi.service.resolver.ExportPackageDescription;	32	import org.eclipse.osgi.service.resolver.ExportPackageDescription;
32	import org.eclipse.osgi.service.resolver.HostSpecification;	33	import org.eclipse.osgi.service.resolver.HostSpecification;
Lines 225-231 Link Here
225		226
226	}	227	}
227		228
228	public static void removeUnusedKeys(	229	public static TextFileChange[] removeUnusedKeys(
229	final IProject project,	230	final IProject project,
230	final IBundle bundle,	231	final IBundle bundle,
231	final IPluginModelBase modelBase) {	232	final IPluginModelBase modelBase) {
Lines 234-242 Link Here
234	localization = "plugin"; //$NON-NLS-1$	235	localization = "plugin"; //$NON-NLS-1$
235	IFile propertiesFile = project.getFile(localization + ".properties"); //$NON-NLS-1$	236	IFile propertiesFile = project.getFile(localization + ".properties"); //$NON-NLS-1$
236	if (!propertiesFile.exists())	237	if (!propertiesFile.exists())
237	return;	238	return new TextFileChange[0];
238		239
239	PDEModelUtility.modifyModel(new ModelModification(propertiesFile) {	240	return PDEModelUtility.changesForModelModication(new ModelModification(propertiesFile) {
240	protected void modifyModel(IBaseModel model, IProgressMonitor monitor) throws CoreException {	241	protected void modifyModel(IBaseModel model, IProgressMonitor monitor) throws CoreException {
241	if (!(model instanceof IBuildModel))	242	if (!(model instanceof IBuildModel))
242	return;	243	return;

Lines 10-53 Link Here

(-)src/org/eclipse/pde/internal/ui/wizards/tools/OrganizeManifestsWizard.java (-23 / +7 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.pde.internal.ui.wizards.tools;	11	package org.eclipse.pde.internal.ui.wizards.tools;
12		12
13	import java.lang.reflect.InvocationTargetException;	13	import org.eclipse.ltk.ui.refactoring.RefactoringWizard;
14	import java.util.ArrayList;
15
16	import org.eclipse.jface.wizard.Wizard;
17	import org.eclipse.pde.internal.ui.PDEPlugin;	14	import org.eclipse.pde.internal.ui.PDEPlugin;
18	import org.eclipse.pde.internal.ui.PDEPluginImages;	15	import org.eclipse.pde.internal.ui.PDEPluginImages;
19	import org.eclipse.pde.internal.ui.PDEUIMessages;	16	import org.eclipse.pde.internal.ui.PDEUIMessages;
20		17
21	public class OrganizeManifestsWizard extends Wizard {	18	public class OrganizeManifestsWizard extends RefactoringWizard {
22		19
23	private OrganizeManifestsWizardPage fMainPage;	20	private OrganizeManifestsWizardPage fMainPage;
24	private ArrayList fProjects;
25		21
26	public OrganizeManifestsWizard(ArrayList projects) {	22	public OrganizeManifestsWizard(OrganizeManifestsRefactor refactoring) {
27	fProjects = projects;	23	super(refactoring, RefactoringWizard.DIALOG_BASED_USER_INTERFACE);
28	setNeedsProgressMonitor(true);	24	setNeedsProgressMonitor(true);
29	setWindowTitle(PDEUIMessages.OrganizeManifestsWizard_title);	25	setWindowTitle(PDEUIMessages.OrganizeManifestsWizard_title);
30	setDialogSettings(PDEPlugin.getDefault().getDialogSettings());	26	setDialogSettings(PDEPlugin.getDefault().getDialogSettings());
31	setDefaultPageImageDescriptor(PDEPluginImages.DESC_ORGANIZE_MANIFESTS);	27	setDefaultPageImageDescriptor(PDEPluginImages.DESC_ORGANIZE_MANIFESTS);
32	}	28	}
33
34	public boolean performFinish() {	29	public boolean performFinish() {
35	fMainPage.preformOk();	30	fMainPage.preformOk();
36	try {	31	return super.performFinish();
37	OrganizeManifestsOperation op = new OrganizeManifestsOperation(fProjects);
38	op.setOperations(fMainPage.getSettings());
39	getContainer().run(false, true, op);
40	} catch (InvocationTargetException e) {
41	PDEPlugin.log(e);
42	return false;
43	} catch (InterruptedException e) {
44	PDEPlugin.log(e);
45	return false;
46	}
47	return true;
48	}	32	}
49		33	protected void addUserInputPages() {
50	public void addPages() {	34	setDefaultPageTitle( getRefactoring().getName() );
51	fMainPage = new OrganizeManifestsWizardPage();	35	fMainPage = new OrganizeManifestsWizardPage();
52	addPage(fMainPage);	36	addPage(fMainPage);
53	}	37	}

Lines 12-18 Link Here

(-)src/org/eclipse/pde/internal/ui/wizards/tools/OrganizeManifestsWizardPage.java (-29 / +93 lines)
12		12
13	import org.eclipse.jface.dialogs.Dialog;	13	import org.eclipse.jface.dialogs.Dialog;
14	import org.eclipse.jface.dialogs.IDialogSettings;	14	import org.eclipse.jface.dialogs.IDialogSettings;
15	import org.eclipse.jface.wizard.WizardPage;	15	import org.eclipse.ltk.ui.refactoring.UserInputWizardPage;
16	import org.eclipse.pde.internal.ui.IHelpContextIds;	16	import org.eclipse.pde.internal.ui.IHelpContextIds;
17	import org.eclipse.pde.internal.ui.IPreferenceConstants;	17	import org.eclipse.pde.internal.ui.IPreferenceConstants;
18	import org.eclipse.pde.internal.ui.PDEUIMessages;	18	import org.eclipse.pde.internal.ui.PDEUIMessages;
Lines 28-34 Link Here
28	import org.eclipse.swt.widgets.Text;	28	import org.eclipse.swt.widgets.Text;
29	import org.eclipse.ui.PlatformUI;	29	import org.eclipse.ui.PlatformUI;
30		30
31	public class OrganizeManifestsWizardPage extends WizardPage implements IPreferenceConstants, IOrganizeManifestsSettings {	31	public class OrganizeManifestsWizardPage extends UserInputWizardPage implements IPreferenceConstants, IOrganizeManifestsSettings {
32		32
33	private Button fRemoveUnresolved;	33	private Button fRemoveUnresolved;
34	private Button fCalculateUses;	34	private Button fCalculateUses;
Lines 46-53 Link Here
46	private Button fRemoveLazy;	46	private Button fRemoveLazy;
47		47
48	private Button[] fTopLevelButtons; // used for setting page complete state	48	private Button[] fTopLevelButtons; // used for setting page complete state
49	private Button[] fParentButtons; // parents with children that need to be dis/enabled
50		49
		50	private OrganizeManifestsProcessor fProcessor;
51		51
52	private static String title = PDEUIMessages.OrganizeManifestsWizardPage_title;	52	private static String title = PDEUIMessages.OrganizeManifestsWizardPage_title;
53	protected OrganizeManifestsWizardPage() {	53	protected OrganizeManifestsWizardPage() {
Lines 61-66 Link Here
61	container.setLayout(new GridLayout());	61	container.setLayout(new GridLayout());
62	container.setLayoutData(new GridData(GridData.FILL_BOTH));	62	container.setLayoutData(new GridData(GridData.FILL_BOTH));
63		63
		64	fProcessor = (OrganizeManifestsProcessor)((OrganizeManifestsRefactor)getRefactoring()).getProcessor();
		65
64	createExportedPackagesGroup(container);	66	createExportedPackagesGroup(container);
65	createRequireImportGroup(container);	67	createRequireImportGroup(container);
66	createGeneralGroup(container);	68	createGeneralGroup(container);
Lines 167-191 Link Here
167	private void presetOptions() {	169	private void presetOptions() {
168	IDialogSettings settings = getDialogSettings();	170	IDialogSettings settings = getDialogSettings();
169		171
170	fAddMissing.setSelection(!settings.getBoolean(PROP_ADD_MISSING));	172	boolean selection = !settings.getBoolean(PROP_ADD_MISSING);
171	fMarkInternal.setSelection(!settings.getBoolean(PROP_MARK_INTERNAL));	173	fAddMissing.setSelection(selection);
172	String filter = settings.get(PROP_INTERAL_PACKAGE_FILTER);	174	fProcessor.setAddMissing(selection);
173	fPackageFilter.setText(filter != null ? filter : VALUE_DEFAULT_FILTER);	175
174	fRemoveUnresolved.setSelection(!settings.getBoolean(PROP_REMOVE_UNRESOLVED_EX));	176	selection = !settings.getBoolean(PROP_MARK_INTERNAL);
175	fCalculateUses.setSelection(settings.getBoolean(PROP_CALCULATE_USES));	177	fMarkInternal.setSelection(selection);
176		178	fProcessor.setMarkInternal(selection);
177	fModifyDependencies.setSelection(!settings.getBoolean(PROP_MODIFY_DEP));
178
179	fRemoveImport.setSelection(!settings.getBoolean(PROP_RESOLVE_IMP_MARK_OPT));
180	fOptionalImport.setSelection(settings.getBoolean(PROP_RESOLVE_IMP_MARK_OPT));
181
182	fUnusedDependencies.setSelection(settings.getBoolean(PROP_UNUSED_DEPENDENCIES));
183	fAdditonalDependencies.setSelection(settings.getBoolean(PROP_ADD_DEPENDENCIES));
184
185	fRemoveLazy.setSelection(!settings.getBoolean(PROP_REMOVE_LAZY));
186		179
187	fFixIconNLSPaths.setSelection(settings.getBoolean(PROP_NLS_PATH));	180	String filter = settings.get(PROP_INTERAL_PACKAGE_FILTER);
188	fRemovedUnusedKeys.setSelection(settings.getBoolean(PROP_UNUSED_KEYS));	181	if (filter == null)
		182	filter = VALUE_DEFAULT_FILTER;
		183	fPackageFilter.setText(filter);
		184	fProcessor.setPackageFilter(filter);
		185
		186	selection = !settings.getBoolean(PROP_REMOVE_UNRESOLVED_EX);
		187	fRemoveUnresolved.setSelection(selection);
		188	fProcessor.setRemoveUnresolved(selection);
		189
		190	selection = settings.getBoolean(PROP_CALCULATE_USES);
		191	fCalculateUses.setSelection(selection);
		192	fProcessor.setCalculateUses(selection);
		193
		194	selection = !settings.getBoolean(PROP_MODIFY_DEP);
		195	fModifyDependencies.setSelection(selection);
		196	fProcessor.setModifyDep(selection);
		197
		198	selection = settings.getBoolean(PROP_RESOLVE_IMP_MARK_OPT);
		199	fRemoveImport.setSelection(!selection);
		200	fOptionalImport.setSelection(selection);
		201	fProcessor.setRemoveDependencies(!selection);
		202
		203	selection = settings.getBoolean(PROP_UNUSED_DEPENDENCIES);
		204	fUnusedDependencies.setSelection(selection);
		205	fProcessor.setUnusedDependencies(selection);
		206
		207	selection = settings.getBoolean(PROP_ADD_DEPENDENCIES);
		208	fAdditonalDependencies.setSelection(selection);
		209	fProcessor.setAddDependencies(selection);
		210
		211	selection = !settings.getBoolean(PROP_REMOVE_LAZY);
		212	fRemoveLazy.setSelection(selection);
		213	fProcessor.setRemoveLazy(selection);
		214
		215	selection = settings.getBoolean(PROP_NLS_PATH);
		216	fFixIconNLSPaths.setSelection(selection);
		217	fProcessor.setPrefixIconNL(selection);
		218
		219	selection = settings.getBoolean(PROP_UNUSED_KEYS);
		220	fRemovedUnusedKeys.setSelection(selection);
		221	fProcessor.setUnusedKeys(selection);
189		222
190	setEnabledStates();	223	setEnabledStates();
191	setPageComplete();	224	setPageComplete();
Lines 228-236 Link Here
228	fRemoveUnresolved, fAddMissing, fModifyDependencies, fMarkInternal,	261	fRemoveUnresolved, fAddMissing, fModifyDependencies, fMarkInternal,
229	fUnusedDependencies, fAdditonalDependencies, fFixIconNLSPaths, fRemovedUnusedKeys, fRemoveLazy, fCalculateUses	262	fUnusedDependencies, fAdditonalDependencies, fFixIconNLSPaths, fRemovedUnusedKeys, fRemoveLazy, fCalculateUses
230	};	263	};
231	fParentButtons = new Button[] {
232	fMarkInternal, fModifyDependencies
233	};
234	}	264	}
235		265
236	private void setPageComplete() {	266	private void setPageComplete() {
Lines 245-269 Link Here
245	}	275	}
246		276
247	private void hookListeners() {	277	private void hookListeners() {
248	hookListener(fParentButtons, new SelectionAdapter() {	278	hookListener(new Button[] {fMarkInternal, fModifyDependencies}, new SelectionAdapter() {
249	public void widgetSelected(SelectionEvent e) {	279	public void widgetSelected(SelectionEvent e) {
250	setEnabledStates();	280	setEnabledStates();
		281	doProcessorSetting(e.getSource());
251	}	282	}
252	});	283	});
253	hookListener(fTopLevelButtons, new SelectionAdapter() {	284	hookListener(fTopLevelButtons, new SelectionAdapter() {
254	public void widgetSelected(SelectionEvent e) {	285	public void widgetSelected(SelectionEvent e) {
255	setPageComplete();	286	setPageComplete();
		287	doProcessorSetting(e.getSource());
		288	}
		289	});
		290	hookListener(new Button[] { fRemoveImport, fOptionalImport }, new SelectionAdapter() {
		291	public void widgetSelected(SelectionEvent e) {
		292	doProcessorSetting(e.getSource());
256	}	293	}
257	});	294	});
258	}	295	}
		296
		297	private void doProcessorSetting(Object source) {
		298	if (fProcessor == null)
		299	return;
		300	if (fAddMissing.equals(source))
		301	fProcessor.setAddMissing(fAddMissing.getSelection());
		302	else if (fMarkInternal.equals(source))
		303	fProcessor.setMarkInternal(fMarkInternal.getSelection());
		304	else if (fPackageFilter.equals(source))
		305	fProcessor.setPackageFilter(fPackageFilter.getText());
		306	else if (fRemoveUnresolved.equals(source))
		307	fProcessor.setRemoveUnresolved(fRemoveUnresolved.getSelection());
		308	else if (fCalculateUses.equals(source))
		309	fProcessor.setCalculateUses(fCalculateUses.getSelection());
		310	else if (fModifyDependencies.equals(source))
		311	fProcessor.setModifyDep(fModifyDependencies.getSelection());
		312	else if (fOptionalImport.equals(source))
		313	fProcessor.setRemoveDependencies(!fOptionalImport.getSelection());
		314	else if (fRemoveImport.equals(source))
		315	fProcessor.setRemoveDependencies(fRemoveImport.getSelection());
		316	else if (fUnusedDependencies.equals(source))
		317	fProcessor.setUnusedDependencies(fUnusedDependencies.getSelection());
		318	else if (fAdditonalDependencies.equals(source))
		319	fProcessor.setAddDependencies(fAdditonalDependencies.getSelection());
		320	else if (fRemoveLazy.equals(source))
		321	fProcessor.setRemoveLazy(fRemoveLazy.getSelection());
		322	else if (fFixIconNLSPaths.equals(source))
		323	fProcessor.setPrefixIconNL(fFixIconNLSPaths.getSelection());
		324	else if (fRemovedUnusedKeys.equals(source))
		325	fProcessor.setUnusedKeys(fRemovedUnusedKeys.getSelection());
		326	}
259		327
260	private void hookListener(Button[] buttons, SelectionAdapter adapter) {	328	private void hookListener(Button[] buttons, SelectionAdapter adapter) {
261	for (int i = 0; i < buttons.length; i++) {	329	for (int i = 0; i < buttons.length; i++) {
262	buttons[i].addSelectionListener(adapter);	330	buttons[i].addSelectionListener(adapter);
263	}	331	}
264	}	332	}
265
266	protected IDialogSettings getSettings() {
267	return getDialogSettings();
268	}
269	}	333	}

Lines 19-29 Link Here

(-)src/org/eclipse/pde/internal/ui/wizards/tools/OrganizeManifestsAction.java (-11 / +10 lines)
19	import org.eclipse.jface.dialogs.MessageDialog;	19	import org.eclipse.jface.dialogs.MessageDialog;
20	import org.eclipse.jface.viewers.ISelection;	20	import org.eclipse.jface.viewers.ISelection;
21	import org.eclipse.jface.viewers.IStructuredSelection;	21	import org.eclipse.jface.viewers.IStructuredSelection;
22	import org.eclipse.jface.wizard.WizardDialog;	22	import org.eclipse.ltk.ui.refactoring.RefactoringWizardOpenOperation;
23	import org.eclipse.pde.internal.core.ICoreConstants;	23	import org.eclipse.pde.internal.core.ICoreConstants;
24	import org.eclipse.pde.internal.ui.PDEPlugin;	24	import org.eclipse.pde.internal.ui.PDEPlugin;
25	import org.eclipse.pde.internal.ui.PDEUIMessages;	25	import org.eclipse.pde.internal.ui.PDEUIMessages;
26	import org.eclipse.swt.custom.BusyIndicator;
27	import org.eclipse.ui.IWorkbenchWindow;	26	import org.eclipse.ui.IWorkbenchWindow;
28	import org.eclipse.ui.IWorkbenchWindowActionDelegate;	27	import org.eclipse.ui.IWorkbenchWindowActionDelegate;
29	import org.eclipse.ui.PlatformUI;	28	import org.eclipse.ui.PlatformUI;
Lines 62-76 Link Here
62	projects.add(proj);	61	projects.add(proj);
63	}	62	}
64	if (projects.size() > 0) {	63	if (projects.size() > 0) {
65	OrganizeManifestsWizard wizard = new OrganizeManifestsWizard(projects);	64	OrganizeManifestsProcessor processor = new OrganizeManifestsProcessor(projects);
66	final WizardDialog dialog = new WizardDialog(PDEPlugin.getActiveWorkbenchShell(), wizard);	65	OrganizeManifestsRefactor refactor = new OrganizeManifestsRefactor(processor);
67	BusyIndicator.showWhile(	66	OrganizeManifestsWizard wizard = new OrganizeManifestsWizard(refactor);
68	PDEPlugin.getActiveWorkbenchShell().getDisplay(),	67	RefactoringWizardOpenOperation op = new RefactoringWizardOpenOperation( wizard );
69	new Runnable() {	68
70	public void run() {	69	try {
71	dialog.open();	70	op.run( PDEPlugin.getActiveWorkbenchShell(), "" ); //$NON-NLS-1$
72	}	71	} catch( final InterruptedException irex ) {
73	});	72	}
74	} else	73	} else
75	MessageDialog.openInformation(	74	MessageDialog.openInformation(
76	PDEPlugin.getActiveWorkbenchShell(),	75	PDEPlugin.getActiveWorkbenchShell(),

Removed Link Here

(-)src/org/eclipse/pde/internal/ui/wizards/tools/OrganizeManifestsOperation.java (-208 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.pde.internal.ui.wizards.tools;
12
13	import java.lang.reflect.InvocationTargetException;
14	import java.util.ArrayList;
15
16	import org.eclipse.core.resources.IProject;
17	import org.eclipse.core.runtime.CoreException;
18	import org.eclipse.core.runtime.IProgressMonitor;
19	import org.eclipse.core.runtime.SubProgressMonitor;
20	import org.eclipse.jface.dialogs.IDialogSettings;
21	import org.eclipse.jface.operation.IRunnableWithProgress;
22	import org.eclipse.osgi.util.NLS;
23	import org.eclipse.pde.core.IBaseModel;
24	import org.eclipse.pde.core.plugin.IPluginModelBase;
25	import org.eclipse.pde.core.plugin.ISharedExtensionsModel;
26	import org.eclipse.pde.internal.core.ibundle.IBundle;
27	import org.eclipse.pde.internal.core.ibundle.IBundlePluginModelBase;
28	import org.eclipse.pde.internal.ui.PDEPlugin;
29	import org.eclipse.pde.internal.ui.PDEUIMessages;
30	import org.eclipse.pde.internal.ui.search.dependencies.AddNewDependenciesOperation;
31	import org.eclipse.pde.internal.ui.search.dependencies.CalculateUsesOperation;
32	import org.eclipse.pde.internal.ui.search.dependencies.GatherUnusedDependenciesOperation;
33	import org.eclipse.pde.internal.ui.util.ModelModification;
34	import org.eclipse.pde.internal.ui.util.PDEModelUtility;
35
36	public class OrganizeManifestsOperation implements IRunnableWithProgress, IOrganizeManifestsSettings {
37
38	// if operation is executed without setting operations, these defaults will be used
39	protected boolean fAddMissing = true; // add all packages to export-package
40	protected boolean fMarkInternal = true; // mark export-package as internal
41	protected String fPackageFilter = VALUE_DEFAULT_FILTER;
42	protected boolean fRemoveUnresolved = true; // remove unresolved export-package
43	protected boolean fCalculateUses = false; // calculate the 'uses' directive for exported packages
44	protected boolean fModifyDep = true; // modify import-package / require-bundle
45	protected boolean fRemoveDependencies = true; // if true: remove, else mark optional
46	protected boolean fUnusedDependencies; // find/remove unused dependencies - long running op
47	protected boolean fRemoveLazy = true; // remove lazy/auto start if no activator
48	protected boolean fPrefixIconNL; // prefix icon paths with $nl$
49	protected boolean fUnusedKeys; // remove unused <bundle-localization>.properties keys
50	protected boolean fAddDependencies;
51
52	private ArrayList fProjectList;
53	private IProject fCurrentProject;
54
55	public OrganizeManifestsOperation(ArrayList projectList) {
56	fProjectList = projectList;
57	}
58
59	public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
60	monitor.beginTask(PDEUIMessages.OrganizeManifestJob_taskName, fProjectList.size());
61	for (int i = 0; i < fProjectList.size() && !monitor.isCanceled(); i++)
62	cleanProject((IProject)fProjectList.get(i), new SubProgressMonitor(monitor, 1));
63	}
64
65	private void cleanProject(IProject project, IProgressMonitor monitor) {
66	fCurrentProject = project;
67	monitor.beginTask(fCurrentProject.getName(), getTotalTicksPerProject());
68
69	final Exception[] ee = new Exception[1];
70	ModelModification modification = new ModelModification(fCurrentProject) {
71	protected void modifyModel(IBaseModel model, IProgressMonitor monitor) throws CoreException {
72	if (model instanceof IBundlePluginModelBase)
73	try {
74	runCleanup(monitor, (IBundlePluginModelBase)model);
75	} catch (InvocationTargetException e) {
76	ee[0] = e;
77	} catch (InterruptedException e) {
78	ee[0] = e;
79	}
80	}
81	};
82	PDEModelUtility.modifyModel(modification, monitor);
83	if (ee[0] != null)
84	PDEPlugin.log(ee[0]);
85	}
86
87
88	private void runCleanup(IProgressMonitor monitor, IBundlePluginModelBase modelBase) throws InvocationTargetException, InterruptedException {
89
90	IBundle bundle = modelBase.getBundleModel().getBundle();
91	ISharedExtensionsModel sharedExtensionsModel = modelBase.getExtensionsModel();
92	IPluginModelBase extensionsModel = null;
93	if (sharedExtensionsModel instanceof IPluginModelBase)
94	extensionsModel = (IPluginModelBase)sharedExtensionsModel;
95
96	String projectName = fCurrentProject.getName();
97
98	if (fAddMissing \|\| fRemoveUnresolved) {
99	monitor.subTask(NLS.bind(PDEUIMessages.OrganizeManifestsOperation_export, projectName));
100	if (!monitor.isCanceled())
101	OrganizeManifest.organizeExportPackages(bundle, fCurrentProject, fAddMissing, fRemoveUnresolved);
102	if (fAddMissing)
103	monitor.worked(1);
104	if (fRemoveUnresolved)
105	monitor.worked(1);
106	}
107
108	if (fMarkInternal) {
109	monitor.subTask(NLS.bind(PDEUIMessages.OrganizeManifestsOperation_filterInternal, projectName));
110	if (!monitor.isCanceled())
111	OrganizeManifest.markPackagesInternal(bundle, fPackageFilter);
112	monitor.worked(1);
113	}
114
115	if (fModifyDep) {
116	String message = fRemoveDependencies ?
117	NLS.bind(PDEUIMessages.OrganizeManifestsOperation_removeUnresolved, projectName) :
118	NLS.bind(PDEUIMessages.OrganizeManifestsOperation_markOptionalUnresolved, projectName);
119	monitor.subTask(message);
120	if (!monitor.isCanceled())
121	OrganizeManifest.organizeImportPackages(bundle, fRemoveDependencies);
122	monitor.worked(1);
123
124	if (!monitor.isCanceled())
125	OrganizeManifest.organizeRequireBundles(bundle, fRemoveDependencies);
126	monitor.worked(1);
127	}
128
129	if (fCalculateUses) {
130	// we don't set the subTask because it is done in the CalculateUsesOperation, for each package it scans
131	if (!monitor.isCanceled()) {
132	CalculateUsesOperation op = new CalculateUsesOperation(fCurrentProject, modelBase);
133	op.run(new SubProgressMonitor(monitor, 2));
134	}
135	}
136
137	if (fAddDependencies) {
138	monitor.subTask(NLS.bind (PDEUIMessages.OrganizeManifestsOperation_additionalDeps, projectName));
139	if (!monitor.isCanceled()) {
140	AddNewDependenciesOperation op = new AddNewDependenciesOperation(fCurrentProject, modelBase);
141	op.run(new SubProgressMonitor(monitor, 4));
142	}
143	}
144
145	if (fUnusedDependencies) {
146	monitor.subTask(NLS.bind(PDEUIMessages.OrganizeManifestsOperation_unusedDeps, projectName));
147	if (!monitor.isCanceled()) {
148	SubProgressMonitor submon = new SubProgressMonitor(monitor, 4);
149	GatherUnusedDependenciesOperation udo = new GatherUnusedDependenciesOperation(modelBase);
150	udo.run(submon);
151	GatherUnusedDependenciesOperation.removeDependencies(modelBase, udo.getList().toArray());
152	submon.done();
153	}
154	}
155
156	if (fRemoveLazy) {
157	monitor.subTask(NLS.bind(PDEUIMessages.OrganizeManifestsOperation_lazyStart, fCurrentProject.getName()));
158	if (!monitor.isCanceled())
159	OrganizeManifest.removeUnneededLazyStart(bundle);
160	monitor.worked(1);
161	}
162
163	if (fPrefixIconNL) {
164	monitor.subTask(NLS.bind(PDEUIMessages.OrganizeManifestsOperation_nlIconPath, projectName));
165	if (!monitor.isCanceled())
166	OrganizeManifest.prefixIconPaths(extensionsModel);
167	monitor.worked(1);
168	}
169
170	if (fUnusedKeys) {
171	monitor.subTask(NLS.bind(PDEUIMessages.OrganizeManifestsOperation_unusedKeys, projectName));
172	if (!monitor.isCanceled())
173	OrganizeManifest.removeUnusedKeys(fCurrentProject, bundle, extensionsModel);
174	monitor.worked(1);
175	}
176	}
177
178	private int getTotalTicksPerProject() {
179	int ticks = 0;
180	if (fAddMissing) ticks += 1;
181	if (fMarkInternal) ticks += 1;
182	if (fRemoveUnresolved) ticks += 1;
183	if (fCalculateUses) ticks += 4;
184	if (fModifyDep) ticks += 2;
185	if (fUnusedDependencies)ticks += 4;
186	if (fAddDependencies) ticks += 4;
187	if (fRemoveLazy) ticks += 1;
188	if (fPrefixIconNL) ticks += 1;
189	if (fUnusedKeys) ticks += 1;
190	return ticks;
191	}
192
193
194	public void setOperations(IDialogSettings settings) {
195	fAddMissing = !settings.getBoolean(PROP_ADD_MISSING);
196	fMarkInternal = !settings.getBoolean(PROP_MARK_INTERNAL);
197	fPackageFilter = settings.get(PROP_INTERAL_PACKAGE_FILTER);
198	fRemoveUnresolved = !settings.getBoolean(PROP_REMOVE_UNRESOLVED_EX);
199	fCalculateUses = settings.getBoolean(PROP_CALCULATE_USES);
200	fModifyDep = !settings.getBoolean(PROP_MODIFY_DEP);
201	fRemoveDependencies = !settings.getBoolean(PROP_RESOLVE_IMP_MARK_OPT);
202	fUnusedDependencies = settings.getBoolean(PROP_UNUSED_DEPENDENCIES);
203	fRemoveLazy = !settings.getBoolean(PROP_REMOVE_LAZY);
204	fPrefixIconNL = settings.getBoolean(PROP_NLS_PATH);
205	fUnusedKeys = settings.getBoolean(PROP_UNUSED_KEYS);
206	fAddDependencies = settings.getBoolean(PROP_ADD_DEPENDENCIES);
207	}
208	}

Lines 73-78 Link Here

(-)src/org/eclipse/pde/internal/ui/PDEUIMessages.java (-8 / +4 lines)
73		73
74	public static String JavaArgumentsTab_appendLauncherIni;	74	public static String JavaArgumentsTab_appendLauncherIni;
75		75
		76	public static String OrganizeManifestsProcessor_invalidParam;
		77
		78	public static String OrganizeManifestsProcessor_rootMessage;
		79
76	public static String PDEWizardNewFileCreationPage_errorMsgStartsWithDot;	80	public static String PDEWizardNewFileCreationPage_errorMsgStartsWithDot;
77		81
78	public static String CommandComposerPart_formTitle;	82	public static String CommandComposerPart_formTitle;
Lines 285-294 Link Here
285		289
286	public static String PluginsTabToolBar_auto_validate;	290	public static String PluginsTabToolBar_auto_validate;
287		291
288	public static String PluginsTabToolBar_filter_disabled;
289
290	public static String PluginsTabToolBar_filter_options;
291
292	public static String PluginsTabToolBar_validate;	292	public static String PluginsTabToolBar_validate;
293		293
294	public static String PluginStructureCreator_name;	294	public static String PluginStructureCreator_name;
Lines 1646-1658 Link Here
1646	public static String DependencyAnalysisSection_title;	1646	public static String DependencyAnalysisSection_title;
1647	public static String DependencyAnalysisSection_loops;	1647	public static String DependencyAnalysisSection_loops;
1648	public static String DependencyAnalysisSection_noCycles;	1648	public static String DependencyAnalysisSection_noCycles;
1649	public static String DependencyAnalysisSection_references;
1650	public static String DependencyExtentOperation_searching;	1649	public static String DependencyExtentOperation_searching;
1651	public static String DependencyExtentOperation_inspecting;	1650	public static String DependencyExtentOperation_inspecting;
1652	public static String DependencyExtentSearchResult_dependency;	1651	public static String DependencyExtentSearchResult_dependency;
1653	public static String DependencyExtentSearchResult_dependencies;	1652	public static String DependencyExtentSearchResult_dependencies;
1654	public static String DependencyAnalysisSection_fragment_editable;	1653	public static String DependencyAnalysisSection_fragment_editable;
1655	public static String DependencyAnalysisSection_noReferencesFound;
1656	public static String DependencyAnalysisSection_fragment_notEditable;	1654	public static String DependencyAnalysisSection_fragment_notEditable;
1657	public static String DependencyAnalysisSection_plugin_editable;	1655	public static String DependencyAnalysisSection_plugin_editable;
1658	public static String DependencyAnalysisSection_plugin_notEditable;	1656	public static String DependencyAnalysisSection_plugin_notEditable;
Lines 2428-2435 Link Here
2428		2426
2429	public static String SchemaAttributeDetails_use;	2427	public static String SchemaAttributeDetails_use;
2430		2428
2431	public static String SchemaAttributeDetails_defaultValue;
2432
2433	public static String SchemaAttributeDetails_type;	2429	public static String SchemaAttributeDetails_type;
2434		2430
2435	public static String SchemaAttributeDetails_restrictions;	2431	public static String SchemaAttributeDetails_restrictions;

Lines 403-409 Link Here

(-)src/org/eclipse/pde/internal/ui/pderesources.properties (-5 / +2 lines)
403	SchemaElementReferenceDetails_reference=Reference:	403	SchemaElementReferenceDetails_reference=Reference:
404	SchemaAttributeDetails_removeRestButton=Remove	404	SchemaAttributeDetails_removeRestButton=Remove
405	SchemaElementReferenceDetails_title=Element Reference Details	405	SchemaElementReferenceDetails_title=Element Reference Details
406	SchemaAttributeDetails_defaultValue=Default Value:
407	SchemaDetails_translatable=Translatable:	406	SchemaDetails_translatable=Translatable:
408	SchemaAttributeDetails_restrictions=Restrictions:	407	SchemaAttributeDetails_restrictions=Restrictions:
409	SchemaAttributeDetails_browseButton=Browse...	408	SchemaAttributeDetails_browseButton=Browse...
Lines 1259-1265 Link Here
1259	DependencyAnalysisSection_noCycles=The dependency graph of this plug-in does not contain cycles.	1258	DependencyAnalysisSection_noCycles=The dependency graph of this plug-in does not contain cycles.
1260	DependencyPropertiesDialog_version=Version:	1259	DependencyPropertiesDialog_version=Version:
1261	DependencyPropertiesDialog_versionRangeError=Minimum version must be less than or equal to maximum version	1260	DependencyPropertiesDialog_versionRangeError=Minimum version must be less than or equal to maximum version
1262	DependencyAnalysisSection_references=References
1263	DependencyPropertiesDialog_properties=Properties	1261	DependencyPropertiesDialog_properties=Properties
1264	DependencyExtentOperation_searching=Searching for dependencies on	1262	DependencyExtentOperation_searching=Searching for dependencies on
1265	DependencyPropertiesDialog_optional=&Optional	1263	DependencyPropertiesDialog_optional=&Optional
Lines 1273-1279 Link Here
1273	<p><img href="dependencies"/> <a href="references">Find this fragment's host plug-in</a></p>\	1271	<p><img href="dependencies"/> <a href="references">Find this fragment's host plug-in</a></p>\
1274	<p><img href="search"/> <a href="unused">Find unused dependencies</a></p>\	1272	<p><img href="search"/> <a href="unused">Find unused dependencies</a></p>\
1275	</form>	1273	</form>
1276	DependencyAnalysisSection_noReferencesFound=No plug-ins reference this fragment.
1277	DependencyAnalysisSection_fragment_notEditable=<form>\	1274	DependencyAnalysisSection_fragment_notEditable=<form>\
1278	<p><img href="dependencies"/> <a href="references">Find this fragment's host plug-in</a></p>\	1275	<p><img href="dependencies"/> <a href="references">Find this fragment's host plug-in</a></p>\
1279	</form>	1276	</form>
Lines 1328-1334 Link Here
1328	PluginsTabToolBar_auto_validate=Validate {0} automatically prior to launching	1325	PluginsTabToolBar_auto_validate=Validate {0} automatically prior to launching
1329	PluginsView_addToJavaSearch=&Add to Java Search	1326	PluginsView_addToJavaSearch=&Add to Java Search
1330	PluginsView_removeFromJavaSearch=Remove &from Java Search	1327	PluginsView_removeFromJavaSearch=Remove &from Java Search
1331	PluginsTabToolBar_filter_options=Filtering Options
1332	PluginWorkingSet_setContent=Working set content:	1328	PluginWorkingSet_setContent=Working set content:
1333	PluginWorkingSet_selectAll_label=Select &All	1329	PluginWorkingSet_selectAll_label=Select &All
1334	PluginDevelopmentPage_extensions=&Always show the Extensions and Extension Points tabs	1330	PluginDevelopmentPage_extensions=&Always show the Extensions and Extension Points tabs
Lines 1354-1360 Link Here
1354	PluginsView_CollapseAllAction_tooltip = Collapse All	1350	PluginsView_CollapseAllAction_tooltip = Collapse All
1355	# Select all is part of a submenu "Select" hence the label is not "Select all"	1351	# Select all is part of a submenu "Select" hence the label is not "Select all"
1356	PluginsView_SelectAllAction_label = &All	1352	PluginsView_SelectAllAction_label = &All
1357	PluginsTabToolBar_filter_disabled=Filter disabled target {0}
1358		1353
1359		1354
1360	PluginSection_open=Open	1355	PluginSection_open=Open
Lines 2037-2048 Link Here
2037	OrganizeManifestsOperation_nlIconPath=checking icon paths for missing $nl$ segments... {0}	2032	OrganizeManifestsOperation_nlIconPath=checking icon paths for missing $nl$ segments... {0}
2038	OrganizeManifestsOperation_unusedKeys=checking for unused keys... {0}	2033	OrganizeManifestsOperation_unusedKeys=checking for unused keys... {0}
2039	OrganizeManifestsWizardPage_addMissing=&Ensure that all packages appear in the MANIFEST.MF	2034	OrganizeManifestsWizardPage_addMissing=&Ensure that all packages appear in the MANIFEST.MF
		2035	OrganizeManifestsProcessor_rootMessage=Organize Manifest for {0}
2040	OrganizeManifestsWizardPage_lazyStart=Remove unnecessary Eclipse-La&zyStart headers	2036	OrganizeManifestsWizardPage_lazyStart=Remove unnecessary Eclipse-La&zyStart headers
2041	OrganizeRequireBundleResolution_Description=Organize Require Bundle Header	2037	OrganizeRequireBundleResolution_Description=Organize Require Bundle Header
2042	OrganizeImportPackageResolution_Description=Organize Import Package Header	2038	OrganizeImportPackageResolution_Description=Organize Import Package Header
2043	OrganizeExportPackageResolution_Description=Organize Export Package Header	2039	OrganizeExportPackageResolution_Description=Organize Export Package Header
2044	OrganizeManifestsOperation_filterInternal=marking export packages matching filter as internal... {0}	2040	OrganizeManifestsOperation_filterInternal=marking export packages matching filter as internal... {0}
2045	OrganizeManifestsWizardPage_description=Organize and clean up plug-in projects.	2041	OrganizeManifestsWizardPage_description=Organize and clean up plug-in projects.
		2042	OrganizeManifestsProcessor_invalidParam=Invalid parameter passed to organize manifests processor
2046	OrganizeManifestsWizardPage_exportedGroup=Exported Packages	2043	OrganizeManifestsWizardPage_exportedGroup=Exported Packages
2047	OrganizeManifestsWizardPage_markInternal=Mark as &internal all packages that match the following filter:	2044	OrganizeManifestsWizardPage_markInternal=Mark as &internal all packages that match the following filter:
2048	OrganizeManifestsWizardPage_packageFilter=Package &filter:	2045	OrganizeManifestsWizardPage_packageFilter=Package &filter:

Lines 14-20 Link Here

(-)src/org/eclipse/pde/internal/ui/launcher/LauncherUtils.java (-21 / +21 lines)
14	import java.io.FileInputStream;	14	import java.io.FileInputStream;
15	import java.io.FileOutputStream;	15	import java.io.FileOutputStream;
16	import java.io.IOException;	16	import java.io.IOException;
17	import java.lang.reflect.InvocationTargetException;
18	import java.util.ArrayList;	17	import java.util.ArrayList;
19	import java.util.HashSet;	18	import java.util.HashSet;
20	import java.util.Iterator;	19	import java.util.Iterator;
Lines 30-35 Link Here
30	import org.eclipse.core.runtime.IPath;	29	import org.eclipse.core.runtime.IPath;
31	import org.eclipse.core.runtime.IProgressMonitor;	30	import org.eclipse.core.runtime.IProgressMonitor;
32	import org.eclipse.core.runtime.IStatus;	31	import org.eclipse.core.runtime.IStatus;
		32	import org.eclipse.core.runtime.OperationCanceledException;
33	import org.eclipse.core.runtime.Path;	33	import org.eclipse.core.runtime.Path;
34	import org.eclipse.core.runtime.Status;	34	import org.eclipse.core.runtime.Status;
35	import org.eclipse.debug.core.ILaunchConfiguration;	35	import org.eclipse.debug.core.ILaunchConfiguration;
Lines 39-49 Link Here
39	import org.eclipse.jdt.core.JavaCore;	39	import org.eclipse.jdt.core.JavaCore;
40	import org.eclipse.jdt.core.JavaModelException;	40	import org.eclipse.jdt.core.JavaModelException;
41	import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;	41	import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
42	import org.eclipse.jface.dialogs.DialogSettings;
43	import org.eclipse.jface.dialogs.IDialogConstants;	42	import org.eclipse.jface.dialogs.IDialogConstants;
44	import org.eclipse.jface.dialogs.IDialogSettings;
45	import org.eclipse.jface.dialogs.MessageDialog;	43	import org.eclipse.jface.dialogs.MessageDialog;
46	import org.eclipse.jface.preference.IPreferenceStore;	44	import org.eclipse.jface.preference.IPreferenceStore;
		45	import org.eclipse.ltk.core.refactoring.Change;
47	import org.eclipse.osgi.util.NLS;	46	import org.eclipse.osgi.util.NLS;
48	import org.eclipse.pde.core.plugin.IPluginModelBase;	47	import org.eclipse.pde.core.plugin.IPluginModelBase;
49	import org.eclipse.pde.core.plugin.PluginRegistry;	48	import org.eclipse.pde.core.plugin.PluginRegistry;
Lines 55-62 Link Here
55	import org.eclipse.pde.internal.ui.IPreferenceConstants;	54	import org.eclipse.pde.internal.ui.IPreferenceConstants;
56	import org.eclipse.pde.internal.ui.PDEPlugin;	55	import org.eclipse.pde.internal.ui.PDEPlugin;
57	import org.eclipse.pde.internal.ui.PDEUIMessages;	56	import org.eclipse.pde.internal.ui.PDEUIMessages;
58	import org.eclipse.pde.internal.ui.wizards.tools.IOrganizeManifestsSettings;	57	import org.eclipse.pde.internal.ui.wizards.tools.OrganizeManifestsProcessor;
59	import org.eclipse.pde.internal.ui.wizards.tools.OrganizeManifestsOperation;
60	import org.eclipse.pde.ui.launcher.IPDELauncherConstants;	58	import org.eclipse.pde.ui.launcher.IPDELauncherConstants;
61	import org.eclipse.swt.widgets.Display;	59	import org.eclipse.swt.widgets.Display;
62	import org.eclipse.swt.widgets.Shell;	60	import org.eclipse.swt.widgets.Shell;
Lines 178-195 Link Here
178	if (!projects.isEmpty())	176	if (!projects.isEmpty())
179	Display.getDefault().syncExec(new Runnable() {	177	Display.getDefault().syncExec(new Runnable() {
180	public void run() {	178	public void run() {
181	OrganizeManifestsOperation op = new OrganizeManifestsOperation(projects);	179	OrganizeManifestsProcessor processor = new OrganizeManifestsProcessor(projects);
182	op.setOperations(getSettings());	180	initializeProcessor(processor);
183	try {	181	try {
184	op.run(monitor);	182	Change change = processor.createChange(monitor);
		183	change.perform(monitor);
185	// update table for each project with current time stamp	184	// update table for each project with current time stamp
186	Properties table = getLastRun();	185	Properties table = getLastRun();
187	String ts = Long.toString(System.currentTimeMillis());	186	String ts = Long.toString(System.currentTimeMillis());
188	Iterator it = projects.iterator();	187	Iterator it = projects.iterator();
189	while (it.hasNext())	188	while (it.hasNext())
190	table.put(((IProject)it.next()).getName(), ts);	189	table.put(((IProject)it.next()).getName(), ts);
191	} catch (InvocationTargetException e) {	190	} catch (OperationCanceledException e) {
192	} catch (InterruptedException e) {	191	} catch (CoreException e) {
193	}	192	}
194	}	193	}
195	});	194	});
Lines 204-220 Link Here
204	} catch (CoreException e) {	203	} catch (CoreException e) {
205	}	204	}
206	}	205	}
207		206
208	private static IDialogSettings getSettings() {	207	private static void initializeProcessor(OrganizeManifestsProcessor processor) {
209	IDialogSettings settings = new DialogSettings(""); //$NON-NLS-1$	208	processor.setAddMissing(false);
210	settings.put(IOrganizeManifestsSettings.PROP_ADD_MISSING, true);	209	processor.setRemoveUnresolved(false);
211	settings.put(IOrganizeManifestsSettings.PROP_MARK_INTERNAL, true);	210	processor.setModifyDep(false);
212	settings.put(IOrganizeManifestsSettings.PROP_REMOVE_UNRESOLVED_EX, true);	211	processor.setRemoveLazy(false);
213	settings.put(IOrganizeManifestsSettings.PROP_MODIFY_DEP, true);	212	processor.setAddDependencies(true);
214	settings.put(IOrganizeManifestsSettings.PROP_RESOLVE_IMP_MARK_OPT, true);	213	processor.setCalculateUses(false);
215	settings.put(IOrganizeManifestsSettings.PROP_REMOVE_LAZY, true);	214	processor.setMarkInternal(false);
216	settings.put(IOrganizeManifestsSettings.PROP_ADD_DEPENDENCIES, true);	215	processor.setPrefixIconNL(false);
217	return settings;	216	processor.setUnusedDependencies(false);
		217	processor.setUnusedKeys(false);
218	}	218	}
219		219
220	private static String getTimeStamp(IProject project) {	220	private static String getTimeStamp(IProject project) {

Lines 70-75 Link Here

(-)src/org/eclipse/pde/internal/ui/editor/PDEFormEditor.java (+14 lines)
70	import org.eclipse.ui.IWorkbenchPart;	70	import org.eclipse.ui.IWorkbenchPart;
71	import org.eclipse.ui.PartInitException;	71	import org.eclipse.ui.PartInitException;
72	import org.eclipse.ui.actions.ActionFactory;	72	import org.eclipse.ui.actions.ActionFactory;
		73	import org.eclipse.ui.forms.IManagedForm;
73	import org.eclipse.ui.forms.editor.FormEditor;	74	import org.eclipse.ui.forms.editor.FormEditor;
74	import org.eclipse.ui.forms.editor.IFormPage;	75	import org.eclipse.ui.forms.editor.IFormPage;
75	import org.eclipse.ui.forms.widgets.FormToolkit;	76	import org.eclipse.ui.forms.widgets.FormToolkit;
Lines 461-466 Link Here
461	editorDirtyStateChanged();	462	editorDirtyStateChanged();
462	}	463	}
463		464
		465	public void flushEdits() {
		466	IFormPage[] pages = getPages();
		467	IManagedForm mForm = pages[getActivePage()].getManagedForm();
		468	if (mForm != null)
		469	mForm.commit(false);
		470	for (int i = 0; i < pages.length; i++) {
		471	if (pages[i] instanceof PDESourcePage) {
		472	PDESourcePage sourcePage = (PDESourcePage)pages[i];
		473	sourcePage.getInputContext().flushEditorInput();
		474	}
		475	}
		476	}
		477
464	/**	478	/**
465	* @return	479	* @return
466	*/	480	*/

Added Link Here

(-)src/org/eclipse/pde/internal/ui/wizards/tools/OrganizeManifestsProcessor.java (+288 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.pde.internal.ui.wizards.tools;
12
13	import java.lang.reflect.InvocationTargetException;
14	import java.util.ArrayList;
15	import java.util.Iterator;
16
17	import org.eclipse.core.resources.IProject;
18	import org.eclipse.core.runtime.CoreException;
19	import org.eclipse.core.runtime.IProgressMonitor;
20	import org.eclipse.core.runtime.OperationCanceledException;
21	import org.eclipse.core.runtime.SubProgressMonitor;
22	import org.eclipse.ltk.core.refactoring.Change;
23	import org.eclipse.ltk.core.refactoring.CompositeChange;
24	import org.eclipse.ltk.core.refactoring.RefactoringStatus;
25	import org.eclipse.ltk.core.refactoring.TextFileChange;
26	import org.eclipse.ltk.core.refactoring.participants.CheckConditionsContext;
27	import org.eclipse.ltk.core.refactoring.participants.RefactoringParticipant;
28	import org.eclipse.ltk.core.refactoring.participants.RefactoringProcessor;
29	import org.eclipse.ltk.core.refactoring.participants.SharableParticipants;
30	import org.eclipse.osgi.util.NLS;
31	import org.eclipse.pde.core.IBaseModel;
32	import org.eclipse.pde.core.plugin.IPluginModelBase;
33	import org.eclipse.pde.core.plugin.ISharedExtensionsModel;
34	import org.eclipse.pde.internal.core.ibundle.IBundle;
35	import org.eclipse.pde.internal.core.ibundle.IBundlePluginModelBase;
36	import org.eclipse.pde.internal.ui.PDEPlugin;
37	import org.eclipse.pde.internal.ui.PDEUIMessages;
38	import org.eclipse.pde.internal.ui.search.dependencies.AddNewDependenciesOperation;
39	import org.eclipse.pde.internal.ui.search.dependencies.CalculateUsesOperation;
40	import org.eclipse.pde.internal.ui.search.dependencies.GatherUnusedDependenciesOperation;
41	import org.eclipse.pde.internal.ui.util.ModelModification;
42	import org.eclipse.pde.internal.ui.util.PDEModelUtility;
43
44	public class OrganizeManifestsProcessor extends RefactoringProcessor implements IOrganizeManifestsSettings {
45
46	// if operation is executed without setting operations, these defaults will be used
47	protected boolean fAddMissing = true; // add all packages to export-package
48	protected boolean fMarkInternal = true; // mark export-package as internal
49	protected String fPackageFilter = VALUE_DEFAULT_FILTER;
50	protected boolean fRemoveUnresolved = true; // remove unresolved export-package
51	protected boolean fCalculateUses = false; // calculate the 'uses' directive for exported packages
52	protected boolean fModifyDep = true; // modify import-package / require-bundle
53	protected boolean fRemoveDependencies = true; // if true: remove, else mark optional
54	protected boolean fUnusedDependencies = false; // find/remove unused dependencies - long running op
55	protected boolean fRemoveLazy = true; // remove lazy/auto start if no activator
56	protected boolean fPrefixIconNL = false; // prefix icon paths with $nl$
57	protected boolean fUnusedKeys = false; // remove unused <bundle-localization>.properties keys
58	protected boolean fAddDependencies = false;
59
60	ArrayList fProjectList;
61	private IProject fCurrentProject;
62
63	public OrganizeManifestsProcessor(ArrayList projects) {
64	fProjectList = projects;
65	}
66
67	public RefactoringStatus checkFinalConditions(IProgressMonitor pm,
68	CheckConditionsContext context) throws CoreException,
69	OperationCanceledException {
70	RefactoringStatus status = new RefactoringStatus();
71	for (Iterator i = fProjectList.iterator(); i.hasNext();) {
72	if (!(i.next() instanceof IProject))
73	status.addFatalError(PDEUIMessages.OrganizeManifestsProcessor_invalidParam);
74	}
75	return status;
76	}
77
78	public RefactoringStatus checkInitialConditions(IProgressMonitor pm)
79	throws CoreException, OperationCanceledException {
80	return null;
81	}
82
83	public Change createChange(IProgressMonitor pm) throws CoreException,
84	OperationCanceledException {
85	CompositeChange change = new CompositeChange(""); //$NON-NLS-1$
86	change.markAsSynthetic();
87	pm.beginTask(PDEUIMessages.OrganizeManifestJob_taskName, fProjectList.size());
88	for (Iterator i = fProjectList.iterator(); i.hasNext() && !pm.isCanceled();)
89	change.add(cleanProject((IProject)i.next(), new SubProgressMonitor(pm, 1)));
90	return change;
91	}
92
93	private Change cleanProject(IProject project, IProgressMonitor monitor) {
94	fCurrentProject = project;
95	CompositeChange change = new CompositeChange(NLS.bind(PDEUIMessages.OrganizeManifestsProcessor_rootMessage, new String[] {fCurrentProject.getName()}));
96	monitor.beginTask(NLS.bind(PDEUIMessages.OrganizeManifestsProcessor_rootMessage, new String[] {fCurrentProject.getName()}), getTotalTicksPerProject());
97
98	final TextFileChange[] result = { null };
99	final Exception[] ee = new Exception[1];
100	ModelModification modification = new ModelModification(fCurrentProject) {
101	protected void modifyModel(IBaseModel model, IProgressMonitor monitor) throws CoreException {
102	if (model instanceof IBundlePluginModelBase)
103	try {
104	runCleanup(monitor, (IBundlePluginModelBase)model, result);
105	} catch (InvocationTargetException e) {
106	ee[0] = e;
107	} catch (InterruptedException e) {
108	ee[0] = e;
109	}
110	}
111	};
112	TextFileChange[] changes = PDEModelUtility.changesForModelModication(modification, monitor);
113	for (int i = 0; i < changes.length; i++)
114	change.add(changes[i]);
115	if (result[0] != null)
116	change.add(result[0]);
117	if (ee[0] != null)
118	PDEPlugin.log(ee[0]);
119	return change;
120	}
121
122	private void runCleanup(IProgressMonitor monitor, IBundlePluginModelBase modelBase,
123	TextFileChange[] result) throws InvocationTargetException, InterruptedException {
124
125	IBundle currentBundle = modelBase.getBundleModel().getBundle();
126	ISharedExtensionsModel sharedExtensionsModel = modelBase.getExtensionsModel();
127	IPluginModelBase currentExtensionsModel = null;
128	if (sharedExtensionsModel instanceof IPluginModelBase)
129	currentExtensionsModel = (IPluginModelBase)sharedExtensionsModel;
130
131	String projectName = fCurrentProject.getName();
132
133	if (fAddMissing \|\| fRemoveUnresolved) {
134	monitor.subTask(NLS.bind(PDEUIMessages.OrganizeManifestsOperation_export, projectName));
135	if (!monitor.isCanceled())
136	OrganizeManifest.organizeExportPackages(currentBundle, fCurrentProject, fAddMissing, fRemoveUnresolved);
137	if (fAddMissing)
138	monitor.worked(1);
139	if (fRemoveUnresolved)
140	monitor.worked(1);
141	}
142
143	if (fMarkInternal) {
144	monitor.subTask(NLS.bind(PDEUIMessages.OrganizeManifestsOperation_filterInternal, projectName));
145	if (!monitor.isCanceled())
146	OrganizeManifest.markPackagesInternal(currentBundle, fPackageFilter);
147	monitor.worked(1);
148	}
149
150	if (fModifyDep) {
151	String message = fRemoveDependencies ?
152	NLS.bind(PDEUIMessages.OrganizeManifestsOperation_removeUnresolved, projectName) :
153	NLS.bind(PDEUIMessages.OrganizeManifestsOperation_markOptionalUnresolved, projectName);
154	monitor.subTask(message);
155	if (!monitor.isCanceled())
156	OrganizeManifest.organizeImportPackages(currentBundle, fRemoveDependencies);
157	monitor.worked(1);
158
159	if (!monitor.isCanceled())
160	OrganizeManifest.organizeRequireBundles(currentBundle, fRemoveDependencies);
161	monitor.worked(1);
162	}
163
164	if (fCalculateUses) {
165	// we don't set the subTask because it is done in the CalculateUsesOperation, for each package it scans
166	if (!monitor.isCanceled()) {
167	CalculateUsesOperation op = new CalculateUsesOperation(fCurrentProject, modelBase);
168	op.run(new SubProgressMonitor(monitor, 2));
169	}
170	}
171
172	if (fAddDependencies) {
173	monitor.subTask(NLS.bind (PDEUIMessages.OrganizeManifestsOperation_additionalDeps, projectName));
174	if (!monitor.isCanceled()) {
175	AddNewDependenciesOperation op = new AddNewDependenciesOperation(fCurrentProject, modelBase);
176	op.run(new SubProgressMonitor(monitor, 4));
177	}
178	}
179
180	if (fUnusedDependencies) {
181	monitor.subTask(NLS.bind(PDEUIMessages.OrganizeManifestsOperation_unusedDeps, projectName));
182	if (!monitor.isCanceled()) {
183	SubProgressMonitor submon = new SubProgressMonitor(monitor, 4);
184	GatherUnusedDependenciesOperation udo = new GatherUnusedDependenciesOperation(modelBase);
185	udo.run(submon);
186	GatherUnusedDependenciesOperation.removeDependencies(modelBase, udo.getList().toArray());
187	submon.done();
188	}
189	}
190
191	if (fRemoveLazy) {
192	monitor.subTask(NLS.bind(PDEUIMessages.OrganizeManifestsOperation_lazyStart, fCurrentProject.getName()));
193	if (!monitor.isCanceled())
194	OrganizeManifest.removeUnneededLazyStart(currentBundle);
195	monitor.worked(1);
196	}
197
198	if (fPrefixIconNL) {
199	monitor.subTask(NLS.bind(PDEUIMessages.OrganizeManifestsOperation_nlIconPath, projectName));
200	if (!monitor.isCanceled())
201	OrganizeManifest.prefixIconPaths(currentExtensionsModel);
202	monitor.worked(1);
203	}
204
205	if (fUnusedKeys) {
206	monitor.subTask(NLS.bind(PDEUIMessages.OrganizeManifestsOperation_unusedKeys, projectName));
207	if (!monitor.isCanceled()) {
208	TextFileChange[] results = OrganizeManifest.removeUnusedKeys(fCurrentProject, currentBundle, currentExtensionsModel);
209	if (results.length > 0)
210	result[0] = results[0];
211	}
212	monitor.worked(1);
213	}
214	}
215
216	public Object[] getElements() {
217	return fProjectList.toArray();
218	}
219
220	public String getIdentifier() {
221	return getClass().getName();
222	}
223
224	public String getProcessorName() {
225	return PDEUIMessages.OrganizeManifestsWizardPage_title;
226	}
227
228	public boolean isApplicable() throws CoreException {
229	return true;
230	}
231
232	public RefactoringParticipant[] loadParticipants(RefactoringStatus status,
233	SharableParticipants sharedParticipants) throws CoreException {
234	return new RefactoringParticipant[0];
235	}
236
237	private int getTotalTicksPerProject() {
238	int ticks = 0;
239	if (fAddMissing) ticks += 1;
240	if (fMarkInternal) ticks += 1;
241	if (fRemoveUnresolved) ticks += 1;
242	if (fCalculateUses) ticks += 4;
243	if (fModifyDep) ticks += 2;
244	if (fUnusedDependencies)ticks += 4;
245	if (fAddDependencies) ticks += 4;
246	if (fRemoveLazy) ticks += 1;
247	if (fPrefixIconNL) ticks += 1;
248	if (fUnusedKeys) ticks += 1;
249	return ticks;
250	}
251
252	public void setAddMissing(boolean addMissing) {
253	fAddMissing = addMissing;
254	}
255	public void setMarkInternal(boolean markInternal) {
256	fMarkInternal = markInternal;
257	}
258	public void setPackageFilter(String packageFilter) {
259	fPackageFilter = packageFilter;
260	}
261	public void setRemoveUnresolved(boolean removeUnresolved) {
262	fRemoveUnresolved = removeUnresolved;
263	}
264	public void setCalculateUses(boolean calculateUses) {
265	fCalculateUses = calculateUses;
266	}
267	public void setModifyDep(boolean modifyDep) {
268	fModifyDep = modifyDep;
269	}
270	public void setRemoveDependencies(boolean removeDependencies) {
271	fRemoveDependencies = removeDependencies;
272	}
273	public void setUnusedDependencies(boolean unusedDependencies) {
274	fUnusedDependencies = unusedDependencies;
275	}
276	public void setRemoveLazy(boolean removeLazy) {
277	fRemoveLazy = removeLazy;
278	}
279	public void setPrefixIconNL(boolean prefixIconNL) {
280	fPrefixIconNL = prefixIconNL;
281	}
282	public void setUnusedKeys(boolean unusedKeys) {
283	fUnusedKeys = unusedKeys;
284	}
285	public void setAddDependencies(boolean addDependencies) {
286	fAddDependencies = addDependencies;
287	}
288	}