bundles/org.eclipse.wst.jsdt.ui/src/org/eclipse/wst/jsdt/ui/actions/RefactorActionGroup.java

/*******************************************************************************
 * Copyright (c) 2000, 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v2.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.wst.jsdt.ui.actions;

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

import org.eclipse.core.commands.operations.IUndoContext;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.PerformanceStats;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.commands.ActionHandler;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.swt.events.MenuAdapter;
import org.eclipse.swt.events.MenuEvent;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IWorkbenchSite;
import org.eclipse.ui.actions.ActionFactory;
import org.eclipse.ui.actions.ActionGroup;
import org.eclipse.ui.handlers.IHandlerActivation;
import org.eclipse.ui.handlers.IHandlerService;
import org.eclipse.ui.operations.UndoRedoActionGroup;
import org.eclipse.ui.part.Page;
import org.eclipse.wst.jsdt.core.IJavaScriptElement;
import org.eclipse.wst.jsdt.internal.ui.IUIConstants;
import org.eclipse.wst.jsdt.internal.ui.JavaScriptPlugin;
import org.eclipse.wst.jsdt.internal.ui.actions.ActionMessages;
import org.eclipse.wst.jsdt.internal.ui.actions.ActionUtil;
import org.eclipse.wst.jsdt.internal.ui.actions.ExtractSuperClassAction;
import org.eclipse.wst.jsdt.internal.ui.actions.JDTQuickMenuAction;
import org.eclipse.wst.jsdt.internal.ui.actions.SelectionConverter;
import org.eclipse.wst.jsdt.internal.ui.javaeditor.IClassFileEditorInput;
import org.eclipse.wst.jsdt.internal.ui.javaeditor.JavaEditor;
import org.eclipse.wst.jsdt.internal.ui.javaeditor.JavaTextSelection;
import org.eclipse.wst.jsdt.internal.ui.refactoring.RefactoringMessages;
import org.eclipse.wst.jsdt.ui.IContextMenuConstants;

/**
 * Action group that adds refactor actions (for example 'Rename', 'Move')
 * to a context menu and the global menu bar.
 * 
 * <p>
 * This class may be instantiated; it is not intended to be subclassed.
 * </p>
 * 
 *
 * Provisional API: This class/interface is part of an interim API that is still under development and expected to
 * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
 * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
 * (repeatedly) as the API evolves.
 */
public class RefactorActionGroup extends ActionGroup {
	
	private static final String PERF_REFACTOR_ACTION_GROUP= "org.eclipse.wst.jsdt.ui/perf/explorer/RefactorActionGroup"; //$NON-NLS-1$

	/**
	 * Pop-up menu: id of the refactor sub menu (value <code>org.eclipse.wst.jsdt.ui.refactoring.menu</code>).
	 * 
	 * 
	 */
	public static final String MENU_ID= "org.eclipse.wst.jsdt.ui.refactoring.menu"; //$NON-NLS-1$

	/**
	 * Pop-up menu: id of the reorg group of the refactor sub menu (value
	 * <code>reorgGroup</code>).
	 * 
	 * 
	 */
	public static final String GROUP_REORG= "reorgGroup"; //$NON-NLS-1$

	/**
	 * Pop-up menu: id of the type group of the refactor sub menu (value
	 * <code>typeGroup</code>).
	 * 
	 * 
	 */
	public static final String GROUP_TYPE= "typeGroup"; //$NON-NLS-1$

	/**
	 * Pop-up menu: id of the coding group of the refactor sub menu (value
	 * <code>codingGroup</code>).
	 * 
	 * 
	 */
	public static final String GROUP_CODING= "codingGroup"; //$NON-NLS-1$
	
	/**
	 * Pop-up menu: id of the coding group 2 of the refactor sub menu (value
	 * <code>codingGroup2</code>).
	 * 
	 * 
	 */
	public static final String GROUP_CODING2= "codingGroup2"; //$NON-NLS-1$

