Attachment #27092 for bug #109468

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




		<extension-point id="dragSourceTransfers" name="Drag Source Transfers"/>
	-->
	<extension point="org.eclipse.ui.commands">
		<scope
			name="%scope.structuredTextEditor.name"
			parent="org.eclipse.ui.textEditorScope"
			description="%scope.structuredTextEditor.description"
			id="org.eclipse.wst.sse.ui.structuredTextEditorScope">
		</scope>
		<!--    dmw 6/6 (and 11/10 :) removed from 'scope'  parentId="org.eclipse.ui.textEditorScope" -->
		<!-- afw 11/11 added scope back in because these are keybindings for structuredtexteditors only -->

		<!-- Edit commands -->
		<command
			name="%ActionDefinition.selectEnclosing.name"
			description="%ActionDefinition.selectEnclosing.description"
			categoryId="org.eclipse.ui.category.edit"
			id="org.eclipse.wst.sse.ui.structure.select.enclosing">
		</command>
		<command
			name="%ActionDefinition.selectNext.name"
			description="%ActionDefinition.selectNext.description"
			categoryId="org.eclipse.ui.category.edit"
			id="org.eclipse.wst.sse.ui.structure.select.next">
		</command>
		<command
			name="%ActionDefinition.selectPrevious.name"
			description="%ActionDefinition.selectPrevious.description"
			categoryId="org.eclipse.ui.category.edit"
			id="org.eclipse.wst.sse.ui.structure.select.previous">
		</command>
		<command
			name="%ActionDefinition.selectLast.name"
			description="%ActionDefinition.selectLast.description"
			categoryId="org.eclipse.ui.category.edit"
			id="org.eclipse.wst.sse.ui.structure.select.last">
		</command>
		<command
			name="%ActionDefinition.showJavadoc.name"
			description="%ActionDefinition.showJavadoc.description"
			categoryId="org.eclipse.ui.category.edit"
			id="org.eclipse.wst.sse.ui.show.javadoc">
		</command>
		<command
			name="%ActionDefinition.quickFix.name"
			description="%ActionDefinition.quickFix.description"
			categoryId="org.eclipse.ui.category.edit"
			id="org.eclipse.wst.sse.ui.edit.text.java.correction.assist.proposals">
		</command>
		<!-- Source commands -->
		<command
			name="%command.toggle.comment.name"
			description="%command.toggle.comment.description"
			categoryId="org.eclipse.ui.category.edit"
			id="org.eclipse.wst.sse.ui.toggle.comment">
		</command>
		<command
			name="%command.add.block.comment.name"
			description="%command.add.block.comment.description"
			categoryId="org.eclipse.ui.category.edit"
			id="org.eclipse.wst.sse.ui.add.block.comment">
		</command>
		<command
			name="%command.remove.block.comment.name"
			description="%command.remove.block.comment.description"
			categoryId="org.eclipse.ui.category.edit"
			id="org.eclipse.wst.sse.ui.remove.block.comment">
		</command>
		<command
			name="%command.cleanup.document.name"
			description="%command.cleanup.document.description"
			categoryId="org.eclipse.ui.category.edit"
			id="org.eclipse.wst.sse.ui.cleanup.document">
		</command>
		<command
			name="%command.format.document.name"
			description="%command.format.document.description"
			categoryId="org.eclipse.ui.category.edit"
			id="org.eclipse.wst.sse.ui.format.document">
		</command>
		<command
			name="%command.format.active.elements.name"
			description="%command.format.active.elements.description"
			categoryId="org.eclipse.ui.category.edit"
			id="org.eclipse.wst.sse.ui.format.active.elements">
		</command>
		<!-- Navigate commands -->
		<command
			name="%command.open.file.from.source.name"
			description="%command.open.file.from.source.description"
			categoryId="org.eclipse.ui.category.edit"
			id="org.eclipse.wst.sse.ui.open.file.from.source">
		</command>
		<!-- Find Occurrences -->
		<command
			name="%command.search.find.occurrences.name"
			description="%command.search.find.occurrences.description"
			categoryId="org.eclipse.ui.category.edit"
			id="org.eclipse.wst.sse.ui.search.find.occurrences">
		</command>
	</extension>
	<!-- Keybinding scope for source editor -->
	<extension point="org.eclipse.ui.contexts">
		<context
			name="%scope.structuredTextEditor.name"
			parentId="org.eclipse.ui.textEditorScope"
			description="%scope.structuredTextEditor.description"
			id="org.eclipse.wst.sse.ui.structuredTextEditorScope">
		</context>
	</extension>
	<!-- Keybindings for source editor -->
	<extension point="org.eclipse.ui.bindings">
		<!-- Edit commands -->
		<key
			sequence="Alt+Shift+ARROW_UP"
			contextId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
			commandId="org.eclipse.wst.sse.ui.structure.select.enclosing"
			schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
		</key>
		<key
			sequence="Alt+Shift+ARROW_RIGHT"
			contextId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
			commandId="org.eclipse.wst.sse.ui.structure.select.next"
			schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
		</key>
		<key
			sequence="Alt+Shift+ARROW_LEFT"
			contextId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
			commandId="org.eclipse.wst.sse.ui.structure.select.previous"
			schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
		</key>
		<key
			sequence="Alt+Shift+ARROW_DOWN"
			contextId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
			commandId="org.eclipse.wst.sse.ui.structure.select.last"
			schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
		</key>
		<key
			sequence="F2"
			contextId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
			commandId="org.eclipse.wst.sse.ui.show.javadoc"
			schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
		</key>
		<key
			sequence="Ctrl+1"
			contextId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
			commandId="org.eclipse.wst.sse.ui.edit.text.java.correction.assist.proposals"
			schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
		</key>
		<!-- Source commands -->
		<key
			sequence="Ctrl+Shift+C"
			contextId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
			commandId="org.eclipse.wst.sse.ui.toggle.comment"
			schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
		</key>
		<key
			sequence="Ctrl+Shift+/"
			contextId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
			commandId="org.eclipse.wst.sse.ui.add.block.comment"
			schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
		</key>
		<key
			sequence="Ctrl+Shift+\"
			contextId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
			commandId="org.eclipse.wst.sse.ui.remove.block.comment"
			schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
		</key>
		<key
			sequence="Ctrl+Shift+F"
			contextId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
			commandId="org.eclipse.wst.sse.ui.format.document"
			schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
		</key>
		<key
			sequence="Ctrl+I"
			contextId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
			commandId="org.eclipse.wst.sse.ui.format.active.elements"
			schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
		</key>
		<!-- Navigate commands -->
		<key
			sequence="F3"
			contextId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
			commandId="org.eclipse.wst.sse.ui.open.file.from.source"
			schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
		</key>
		<!-- Find Occurrences -->
		<key
			sequence="Ctrl+Shift+A"
			contextId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
			commandId="org.eclipse.wst.sse.ui.search.find.occurrences"
			schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
		</key>
	</extension>
	<!-- Font and colors contributions -->
	<extension point="org.eclipse.ui.themes">

Lines 171-180 Link Here

