<element ref="commandMenuContribution" minOccurs="0" maxOccurs="unbounded"/>

   <element name="commandMenuContribution">

      <annotation>

         <documentation>

            Specifies the contribution of a command to the context menu associated with a Common Navigator ViewPart. This is used in conjuction with the <b>viewerCommandMenuBinding</b> element in the <b>viewer</b> extension point.

<br/><br/>

Its function is similar the <b>menuContribution</b> element in the <b>org.eclipse.ui.menus</b> extention point (and replaces its use in the context of the Common Navigator).

<br/><br/>

You should use this element (instead of the <b>menuContribution</b> element) when there is a possibility that the same command may be associated with a given Common Navigator ViewPart instance. Configuring using this element will make sure the command only occurs one time in the context menu, where if you used the <b>menuContribution</b> element the command would be duplicated.

         </documentation>

      </annotation>

      <complexType>

         <attribute name="commandId" type="string" use="required">

            <annotation>

               <documentation>

               </documentation>

               <appInfo>

                  <meta.attribute kind="identifier" basedOn="org.eclipse.ui.commands/command/@id"/>

               </appInfo>

            </annotation>

         </attribute>

         <attribute name="after" type="string">

            <annotation>

               <documentation>

               </documentation>

            </annotation>

         </attribute>

      </complexType>

   </element>

            <element ref="viewerCommandMenuBinding" minOccurs="0" maxOccurs="unbounded"/>

            <element ref="viewerHandlerBinding" minOccurs="0" maxOccurs="unbounded"/>

   <element name="viewerCommandMenuBinding">

      <annotation>

         <documentation>

            Clients may use this to bind commands and handlers to their viewer. Although you can bind commands to a view using the normal mechanisms in the LINKcommand service, using this element is recommended if there will be multple unrelated plugins contributing to the view as it provides two additional benefits:

<ol>

<li>Prevents duplication - in the event that the same command is found to a viewer multiple times (by multiple unrelated plugins), it will be found only once. As is normal when using handlers, they must properly coordinate their activation.

<li>Dynamic handler creation - the specified handler will be created in response to this element, and if it has a constructor that has a LINKViewPart as its argument, that will be invoked, allowing the handler to register for and respond to the view's selection events.

</ol>

Clients may define an <b>includes</b> element to select which commands are visible to the viewer, and  similarly an <b>excludes</b> element for commands that should not be made visible to the viewer. 

<br><br>

A viewer may have multiple <b>viewerCommandBinding</b>s defined, and their <b>includes</b>/<b>excludes</b> statements will be aggregated to produce the final behavior.

<br><br>

For <b>actionProvider</b> definitions which are not nested under a <b>navigatorContent</b> definition, clients may specify a custom id. If clients do not specify an id, the id defaults to "org.eclipse.ui.navigator.actionProvider.X". For clients that wish to pick up <b>actionProvider</b>s with no specific id, clients must define a <b>viewerActionBinding</b> for the default id. See the examples section for how this is done.

         </documentation>

      </annotation>

      <complexType>

         <sequence>

            <element ref="includes" minOccurs="0" maxOccurs="1"/>

            <element ref="excludes" minOccurs="0" maxOccurs="1"/>

         </sequence>

         <attribute name="viewerId" type="string" use="required">

            <annotation>

               <documentation>

                  The id of the common viewer. If the viewer is in a common navigator then the id must match the navigator's id defined in its <b>org.eclipse.ui.views</b> extension.

               </documentation>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <element name="viewerHandlerBinding">

      <annotation>

         <documentation>

            *** get rid of this one, just start the handlers with the project explorer **

Clients may use this to bind commands and handlers to their viewer. Although you can bind commands to a view using the normal mechanisms in the LINKcommand service, using this element is recommended if there will be multple unrelated plugins contributing to the view as it provides two additional benefits:

<ol>