	/**
	 * Pop-up menu: id of the reorg group 2 of the refactor sub menu (value
	 * <code>reorgGroup2</code>).
	 * 
	 * 
	 */
	private static final String GROUP_REORG2= "reorgGroup2"; //$NON-NLS-1$ //TODO(3.3): make public
	
	/**
	 * Pop-up menu: id of the type group 2 of the refactor sub menu (value
	 * <code>typeGroup2</code>).
	 * 
	 * 
	 */
	private static final String GROUP_TYPE2= "typeGroup2"; //$NON-NLS-1$ //TODO(3.3): make public
	
	private IWorkbenchSite fSite;
	private JavaEditor fEditor;
	private String fGroupName= IContextMenuConstants.GROUP_REORGANIZE;
	private boolean fBinary= false;

 	private SelectionDispatchAction fMoveAction;
	private SelectionDispatchAction fRenameAction;
	private SelectionDispatchAction fModifyParametersAction;
//	private SelectionDispatchAction fConvertAnonymousToNestedAction;
//	private SelectionDispatchAction fConvertNestedToTopAction;
	
	private SelectionDispatchAction fPullUpAction;
	private SelectionDispatchAction fPushDownAction;
//	private SelectionDispatchAction fExtractInterfaceAction;
	private SelectionDispatchAction fExtractSupertypeAction;
//	private SelectionDispatchAction fChangeTypeAction;
	private SelectionDispatchAction fUseSupertypeAction;
	
	private SelectionDispatchAction fInlineAction;
//	private SelectionDispatchAction fReplaceInvocationsAction;
	private SelectionDispatchAction fIntroduceIndirectionAction;
	private SelectionDispatchAction fExtractMethodAction;
	private SelectionDispatchAction fExtractTempAction;
	private SelectionDispatchAction fExtractConstantAction;
	private SelectionDispatchAction fIntroduceParameterAction;
	private SelectionDispatchAction fIntroduceFactoryAction;
	private SelectionDispatchAction fConvertLocalToFieldAction;
	private SelectionDispatchAction fSelfEncapsulateField;
	
	private UndoRedoActionGroup fUndoRedoActionGroup;
	
	private final List fActions= new ArrayList();
	
	private static final String QUICK_MENU_ID= "org.eclipse.wst.jsdt.ui.edit.text.java.refactor.quickMenu"; //$NON-NLS-1$
	
	private class RefactorQuickAccessAction extends JDTQuickMenuAction {
		public RefactorQuickAccessAction(JavaEditor editor) {
			super(editor, QUICK_MENU_ID); 
		}
		protected void fillMenu(IMenuManager menu) {
			fillQuickMenu(menu);
		}
	}
	
	private JDTQuickMenuAction fQuickAccessAction;
	private IHandlerActivation fQuickAccessHandlerActivation;
	private IHandlerService fHandlerService;

	private static class NoActionAvailable extends Action {
		public NoActionAvailable() {
			setEnabled(true);
			setText(RefactoringMessages.RefactorActionGroup_no_refactoring_available); 
		}
	}
	private Action fNoActionAvailable= new NoActionAvailable(); 
		
	/**
	 * Creates a new <code>RefactorActionGroup</code>. The group requires
	 * that the selection provided by the part's selection provider is of type <code>
	 * org.eclipse.jface.viewers.IStructuredSelection</code>.
	 * 
	 * @param part the view part that owns this action group
	 */
	public RefactorActionGroup(IViewPart part) {
		this(part.getSite());
		
		IUndoContext workspaceContext= (IUndoContext)ResourcesPlugin.getWorkspace().getAdapter(IUndoContext.class);
		fUndoRedoActionGroup= new UndoRedoActionGroup(part.getViewSite(), workspaceContext, true);
	}	
	
	/**
	 * Creates a new <code>RefactorActionGroup</code>. The action requires
	 * that the selection provided by the page's selection provider is of type <code>
	 * org.eclipse.jface.viewers.IStructuredSelection</code>.
	 * 
	 * @param page the page that owns this action group
	 */
	public RefactorActionGroup(Page page) {
		this(page.getSite());
	}
	