(-)src/org/eclipse/wst/sse/ui/internal/StructuredTextEditor.java (-22 / +13 lines)
171	import org.eclipse.wst.sse.ui.internal.provisional.views.properties.PropertySheetConfiguration;	171	import org.eclipse.wst.sse.ui.internal.provisional.views.properties.PropertySheetConfiguration;
172	import org.eclipse.wst.sse.ui.internal.provisional.views.properties.StructuredPropertySheetConfiguration;	172	import org.eclipse.wst.sse.ui.internal.provisional.views.properties.StructuredPropertySheetConfiguration;
173	import org.eclipse.wst.sse.ui.internal.selection.SelectionHistory;	173	import org.eclipse.wst.sse.ui.internal.selection.SelectionHistory;
174	import org.eclipse.wst.sse.ui.internal.selection.StructureSelectEnclosingAction;
175	import org.eclipse.wst.sse.ui.internal.selection.StructureSelectHistoryAction;
176	import org.eclipse.wst.sse.ui.internal.selection.StructureSelectNextAction;
177	import org.eclipse.wst.sse.ui.internal.selection.StructureSelectPreviousAction;
178	import org.eclipse.wst.sse.ui.internal.text.DocumentRegionEdgeMatcher;	174	import org.eclipse.wst.sse.ui.internal.text.DocumentRegionEdgeMatcher;
179	import org.eclipse.wst.sse.ui.internal.util.Assert;	175	import org.eclipse.wst.sse.ui.internal.util.Assert;
180		176
Lines 815-820 Link Here
815	/** The text context menu manager to be disposed. */	811	/** The text context menu manager to be disposed. */
816	private MenuManager fTextContextMenuManager;	812	private MenuManager fTextContextMenuManager;
817	private String fViewerConfigurationTargetId;	813	private String fViewerConfigurationTargetId;
		814	/** The selection history of the editor */
		815	private SelectionHistory fSelectionHistory;
818		816
819	private boolean fUpdateMenuTextPending;	817	private boolean fUpdateMenuTextPending;
820	int hoverX = -1;	818	int hoverX = -1;
Lines 1155-1178 Link Here
1155	setAction(StructuredTextEditorActionConstants.ACTION_NAME_OPEN_FILE, action);	1153	setAction(StructuredTextEditorActionConstants.ACTION_NAME_OPEN_FILE, action);
1156		1154
1157	fShowPropertiesAction = new ShowPropertiesAction();	1155	fShowPropertiesAction = new ShowPropertiesAction();
1158
1159	SelectionHistory selectionHistory = new SelectionHistory(this);
1160	action = new StructureSelectEnclosingAction(this, selectionHistory);
1161	action.setActionDefinitionId(ActionDefinitionIds.STRUCTURE_SELECT_ENCLOSING);
1162	setAction(StructuredTextEditorActionConstants.ACTION_NAME_STRUCTURE_SELECT_ENCLOSING, action);
1163
1164	action = new StructureSelectNextAction(this, selectionHistory);
1165	action.setActionDefinitionId(ActionDefinitionIds.STRUCTURE_SELECT_NEXT);
1166	setAction(StructuredTextEditorActionConstants.ACTION_NAME_STRUCTURE_SELECT_NEXT, action);
1167
1168	action = new StructureSelectPreviousAction(this, selectionHistory);
1169	action.setActionDefinitionId(ActionDefinitionIds.STRUCTURE_SELECT_PREVIOUS);
1170	setAction(StructuredTextEditorActionConstants.ACTION_NAME_STRUCTURE_SELECT_PREVIOUS, action);
1171
1172	action = new StructureSelectHistoryAction(this, selectionHistory);
1173	action.setActionDefinitionId(ActionDefinitionIds.STRUCTURE_SELECT_HISTORY);
1174	setAction(StructuredTextEditorActionConstants.ACTION_NAME_STRUCTURE_SELECT_HISTORY, action);
1175	selectionHistory.setHistoryAction((StructureSelectHistoryAction) action);
1176	}	1156	}
1177		1157
1178	protected LineChangeHover createChangeHover() {	1158	protected LineChangeHover createChangeHover() {
Lines 1385-1390 Link Here
1385	System.out.println("Total time in getAdapter: " + adapterTime); //$NON-NLS-1$	1365	System.out.println("Total time in getAdapter: " + adapterTime); //$NON-NLS-1$
1386	System.out.println("Average time per call: " + (adapterTime / adapterRequests)); //$NON-NLS-1$	1366	System.out.println("Average time per call: " + (adapterTime / adapterRequests)); //$NON-NLS-1$
1387	}	1367	}
		1368
		1369	// dispose of selection history
		1370	if (fSelectionHistory != null) {
		1371	fSelectionHistory.dispose();
		1372	fSelectionHistory = null;
		1373	}
