Attachment #127393 for bug #266938

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

View | Details | Raw Unified | Return to bug 266938
Collapse All | Expand All




/*******************************************************************************
 * 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.jdt.internal.ui.actions;

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

import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeItem;

import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;

import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.keys.IBindingService;

/**
 * A quick menu actions provides support to assign short cuts
 * to sub menus.
 *
 * @since 3.0
 */
public abstract class QuickMenuAction extends Action {

	private static final int CHAR_INDENT= 3;

	/**
	 * Creates a new quick menu action with the given command id.
	 *
	 * @param commandId the command id of the short cut used to open
	 *  the sub menu
	 */
	public QuickMenuAction(String commandId) {
		setActionDefinitionId(commandId);
	}

	/**
	 * {@inheritDoc}
	 */
	public void run() {
		Display display= Display.getCurrent();
		if (display == null)
			return;
		Control focus= display.getFocusControl();
		if (focus == null || focus.isDisposed())
			return;

		MenuManager menu= new MenuManager();
		fillMenu(menu);
		final Menu widget= menu.createContextMenu(focus.getShell());
		Point location= computeMenuLocation(focus, widget);
		if (location == null)
			return;
		widget.setLocation(location);
		widget.setVisible(true);
		while (!widget.isDisposed() && widget.isVisible()) {
			if (!display.readAndDispatch())
				display.sleep();
		}
		if (!widget.isDisposed()) {
			widget.dispose();
		}
	}

	/**
	 * Hook to fill a menu manager with the items of the sub menu.
	 *
	 * @param menu the sub menu to fill
	 */
	protected abstract void fillMenu(IMenuManager menu);

	/**
	 * Adds the shortcut to the given menu text and returns it.
	 *
	 * @param menuText the menu text
	 * @return the menu text with the shortcut
	 * @since 3.1
	 */
	public String addShortcut(String menuText) {
		String shortcut= getShortcutString();
		if (menuText == null || shortcut == null)
			return menuText;

		return menuText + '\t' + shortcut;
	}

	/**
	 * Returns the shortcut assigned to the sub menu or <code>null</code> if
	 * no short cut is assigned.
	 *
	 * @return the shortcut as a human readable string or <code>null</code>
	 */
	private String getShortcutString() {
		IBindingService bindingService= (IBindingService)PlatformUI.getWorkbench().getAdapter(IBindingService.class);
		if (bindingService == null)
			return null;
		return bindingService.getBestActiveBindingFormattedFor(getActionDefinitionId());
	}

	private Point computeMenuLocation(Control focus, Menu menu) {
		Point cursorLocation= focus.getDisplay().getCursorLocation();
		Rectangle clientArea= null;
		Point result= null;
		if (focus instanceof StyledText) {
			StyledText styledText= (StyledText)focus;
			clientArea= styledText.getClientArea();
			result= computeMenuLocation(styledText);
		} else if (focus instanceof Tree) {
			Tree tree= (Tree)focus;
			clientArea= tree.getClientArea();
			result= computeMenuLocation(tree);
		} else if (focus instanceof Table) {
			Table table= (Table)focus;
			clientArea= table.getClientArea();
			result= computeMenuLocation(table);
		}
		if (result == null) {
			result= focus.toControl(cursorLocation);
		}
		if (clientArea != null && !clientArea.contains(result)) {
			result= new Point(
				clientArea.x + clientArea.width  / 2,
				clientArea.y + clientArea.height / 2);
		}
		Rectangle shellArea= focus.getShell().getClientArea();
		if (!shellArea.contains(focus.getShell().toControl(focus.toDisplay(result)))) {
			result= new Point(
				shellArea.x + shellArea.width  / 2,
				shellArea.y + shellArea.height / 2);
		}
		return focus.toDisplay(result);
	}

	/**
	 * Hook to compute the menu location if the focus widget is
	 * a styled text widget.
	 *
	 * @param text the styled text widget that has the focus
	 *
	 * @return a widget relative position of the menu to pop up or
	 *  <code>null</code> if now position inside the widget can
	 *  be computed
	 */
	protected Point computeMenuLocation(StyledText text) {
		int offset= text.getCaretOffset();
		Point result= text.getLocationAtOffset(offset);
		result.y+= text.getLineHeight(offset);
		if (!text.getClientArea().contains(result))
			return null;
		return result;
	}

	/**
	 * Hook to compute the menu location if the focus widget is
	 * a tree widget.
	 *
	 * @param tree the tree widget that has the focus
	 *
	 * @return a widget relative position of the menu to pop up or
	 *  <code>null</code> if now position inside the widget can
	 *  be computed
	 */
	protected Point computeMenuLocation(Tree tree) {
		TreeItem[] items= tree.getSelection();
		Rectangle clientArea= tree.getClientArea();
		switch (items.length) {
			case 0:
				return null;
			case 1:
				Rectangle bounds= items[0].getBounds();
				Rectangle intersect= clientArea.intersection(bounds);
				if (intersect != null && intersect.height == bounds.height) {
					return new Point(
						Math.max(0, bounds.x + getAvarageCharWith(tree) * CHAR_INDENT),
						bounds.y + bounds.height);
				} else {
					return null;
				}
			default:
				Rectangle[] rectangles= new Rectangle[items.length];
				for (int i= 0; i < rectangles.length; i++) {
					rectangles[i]= items[i].getBounds();
				}
				Point cursorLocation= tree.getDisplay().getCursorLocation();
				Point result= findBestLocation(getIncludedPositions(rectangles, clientArea),
					tree.toControl(cursorLocation));
				if (result != null)
					result.x= result.x + getAvarageCharWith(tree) * CHAR_INDENT;
				return result;
		}
	}