	/**
	 * Note: This constructor is for internal use only. Clients should not call this constructor.
	 * @param editor the JavaScript editor
	 * @param groupName the group name to add the actions to
	 * @param binary <code>true</code> if the action group is used in a binary environment, <code>false</code> otherwise
	 */
	public RefactorActionGroup(JavaEditor editor, String groupName, boolean binary) {

		final PerformanceStats stats= PerformanceStats.getStats(PERF_REFACTOR_ACTION_GROUP, this);
		stats.startRun();

		fSite= editor.getEditorSite();
		fEditor= editor;
		fGroupName= groupName;
		fBinary= binary;

		ISelectionProvider provider= editor.getSelectionProvider();
		ISelection selection= provider.getSelection();
		
		if (!fBinary) {
			fRenameAction= new RenameAction(editor);
			initAction(fRenameAction, selection, IJavaEditorActionDefinitionIds.RENAME_ELEMENT);
			editor.setAction("RenameElement", fRenameAction); //$NON-NLS-1$
			
			fMoveAction= new MoveAction(editor);
			initAction(fMoveAction, selection, IJavaEditorActionDefinitionIds.MOVE_ELEMENT);
			editor.setAction("MoveElement", fMoveAction); //$NON-NLS-1$
			
			fModifyParametersAction= new ModifyParametersAction(editor);
			initAction(fModifyParametersAction, selection, IJavaEditorActionDefinitionIds.MODIFY_METHOD_PARAMETERS);
			editor.setAction("ModifyParameters", fModifyParametersAction); //$NON-NLS-1$
	
//			fConvertAnonymousToNestedAction= new ConvertAnonymousToNestedAction(editor);
//			initUpdatingAction(fConvertAnonymousToNestedAction, provider, selection, IJavaEditorActionDefinitionIds.CONVERT_ANONYMOUS_TO_NESTED);
//			editor.setAction("ConvertAnonymousToNested", fConvertAnonymousToNestedAction); //$NON-NLS-1$
//	
//			fConvertNestedToTopAction= new ConvertNestedToTopAction(editor);
//			initAction(fConvertNestedToTopAction, selection, IJavaEditorActionDefinitionIds.MOVE_INNER_TO_TOP);
//			editor.setAction("MoveInnerToTop", fConvertNestedToTopAction); //$NON-NLS-1$

			if (IUIConstants.SUPPORT_REFACTORING)
			{
				fPullUpAction= new PullUpAction(editor);
				initAction(fPullUpAction, selection, IJavaEditorActionDefinitionIds.PULL_UP);
				editor.setAction("PullUp", fPullUpAction); //$NON-NLS-1$
	
				fPushDownAction= new PushDownAction(editor);
				initAction(fPushDownAction, selection, IJavaEditorActionDefinitionIds.PUSH_DOWN);
				editor.setAction("PushDown", fPushDownAction); //$NON-NLS-1$
	
				fExtractSupertypeAction= new ExtractSuperClassAction(editor);
				initAction(fExtractSupertypeAction, selection, ExtractSuperClassAction.EXTRACT_SUPERTYPE);
				editor.setAction("ExtractSupertype", fExtractSupertypeAction); //$NON-NLS-1$
	
			}

			fExtractMethodAction= new ExtractMethodAction(editor);
			initUpdatingAction(fExtractMethodAction, provider, selection, IJavaEditorActionDefinitionIds.EXTRACT_METHOD);
			editor.setAction("ExtractMethod", fExtractMethodAction); //$NON-NLS-1$
	
			fExtractTempAction= new ExtractTempAction(editor);
			initUpdatingAction(fExtractTempAction, provider, selection, IJavaEditorActionDefinitionIds.EXTRACT_LOCAL_VARIABLE);
			editor.setAction("ExtractLocalVariable", fExtractTempAction); //$NON-NLS-1$
	
			fExtractConstantAction= new ExtractConstantAction(editor);
			initUpdatingAction(fExtractConstantAction, provider, selection, IJavaEditorActionDefinitionIds.EXTRACT_CONSTANT);
			editor.setAction("ExtractConstant", fExtractConstantAction); //$NON-NLS-1$
	
			fIntroduceParameterAction= new IntroduceParameterAction(editor);
			initUpdatingAction(fIntroduceParameterAction, provider, selection, IJavaEditorActionDefinitionIds.INTRODUCE_PARAMETER);
			editor.setAction("IntroduceParameter", fIntroduceParameterAction); //$NON-NLS-1$
	
			if (IUIConstants.SUPPORT_REFACTORING) {
				fIntroduceFactoryAction = new IntroduceFactoryAction(editor);
				initUpdatingAction(fIntroduceFactoryAction, provider,
						selection,
						IJavaEditorActionDefinitionIds.INTRODUCE_FACTORY);
				editor.setAction("IntroduceFactory", fIntroduceFactoryAction); //$NON-NLS-1$
				fConvertLocalToFieldAction = new ConvertLocalToFieldAction(
						editor);
				initUpdatingAction(fConvertLocalToFieldAction, provider,
						selection,
						IJavaEditorActionDefinitionIds.PROMOTE_LOCAL_VARIABLE);
				editor.setAction("PromoteTemp", fConvertLocalToFieldAction); //$NON-NLS-1$
				fSelfEncapsulateField = new SelfEncapsulateFieldAction(editor);
				initAction(fSelfEncapsulateField, selection,
						IJavaEditorActionDefinitionIds.SELF_ENCAPSULATE_FIELD);
				editor.setAction("SelfEncapsulateField", fSelfEncapsulateField); //$NON-NLS-1$
			}
		}		
		if (IUIConstants.SUPPORT_REFACTORING) {
			fIntroduceIndirectionAction = new IntroduceIndirectionAction(editor);
			initUpdatingAction(fIntroduceIndirectionAction, provider,
					selection,
					IJavaEditorActionDefinitionIds.INTRODUCE_INDIRECTION);
			editor.setAction(
					"IntroduceIndirection", fIntroduceIndirectionAction); //$NON-NLS-1$
			fUseSupertypeAction = new UseSupertypeAction(editor);
			initAction(fUseSupertypeAction, selection,
					IJavaEditorActionDefinitionIds.USE_SUPERTYPE);
			editor.setAction("UseSupertype", fUseSupertypeAction); //$NON-NLS-1$
		}
		fInlineAction= new InlineAction(editor);
		initAction(fInlineAction, selection, IJavaEditorActionDefinitionIds.INLINE);
		editor.setAction("Inline", fInlineAction); //$NON-NLS-1$
		
		installQuickAccessAction();
		
		stats.endRun();
	}

