<extension

             point="org.eclipse.jdt.ui.classpathFixProcessors">

          <classpathFixProcessor

                class="org.eclipse.pde.internal.ui.correction.java.UnresolvedImportFixProcessor"

                id="org.eclipse.pde.ui.unresolvedImportQuickFixProcessor"

                name="Unresolved Import Quick Fix Processor">

                <enablement>

                   <with variable="project">

		              <test property="org.eclipse.jdt.core.isInJavaProjectWithNature" value="org.eclipse.pde.PluginNature"/>

                   </with>

                </enablement>

                <overrides id="org.eclipse.jdt.ui.text.correction.DefaultClasspathFixProcessor"/>

                <overrides id="org.eclipse.jdt.junit.JUnitClasspathFixProcessor"/>

          </classpathFixProcessor>

       </extension>

	public static String UnresolvedImportFixProcessor_0;

	public static String UnresolvedImportFixProcessor_1;

	public static String UnresolvedImportFixProcessor_2;

	public static String UnresolvedImportFixProcessor_3;

	public static String UnresolvedImportFixProcessor_4;

	public static String UnresolvedImportFixProcessor_5;

/*******************************************************************************

 * 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.correction.java;

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.Status;

import org.eclipse.jdt.ui.ISharedImages;

import org.eclipse.jdt.ui.JavaUI;

import org.eclipse.jdt.ui.text.java.ClasspathFixProcessor.ClasspathFixProposal;

import org.eclipse.ltk.core.refactoring.Change;

import org.eclipse.ltk.core.refactoring.RefactoringStatus;

import org.eclipse.osgi.service.resolver.ExportPackageDescription;

import org.eclipse.pde.core.IBaseModel;

import org.eclipse.pde.core.plugin.IPluginModelBase;

import org.eclipse.pde.internal.ui.util.ModelModification;

import org.eclipse.pde.internal.ui.util.PDEModelUtility;

import org.eclipse.swt.graphics.Image;

/**

 * Abstract class defining a classpath fix proposal that will 

 * offer to fix an unresolved import by adding a dependency to

 * the plugin.  Creates a Change object that will add the dependency

 * when invoked.  When invoked, the Change object will also add an

 * undo change that will remove the dependency.  Extending classes

 * must implement handleDependencyChange to determine how the

 * dependency will be added (bundle requirement, package import, etc).

 * Two other abstract methods allow extending classes to define the

 * label and description associated with this proposal and it's changes.

 *  

 * @since 3.4

 * @see UnresolvedImportFixProcessor

 * @see UnresolvedImportDependencyChange

 */

public abstract class UnresolvedImportFixProposal extends ClasspathFixProposal{

	private IProject fProject;

	private ExportPackageDescription fDependency;

	/**

	 * Constructor

	 * @param project The project that needs the new required bundle

	 * @param packageDescription the package we want a dependency on

	 */

	/**

	 * Constructor

	 * @param project the project that will be modified to add the dependency

	 * @param packageDependency the package that must be added as a dependency

	 */

	public UnresolvedImportFixProposal(IProject project, ExportPackageDescription packageDependency) {

		fProject = project;

		fDependency = packageDependency;

	}

	/**

	 * Returns the label to use for the proposal and change.

	 * Label can be different if this is the undo change and

	 * the dependency is being removed rather than added.

	 * 

	 * @param isAdd whether the dependency is being added vs removed

	 * @return label to use for the proposal and change

	 */

	public abstract String getLabel(boolean isAdd);

	/**

	 * Return the description that will be displayed for this

	 * proposal in the 'Additional Information' area of the 

	 * quick fix popup.

	 * 

	 * @return description to use for this proposal

	 */

	public abstract String getDescription();

	/**

	 * Implementors must handle the addition or removal of the given package

	 * as a dependency for the given model in this method.

	 * 

	 * @param pm progress monitor to display progress as change takes place

	 * @param model model that will be changed to add/remove the dependency

	 * @param dependency the package to add/remove as a dependency

	 * @param isAdd whether the package is being added or removed

	 * @throws CoreException if there is a problem trying to change the dependency.

	 */

	public abstract void handleDependencyChange(IProgressMonitor pm, IPluginModelBase model, ExportPackageDescription dependency, boolean isAdd) throws CoreException;

	/* (non-Javadoc)

	 * @see org.eclipse.jdt.ui.text.java.ClasspathFixProcessor.ClasspathFixProposal#createChange(org.eclipse.core.runtime.IProgressMonitor)

	 */