	/**
	 * Hook to compute the menu location if the focus widget is
	 * a table widget.
	 *
	 * @param table the table widget that has the focus
	 *
	 * @return a widget relative position of the menu to pop up or
	 *  <code>null</code> if now position inside the widget can
	 *  be computed
	 */
	protected Point computeMenuLocation(Table table) {
		TableItem[] items= table.getSelection();
		Rectangle clientArea= table.getClientArea();
		switch (items.length) {
			case 0: {
				return null;
			} case 1: {
				Rectangle bounds= items[0].getBounds(0);
				Rectangle iBounds= items[0].getImageBounds(0);
				Rectangle intersect= clientArea.intersection(bounds);
				if (intersect != null && intersect.height == bounds.height) {
					return new Point(
						Math.max(0, bounds.x + iBounds.width + getAvarageCharWith(table) * CHAR_INDENT),
						bounds.y + bounds.height);
				} else {
					return null;
				}
			} default: {
				Rectangle[] rectangles= new Rectangle[items.length];
				for (int i= 0; i < rectangles.length; i++) {
					rectangles[i]= items[i].getBounds(0);
				}
				Rectangle iBounds= items[0].getImageBounds(0);
				Point cursorLocation= table.getDisplay().getCursorLocation();
				Point result= findBestLocation(getIncludedPositions(rectangles, clientArea),
					table.toControl(cursorLocation));
				if (result != null)
					result.x= result.x + iBounds.width + getAvarageCharWith(table) * CHAR_INDENT;
				return result;
			}
		}
	}

	private Point[] getIncludedPositions(Rectangle[] rectangles, Rectangle widgetBounds) {
		List result= new ArrayList();
		for (int i= 0; i < rectangles.length; i++) {
			Rectangle rectangle= rectangles[i];
			Rectangle intersect= widgetBounds.intersection(rectangle);
			if (intersect != null && intersect.height == rectangle.height) {
				result.add(new Point(intersect.x, intersect.y + intersect.height));
			}
		}
		return (Point[]) result.toArray(new Point[result.size()]);
	}

	private Point findBestLocation(Point[] points, Point relativeCursor) {
		Point result= null;
		double bestDist= Double.MAX_VALUE;
		for (int i= 0; i < points.length; i++) {
			Point point= points[i];
			int a= 0;
			int b= 0;
			if (point.x > relativeCursor.x) {
				a= point.x - relativeCursor.x;
			} else {
				a= relativeCursor.x - point.x;
			}
			if (point.y > relativeCursor.y) {
				b= point.y - relativeCursor.y;
			} else {
				b= relativeCursor.y - point.y;
			}
			double dist= Math.sqrt(a * a + b * b);
			if (dist < bestDist) {
				result= point;
				bestDist= dist;
			}
		}
		return result;
	}

	private int getAvarageCharWith(Control control) {
		GC gc= null;
		try {
			gc= new GC(control);
			return gc.getFontMetrics().getAverageCharWidth();
		} finally {
			if (gc != null)
				gc.dispose();
		}
	}
}

Lines 33-39 Link Here

(-)ui/org/eclipse/jdt/internal/ui/actions/WorkbenchRunnableAdapter.java (-2 / +9 lines)
33		33
34	/**	34	/**
35	* An {@link IRunnableWithProgress} that adapts an {@link IWorkspaceRunnable} so that is can be	35	* An {@link IRunnableWithProgress} that adapts an {@link IWorkspaceRunnable} so that is can be
36	* executed inside an {@link IRunnableContext}.	36	* executed inside an {@link IRunnableContext}. The runnable is run as an
		37	* {@linkplain JavaCore#run(IWorkspaceRunnable, ISchedulingRule, IProgressMonitor) atomic Java model operation}.
37	* <p>	38	* <p>
38	* {@link OperationCanceledException}s thrown by the	39	* {@link OperationCanceledException}s thrown by the
39	* adapted runnable are caught and re-thrown as {@link InterruptedException}s.	40	* adapted runnable are caught and re-thrown as {@link InterruptedException}s.
Lines 71-77 Link Here
71	*	72	*
72	* @param runnable the runnable	73	* @param runnable the runnable
73	* @param rule the scheduling rule, or <code>null</code>	74	* @param rule the scheduling rule, or <code>null</code>
74	* @param transfer <code>true</code> iff the rule is to be transfered to the model context	75	* @param transfer <code>true</code> iff the rule is to be transfered to the modal context
75	* thread	76	* thread
76	*/	77	*/
77	public WorkbenchRunnableAdapter(IWorkspaceRunnable runnable, ISchedulingRule rule, boolean transfer) {	78	public WorkbenchRunnableAdapter(IWorkspaceRunnable runnable, ISchedulingRule rule, boolean transfer) {
Lines 80-85 Link Here
80	fTransfer= transfer;	81	fTransfer= transfer;
81	}	82	}
82		83
		84	/**
		85	* Returns the scheduling rule, or <code>null</code> if none.
		86	*
		87	* @return the scheduling rule, or <code>null</code> if none
		88	* @since 3.5
		89	*/
