/*******************************************************************************
 * Copyright (c) 2000, 2017 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
 *
 *******************************************************************************/
package org.eclipse.dltk.internal.ui.wizards.buildpath.newsourcepage;

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

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.dltk.core.DLTKCore;
import org.eclipse.dltk.core.IModelElement;
import org.eclipse.dltk.core.IProjectFragment;
import org.eclipse.dltk.core.IScriptFolder;
import org.eclipse.dltk.core.IScriptProject;
import org.eclipse.dltk.core.ISourceModule;
import org.eclipse.dltk.core.ModelException;
import org.eclipse.dltk.internal.corext.buildpath.AddSelectedSourceFolderOperation;
import org.eclipse.dltk.internal.corext.buildpath.BuildpathModifier;
import org.eclipse.dltk.internal.corext.buildpath.BuildpathModifier.IBuildpathModifierListener;
import org.eclipse.dltk.internal.corext.buildpath.BuildpathModifierOperation;
import org.eclipse.dltk.internal.corext.buildpath.CreateFolderOperation;
import org.eclipse.dltk.internal.corext.buildpath.EditFiltersOperation;
import org.eclipse.dltk.internal.corext.buildpath.ExcludeOperation;
import org.eclipse.dltk.internal.corext.buildpath.IBuildpathInformationProvider;
import org.eclipse.dltk.internal.corext.buildpath.IPackageExplorerActionListener;
import org.eclipse.dltk.internal.corext.buildpath.LinkedSourceFolderOperation;
import org.eclipse.dltk.internal.corext.buildpath.PackageExplorerActionEvent;
import org.eclipse.dltk.internal.corext.buildpath.RemoveFromBuildpathOperation;
import org.eclipse.dltk.internal.corext.buildpath.ResetAllOperation;
import org.eclipse.dltk.internal.corext.buildpath.UnexcludeOperation;
import org.eclipse.dltk.internal.ui.actions.CompositeActionGroup;
import org.eclipse.dltk.internal.ui.scriptview.BuildPathContainer;
import org.eclipse.dltk.internal.ui.util.ViewerPane;
import org.eclipse.dltk.internal.ui.wizards.NewWizardMessages;
import org.eclipse.dltk.ui.DLTKPluginImages;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.ToolBar;
import org.eclipse.ui.actions.ActionContext;

/**
 * Action group for the package explorer. Creates and manages a set of
 * <code>BuildpathModifierOperation</code>s and creates a
 * <code>ToolBarManager</code> on request. Based on this operations,
 * <code>BuildpathModifierAction</code>s are generated. The available operations
 * are:
 *
 * @see org.eclipse.dltk.internal.corext.buildpath.AddSelectedSourceFolderOperation
 * @see org.eclipse.dltk.internal.corext.buildpath.RemoveFromBuildpathOperation
 * @see org.eclipse.dltk.internal.corext.buildpath.IncludeOperation
 * @see org.eclipse.dltk.internal.corext.buildpath.UnincludeOperation
 * @see org.eclipse.dltk.internal.corext.buildpath.ExcludeOperation
 * @see org.eclipse.dltk.internal.corext.buildpath.UnexcludeOperation
 * @see org.eclipse.dltk.internal.corext.buildpath.EditFiltersOperation
 * @see org.eclipse.dltk.internal.corext.buildpath.ResetOperation
 */
public class DialogPackageExplorerActionGroup extends CompositeActionGroup {

	public static class DialogExplorerActionContext extends ActionContext {
		private IScriptProject fScriptProject;
		private List fSelectedElements;

		/**
		 * Constructor to create an action context for the dialog package
		 * explorer.
		 *
		 * For reasons of completeness, the selection of the super class
		 * <code>ActionContext</code> is also set, but is not intendet to be
		 * used.
		 *
		 * @param selection
		 *            the current selection
		 * @param jProject
		 *            the element's script project
		 */
		public DialogExplorerActionContext(ISelection selection,
				IScriptProject jProject) {
			super(null);
			fScriptProject = jProject;
			fSelectedElements = ((IStructuredSelection) selection).toList();
			IStructuredSelection structuredSelection = new StructuredSelection(
					new Object[] { fSelectedElements, jProject });
			super.setSelection(structuredSelection);
		}