	private RefactorActionGroup(IWorkbenchSite site) {

		final PerformanceStats stats= PerformanceStats.getStats(PERF_REFACTOR_ACTION_GROUP, this);
		stats.startRun();

		fSite= site;
		ISelectionProvider provider= fSite.getSelectionProvider();
		ISelection selection= provider.getSelection();
		
		if (!fBinary) {
			
			fMoveAction= new MoveAction(site);
			initUpdatingAction(fMoveAction, provider, selection, IJavaEditorActionDefinitionIds.MOVE_ELEMENT);
	
			fRenameAction= new RenameAction(site);
			initUpdatingAction(fRenameAction, provider, selection, IJavaEditorActionDefinitionIds.RENAME_ELEMENT);
	
			fModifyParametersAction= new ModifyParametersAction(fSite);
			initUpdatingAction(fModifyParametersAction, provider, selection, IJavaEditorActionDefinitionIds.MODIFY_METHOD_PARAMETERS);
	
			if (IUIConstants.SUPPORT_REFACTORING) {
				fPullUpAction = new PullUpAction(fSite);
				initUpdatingAction(fPullUpAction, provider, selection,
						IJavaEditorActionDefinitionIds.PULL_UP);
				fPushDownAction = new PushDownAction(fSite);
				initUpdatingAction(fPushDownAction, provider, selection,
						IJavaEditorActionDefinitionIds.PUSH_DOWN);
				fSelfEncapsulateField = new SelfEncapsulateFieldAction(fSite);
				initUpdatingAction(fSelfEncapsulateField, provider, selection,
						IJavaEditorActionDefinitionIds.SELF_ENCAPSULATE_FIELD);
				fExtractSupertypeAction = new ExtractSuperClassAction(fSite);
				initUpdatingAction(fExtractSupertypeAction, provider,
						selection, ExtractSuperClassAction.EXTRACT_SUPERTYPE);
				fIntroduceFactoryAction = new IntroduceFactoryAction(fSite);
				initUpdatingAction(fIntroduceFactoryAction, provider,
						selection,
						IJavaEditorActionDefinitionIds.INTRODUCE_FACTORY);
			}
	
//			fConvertAnonymousToNestedAction= new ConvertAnonymousToNestedAction(fSite);
//			initUpdatingAction(fConvertAnonymousToNestedAction, provider, selection, IJavaEditorActionDefinitionIds.CONVERT_ANONYMOUS_TO_NESTED);
		}		
		fInlineAction= new InlineAction(fSite);
		initUpdatingAction(fInlineAction, provider, selection, IJavaEditorActionDefinitionIds.INLINE);

		if (IUIConstants.SUPPORT_REFACTORING) {
			fUseSupertypeAction = new UseSupertypeAction(fSite);
			initUpdatingAction(fUseSupertypeAction, provider, selection,
					IJavaEditorActionDefinitionIds.USE_SUPERTYPE);
			fIntroduceIndirectionAction = new IntroduceIndirectionAction(fSite);
			initUpdatingAction(fIntroduceIndirectionAction, provider,
					selection,
					IJavaEditorActionDefinitionIds.INTRODUCE_INDIRECTION);
		}
		installQuickAccessAction();
		
		stats.endRun();
	}
	