<li>Prevents duplication - in the event that the same command is found to a viewer multiple times (by multiple unrelated plugins), it will be found only once. As is normal when using handlers, they must properly coordinate their activation.

<li>Dynamic handler creation - the specified handler will be created in response to this element, and if it has a constructor that has a LINKViewPart as its argument, that will be invoked, allowing the handler to register for and respond to the view's selection events.

</ol>

Clients may define an <b>includes</b> element to select which commands are visible to the viewer, and  similarly an <b>excludes</b> element for commands that should not be made visible to the viewer. 

<br><br>

A viewer may have multiple <b>viewerCommandBinding</b>s defined, and their <b>includes</b>/<b>excludes</b> statements will be aggregated to produce the final behavior.

<br><br>

For <b>actionProvider</b> definitions which are not nested under a <b>navigatorContent</b> definition, clients may specify a custom id. If clients do not specify an id, the id defaults to "org.eclipse.ui.navigator.actionProvider.X". For clients that wish to pick up <b>actionProvider</b>s with no specific id, clients must define a <b>viewerActionBinding</b> for the default id. See the examples section for how this is done.

         </documentation>

      </annotation>

      <complexType>

         <sequence>

            <element ref="includes" minOccurs="0" maxOccurs="1"/>

            <element ref="excludes" minOccurs="0" maxOccurs="1"/>

         </sequence>

         <attribute name="viewerId" type="string" use="required">

            <annotation>

               <documentation>

                  The id of the common viewer. If the viewer is in a common navigator then the id must match the navigator's id defined in its <b>org.eclipse.ui.views</b> extension.

               </documentation>

            </annotation>

         </attribute>

      </complexType>

   </element>

            <sequence>

               <element ref="commandMenuExtension" minOccurs="1" maxOccurs="unbounded"/>

            </sequence>

            <sequence>

               <element ref="handler" minOccurs="1" maxOccurs="unbounded"/>

            </sequence>

            <sequence>

               <element ref="commandMenuExtension" minOccurs="1" maxOccurs="unbounded"/>

            </sequence>

            <sequence>

               <element ref="handler" minOccurs="1" maxOccurs="unbounded"/>

            </sequence>

   <element name="commandMenuExtension">

      <annotation>

         <documentation>

            Indicates the command id or regular expression pattern to be used to find the command(s) to be associated with the viewer. These must be declared using the <b>commandMenuContribution</b> element in the <b>navigatorContent</b> extension point.

         </documentation>

      </annotation>

      <complexType>

         <attribute name="pattern" type="string" use="required">

            <annotation>

               <documentation>

                  Content extensions may be selected exactly by using their content extension id. Clients may also use a regular expression pattern to select any content extensions that have ids that match the pattern. 

<p>

Patterns are regular expressions which match unique identifiers. Please see the Java(tm) Platform documentation for <code>java.util.regex.Pattern</code> for further details.

               </documentation>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <element name="handler">

      <annotation>

         <documentation>

            The identification of a handler to bind in the <b>viewerCommandBinding</b>.

         </documentation>

      </annotation>

      <complexType>

         <attribute name="pattern" type="string" use="required">

            <annotation>

               <documentation>

                  Content extensions may be selected exactly by using their content extension id. Clients may also use a regular expression pattern to select any content extensions that have ids that match the pattern. 

<p>

Patterns are regular expressions which match unique identifiers. Please see the Java(tm) Platform documentation for <code>java.util.regex.Pattern</code> for further details.

               </documentation>

            </annotation>

         </attribute>

      </complexType>

   </element>

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.internal.navigator.extensions.CommandMenuContributionDescriptor;

import org.eclipse.ui.internal.navigator.extensions.CommandMenuContributionDescriptorManager;

import org.eclipse.ui.menus.AbstractContributionFactory;

import org.eclipse.ui.menus.CommandContributionItem;

import org.eclipse.ui.menus.CommandContributionItemParameter;