		/**
		 * Constructor to create an action context for the dialog package
		 * explorer.
		 *
		 * For reasons of completeness, the selection of the super class
		 * <code>ActionContext</code> is also set, but is not intendet to be
		 * used.
		 *
		 * @param selectedElements
		 *            a list of currently selected elements
		 * @param jProject
		 *            the element's script project
		 */
		public DialogExplorerActionContext(List selectedElements,
				IScriptProject jProject) {
			super(null);
			fScriptProject = jProject;
			fSelectedElements = selectedElements;
			IStructuredSelection structuredSelection = new StructuredSelection(
					new Object[] { fSelectedElements, jProject });
			super.setSelection(structuredSelection);
		}

		public IScriptProject getScriptProject() {
			return fScriptProject;
		}

		public List getSelectedElements() {
			return fSelectedElements;
		}
	}

	/** script project */
	public static final int SCRIPT_PROJECT = 0x01;
	/** Package fragment root */
	public static final int PACKAGE_FRAGMENT_ROOT = 0x02;
	/** Package fragment */
	public static final int PACKAGE_FRAGMENT = 0x03;
	/** Compilation unit */
	public static final int SOURCE_MODULE = 0x04;
	/** File */
	public static final int FILE = 0x05;
	/** Normal folder */
	public static final int FOLDER = 0x06;
	/** Excluded folder */
	public static final int EXCLUDED_FOLDER = 0x07;
	/** Excluded file */
	public static final int EXCLUDED_FILE = 0x08;
	/** Included file */
	public static final int INCLUDED_FILE = 0xA;
	/** Included folder */
	public static final int INCLUDED_FOLDER = 0xB;
	/** An archive element */
	public static final int ARCHIVE = 0xD;
	/** A IProjectFragment with include/exclude filters set */
	public static final int MODIFIED_FRAGMENT_ROOT = 0xE;
	/** Default package fragment */
	public static final int DEFAULT_FRAGMENT = 0xF;
	/** Undefined type */
	public static final int UNDEFINED = 0x10;
	/** Multi selection */
	public static final int MULTI = 0x11;
	/** No elements selected */
	public static final int NULL_SELECTION = 0x12;
	/** Elements that are contained in an archive */
	public static final int ARCHIVE_RESOURCE = 0x13;

	public static final int EXTERNAL_RESOURCE = 0x15;
	/** Elements that represent Buildpath container (= libraries) */
	public static final int CONTAINER = 0x14;

	private BuildpathModifierAction[] fActions;
	private int fLastType;
	private List fListeners;
	private static final int fContextSensitiveActions = 5;