	private void installQuickAccessAction() {
		fHandlerService= (IHandlerService)fSite.getService(IHandlerService.class);
		if (fHandlerService != null) {
			fQuickAccessAction= new RefactorQuickAccessAction(fEditor);
			fQuickAccessHandlerActivation= fHandlerService.activateHandler(fQuickAccessAction.getActionDefinitionId(), new ActionHandler(fQuickAccessAction));
		}
	}
	
	private void initAction(SelectionDispatchAction action, ISelection selection, String actionDefinitionId){
		initUpdatingAction(action, null, selection, actionDefinitionId);
	}
	
	/**
	 * Sets actionDefinitionId, updates enablement, adds to fActions,
	 * and adds selection changed listener if provider is not <code>null</code>.
	 *  
	 * @param action
	 * @param provider can be <code>null</code>
	 * @param selection
	 * @param actionDefinitionId
	 */
	private void initUpdatingAction(SelectionDispatchAction action, ISelectionProvider provider, ISelection selection, String actionDefinitionId){
		action.setActionDefinitionId(actionDefinitionId);
		action.update(selection);
		if (provider != null)
			provider.addSelectionChangedListener(action);
		fActions.add(action);
	}
	
	/* (non-Javadoc)
	 * Method declared in ActionGroup
	 */
	public void fillActionBars(IActionBars actionBars) {
		super.fillActionBars(actionBars);
		if (!fBinary) {
			if (IUIConstants.SUPPORT_REFACTORING)
				actionBars.setGlobalActionHandler(JdtActionConstants.SELF_ENCAPSULATE_FIELD, fSelfEncapsulateField);
			actionBars.setGlobalActionHandler(JdtActionConstants.MOVE, fMoveAction);
			actionBars.setGlobalActionHandler(JdtActionConstants.RENAME, fRenameAction);
			actionBars.setGlobalActionHandler(JdtActionConstants.MODIFY_PARAMETERS, fModifyParametersAction);
			if (IUIConstants.SUPPORT_REFACTORING) {
				actionBars.setGlobalActionHandler(JdtActionConstants.PULL_UP,
						fPullUpAction);
				actionBars.setGlobalActionHandler(JdtActionConstants.PUSH_DOWN,
						fPushDownAction);
			}
			actionBars.setGlobalActionHandler(JdtActionConstants.EXTRACT_TEMP, fExtractTempAction);
			if (IUIConstants.SUPPORT_REFACTORING) {
				actionBars.setGlobalActionHandler(
						JdtActionConstants.EXTRACT_CONSTANT,
						fExtractConstantAction);
				actionBars.setGlobalActionHandler(
						JdtActionConstants.INTRODUCE_PARAMETER,
						fIntroduceParameterAction);
				actionBars.setGlobalActionHandler(
						JdtActionConstants.INTRODUCE_FACTORY,
						fIntroduceFactoryAction);
			}
			actionBars.setGlobalActionHandler(JdtActionConstants.EXTRACT_METHOD, fExtractMethodAction);
			//	actionBars.setGlobalActionHandler(JdtActionConstants.REPLACE_INVOCATIONS, fReplaceInvocationsAction);
//			actionBars.setGlobalActionHandler(JdtActionConstants.EXTRACT_INTERFACE, fExtractInterfaceAction);
			if (IUIConstants.SUPPORT_REFACTORING) {
				actionBars.setGlobalActionHandler(ExtractSuperClassAction.EXTRACT_SUPERTYPES, fExtractSupertypeAction);
	//			actionBars.setGlobalActionHandler(JdtActionConstants.CHANGE_TYPE, fChangeTypeAction);
	//			actionBars.setGlobalActionHandler(JdtActionConstants.CONVERT_NESTED_TO_TOP, fConvertNestedToTopAction);
				actionBars.setGlobalActionHandler(JdtActionConstants.CONVERT_LOCAL_TO_FIELD, fConvertLocalToFieldAction);
	//			actionBars.setGlobalActionHandler(JdtActionConstants.CONVERT_ANONYMOUS_TO_NESTED, fConvertAnonymousToNestedAction);
			}
		}
		if (IUIConstants.SUPPORT_REFACTORING) {
				actionBars.setGlobalActionHandler(JdtActionConstants.INLINE, fInlineAction);
				actionBars.setGlobalActionHandler(JdtActionConstants.USE_SUPERTYPE, fUseSupertypeAction);
				actionBars.setGlobalActionHandler(JdtActionConstants.INTRODUCE_INDIRECTION, fIntroduceIndirectionAction);
		}
		if (fUndoRedoActionGroup != null) {
			fUndoRedoActionGroup.fillActionBars(actionBars);
		}
	}
	