import org.eclipse.ui.menus.IContributionRoot;

import org.eclipse.ui.menus.IMenuService;

import org.eclipse.ui.services.IServiceLocator;

	/**

	 * Install the commands into the specified viewer

	 * 

	 * @param viewer

	 */

	public void bindCommandMenuContributions(StructuredViewer viewer) {

		CommandMenuContributionDescriptorManager mgr = CommandMenuContributionDescriptorManager

				.getInstance();

		final IMenuService menuService = (IMenuService) PlatformUI.getWorkbench().getService(

				IMenuService.class);

		String urlBase = "popup:" + getViewerId(); //$NON-NLS-1$

		Iterator it = mgr.getDescriptors().iterator();

		while (it.hasNext()) {

			CommandMenuContributionDescriptor desc = (CommandMenuContributionDescriptor) it.next();

			NavigatorViewerDescriptor vd = NavigatorViewerDescriptorManager.getInstance()

					.getNavigatorViewerDescriptor(getViewerId());

			if (vd.isVisibleCommand(desc.getCommandId())) {

				final CommandMenuContributionDescriptor finalDesc = desc;

				String url = urlBase;

				if (desc.getAfter() != null)

					url += "?after=" + desc.getAfter(); //$NON-NLS-1$

				AbstractContributionFactory factory = new AbstractContributionFactory(url, desc.getPluginId()) {

					public void createContributionItems(IServiceLocator serviceLocator,

							IContributionRoot additions) {

						CommandContributionItemParameter cp = new CommandContributionItemParameter(serviceLocator, null, finalDesc.getCommandId(), CommandContributionItem.STYLE_PULLDOWN);

						CommandContributionItem item = new CommandContributionItem(cp);

						additions.addContributionItem(item, null);

					}

				};

				menuService.addContributionFactory(factory);

			}

		}

	}

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

 * Copyright (c) 2003, 2010 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.ui.internal.navigator.extensions;

import org.eclipse.core.runtime.Assert;

import org.eclipse.core.runtime.IConfigurationElement;

import org.eclipse.ui.internal.navigator.extensions.INavigatorContentExtPtConstants;

/**

 * 

 * 

 * @since 3.5

 */

public class CommandMenuContributionDescriptor implements INavigatorContentExtPtConstants {

	private final IConfigurationElement configurationElement;

	private final String commandId;

	private final String after;

	private final String pluginId;

	private String toString;

	/**

	 * @param aConfigElement

	 */

	public CommandMenuContributionDescriptor(IConfigurationElement aConfigElement) {

		super();

		Assert.isTrue(TAG_COMMAND_MENU_CONTRIBUTION.equals(aConfigElement.getName()));

		configurationElement = aConfigElement;

		pluginId = configurationElement.getContributor().getName();

		commandId = configurationElement.getAttribute(ATT_COMMAND_ID);

		after = configurationElement.getAttribute(ATT_AFTER);

	}

	/**

	 * 

	 * @return The command id.

	 */

	public String getCommandId() {

		return commandId;

	}

	/**

	 * 

	 * @return The after value which is which group the command is placed in in

	 *         the context menu.

	 */

	public String getAfter() {

		return after;

	}

	/**

	 * @return the id of the contributing plugin

	 */

	public String getPluginId() {

		return pluginId;

	}

	public String toString() {

		if (toString == null) {

			toString = "CommandMenuContributionDescriptor[commandId=" + getCommandId() + ", after=" + getAfter() + "]"; //$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$

		}

		return toString;

	}

}

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

 * Copyright (c) 2010 Oakland Software Incorporated 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:

 *     Francis Upton IV, Oakland Software Incorporated - initial API and implementation

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

package org.eclipse.ui.internal.navigator.extensions;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import org.eclipse.core.runtime.IConfigurationElement;

import org.eclipse.ui.internal.navigator.extensions.NavigatorContentRegistryReader;