	/**
	 * Constructor which creates the operations and based on this operations the
	 * actions.
	 *
	 * @param provider
	 *            a information provider to pass necessary information to the
	 *            operations
	 * @param listener
	 *            a listener for the changes on Buildpath entries, that is the
	 *            listener will be notified whenever a Buildpath entry changed.
	 * @see IBuildpathModifierListener
	 */
	public DialogPackageExplorerActionGroup(
			IBuildpathInformationProvider provider,
			IBuildpathModifierListener listener) {
		super();
		fLastType = UNDEFINED;
		fListeners = new ArrayList();
		fActions = new BuildpathModifierAction[8];
		BuildpathModifierOperation op;
		op = new AddSelectedSourceFolderOperation(listener, provider);
		// TODO User disabled image when available
		addAction(new BuildpathModifierAction(op,
				DLTKPluginImages.DESC_ELCL_ADD_AS_SOURCE_FOLDER, null,
				NewWizardMessages.NewSourceContainerWorkbookPage_ToolBar_AddSelSFToCP_label,
				NewWizardMessages.NewSourceContainerWorkbookPage_ToolBar_AddSelSFToCP_tooltip,
				IAction.AS_PUSH_BUTTON), 0);
		op = new RemoveFromBuildpathOperation(listener, provider);
		addAction(new BuildpathModifierAction(op,
				DLTKPluginImages.DESC_ELCL_REMOVE_AS_SOURCE_FOLDER,
				DLTKPluginImages.DESC_DLCL_REMOVE_AS_SOURCE_FOLDER,
				NewWizardMessages.NewSourceContainerWorkbookPage_ToolBar_RemoveFromCP_label,
				NewWizardMessages.NewSourceContainerWorkbookPage_ToolBar_RemoveFromCP_tooltip,
				IAction.AS_PUSH_BUTTON), 1);
		op = new ExcludeOperation(listener, provider);
		addAction(new BuildpathModifierAction(op,
				DLTKPluginImages.DESC_ELCL_EXCLUDE_FROM_BUILDPATH,
				DLTKPluginImages.DESC_DLCL_EXCLUDE_FROM_BUILDPATH,
				NewWizardMessages.NewSourceContainerWorkbookPage_ToolBar_Exclude_label,
				NewWizardMessages.NewSourceContainerWorkbookPage_ToolBar_Exclude_tooltip,
				IAction.AS_PUSH_BUTTON), 2);
		op = new UnexcludeOperation(listener, provider);
		addAction(new BuildpathModifierAction(op,
				DLTKPluginImages.DESC_ELCL_INCLUDE_ON_BUILDPATH,
				DLTKPluginImages.DESC_DLCL_INCLUDE_ON_BUILDPATH,
				NewWizardMessages.NewSourceContainerWorkbookPage_ToolBar_Unexclude_label,
				NewWizardMessages.NewSourceContainerWorkbookPage_ToolBar_Unexclude_tooltip,
				IAction.AS_PUSH_BUTTON), 3);
		op = new EditFiltersOperation(listener, provider);
		BuildpathModifierAction action = new BuildpathModifierAction(op,
				DLTKPluginImages.DESC_ELCL_CONFIGURE_BUILDPATH_FILTERS,
				DLTKPluginImages.DESC_DLCL_CONFIGURE_BUILDPATH_FILTERS,
				NewWizardMessages.NewSourceContainerWorkbookPage_ToolBar_Edit_label,
				NewWizardMessages.NewSourceContainerWorkbookPage_ToolBar_Edit_tooltip,
				IAction.AS_PUSH_BUTTON);
		BuildpathModifierDropDownAction dropDown = new BuildpathModifierDropDownAction(
				action,
				NewWizardMessages.NewSourceContainerWorkbookPage_ToolBar_Configure_label,
				NewWizardMessages.NewSourceContainerWorkbookPage_ToolBar_Configure_tooltip);
		addAction(dropDown, 4);

		/*
		 * addAction(new BuildpathModifierAction(op,
		 * DLTKPluginImages.DESC_OBJS_TEXT_EDIT,
		 * DLTKPluginImages.DESC_DLCL_TEXT_EDIT, NewWizardMessages.getString(
		 * "NewSourceContainerWorkbookPage.ToolBar.Edit.label"), //$NON-NLS-1$
		 * NewWizardMessages.getString(
		 * "NewSourceContainerWorkbookPage.ToolBar.Edit.tooltip"),
		 * IAction.AS_PUSH_BUTTON), //$NON-NLS-1$
		 * IBuildpathInformationProvider.EDIT);
		 */
		op = new LinkedSourceFolderOperation(listener, provider);
		addAction(new BuildpathModifierAction(op,
				DLTKPluginImages.DESC_ELCL_ADD_LINKED_SOURCE_TO_BUILDPATH,
				DLTKPluginImages.DESC_DLCL_ADD_LINKED_SOURCE_TO_BUILDPATH,
				NewWizardMessages.NewSourceContainerWorkbookPage_ToolBar_Link_label,
				NewWizardMessages.NewSourceContainerWorkbookPage_ToolBar_Link_tooltip,
				IAction.AS_PUSH_BUTTON), 5);
		op = new CreateFolderOperation(listener, provider);
		addAction(new BuildpathModifierAction(op,
				DLTKPluginImages.DESC_OBJS_PACKFRAG_ROOT, null,
				NewWizardMessages.NewSourceContainerWorkbookPage_ToolBar_CreateSrcFolder_label,
				NewWizardMessages.NewSourceContainerWorkbookPage_ToolBar_CreateSrcFolder_tooltip,
				IAction.AS_PUSH_BUTTON), 6);
		op = new ResetAllOperation(listener, provider);
		addAction(new BuildpathModifierAction(op,
				DLTKPluginImages.DESC_ELCL_CLEAR,
				DLTKPluginImages.DESC_DLCL_CLEAR,
				NewWizardMessages.NewSourceContainerWorkbookPage_ToolBar_ClearAll_label,
				NewWizardMessages.NewSourceContainerWorkbookPage_ToolBar_ClearAll_tooltip,
				IAction.AS_PUSH_BUTTON), 7);
	}