	/**
	 * Retargets the File actions with the corresponding refactoring actions.
	 * 
	 * @param actionBars the action bar to register the move and rename action with
	 */
	public void retargetFileMenuActions(IActionBars actionBars) {
		actionBars.setGlobalActionHandler(ActionFactory.RENAME.getId(), fRenameAction);
		actionBars.setGlobalActionHandler(ActionFactory.MOVE.getId(), fMoveAction);
	}
	
	/* (non-Javadoc)
	 * Method declared in ActionGroup
	 */
	public void fillContextMenu(IMenuManager menu) {
		super.fillContextMenu(menu);
		addRefactorSubmenu(menu);
	}
	
	/*
	 * @see ActionGroup#dispose()
	 */
	public void dispose() {
		ISelectionProvider provider= fSite.getSelectionProvider();
		if (!fBinary) {
			disposeAction(fMoveAction, provider);
			disposeAction(fRenameAction, provider);
			disposeAction(fExtractTempAction, provider);
			disposeAction(fIntroduceParameterAction, provider);
			disposeAction(fExtractMethodAction, provider);
			if (IUIConstants.SUPPORT_REFACTORING) {
				disposeAction(fSelfEncapsulateField, provider);
				disposeAction(fModifyParametersAction, provider);
				disposeAction(fPullUpAction, provider);
				disposeAction(fPushDownAction, provider);
				disposeAction(fExtractConstantAction, provider);
				disposeAction(fIntroduceFactoryAction, provider);
				//	disposeAction(fReplaceInvocationsAction, provider);
				//			disposeAction(fExtractInterfaceAction, provider);
				disposeAction(fExtractSupertypeAction, provider);
				//			disposeAction(fChangeTypeAction, provider);
				//			disposeAction(fConvertNestedToTopAction, provider);
				disposeAction(fConvertLocalToFieldAction, provider);
				//			disposeAction(fConvertAnonymousToNestedAction, provider);
			}
		}
		if (IUIConstants.SUPPORT_REFACTORING) {
			disposeAction(fIntroduceIndirectionAction, provider);
			disposeAction(fInlineAction, provider);
			disposeAction(fUseSupertypeAction, provider);
		}
		if (fQuickAccessHandlerActivation != null && fHandlerService != null) {
			fHandlerService.deactivateHandler(fQuickAccessHandlerActivation);
		}
		if (fUndoRedoActionGroup != null) {
			fUndoRedoActionGroup.dispose();
		}
		super.dispose();
	}
	
