001: /*******************************************************************************
002: * Copyright (c) 2000, 2007 IBM Corporation and others.
003: * All rights reserved. This program and the accompanying materials
004: * are made available under the terms of the Eclipse Public License v1.0
005: * which accompanies this distribution, and is available at
006: * http://www.eclipse.org/legal/epl-v10.html
007: *
008: * Contributors:
009: * IBM Corporation - initial API and implementation
010: *******************************************************************************/package org.eclipse.jdt.ui.actions;
011:
012: import java.util.ArrayList;
013: import java.util.Iterator;
014: import java.util.List;
015:
016: import org.eclipse.core.commands.operations.IUndoContext;
017:
018: import org.eclipse.core.runtime.PerformanceStats;
019:
020: import org.eclipse.core.resources.ResourcesPlugin;
021:
022: import org.eclipse.swt.events.MenuAdapter;
023: import org.eclipse.swt.events.MenuEvent;
024: import org.eclipse.swt.widgets.Menu;
025:
026: import org.eclipse.jface.action.Action;
027: import org.eclipse.jface.action.IAction;
028: import org.eclipse.jface.action.IMenuListener;
029: import org.eclipse.jface.action.IMenuManager;
030: import org.eclipse.jface.action.MenuManager;
031: import org.eclipse.jface.action.Separator;
032: import org.eclipse.jface.commands.ActionHandler;
033: import org.eclipse.jface.viewers.ISelection;
034: import org.eclipse.jface.viewers.ISelectionChangedListener;
035: import org.eclipse.jface.viewers.ISelectionProvider;
036:
037: import org.eclipse.jface.text.IDocument;
038: import org.eclipse.jface.text.ITextSelection;
039:
040: import org.eclipse.ui.IActionBars;
041: import org.eclipse.ui.IViewPart;
042: import org.eclipse.ui.IWorkbenchSite;
043: import org.eclipse.ui.actions.ActionFactory;
044: import org.eclipse.ui.actions.ActionGroup;
045: import org.eclipse.ui.handlers.IHandlerActivation;
046: import org.eclipse.ui.handlers.IHandlerService;
047: import org.eclipse.ui.operations.UndoRedoActionGroup;
048: import org.eclipse.ui.part.Page;
049:
050: import org.eclipse.jdt.core.IJavaElement;
051: import org.eclipse.jdt.core.ITypeRoot;
052:
053: import org.eclipse.jdt.ui.IContextMenuConstants;
054: import org.eclipse.jdt.ui.JavaUI;
055:
056: import org.eclipse.jdt.internal.ui.JavaPlugin;
057: import org.eclipse.jdt.internal.ui.actions.ActionMessages;
058: import org.eclipse.jdt.internal.ui.actions.ActionUtil;
059: import org.eclipse.jdt.internal.ui.actions.ExtractSuperClassAction;
060: import org.eclipse.jdt.internal.ui.actions.IntroduceParameterObjectAction;
061: import org.eclipse.jdt.internal.ui.actions.JDTQuickMenuAction;
062: import org.eclipse.jdt.internal.ui.actions.SelectionConverter;
063: import org.eclipse.jdt.internal.ui.javaeditor.JavaEditor;
064: import org.eclipse.jdt.internal.ui.javaeditor.JavaTextSelection;
065: import org.eclipse.jdt.internal.ui.refactoring.RefactoringMessages;
066:
067: /**
068: * Action group that adds refactor actions (for example 'Rename', 'Move')
069: * to a context menu and the global menu bar.
070: *
071: * <p>
072: * This class may be instantiated; it is not intended to be subclassed.
073: * </p>
074: *
075: * @since 2.0
076: */
077: public class RefactorActionGroup extends ActionGroup {
078:
079: private static final String PERF_REFACTOR_ACTION_GROUP = "org.eclipse.jdt.ui/perf/explorer/RefactorActionGroup"; //$NON-NLS-1$
080:
081: /**
082: * Pop-up menu: id of the refactor sub menu (value <code>org.eclipse.jdt.ui.refactoring.menu</code>).
083: *
084: * @since 2.1
085: */
086: public static final String MENU_ID = "org.eclipse.jdt.ui.refactoring.menu"; //$NON-NLS-1$
087:
088: /**
089: * Pop-up menu: id of the reorg group of the refactor sub menu (value
090: * <code>reorgGroup</code>).
091: *
092: * @since 2.1
093: */
094: public static final String GROUP_REORG = "reorgGroup"; //$NON-NLS-1$
095:
096: /**
097: * Pop-up menu: id of the type group of the refactor sub menu (value
098: * <code>typeGroup</code>).
099: *
100: * @since 2.1
101: */
102: public static final String GROUP_TYPE = "typeGroup"; //$NON-NLS-1$
103:
104: /**
105: * Pop-up menu: id of the coding group of the refactor sub menu (value
106: * <code>codingGroup</code>).
107: *
108: * @since 2.1
109: */
110: public static final String GROUP_CODING = "codingGroup"; //$NON-NLS-1$
111:
112: /**
113: * Pop-up menu: id of the coding group 2 of the refactor sub menu (value
114: * <code>codingGroup2</code>).
115: *
116: * @since 3.2
117: */
118: public static final String GROUP_CODING2 = "codingGroup2"; //$NON-NLS-1$
119:
120: /**
121: * Pop-up menu: id of the reorg group 2 of the refactor sub menu (value
122: * <code>reorgGroup2</code>).
123: *
124: * @since 3.2
125: */
126: private static final String GROUP_REORG2 = "reorgGroup2"; //$NON-NLS-1$ //TODO(3.3): make public
127:
128: /**
129: * Pop-up menu: id of the type group 2 of the refactor sub menu (value
130: * <code>typeGroup2</code>).
131: *
132: * @since 3.2
133: */
134: private static final String GROUP_TYPE2 = "typeGroup2"; //$NON-NLS-1$ //TODO(3.3): make public
135:
136: /**
137: * Pop-up menu: id of the type group 2 of the refactor sub menu (value
138: * <code>typeGroup3</code>).
139: *
140: * @since 3.4
141: */
142: private static final String GROUP_TYPE3 = "typeGroup3"; //$NON-NLS-1$ //TODO(3.3): make public
143:
144: private IWorkbenchSite fSite;
145: private JavaEditor fEditor;
146: private String fGroupName = IContextMenuConstants.GROUP_REORGANIZE;
147: private boolean fBinary = false;
148:
149: private SelectionDispatchAction fMoveAction;
150: private SelectionDispatchAction fRenameAction;
151: private SelectionDispatchAction fModifyParametersAction;
152: private SelectionDispatchAction fConvertAnonymousToNestedAction;
153: private SelectionDispatchAction fConvertNestedToTopAction;
154:
155: private SelectionDispatchAction fPullUpAction;
156: private SelectionDispatchAction fPushDownAction;
157: private SelectionDispatchAction fExtractInterfaceAction;
158: private SelectionDispatchAction fExtractSupertypeAction;
159: private SelectionDispatchAction fChangeTypeAction;
160: private SelectionDispatchAction fUseSupertypeAction;
161: private SelectionDispatchAction fInferTypeArgumentsAction;
162:
163: private SelectionDispatchAction fInlineAction;
164: // private SelectionDispatchAction fReplaceInvocationsAction;
165: private SelectionDispatchAction fIntroduceIndirectionAction;
166: private SelectionDispatchAction fExtractMethodAction;
167: private SelectionDispatchAction fExtractTempAction;
168: private SelectionDispatchAction fExtractConstantAction;
169: private SelectionDispatchAction fExtractClassAction;
170: private SelectionDispatchAction fIntroduceParameterAction;
171: private SelectionDispatchAction fIntroduceParameterObjectAction;
172: private SelectionDispatchAction fIntroduceFactoryAction;
173: private SelectionDispatchAction fConvertLocalToFieldAction;
174: private SelectionDispatchAction fSelfEncapsulateField;
175:
176: private UndoRedoActionGroup fUndoRedoActionGroup;
177:
178: private final List fActions = new ArrayList();
179:
180: private static final String QUICK_MENU_ID = "org.eclipse.jdt.ui.edit.text.java.refactor.quickMenu"; //$NON-NLS-1$
181:
182: private class RefactorQuickAccessAction extends JDTQuickMenuAction {
183: public RefactorQuickAccessAction(JavaEditor editor) {
184: super (editor, QUICK_MENU_ID);
185: }
186:
187: protected void fillMenu(IMenuManager menu) {
188: fillQuickMenu(menu);
189: }
190: }
191:
192: private JDTQuickMenuAction fQuickAccessAction;
193: private IHandlerActivation fQuickAccessHandlerActivation;
194: private IHandlerService fHandlerService;
195:
196: private static class NoActionAvailable extends Action {
197: public NoActionAvailable() {
198: setEnabled(true);
199: setText(RefactoringMessages.RefactorActionGroup_no_refactoring_available);
200: }
201: }
202:
203: private Action fNoActionAvailable = new NoActionAvailable();
204:
205: /**
206: * Creates a new <code>RefactorActionGroup</code>. The group requires
207: * that the selection provided by the part's selection provider is of type <code>
208: * org.eclipse.jface.viewers.IStructuredSelection</code>.
209: *
210: * @param part the view part that owns this action group
211: */
212: public RefactorActionGroup(IViewPart part) {
213: this (part.getSite());
214:
215: IUndoContext workspaceContext = (IUndoContext) ResourcesPlugin
216: .getWorkspace().getAdapter(IUndoContext.class);
217: fUndoRedoActionGroup = new UndoRedoActionGroup(part
218: .getViewSite(), workspaceContext, true);
219: }
220:
221: /**
222: * Creates a new <code>RefactorActionGroup</code>. The action requires
223: * that the selection provided by the page's selection provider is of type <code>
224: * org.eclipse.jface.viewers.IStructuredSelection</code>.
225: *
226: * @param page the page that owns this action group
227: */
228: public RefactorActionGroup(Page page) {
229: this (page.getSite());
230: }
231:
232: /**
233: * Note: This constructor is for internal use only. Clients should not call this constructor.
234: * @param editor the java editor
235: * @param groupName the group name to add the actions to
236: * @param binary <code>true</code> if the action group is used in a binary environment, <code>false</code> otherwise
237: */
238: public RefactorActionGroup(JavaEditor editor, String groupName,
239: boolean binary) {
240:
241: final PerformanceStats stats = PerformanceStats.getStats(
242: PERF_REFACTOR_ACTION_GROUP, this );
243: stats.startRun();
244:
245: fSite = editor.getEditorSite();
246: fEditor = editor;
247: fGroupName = groupName;
248: fBinary = binary;
249:
250: ISelectionProvider provider = editor.getSelectionProvider();
251: ISelection selection = provider.getSelection();
252:
253: if (!fBinary) {
254: fRenameAction = new RenameAction(editor);
255: initAction(fRenameAction, selection,
256: IJavaEditorActionDefinitionIds.RENAME_ELEMENT);
257: editor.setAction("RenameElement", fRenameAction); //$NON-NLS-1$
258:
259: fMoveAction = new MoveAction(editor);
260: initAction(fMoveAction, selection,
261: IJavaEditorActionDefinitionIds.MOVE_ELEMENT);
262: editor.setAction("MoveElement", fMoveAction); //$NON-NLS-1$
263:
264: fModifyParametersAction = new ModifyParametersAction(editor);
265: initAction(
266: fModifyParametersAction,
267: selection,
268: IJavaEditorActionDefinitionIds.MODIFY_METHOD_PARAMETERS);
269: editor.setAction(
270: "ModifyParameters", fModifyParametersAction); //$NON-NLS-1$
271:
272: fConvertAnonymousToNestedAction = new ConvertAnonymousToNestedAction(
273: editor);
274: initUpdatingAction(
275: fConvertAnonymousToNestedAction,
276: provider,
277: selection,
278: IJavaEditorActionDefinitionIds.CONVERT_ANONYMOUS_TO_NESTED);
279: editor
280: .setAction(
281: "ConvertAnonymousToNested", fConvertAnonymousToNestedAction); //$NON-NLS-1$
282:
283: fConvertNestedToTopAction = new ConvertNestedToTopAction(
284: editor);
285: initAction(fConvertNestedToTopAction, selection,
286: IJavaEditorActionDefinitionIds.MOVE_INNER_TO_TOP);
287: editor.setAction(
288: "MoveInnerToTop", fConvertNestedToTopAction); //$NON-NLS-1$
289:
290: fPullUpAction = new PullUpAction(editor);
291: initAction(fPullUpAction, selection,
292: IJavaEditorActionDefinitionIds.PULL_UP);
293: editor.setAction("PullUp", fPullUpAction); //$NON-NLS-1$
294:
295: fPushDownAction = new PushDownAction(editor);
296: initAction(fPushDownAction, selection,
297: IJavaEditorActionDefinitionIds.PUSH_DOWN);
298: editor.setAction("PushDown", fPushDownAction); //$NON-NLS-1$
299:
300: fExtractSupertypeAction = new ExtractSuperClassAction(
301: editor);
302: initAction(fExtractSupertypeAction, selection,
303: ExtractSuperClassAction.EXTRACT_SUPERTYPE);
304: editor.setAction(
305: "ExtractSupertype", fExtractSupertypeAction); //$NON-NLS-1$
306:
307: fExtractInterfaceAction = new ExtractInterfaceAction(editor);
308: initAction(fExtractInterfaceAction, selection,
309: IJavaEditorActionDefinitionIds.EXTRACT_INTERFACE);
310: editor.setAction(
311: "ExtractInterface", fExtractInterfaceAction); //$NON-NLS-1$
312:
313: fExtractClassAction = new ExtractClassAction(editor);
314: initAction(fExtractClassAction, selection,
315: IJavaEditorActionDefinitionIds.EXTRACT_CLASS);
316: editor.setAction("ExtractClass", fExtractClassAction); //$NON-NLS-1$
317:
318: fChangeTypeAction = new ChangeTypeAction(editor);
319: initUpdatingAction(fChangeTypeAction, provider, selection,
320: IJavaEditorActionDefinitionIds.CHANGE_TYPE);
321: editor.setAction("ChangeType", fChangeTypeAction); //$NON-NLS-1$
322:
323: fInferTypeArgumentsAction = new InferTypeArgumentsAction(
324: editor);
325: initAction(
326: fInferTypeArgumentsAction,
327: selection,
328: IJavaEditorActionDefinitionIds.INFER_TYPE_ARGUMENTS_ACTION);
329: editor.setAction(
330: "InferTypeArguments", fInferTypeArgumentsAction); //$NON-NLS-1$
331:
332: fExtractMethodAction = new ExtractMethodAction(editor);
333: initUpdatingAction(fExtractMethodAction, provider,
334: selection,
335: IJavaEditorActionDefinitionIds.EXTRACT_METHOD);
336: editor.setAction("ExtractMethod", fExtractMethodAction); //$NON-NLS-1$
337:
338: fExtractTempAction = new ExtractTempAction(editor);
339: initUpdatingAction(
340: fExtractTempAction,
341: provider,
342: selection,
343: IJavaEditorActionDefinitionIds.EXTRACT_LOCAL_VARIABLE);
344: editor
345: .setAction(
346: "ExtractLocalVariable", fExtractTempAction); //$NON-NLS-1$
347:
348: fExtractConstantAction = new ExtractConstantAction(editor);
349: initUpdatingAction(fExtractConstantAction, provider,
350: selection,
351: IJavaEditorActionDefinitionIds.EXTRACT_CONSTANT);
352: editor.setAction("ExtractConstant", fExtractConstantAction); //$NON-NLS-1$
353:
354: fIntroduceParameterAction = new IntroduceParameterAction(
355: editor);
356: initUpdatingAction(fIntroduceParameterAction, provider,
357: selection,
358: IJavaEditorActionDefinitionIds.INTRODUCE_PARAMETER);
359: editor.setAction(
360: "IntroduceParameter", fIntroduceParameterAction); //$NON-NLS-1$
361:
362: fIntroduceFactoryAction = new IntroduceFactoryAction(editor);
363: initUpdatingAction(fIntroduceFactoryAction, provider,
364: selection,
365: IJavaEditorActionDefinitionIds.INTRODUCE_FACTORY);
366: editor.setAction(
367: "IntroduceFactory", fIntroduceFactoryAction); //$NON-NLS-1$
368:
369: fConvertLocalToFieldAction = new ConvertLocalToFieldAction(
370: editor);
371: initUpdatingAction(
372: fConvertLocalToFieldAction,
373: provider,
374: selection,
375: IJavaEditorActionDefinitionIds.PROMOTE_LOCAL_VARIABLE);
376: editor.setAction("PromoteTemp", fConvertLocalToFieldAction); //$NON-NLS-1$
377:
378: fSelfEncapsulateField = new SelfEncapsulateFieldAction(
379: editor);
380: initAction(
381: fSelfEncapsulateField,
382: selection,
383: IJavaEditorActionDefinitionIds.SELF_ENCAPSULATE_FIELD);
384: editor.setAction(
385: "SelfEncapsulateField", fSelfEncapsulateField); //$NON-NLS-1$
386:
387: fIntroduceParameterObjectAction = new IntroduceParameterObjectAction(
388: editor);
389: initAction(
390: fIntroduceParameterObjectAction,
391: selection,
392: IJavaEditorActionDefinitionIds.INTRODUCE_PARAMETER_OBJECT);
393: editor
394: .setAction(
395: "IntroduceParameterObjectAction", fIntroduceParameterObjectAction); //$NON-NLS-1$
396: }
397: fIntroduceIndirectionAction = new IntroduceIndirectionAction(
398: editor);
399: initUpdatingAction(fIntroduceIndirectionAction, provider,
400: selection,
401: IJavaEditorActionDefinitionIds.INTRODUCE_INDIRECTION);
402: editor.setAction(
403: "IntroduceIndirection", fIntroduceIndirectionAction); //$NON-NLS-1$
404:
405: fUseSupertypeAction = new UseSupertypeAction(editor);
406: initAction(fUseSupertypeAction, selection,
407: IJavaEditorActionDefinitionIds.USE_SUPERTYPE);
408: editor.setAction("UseSupertype", fUseSupertypeAction); //$NON-NLS-1$
409:
410: fInlineAction = new InlineAction(editor);
411: initAction(fInlineAction, selection,
412: IJavaEditorActionDefinitionIds.INLINE);
413: editor.setAction("Inline", fInlineAction); //$NON-NLS-1$
414:
415: installQuickAccessAction();
416:
417: stats.endRun();
418: }
419:
420: private RefactorActionGroup(IWorkbenchSite site) {
421:
422: final PerformanceStats stats = PerformanceStats.getStats(
423: PERF_REFACTOR_ACTION_GROUP, this );
424: stats.startRun();
425:
426: fSite = site;
427: ISelectionProvider provider = fSite.getSelectionProvider();
428: ISelection selection = provider.getSelection();
429:
430: if (!fBinary) {
431:
432: fMoveAction = new MoveAction(site);
433: initUpdatingAction(fMoveAction, provider, selection,
434: IJavaEditorActionDefinitionIds.MOVE_ELEMENT);
435:
436: fRenameAction = new RenameAction(site);
437: initUpdatingAction(fRenameAction, provider, selection,
438: IJavaEditorActionDefinitionIds.RENAME_ELEMENT);
439:
440: fModifyParametersAction = new ModifyParametersAction(fSite);
441: initUpdatingAction(
442: fModifyParametersAction,
443: provider,
444: selection,
445: IJavaEditorActionDefinitionIds.MODIFY_METHOD_PARAMETERS);
446:
447: fPullUpAction = new PullUpAction(fSite);
448: initUpdatingAction(fPullUpAction, provider, selection,
449: IJavaEditorActionDefinitionIds.PULL_UP);
450:
451: fPushDownAction = new PushDownAction(fSite);
452: initUpdatingAction(fPushDownAction, provider, selection,
453: IJavaEditorActionDefinitionIds.PUSH_DOWN);
454:
455: fSelfEncapsulateField = new SelfEncapsulateFieldAction(
456: fSite);
457: initUpdatingAction(
458: fSelfEncapsulateField,
459: provider,
460: selection,
461: IJavaEditorActionDefinitionIds.SELF_ENCAPSULATE_FIELD);
462:
463: fIntroduceParameterObjectAction = new IntroduceParameterObjectAction(
464: fSite);
465: initUpdatingAction(
466: fIntroduceParameterObjectAction,
467: provider,
468: selection,
469: IJavaEditorActionDefinitionIds.INTRODUCE_PARAMETER_OBJECT);
470:
471: fExtractSupertypeAction = new ExtractSuperClassAction(fSite);
472: initUpdatingAction(fExtractSupertypeAction, provider,
473: selection,
474: ExtractSuperClassAction.EXTRACT_SUPERTYPE);
475:
476: fExtractInterfaceAction = new ExtractInterfaceAction(fSite);
477: initUpdatingAction(fExtractInterfaceAction, provider,
478: selection,
479: IJavaEditorActionDefinitionIds.EXTRACT_INTERFACE);
480:
481: fExtractClassAction = new ExtractClassAction(fSite);
482: initUpdatingAction(fExtractClassAction, provider,
483: selection,
484: IJavaEditorActionDefinitionIds.EXTRACT_CLASS);
485:
486: fChangeTypeAction = new ChangeTypeAction(fSite);
487: initUpdatingAction(fChangeTypeAction, provider, selection,
488: IJavaEditorActionDefinitionIds.CHANGE_TYPE);
489:
490: fConvertNestedToTopAction = new ConvertNestedToTopAction(
491: fSite);
492: initUpdatingAction(fConvertNestedToTopAction, provider,
493: selection,
494: IJavaEditorActionDefinitionIds.MOVE_INNER_TO_TOP);
495:
496: fInferTypeArgumentsAction = new InferTypeArgumentsAction(
497: fSite);
498: initUpdatingAction(
499: fInferTypeArgumentsAction,
500: provider,
501: selection,
502: IJavaEditorActionDefinitionIds.INFER_TYPE_ARGUMENTS_ACTION);
503:
504: fIntroduceFactoryAction = new IntroduceFactoryAction(fSite);
505: initUpdatingAction(fIntroduceFactoryAction, provider,
506: selection,
507: IJavaEditorActionDefinitionIds.INTRODUCE_FACTORY);
508:
509: fConvertAnonymousToNestedAction = new ConvertAnonymousToNestedAction(
510: fSite);
511: initUpdatingAction(
512: fConvertAnonymousToNestedAction,
513: provider,
514: selection,
515: IJavaEditorActionDefinitionIds.CONVERT_ANONYMOUS_TO_NESTED);
516: }
517: fInlineAction = new InlineAction(fSite);
518: initUpdatingAction(fInlineAction, provider, selection,
519: IJavaEditorActionDefinitionIds.INLINE);
520:
521: fUseSupertypeAction = new UseSupertypeAction(fSite);
522: initUpdatingAction(fUseSupertypeAction, provider, selection,
523: IJavaEditorActionDefinitionIds.USE_SUPERTYPE);
524:
525: fIntroduceIndirectionAction = new IntroduceIndirectionAction(
526: fSite);
527: initUpdatingAction(fIntroduceIndirectionAction, provider,
528: selection,
529: IJavaEditorActionDefinitionIds.INTRODUCE_INDIRECTION);
530:
531: installQuickAccessAction();
532:
533: stats.endRun();
534: }
535:
536: private void installQuickAccessAction() {
537: fHandlerService = (IHandlerService) fSite
538: .getService(IHandlerService.class);
539: if (fHandlerService != null) {
540: fQuickAccessAction = new RefactorQuickAccessAction(fEditor);
541: fQuickAccessHandlerActivation = fHandlerService
542: .activateHandler(fQuickAccessAction
543: .getActionDefinitionId(),
544: new ActionHandler(fQuickAccessAction));
545: }
546: }
547:
548: private void initAction(SelectionDispatchAction action,
549: ISelection selection, String actionDefinitionId) {
550: initUpdatingAction(action, null, selection, actionDefinitionId);
551: }
552:
553: /**
554: * Sets actionDefinitionId, updates enablement, adds to fActions,
555: * and adds selection changed listener if provider is not <code>null</code>.
556: *
557: * @param action
558: * @param provider can be <code>null</code>
559: * @param selection
560: * @param actionDefinitionId
561: */
562: private void initUpdatingAction(SelectionDispatchAction action,
563: ISelectionProvider provider, ISelection selection,
564: String actionDefinitionId) {
565: action.setActionDefinitionId(actionDefinitionId);
566: action.update(selection);
567: if (provider != null)
568: provider.addSelectionChangedListener(action);
569: fActions.add(action);
570: }
571:
572: /* (non-Javadoc)
573: * Method declared in ActionGroup
574: */
575: public void fillActionBars(IActionBars actionBars) {
576: super .fillActionBars(actionBars);
577: if (!fBinary) {
578: actionBars.setGlobalActionHandler(
579: JdtActionConstants.SELF_ENCAPSULATE_FIELD,
580: fSelfEncapsulateField);
581: actionBars.setGlobalActionHandler(JdtActionConstants.MOVE,
582: fMoveAction);
583: actionBars.setGlobalActionHandler(
584: JdtActionConstants.RENAME, fRenameAction);
585: actionBars.setGlobalActionHandler(
586: JdtActionConstants.MODIFY_PARAMETERS,
587: fModifyParametersAction);
588: actionBars.setGlobalActionHandler(
589: JdtActionConstants.PULL_UP, fPullUpAction);
590: actionBars.setGlobalActionHandler(
591: JdtActionConstants.PUSH_DOWN, fPushDownAction);
592: actionBars
593: .setGlobalActionHandler(
594: JdtActionConstants.EXTRACT_TEMP,
595: fExtractTempAction);
596: actionBars.setGlobalActionHandler(
597: JdtActionConstants.EXTRACT_CONSTANT,
598: fExtractConstantAction);
599: actionBars.setGlobalActionHandler(
600: JdtActionConstants.INTRODUCE_PARAMETER,
601: fIntroduceParameterAction);
602: actionBars.setGlobalActionHandler(
603: JdtActionConstants.INTRODUCE_FACTORY,
604: fIntroduceFactoryAction);
605: actionBars.setGlobalActionHandler(
606: JdtActionConstants.EXTRACT_METHOD,
607: fExtractMethodAction);
608: // actionBars.setGlobalActionHandler(JdtActionConstants.REPLACE_INVOCATIONS, fReplaceInvocationsAction);
609: actionBars.setGlobalActionHandler(
610: JdtActionConstants.EXTRACT_INTERFACE,
611: fExtractInterfaceAction);
612: actionBars.setGlobalActionHandler(
613: JdtActionConstants.EXTRACT_CLASS,
614: fExtractClassAction);
615: actionBars.setGlobalActionHandler(
616: ExtractSuperClassAction.EXTRACT_SUPERTYPES,
617: fExtractSupertypeAction);
618: actionBars.setGlobalActionHandler(
619: JdtActionConstants.CHANGE_TYPE, fChangeTypeAction);
620: actionBars.setGlobalActionHandler(
621: JdtActionConstants.CONVERT_NESTED_TO_TOP,
622: fConvertNestedToTopAction);
623: actionBars.setGlobalActionHandler(
624: JdtActionConstants.INFER_TYPE_ARGUMENTS,
625: fInferTypeArgumentsAction);
626: actionBars.setGlobalActionHandler(
627: JdtActionConstants.CONVERT_LOCAL_TO_FIELD,
628: fConvertLocalToFieldAction);
629: actionBars.setGlobalActionHandler(
630: JdtActionConstants.CONVERT_ANONYMOUS_TO_NESTED,
631: fConvertAnonymousToNestedAction);
632: actionBars.setGlobalActionHandler(
633: JdtActionConstants.INTRODUCE_PARAMETER_OBJECT,
634: fIntroduceParameterObjectAction);
635: }
636: actionBars.setGlobalActionHandler(JdtActionConstants.INLINE,
637: fInlineAction);
638: actionBars.setGlobalActionHandler(
639: JdtActionConstants.USE_SUPERTYPE, fUseSupertypeAction);
640: actionBars.setGlobalActionHandler(
641: JdtActionConstants.INTRODUCE_INDIRECTION,
642: fIntroduceIndirectionAction);
643: if (fUndoRedoActionGroup != null) {
644: fUndoRedoActionGroup.fillActionBars(actionBars);
645: }
646: }
647:
648: /**
649: * Retargets the File actions with the corresponding refactoring actions.
650: *
651: * @param actionBars the action bar to register the move and rename action with
652: */
653: public void retargetFileMenuActions(IActionBars actionBars) {
654: actionBars.setGlobalActionHandler(ActionFactory.RENAME.getId(),
655: fRenameAction);
656: actionBars.setGlobalActionHandler(ActionFactory.MOVE.getId(),
657: fMoveAction);
658: }
659:
660: /* (non-Javadoc)
661: * Method declared in ActionGroup
662: */
663: public void fillContextMenu(IMenuManager menu) {
664: super .fillContextMenu(menu);
665: addRefactorSubmenu(menu);
666: }
667:
668: /*
669: * @see ActionGroup#dispose()
670: */
671: public void dispose() {
672: ISelectionProvider provider = fSite.getSelectionProvider();
673: if (!fBinary) {
674: disposeAction(fSelfEncapsulateField, provider);
675: disposeAction(fMoveAction, provider);
676: disposeAction(fRenameAction, provider);
677: disposeAction(fModifyParametersAction, provider);
678: disposeAction(fPullUpAction, provider);
679: disposeAction(fPushDownAction, provider);
680: disposeAction(fExtractTempAction, provider);
681: disposeAction(fExtractConstantAction, provider);
682: disposeAction(fIntroduceParameterAction, provider);
683: disposeAction(fIntroduceParameterObjectAction, provider);
684: disposeAction(fIntroduceFactoryAction, provider);
685: disposeAction(fExtractMethodAction, provider);
686: // disposeAction(fReplaceInvocationsAction, provider);
687: disposeAction(fExtractInterfaceAction, provider);
688: disposeAction(fExtractClassAction, provider);
689: disposeAction(fExtractSupertypeAction, provider);
690: disposeAction(fChangeTypeAction, provider);
691: disposeAction(fConvertNestedToTopAction, provider);
692: disposeAction(fInferTypeArgumentsAction, provider);
693: disposeAction(fConvertLocalToFieldAction, provider);
694: disposeAction(fConvertAnonymousToNestedAction, provider);
695: }
696: disposeAction(fIntroduceIndirectionAction, provider);
697: disposeAction(fInlineAction, provider);
698: disposeAction(fUseSupertypeAction, provider);
699: if (fQuickAccessHandlerActivation != null
700: && fHandlerService != null) {
701: fHandlerService
702: .deactivateHandler(fQuickAccessHandlerActivation);
703: }
704: if (fUndoRedoActionGroup != null) {
705: fUndoRedoActionGroup.dispose();
706: }
707: super .dispose();
708: }
709:
710: private void disposeAction(ISelectionChangedListener action,
711: ISelectionProvider provider) {
712: if (action != null)
713: provider.removeSelectionChangedListener(action);
714: }
715:
716: private void addRefactorSubmenu(IMenuManager menu) {
717: String menuText = ActionMessages.RefactorMenu_label;
718: if (fQuickAccessAction != null) {
719: menuText = fQuickAccessAction.addShortcut(menuText);
720: }
721: IMenuManager refactorSubmenu = new MenuManager(menuText,
722: MENU_ID);
723: if (fEditor != null) {
724: IJavaElement element = SelectionConverter.getInput(fEditor);
725: if (element != null && ActionUtil.isOnBuildPath(element)) {
726: refactorSubmenu.addMenuListener(new IMenuListener() {
727: public void menuAboutToShow(IMenuManager manager) {
728: refactorMenuShown(manager);
729: }
730: });
731: refactorSubmenu.add(fNoActionAvailable);
732: menu.appendToGroup(fGroupName, refactorSubmenu);
733: }
734: } else {
735: ISelection selection = fSite.getSelectionProvider()
736: .getSelection();
737: for (Iterator iter = fActions.iterator(); iter.hasNext();) {
738: ((SelectionDispatchAction) iter.next())
739: .update(selection);
740: }
741: if (fillRefactorMenu(refactorSubmenu) > 0)
742: menu.appendToGroup(fGroupName, refactorSubmenu);
743: }
744: }
745:
746: private int fillRefactorMenu(IMenuManager refactorSubmenu) {
747: int added = 0;
748: refactorSubmenu.add(new Separator(GROUP_REORG));
749: added += addAction(refactorSubmenu, fRenameAction);
750: added += addAction(refactorSubmenu, fMoveAction);
751: refactorSubmenu.add(new Separator(GROUP_CODING));
752: added += addAction(refactorSubmenu, fModifyParametersAction);
753: added += addAction(refactorSubmenu, fExtractMethodAction);
754: added += addAction(refactorSubmenu, fExtractTempAction);
755: added += addAction(refactorSubmenu, fExtractConstantAction);
756: added += addAction(refactorSubmenu, fInlineAction);
757: refactorSubmenu.add(new Separator(GROUP_REORG2));
758: added += addAction(refactorSubmenu,
759: fConvertAnonymousToNestedAction);
760: added += addAction(refactorSubmenu, fConvertNestedToTopAction);
761: added += addAction(refactorSubmenu, fConvertLocalToFieldAction);
762: refactorSubmenu.add(new Separator(GROUP_TYPE));
763: added += addAction(refactorSubmenu, fExtractInterfaceAction);
764: added += addAction(refactorSubmenu, fExtractSupertypeAction);
765: added += addAction(refactorSubmenu, fUseSupertypeAction);
766: added += addAction(refactorSubmenu, fPullUpAction);
767: added += addAction(refactorSubmenu, fPushDownAction);
768:
769: refactorSubmenu.add(new Separator(GROUP_TYPE2));
770: added += addAction(refactorSubmenu, fExtractClassAction);
771: added += addAction(refactorSubmenu,
772: fIntroduceParameterObjectAction);
773:
774: refactorSubmenu.add(new Separator(GROUP_CODING2));
775: added += addAction(refactorSubmenu, fIntroduceIndirectionAction);
776: added += addAction(refactorSubmenu, fIntroduceFactoryAction);
777: added += addAction(refactorSubmenu, fIntroduceParameterAction);
778: added += addAction(refactorSubmenu, fSelfEncapsulateField);
779: // added+= addAction(refactorSubmenu, fReplaceInvocationsAction);
780:
781: refactorSubmenu.add(new Separator(GROUP_TYPE3));
782: added += addAction(refactorSubmenu, fChangeTypeAction);
783: added += addAction(refactorSubmenu, fInferTypeArgumentsAction);
784: return added;
785: }
786:
787: private int addAction(IMenuManager menu, IAction action) {
788: if (action != null && action.isEnabled()) {
789: menu.add(action);
790: return 1;
791: }
792: return 0;
793: }
794:
795: private void refactorMenuShown(IMenuManager refactorSubmenu) {
796: // we know that we have an MenuManager since we created it in
797: // addRefactorSubmenu.
798: Menu menu = ((MenuManager) refactorSubmenu).getMenu();
799: menu.addMenuListener(new MenuAdapter() {
800: public void menuHidden(MenuEvent e) {
801: refactorMenuHidden();
802: }
803: });
804: ITextSelection textSelection = (ITextSelection) fEditor
805: .getSelectionProvider().getSelection();
806: JavaTextSelection javaSelection = new JavaTextSelection(
807: getEditorInput(), getDocument(), textSelection
808: .getOffset(), textSelection.getLength());
809:
810: for (Iterator iter = fActions.iterator(); iter.hasNext();) {
811: SelectionDispatchAction action = (SelectionDispatchAction) iter
812: .next();
813: action.update(javaSelection);
814: }
815: refactorSubmenu.removeAll();
816: if (fillRefactorMenu(refactorSubmenu) == 0)
817: refactorSubmenu.add(fNoActionAvailable);
818: }
819:
820: private void refactorMenuHidden() {
821: ITextSelection textSelection = (ITextSelection) fEditor
822: .getSelectionProvider().getSelection();
823: for (Iterator iter = fActions.iterator(); iter.hasNext();) {
824: SelectionDispatchAction action = (SelectionDispatchAction) iter
825: .next();
826: action.update(textSelection);
827: }
828: }
829:
830: private ITypeRoot getEditorInput() {
831: return JavaUI.getEditorInputTypeRoot(fEditor.getEditorInput());
832: }
833:
834: private IDocument getDocument() {
835: return JavaPlugin.getDefault()
836: .getCompilationUnitDocumentProvider().getDocument(
837: fEditor.getEditorInput());
838: }
839:
840: private void fillQuickMenu(IMenuManager menu) {
841: if (fEditor != null) {
842: IJavaElement element = SelectionConverter.getInput(fEditor);
843: if (element == null || !ActionUtil.isOnBuildPath(element)) {
844: menu.add(fNoActionAvailable);
845: return;
846: }
847: ITextSelection textSelection = (ITextSelection) fEditor
848: .getSelectionProvider().getSelection();
849: JavaTextSelection javaSelection = new JavaTextSelection(
850: getEditorInput(), getDocument(), textSelection
851: .getOffset(), textSelection.getLength());
852:
853: for (Iterator iter = fActions.iterator(); iter.hasNext();) {
854: ((SelectionDispatchAction) iter.next())
855: .update(javaSelection);
856: }
857: fillRefactorMenu(menu);
858: for (Iterator iter = fActions.iterator(); iter.hasNext();) {
859: ((SelectionDispatchAction) iter.next())
860: .update(textSelection);
861: }
862:
863: } else {
864: ISelection selection = fSite.getSelectionProvider()
865: .getSelection();
866: for (Iterator iter = fActions.iterator(); iter.hasNext();) {
867: ((SelectionDispatchAction) iter.next())
868: .update(selection);
869: }
870: fillRefactorMenu(menu);
871: }
872: }
873: }
|