	private void addAction(BuildpathModifierAction action, int index) {
		fActions[index] = action;
	}

	/**
	 * Get an action of the specified type
	 *
	 * @param type
	 *            the type of the desired action, must be a constante of
	 *            <code>IBuildpathInformationProvider</code>
	 * @return the requested action
	 *
	 * @see IBuildpathInformationProvider
	 */
	public BuildpathModifierAction getAction(int type) {
		for (int i = 0; i < fActions.length; i++) {
			if (fActions[i].getOperation().getTypeId() == type)
				return fActions[i];
		}
		throw new ArrayIndexOutOfBoundsException();
	}

	public BuildpathModifierAction[] getActions() {
		List<BuildpathModifierAction> result = new ArrayList<BuildpathModifierAction>();
		for (int i = 0; i < fActions.length; i++) {
			BuildpathModifierAction action = fActions[i];
			if (action instanceof BuildpathModifierDropDownAction) {
				BuildpathModifierDropDownAction dropDownAction = (BuildpathModifierDropDownAction) action;
				BuildpathModifierAction[] actions = dropDownAction.getActions();
				for (int j = 0; j < actions.length; j++) {
					result.add(actions[j]);
				}
			} else {
				result.add(action);
			}
		}
		return result.toArray(new BuildpathModifierAction[result.size()]);
	}

	/**
	 * Create a toolbar manager for a given <code>ViewerPane</code>
	 *
	 * @param pane
	 *            the pane to create the <code>
	 * ToolBarManager</code> for.
	 * @return the created <code>ToolBarManager</code>
	 */
	public ToolBarManager createLeftToolBarManager(ViewerPane pane) {
		ToolBarManager tbm = pane.getToolBarManager();
		for (int i = 0; i < fContextSensitiveActions; i++) {
			tbm.add(fActions[i]);
			if (i == 1 || i == 3)
				tbm.add(new Separator());
		}
		tbm.update(true);
		return tbm;
	}

	/**
	 * Create a toolbar manager for a given <code>ViewerPane</code>
	 *
	 * @param pane
	 *            the pane to create the help toolbar for
	 * @return the created <code>ToolBarManager</code>
	 */
	public ToolBarManager createLeftToolBar(ViewerPane pane) {
		ToolBar tb = new ToolBar(pane, SWT.FLAT);
		pane.setTopRight(tb);
		ToolBarManager tbm = new ToolBarManager(tb);
		for (int i = fContextSensitiveActions; i < fActions.length; i++) {
			tbm.add(fActions[i]);
		}
		if (DLTKCore.DEBUG) {
			System.err.println("Add help support here..."); //$NON-NLS-1$
		}
		// tbm.add(new HelpAction());
		tbm.update(true);
		return tbm;
	}

	/**
	 * Forces the action group to recompute the available actions and fire an
	 * event to all listeners
	 * 
	 * @throws ModelException
	 *
	 * @see #setContext(DialogExplorerActionContext)
	 * @see #informListeners(String[], BuildpathModifierAction[])
	 */
	public void refresh(DialogExplorerActionContext context)
			throws ModelException {
		super.setContext(context);
		if (context == null) // can happen when disposing
			return;
		List selectedElements = context.getSelectedElements();
		IScriptProject project = context.getScriptProject();

		int type = MULTI;
		if (selectedElements.size() == 0) {
			type = NULL_SELECTION;

			if (type == fLastType)
				return;
		} else if (selectedElements.size() == 1
				|| identicalTypes(selectedElements, project)) {
			type = getType(selectedElements.get(0), project);
		}

		internalSetContext(selectedElements, project, type);
	}