/**

 * Manages descriptors consumed from the 'commandMenuContribution' elements of

 * the <b>org.eclipse.ui.navigator.navigatorContent</b> extension point.

 * 

 * @since 3.5

 * 

 */

public class CommandMenuContributionDescriptorManager {

	private static final CommandMenuContributionDescriptorManager INSTANCE = new CommandMenuContributionDescriptorManager();

	private CommandMenuContributionDescriptorManager() {

		new RegistryReader().readRegistry();

	}

	/**

	 * @return the singleton instance of the this class

	 */

	public static CommandMenuContributionDescriptorManager getInstance() {

		return INSTANCE;

	}

	private final Set rootDescriptors = new HashSet();

	private final List rootDescriptorsList = new ArrayList();

	/**

	 * @return the descriptors

	 */

	public List getDescriptors() {

		return rootDescriptorsList;

	}

	/**

	 * 

	 * @param descriptor

	 *            A valid descriptor to begin managing.

	 */

	protected void addActionDescriptor(CommandMenuContributionDescriptor descriptor) {

		if (rootDescriptors.contains(descriptor.getCommandId())) {

			return;

		}

		rootDescriptorsList.add(descriptor);

		rootDescriptors.add(descriptor.getCommandId());

	}

	private class RegistryReader extends NavigatorContentRegistryReader {

		protected boolean readElement(IConfigurationElement anElement) {

			if (TAG_COMMAND_MENU_CONTRIBUTION.equals(anElement.getName())) {

				addActionDescriptor(new CommandMenuContributionDescriptor(anElement));

				return true;

			}

			return super.readElement(anElement);

		}

	}

}

	String TAG_COMMAND_MENU_CONTRIBUTION = "commandMenuContribution"; //$NON-NLS-1$

	/** */

	String ATT_COMMAND_ID = "commandId"; //$NON-NLS-1$

	/** */

	String ATT_AFTER = "after"; //$NON-NLS-1$

	/** */

	String TAG_VIEWER_COMMAND_BINDING = "viewerCommandMenuBinding"; //$NON-NLS-1$

	/** */

	String TAG_VIEWER_HANDLER_BINDING = "viewerHandlerBinding"; //$NON-NLS-1$

	/** */

	private Binding commandBinding = new Binding(TAG_COMMAND_MENU_EXTENSION);

	public boolean isVisibleCommand(String aCommandId) {

		return commandBinding.isVisibleExtension(aCommandId);

	}

	 * @param binding

	 */

	public void setCommandBinding(Binding binding) {

		commandBinding = binding;

	}

	/**

	 * @return the content Binding

	 */

	public Binding getCommandBinding() {

		return commandBinding;

	}

	/**

		boolean respectRoots = false;

		Binding binding = null;

		if (bindingTag.equals(TAG_CONTENT_EXTENSION)) {

			binding = contentBinding;

			respectRoots = true;

		} else if (bindingTag.equals(TAG_ACTION_EXTENSION))

			binding = actionBinding;

		else if (bindingTag.equals(TAG_COMMAND_MENU_EXTENSION))

			binding = commandBinding;

	void setupFromParent(NavigatorViewerDescriptor parentDesc) {

		setActionBinding(parentDesc.getActionBinding());

		setContentBinding(parentDesc.getContentBinding());

		setCommandBinding(parentDesc.getCommandBinding());

		setDragAssistants(parentDesc.getDragAssistants());

	}

			System.out.println("name: " + element.getName()); //$NON-NLS-1$

import org.eclipse.core.commands.IHandler;

	/**

	 * @param commandId

	 * @param handler

	 * 

	 * @since 3.5

	 */

	public void bindHandler(String commandId, IHandler handler) {

	}

		contentService.bindCommandMenuContributions(this);

	 * Returns true if a command with the given id is 'visible'. A command

	 * is 'visible' if it matches a viewerCommandMenuBinding for the

	 * given viewer id.

	 * 

	 * @param aCommandId

	 *            The id to query

	 * @return True if the command id matches a viewerCommandMenuBinding for

	 *         the viewer id of this descriptor.

	 * @since 3.5

	 */

	boolean isVisibleCommand(String aCommandId);

	/**

command.goToResource=Go To Resource

       <viewerCommandMenuBinding

             viewerId="org.eclipse.ui.navigator.ProjectExplorer">

          <includes>

             <commandMenuExtension

                   pattern="org.eclipse.ui.navigate.goToResource">

             </commandMenuExtension>

          </includes>

       </viewerCommandMenuBinding>

       <viewerHandlerBinding

             viewerId="org.eclipse.ui.navigator.ProjectExplorer">

          <includes>

             <handler

                   pattern="org.eclipse.ui.navigate.goToResource">

             </handler>

          </includes>

       </viewerHandlerBinding>

      <commandMenuContribution

            commandId="org.eclipse.ui.navigate.goToResource">

      </commandMenuContribution>

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

 * Copyright (c) 2000, 2008 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.ui.navigator.resources;

import java.util.Iterator;

import java.util.List;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.eclipse.core.resources.IContainer;

import org.eclipse.core.resources.IResource;

import org.eclipse.core.runtime.Assert;

import org.eclipse.core.runtime.IPath;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.swt.SWTError;

import org.eclipse.swt.dnd.Clipboard;

import org.eclipse.swt.dnd.DND;

import org.eclipse.swt.dnd.FileTransfer;

import org.eclipse.swt.dnd.TextTransfer;

import org.eclipse.swt.dnd.Transfer;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.actions.SelectionListenerAction;

import org.eclipse.ui.part.ResourceTransfer;

import org.eclipse.ui.internal.navigator.resources.plugin.WorkbenchNavigatorMessages;

/**

 * Standard action for copying the currently selected resources to the clipboard.

 * <p>

 * This class may be instantiated; it is not intended to be subclassed.

 * </p>

 * 

 * @since 3.5

 */