	public Change createChange(IProgressMonitor monitor) throws CoreException {

		return new UnresolvedImportDependencyChange(fProject,fDependency, true);

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jdt.ui.text.java.ClasspathFixProcessor.ClasspathFixProposal#getAdditionalProposalInfo()

	 */

	public String getAdditionalProposalInfo() {

		return getDescription();

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jdt.ui.text.java.ClasspathFixProcessor.ClasspathFixProposal#getDisplayString()

	 */

	public String getDisplayString() {

		return getLabel(true);

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jdt.ui.text.java.ClasspathFixProcessor.ClasspathFixProposal#getImage()

	 */

	public Image getImage() {

		return JavaUI.getSharedImages().getImage(ISharedImages.IMG_OBJS_LIBRARY);

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jdt.ui.text.java.ClasspathFixProcessor.ClasspathFixProposal#getRelevance()

	 */

	public int getRelevance() {

		return 16;

	}

	/**

	 * @return the project this proposal will change with the new dependency

	 */

	public IProject getProject(){

		return fProject;

	}

	/**

	 * @return the package dependency this proposal is offering add

	 */

	public ExportPackageDescription getDependency(){

		return fDependency;

	}

	/**

	 * A Change object that will modify a plugin to add or remove

	 * a dependency on a package.

	 * @see UnresolvedImportFixProposal 

	 * @see UnresolvedImportFixProcessor

	 */

	private class UnresolvedImportDependencyChange extends Change{

		private IProject fBaseProject;

		private ExportPackageDescription fDependency;

		private boolean fIsAdd;

		/**

		 * Constructor

		 * @param project the project to change dependency on

		 * @param packageDescription the package dependency to change

		 * @param isAdd whether the dependency will be added or removed

		 */

		public UnresolvedImportDependencyChange(IProject project, ExportPackageDescription packageDescription, boolean isAdd) {

			fBaseProject = project;

			fDependency = packageDescription;

			fIsAdd= isAdd;

		}

		/* (non-Javadoc)

		 * @see org.eclipse.ltk.core.refactoring.Change#perform(org.eclipse.core.runtime.IProgressMonitor)

		 */

		public Change perform(IProgressMonitor pm) throws CoreException {

			ModelModification modelMod = new ModelModification(fBaseProject){

				protected void modifyModel(IBaseModel model, IProgressMonitor monitor) throws CoreException {

					if (model instanceof IPluginModelBase) {

						handleDependencyChange(monitor, (IPluginModelBase)model, fDependency, fIsAdd);

					}

				}

			};

			PDEModelUtility.modifyModel(modelMod, pm);

			// Return the undo action to do the opposite

			return new UnresolvedImportDependencyChange(fBaseProject, fDependency, !fIsAdd);

		}

		/* (non-Javadoc)

		 * @see org.eclipse.ltk.core.refactoring.Change#isValid(org.eclipse.core.runtime.IProgressMonitor)

		 */

		public RefactoringStatus isValid(IProgressMonitor pm) throws CoreException,	OperationCanceledException {

			return RefactoringStatus.create(Status.OK_STATUS);

		}

		/* (non-Javadoc)

		 * @see org.eclipse.ltk.core.refactoring.Change#initializeValidationData(org.eclipse.core.runtime.IProgressMonitor)

		 */

		public void initializeValidationData(IProgressMonitor pm) {

		}

		/* (non-Javadoc)

		 * @see org.eclipse.ltk.core.refactoring.Change#getName()

		 */

		public String getName() {

			return getLabel(fIsAdd);

		}

		/* (non-Javadoc)

		 * @see org.eclipse.ltk.core.refactoring.Change#getModifiedElement()

		 */

		public Object getModifiedElement() {

			return fBaseProject;

		}

	}

}

/*******************************************************************************

 * 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.correction.java;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

import org.eclipse.core.resources.IProject;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.jdt.core.IJavaProject;

import org.eclipse.jdt.ui.text.java.ClasspathFixProcessor;

import org.eclipse.osgi.service.resolver.BundleDescription;

import org.eclipse.osgi.service.resolver.BundleSpecification;

import org.eclipse.osgi.service.resolver.ExportPackageDescription;

import org.eclipse.osgi.service.resolver.ImportPackageSpecification;

import org.eclipse.pde.core.plugin.IPluginImport;

import org.eclipse.pde.core.plugin.IPluginModelBase;

import org.eclipse.pde.core.plugin.PluginRegistry;

import org.eclipse.pde.internal.core.ICoreConstants;

import org.eclipse.pde.internal.core.PDECore;

import org.eclipse.pde.internal.core.bundle.BundlePluginBase;

import org.eclipse.pde.internal.core.converter.PluginConverter;

import org.eclipse.pde.internal.core.ibundle.IBundle;

import org.eclipse.pde.internal.core.ibundle.IBundlePluginModelBase;

import org.eclipse.pde.internal.core.ibundle.IManifestHeader;

import org.eclipse.pde.internal.core.text.bundle.Bundle;

import org.eclipse.pde.internal.core.text.bundle.ImportPackageHeader;

import org.eclipse.pde.internal.core.text.bundle.ImportPackageObject;

import org.eclipse.pde.internal.ui.PDEUIMessages;

import org.osgi.framework.Constants;

import org.osgi.framework.Version;

import com.ibm.icu.text.MessageFormat;

/**

 * Offers a classpath fix proposal if the broken import statement can be

 * fixed by adding a plugin dependency (required bundle or package import).

 * @since 3.4

 */

public class UnresolvedImportFixProcessor extends ClasspathFixProcessor {

	/* (non-Javadoc)

	 * @see org.eclipse.jdt.ui.text.java.ClasspathFixProcessor#getFixImportProposals(org.eclipse.jdt.core.IJavaProject, java.lang.String)

	 */

	public ClasspathFixProposal[] getFixImportProposals(IJavaProject project, String name) throws CoreException {

		int idx= name.lastIndexOf('.');

		String packageName= idx != -1 ? name.substring(0, idx) : null;

		String typeName= name.substring(idx + 1);

		if (typeName.length() == 1 && typeName.charAt(0) == '*') {

			typeName= null;

		}

		if (packageName != null){

			// Get the packages exported by all bundles, see if any can provide the required classes

			ExportPackageDescription[] knownPackages = PDECore.getDefault().getModelManager().getState().getState().getExportedPackages();

			Set validPackages = new HashSet();

			for (int i = 0; i < knownPackages.length; i++) {

				if (knownPackages[i].getName().equals(packageName)){

					validPackages.add(knownPackages[i]);

				}

			}

			List proposals = new ArrayList();

			Iterator validPackagesIter = validPackages.iterator();

			while (validPackagesIter.hasNext()) {

				ExportPackageDescription currentPackage = (ExportPackageDescription) validPackagesIter.next();

				addRequireBundleProposal(proposals, project.getProject(),currentPackage);

				addImportPackageProposal(proposals, project.getProject(),currentPackage);

			}

			return (ClasspathFixProposal[])proposals.toArray(new ClasspathFixProposal[proposals.size()]);

		}

		return new ClasspathFixProposal[0];

	}

	/**

	 * Helper method to create a proposal to add an require bundle dependency to the project

	 */

	private void addRequireBundleProposal(List proposalList, IProject project, ExportPackageDescription dependency){

		// Check if the bundle already exists

		boolean alreadyExists = false;

		BundleDescription description = PluginRegistry.findModel(project).getBundleDescription();

		BundleSpecification[] requiredBundles = description.getRequiredBundles();

		for (int i = 0; i < requiredBundles.length; i++) {

			if (requiredBundles[i].getName().equals(dependency.getExporter().getSymbolicName())){

				alreadyExists = true;

				break;

			}

		}

		if (!alreadyExists){

			proposalList.add(new UnresolvedImportFixProposal(project, dependency) {

				/* (non-Javadoc)

				 * @see org.eclipse.pde.internal.ui.correction.java.UnresolvedImportFixProposal#handleDependencyChange(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.pde.internal.core.ibundle.IBundlePluginModelBase, org.eclipse.osgi.service.resolver.ExportPackageDescription, boolean)

				 */

				public void handleDependencyChange(IProgressMonitor pm,	IPluginModelBase model, ExportPackageDescription dependency, boolean isAdd) throws CoreException {

					IPluginImport pluginImport = model.getPluginFactory().createImport();

					pluginImport.setId(dependency.getExporter().getSymbolicName());

					if (isAdd) {

						model.getPluginBase().add(pluginImport);

					} else {

						model.getPluginBase().remove(pluginImport);

					}

				}

				/* (non-Javadoc)

				 * @see org.eclipse.pde.internal.ui.correction.java.UnresolvedImportFixProposal#getLabel(boolean)

				 */

				public String getLabel(boolean isAdd) {

					if (isAdd) {

						return MessageFormat.format(PDEUIMessages.UnresolvedImportFixProcessor_0,new Object[]{getDependency().getExporter().getName()});

					}

					return MessageFormat.format(PDEUIMessages.UnresolvedImportFixProcessor_1,new Object[]{getDependency().getExporter().getName()});

				}

				/* (non-Javadoc)

				 * @see org.eclipse.pde.internal.ui.correction.java.UnresolvedImportFixProposal#getDescription()

				 */

				public String getDescription() {

					return PDEUIMessages.UnresolvedImportFixProcessor_2;

				}

			});

		}

	}

	/**

	 * Helper method to create a proposal to add an import package dependency to the project

	 */

	private void addImportPackageProposal(List proposalList, IProject project, ExportPackageDescription dependency){

		// Check if the import package already exists

		boolean alreadyExists = false;

		IPluginModelBase base = PluginRegistry.findModel(project);

		if (!(base instanceof IBundlePluginModelBase)){

			// The model must be manifest based to add an import package entry

			return;

		}

		BundleDescription description = base.getBundleDescription();

		ImportPackageSpecification[] importedPackages = description.getImportPackages();

		for (int i = 0; i < importedPackages.length; i++) {

			if (importedPackages[i].getName().equals(dependency.getName())){

				alreadyExists = true;

				break;

			}

		}

		if (!alreadyExists){

			proposalList.add(new UnresolvedImportFixProposal(project, dependency) {

				/* (non-Javadoc)

				 * @see org.eclipse.pde.internal.ui.correction.java.UnresolvedImportFixProposal#handleDependencyChange(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.pde.internal.core.ibundle.IBundlePluginModelBase, org.eclipse.osgi.service.resolver.ExportPackageDescription, boolean)

				 */

				public void handleDependencyChange(IProgressMonitor pm,	IPluginModelBase model, ExportPackageDescription dependency, boolean isAdd) throws CoreException {

					IBundle bundle = ((IBundlePluginModelBase)model).getBundleModel().getBundle();

					if (!(bundle instanceof Bundle)){

						return;

					}

					IManifestHeader mheader = bundle.getManifestHeader(Constants.IMPORT_PACKAGE);

					if (mheader == null) {

						bundle.setHeader(Constants.IMPORT_PACKAGE, new String());

						mheader = bundle.getManifestHeader(Constants.IMPORT_PACKAGE);

					}

					if (mheader instanceof ImportPackageHeader) {

						ImportPackageHeader header = (ImportPackageHeader) mheader;

						String versionAttr = (BundlePluginBase.getBundleManifestVersion(bundle) < 2) ? ICoreConstants.PACKAGE_SPECIFICATION_VERSION : Constants.VERSION_ATTRIBUTE;  

						ImportPackageObject obj = new ImportPackageObject(header, dependency, versionAttr);

						header.addPackage(obj);

					} else {

						StringBuffer buffer = new StringBuffer();

						String currentValue = (mheader != null) ? mheader.getValue() : null;

						if (currentValue != null){

							buffer.append(currentValue).append(PluginConverter.LIST_SEPARATOR);

						}

						if (dependency.getVersion().equals(Version.emptyVersion)){

							buffer.append(dependency.getName());

						} else {

							buffer.append(dependency.getName());

							buffer.append("; version=\""); //$NON-NLS-1$

							buffer.append(dependency.getVersion());

							buffer.append("\""); //$NON-NLS-1$

						}

						bundle.setHeader(Constants.IMPORT_PACKAGE, buffer.toString());

					}

				}

				/* (non-Javadoc)

				 * @see org.eclipse.pde.internal.ui.correction.java.UnresolvedImportFixProposal#getLabel(boolean)

				 */

				public String getLabel(boolean isAdd) {

					if (isAdd) {

						return MessageFormat.format(PDEUIMessages.UnresolvedImportFixProcessor_3,new Object[]{getDependency().getName()});

					}

					return MessageFormat.format(PDEUIMessages.UnresolvedImportFixProcessor_4,new Object[]{getDependency().getName()});

				}

				/* (non-Javadoc)

				 * @see org.eclipse.pde.internal.ui.correction.java.UnresolvedImportFixProposal#getDescription()

				 */

				public String getDescription() {

					return PDEUIMessages.UnresolvedImportFixProcessor_5;

				}

			});

		}

	}

}