	/**
	 * Set the context for the action group. This also includes updating the
	 * actions (that is, enable or disable them). The decision which actions
	 * should be enabled or disabled is based on the content of the
	 * <code>DialogExplorerActionContext</code>
	 *
	 * If the type of the selection changes, then listeners will be notified
	 * about the new set of available actions.
	 *
	 * Note: notification is only done if the TYPE changes (not the selected
	 * object as such). This means that if elements of the same type are
	 * selected (for example two times a folder), NO notification will take
	 * place. There might be situations where the type of two objects is the
	 * same but the set of available actions is not. However, if clients decide
	 * that upon some action a recomputation of the available actions has to be
	 * forced, then
	 * <code>PackageExplorerActionGroup.refresh(DialogExplorerActionContext)</code>
	 * can be called.
	 *
	 * @param context
	 *            the action context
	 *
	 * @see IPackageExplorerActionListener
	 * @see PackageExplorerActionEvent
	 * @see DialogExplorerActionContext
	 * @see #addListener(IPackageExplorerActionListener)
	 * @see #refresh(DialogExplorerActionContext)
	 *
	 * @throws ModelException
	 *             if there is a failure while computing the available actions.
	 */
	public void setContext(DialogExplorerActionContext context)
			throws ModelException {
		super.setContext(context);
		if (context == null) // can happen when disposing
			return;
		List selectedElements = context.getSelectedElements();
		IScriptProject project = context.getScriptProject();

		int type = MULTI;
		if (selectedElements.size() == 0) {
			type = NULL_SELECTION;

			if (type == fLastType)
				return;
		} else if (selectedElements.size() == 1
				|| identicalTypes(selectedElements, project)) {
			type = getType(selectedElements.get(0), project);

			if (selectedElements.size() > 1)
				type = type | MULTI;

			if (type == fLastType)
				return;
		}

		internalSetContext(selectedElements, project, type);
	}

	/**
	 * Get a description for the last selection explaining why no operation is
	 * possible.
	 * <p>
	 * This can be usefull if a context sensitive widget does not want to
	 * display all operations although some of them are valid.
	 *
	 * @return a description for the last selection that explains why no
	 *         operation is available.
	 */
	public String getNoActionDescription() {
		String[] description = noAction(fLastType);
		return description[0];
	}

	/**
	 * Internal method to set the context of the action group.
	 *
	 * @param selectedElements
	 *            a list of selected elements, can be empty
	 * @param project
	 *            the script project
	 * @param type
	 *            the type of the selected element(s)
	 * @throws ModelException
	 */
	private void internalSetContext(List selectedElements,
			IScriptProject project, int type) throws ModelException {
		fLastType = type;
		List availableActions = getAvailableActions(selectedElements, project);
		BuildpathModifierAction[] actions = new BuildpathModifierAction[availableActions
				.size()];
		String[] descriptions = new String[availableActions.size()];
		if (availableActions.size() > 0) {
			for (int i = 0; i < availableActions.size(); i++) {
				BuildpathModifierAction action = (BuildpathModifierAction) availableActions
						.get(i);
				actions[i] = action;
				descriptions[i] = action.getDescription(type);
			}
		} else
			descriptions = noAction(type);

		informListeners(descriptions, actions);
	}

	/**
	 * Finds out wheter the list of elements consists only of elements having
	 * the same type (for example all are of type
	 * DialogPackageExplorerActionGroup.COMPILATION_UNIT). This allows to use a
	 * description for the available actions which is more specific and
	 * therefore provides more information.
	 *
	 * @param elements
	 *            a list of elements to be compared to each other
	 * @param project
	 *            the script project
	 * @return <code>true</code> if all elements are of the same type,
	 *         <code>false</code> otherwise.
	 * @throws ModelException
	 */
	private boolean identicalTypes(List elements, IScriptProject project)
			throws ModelException {
		if (elements.size() == 0) {
			return false;
		}

		Object firstElement = elements.get(0);
		int firstType = getType(firstElement, project);
		for (int i = 1; i < elements.size(); i++) {
			if (firstType != getType(elements.get(i), project))
				return false;
		}
		return true;
	}