83	public ISchedulingRule getSchedulingRule() {	90	public ISchedulingRule getSchedulingRule() {
84	return fRule;	91	return fRule;
85	}	92	}




/*******************************************************************************
 * 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.jdt.internal.ui.actions;

import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.graphics.Point;

import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.text.ITextViewerExtension5;
import org.eclipse.jface.text.Region;
import org.eclipse.jface.text.source.ISourceViewer;

import org.eclipse.jdt.internal.ui.javaeditor.JavaEditor;
import org.eclipse.jdt.internal.ui.text.JavaWordFinder;


public abstract class JDTQuickMenuAction extends QuickMenuAction {

	private JavaEditor fEditor;

	public JDTQuickMenuAction(String commandId) {
		super(commandId);
	}

	public JDTQuickMenuAction(JavaEditor editor, String commandId) {
		super(commandId);
		fEditor= editor;
	}

	protected JavaEditor getJavaEditor() {
		return fEditor;
	}

	protected Point computeMenuLocation(StyledText text) {
		if (fEditor == null || text != fEditor.getViewer().getTextWidget())
			return null;
		return computeWordStart();
	}

	private Point computeWordStart() {
		ITextSelection selection= (ITextSelection)fEditor.getSelectionProvider().getSelection();
		IRegion textRegion= JavaWordFinder.findWord(fEditor.getViewer().getDocument(), selection.getOffset());
		if (textRegion == null)
			return null;

		IRegion widgetRegion= modelRange2WidgetRange(textRegion);
		if (widgetRegion == null)
			return null;

		int start= widgetRegion.getOffset();

		StyledText styledText= fEditor.getViewer().getTextWidget();
		Point result= styledText.getLocationAtOffset(start);
		result.y+= styledText.getLineHeight(start);

		if (!styledText.getClientArea().contains(result))
			return null;
		return result;
	}

	private IRegion modelRange2WidgetRange(IRegion region) {
		ISourceViewer viewer= fEditor.getViewer();
		if (viewer instanceof ITextViewerExtension5) {
			ITextViewerExtension5 extension= (ITextViewerExtension5)viewer;
			return extension.modelRange2WidgetRange(region);
		}

		IRegion visibleRegion= viewer.getVisibleRegion();
		int start= region.getOffset() - visibleRegion.getOffset();
		int end= start + region.getLength();
		if (end > visibleRegion.getLength())
			end= visibleRegion.getLength();

		return new Region(start, end - start);
	}
}




/*******************************************************************************
 * 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 v1.0
 * which accompanies this distribution, and is available at

		if (activeActions.size() == 1) {
			((IAction) activeActions.get(0)).run();
		} else {
			new JDTQuickMenuCreator(editor) {
				protected void fillMenu(IMenuManager menu) {
					fillQuickMenu(menu, activeActions);
				}
			}.createMenu();
		}
	}





/*******************************************************************************
 * 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 v1.0
 * which accompanies this distribution, and is available at


		final CompilationUnitEditor editor= (CompilationUnitEditor)activePart;

		new JDTQuickMenuCreator(editor) {
			protected void fillMenu(IMenuManager menu) {
				SurroundWithTryCatchAction surroundWithTryCatch= createSurroundWithTryCatchAction(editor);
				SurroundWithTemplateMenuAction.fillMenu(menu, editor, surroundWithTryCatch);
			}
		}.createMenu();
	}

	/**




/*******************************************************************************
 * 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 v1.0
 * which accompanies this distribution, and is available at

import org.eclipse.jface.text.ITextSelection;

import org.eclipse.ui.IActionBars;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.actions.ActionGroup;
import org.eclipse.ui.keys.IBindingService;

import org.eclipse.jdt.ui.actions.IJavaEditorActionDefinitionIds;
import org.eclipse.jdt.ui.actions.JdtActionConstants;


		String menuText= ActionMessages.SurroundWithTemplateMenuAction_SurroundWithTemplateSubMenuName;

		String shortcutString= getShortcutString();
		if (shortcutString != null) {
			menuText= menuText + '\t' + shortcutString;
		}

		MenuManager subMenu = new MenuManager(menuText, SurroundWithTemplateMenuAction.SURROUND_WITH_QUICK_MENU_ACTION_ID);
		subMenu.setActionDefinitionId(SurroundWithTemplateMenuAction.SURROUND_WITH_QUICK_MENU_ACTION_ID);
		menu.appendToGroup(fGroup, subMenu);
		subMenu.add(new Action() {});
		subMenu.addMenuListener(new IMenuListener() {

		});
	}

	private String getShortcutString() {
		IBindingService bindingService= (IBindingService)PlatformUI.getWorkbench().getAdapter(IBindingService.class);
		if (bindingService == null)
			return null;
		return bindingService.getBestActiveBindingFormattedFor(SurroundWithTemplateMenuAction.SURROUND_WITH_QUICK_MENU_ACTION_ID);
	}

	private static SurroundWithTryCatchAction createSurroundWithTryCatchAction(CompilationUnitEditor editor) {
		SurroundWithTryCatchAction result= new SurroundWithTryCatchAction(editor);
		result.setText(ActionMessages.SurroundWithTemplateMenuAction_SurroundWithTryCatchActionName);




/*******************************************************************************
 * 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 v1.0
 * which accompanies this distribution, and is available at


import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IWorkbenchSite;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.actions.ActionGroup;
import org.eclipse.ui.keys.IBindingService;

import org.eclipse.ui.texteditor.ITextEditorActionConstants;


	 */
	public void fillContextMenu(IMenuManager manager) {
		String menuText= SearchMessages.group_occurrences;
		String shortcut= getShortcutString();
		if (shortcut != null) {
			menuText= menuText + '\t' + shortcut;
		}

		MenuManager javaSearchMM= new MenuManager(menuText, IContextMenuConstants.GROUP_SEARCH);
		javaSearchMM.setActionDefinitionId(IJavaEditorActionDefinitionIds.SEARCH_OCCURRENCES_IN_FILE_QUICK_MENU);
		javaSearchMM.add(new Action() {
		});
		javaSearchMM.addMenuListener(new IMenuListener() {

		fMethodExitOccurrencesAction.update(javaSelection);
	}

	private String getShortcutString() {
		IBindingService bindingService= (IBindingService)PlatformUI.getWorkbench().getAdapter(IBindingService.class);
		if (bindingService == null)
			return null;
		return bindingService.getBestActiveBindingFormattedFor(IJavaEditorActionDefinitionIds.SEARCH_OCCURRENCES_IN_FILE_QUICK_MENU);
	}

	/*
	 * Method declared on ActionGroup.
	 */




/*******************************************************************************
 * 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 v1.0
 * which accompanies this distribution, and is available at

import org.eclipse.swt.events.MenuEvent;
import org.eclipse.swt.widgets.Menu;

import org.eclipse.core.commands.IHandler;
import org.eclipse.core.commands.operations.IUndoContext;

import org.eclipse.core.runtime.PerformanceStats;

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.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ISelectionProvider;

import org.eclipse.jdt.internal.ui.actions.ActionUtil;
import org.eclipse.jdt.internal.ui.actions.ExtractSuperClassAction;
import org.eclipse.jdt.internal.ui.actions.IntroduceParameterObjectAction;
import org.eclipse.jdt.internal.ui.actions.JDTQuickMenuCreator;
import org.eclipse.jdt.internal.ui.javaeditor.JavaEditor;
import org.eclipse.jdt.internal.ui.javaeditor.JavaTextSelection;
import org.eclipse.jdt.internal.ui.refactoring.RefactoringMessages;


	private static final String QUICK_MENU_ID= "org.eclipse.jdt.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 void installQuickAccessAction() {
		fHandlerService= (IHandlerService)fSite.getService(IHandlerService.class);
		if (fHandlerService != null) {
			IHandler handler= new JDTQuickMenuCreator(fEditor) {
				protected void fillMenu(IMenuManager menu) {
					fillQuickMenu(menu);
				}
			}.createHandler();
			fQuickAccessHandlerActivation= fHandlerService.activateHandler(QUICK_MENU_ID, handler);
		}
	}


	}

	private void addRefactorSubmenu(IMenuManager menu) {
		MenuManager refactorSubmenu= new MenuManager(ActionMessages.RefactorMenu_label, MENU_ID);
		refactorSubmenu.setActionDefinitionId(QUICK_MENU_ID);
			menuText= fQuickAccessAction.addShortcut(menuText);
		}
		IMenuManager refactorSubmenu= new MenuManager(menuText, MENU_ID);
		if (fEditor != null) {
			final ITypeRoot element= getEditorInput();
			if (element != null && ActionUtil.isOnBuildPath(element)) {

Lines 1-5 Link Here

(-)ui/org/eclipse/jdt/ui/actions/GenerateActionGroup.java (-20 / +12 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 14-26 Link Here
14	import java.util.Iterator;	14	import java.util.Iterator;
15	import java.util.List;	15	import java.util.List;
16		16
		17	import org.eclipse.core.commands.IHandler;
		18
17	import org.eclipse.core.runtime.Assert;	19	import org.eclipse.core.runtime.Assert;
18		20
19	import org.eclipse.jface.action.IAction;	21	import org.eclipse.jface.action.IAction;
20	import org.eclipse.jface.action.IMenuManager;	22	import org.eclipse.jface.action.IMenuManager;
21	import org.eclipse.jface.action.MenuManager;	23	import org.eclipse.jface.action.MenuManager;
22	import org.eclipse.jface.action.Separator;	24	import org.eclipse.jface.action.Separator;
23	import org.eclipse.jface.commands.ActionHandler;
24	import org.eclipse.jface.viewers.ISelection;	25	import org.eclipse.jface.viewers.ISelection;
25	import org.eclipse.jface.viewers.ISelectionChangedListener;	26	import org.eclipse.jface.viewers.ISelectionChangedListener;
26	import org.eclipse.jface.viewers.ISelectionProvider;	27	import org.eclipse.jface.viewers.ISelectionProvider;
Lines 45-51 Link Here
45	import org.eclipse.jdt.internal.ui.actions.AddTaskAction;	46	import org.eclipse.jdt.internal.ui.actions.AddTaskAction;
46	import org.eclipse.jdt.internal.ui.actions.AllCleanUpsAction;	47	import org.eclipse.jdt.internal.ui.actions.AllCleanUpsAction;
47	import org.eclipse.jdt.internal.ui.actions.FindBrokenNLSKeysAction;	48	import org.eclipse.jdt.internal.ui.actions.FindBrokenNLSKeysAction;
48	import org.eclipse.jdt.internal.ui.actions.JDTQuickMenuAction;	49	import org.eclipse.jdt.internal.ui.actions.JDTQuickMenuCreator;
49	import org.eclipse.jdt.internal.ui.actions.MultiSortMembersAction;	50	import org.eclipse.jdt.internal.ui.actions.MultiSortMembersAction;
50	import org.eclipse.jdt.internal.ui.javaeditor.AddImportOnSelectionAction;	51	import org.eclipse.jdt.internal.ui.javaeditor.AddImportOnSelectionAction;
51	import org.eclipse.jdt.internal.ui.javaeditor.CompilationUnitEditor;	52	import org.eclipse.jdt.internal.ui.javaeditor.CompilationUnitEditor;
Lines 144-159 Link Here
144		145
145	private static final String QUICK_MENU_ID= "org.eclipse.jdt.ui.edit.text.java.source.quickMenu"; //$NON-NLS-1$	146	private static final String QUICK_MENU_ID= "org.eclipse.jdt.ui.edit.text.java.source.quickMenu"; //$NON-NLS-1$
146		147
147	private class SourceQuickAccessAction extends JDTQuickMenuAction {
148	public SourceQuickAccessAction(CompilationUnitEditor editor) {
149	super(editor, QUICK_MENU_ID);
150	}
151	protected void fillMenu(IMenuManager menu) {
152	fillQuickMenu(menu);
153	}
154	}
155
156	private JDTQuickMenuAction fQuickAccessAction;
157	private IHandlerActivation fQuickAccessHandlerActivation;	148	private IHandlerActivation fQuickAccessHandlerActivation;
158	private IHandlerService fHandlerService;	149	private IHandlerService fHandlerService;
159		150
Lines 368-375 Link Here
368	private void installQuickAccessAction() {	359	private void installQuickAccessAction() {
369	fHandlerService= (IHandlerService)fSite.getService(IHandlerService.class);	360	fHandlerService= (IHandlerService)fSite.getService(IHandlerService.class);
370	if (fHandlerService != null) {	361	if (fHandlerService != null) {
371	fQuickAccessAction= new SourceQuickAccessAction(fEditor);	362	IHandler handler= new JDTQuickMenuCreator(fEditor) {
372	fQuickAccessHandlerActivation= fHandlerService.activateHandler(fQuickAccessAction.getActionDefinitionId(), new ActionHandler(fQuickAccessAction));	363	protected void fillMenu(IMenuManager menu) {
		364	fillQuickMenu(menu);
		365	}
		366	}.createHandler();
		367	fQuickAccessHandlerActivation= fHandlerService.activateHandler(QUICK_MENU_ID, handler);
373	}	368	}
374	}	369	}
375		370
Lines 408-418 Link Here
408	*/	403	*/
409	public void fillContextMenu(IMenuManager menu) {	404	public void fillContextMenu(IMenuManager menu) {
410	super.fillContextMenu(menu);	405	super.fillContextMenu(menu);
411	String menuText= ActionMessages.SourceMenu_label;	406	MenuManager subMenu= new MenuManager(ActionMessages.SourceMenu_label, MENU_ID);
412	if (fQuickAccessAction != null) {	407	subMenu.setActionDefinitionId(QUICK_MENU_ID);
413	menuText= fQuickAccessAction.addShortcut(menuText);
414	}
415	IMenuManager subMenu= new MenuManager(menuText, MENU_ID);
416	int added= 0;	408	int added= 0;
417	if (isEditorOwner()) {	409	if (isEditorOwner()) {
418	added= fillEditorSubMenu(subMenu);	410	added= fillEditorSubMenu(subMenu);




/*******************************************************************************
 * Copyright (c) 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 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.jdt.internal.ui.actions;

import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.graphics.Point;

import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.IHandler;

import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.text.ITextViewerExtension5;
import org.eclipse.jface.text.Region;
import org.eclipse.jface.text.source.ISourceViewer;

import org.eclipse.ui.actions.QuickMenuCreator;

import org.eclipse.jdt.internal.ui.javaeditor.JavaEditor;
import org.eclipse.jdt.internal.ui.text.JavaWordFinder;

/**
 * Java editor aware quick menu creator. In the given editor, the menu will be aligned with the word
 * at the current offset.
 * 
 * @since 3.5
 */
public abstract class JDTQuickMenuCreator extends QuickMenuCreator {

	private final JavaEditor fEditor;

	public JDTQuickMenuCreator(JavaEditor editor) {
		fEditor= editor;
	}

	protected Point computeMenuLocation(StyledText text) {
		if (fEditor == null || text != fEditor.getViewer().getTextWidget())
			return super.computeMenuLocation(text);
		return computeWordStart();
	}

	private Point computeWordStart() {
		ITextSelection selection= (ITextSelection)fEditor.getSelectionProvider().getSelection();
		IRegion textRegion= JavaWordFinder.findWord(fEditor.getViewer().getDocument(), selection.getOffset());
		if (textRegion == null)
			return null;

		IRegion widgetRegion= modelRange2WidgetRange(textRegion);
		if (widgetRegion == null)
			return null;

		int start= widgetRegion.getOffset();

		StyledText styledText= fEditor.getViewer().getTextWidget();
		Point result= styledText.getLocationAtOffset(start);
		result.y+= styledText.getLineHeight(start);

		if (!styledText.getClientArea().contains(result))
			return null;
		return result;
	}

	private IRegion modelRange2WidgetRange(IRegion region) {
		ISourceViewer viewer= fEditor.getViewer();
		if (viewer instanceof ITextViewerExtension5) {
			ITextViewerExtension5 extension= (ITextViewerExtension5)viewer;
			return extension.modelRange2WidgetRange(region);
		}

		IRegion visibleRegion= viewer.getVisibleRegion();
		int start= region.getOffset() - visibleRegion.getOffset();
		int end= start + region.getLength();
		if (end > visibleRegion.getLength())
			end= visibleRegion.getLength();

		return new Region(start, end - start);
	}

	public IHandler createHandler() {
		return new AbstractHandler() {
			public Object execute(ExecutionEvent event) throws ExecutionException {
				createMenu();
				return null;
			}
		};
	}

}

Return to bug 266938

Lines 1-5 Link Here

(-)ui/org/eclipse/jdt/internal/ui/actions/OccurrencesSearchMenuAction.java (-3 / +3 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 189-199 Link Here
189	if (activeActions.size() == 1) {	189	if (activeActions.size() == 1) {
190	((IAction) activeActions.get(0)).run();	190	((IAction) activeActions.get(0)).run();
191	} else {	191	} else {
192	(new JDTQuickMenuAction(editor, IJavaEditorActionDefinitionIds.SEARCH_OCCURRENCES_IN_FILE_QUICK_MENU) {	192	new JDTQuickMenuCreator(editor) {
193	protected void fillMenu(IMenuManager menu) {	193	protected void fillMenu(IMenuManager menu) {
194	fillQuickMenu(menu, activeActions);	194	fillQuickMenu(menu, activeActions);
195	}	195	}
196	}).run();	196	}.createMenu();
197	}	197	}
198	}	198	}
199		199

Lines 1-5 Link Here

(-)ui/org/eclipse/jdt/internal/ui/actions/SurroundWithTemplateMenuAction.java (-3 / +3 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 220-231 Link Here
220		220
221	final CompilationUnitEditor editor= (CompilationUnitEditor)activePart;	221	final CompilationUnitEditor editor= (CompilationUnitEditor)activePart;
222		222
223	(new JDTQuickMenuAction(editor, SURROUND_WITH_QUICK_MENU_ACTION_ID) {	223	new JDTQuickMenuCreator(editor) {
224	protected void fillMenu(IMenuManager menu) {	224	protected void fillMenu(IMenuManager menu) {
225	SurroundWithTryCatchAction surroundWithTryCatch= createSurroundWithTryCatchAction(editor);	225	SurroundWithTryCatchAction surroundWithTryCatch= createSurroundWithTryCatchAction(editor);
226	SurroundWithTemplateMenuAction.fillMenu(menu, editor, surroundWithTryCatch);	226	SurroundWithTemplateMenuAction.fillMenu(menu, editor, surroundWithTryCatch);
227	}	227	}
228	}).run();	228	}.createMenu();
229	}	229	}
230		230
231	/**	231	/**

Lines 1-5 Link Here

(-)ui/org/eclipse/jdt/ui/actions/OccurrencesSearchGroup.java (-15 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 26-34 Link Here
26		26
27	import org.eclipse.ui.IActionBars;	27	import org.eclipse.ui.IActionBars;
28	import org.eclipse.ui.IWorkbenchSite;	28	import org.eclipse.ui.IWorkbenchSite;
29	import org.eclipse.ui.PlatformUI;
30	import org.eclipse.ui.actions.ActionGroup;	29	import org.eclipse.ui.actions.ActionGroup;
31	import org.eclipse.ui.keys.IBindingService;
32		30
33	import org.eclipse.ui.texteditor.ITextEditorActionConstants;	31	import org.eclipse.ui.texteditor.ITextEditorActionConstants;
34		32
Lines 177-188 Link Here
177	*/	175	*/
178	public void fillContextMenu(IMenuManager manager) {	176	public void fillContextMenu(IMenuManager manager) {
179	String menuText= SearchMessages.group_occurrences;	177	String menuText= SearchMessages.group_occurrences;
180	String shortcut= getShortcutString();
181	if (shortcut != null) {
182	menuText= menuText + '\t' + shortcut;
183	}
184
185	MenuManager javaSearchMM= new MenuManager(menuText, IContextMenuConstants.GROUP_SEARCH);	178	MenuManager javaSearchMM= new MenuManager(menuText, IContextMenuConstants.GROUP_SEARCH);
		179	javaSearchMM.setActionDefinitionId(IJavaEditorActionDefinitionIds.SEARCH_OCCURRENCES_IN_FILE_QUICK_MENU);
186	javaSearchMM.add(new Action() {	180	javaSearchMM.add(new Action() {
187	});	181	});
188	javaSearchMM.addMenuListener(new IMenuListener() {	182	javaSearchMM.addMenuListener(new IMenuListener() {
Lines 230-242 Link Here
230	fMethodExitOccurrencesAction.update(javaSelection);	224	fMethodExitOccurrencesAction.update(javaSelection);
231	}	225	}
232		226
233	private String getShortcutString() {
234	IBindingService bindingService= (IBindingService)PlatformUI.getWorkbench().getAdapter(IBindingService.class);
235	if (bindingService == null)
236	return null;
237	return bindingService.getBestActiveBindingFormattedFor(IJavaEditorActionDefinitionIds.SEARCH_OCCURRENCES_IN_FILE_QUICK_MENU);
238	}
239
240	/*	227	/*
241	* Method declared on ActionGroup.	228	* Method declared on ActionGroup.
242	*/	229	*/

Lines 1-5 Link Here

(-)ui/org/eclipse/jdt/ui/actions/RefactorActionGroup.java (-20 / +11 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 18-23 Link Here
18	import org.eclipse.swt.events.MenuEvent;	18	import org.eclipse.swt.events.MenuEvent;
19	import org.eclipse.swt.widgets.Menu;	19	import org.eclipse.swt.widgets.Menu;
20		20
		21	import org.eclipse.core.commands.IHandler;
21	import org.eclipse.core.commands.operations.IUndoContext;	22	import org.eclipse.core.commands.operations.IUndoContext;
22		23
23	import org.eclipse.core.runtime.PerformanceStats;	24	import org.eclipse.core.runtime.PerformanceStats;
Lines 30-36 Link Here
30	import org.eclipse.jface.action.IMenuManager;	31	import org.eclipse.jface.action.IMenuManager;
31	import org.eclipse.jface.action.MenuManager;	32	import org.eclipse.jface.action.MenuManager;
32	import org.eclipse.jface.action.Separator;	33	import org.eclipse.jface.action.Separator;
33	import org.eclipse.jface.commands.ActionHandler;
34	import org.eclipse.jface.viewers.ISelection;	34	import org.eclipse.jface.viewers.ISelection;
35	import org.eclipse.jface.viewers.ISelectionChangedListener;	35	import org.eclipse.jface.viewers.ISelectionChangedListener;
36	import org.eclipse.jface.viewers.ISelectionProvider;	36	import org.eclipse.jface.viewers.ISelectionProvider;
Lines 58-64 Link Here
58	import org.eclipse.jdt.internal.ui.actions.ActionUtil;	58	import org.eclipse.jdt.internal.ui.actions.ActionUtil;
59	import org.eclipse.jdt.internal.ui.actions.ExtractSuperClassAction;	59	import org.eclipse.jdt.internal.ui.actions.ExtractSuperClassAction;
60	import org.eclipse.jdt.internal.ui.actions.IntroduceParameterObjectAction;	60	import org.eclipse.jdt.internal.ui.actions.IntroduceParameterObjectAction;
61	import org.eclipse.jdt.internal.ui.actions.JDTQuickMenuAction;	61	import org.eclipse.jdt.internal.ui.actions.JDTQuickMenuCreator;
62	import org.eclipse.jdt.internal.ui.javaeditor.JavaEditor;	62	import org.eclipse.jdt.internal.ui.javaeditor.JavaEditor;
63	import org.eclipse.jdt.internal.ui.javaeditor.JavaTextSelection;	63	import org.eclipse.jdt.internal.ui.javaeditor.JavaTextSelection;
64	import org.eclipse.jdt.internal.ui.refactoring.RefactoringMessages;	64	import org.eclipse.jdt.internal.ui.refactoring.RefactoringMessages;
Lines 180-195 Link Here
180		180
181	private static final String QUICK_MENU_ID= "org.eclipse.jdt.ui.edit.text.java.refactor.quickMenu"; //$NON-NLS-1$	181	private static final String QUICK_MENU_ID= "org.eclipse.jdt.ui.edit.text.java.refactor.quickMenu"; //$NON-NLS-1$
182		182
183	private class RefactorQuickAccessAction extends JDTQuickMenuAction {
184	public RefactorQuickAccessAction(JavaEditor editor) {
185	super(editor, QUICK_MENU_ID);
186	}
187	protected void fillMenu(IMenuManager menu) {
188	fillQuickMenu(menu);
189	}
190	}
191
192	private JDTQuickMenuAction fQuickAccessAction;
193	private IHandlerActivation fQuickAccessHandlerActivation;	183	private IHandlerActivation fQuickAccessHandlerActivation;
194	private IHandlerService fHandlerService;	184	private IHandlerService fHandlerService;
195		185
Lines 438-445 Link Here
438	private void installQuickAccessAction() {	428	private void installQuickAccessAction() {
439	fHandlerService= (IHandlerService)fSite.getService(IHandlerService.class);	429	fHandlerService= (IHandlerService)fSite.getService(IHandlerService.class);
440	if (fHandlerService != null) {	430	if (fHandlerService != null) {
441	fQuickAccessAction= new RefactorQuickAccessAction(fEditor);	431	IHandler handler= new JDTQuickMenuCreator(fEditor) {
442	fQuickAccessHandlerActivation= fHandlerService.activateHandler(fQuickAccessAction.getActionDefinitionId(), new ActionHandler(fQuickAccessAction));	432	protected void fillMenu(IMenuManager menu) {
		433	fillQuickMenu(menu);
		434	}
		435	}.createHandler();
		436	fQuickAccessHandlerActivation= fHandlerService.activateHandler(QUICK_MENU_ID, handler);
443	}	437	}
444	}	438	}
445		439
Lines 566-576 Link Here
566	}	560	}
567		561
568	private void addRefactorSubmenu(IMenuManager menu) {	562	private void addRefactorSubmenu(IMenuManager menu) {
569	String menuText= ActionMessages.RefactorMenu_label;	563	MenuManager refactorSubmenu= new MenuManager(ActionMessages.RefactorMenu_label, MENU_ID);
570	if (fQuickAccessAction != null) {	564	refactorSubmenu.setActionDefinitionId(QUICK_MENU_ID);
571	menuText= fQuickAccessAction.addShortcut(menuText);
572	}
573	IMenuManager refactorSubmenu= new MenuManager(menuText, MENU_ID);
574	if (fEditor != null) {	565	if (fEditor != null) {
575	final ITypeRoot element= getEditorInput();	566	final ITypeRoot element= getEditorInput();
576	if (element != null && ActionUtil.isOnBuildPath(element)) {	567	if (element != null && ActionUtil.isOnBuildPath(element)) {

Added Link Here

(-)ui/org/eclipse/jdt/internal/ui/actions/JDTQuickMenuCreator.java (+98 lines)
1	/*******************************************************************************
2	* Copyright (c) 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jdt.internal.ui.actions;
12
13	import org.eclipse.swt.custom.StyledText;
14	import org.eclipse.swt.graphics.Point;
15
16	import org.eclipse.core.commands.AbstractHandler;
17	import org.eclipse.core.commands.ExecutionEvent;
18	import org.eclipse.core.commands.ExecutionException;
19	import org.eclipse.core.commands.IHandler;
20
21	import org.eclipse.jface.text.IRegion;
22	import org.eclipse.jface.text.ITextSelection;
23	import org.eclipse.jface.text.ITextViewerExtension5;
24	import org.eclipse.jface.text.Region;
25	import org.eclipse.jface.text.source.ISourceViewer;
26
27	import org.eclipse.ui.actions.QuickMenuCreator;
28
29	import org.eclipse.jdt.internal.ui.javaeditor.JavaEditor;
30	import org.eclipse.jdt.internal.ui.text.JavaWordFinder;
31
32	/**
33	* Java editor aware quick menu creator. In the given editor, the menu will be aligned with the word
34	* at the current offset.
35	*
36	* @since 3.5
37	*/
38	public abstract class JDTQuickMenuCreator extends QuickMenuCreator {
39
40	private final JavaEditor fEditor;
41
42	public JDTQuickMenuCreator(JavaEditor editor) {
43	fEditor= editor;
44	}
45
46	protected Point computeMenuLocation(StyledText text) {
47	if (fEditor == null \|\| text != fEditor.getViewer().getTextWidget())
48	return super.computeMenuLocation(text);
49	return computeWordStart();
50	}
51
52	private Point computeWordStart() {
53	ITextSelection selection= (ITextSelection)fEditor.getSelectionProvider().getSelection();
54	IRegion textRegion= JavaWordFinder.findWord(fEditor.getViewer().getDocument(), selection.getOffset());
55	if (textRegion == null)
56	return null;
57
58	IRegion widgetRegion= modelRange2WidgetRange(textRegion);
59	if (widgetRegion == null)
60	return null;
61
62	int start= widgetRegion.getOffset();
63
64	StyledText styledText= fEditor.getViewer().getTextWidget();
65	Point result= styledText.getLocationAtOffset(start);
66	result.y+= styledText.getLineHeight(start);
67
68	if (!styledText.getClientArea().contains(result))
69	return null;
70	return result;
71	}
72
73	private IRegion modelRange2WidgetRange(IRegion region) {
74	ISourceViewer viewer= fEditor.getViewer();
75	if (viewer instanceof ITextViewerExtension5) {
76	ITextViewerExtension5 extension= (ITextViewerExtension5)viewer;
77	return extension.modelRange2WidgetRange(region);
78	}
79
80	IRegion visibleRegion= viewer.getVisibleRegion();
81	int start= region.getOffset() - visibleRegion.getOffset();
82	int end= start + region.getLength();
83	if (end > visibleRegion.getLength())
84	end= visibleRegion.getLength();
85
86	return new Region(start, end - start);
87	}
88
89	public IHandler createHandler() {
90	return new AbstractHandler() {
91	public Object execute(ExecutionEvent event) throws ExecutionException {
92	createMenu();
93	return null;
94	}
95	};
96	}
97
98	}