public class CopyHandler extends AbstractHandler {

    /**

     * The id of this action.

     */

    public static final String ID = PlatformUI.PLUGIN_ID + ".CopyAction"; //$NON-NLS-1$

    /**

     * The shell in which to show any dialogs.

     */

    private Shell shell;

    /**

     * System clipboard

     */

    private Clipboard clipboard;

    /**

     * Associated paste action. May be <code>null</code>

     */

    private PasteHandler pasteAction;

    /**

     * Creates a new action.

     *

     * @param shell the shell for any dialogs

     * @param clipboard a platform clipboard

     */

    public CopyHandler(Shell shell, Clipboard clipboard) {

        super(WorkbenchNavigatorMessages.CopyAction_Cop_); 

        Assert.isNotNull(shell);

        Assert.isNotNull(clipboard);

        this.shell = shell;

        this.clipboard = clipboard;

        setToolTipText(WorkbenchNavigatorMessages.CopyAction_Copy_selected_resource_s_); 

        setId(CopyHandler.ID);

        PlatformUI.getWorkbench().getHelpSystem().setHelp(this, "CopyHelpId"); //$NON-NLS-1$

				// TODO INavigatorHelpContextIds.COPY_ACTION);

    }

    /**

     * Creates a new action.

     *

     * @param shell the shell for any dialogs

     * @param clipboard a platform clipboard

     * @param pasteAction a paste action

     * 

     * @since 2.0

     */

    public CopyHandler(Shell shell, Clipboard clipboard, PasteHandler pasteAction) {

        this(shell, clipboard);

        this.pasteAction = pasteAction;

    }

    /**

     * The <code>CopyAction</code> implementation of this method defined 

     * on <code>IAction</code> copies the selected resources to the 

     * clipboard.

     */

	/* (non-Javadoc)

	 * @see org.eclipse.core.commands.IHandler#execute(org.eclipse.core.commands.ExecutionEvent)

	 */