	/**
	 * Inform all listeners about new actions.
	 *
	 * @param descriptions
	 *            an array of descriptions for each actions, where the
	 *            description at position 'i' belongs to the action at position
	 *            'i'
	 * @param actions
	 *            an array of available actions
	 */
	private void informListeners(String[] descriptions,
			BuildpathModifierAction[] actions) {
		Iterator iterator = fListeners.iterator();
		PackageExplorerActionEvent event = new PackageExplorerActionEvent(
				descriptions, actions);
		while (iterator.hasNext()) {
			IPackageExplorerActionListener listener = (IPackageExplorerActionListener) iterator
					.next();
			listener.handlePackageExplorerActionEvent(event);
		}
	}

	/**
	 * Returns string array with only one element which contains a short reason
	 * to indicate why there are no actions available.
	 *
	 * @return a description to explain why there are no actions available
	 */
	private String[] noAction(int type) {
		String reason;
		switch (type) {
		case FILE:
			reason = NewWizardMessages.PackageExplorerActionGroup_NoAction_File;
			break;
		case FILE | MULTI:
			reason = NewWizardMessages.PackageExplorerActionGroup_NoAction_File;
			break;
		case DEFAULT_FRAGMENT:
			reason = NewWizardMessages.PackageExplorerActionGroup_NoAction_DefaultPackage;
			break;
		case DEFAULT_FRAGMENT | MULTI:
			reason = NewWizardMessages.PackageExplorerActionGroup_NoAction_DefaultPackage;
			break;
		case NULL_SELECTION:
			reason = NewWizardMessages.PackageExplorerActionGroup_NoAction_NullSelection;
			break;
		case MULTI:
			reason = NewWizardMessages.PackageExplorerActionGroup_NoAction_MultiSelection;
			break;
		case ARCHIVE_RESOURCE:
			reason = NewWizardMessages.PackageExplorerActionGroup_NoAction_ArchiveResource;
			break;
		default:
			reason = NewWizardMessages.PackageExplorerActionGroup_NoAction_NoReason;
		}
		return new String[] { reason };
	}