	private void disposeAction(ISelectionChangedListener action, ISelectionProvider provider) {
		if (action != null)
			provider.removeSelectionChangedListener(action);
	}
	
	private void addRefactorSubmenu(IMenuManager menu) {
		String menuText= ActionMessages.RefactorMenu_label; 
		if (fQuickAccessAction != null) {
			menuText= fQuickAccessAction.addShortcut(menuText); 
		}
		IMenuManager refactorSubmenu= new MenuManager(menuText, MENU_ID);  
		if (fEditor != null) {
			IJavaScriptElement element= SelectionConverter.getInput(fEditor);
			if (element != null && ActionUtil.isOnBuildPath(element)) {
				refactorSubmenu.addMenuListener(new IMenuListener() {
					public void menuAboutToShow(IMenuManager manager) {
						refactorMenuShown(manager);
					}
				});
				refactorSubmenu.add(fNoActionAvailable);
				menu.appendToGroup(fGroupName, refactorSubmenu);
			} 
		} else {
			ISelection selection= fSite.getSelectionProvider().getSelection();
			for (Iterator iter= fActions.iterator(); iter.hasNext(); ) {
				((SelectionDispatchAction)iter.next()).update(selection);
			}
			if (fillRefactorMenu(refactorSubmenu) > 0)
				menu.appendToGroup(fGroupName, refactorSubmenu);
		}
	}
	
	private int fillRefactorMenu(IMenuManager refactorSubmenu) {
		int added= 0;
		refactorSubmenu.add(new Separator(GROUP_REORG));
		added+= addAction(refactorSubmenu, fRenameAction);
		added+= addAction(refactorSubmenu, fMoveAction);
		refactorSubmenu.add(new Separator(GROUP_CODING));
		added+= addAction(refactorSubmenu, fModifyParametersAction);
		added+= addAction(refactorSubmenu, fExtractMethodAction);
		added+= addAction(refactorSubmenu, fExtractTempAction);
		if (IUIConstants.SUPPORT_REFACTORING) {
			added += addAction(refactorSubmenu, fExtractConstantAction);
			added += addAction(refactorSubmenu, fInlineAction);
			refactorSubmenu.add(new Separator(GROUP_REORG2));
			//		added+= addAction(refactorSubmenu, fConvertAnonymousToNestedAction);
			//		added+= addAction(refactorSubmenu, fConvertNestedToTopAction);
			added += addAction(refactorSubmenu, fConvertLocalToFieldAction);
			refactorSubmenu.add(new Separator(GROUP_TYPE));
			//		added+= addAction(refactorSubmenu, fExtractInterfaceAction);
			added += addAction(refactorSubmenu, fExtractSupertypeAction);
			added += addAction(refactorSubmenu, fUseSupertypeAction);
			added += addAction(refactorSubmenu, fPullUpAction);
			added += addAction(refactorSubmenu, fPushDownAction);
		}
		refactorSubmenu.add(new Separator(GROUP_CODING2));
		if (IUIConstants.SUPPORT_REFACTORING) {
			added += addAction(refactorSubmenu, fIntroduceIndirectionAction);
			added += addAction(refactorSubmenu, fIntroduceFactoryAction);
		}
		added+= addAction(refactorSubmenu, fIntroduceParameterAction);
		if (IUIConstants.SUPPORT_REFACTORING) 
			added+= addAction(refactorSubmenu, fSelfEncapsulateField);
//		added+= addAction(refactorSubmenu, fReplaceInvocationsAction);
		if (IUIConstants.SUPPORT_REFACTORING) {
			refactorSubmenu.add(new Separator(GROUP_TYPE2));
		}
		return added;
	}
	