	public Object execute(ExecutionEvent event) throws ExecutionException {

        List selectedResources = getSelectedResources();

        IResource[] resources = (IResource[]) selectedResources

                .toArray(new IResource[selectedResources.size()]);

        // Get the file names and a string representation

        final int length = resources.length;

        int actualLength = 0;

        String[] fileNames = new String[length];

        StringBuffer buf = new StringBuffer();

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

            IPath location = resources[i].getLocation();

            // location may be null. See bug 29491.

            if (location != null) {

				fileNames[actualLength++] = location.toOSString();

			}

            if (i > 0) {

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

			}

            buf.append(resources[i].getName());

        }

        // was one or more of the locations null?

        if (actualLength < length) {

            String[] tempFileNames = fileNames;

            fileNames = new String[actualLength];

            for (int i = 0; i < actualLength; i++) {

				fileNames[i] = tempFileNames[i];

			}

        }

        setClipboard(resources, fileNames, buf.toString());

        // update the enablement of the paste action

        // workaround since the clipboard does not suppot callbacks

        if (pasteAction != null && pasteAction.getStructuredSelection() != null) {

			pasteAction.selectionChanged(pasteAction.getStructuredSelection());

		}

        return null;

    }

    /**

     * Set the clipboard contents. Prompt to retry if clipboard is busy.

     * 

     * @param resources the resources to copy to the clipboard

     * @param fileNames file names of the resources to copy to the clipboard

     * @param names string representation of all names

     */

    private void setClipboard(IResource[] resources, String[] fileNames,

            String names) {

        try {

            // set the clipboard contents

            if (fileNames.length > 0) {

                clipboard.setContents(new Object[] { resources, fileNames,

                        names },

                        new Transfer[] { ResourceTransfer.getInstance(),

                                FileTransfer.getInstance(),

                                TextTransfer.getInstance() });

            } else {

                clipboard.setContents(new Object[] { resources, names },

                        new Transfer[] { ResourceTransfer.getInstance(),

                                TextTransfer.getInstance() });

            }

        } catch (SWTError e) {

            if (e.code != DND.ERROR_CANNOT_SET_CLIPBOARD) {

				throw e;

			}

            if (MessageDialog

                    .openQuestion(

                            shell,

                            "Problem with copy title", // TODO ResourceNavigatorMessages.CopyToClipboardProblemDialog_title,  //$NON-NLS-1$

                            "Problem with copy.")) { //$NON-NLS-1$

				setClipboard(resources, fileNames, names);

			}

        }

    }

    /**

     * The <code>CopyAction</code> implementation of this

     * <code>SelectionListenerAction</code> method enables this action if 

     * one or more resources of compatible types are selected.

     */

    protected boolean updateSelection(IStructuredSelection selection) {

        if (!super.updateSelection(selection)) {

			return false;

		}

        if (getSelectedNonResources().size() > 0) {

			return false;

		}

        List selectedResources = getSelectedResources();

        if (selectedResources.size() == 0) {

			return false;

		}

        boolean projSelected = selectionIsOfType(IResource.PROJECT);

        boolean fileFoldersSelected = selectionIsOfType(IResource.FILE

                | IResource.FOLDER);

        if (!projSelected && !fileFoldersSelected) {

			return false;

		}

        // selection must be homogeneous

        if (projSelected && fileFoldersSelected) {

			return false;

		}

        // must have a common parent	

        IContainer firstParent = ((IResource) selectedResources.get(0))

                .getParent();

        if (firstParent == null) {

			return false;

		}

        Iterator resourcesEnum = selectedResources.iterator();

        while (resourcesEnum.hasNext()) {

            IResource currentResource = (IResource) resourcesEnum.next();

            if (!currentResource.getParent().equals(firstParent)) {

				return false;

			}

            // resource location must exist

            if (currentResource.getLocationURI() == null) {

				return false;

			}

        }

        return true;

    }

}

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

 * Copyright (c) 2000, 2008 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.ui.navigator.resources;