	/**
	 * Computes the type based on the current selection. The type can be usefull
	 * to set the content of the hint text group properly.
	 *
	 * @param obj
	 *            the object to get the type from
	 * @return the type of the current selection or UNDEFINED if no appropriate
	 *         type could be found. Possible types are:<br>
	 *         PackageExplorerActionGroup.FOLDER<br>
	 *         PackageExplorerActionGroup.EXCLUDED_FOLDER;<br>
	 *         PackageExplorerActionGroup.EXCLUDED_FILE<br>
	 *         PackageExplorerActionGroup.DEFAULT_OUTPUT<br>
	 *         PackageExplorerActionGroup.INCLUDED_FILE<br>
	 *         PackageExplorerActionGroup.INCLUDED_FOLDER<br>
	 *         PackageExplorerActionGroup.OUTPUT<br>
	 *         PackageExplorerActionGroup.MODIFIED_FRAGMENT_ROOT<br>
	 *         PackageExplorerActionGroup.DEFAULT_FRAGMENT<br>
	 *         PackageExplorerActionGroup.JAVA_PROJECT<br>
	 *         PackageExplorerActionGroup.PACKAGE_FRAGMENT_ROOT<br>
	 *         PackageExplorerActionGroup.PACKAGE_FRAGMENT<br>
	 *         PackageExplorerActionGroup.COMPILATION_UNIT<br>
	 *         PackageExplorerActionGroup.FILE<br>
	 * @throws ModelException
	 */
	public static int getType(Object obj, IScriptProject project)
			throws ModelException {
		if (obj instanceof IScriptProject)
			return SCRIPT_PROJECT;
		if (obj instanceof BuildPathContainer)
			return CONTAINER;
		if (obj instanceof IProjectFragment)
			return BuildpathModifier.filtersSet((IProjectFragment) obj)
					? MODIFIED_FRAGMENT_ROOT
					: PACKAGE_FRAGMENT_ROOT;
		if (obj instanceof IScriptFolder) {
			if (BuildpathModifier.isDefaultFragment((IScriptFolder) obj)) {
				if (((IProjectFragment) ((IModelElement) obj)
						.getAncestor(IModelElement.PROJECT_FRAGMENT))
								.isArchive())
					return ARCHIVE_RESOURCE;
				return DEFAULT_FRAGMENT;
			}
			if (BuildpathModifier.isIncluded((IModelElement) obj, project,
					null))
				return INCLUDED_FOLDER;
			if (((IProjectFragment) ((IModelElement) obj)
					.getAncestor(IModelElement.PROJECT_FRAGMENT)).isArchive())
				return ARCHIVE_RESOURCE;
			if (((IProjectFragment) ((IModelElement) obj)
					.getAncestor(IModelElement.PROJECT_FRAGMENT)).isExternal())
				return EXTERNAL_RESOURCE;
			return PACKAGE_FRAGMENT;
		}
		if (obj instanceof ISourceModule) {
			if (((IProjectFragment) ((IModelElement) obj)
					.getAncestor(IModelElement.PROJECT_FRAGMENT)).isArchive()) {
				return ARCHIVE_RESOURCE;
			}
			if (((IProjectFragment) ((IModelElement) obj)
					.getAncestor(IModelElement.PROJECT_FRAGMENT))
							.isExternal()) {
				return EXTERNAL_RESOURCE;
			}
			return BuildpathModifier.isIncluded((IModelElement) obj, project,
					null) ? INCLUDED_FILE : SOURCE_MODULE;
		}
		if (obj instanceof IFolder) {
			return getFolderType((IFolder) obj, project);
		}
		if (obj instanceof IFile)
			return getFileType((IFile) obj, project);
		return UNDEFINED;
	}

	/**
	 * Get the type of the folder
	 *
	 * @param folder
	 *            folder to get the type from
	 * @return the type code for the folder. Possible types are:<br>
	 *         PackageExplorerActionGroup.FOLDER<br>
	 *         PackageExplorerActionGroup.EXCLUDED_FOLDER;<br>
	 * @throws ModelException
	 */
	private static int getFolderType(IFolder folder, IScriptProject project)
			throws ModelException {
		IContainer folderParent = folder.getParent();
		if (folderParent.getFullPath().equals(project.getPath()))
			return FOLDER;
		if (BuildpathModifier.getFragment(folderParent) != null)
			return EXCLUDED_FOLDER;
		IProjectFragment fragmentRoot = BuildpathModifier
				.getFragmentRoot(folder, project, null);
		if (fragmentRoot == null)
			return FOLDER;
		if (fragmentRoot.equals(DLTKCore.create(folderParent)))
			return EXCLUDED_FOLDER;
		return FOLDER;
	}

	/**
	 * Get the type of the file
	 *
	 * @param file
	 *            file to get the type from
	 * @return the type code for the file. Possible types are:<br>
	 *         PackageExplorerActionGroup.EXCLUDED_FILE<br>
	 *         PackageExplorerActionGroup.FILE
	 * @throws ModelException
	 */
	private static int getFileType(IFile file, IScriptProject project)
			throws ModelException {
		if (BuildpathModifier.isArchive(file, project))
			return ARCHIVE;
		if (DLTKCore.DEBUG) {
			System.err.println(
					"DialogPackageExplorerActionGroup:: Add some filters here"); //$NON-NLS-1$
		}
		// if (!DLTKCore.isScriptLikeFileName(file.getName()))
		// return FILE;
		IContainer fileParent = file.getParent();
		if (fileParent.getFullPath().equals(project.getPath())) {
			if (project.isOnBuildpath(project))
				return EXCLUDED_FILE;
			return FILE;
		}
		IProjectFragment fragmentRoot = BuildpathModifier.getFragmentRoot(file,
				project, null);
		if (fragmentRoot == null)
			return FILE;
		if (fragmentRoot.isArchive())
			return ARCHIVE_RESOURCE;
		if (fragmentRoot.equals(DLTKCore.create(fileParent)))
			return EXCLUDED_FILE;
		if (BuildpathModifier.getFragment(fileParent) == null) {
			if (BuildpathModifier.parentExcluded(fileParent, project))
				return FILE;
			return EXCLUDED_FILE;
		}
		return EXCLUDED_FILE;
	}