1388		1374
1389	// dispose of document folding support	1375	// dispose of document folding support
1390	if (fProjectionModelUpdater != null) {	1376	if (fProjectionModelUpdater != null) {
Lines 1733-1738 Link Here
1733	else if (IShowInTargetList.class.equals(required)) {	1719	else if (IShowInTargetList.class.equals(required)) {
1734	return new ShowInTargetListAdapter();	1720	return new ShowInTargetListAdapter();
1735	}	1721	}
		1722	else if (SelectionHistory.class.equals(required)) {
		1723	if (fSelectionHistory == null)
		1724	fSelectionHistory = new SelectionHistory(this);
		1725	return fSelectionHistory;
		1726	}
1736	else {	1727	else {
1737	if (result == null && getInternalModel() != null) {	1728	if (result == null && getInternalModel() != null) {
1738	result = getInternalModel().getAdapter(required);	1729	result = getInternalModel().getAdapter(required);

Lines 42-48 Link Here

(-)src/org/eclipse/wst/sse/ui/internal/search/BasicFindOccurrencesAction.java (-1 / +1 lines)
42	* Java elements, etc...)	42	* Java elements, etc...)
43	* </p>	43	* </p>
44	*	44	*
45	* @author pavery	45	* @deprecated use FindOccurrencesProcessor instead
46	*/	46	*/
47	public class BasicFindOccurrencesAction extends TextEditorAction {	47	public class BasicFindOccurrencesAction extends TextEditorAction {
48	private IStructuredDocument fDocument = null;	48	private IStructuredDocument fDocument = null;

Lines 33-39 Link Here

(-)src/org/eclipse/wst/sse/ui/internal/search/FindOccurrencesActionProvider.java (-1 / +1 lines)
33	* Clients can add actions for different partitions via	33	* Clients can add actions for different partitions via
34	* <code>addAction(BasicFindOccurrencesAction action)</code>	34	* <code>addAction(BasicFindOccurrencesAction action)</code>
35	*	35	*
36	* @author pavery	36	* @deprecated use FindOccurrencesActionDelegate instead
37	*/	37	*/
38	public class FindOccurrencesActionProvider extends TextEditorAction {	38	public class FindOccurrencesActionProvider extends TextEditorAction {
39		39




package org.eclipse.wst.sse.ui.internal.selection;

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

import org.eclipse.jface.action.IAction;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.util.Assert;
import org.eclipse.jface.viewers.ISelectionChangedListener;


public class SelectionHistory {
	private ITextEditor fEditor;

	private List fHistory;
	private List fHistoryActions;
	private int fSelectionChangeListenerCounter;
	private ISelectionChangedListener fSelectionListener;



	public void dispose() {
		fEditor.getSelectionProvider().removeSelectionChangedListener(fSelectionListener);
		fEditor = null;
		if (fHistory != null && !fHistory.isEmpty()) {
			fHistory.clear();
		}
		if (fHistoryActions != null && !fHistoryActions.isEmpty()) {
			fHistoryActions.clear();
		}
	}

	public void flush() {
		if (fHistory.isEmpty())
			return;
		fHistory.clear();
		updateHistoryAction();
	}

	public IRegion getLast() {

			return null;
		int size = fHistory.size();
		IRegion result = (IRegion) fHistory.remove(size - 1);
		updateHistoryAction();
		return result;
	}



	public void remember(IRegion region) {
		fHistory.add(region);
		updateHistoryAction();
	}

	public void setHistoryAction(IAction action) {
		Assert.isNotNull(action);
		
		if (fHistoryActions == null)
			fHistoryActions = new ArrayList();
		if (!fHistoryActions.contains(action))
			fHistoryActions.add(action);
		
		// update action
		if (fHistory != null && !fHistory.isEmpty())
			action.setEnabled(true);
		else
			action.setEnabled(false);
	}

	private void updateHistoryAction() {
		if (fHistoryActions != null && !fHistoryActions.isEmpty()) {
			boolean enabled = false;
			if (fHistory != null && !fHistory.isEmpty())
				enabled = true;

			Iterator iter = fHistoryActions.iterator();
			while (iter.hasNext()) {
				((IAction)iter.next()).setEnabled(enabled);
			}
		}
	}
}




package org.eclipse.wst.sse.ui.internal.selection;

import org.eclipse.jface.action.Action;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.Region;
import org.eclipse.jface.util.Assert;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.sse.core.internal.provisional.IndexedRegion;
import org.eclipse.wst.sse.core.internal.provisional.StructuredModelManager;
import org.eclipse.wst.sse.ui.internal.StructuredTextEditor;
import org.eclipse.wst.sse.ui.internal.StructuredTextViewer;
import org.w3c.dom.Node;

/**
 * @deprecated use StructuredSelectActionDelegate instead
 */
public abstract class StructureSelectAction extends Action {
	protected StructuredTextEditor fEditor = null;
	protected SelectionHistory fHistory;
	protected IStructuredModel fModel = null;
	protected StructuredTextViewer fViewer = null;

	public StructureSelectAction(StructuredTextEditor editor) {
		super();

		Assert.isNotNull(editor);
		Assert.isNotNull(history);
		fEditor = editor;
		fHistory = (SelectionHistory) editor.getAdapter(SelectionHistory.class);
		fViewer = editor.getTextViewer();
		fModel = editor.getModel();
		Assert.isNotNull(fViewer);
		//Assert.isNotNull(fModel);
	}

	abstract protected IndexedRegion getCursorIndexedRegion();

		IndexedRegion indexedRegion = null;

		int lastOffset = offset;
		IDocument document = fEditor.getDocumentProvider().getDocument(fEditor.getEditorInput());
		IStructuredModel model = StructuredModelManager.getModelManager().getExistingModelForRead(document);
		if (model != null) {
			try {
				indexedRegion = model.getIndexedRegion(lastOffset);
				while (indexedRegion == null && lastOffset >= 0) {
					lastOffset--;
					indexedRegion = model.getIndexedRegion(lastOffset);
				}
			}
			finally {
				model.releaseFromRead();
			}
		}

		return indexedRegion;

				try {
					fHistory.ignoreSelectionChanges();
					fEditor.selectAndReveal(newRegion.getOffset(), newRegion.getLength());
				}
				finally {
					fHistory.listenToSelectionChanges();
				}
			}

Lines 18-26 Link Here

(-)src/org/eclipse/wst/sse/ui/internal/selection/StructureSelectEnclosingAction.java (-2 / +7 lines)
18	import org.eclipse.wst.sse.ui.internal.StructuredTextEditor;	18	import org.eclipse.wst.sse.ui.internal.StructuredTextEditor;
19	import org.w3c.dom.Node;	19	import org.w3c.dom.Node;
20		20
		21	/**
		22	* @deprecated use
		23	* org.eclipse.wst.xml.ui.internal.selection.StructuredSelectEnclosingXMLActionDelegate
		24	* instead
		25	*/
21	public class StructureSelectEnclosingAction extends StructureSelectAction {	26	public class StructureSelectEnclosingAction extends StructureSelectAction {
22	public StructureSelectEnclosingAction(StructuredTextEditor editor, SelectionHistory history) {	27	public StructureSelectEnclosingAction(StructuredTextEditor editor) {
23	super(editor, history);	28	super(editor);
24	setText(SSEUIMessages.StructureSelectEnclosing_label); //$NON-NLS-1$	29	setText(SSEUIMessages.StructureSelectEnclosing_label); //$NON-NLS-1$
25	setToolTipText(SSEUIMessages.StructureSelectEnclosing_tooltip); //$NON-NLS-1$	30	setToolTipText(SSEUIMessages.StructureSelectEnclosing_tooltip); //$NON-NLS-1$
26	setDescription(SSEUIMessages.StructureSelectEnclosing_description); //$NON-NLS-1$	31	setDescription(SSEUIMessages.StructureSelectEnclosing_description); //$NON-NLS-1$




import org.eclipse.wst.sse.ui.internal.StructuredTextEditor;
import org.w3c.dom.Node;

/**
 * @deprecated use StructuredSelectHistoryActionDelegate instead
 */
public class StructureSelectHistoryAction extends StructureSelectAction implements IUpdate {
	public StructureSelectHistoryAction(StructuredTextEditor editor) {
		super(editor);
		setText(SSEUIMessages.StructureSelectHistory_label); //$NON-NLS-1$
		setToolTipText(SSEUIMessages.StructureSelectHistory_tooltip); //$NON-NLS-1$
		setDescription(SSEUIMessages.StructureSelectHistory_description); //$NON-NLS-1$

		fHistory.setHistoryAction(this);
		update();
	}


Lines 18-26 Link Here

(-)src/org/eclipse/wst/sse/ui/internal/selection/StructureSelectNextAction.java (-2 / +7 lines)
18	import org.eclipse.wst.sse.ui.internal.StructuredTextEditor;	18	import org.eclipse.wst.sse.ui.internal.StructuredTextEditor;
19	import org.w3c.dom.Node;	19	import org.w3c.dom.Node;
20		20
		21	/**
		22	* @deprecated use
		23	* org.eclipse.wst.xml.ui.internal.selection.StructuredSelectNextXMLActionDelegate
		24	* instead
		25	*/
21	public class StructureSelectNextAction extends StructureSelectAction {	26	public class StructureSelectNextAction extends StructureSelectAction {
22	public StructureSelectNextAction(StructuredTextEditor editor, SelectionHistory history) {	27	public StructureSelectNextAction(StructuredTextEditor editor) {
23	super(editor, history);	28	super(editor);
24	setText(SSEUIMessages.StructureSelectNext_label); //$NON-NLS-1$	29	setText(SSEUIMessages.StructureSelectNext_label); //$NON-NLS-1$
25	setToolTipText(SSEUIMessages.StructureSelectNext_tooltip); //$NON-NLS-1$	30	setToolTipText(SSEUIMessages.StructureSelectNext_tooltip); //$NON-NLS-1$
26	setDescription(SSEUIMessages.StructureSelectNext_description); //$NON-NLS-1$	31	setDescription(SSEUIMessages.StructureSelectNext_description); //$NON-NLS-1$

Lines 18-26 Link Here

(-)src/org/eclipse/wst/sse/ui/internal/selection/StructureSelectPreviousAction.java (-2 / +7 lines)
18	import org.eclipse.wst.sse.ui.internal.StructuredTextEditor;	18	import org.eclipse.wst.sse.ui.internal.StructuredTextEditor;
19	import org.w3c.dom.Node;	19	import org.w3c.dom.Node;
20		20
		21	/**
		22	* @deprecated use
		23	* org.eclipse.wst.xml.ui.internal.selection.StructuredSelectPreviousXMLActionDelegate
		24	* instead
		25	*/
21	public class StructureSelectPreviousAction extends StructureSelectAction {	26	public class StructureSelectPreviousAction extends StructureSelectAction {
22	public StructureSelectPreviousAction(StructuredTextEditor editor, SelectionHistory history) {	27	public StructureSelectPreviousAction(StructuredTextEditor editor) {
23	super(editor, history);	28	super(editor);
24	setText(SSEUIMessages.StructureSelectPrevious_label); //$NON-NLS-1$	29	setText(SSEUIMessages.StructureSelectPrevious_label); //$NON-NLS-1$
25	setToolTipText(SSEUIMessages.StructureSelectPrevious_tooltip); //$NON-NLS-1$	30	setToolTipText(SSEUIMessages.StructureSelectPrevious_tooltip); //$NON-NLS-1$
26	setDescription(SSEUIMessages.StructureSelectPrevious_description); //$NON-NLS-1$	31	setDescription(SSEUIMessages.StructureSelectPrevious_description); //$NON-NLS-1$




/*******************************************************************************
 * Copyright (c) 2005 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.wst.sse.ui.internal.search;

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

import org.eclipse.core.resources.IFile;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.text.ITypedRegion;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.swt.widgets.Event;
import org.eclipse.ui.IActionDelegate2;
import org.eclipse.ui.IEditorActionDelegate;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IFileEditorInput;
import org.eclipse.ui.IViewActionDelegate;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.wst.sse.ui.internal.SSEUIMessages;
import org.eclipse.wst.sse.ui.internal.util.PlatformStatusLineUtil;

/**
 * Performs the appropriate FindOccurrencesProcessor action call based on
 * selection. Clients can add processors for different partitions via
 * <code>getProcessors</code>
 * 
 */
abstract public class FindOccurrencesActionDelegate implements IEditorActionDelegate, IActionDelegate2, IViewActionDelegate {
	private IEditorPart fEditor;

	public void setActiveEditor(IAction action, IEditorPart targetEditor) {
		fEditor = targetEditor;
	}

	public void dispose() {
		// nulling out just in case
		fEditor = null;
	}

	public void init(IAction action) {
		if (action != null) {
			action.setText(SSEUIMessages.FindOccurrences_label);
		}
	}

	public void runWithEvent(IAction action, Event event) {
		run(action);
	}

	public void run(IAction action) {
		boolean okay = false;
		if (fEditor instanceof ITextEditor) {
			ITextEditor textEditor = (ITextEditor) fEditor;
			IDocument document = textEditor.getDocumentProvider().getDocument(textEditor.getEditorInput());
			if (document != null) {
				ITextSelection textSelection = getTextSelection(textEditor);
				FindOccurrencesProcessor findOccurrenceProcessor = getProcessorForCurrentSelection(document, textSelection);
				if (findOccurrenceProcessor != null) {
					if (textEditor.getEditorInput() instanceof IFileEditorInput) {
						IFile file = ((IFileEditorInput) textEditor.getEditorInput()).getFile();
						okay = findOccurrenceProcessor.findOccurrences(document, textSelection, file);
					}
				}
			}
		}
		if (okay) {
			// clear status message
			PlatformStatusLineUtil.clearStatusLine();
		}
		else {
			String errorMessage = SSEUIMessages.FindOccurrencesActionProvider_0; //$NON-NLS-1$
			PlatformStatusLineUtil.displayErrorMessage(errorMessage);
			PlatformStatusLineUtil.addOneTimeClearListener();
		}
	}

	public void init(IViewPart view) {
		// do nothing
	}

	public void selectionChanged(IAction action, ISelection selection) {
		// clear status message
		PlatformStatusLineUtil.clearStatusLine();
	}

	/**
	 * Get the appropriate find occurrences processor
	 * 
	 * @param document -
	 *            assumes not null
	 * @param textSelection
	 * @return
	 */
	private FindOccurrencesProcessor getProcessorForCurrentSelection(IDocument document, ITextSelection textSelection) {
		// check if we have an action that's enabled on the current partition
		ITypedRegion tr = getPartition(document, textSelection);
		String partition = tr != null ? tr.getType() : ""; //$NON-NLS-1$

		Iterator it = getProcessors().iterator();
		FindOccurrencesProcessor action = null;
		while (it.hasNext()) {
			action = (FindOccurrencesProcessor) it.next();
			// we just choose the first action that can handle the partition
			if (action.enabledForParitition(partition))
				return action;
		}
		return null;
	}

	private ITypedRegion getPartition(IDocument document, ITextSelection textSelection) {
		ITypedRegion region = null;
		if (textSelection != null) {
			try {
				region = document.getPartition(textSelection.getOffset());
			}
			catch (BadLocationException e) {
				region = null;
			}
		}
		return region;
	}

	private ITextSelection getTextSelection(ITextEditor textEditor) {
		ITextSelection textSelection = null;
		ISelection selection = textEditor.getSelectionProvider().getSelection();
		if (selection instanceof ITextSelection && !selection.isEmpty()) {
			textSelection = (ITextSelection) selection;
		}
		return textSelection;
	}

	abstract protected List getProcessors();
}




/*******************************************************************************
 * Copyright (c) 2005 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.wst.sse.ui.internal.search;

import org.eclipse.core.resources.IFile;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.search.ui.ISearchQuery;
import org.eclipse.search.ui.NewSearchUI;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegion;
import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegion;

/**
 * <p>
 * Finds occurrences of a specified region type w/ region text in an
 * IStructuredDocument. Clients must implement getPartitionTypes() and
 * getRegionTypes() to indicate which partition types and region types it can
 * operate on.
 * </p>
 * 
 * <p>
 * Clients should override <code>getSearchQuery()</code> in order to provide
 * their own type of "search" (eg. searching for XML start tags, searching for
 * Java elements, etc...)
 * </p>
 * 
 */
abstract public class FindOccurrencesProcessor {
	public boolean findOccurrences(IDocument document, ITextSelection textSelection, IFile file) {
		boolean findOccurrences = false;

		// determine if action should be enabled or not
		if (document instanceof IStructuredDocument) {
			IStructuredDocument structuredDocument = (IStructuredDocument) document;
			IStructuredDocumentRegion sdRegion = structuredDocument.getRegionAtCharacterOffset(textSelection.getOffset());
			if (sdRegion != null) {
				ITextRegion r = sdRegion.getRegionAtCharacterOffset(textSelection.getOffset());
				if (r != null) {
					String type = r.getType();
					if (enabledForRegionType(type)) {
						String matchText = sdRegion.getText(r);

						// first of all activate the view
						NewSearchUI.activateSearchResultView();

						if (matchText != null && type != null) {
							ISearchQuery searchQuery = getSearchQuery(file, structuredDocument, matchText, type, textSelection);
							if (searchQuery != null) {
								if (searchQuery.canRunInBackground())
									NewSearchUI.runQueryInBackground(searchQuery);
								else
									NewSearchUI.runQueryInForeground(null, searchQuery);
							}
							findOccurrences = true;
						}
					}
				}
			}
		}
		return findOccurrences;
	}

	/**
	 * @param regionType
	 * @return <code>true</code> if this action can operate on this region
	 *         type (ITextRegion), otherwise false.
	 */
	private boolean enabledForRegionType(String regionType) {

		String[] accept = getRegionTypes();
		for (int i = 0; i < accept.length; i++) {
			if (regionType.equals(accept[i]))
				return true;
		}
		return false;
	}

	/**
	 * Clients should override this to enable find occurrences on certain
	 * partition(s).
	 */
	abstract protected String[] getPartitionTypes();

	/**
	 * Clients should override this to enable find occurrences on different
	 * region type(s).
	 */
	abstract protected String[] getRegionTypes();

	/**
	 * Clients should override to provide their own search for the file.
	 */
	protected ISearchQuery getSearchQuery(IFile file, IStructuredDocument document, String regionText, String regionType, ITextSelection textSelection) {
		return new OccurrencesSearchQuery(file, document, regionText, regionType);
	}

	/**
	 * @param partitionType
	 * @return <code>true</code> if this action can operate on this type of
	 *         partition, otherwise <code>false</code>.
	 */
	public boolean enabledForParitition(String partitionType) {
		String[] accept = getPartitionTypes();
		for (int i = 0; i < accept.length; i++) {
			if (partitionType.equals(accept[i]))
				return true;
		}
		return false;
	}
}




/*******************************************************************************
 * Copyright (c) 2005 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.wst.sse.ui.internal.selection;

import org.eclipse.jface.action.IAction;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.text.Region;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.swt.widgets.Event;
import org.eclipse.ui.IActionDelegate2;
import org.eclipse.ui.IEditorActionDelegate;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IViewActionDelegate;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.sse.core.internal.provisional.IndexedRegion;
import org.eclipse.wst.sse.core.internal.provisional.StructuredModelManager;

abstract public class StructuredSelectActionDelegate implements IEditorActionDelegate, IActionDelegate2, IViewActionDelegate {
	private IEditorPart fEditor;
	private SelectionHistory fHistory;

	public void dispose() {
		fEditor = null;
		fHistory = null;
	}

	public void init(IViewPart view) {
		// do nothing
	}

	public void runWithEvent(IAction action, Event event) {
		run(action);
	}

	public void run(IAction action) {
		if (fEditor instanceof ITextEditor) {
			ITextEditor textEditor = (ITextEditor) fEditor;

			ISelection selection = textEditor.getSelectionProvider().getSelection();
			IDocument document = textEditor.getDocumentProvider().getDocument(textEditor.getEditorInput());
			// determine current text selection
			if (selection instanceof ITextSelection && document != null) {
				ITextSelection textSelection = (ITextSelection) selection;

				if (textSelection.getLength() < document.getLength()) {
					// get current indexed region
					IndexedRegion cursorIndexedRegion = getCursorIndexedRegion(document, textSelection);

					// determine new selection based on current indexed region
					Region newSelectionRegion = getNewSelectionRegion(cursorIndexedRegion, textSelection);

					// select new selection
					if (newSelectionRegion != null) {
						fHistory.remember(new Region(textSelection.getOffset(), textSelection.getLength()));
						try {
							fHistory.ignoreSelectionChanges();
							textEditor.selectAndReveal(newSelectionRegion.getOffset(), newSelectionRegion.getLength());
						}
						finally {
							fHistory.listenToSelectionChanges();
						}
					}
				}
			}
		}
	}

	public void selectionChanged(IAction action, ISelection selection) {
		// do nothing
	}

	public void setActiveEditor(IAction action, IEditorPart targetEditor) {
		fEditor = targetEditor;
		if (fEditor != null)
			fHistory = (SelectionHistory) fEditor.getAdapter(SelectionHistory.class);
		else
			fHistory = null;
	}
	
	abstract protected IndexedRegion getCursorIndexedRegion(IDocument document, ITextSelection textSelection);
	
	abstract protected Region getNewSelectionRegion(IndexedRegion indexedRegion, ITextSelection textSelection);
	
	/**
	 * This method will probably be removed and replaced by using new selection provider
	 * @param document
	 * @param offset
	 * @return
	 */
	protected IndexedRegion getIndexedRegion(IDocument document, int offset) {
		IndexedRegion indexedRegion = null;

		int lastOffset = offset;
		IStructuredModel model = StructuredModelManager.getModelManager().getExistingModelForRead(document);
		if (model != null) {
			try {
				indexedRegion = model.getIndexedRegion(lastOffset);
				while (indexedRegion == null && lastOffset >= 0) {
					lastOffset--;
					indexedRegion = model.getIndexedRegion(lastOffset);
				}
			}
			finally {
				model.releaseFromRead();
			}
		}

		return indexedRegion;
	}

}




/*******************************************************************************
 * Copyright (c) 2005 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.wst.sse.ui.internal.selection;

import org.eclipse.jface.action.IAction;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.swt.widgets.Event;
import org.eclipse.ui.IActionDelegate2;
import org.eclipse.ui.IEditorActionDelegate;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IViewActionDelegate;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.wst.sse.ui.internal.SSEUIMessages;

/**
 * Selection history action delegate. Keeps track of selection within editor.
 */
public class StructuredSelectHistoryActionDelegate implements IEditorActionDelegate, IActionDelegate2, IViewActionDelegate {
	private IEditorPart fEditor;
	private SelectionHistory fHistory;

	public void dispose() {
		fEditor = null;
		fHistory = null;
	}

	public void init(IAction action) {
		if (action != null) {
			action.setText(SSEUIMessages.StructureSelectHistory_label);
			action.setToolTipText(SSEUIMessages.StructureSelectHistory_tooltip);
			action.setDescription(SSEUIMessages.StructureSelectHistory_description);
		}
	}

	public void init(IViewPart view) {
		// do nothing
	}

	public void run(IAction action) {
		IRegion old = fHistory.getLast();
		if (old != null) {
			try {
				fHistory.ignoreSelectionChanges();
				if (fEditor instanceof ITextEditor)
					((ITextEditor) fEditor).selectAndReveal(old.getOffset(), old.getLength());
			}
			finally {
				fHistory.listenToSelectionChanges();
			}
		}
	}

	public void runWithEvent(IAction action, Event event) {
		run(action);
	}

	public void selectionChanged(IAction action, ISelection selection) {
		// do nothing
	}

	public void setActiveEditor(IAction action, IEditorPart targetEditor) {
		fEditor = targetEditor;
		if (fEditor != null)
			fHistory = (SelectionHistory) fEditor.getAdapter(SelectionHistory.class);
		else
			fHistory = null;
		if (fHistory != null) {
			fHistory.setHistoryAction(action);
		}
	}
}

Return to bug 109468

Lines 112-296 Link Here

(-)plugin.xml (-101 / +104 lines)
112	<extension-point id="dragSourceTransfers" name="Drag Source Transfers"/>	112	<extension-point id="dragSourceTransfers" name="Drag Source Transfers"/>
113	-->	113	-->
114	<extension point="org.eclipse.ui.commands">	114	<extension point="org.eclipse.ui.commands">
115	<scope
116	name="%scope.structuredTextEditor.name"
117	parent="org.eclipse.ui.textEditorScope"
118	description="%scope.structuredTextEditor.description"
119	id="org.eclipse.wst.sse.ui.structuredTextEditorScope">
120	</scope>
121	<!-- dmw 6/6 (and 11/10 :) removed from 'scope' parentId="org.eclipse.ui.textEditorScope" -->
122	<!-- afw 11/11 added scope back in because these are keybindings for structuredtexteditors only -->
123
124	<!-- Edit commands -->	115	<!-- Edit commands -->
125	<command	116	<command
126	name="%ActionDefinition.selectEnclosing.name"	117	name="%ActionDefinition.selectEnclosing.name"
127	description="%ActionDefinition.selectEnclosing.description"	118	description="%ActionDefinition.selectEnclosing.description"
128	category="org.eclipse.ui.category.edit"	119	categoryId="org.eclipse.ui.category.edit"
129	id="org.eclipse.wst.sse.ui.structure.select.enclosing">	120	id="org.eclipse.wst.sse.ui.structure.select.enclosing">
130	</command>	121	</command>
131	<command	122	<command
132	name="%ActionDefinition.selectNext.name"	123	name="%ActionDefinition.selectNext.name"
133	description="%ActionDefinition.selectNext.description"	124	description="%ActionDefinition.selectNext.description"
134	category="org.eclipse.ui.category.edit"	125	categoryId="org.eclipse.ui.category.edit"
135	id="org.eclipse.wst.sse.ui.structure.select.next">	126	id="org.eclipse.wst.sse.ui.structure.select.next">
136	</command>	127	</command>
137	<command	128	<command
138	name="%ActionDefinition.selectPrevious.name"	129	name="%ActionDefinition.selectPrevious.name"
139	description="%ActionDefinition.selectPrevious.description"	130	description="%ActionDefinition.selectPrevious.description"
140	category="org.eclipse.ui.category.edit"	131	categoryId="org.eclipse.ui.category.edit"
141	id="org.eclipse.wst.sse.ui.structure.select.previous">	132	id="org.eclipse.wst.sse.ui.structure.select.previous">
142	</command>	133	</command>
143	<command	134	<command
144	name="%ActionDefinition.selectLast.name"	135	name="%ActionDefinition.selectLast.name"
145	description="%ActionDefinition.selectLast.description"	136	description="%ActionDefinition.selectLast.description"
146	category="org.eclipse.ui.category.edit"	137	categoryId="org.eclipse.ui.category.edit"
147	id="org.eclipse.wst.sse.ui.structure.select.last">	138	id="org.eclipse.wst.sse.ui.structure.select.last">
148	</command>	139	</command>
149	<command	140	<command
150	name="%ActionDefinition.showJavadoc.name"	141	name="%ActionDefinition.showJavadoc.name"
151	description="%ActionDefinition.showJavadoc.description"	142	description="%ActionDefinition.showJavadoc.description"
152	category="org.eclipse.ui.category.edit"	143	categoryId="org.eclipse.ui.category.edit"
153	id="org.eclipse.wst.sse.ui.show.javadoc">	144	id="org.eclipse.wst.sse.ui.show.javadoc">
154	</command>	145	</command>
155	<command	146	<command
156	name="%ActionDefinition.quickFix.name"	147	name="%ActionDefinition.quickFix.name"
157	description="%ActionDefinition.quickFix.description"	148	description="%ActionDefinition.quickFix.description"
158	category="org.eclipse.ui.category.edit"	149	categoryId="org.eclipse.ui.category.edit"
159	id="org.eclipse.wst.sse.ui.edit.text.java.correction.assist.proposals">	150	id="org.eclipse.wst.sse.ui.edit.text.java.correction.assist.proposals">
160	</command>	151	</command>
161	<!-- Source commands -->	152	<!-- Source commands -->
162	<command	153	<command
163	name="%command.toggle.comment.name"	154	name="%command.toggle.comment.name"
164	description="%command.toggle.comment.description"	155	description="%command.toggle.comment.description"
165	category="org.eclipse.ui.category.edit"	156	categoryId="org.eclipse.ui.category.edit"
166	id="org.eclipse.wst.sse.ui.toggle.comment">	157	id="org.eclipse.wst.sse.ui.toggle.comment">
167	</command>	158	</command>
168	<command	159	<command
169	name="%command.add.block.comment.name"	160	name="%command.add.block.comment.name"
170	description="%command.add.block.comment.description"	161	description="%command.add.block.comment.description"
171	category="org.eclipse.ui.category.edit"	162	categoryId="org.eclipse.ui.category.edit"
172	id="org.eclipse.wst.sse.ui.add.block.comment">	163	id="org.eclipse.wst.sse.ui.add.block.comment">
173	</command>	164	</command>
174	<command	165	<command
175	name="%command.remove.block.comment.name"	166	name="%command.remove.block.comment.name"
176	description="%command.remove.block.comment.description"	167	description="%command.remove.block.comment.description"
177	category="org.eclipse.ui.category.edit"	168	categoryId="org.eclipse.ui.category.edit"
178	id="org.eclipse.wst.sse.ui.remove.block.comment">	169	id="org.eclipse.wst.sse.ui.remove.block.comment">
179	</command>	170	</command>
180	<command	171	<command
181	name="%command.cleanup.document.name"	172	name="%command.cleanup.document.name"
182	description="%command.cleanup.document.description"	173	description="%command.cleanup.document.description"
183	category="org.eclipse.ui.category.edit"	174	categoryId="org.eclipse.ui.category.edit"
184	id="org.eclipse.wst.sse.ui.cleanup.document">	175	id="org.eclipse.wst.sse.ui.cleanup.document">
185	</command>	176	</command>
186	<command	177	<command
187	name="%command.format.document.name"	178	name="%command.format.document.name"
188	description="%command.format.document.description"	179	description="%command.format.document.description"
189	category="org.eclipse.ui.category.edit"	180	categoryId="org.eclipse.ui.category.edit"
190	id="org.eclipse.wst.sse.ui.format.document">	181	id="org.eclipse.wst.sse.ui.format.document">
191	</command>	182	</command>
192	<command	183	<command
193	name="%command.format.active.elements.name"	184	name="%command.format.active.elements.name"
194	description="%command.format.active.elements.description"	185	description="%command.format.active.elements.description"
195	category="org.eclipse.ui.category.edit"	186	categoryId="org.eclipse.ui.category.edit"
196	id="org.eclipse.wst.sse.ui.format.active.elements">	187	id="org.eclipse.wst.sse.ui.format.active.elements">
197	</command>	188	</command>
198	<!-- Navigate commands -->	189	<!-- Navigate commands -->
199	<command	190	<command
200	name="%command.open.file.from.source.name"	191	name="%command.open.file.from.source.name"
201	description="%command.open.file.from.source.description"	192	description="%command.open.file.from.source.description"
202	category="org.eclipse.ui.category.edit"	193	categoryId="org.eclipse.ui.category.edit"
203	id="org.eclipse.wst.sse.ui.open.file.from.source">	194	id="org.eclipse.wst.sse.ui.open.file.from.source">
204	</command>	195	</command>
205	<!-- Find Occurrences -->	196	<!-- Find Occurrences -->
206	<command	197	<command
207	name="%command.search.find.occurrences.name"	198	name="%command.search.find.occurrences.name"
208	description="%command.search.find.occurrences.description"	199	description="%command.search.find.occurrences.description"
209	category="org.eclipse.ui.category.edit"	200	categoryId="org.eclipse.ui.category.edit"
210	id="org.eclipse.wst.sse.ui.search.find.occurrences">	201	id="org.eclipse.wst.sse.ui.search.find.occurrences">
211	</command>	202	</command>
		203	</extension>
		204	<!-- Keybinding scope for source editor -->
		205	<extension point="org.eclipse.ui.contexts">
		206	<context
		207	name="%scope.structuredTextEditor.name"
		208	parentId="org.eclipse.ui.textEditorScope"
		209	description="%scope.structuredTextEditor.description"
		210	id="org.eclipse.wst.sse.ui.structuredTextEditorScope">
		211	</context>
		212	</extension>
		213	<!-- Keybindings for source editor -->
		214	<extension point="org.eclipse.ui.bindings">
212	<!-- Edit commands -->	215	<!-- Edit commands -->
213	<keyBinding	216	<key
214	string="Alt+Shift+ARROW_UP"	217	sequence="Alt+Shift+ARROW_UP"
215	scope="org.eclipse.wst.sse.ui.structuredTextEditorScope"	218	contextId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
216	command="org.eclipse.wst.sse.ui.structure.select.enclosing"	219	commandId="org.eclipse.wst.sse.ui.structure.select.enclosing"
217	configuration="org.eclipse.ui.defaultAcceleratorConfiguration">	220	schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
218	</keyBinding>	221	</key>
219	<keyBinding	222	<key
220	string="Alt+Shift+ARROW_RIGHT"	223	sequence="Alt+Shift+ARROW_RIGHT"
221	scope="org.eclipse.wst.sse.ui.structuredTextEditorScope"	224	contextId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
222	command="org.eclipse.wst.sse.ui.structure.select.next"	225	commandId="org.eclipse.wst.sse.ui.structure.select.next"
223	configuration="org.eclipse.ui.defaultAcceleratorConfiguration">	226	schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
224	</keyBinding>	227	</key>
225	<keyBinding	228	<key
226	string="Alt+Shift+ARROW_LEFT"	229	sequence="Alt+Shift+ARROW_LEFT"
227	scope="org.eclipse.wst.sse.ui.structuredTextEditorScope"	230	contextId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
228	command="org.eclipse.wst.sse.ui.structure.select.previous"	231	commandId="org.eclipse.wst.sse.ui.structure.select.previous"
229	configuration="org.eclipse.ui.defaultAcceleratorConfiguration">	232	schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
230	</keyBinding>	233	</key>
231	<keyBinding	234	<key
232	string="Alt+Shift+ARROW_DOWN"	235	sequence="Alt+Shift+ARROW_DOWN"
233	scope="org.eclipse.wst.sse.ui.structuredTextEditorScope"	236	contextId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
234	command="org.eclipse.wst.sse.ui.structure.select.last"	237	commandId="org.eclipse.wst.sse.ui.structure.select.last"
235	configuration="org.eclipse.ui.defaultAcceleratorConfiguration">	238	schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
236	</keyBinding>	239	</key>
237	<keyBinding	240	<key
238	string="F2"	241	sequence="F2"
239	scope="org.eclipse.wst.sse.ui.structuredTextEditorScope"	242	contextId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
240	command="org.eclipse.wst.sse.ui.show.javadoc"	243	commandId="org.eclipse.wst.sse.ui.show.javadoc"
241	configuration="org.eclipse.ui.defaultAcceleratorConfiguration">	244	schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
242	</keyBinding>	245	</key>
243	<keyBinding	246	<key
244	string="Ctrl+1"	247	sequence="Ctrl+1"
245	scope="org.eclipse.wst.sse.ui.structuredTextEditorScope"	248	contextId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
246	command="org.eclipse.wst.sse.ui.edit.text.java.correction.assist.proposals"	249	commandId="org.eclipse.wst.sse.ui.edit.text.java.correction.assist.proposals"
247	configuration="org.eclipse.ui.defaultAcceleratorConfiguration">	250	schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
248	</keyBinding>	251	</key>
249	<!-- Source commands -->	252	<!-- Source commands -->
250	<keyBinding	253	<key
251	string="Ctrl+Shift+C"	254	sequence="Ctrl+Shift+C"
252	scope="org.eclipse.wst.sse.ui.structuredTextEditorScope"	255	contextId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
253	command="org.eclipse.wst.sse.ui.toggle.comment"	256	commandId="org.eclipse.wst.sse.ui.toggle.comment"
254	configuration="org.eclipse.ui.defaultAcceleratorConfiguration">	257	schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
255	</keyBinding>	258	</key>
256	<keyBinding	259	<key
257	string="Ctrl+Shift+/"	260	sequence="Ctrl+Shift+/"
258	scope="org.eclipse.wst.sse.ui.structuredTextEditorScope"	261	contextId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
259	command="org.eclipse.wst.sse.ui.add.block.comment"	262	commandId="org.eclipse.wst.sse.ui.add.block.comment"
260	configuration="org.eclipse.ui.defaultAcceleratorConfiguration">	263	schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
261	</keyBinding>	264	</key>
262	<keyBinding	265	<key
263	string="Ctrl+Shift+\"	266	sequence="Ctrl+Shift+\"
264	scope="org.eclipse.wst.sse.ui.structuredTextEditorScope"	267	contextId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
265	command="org.eclipse.wst.sse.ui.remove.block.comment"	268	commandId="org.eclipse.wst.sse.ui.remove.block.comment"
266	configuration="org.eclipse.ui.defaultAcceleratorConfiguration">	269	schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
267	</keyBinding>	270	</key>
268	<keyBinding	271	<key
269	string="Ctrl+Shift+F"	272	sequence="Ctrl+Shift+F"
270	scope="org.eclipse.wst.sse.ui.structuredTextEditorScope"	273	contextId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
271	command="org.eclipse.wst.sse.ui.format.document"	274	commandId="org.eclipse.wst.sse.ui.format.document"
272	configuration="org.eclipse.ui.defaultAcceleratorConfiguration">	275	schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
273	</keyBinding>	276	</key>
274	<keyBinding	277	<key
275	string="Ctrl+I"	278	sequence="Ctrl+I"
276	scope="org.eclipse.wst.sse.ui.structuredTextEditorScope"	279	contextId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
277	command="org.eclipse.wst.sse.ui.format.active.elements"	280	commandId="org.eclipse.wst.sse.ui.format.active.elements"
278	configuration="org.eclipse.ui.defaultAcceleratorConfiguration">	281	schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
279	</keyBinding>	282	</key>
280	<!-- Navigate commands -->	283	<!-- Navigate commands -->
281	<keyBinding	284	<key
282	string="F3"	285	sequence="F3"
283	scope="org.eclipse.wst.sse.ui.structuredTextEditorScope"	286	contextId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
284	command="org.eclipse.wst.sse.ui.open.file.from.source"	287	commandId="org.eclipse.wst.sse.ui.open.file.from.source"
285	configuration="org.eclipse.ui.defaultAcceleratorConfiguration">	288	schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
286	</keyBinding>	289	</key>
287	<!-- Find Occurrences -->	290	<!-- Find Occurrences -->
288	<keyBinding	291	<key
289	string="Ctrl+Shift+A"	292	sequence="Ctrl+Shift+A"
290	scope="org.eclipse.wst.sse.ui.structuredTextEditorScope"	293	contextId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
291	command="org.eclipse.wst.sse.ui.search.find.occurrences"	294	commandId="org.eclipse.wst.sse.ui.search.find.occurrences"
292	configuration="org.eclipse.ui.defaultAcceleratorConfiguration">	295	schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
293	</keyBinding>	296	</key>
294	</extension>	297	</extension>
295	<!-- Font and colors contributions -->	298	<!-- Font and colors contributions -->
296	<extension point="org.eclipse.ui.themes">	299	<extension point="org.eclipse.ui.themes">

Lines 13-20 Link Here

(-)src/org/eclipse/wst/sse/ui/internal/selection/SelectionHistory.java (-7 / +38 lines)
13	package org.eclipse.wst.sse.ui.internal.selection;	13	package org.eclipse.wst.sse.ui.internal.selection;
14		14
15	import java.util.ArrayList;	15	import java.util.ArrayList;
		16	import java.util.Iterator;
16	import java.util.List;	17	import java.util.List;
17		18
		19	import org.eclipse.jface.action.IAction;
18	import org.eclipse.jface.text.IRegion;	20	import org.eclipse.jface.text.IRegion;
19	import org.eclipse.jface.util.Assert;	21	import org.eclipse.jface.util.Assert;
20	import org.eclipse.jface.viewers.ISelectionChangedListener;	22	import org.eclipse.jface.viewers.ISelectionChangedListener;
Lines 23-31 Link Here
23		25
24	public class SelectionHistory {	26	public class SelectionHistory {
25	private ITextEditor fEditor;	27	private ITextEditor fEditor;
26
27	private List fHistory;	28	private List fHistory;
28	private StructureSelectHistoryAction fHistoryAction;	29	private List fHistoryActions;
29	private int fSelectionChangeListenerCounter;	30	private int fSelectionChangeListenerCounter;
30	private ISelectionChangedListener fSelectionListener;	31	private ISelectionChangedListener fSelectionListener;
31		32
Lines 44-56 Link Here
44		45
45	public void dispose() {	46	public void dispose() {
46	fEditor.getSelectionProvider().removeSelectionChangedListener(fSelectionListener);	47	fEditor.getSelectionProvider().removeSelectionChangedListener(fSelectionListener);
		48	fEditor = null;
		49	if (fHistory != null && !fHistory.isEmpty()) {
		50	fHistory.clear();
		51	}
		52	if (fHistoryActions != null && !fHistoryActions.isEmpty()) {
		53	fHistoryActions.clear();
		54	}
47	}	55	}
48		56
49	public void flush() {	57	public void flush() {
50	if (fHistory.isEmpty())	58	if (fHistory.isEmpty())
51	return;	59	return;
52	fHistory.clear();	60	fHistory.clear();
53	fHistoryAction.update();	61	updateHistoryAction();
54	}	62	}
55		63
56	public IRegion getLast() {	64	public IRegion getLast() {
Lines 58-64 Link Here
58	return null;	66	return null;
59	int size = fHistory.size();	67	int size = fHistory.size();
60	IRegion result = (IRegion) fHistory.remove(size - 1);	68	IRegion result = (IRegion) fHistory.remove(size - 1);
61	fHistoryAction.update();	69	updateHistoryAction();
62	return result;	70	return result;
63	}	71	}
64		72
Lines 76-86 Link Here
76		84
77	public void remember(IRegion region) {	85	public void remember(IRegion region) {
78	fHistory.add(region);	86	fHistory.add(region);
79	fHistoryAction.update();	87	updateHistoryAction();
80	}	88	}
81		89
82	public void setHistoryAction(StructureSelectHistoryAction action) {	90	public void setHistoryAction(IAction action) {
83	Assert.isNotNull(action);	91	Assert.isNotNull(action);
84	fHistoryAction = action;	92
		93	if (fHistoryActions == null)
		94	fHistoryActions = new ArrayList();
		95	if (!fHistoryActions.contains(action))
		96	fHistoryActions.add(action);
		97
		98	// update action
		99	if (fHistory != null && !fHistory.isEmpty())
		100	action.setEnabled(true);
		101	else
		102	action.setEnabled(false);
		103	}
		104
		105	private void updateHistoryAction() {
		106	if (fHistoryActions != null && !fHistoryActions.isEmpty()) {
		107	boolean enabled = false;
		108	if (fHistory != null && !fHistory.isEmpty())
		109	enabled = true;
		110
		111	Iterator iter = fHistoryActions.iterator();
		112	while (iter.hasNext()) {
		113	((IAction)iter.next()).setEnabled(enabled);
		114	}
		115	}
85	}	116	}
86	}	117	}

Added Link Here

(-)src/org/eclipse/wst/sse/ui/internal/search/FindOccurrencesActionDelegate.java (+147 lines)
1	/*******************************************************************************
2	* Copyright (c) 2005 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	*******************************************************************************/
12
13	package org.eclipse.wst.sse.ui.internal.search;
14
15	import java.util.Iterator;
16	import java.util.List;
17
18	import org.eclipse.core.resources.IFile;
19	import org.eclipse.jface.action.IAction;
20	import org.eclipse.jface.text.BadLocationException;
21	import org.eclipse.jface.text.IDocument;
22	import org.eclipse.jface.text.ITextSelection;
23	import org.eclipse.jface.text.ITypedRegion;
24	import org.eclipse.jface.viewers.ISelection;
25	import org.eclipse.swt.widgets.Event;
26	import org.eclipse.ui.IActionDelegate2;
27	import org.eclipse.ui.IEditorActionDelegate;
28	import org.eclipse.ui.IEditorPart;
29	import org.eclipse.ui.IFileEditorInput;
30	import org.eclipse.ui.IViewActionDelegate;
31	import org.eclipse.ui.IViewPart;
32	import org.eclipse.ui.texteditor.ITextEditor;
33	import org.eclipse.wst.sse.ui.internal.SSEUIMessages;
34	import org.eclipse.wst.sse.ui.internal.util.PlatformStatusLineUtil;
35
36	/**
37	* Performs the appropriate FindOccurrencesProcessor action call based on
38	* selection. Clients can add processors for different partitions via
39	* <code>getProcessors</code>
40	*
41	*/
42	abstract public class FindOccurrencesActionDelegate implements IEditorActionDelegate, IActionDelegate2, IViewActionDelegate {
43	private IEditorPart fEditor;
44
45	public void setActiveEditor(IAction action, IEditorPart targetEditor) {
46	fEditor = targetEditor;
47	}
48
49	public void dispose() {
50	// nulling out just in case
51	fEditor = null;
52	}
53
54	public void init(IAction action) {
55	if (action != null) {
56	action.setText(SSEUIMessages.FindOccurrences_label);
57	}
58	}
59
60	public void runWithEvent(IAction action, Event event) {
61	run(action);
62	}
63
64	public void run(IAction action) {
65	boolean okay = false;
66	if (fEditor instanceof ITextEditor) {
67	ITextEditor textEditor = (ITextEditor) fEditor;
68	IDocument document = textEditor.getDocumentProvider().getDocument(textEditor.getEditorInput());
69	if (document != null) {
70	ITextSelection textSelection = getTextSelection(textEditor);
71	FindOccurrencesProcessor findOccurrenceProcessor = getProcessorForCurrentSelection(document, textSelection);
72	if (findOccurrenceProcessor != null) {
73	if (textEditor.getEditorInput() instanceof IFileEditorInput) {
74	IFile file = ((IFileEditorInput) textEditor.getEditorInput()).getFile();
75	okay = findOccurrenceProcessor.findOccurrences(document, textSelection, file);
76	}
77	}
78	}
79	}
80	if (okay) {
81	// clear status message
82	PlatformStatusLineUtil.clearStatusLine();
83	}
84	else {
85	String errorMessage = SSEUIMessages.FindOccurrencesActionProvider_0; //$NON-NLS-1$
86	PlatformStatusLineUtil.displayErrorMessage(errorMessage);
87	PlatformStatusLineUtil.addOneTimeClearListener();
88	}
89	}
90
91	public void init(IViewPart view) {
92	// do nothing
93	}
94
95	public void selectionChanged(IAction action, ISelection selection) {
96	// clear status message
97	PlatformStatusLineUtil.clearStatusLine();
98	}
99
100	/**
101	* Get the appropriate find occurrences processor
102	*
103	* @param document -
104	* assumes not null
105	* @param textSelection
106	* @return
107	*/
108	private FindOccurrencesProcessor getProcessorForCurrentSelection(IDocument document, ITextSelection textSelection) {
109	// check if we have an action that's enabled on the current partition
110	ITypedRegion tr = getPartition(document, textSelection);
111	String partition = tr != null ? tr.getType() : ""; //$NON-NLS-1$
112
113	Iterator it = getProcessors().iterator();
114	FindOccurrencesProcessor action = null;
115	while (it.hasNext()) {
116	action = (FindOccurrencesProcessor) it.next();
117	// we just choose the first action that can handle the partition
118	if (action.enabledForParitition(partition))
119	return action;
120	}
121	return null;
122	}
123
124	private ITypedRegion getPartition(IDocument document, ITextSelection textSelection) {
125	ITypedRegion region = null;
126	if (textSelection != null) {
127	try {
128	region = document.getPartition(textSelection.getOffset());
129	}
130	catch (BadLocationException e) {
131	region = null;
132	}
133	}
134	return region;
135	}
136
137	private ITextSelection getTextSelection(ITextEditor textEditor) {
138	ITextSelection textSelection = null;
139	ISelection selection = textEditor.getSelectionProvider().getSelection();
140	if (selection instanceof ITextSelection && !selection.isEmpty()) {
141	textSelection = (ITextSelection) selection;
142	}
143	return textSelection;
144	}
145
146	abstract protected List getProcessors();
147	}