import java.util.List;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.eclipse.core.resources.IContainer;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.resources.IProject;

import org.eclipse.core.resources.IResource;

import org.eclipse.core.runtime.Assert;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.swt.dnd.Clipboard;

import org.eclipse.swt.dnd.FileTransfer;

import org.eclipse.swt.dnd.TransferData;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.actions.CopyFilesAndFoldersOperation;

import org.eclipse.ui.actions.CopyProjectOperation;

import org.eclipse.ui.actions.SelectionListenerAction;

import org.eclipse.ui.part.ResourceTransfer;

import org.eclipse.ui.internal.navigator.resources.plugin.WorkbenchNavigatorMessages;

/**

 * Standard action for pasting resources on the clipboard to the selected resource's location.

 * <p>

 * This class may be instantiated; it is not intended to be subclassed.

 * </p>

 * 

 * @since 3.5

 */

public class PasteHandler extends AbstractHandler {

    /**

     * The id of this action.

     */

    public static final String ID = PlatformUI.PLUGIN_ID + ".PasteAction";//$NON-NLS-1$

    /**

     * The shell in which to show any dialogs.

     */

    private Shell shell;

    /**

     * System clipboard

     */

    private Clipboard clipboard;

    /**

     * Creates a new action.

     *

     * @param shell the shell for any dialogs

     * @param clipboard the clipboard

     */

    public PasteHandler(Shell shell, Clipboard clipboard) {

        super(WorkbenchNavigatorMessages.PasteAction_Past_); 

        Assert.isNotNull(shell);

        Assert.isNotNull(clipboard);

        this.shell = shell;

        this.clipboard = clipboard;

        setToolTipText(WorkbenchNavigatorMessages.PasteAction_Paste_selected_resource_s_); 

        setId(PasteHandler.ID);

        PlatformUI.getWorkbench().getHelpSystem().setHelp(this, "HelpId"); //$NON-NLS-1$

				// TODO INavigatorHelpContextIds.PASTE_ACTION);

    }

    /**

     * Returns the actual target of the paste action. Returns null

     * if no valid target is selected.

     * 

     * @return the actual target of the paste action

     */

    private IResource getTarget() {

        List selectedResources = getSelectedResources();

        for (int i = 0; i < selectedResources.size(); i++) {

            IResource resource = (IResource) selectedResources.get(i);

            if (resource instanceof IProject && !((IProject) resource).isOpen()) {

				return null;

			}

            if (resource.getType() == IResource.FILE) {

				resource = resource.getParent();

			}

            if (resource != null) {

				return resource;

			}

        }

        return null;

    }

    /**

     * Returns whether any of the given resources are linked resources.

     * 

     * @param resources resource to check for linked type. may be null

     * @return true=one or more resources are linked. false=none of the 

     * 	resources are linked

     */

    private boolean isLinked(IResource[] resources) {

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

            if (resources[i].isLinked()) {

				return true;

			}

        }