	/**
	 * Based on the given list of elements, get the list of available actions
	 * that can be applied on this elements
	 *
	 * @param selectedElements
	 *            the list of elements to get the actions for
	 * @param project
	 *            the script project
	 * @return a list of <code>BuildpathModifierAction</code>s
	 * @throws ModelException
	 */
	private List getAvailableActions(List selectedElements,
			IScriptProject project) throws ModelException {
		if (project == null || !project.exists()) {
			return new ArrayList();
		}

		List actions = new ArrayList();
		int[] types = new int[selectedElements.size()];
		for (int i = 0; i < types.length; i++) {
			types[i] = getType(selectedElements.get(i), project);
		}
		for (int i = 0; i < fActions.length; i++) {
			if (fActions[i] instanceof BuildpathModifierDropDownAction) {
				if (changeEnableState(fActions[i], selectedElements, types)) {
					BuildpathModifierAction[] dropDownActions = ((BuildpathModifierDropDownAction) fActions[i])
							.getActions();
					for (int j = 0; j < dropDownActions.length; j++) {
						if (changeEnableState(dropDownActions[j],
								selectedElements, types))
							actions.add(dropDownActions[j]);
					}
				}
			} else if (changeEnableState(fActions[i], selectedElements,
					types)) {
				actions.add(fActions[i]);
			}
		}
		return actions;
	}

	/**
	 * Changes the enabled state of an action if necessary.
	 *
	 * @param action
	 *            the action to change it's state for
	 * @param selectedElements
	 *            a list of selected elements
	 * @param types
	 *            an array of types corresponding to the types of the selected
	 *            elements
	 * @return <code>true</code> if the action is valid (= enabled),
	 *         <code>false</code> otherwise
	 * @throws ModelException
	 */
	private boolean changeEnableState(BuildpathModifierAction action,
			List selectedElements, int[] types) throws ModelException {
		if (action.isValid(selectedElements, types)) {
			if (!action.isEnabled())
				action.setEnabled(true);
			return true;
		} else {
			if (action.isEnabled())
				action.setEnabled(false);
			return false;
		}
	}

	/**
	 * Fill the context menu with the available actions
	 *
	 * @param menu
	 *            the menu to be filled up with actions
	 */
	@Override
	public void fillContextMenu(IMenuManager menu) {
		for (int i = 0; i < fContextSensitiveActions; i++) {
			IAction action = getAction(i);
			if (action instanceof BuildpathModifierDropDownAction) {
				if (action.isEnabled()) {
					IAction[] actions = ((BuildpathModifierDropDownAction) action)
							.getActions();
					for (int j = 0; j < actions.length; j++) {
						if (actions[j].isEnabled())
							menu.add(actions[j]);
					}
				}
			} else if (action.isEnabled())
				menu.add(action);
		}
		super.fillContextMenu(menu);
	}

	/**
	 * Add listeners for the <code>PackageExplorerActionEvent</code>.
	 *
	 * @param listener
	 *            the listener to be added
	 *
	 * @see PackageExplorerActionEvent
	 * @see IPackageExplorerActionListener
	 */
	public void addListener(IPackageExplorerActionListener listener) {
		fListeners.add(listener);
	}

	/**
	 * Remove the listener from the list of registered listeners.
	 *
	 * @param listener
	 *            the listener to be removed
	 */
	public void removeListener(IPackageExplorerActionListener listener) {
		fListeners.remove(listener);
	}

	@Override
	public void dispose() {
		fListeners.clear();
		super.dispose();
	}
}