	private int addAction(IMenuManager menu, IAction action) {
		if (action != null && action.isEnabled()) {
			menu.add(action);
			return 1;
		}
		return 0;
	}
	
	private void refactorMenuShown(final IMenuManager refactorSubmenu) {
		// we know that we have an MenuManager since we created it in
		// addRefactorSubmenu.
		Menu menu= ((MenuManager)refactorSubmenu).getMenu();
		menu.addMenuListener(new MenuAdapter() {
			public void menuHidden(MenuEvent e) {
				refactorMenuHidden(refactorSubmenu);
			}
		});
		ITextSelection textSelection= (ITextSelection)fEditor.getSelectionProvider().getSelection();
		JavaTextSelection javaSelection= new JavaTextSelection(
			getEditorInput(), getDocument(), textSelection.getOffset(), textSelection.getLength());
		
		for (Iterator iter= fActions.iterator(); iter.hasNext(); ) {
			SelectionDispatchAction action= (SelectionDispatchAction)iter.next();
			action.update(javaSelection);
		}
		refactorSubmenu.removeAll();
		if (fillRefactorMenu(refactorSubmenu) == 0)
			refactorSubmenu.add(fNoActionAvailable);
	}
	
	private void refactorMenuHidden(IMenuManager manager) {
		ITextSelection textSelection= (ITextSelection)fEditor.getSelectionProvider().getSelection();
		for (Iterator iter= fActions.iterator(); iter.hasNext(); ) {
			SelectionDispatchAction action= (SelectionDispatchAction)iter.next();
			action.update(textSelection);
		}
	}
	
	private IJavaScriptElement getEditorInput() {
		final IEditorInput input= fEditor.getEditorInput();
		if (input instanceof IClassFileEditorInput) {
			IClassFileEditorInput extended= (IClassFileEditorInput) input;
			return extended.getClassFile();
		}
		return JavaScriptPlugin.getDefault().getWorkingCopyManager().getWorkingCopy(input);
	}
	
	private IDocument getDocument() {
		return JavaScriptPlugin.getDefault().getCompilationUnitDocumentProvider().
			getDocument(fEditor.getEditorInput());
	}
	
	private void fillQuickMenu(IMenuManager menu) {
		if (fEditor != null) {
			IJavaScriptElement element= SelectionConverter.getInput(fEditor);
			if (element == null || !ActionUtil.isOnBuildPath(element)) {
				menu.add(fNoActionAvailable);
				return;
			}
			ITextSelection textSelection= (ITextSelection)fEditor.getSelectionProvider().getSelection();
			JavaTextSelection javaSelection= new JavaTextSelection(
				getEditorInput(), getDocument(), textSelection.getOffset(), textSelection.getLength());
			
			for (Iterator iter= fActions.iterator(); iter.hasNext(); ) {
				((SelectionDispatchAction)iter.next()).update(javaSelection);
			}
			fillRefactorMenu(menu);
			for (Iterator iter= fActions.iterator(); iter.hasNext(); ) {
				((SelectionDispatchAction)iter.next()).update(textSelection);
			}
			
		} else {
			ISelection selection= fSite.getSelectionProvider().getSelection();
			for (Iterator iter= fActions.iterator(); iter.hasNext(); ) {
				((SelectionDispatchAction)iter.next()).update(selection);
			}
			fillRefactorMenu(menu);
		}
	}
}