        return false;

    }

	/* (non-Javadoc)

	 * @see org.eclipse.core.commands.IHandler#execute(org.eclipse.core.commands.ExecutionEvent)

	 */

	public Object execute(ExecutionEvent event) throws ExecutionException {

		// TODO Auto-generated method stub

		return null;

	}

	/**

     * Implementation of method defined on <code>IAction</code>.

     */

    public void run() {

        // try a resource transfer

        ResourceTransfer resTransfer = ResourceTransfer.getInstance();

        IResource[] resourceData = (IResource[]) clipboard

                .getContents(resTransfer);

        if (resourceData != null && resourceData.length > 0) {

            if (resourceData[0].getType() == IResource.PROJECT) {

                // enablement checks for all projects

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

                    CopyProjectOperation operation = new CopyProjectOperation(

                            this.shell);

                    operation.copyProject((IProject) resourceData[i]);

                }

            } else {

                // enablement should ensure that we always have access to a container

                IContainer container = getContainer();

                CopyFilesAndFoldersOperation operation = new CopyFilesAndFoldersOperation(

                        this.shell);

                operation.copyResources(resourceData, container);

            }

            return;

        }

        // try a file transfer

        FileTransfer fileTransfer = FileTransfer.getInstance();

        String[] fileData = (String[]) clipboard.getContents(fileTransfer);

        if (fileData != null) {

            // enablement should ensure that we always have access to a container

            IContainer container = getContainer();

            CopyFilesAndFoldersOperation operation = new CopyFilesAndFoldersOperation(

                    this.shell);

            operation.copyFiles(fileData, container);

        }

    }

    /**

     * Returns the container to hold the pasted resources.

     */

    private IContainer getContainer() {

        List selection = getSelectedResources();

        if (selection.get(0) instanceof IFile) {

			return ((IFile) selection.get(0)).getParent();

		}

        return (IContainer) selection.get(0);

    }

    /**

     * The <code>PasteAction</code> implementation of this

     * <code>SelectionListenerAction</code> method enables this action if 

     * a resource compatible with what is on the clipboard is selected.

     * 

     * -Clipboard must have IResource or java.io.File

     * -Projects can always be pasted if they are open

     * -Workspace folder may not be copied into itself

     * -Files and folders may be pasted to a single selected folder in open 

     * 	project or multiple selected files in the same folder 

     */

    protected boolean updateSelection(IStructuredSelection selection) {

        if (!super.updateSelection(selection)) {

			return false;

		}

        final IResource[][] clipboardData = new IResource[1][];

        shell.getDisplay().syncExec(new Runnable() {

            public void run() {

                // clipboard must have resources or files

                ResourceTransfer resTransfer = ResourceTransfer.getInstance();

                clipboardData[0] = (IResource[]) clipboard

                        .getContents(resTransfer);

            }

        });

        IResource[] resourceData = clipboardData[0];

        boolean isProjectRes = resourceData != null && resourceData.length > 0

                && resourceData[0].getType() == IResource.PROJECT;

        if (isProjectRes) {

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

                // make sure all resource data are open projects

                // can paste open projects regardless of selection

                if (resourceData[i].getType() != IResource.PROJECT

                        || ((IProject) resourceData[i]).isOpen() == false) {

					return false;

				}

            }

            return true;

        }

        if (getSelectedNonResources().size() > 0) {

			return false;

		}

        IResource targetResource = getTarget();

        // targetResource is null if no valid target is selected (e.g., open project) 

        // or selection is empty	

        if (targetResource == null) {

			return false;

		}

        // can paste files and folders to a single selection (file, folder, 

        // open project) or multiple file selection with the same parent

        List selectedResources = getSelectedResources();

        if (selectedResources.size() > 1) {

            for (int i = 0; i < selectedResources.size(); i++) {

                IResource resource = (IResource) selectedResources.get(i);

                if (resource.getType() != IResource.FILE) {

					return false;

				}

                if (!targetResource.equals(resource.getParent())) {

					return false;

				}

            }

        }

        if (resourceData != null) {

            // linked resources can only be pasted into projects

            if (isLinked(resourceData)

                && targetResource.getType() != IResource.PROJECT

                && targetResource.getType() != IResource.FOLDER) {

				return false;

			}

            if (targetResource.getType() == IResource.FOLDER) {

                // don't try to copy folder to self

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

                    if (targetResource.equals(resourceData[i])) {

						return false;

					}

                }

            }

            return true;

        }

        TransferData[] transfers = clipboard.getAvailableTypes();

        FileTransfer fileTransfer = FileTransfer.getInstance();

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

            if (fileTransfer.isSupportedType(transfers[i])) {

				return true;

			}

        }

        return false;

    }

}