| /******************************************************************************* |
| * Copyright (c) 2005, 2017 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * xored software, Inc. - initial API and implementation |
| * xored software, Inc. - fix tab handling (Bug# 200024) (Alex Panchenko) |
| *******************************************************************************/ |
| package org.eclipse.dltk.internal.ui.editor; |
| |
| import java.text.CharacterIterator; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Stack; |
| |
| import org.eclipse.core.filebuffers.IPersistableAnnotationModel; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.ProjectScope; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IConfigurationElement; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.ListenerList; |
| import org.eclipse.core.runtime.Platform; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.core.runtime.jobs.Job; |
| import org.eclipse.core.runtime.preferences.DefaultScope; |
| import org.eclipse.core.runtime.preferences.InstanceScope; |
| import org.eclipse.dltk.compiler.CharOperation; |
| import org.eclipse.dltk.core.DLTKCore; |
| import org.eclipse.dltk.core.DLTKLanguageManager; |
| import org.eclipse.dltk.core.IDLTKLanguageToolkit; |
| import org.eclipse.dltk.core.IImportDeclaration; |
| import org.eclipse.dltk.core.ILocalVariable; |
| import org.eclipse.dltk.core.IMember; |
| import org.eclipse.dltk.core.IModelElement; |
| import org.eclipse.dltk.core.IPackageDeclaration; |
| import org.eclipse.dltk.core.IScriptLanguageProvider; |
| import org.eclipse.dltk.core.IScriptProject; |
| import org.eclipse.dltk.core.ISourceModule; |
| import org.eclipse.dltk.core.ISourceRange; |
| import org.eclipse.dltk.core.ISourceReference; |
| import org.eclipse.dltk.core.ModelException; |
| import org.eclipse.dltk.core.PreferencesLookupDelegate; |
| import org.eclipse.dltk.core.ScriptModelUtil; |
| import org.eclipse.dltk.internal.ui.BrowserInformationControl; |
| import org.eclipse.dltk.internal.ui.actions.CompositeActionGroup; |
| import org.eclipse.dltk.internal.ui.actions.FoldingActionGroup; |
| import org.eclipse.dltk.internal.ui.actions.refactoring.RefactorActionGroup; |
| import org.eclipse.dltk.internal.ui.editor.SourceModuleDocumentProvider.SourceModuleAnnotationModel; |
| import org.eclipse.dltk.internal.ui.editor.selectionaction.GoToNextPreviousMemberAction; |
| import org.eclipse.dltk.internal.ui.editor.semantic.highlighting.SemanticHighlightingManager; |
| import org.eclipse.dltk.internal.ui.editor.semantic.highlighting.SemanticHighlightingReconciler; |
| import org.eclipse.dltk.internal.ui.text.DLTKWordIterator; |
| import org.eclipse.dltk.internal.ui.text.DocumentCharacterIterator; |
| import org.eclipse.dltk.internal.ui.text.HTMLTextPresenter; |
| import org.eclipse.dltk.internal.ui.text.IScriptReconcilingListener; |
| import org.eclipse.dltk.internal.ui.text.hover.ScriptExpandHover; |
| import org.eclipse.dltk.internal.ui.text.hover.SourceViewerInformationControl; |
| import org.eclipse.dltk.ui.CodeFormatterConstants; |
| import org.eclipse.dltk.ui.DLTKUILanguageManager; |
| import org.eclipse.dltk.ui.DLTKUIPlugin; |
| import org.eclipse.dltk.ui.EclipsePreferencesAdapter; |
| import org.eclipse.dltk.ui.IContextMenuConstants; |
| import org.eclipse.dltk.ui.IDLTKUILanguageToolkit; |
| import org.eclipse.dltk.ui.IWorkingCopyManager; |
| import org.eclipse.dltk.ui.PreferenceConstants; |
| import org.eclipse.dltk.ui.PreferencesAdapter; |
| import org.eclipse.dltk.ui.actions.DLTKActionConstants; |
| import org.eclipse.dltk.ui.actions.GenerateActionGroup; |
| import org.eclipse.dltk.ui.actions.IScriptEditorActionDefinitionIds; |
| import org.eclipse.dltk.ui.actions.OpenEditorActionGroup; |
| import org.eclipse.dltk.ui.actions.OpenViewActionGroup; |
| import org.eclipse.dltk.ui.actions.SearchActionGroup; |
| import org.eclipse.dltk.ui.editor.IScriptAnnotation; |
| import org.eclipse.dltk.ui.editor.highlighting.ISemanticHighlightingUpdater; |
| import org.eclipse.dltk.ui.formatter.IScriptFormatterFactory; |
| import org.eclipse.dltk.ui.formatter.ScriptFormatterManager; |
| import org.eclipse.dltk.ui.formatter.internal.ScriptFormattingContextProperties; |
| import org.eclipse.dltk.ui.text.ScriptSourceViewerConfiguration; |
| import org.eclipse.dltk.ui.text.ScriptTextTools; |
| import org.eclipse.dltk.ui.text.folding.FoldingProviderManager; |
| import org.eclipse.dltk.ui.text.folding.IFoldingStructureProvider; |
| import org.eclipse.dltk.ui.text.folding.IFoldingStructureProviderExtension; |
| import org.eclipse.dltk.ui.text.templates.ITemplateAccess; |
| import org.eclipse.jface.action.Action; |
| import org.eclipse.jface.action.GroupMarker; |
| import org.eclipse.jface.action.IAction; |
| import org.eclipse.jface.action.IMenuManager; |
| import org.eclipse.jface.action.MenuManager; |
| import org.eclipse.jface.dialogs.MessageDialog; |
| import org.eclipse.jface.preference.IPreferenceStore; |
| import org.eclipse.jface.resource.JFaceResources; |
| import org.eclipse.jface.text.BadLocationException; |
| import org.eclipse.jface.text.BadPositionCategoryException; |
| import org.eclipse.jface.text.DefaultInformationControl; |
| import org.eclipse.jface.text.DocumentCommand; |
| import org.eclipse.jface.text.DocumentEvent; |
| import org.eclipse.jface.text.IDocument; |
| import org.eclipse.jface.text.IInformationControlCreator; |
| import org.eclipse.jface.text.IPositionUpdater; |
| import org.eclipse.jface.text.IRegion; |
| import org.eclipse.jface.text.ITextHover; |
| import org.eclipse.jface.text.ITextOperationTarget; |
| import org.eclipse.jface.text.ITextSelection; |
| import org.eclipse.jface.text.ITextViewerExtension2; |
| import org.eclipse.jface.text.ITextViewerExtension5; |
| import org.eclipse.jface.text.IWidgetTokenKeeper; |
| import org.eclipse.jface.text.Position; |
| import org.eclipse.jface.text.Region; |
| import org.eclipse.jface.text.TextSelection; |
| import org.eclipse.jface.text.contentassist.ContentAssistEvent; |
| import org.eclipse.jface.text.contentassist.ContentAssistant; |
| import org.eclipse.jface.text.contentassist.ICompletionListener; |
| import org.eclipse.jface.text.contentassist.ICompletionProposal; |
| import org.eclipse.jface.text.contentassist.IContentAssistant; |
| import org.eclipse.jface.text.contentassist.IContentAssistantExtension2; |
| import org.eclipse.jface.text.formatter.FormattingContextProperties; |
| import org.eclipse.jface.text.formatter.IFormattingContext; |
| import org.eclipse.jface.text.information.InformationPresenter; |
| import org.eclipse.jface.text.link.ILinkedModeListener; |
| import org.eclipse.jface.text.link.LinkedModeModel; |
| import org.eclipse.jface.text.link.LinkedModeUI; |
| import org.eclipse.jface.text.link.LinkedModeUI.ExitFlags; |
| import org.eclipse.jface.text.link.LinkedModeUI.IExitPolicy; |
| import org.eclipse.jface.text.reconciler.IReconciler; |
| import org.eclipse.jface.text.source.Annotation; |
| import org.eclipse.jface.text.source.AnnotationRulerColumn; |
| import org.eclipse.jface.text.source.CompositeRuler; |
| import org.eclipse.jface.text.source.IAnnotationModel; |
| import org.eclipse.jface.text.source.ICharacterPairMatcher; |
| import org.eclipse.jface.text.source.IOverviewRuler; |
| import org.eclipse.jface.text.source.ISourceViewer; |
| import org.eclipse.jface.text.source.ISourceViewerExtension2; |
| import org.eclipse.jface.text.source.IVerticalRuler; |
| import org.eclipse.jface.text.source.IVerticalRulerColumn; |
| import org.eclipse.jface.text.source.SourceViewerConfiguration; |
| import org.eclipse.jface.text.source.projection.ProjectionSupport; |
| import org.eclipse.jface.text.source.projection.ProjectionViewer; |
| import org.eclipse.jface.util.PropertyChangeEvent; |
| import org.eclipse.jface.viewers.DoubleClickEvent; |
| import org.eclipse.jface.viewers.IDoubleClickListener; |
| import org.eclipse.jface.viewers.IPostSelectionProvider; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.ISelectionChangedListener; |
| import org.eclipse.jface.viewers.ISelectionProvider; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.SelectionChangedEvent; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.custom.ST; |
| import org.eclipse.swt.custom.StyledText; |
| import org.eclipse.swt.events.VerifyEvent; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.graphics.Point; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.IPageLayout; |
| import org.eclipse.ui.IPartListener2; |
| import org.eclipse.ui.IPartService; |
| import org.eclipse.ui.ISelectionListener; |
| import org.eclipse.ui.IWorkbenchPage; |
| import org.eclipse.ui.IWorkbenchPart; |
| import org.eclipse.ui.IWorkbenchPartReference; |
| import org.eclipse.ui.IWorkbenchPartSite; |
| import org.eclipse.ui.IWorkbenchWindow; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.actions.ActionContext; |
| import org.eclipse.ui.actions.ActionGroup; |
| import org.eclipse.ui.editors.text.EditorsUI; |
| import org.eclipse.ui.part.IShowInTargetList; |
| import org.eclipse.ui.texteditor.AbstractDecoratedTextEditor; |
| import org.eclipse.ui.texteditor.AbstractDecoratedTextEditorPreferenceConstants; |
| import org.eclipse.ui.texteditor.ChainedPreferenceStore; |
| import org.eclipse.ui.texteditor.ContentAssistAction; |
| import org.eclipse.ui.texteditor.IDocumentProvider; |
| import org.eclipse.ui.texteditor.ITextEditorActionConstants; |
| import org.eclipse.ui.texteditor.ITextEditorActionDefinitionIds; |
| import org.eclipse.ui.texteditor.IUpdate; |
| import org.eclipse.ui.texteditor.SourceViewerDecorationSupport; |
| import org.eclipse.ui.texteditor.TextNavigationAction; |
| import org.eclipse.ui.texteditor.TextOperationAction; |
| import org.eclipse.ui.texteditor.templates.ITemplatesPage; |
| import org.eclipse.ui.views.contentoutline.ContentOutline; |
| import org.eclipse.ui.views.contentoutline.IContentOutlinePage; |
| |
| import com.ibm.icu.text.BreakIterator; |
| |
| public abstract class ScriptEditor extends AbstractDecoratedTextEditor |
| implements IScriptReconcilingListener, IScriptLanguageProvider, |
| IScriptEditor { |
| |
| /** The editor's save policy */ |
| protected ISavePolicy fSavePolicy = null; |
| |
| /** Preference key for matching brackets */ |
| protected final static String MATCHING_BRACKETS = PreferenceConstants.EDITOR_MATCHING_BRACKETS; |
| /** Preference key for matching brackets color */ |
| protected final static String MATCHING_BRACKETS_COLOR = PreferenceConstants.EDITOR_MATCHING_BRACKETS_COLOR; |
| |
| private ScriptEditorErrorTickUpdater fScriptEditorErrorTickUpdater; |
| |
| private OccurrencesFinder occurrencesFinder; |
| |
| private static String[] GLOBAL_FOLDING_PROPERTIES = { |
| PreferenceConstants.EDITOR_FOLDING_ENABLED, |
| PreferenceConstants.EDITOR_COMMENTS_FOLDING_ENABLED, |
| PreferenceConstants.EDITOR_FOLDING_LINES_LIMIT, |
| PreferenceConstants.EDITOR_COMMENT_FOLDING_JOIN_NEWLINES }; |
| |
| public ISourceViewer getScriptSourceViewer() { |
| return super.getSourceViewer(); |
| } |
| |
| public static class BracketLevel { |
| public int fOffset; |
| public int fLength; |
| public LinkedModeUI fUI; |
| public Position fFirstPosition; |
| public Position fSecondPosition; |
| } |
| |
| public class ExitPolicy implements IExitPolicy { |
| |
| public final char fExitCharacter; |
| public final char fEscapeCharacter; |
| public final Stack fStack; |
| public final int fSize; |
| |
| public ExitPolicy(char exitCharacter, char escapeCharacter, |
| Stack stack) { |
| fExitCharacter = exitCharacter; |
| fEscapeCharacter = escapeCharacter; |
| fStack = stack; |
| fSize = fStack.size(); |
| } |
| |
| /* |
| * @see |
| * org.eclipse.jdt.internal.ui.text.link.LinkedPositionUI.ExitPolicy |
| * #doExit(org.eclipse.jdt.internal.ui.text.link.LinkedPositionManager, |
| * org.eclipse.swt.events.VerifyEvent, int, int) |
| */ |
| @Override |
| public ExitFlags doExit(LinkedModeModel model, VerifyEvent event, |
| int offset, int length) { |
| |
| if (fSize == fStack.size() && !isMasked(offset)) { |
| if (event.character == fExitCharacter) { |
| BracketLevel level = (BracketLevel) fStack.peek(); |
| if (level.fFirstPosition.offset > offset |
| || level.fSecondPosition.offset < offset) |
| return null; |
| if (level.fSecondPosition.offset == offset && length == 0) |
| // don't enter the character if if its the closing peer |
| return new ExitFlags(ILinkedModeListener.UPDATE_CARET, |
| false); |
| } |
| // when entering an anonymous class between the parenthesis', we |
| // don't want |
| // to jump after the closing parenthesis when return is pressed |
| if (event.character == SWT.CR && offset > 0) { |
| // ssanders: If completion popup is displayed, Enter |
| // dismisses it |
| if (((AdaptedSourceViewer) getScriptSourceViewer()).fInCompletionSession) |
| return new ExitFlags(ILinkedModeListener.NONE, true); |
| |
| IDocument document = getSourceViewer().getDocument(); |
| try { |
| if (document.getChar(offset - 1) == '{') |
| return new ExitFlags(ILinkedModeListener.EXIT_ALL, |
| true); |
| } catch (BadLocationException e) { |
| } |
| } |
| } |
| return null; |
| } |
| |
| private boolean isMasked(int offset) { |
| IDocument document = getSourceViewer().getDocument(); |
| try { |
| return fEscapeCharacter == document.getChar(offset - 1); |
| } catch (BadLocationException e) { |
| } |
| return false; |
| } |
| } |
| |
| static class ExclusivePositionUpdater implements IPositionUpdater { |
| |
| /** The position category. */ |
| private final String fCategory; |
| |
| /** |
| * Creates a new updater for the given <code>category</code>. |
| * |
| * @param category |
| * the new category. |
| */ |
| public ExclusivePositionUpdater(String category) { |
| fCategory = category; |
| } |
| |
| /* |
| * @see |
| * org.eclipse.jface.text.IPositionUpdater#update(org.eclipse.jface. |
| * text.DocumentEvent) |
| */ |
| @Override |
| public void update(DocumentEvent event) { |
| |
| int eventOffset = event.getOffset(); |
| int eventOldLength = event.getLength(); |
| int eventNewLength = event.getText() == null ? 0 |
| : event.getText().length(); |
| int deltaLength = eventNewLength - eventOldLength; |
| |
| try { |
| Position[] positions = event.getDocument() |
| .getPositions(fCategory); |
| |
| for (int i = 0; i != positions.length; i++) { |
| |
| Position position = positions[i]; |
| |
| if (position.isDeleted()) |
| continue; |
| |
| int offset = position.getOffset(); |
| int length = position.getLength(); |
| int end = offset + length; |
| |
| if (offset >= eventOffset + eventOldLength) |
| // position comes |
| // after change - shift |
| position.setOffset(offset + deltaLength); |
| else if (end <= eventOffset) { |
| // position comes way before change - |
| // leave alone |
| } else if (offset <= eventOffset |
| && end >= eventOffset + eventOldLength) { |
| // event completely internal to the position - adjust |
| // length |
| position.setLength(length + deltaLength); |
| } else if (offset < eventOffset) { |
| // event extends over end of position - adjust length |
| int newEnd = eventOffset; |
| position.setLength(newEnd - offset); |
| } else if (end > eventOffset + eventOldLength) { |
| // event extends from before position into it - adjust |
| // offset |
| // and length |
| // offset becomes end of event, length adjusted |
| // accordingly |
| int newOffset = eventOffset + eventNewLength; |
| position.setOffset(newOffset); |
| position.setLength(end - newOffset); |
| } else { |
| // event consumes the position - delete it |
| position.delete(); |
| } |
| } |
| } catch (BadPositionCategoryException e) { |
| // ignore and return |
| } |
| } |
| |
| /** |
| * Returns the position category. |
| * |
| * @return the position category |
| */ |
| public String getCategory() { |
| return fCategory; |
| } |
| |
| } |
| |
| /** |
| * Text operation code for requesting common prefix completion. |
| */ |
| public static final int CONTENTASSIST_COMPLETE_PREFIX = 60; |
| |
| interface ITextConverter { |
| void customizeDocumentCommand(IDocument document, |
| DocumentCommand command); |
| } |
| |
| class AdaptedSourceViewer extends ScriptSourceViewer |
| implements ICompletionListener { |
| private List<ITextConverter> fTextConverters; |
| |
| private boolean fIgnoreTextConverters = false; |
| private boolean fInCompletionSession; |
| |
| protected IContentAssistant getContentAssistant() { |
| return fContentAssistant; |
| } |
| |
| public AdaptedSourceViewer(Composite parent, |
| IVerticalRuler verticalRuler, IOverviewRuler overviewRuler, |
| boolean showAnnotationsOverview, int styles, |
| IPreferenceStore store) { |
| super(parent, verticalRuler, overviewRuler, showAnnotationsOverview, |
| styles, store); |
| } |
| |
| @Override |
| public void configure(SourceViewerConfiguration configuration) { |
| super.configure(configuration); |
| |
| final IContentAssistant ca = getContentAssistant(); |
| if (ca instanceof IContentAssistantExtension2) { |
| ((IContentAssistantExtension2) ca).addCompletionListener(this); |
| } |
| } |
| |
| @Override |
| public void unconfigure() { |
| final IContentAssistant ca = getContentAssistant(); |
| if (ca instanceof IContentAssistantExtension2) { |
| ((IContentAssistantExtension2) ca) |
| .removeCompletionListener(this); |
| } |
| |
| super.unconfigure(); |
| } |
| |
| /* |
| * @see ITextOperationTarget#doOperation(int) |
| */ |
| @Override |
| public void doOperation(int operation) { |
| |
| if (getTextWidget() == null) |
| return; |
| |
| switch (operation) { |
| case CONTENTASSIST_PROPOSALS: |
| String msg = fContentAssistant.showPossibleCompletions(); |
| setStatusLineErrorMessage(msg); |
| return; |
| case QUICK_ASSIST: |
| /* |
| * XXX: We can get rid of this once the SourceViewer has a way |
| * to update the status line |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=133787 |
| */ |
| msg = fQuickAssistAssistant.showPossibleQuickAssists(); |
| setStatusLineErrorMessage(msg); |
| return; |
| case UNDO: |
| fIgnoreTextConverters = true; |
| super.doOperation(operation); |
| fIgnoreTextConverters = false; |
| return; |
| case REDO: |
| fIgnoreTextConverters = true; |
| super.doOperation(operation); |
| fIgnoreTextConverters = false; |
| return; |
| } |
| |
| super.doOperation(operation); |
| } |
| |
| public void insertTextConverter(ITextConverter textConverter, |
| int index) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public void addTextConverter(ITextConverter textConverter) { |
| if (fTextConverters == null) { |
| fTextConverters = new ArrayList<>(1); |
| fTextConverters.add(textConverter); |
| } else if (!fTextConverters.contains(textConverter)) |
| fTextConverters.add(textConverter); |
| } |
| |
| public void removeTextConverter(ITextConverter textConverter) { |
| if (fTextConverters != null) { |
| fTextConverters.remove(textConverter); |
| if (fTextConverters.size() == 0) |
| fTextConverters = null; |
| } |
| } |
| |
| /* |
| * @see TextViewer#customizeDocumentCommand(DocumentCommand) |
| */ |
| @Override |
| protected void customizeDocumentCommand(DocumentCommand command) { |
| super.customizeDocumentCommand(command); |
| if (!fIgnoreTextConverters && fTextConverters != null) { |
| for (ITextConverter c : fTextConverters) |
| c.customizeDocumentCommand(getDocument(), command); |
| } |
| } |
| |
| @Override |
| public boolean requestWidgetToken(IWidgetTokenKeeper requester) { |
| if (PlatformUI.getWorkbench().getHelpSystem() |
| .isContextHelpDisplayed()) |
| return false; |
| return super.requestWidgetToken(requester); |
| } |
| |
| @Override |
| public boolean requestWidgetToken(IWidgetTokenKeeper requester, |
| int priority) { |
| if (PlatformUI.getWorkbench().getHelpSystem() |
| .isContextHelpDisplayed()) |
| return false; |
| return super.requestWidgetToken(requester, priority); |
| } |
| |
| @Override |
| public void assistSessionEnded(ContentAssistEvent event) { |
| fInCompletionSession = false; |
| } |
| |
| @Override |
| public void assistSessionStarted(ContentAssistEvent event) { |
| fInCompletionSession = true; |
| } |
| |
| @Override |
| public void selectionChanged(ICompletionProposal proposal, |
| boolean smartToggle) { |
| } |
| |
| private IProject getProject() { |
| final IModelElement input = getInputModelElement(); |
| if (input != null) { |
| final IScriptProject scriptProject = input.getScriptProject(); |
| if (scriptProject != null) { |
| return scriptProject.getProject(); |
| } |
| } |
| return null; |
| } |
| |
| private ISourceModule getSourceModule() { |
| final IModelElement input = getInputModelElement(); |
| if (input != null) { |
| return (ISourceModule) input |
| .getAncestor(IModelElement.SOURCE_MODULE); |
| } |
| return null; |
| } |
| |
| @Override |
| public IFormattingContext createFormattingContext() { |
| final IFormattingContext context = super.createFormattingContext(); |
| context.setProperty(ScriptFormattingContextProperties.MODULE, |
| getSourceModule()); |
| final IProject project = getProject(); |
| context.setProperty( |
| ScriptFormattingContextProperties.CONTEXT_PROJECT, project); |
| final IScriptFormatterFactory factory = ScriptFormatterManager |
| .getSelected(getLanguageToolkit().getNatureId(), project); |
| if (factory != null) { |
| context.setProperty( |
| ScriptFormattingContextProperties.CONTEXT_FORMATTER_ID, |
| factory.getId()); |
| final Map<String, String> preferences = factory |
| .retrievePreferences( |
| new PreferencesLookupDelegate(project)); |
| context.setProperty( |
| FormattingContextProperties.CONTEXT_PREFERENCES, |
| preferences); |
| } |
| return context; |
| } |
| } |
| |
| /** |
| * Internal implementation class for a change listener. |
| * |
| * |
| */ |
| protected abstract class AbstractSelectionChangedListener |
| implements ISelectionChangedListener { |
| /** |
| * Installs this selection changed listener with the given selection |
| * provider. If the selection provider is a post selection provider, |
| * post selection changed events are the preferred choice, otherwise |
| * normal selection changed events are requested. |
| * |
| * @param selectionProvider |
| */ |
| public void install(ISelectionProvider selectionProvider) { |
| if (selectionProvider == null) |
| return; |
| if (selectionProvider instanceof IPostSelectionProvider) { |
| IPostSelectionProvider provider = (IPostSelectionProvider) selectionProvider; |
| provider.addPostSelectionChangedListener(this); |
| } else { |
| selectionProvider.addSelectionChangedListener(this); |
| } |
| } |
| |
| /** |
| * Removes this selection changed listener from the given selection |
| * provider. |
| * |
| * @param selectionProvider |
| * the selection provider |
| */ |
| public void uninstall(ISelectionProvider selectionProvider) { |
| if (selectionProvider == null) |
| return; |
| if (selectionProvider instanceof IPostSelectionProvider) { |
| IPostSelectionProvider provider = (IPostSelectionProvider) selectionProvider; |
| provider.removePostSelectionChangedListener(this); |
| } else { |
| selectionProvider.removeSelectionChangedListener(this); |
| } |
| } |
| } |
| |
| /** |
| * Updates the selection in the editor's widget with the selection of the |
| * outline page. |
| */ |
| class OutlineSelectionChangedListener |
| extends AbstractSelectionChangedListener { |
| @Override |
| public void selectionChanged(SelectionChangedEvent event) { |
| doSelectionChanged(event); |
| } |
| } |
| |
| private ScriptOutlinePage fOutlinePage; |
| |
| private ProjectionSupport fProjectionSupport; |
| |
| /** |
| * This editor's projection model updater |
| */ |
| private IFoldingStructureProvider fProjectionModelUpdater; |
| |
| /** |
| * The action group for folding. |
| */ |
| private ActionGroup fFoldingGroup; |
| |
| /** The information presenter. */ |
| private InformationPresenter fInformationPresenter; |
| |
| private CompositeActionGroup fContextMenuGroup; |
| |
| // private SelectionHistory fSelectionHistory; |
| |
| private CompositeActionGroup fActionGroups; |
| |
| private AbstractSelectionChangedListener fOutlineSelectionChangedListener = new OutlineSelectionChangedListener(); |
| |
| /** |
| * Updates the script outline page selection and this editor's range |
| * indicator. |
| * |
| * |
| */ |
| private class EditorSelectionChangedListener |
| extends AbstractSelectionChangedListener { |
| /* |
| * @see |
| * org.eclipse.jface.viewers.ISelectionChangedListener#selectionChanged |
| * (org.eclipse.jface.viewers.SelectionChangedEvent) |
| */ |
| @Override |
| public void selectionChanged(SelectionChangedEvent event) { |
| // XXX: see https://bugs.eclipse.org/bugs/show_bug.cgi?id=56161 |
| ScriptEditor.this.selectionChanged(); |
| } |
| } |
| |
| /** |
| * The editor selection changed listener. |
| */ |
| private EditorSelectionChangedListener fEditorSelectionChangedListener; |
| |
| public ScriptEditor() { |
| super(); |
| setDocumentProvider( |
| DLTKUIPlugin.getDefault().getSourceModuleDocumentProvider()); |
| fScriptEditorErrorTickUpdater = new ScriptEditorErrorTickUpdater(this); |
| } |
| |
| /** |
| * @see org.eclipse.ui.texteditor.StatusTextEditor#handleElementContentReplaced() |
| */ |
| @Override |
| protected void handleElementContentReplaced() { |
| super.handleElementContentReplaced(); |
| |
| IAnnotationModel annotationModel = getScriptSourceViewer() |
| .getAnnotationModel(); |
| if (annotationModel instanceof IPersistableAnnotationModel) { |
| try { |
| ((IPersistableAnnotationModel) annotationModel) |
| .reinitialize(getScriptSourceViewer().getDocument()); |
| } catch (CoreException ex) { |
| ex.printStackTrace(); |
| } |
| } |
| } |
| |
| @Override |
| public void dispose() { |
| |
| if (fProjectionModelUpdater != null) { |
| fProjectionModelUpdater.uninstall(); |
| fProjectionModelUpdater = null; |
| } |
| if (occurrencesFinder != null) { |
| occurrencesFinder.dispose(); |
| occurrencesFinder = null; |
| } |
| |
| // ISourceViewer sourceViewer= getSourceViewer(); |
| // if (sourceViewer instanceof ITextViewerExtension) |
| // ((ITextViewerExtension) |
| // sourceViewer).removeVerifyKeyListener(fBracketInserter); |
| |
| if (fScriptEditorErrorTickUpdater != null) { |
| fScriptEditorErrorTickUpdater.dispose(); |
| fScriptEditorErrorTickUpdater = null; |
| } |
| |
| // if (fCorrectionCommands != null) { |
| // fCorrectionCommands.deregisterCommands(); |
| // fCorrectionCommands= null; |
| // } |
| uninstallSemanticHighlighting(); |
| super.dispose(); |
| } |
| |
| @Override |
| protected void initializeEditor() { |
| occurrencesFinder = new OccurrencesFinder(this); |
| if (!occurrencesFinder.isValid()) { |
| occurrencesFinder = null; |
| } |
| IPreferenceStore store = createCombinedPreferenceStore(null); |
| setPreferenceStore(store); |
| ScriptTextTools textTools = getTextTools(); |
| if (textTools != null) { |
| setSourceViewerConfiguration( |
| textTools.createSourceViewerConfiguraton(store, this)); |
| } |
| } |
| |
| /** |
| * Creates and returns the preference store for this editor with the given |
| * input. |
| * |
| * @param input |
| * The editor input for which to create the preference store |
| * @return the preference store for this editor |
| */ |
| private IPreferenceStore createCombinedPreferenceStore(IEditorInput input) { |
| final List<IPreferenceStore> stores = new ArrayList<>(8); |
| final IScriptProject project = EditorUtility.getScriptProject(input); |
| final IDLTKLanguageToolkit toolkit = getLanguageToolkit(); |
| final String preferenceQualifier = toolkit.getPreferenceQualifier(); |
| if (project != null) { |
| if (preferenceQualifier != null) { |
| stores.add(new EclipsePreferencesAdapter( |
| new ProjectScope(project.getProject()), |
| preferenceQualifier)); |
| } |
| stores.add(new EclipsePreferencesAdapter( |
| new ProjectScope(project.getProject()), |
| DLTKCore.PLUGIN_ID)); |
| } |
| stores.add(getScriptPreferenceStore()); |
| if (preferenceQualifier != null) { |
| stores.add(new EclipsePreferencesAdapter(InstanceScope.INSTANCE, |
| preferenceQualifier)); |
| stores.add(new EclipsePreferencesAdapter(DefaultScope.INSTANCE, |
| preferenceQualifier)); |
| } |
| stores.add(new PreferencesAdapter( |
| DLTKCore.getDefault().getPluginPreferences())); |
| stores.add(EditorsUI.getPreferenceStore()); |
| stores.add(PlatformUI.getPreferenceStore()); |
| return new ChainedPreferenceStore( |
| stores.toArray(new IPreferenceStore[stores.size()])); |
| } |
| |
| public IPreferenceStore getScriptPreferenceStore() { |
| IDLTKLanguageToolkit toolkit = getLanguageToolkit(); |
| if (toolkit != null) { |
| IDLTKUILanguageToolkit uiToolkit = DLTKUILanguageManager |
| .getLanguageToolkit(toolkit.getNatureId()); |
| if (uiToolkit != null) { |
| return uiToolkit.getPreferenceStore(); |
| } |
| } |
| return null; |
| } |
| |
| public ScriptTextTools getTextTools() { |
| return null; |
| } |
| |
| protected void connectPartitioningToElement(IEditorInput input, |
| IDocument document) { |
| } |
| |
| protected void internalDoSetInput(IEditorInput input) throws CoreException { |
| ISourceViewer sourceViewer = getSourceViewer(); |
| ScriptSourceViewer scriptSourceViewer = null; |
| if (sourceViewer instanceof ScriptSourceViewer) |
| scriptSourceViewer = (ScriptSourceViewer) sourceViewer; |
| IPreferenceStore store = getPreferenceStore(); |
| |
| if (scriptSourceViewer != null && isFoldingEnabled() && (store == null |
| || !store.getBoolean(PreferenceConstants.EDITOR_SHOW_SEGMENTS))) |
| scriptSourceViewer.prepareDelayedProjection(); |
| |
| // correct connection code here. |
| |
| super.doSetInput(input); |
| |
| final IDocumentProvider docProvider = getDocumentProvider(); |
| final IAnnotationModel model = docProvider.getAnnotationModel(input); |
| if (model instanceof SourceModuleAnnotationModel) { |
| ((SourceModuleAnnotationModel) model).problemFactory = DLTKLanguageManager |
| .getProblemFactory(getNatureId()); |
| } |
| final IDocument doc = docProvider.getDocument(input); |
| connectPartitioningToElement(input, doc); |
| |
| if (scriptSourceViewer != null |
| && scriptSourceViewer.getReconciler() == null) { |
| IReconciler reconciler = getSourceViewerConfiguration() |
| .getReconciler(scriptSourceViewer); |
| if (reconciler != null) { |
| reconciler.install(scriptSourceViewer); |
| scriptSourceViewer.setReconciler(reconciler); |
| } |
| } |
| if (DLTKCore.DEBUG) { |
| System.err.println( |
| "TODO: Add encoding support and overriding indicator support"); //$NON-NLS-1$ |
| } |
| // if (fEncodingSupport != null) |
| // fEncodingSupport.reset(); |
| // if (isShowingOverrideIndicators()) |
| // installOverrideIndicator(false); |
| setOutlinePageInput(fOutlinePage, input); |
| } |
| |
| private boolean isFoldingEnabled() { |
| return getPreferenceStore() |
| .getBoolean(PreferenceConstants.EDITOR_FOLDING_ENABLED); |
| } |
| |
| @Override |
| public boolean isSaveAsAllowed() { |
| return true; |
| } |
| |
| /** |
| * Returns the standard action group of this editor. |
| * |
| * @return returns this editor's standard action group |
| */ |
| ActionGroup getActionGroup() { |
| return fActionGroups; |
| } |
| |
| /* |
| * @see AbstractTextEditor#editorContextMenuAboutToShow |
| */ |
| @Override |
| public void editorContextMenuAboutToShow(IMenuManager menu) { |
| super.editorContextMenuAboutToShow(menu); |
| |
| menu.insertAfter(IContextMenuConstants.GROUP_OPEN, |
| new GroupMarker(IContextMenuConstants.GROUP_SHOW)); |
| |
| ActionContext context = new ActionContext( |
| getSelectionProvider().getSelection()); |
| context.setInput(getEditorInput()); |
| fContextMenuGroup.setContext(context); |
| fContextMenuGroup.fillContextMenu(menu); |
| fContextMenuGroup.setContext(null); |
| // Quick views |
| menu.appendToGroup(IContextMenuConstants.GROUP_OPEN, |
| getAction(IScriptEditorActionDefinitionIds.SHOW_OUTLINE)); |
| menu.appendToGroup(IContextMenuConstants.GROUP_OPEN, |
| getAction(IScriptEditorActionDefinitionIds.OPEN_HIERARCHY)); |
| } |
| |
| @Override |
| protected void createActions() { |
| super.createActions(); |
| |
| ActionGroup oeg = new OpenEditorActionGroup(this); |
| ActionGroup ovg = new OpenViewActionGroup(this); |
| ActionGroup dsg = new SearchActionGroup(this); |
| |
| fActionGroups = new CompositeActionGroup( |
| new ActionGroup[] { oeg, ovg, dsg }); |
| |
| // fSelectionHistory= new SelectionHistory(this); |
| |
| fContextMenuGroup = new CompositeActionGroup( |
| new ActionGroup[] { oeg, ovg, dsg }); |
| loadContributedContextActionGroups(); |
| |
| fFoldingGroup = createFoldingActionGroup(); |
| |
| // ResourceAction resAction = new TextOperationAction(DLTKEditorMessages |
| // .getBundleForConstructedKeys(), "ShowDocumentaion.", this, |
| // ISourceViewer.INFORMATION, true); |
| // |
| // resAction = new InformationDispatchAction(DLTKEditorMessages |
| // .getBundleForConstructedKeys(), "ShowDocumentation.", |
| // (TextOperationAction) resAction); |
| // |
| // resAction |
| // .setActionDefinitionId(IScriptEditorActionDefinitionIds. |
| // SHOW_DOCUMENTATION); |
| // setAction("ShowDocumentation", resAction); |
| |
| Action action = new GotoMatchingBracketAction(this); |
| action.setActionDefinitionId( |
| IScriptEditorActionDefinitionIds.GOTO_MATCHING_BRACKET); |
| setAction(GotoMatchingBracketAction.GOTO_MATCHING_BRACKET, action); |
| |
| Action outlineAction = new TextOperationAction( |
| DLTKEditorMessages.getBundleForConstructedKeys(), |
| "ShowOutline.", this, //$NON-NLS-1$ |
| ScriptSourceViewer.SHOW_OUTLINE, true); |
| outlineAction.setActionDefinitionId( |
| IScriptEditorActionDefinitionIds.SHOW_OUTLINE); |
| setAction(IScriptEditorActionDefinitionIds.SHOW_OUTLINE, outlineAction); |
| |
| action = new TextOperationAction( |
| DLTKEditorMessages.getBundleForConstructedKeys(), |
| "OpenHierarchy.", this, ScriptSourceViewer.SHOW_HIERARCHY, //$NON-NLS-1$ |
| true); |
| action.setActionDefinitionId( |
| IScriptEditorActionDefinitionIds.OPEN_HIERARCHY); |
| setAction(IScriptEditorActionDefinitionIds.OPEN_HIERARCHY, action); |
| |
| // ContentAssistProposal |
| action = new ContentAssistAction( |
| DLTKEditorMessages.getBundleForConstructedKeys(), |
| "ContentAssistProposal.", this); //$NON-NLS-1$ |
| action.setActionDefinitionId( |
| ITextEditorActionDefinitionIds.CONTENT_ASSIST_PROPOSALS); |
| setAction("ContentAssistProposal", action); //$NON-NLS-1$ |
| markAsStateDependentAction("ContentAssistProposal", true); //$NON-NLS-1$ |
| |
| // ContentAssistContextInformation |
| action = new TextOperationAction( |
| DLTKEditorMessages.getBundleForConstructedKeys(), |
| "ContentAssistContextInformation.", this, //$NON-NLS-1$ |
| ISourceViewer.CONTENTASSIST_CONTEXT_INFORMATION); |
| action.setActionDefinitionId( |
| ITextEditorActionDefinitionIds.CONTENT_ASSIST_CONTEXT_INFORMATION); |
| setAction("ContentAssistContextInformation", action); //$NON-NLS-1$ |
| markAsStateDependentAction("ContentAssistContextInformation", true); //$NON-NLS-1$ |
| |
| // GroupEdit |
| ActionGroup rg = new RefactorActionGroup(this, |
| ITextEditorActionConstants.GROUP_EDIT); |
| fActionGroups.addGroup(rg); |
| fContextMenuGroup.addGroup(rg); |
| |
| // GoToNextMember |
| action = GoToNextPreviousMemberAction.newGoToNextMemberAction(this); |
| action.setActionDefinitionId( |
| IScriptEditorActionDefinitionIds.GOTO_NEXT_MEMBER); |
| setAction(GoToNextPreviousMemberAction.NEXT_MEMBER, action); |
| |
| // GoToPreviousMember |
| action = GoToNextPreviousMemberAction.newGoToPreviousMemberAction(this); |
| action.setActionDefinitionId( |
| IScriptEditorActionDefinitionIds.GOTO_PREVIOUS_MEMBER); |
| setAction(GoToNextPreviousMemberAction.PREVIOUS_MEMBER, action); |
| |
| // Source menu actions |
| action = new TextOperationAction( |
| DLTKEditorMessages.getBundleForConstructedKeys(), "Comment.", //$NON-NLS-1$ |
| this, ITextOperationTarget.PREFIX); |
| action.setActionDefinitionId(IScriptEditorActionDefinitionIds.COMMENT); |
| setAction(DLTKActionConstants.COMMENT, action); |
| markAsStateDependentAction(DLTKActionConstants.COMMENT, true); |
| |
| action = new TextOperationAction( |
| DLTKEditorMessages.getBundleForConstructedKeys(), "Uncomment.", //$NON-NLS-1$ |
| this, ITextOperationTarget.STRIP_PREFIX); |
| action.setActionDefinitionId( |
| IScriptEditorActionDefinitionIds.UNCOMMENT); |
| setAction(DLTKActionConstants.UNCOMMENT, action); |
| markAsStateDependentAction(DLTKActionConstants.UNCOMMENT, true); |
| |
| action = new ToggleCommentAction( |
| DLTKEditorMessages.getBundleForConstructedKeys(), |
| "ToggleComment.", this); //$NON-NLS-1$ |
| action.setActionDefinitionId( |
| IScriptEditorActionDefinitionIds.TOGGLE_COMMENT); |
| setAction(DLTKActionConstants.TOGGLE_COMMENT, action); |
| markAsStateDependentAction(DLTKActionConstants.TOGGLE_COMMENT, true); |
| |
| ISourceViewer sourceViewer = getSourceViewer(); |
| SourceViewerConfiguration configuration = getSourceViewerConfiguration(); |
| ((ToggleCommentAction) action).configure(sourceViewer, configuration); |
| |
| final ActionGroup generateActions = createGenerateActionGroup(); |
| if (generateActions != null) { |
| fActionGroups.addGroup(generateActions); |
| fContextMenuGroup.addGroup(generateActions); |
| } |
| } |
| |
| /** |
| * @since 3.0 |
| */ |
| protected ActionGroup createGenerateActionGroup() { |
| return new GenerateActionGroup(this, |
| ITextEditorActionConstants.GROUP_EDIT); |
| } |
| |
| private static final String EXTENSION_EDITOR_CONTEXT_ACTION_GROUPS = "editorContextActionGroup"; //$NON-NLS-1$ |
| private static final String ATTR_NATURE = "nature"; //$NON-NLS-1$ |
| private static final String ATTR_CLASS = "class"; //$NON-NLS-1$ |
| |
| private void loadContributedContextActionGroups() { |
| final IConfigurationElement[] elements = Platform.getExtensionRegistry() |
| .getConfigurationElementsFor(DLTKUIPlugin.PLUGIN_ID, |
| EXTENSION_EDITOR_CONTEXT_ACTION_GROUPS); |
| final String natureId = getNatureId(); |
| for (int i = 0; i < elements.length; ++i) { |
| final IConfigurationElement element = elements[i]; |
| final String elementNature = element.getAttribute(ATTR_NATURE); |
| if (elementNature == null || elementNature.equals(natureId)) { |
| try { |
| final Object actionGroup = element |
| .createExecutableExtension(ATTR_CLASS); |
| if (actionGroup instanceof ActionGroup) { |
| fContextMenuGroup.addGroup((ActionGroup) actionGroup); |
| } else { |
| DLTKUIPlugin.logErrorMessage( |
| actionGroup.getClass().getName() |
| + " should extend ActionGroup"); //$NON-NLS-1$ |
| } |
| } catch (CoreException e) { |
| DLTKUIPlugin.log(e); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Creates action group for folding. |
| * |
| * @return |
| * @since 3.0 |
| */ |
| protected ActionGroup createFoldingActionGroup() { |
| return new FoldingActionGroup(this, getViewer(), |
| getScriptPreferenceStore()); |
| } |
| |
| @Override |
| protected IVerticalRulerColumn createAnnotationRulerColumn( |
| CompositeRuler ruler) { |
| if (!getPreferenceStore() |
| .getBoolean(PreferenceConstants.EDITOR_ANNOTATION_ROLL_OVER)) |
| return super.createAnnotationRulerColumn(ruler); |
| |
| AnnotationRulerColumn column = new AnnotationRulerColumn( |
| VERTICAL_RULER_WIDTH, getAnnotationAccess()); |
| column.setHover(new ScriptExpandHover(ruler, getAnnotationAccess(), |
| new IDoubleClickListener() { |
| |
| @Override |
| public void doubleClick(DoubleClickEvent event) { |
| // for now: just invoke ruler double click action |
| triggerAction( |
| ITextEditorActionConstants.RULER_DOUBLE_CLICK); |
| } |
| |
| private void triggerAction(String actionID) { |
| IAction action = getAction(actionID); |
| if (action != null) { |
| if (action instanceof IUpdate) |
| ((IUpdate) action).update(); |
| // hack to propagate line change |
| if (action instanceof ISelectionListener) { |
| ((ISelectionListener) action) |
| .selectionChanged(null, null); |
| } |
| if (action.isEnabled()) |
| action.run(); |
| } |
| } |
| |
| })); |
| |
| return column; |
| } |
| |
| /** |
| * Returns the folding action group, or <code>null</code> if there is none. |
| * |
| * @return the folding action group, or <code>null</code> if there is none |
| * |
| */ |
| ActionGroup getFoldingActionGroup() { |
| return fFoldingGroup; |
| } |
| |
| public final ISourceViewer getViewer() { |
| return getSourceViewer(); |
| } |
| |
| @Override |
| protected void doSetInput(IEditorInput input) throws CoreException { |
| ISourceViewer sourceViewer = getSourceViewer(); |
| if (!(sourceViewer instanceof ISourceViewerExtension2)) { |
| setPreferenceStore(createCombinedPreferenceStore(input)); |
| try { |
| internalDoSetInput(input); |
| } catch (ModelException e) { |
| DLTKUIPlugin.log(e); |
| this.close(false); |
| } |
| } else { |
| // uninstall & unregister preference store listener |
| getSourceViewerDecorationSupport(sourceViewer).uninstall(); |
| ((ISourceViewerExtension2) sourceViewer).unconfigure(); |
| setPreferenceStore(createCombinedPreferenceStore(input)); |
| // install & register preference store listener |
| sourceViewer.configure(getSourceViewerConfiguration()); |
| getSourceViewerDecorationSupport(sourceViewer) |
| .install(getPreferenceStore()); |
| try { |
| internalDoSetInput(input); |
| } catch (ModelException e) { |
| DLTKUIPlugin.log(e); |
| this.close(false); |
| } |
| } |
| |
| if (fScriptEditorErrorTickUpdater != null) |
| fScriptEditorErrorTickUpdater |
| .updateEditorImage(getInputModelElement()); |
| } |
| |
| @Override |
| protected void setPreferenceStore(IPreferenceStore store) { |
| super.setPreferenceStore(store); |
| final SourceViewerConfiguration svConfiguration = getSourceViewerConfiguration(); |
| if (svConfiguration == null |
| || svConfiguration instanceof ScriptSourceViewerConfiguration) { |
| final ScriptTextTools textTools = getTextTools(); |
| if (textTools != null) { |
| setSourceViewerConfiguration( |
| textTools.createSourceViewerConfiguraton(store, this)); |
| } |
| } |
| if (getSourceViewer() instanceof ScriptSourceViewer) { |
| ((ScriptSourceViewer) getSourceViewer()).setPreferenceStore(store); |
| } |
| if (occurrencesFinder != null) { |
| occurrencesFinder.setPreferenceStore(store); |
| } |
| } |
| |
| private ScriptOutlinePage createOutlinePage() { |
| final ScriptOutlinePage page = doCreateOutlinePage(); |
| fOutlineSelectionChangedListener.install(page); |
| setOutlinePageInput(page, getEditorInput()); |
| return page; |
| } |
| |
| /** |
| * Creates the outline page used with this editor. |
| * |
| * @return the created script outline page |
| */ |
| protected ScriptOutlinePage doCreateOutlinePage() { |
| return new ScriptOutlinePage(this, getPreferenceStore()); |
| } |
| |
| /** |
| * String identifiying concrete language editor. Used for ex. for fetching |
| * available filters |
| * |
| * @return |
| */ |
| public abstract String getEditorId(); |
| |
| /** |
| * Informs the editor that its outliner has been closed. |
| */ |
| @Override |
| public void outlinePageClosed() { |
| if (fOutlinePage != null) { |
| fOutlineSelectionChangedListener.uninstall(fOutlinePage); |
| fOutlinePage = null; |
| resetHighlightRange(); |
| } |
| } |
| |
| private void setOutlinePageInput(ScriptOutlinePage page, |
| IEditorInput input) { |
| if (page == null) { |
| return; |
| } |
| IModelElement me = getInputModelElement(); |
| if (me != null && me.exists()) { |
| page.setInput(me); |
| } else { |
| page.setInput(null); |
| } |
| } |
| |
| /** |
| * The templates page. |
| * |
| * @since 3.0 |
| */ |
| private ScriptTemplatesPage fTemplatesPage; |
| |
| /** |
| * Creates the templates page used with this editor. |
| * |
| * @return the created script templates page |
| * @since 3.0 |
| */ |
| protected ScriptTemplatesPage createTemplatesPage() { |
| final IDLTKUILanguageToolkit uiToolkit = getUILanguageToolkit(); |
| if (uiToolkit == null) { |
| return null; |
| } |
| final ITemplateAccess templateAccess = uiToolkit.getEditorTemplates(); |
| if (templateAccess == null) { |
| return null; |
| } |
| try { |
| return new ScriptTemplatesPage(this, templateAccess); |
| } catch (Throwable e) { |
| return null; |
| } |
| } |
| |
| @SuppressWarnings("unchecked") |
| @Override |
| public <T> T getAdapter(Class<T> required) { |
| if (ITemplatesPage.class.equals(required)) { |
| if (fTemplatesPage == null) |
| fTemplatesPage = createTemplatesPage(); |
| return (T) fTemplatesPage; |
| } |
| if (IContentOutlinePage.class.equals(required)) { |
| if (fOutlinePage == null) |
| fOutlinePage = createOutlinePage(); |
| return (T) fOutlinePage; |
| } |
| if (required == IShowInTargetList.class) { |
| return (T) (IShowInTargetList) () -> new String[] { |
| DLTKUIPlugin.ID_SCRIPT_EXPLORER, IPageLayout.ID_OUTLINE }; |
| } |
| if (required == OccurrencesFinder.class) { |
| return (T) occurrencesFinder; |
| } |
| if (required == IFoldingStructureProvider.class) |
| return (T) fProjectionModelUpdater; |
| if (required == IFoldingStructureProviderExtension.class) |
| return (T) fProjectionModelUpdater; |
| |
| if (fProjectionSupport != null) { |
| Object adapter = fProjectionSupport.getAdapter(getSourceViewer(), |
| required); |
| if (adapter != null) |
| return (T) adapter; |
| } |
| |
| return super.getAdapter(required); |
| } |
| |
| /** |
| * Returns the mutex for the reconciler. See |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=63898 for a description of |
| * the problem. |
| * <p> |
| * XXX remove once the underlying problem |
| * (https://bugs.eclipse.org/bugs/show_bug.cgi?id=66176) is solved. |
| * </p> |
| * |
| * @return the lock reconcilers may use to synchronize on |
| */ |
| public Object getReconcilerLock() { |
| return fReconcilerLock; |
| } |
| |
| protected void doSelectionChanged(SelectionChangedEvent event) { |
| ISourceReference reference = null; |
| ISelection selection = event.getSelection(); |
| Iterator<?> iter = ((IStructuredSelection) selection).iterator(); |
| while (iter.hasNext()) { |
| Object o = iter.next(); |
| if (o instanceof ISourceReference) { |
| reference = (ISourceReference) o; |
| break; |
| } |
| } |
| if (!isActivePart() && DLTKUIPlugin.getActivePage() != null) |
| DLTKUIPlugin.getActivePage().bringToTop(this); |
| setSelection(reference, !isActivePart()); |
| if (occurrencesFinder != null) { |
| occurrencesFinder.updateOccurrenceAnnotations(); |
| } |
| } |
| |
| protected boolean isActivePart() { |
| IWorkbenchPart part = getActivePart(); |
| return part != null && part.equals(this); |
| } |
| |
| private IWorkbenchPart getActivePart() { |
| IWorkbenchWindow window = getSite().getWorkbenchWindow(); |
| IPartService service = window.getPartService(); |
| IWorkbenchPart part = service.getActivePart(); |
| return part; |
| } |
| |
| protected void setSelection(ISourceReference reference, |
| boolean moveCursor) { |
| if (getSelectionProvider() == null) |
| return; |
| ISelection selection = getSelectionProvider().getSelection(); |
| if (selection instanceof TextSelection) { |
| TextSelection textSelection = (TextSelection) selection; |
| // PR 39995: [navigation] Forward history cleared after going back |
| // in navigation history: |
| // mark only in navigation history if the cursor is being moved |
| // (which it isn't if |
| // this is called from a PostSelectionEvent that should only update |
| // the magnet) |
| if (moveCursor && (textSelection.getOffset() != 0 |
| || textSelection.getLength() != 0)) |
| markInNavigationHistory(); |
| } |
| if (reference != null) { |
| StyledText textWidget = null; |
| ISourceViewer sourceViewer = getSourceViewer(); |
| if (sourceViewer != null) |
| textWidget = sourceViewer.getTextWidget(); |
| if (textWidget == null) |
| return; |
| try { |
| ISourceRange range = null; |
| range = reference.getSourceRange(); |
| if (range == null) |
| return; |
| int offset = range.getOffset(); |
| int length = range.getLength(); |
| if (offset < 0 || length < 0) |
| return; |
| setHighlightRange(offset, length, moveCursor); |
| if (!moveCursor) |
| return; |
| offset = -1; |
| length = -1; |
| if (reference instanceof IMember) { |
| range = ((IMember) reference).getNameRange(); |
| if (range != null) { |
| offset = range.getOffset(); |
| length = range.getLength(); |
| } |
| } else if (reference instanceof ILocalVariable) { |
| range = ((ILocalVariable) reference).getNameRange(); |
| if (range != null) { |
| offset = range.getOffset(); |
| length = range.getLength(); |
| } |
| } else if (reference instanceof IImportDeclaration |
| || reference instanceof IPackageDeclaration) { |
| // range is still getSourceRange() |
| offset = range.getOffset(); |
| length = range.getLength(); |
| } |
| if (offset > -1 && length > 0) { |
| try { |
| textWidget.setRedraw(false); |
| sourceViewer.revealRange(offset, length); |
| sourceViewer.setSelectedRange(offset, length); |
| } finally { |
| textWidget.setRedraw(true); |
| } |
| markInNavigationHistory(); |
| } |
| } catch (ModelException x) { |
| } catch (IllegalArgumentException x) { |
| } |
| } else if (moveCursor) { |
| resetHighlightRange(); |
| markInNavigationHistory(); |
| } |
| } |
| |
| @Override |
| protected void doSetSelection(ISelection selection) { |
| super.doSetSelection(selection); |
| synchronizeOutlinePageSelection(); |
| } |
| |
| @Override |
| public void setSelection(IModelElement element) { |
| |
| if (element == null || element instanceof ISourceModule) { |
| /* |
| * If the element is an ISourceModule this unit is either the input |
| * of this editor or not being displayed. In both cases, nothing |
| * should happened. |
| * (http://dev.eclipse.org/bugs/show_bug.cgi?id=5128) |
| */ |
| return; |
| } |
| |
| IModelElement corresponding = getCorrespondingElement(element); |
| if (corresponding instanceof ISourceReference) { |
| ISourceReference reference = (ISourceReference) corresponding; |
| // set highlight range |
| setSelection(reference, true); |
| // set outliner selection |
| if (fOutlinePage != null) { |
| fOutlineSelectionChangedListener.uninstall(fOutlinePage); |
| fOutlinePage.select(reference); |
| fOutlineSelectionChangedListener.install(fOutlinePage); |
| } |
| } |
| } |
| |
| /** |
| * Synchronizes the outliner selection with the given element position in |
| * the editor. |
| * |
| * @param element |
| * thescriptelement to select |
| */ |
| protected void synchronizeOutlinePage(ISourceReference element) { |
| synchronizeOutlinePage(element, true); |
| } |
| |
| /** |
| * Synchronizes the outliner selection with the given element position in |
| * the editor. |
| * |
| * @param element |
| * thescriptelement to select |
| * @param checkIfOutlinePageActive |
| * <code>true</code> if check for active outline page needs to be |
| * done |
| * @since 2.0 |
| */ |
| @Override |
| public void synchronizeOutlinePage(ISourceReference element, |
| boolean checkIfOutlinePageActive) { |
| if (fOutlinePage != null && element != null |
| && !(checkIfOutlinePageActive && isOutlinePageActive())) { |
| fOutlineSelectionChangedListener.uninstall(fOutlinePage); |
| fOutlinePage.select(element); |
| fOutlineSelectionChangedListener.install(fOutlinePage); |
| } |
| } |
| |
| /** |
| * Synchronizes the outliner selection with the actual cursor position in |
| * the editor. |
| */ |
| public void synchronizeOutlinePageSelection() { |
| synchronizeOutlinePage(computeHighlightRangeSourceReference()); |
| } |
| |
| private boolean isOutlinePageActive() { |
| IWorkbenchPart part = getActivePart(); |
| return part instanceof ContentOutline |
| && ((ContentOutline) part).getCurrentPage() == fOutlinePage; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * <p> |
| * Overrides the default implementation to handle {@link IJavaAnnotation}. |
| * </p> |
| * |
| * @param offset |
| * the region offset |
| * @param length |
| * the region length |
| * @param forward |
| * <code>true</code> for forwards, <code>false</code> for |
| * backward |
| * @param annotationPosition |
| * the position of the found annotation |
| * @return the found annotation |
| */ |
| @Override |
| protected Annotation findAnnotation(final int offset, final int length, |
| boolean forward, Position annotationPosition) { |
| |
| Annotation nextAnnotation = null; |
| Position nextAnnotationPosition = null; |
| Annotation containingAnnotation = null; |
| Position containingAnnotationPosition = null; |
| boolean currentAnnotation = false; |
| |
| IDocument document = getDocumentProvider() |
| .getDocument(getEditorInput()); |
| int endOfDocument = document.getLength(); |
| int distance = Integer.MAX_VALUE; |
| |
| IAnnotationModel model = getDocumentProvider() |
| .getAnnotationModel(getEditorInput()); |
| Iterator<Annotation> e = new ScriptAnnotationIterator(model, true); |
| while (e.hasNext()) { |
| Annotation a = e.next(); |
| if ((a instanceof IScriptAnnotation) |
| && ((IScriptAnnotation) a).hasOverlay() |
| || !isNavigationTarget(a)) |
| continue; |
| |
| Position p = model.getPosition(a); |
| if (p == null) |
| continue; |
| |
| if (forward && p.offset == offset || !forward |
| && p.offset + p.getLength() == offset + length) {// || |
| // p.includes(offset)) |
| // { |
| if (containingAnnotation == null || (forward |
| && p.length >= containingAnnotationPosition.length |
| || !forward |
| && p.length >= containingAnnotationPosition.length)) { |
| containingAnnotation = a; |
| containingAnnotationPosition = p; |
| currentAnnotation = p.length == length; |
| } |
| } else { |
| int currentDistance = 0; |
| |
| if (forward) { |
| currentDistance = p.getOffset() - offset; |
| if (currentDistance < 0) |
| currentDistance = endOfDocument + currentDistance; |
| |
| if (currentDistance < distance |
| || currentDistance == distance |
| && p.length < nextAnnotationPosition.length) { |
| distance = currentDistance; |
| nextAnnotation = a; |
| nextAnnotationPosition = p; |
| } |
| } else { |
| currentDistance = offset + length |
| - (p.getOffset() + p.length); |
| if (currentDistance < 0) |
| currentDistance = endOfDocument + currentDistance; |
| |
| if (currentDistance < distance |
| || currentDistance == distance |
| && p.length < nextAnnotationPosition.length) { |
| distance = currentDistance; |
| nextAnnotation = a; |
| nextAnnotationPosition = p; |
| } |
| } |
| } |
| } |
| if (containingAnnotationPosition != null |
| && (!currentAnnotation || nextAnnotation == null)) { |
| annotationPosition |
| .setOffset(containingAnnotationPosition.getOffset()); |
| annotationPosition |
| .setLength(containingAnnotationPosition.getLength()); |
| return containingAnnotation; |
| } |
| if (nextAnnotationPosition != null) { |
| annotationPosition.setOffset(nextAnnotationPosition.getOffset()); |
| annotationPosition.setLength(nextAnnotationPosition.getLength()); |
| } |
| |
| return nextAnnotation; |
| } |
| |
| /** |
| * Returns the annotation overlapping with the given range or |
| * <code>null</code>. |
| * |
| * @param offset |
| * the region offset |
| * @param length |
| * the region length |
| * @return the found annotation or <code>null</code> |
| * @since 3.0 |
| */ |
| private Annotation getAnnotation(int offset, int length) { |
| IAnnotationModel model = getDocumentProvider() |
| .getAnnotationModel(getEditorInput()); |
| Iterator<Annotation> e = new ScriptAnnotationIterator(model, false); |
| while (e.hasNext()) { |
| Annotation a = e.next(); |
| Position p = model.getPosition(a); |
| if (p != null && p.overlapsWith(offset, length)) |
| return a; |
| } |
| return null; |
| } |
| |
| /* |
| * @see |
| * org.eclipse.ui.texteditor.AbstractDecoratedTextEditor#gotoAnnotation( |
| * boolean) |
| * |
| * @since 3.2 |
| */ |
| @Override |
| public Annotation gotoAnnotation(boolean forward) { |
| fSelectionChangedViaGotoAnnotation = true; |
| return super.gotoAnnotation(forward); |
| } |
| |
| /** |
| * Computes and returns the source reference that includes the caret and |
| * serves as provider for the outline page selection and the editor range |
| * indication. |
| * |
| * @return the computed source reference |
| * @since 2.0 |
| */ |
| @Override |
| public ISourceReference computeHighlightRangeSourceReference() { |
| ISourceViewer sourceViewer = getSourceViewer(); |
| if (sourceViewer == null) |
| return null; |
| StyledText styledText = sourceViewer.getTextWidget(); |
| if (styledText == null) |
| return null; |
| int caret = 0; |
| if (sourceViewer instanceof ITextViewerExtension5) { |
| ITextViewerExtension5 extension = (ITextViewerExtension5) sourceViewer; |
| caret = extension |
| .widgetOffset2ModelOffset(styledText.getCaretOffset()); |
| } else { |
| int offset = sourceViewer.getVisibleRegion().getOffset(); |
| caret = offset + styledText.getCaretOffset(); |
| } |
| IModelElement element = getElementAt(caret, false); |
| if (!(element instanceof ISourceReference)) |
| return null; |
| // if (element.getElementType() == IModelElement.IMPORT_DECLARATION) { |
| // |
| // IImportDeclaration declaration= (IImportDeclaration) element; |
| // IImportContainer container= (IImportContainer) |
| // declaration.getParent(); |
| // ISourceRange srcRange= null; |
| // |
| // try { |
| // srcRange= container.getSourceRange(); |
| // } catch (ModelException e) { |
| // } |
| // |
| // if (srcRange != null && srcRange.getOffset() == caret) |
| // return container; |
| // } |
| return (ISourceReference) element; |
| } |
| |
| @Override |
| public void createPartControl(Composite parent) { |
| super.createPartControl(parent); |
| |
| IInformationControlCreator informationControlCreator = shell -> { |
| boolean cutDown = false; |
| // int style = cutDown ? SWT.NONE : (SWT.V_SCROLL | SWT.H_SCROLL); |
| // return new DefaultInformationControl(shell, SWT.RESIZE |
| // | SWT.TOOL, style, new HTMLTextPresenter(cutDown)); |
| if (BrowserInformationControl.isAvailable(shell)) |
| return new BrowserInformationControl(shell, |
| JFaceResources.DIALOG_FONT, true); |
| else |
| return new DefaultInformationControl(shell, |
| new HTMLTextPresenter(cutDown)); |
| }; |
| |
| fInformationPresenter = new InformationPresenter( |
| informationControlCreator); |
| fInformationPresenter.setSizeConstraints(60, 10, true, true); |
| fInformationPresenter.install(getSourceViewer()); |
| fInformationPresenter |
| .setDocumentPartitioning(IDocument.DEFAULT_CONTENT_TYPE); |
| |
| fEditorSelectionChangedListener = new EditorSelectionChangedListener(); |
| fEditorSelectionChangedListener.install(getSelectionProvider()); |
| if (true) |
| installSemanticHighlighting(); |
| if (!isEditable()) { |
| /* |
| * Manually call semantic highlighting for read only editor, since |
| * usually it's done from reconciler, but |
| * ScriptSourceViewerConfiguration.getReconciler(ISourceViewer) |
| * doesn't create reconciler for read only editor. |
| */ |
| updateSemanticHighlighting(); |
| } |
| if (occurrencesFinder != null) { |
| occurrencesFinder.install(); |
| } |
| } |
| |
| /** |
| * React to changed selection. |
| * |
| * |
| */ |
| protected void selectionChanged() { |
| if (getSelectionProvider() == null) |
| return; |
| ISourceReference element = computeHighlightRangeSourceReference(); |
| if (getPreferenceStore().getBoolean( |
| PreferenceConstants.EDITOR_SYNC_OUTLINE_ON_CURSOR_MOVE)) |
| synchronizeOutlinePage(element); |
| setSelection(element, false); |
| if (!fSelectionChangedViaGotoAnnotation) |
| updateStatusLine(); |
| fSelectionChangedViaGotoAnnotation = false; |
| } |
| |
| protected void updateStatusLine() { |
| ITextSelection selection = (ITextSelection) getSelectionProvider() |
| .getSelection(); |
| Annotation annotation = getAnnotation(selection.getOffset(), |
| selection.getLength()); |
| setStatusLineErrorMessage(null); |
| setStatusLineMessage(null); |
| if (annotation != null) { |
| updateMarkerViews(annotation); |
| if (annotation instanceof IScriptAnnotation |
| && ((IScriptAnnotation) annotation).isProblem()) |
| setStatusLineMessage(annotation.getText()); |
| } |
| } |
| |
| /** |
| * Returns the model element wrapped by this editors input. |
| * |
| * @return the model element wrapped by this editors input. |
| * |
| */ |
| public IModelElement getInputModelElement() { |
| return EditorUtility.getEditorInputModelElement(this, false); |
| } |
| |
| /** |
| * Returns thescriptelement of this editor's input corresponding to the |
| * given IModelElement. |
| * |
| * @param element |
| * thescriptelement |
| * @return the corresponding model element |
| */ |
| protected IModelElement getCorrespondingElement(IModelElement element) { |
| return element; |
| } |
| |
| /** |
| * Returns the most narrow model element including the given offset. |
| * |
| * @param offset |
| * the offset inside of the requested element |
| * @return the most narrow model element |
| */ |
| @Override |
| public IModelElement getElementAt(int offset) { |
| return getElementAt(offset, true); |
| } |
| |
| /** |
| * Returns the most narrow element including the given offset. If |
| * <code>reconcile</code> is <code>true</code> the editor's input element is |
| * reconciled in advance. If it is <code>false</code> this method only |
| * returns a result if the editor's input element does not need to be |
| * reconciled. |
| * |
| * @param offset |
| * the offset included by the retrieved element |
| * @param reconcile |
| * <code>true</code> if working copy should be reconciled |
| * @return the most narrow element which includes the given offset |
| */ |
| public IModelElement getElementAt(int offset, boolean reconcile) { |
| ISourceModule unit = (ISourceModule) getInputModelElement(); |
| if (unit != null) { |
| try { |
| if (reconcile) { |
| ScriptModelUtil.reconcile(unit); |
| return unit.getElementAt(offset); |
| } else if (unit.isConsistent()) |
| return unit.getElementAt(offset); |
| } catch (ModelException x) { |
| if (!x.isDoesNotExist()) |
| // DLTKUIPlugin.log(x.getStatus()); |
| System.err.println(x.getStatus()); |
| // nothing found, be tolerant and go on |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * The folding runner. |
| * |
| * |
| */ |
| private ToggleFoldingRunner fFoldingRunner; |
| |
| /** |
| * Tells whether the selection changed event is caused by a call to |
| * {@link #gotoAnnotation(boolean)}. |
| * |
| */ |
| private boolean fSelectionChangedViaGotoAnnotation; |
| |
| /** |
| * Runner that will toggle folding either instantly (if the editor is |
| * visible) or the next time it becomes visible. If a runner is started when |
| * there is already one registered, the registered one is canceled as |
| * toggling folding twice is a no-op. |
| * <p> |
| * The access to the fFoldingRunner field is not thread-safe, it is assumed |
| * that <code>runWhenNextVisible</code> is only called from the UI thread. |
| * </p> |
| * |
| * |
| */ |
| protected final class ToggleFoldingRunner implements IPartListener2 { |
| public ToggleFoldingRunner() { |
| } |
| |
| /** |
| * The workbench page we registered the part listener with, or |
| * <code>null</code>. |
| */ |
| private IWorkbenchPage fPage; |
| |
| /** |
| * Does the actual toggling of projection. |
| */ |
| private void toggleFolding() { |
| ISourceViewer sourceViewer = getSourceViewer(); |
| if (sourceViewer instanceof ProjectionViewer) { |
| ProjectionViewer pv = (ProjectionViewer) sourceViewer; |
| if (pv.isProjectionMode() != isFoldingEnabled()) { |
| if (pv.canDoOperation(ProjectionViewer.TOGGLE)) |
| pv.doOperation(ProjectionViewer.TOGGLE); |
| } |
| } |
| } |
| |
| /** |
| * Makes sure that the editor's folding state is correct the next time |
| * it becomes visible. If it already is visible, it toggles the folding |
| * state. If not, it either registers a part listener to toggle folding |
| * when the editor becomes visible, or cancels an already registered |
| * runner. |
| */ |
| public void runWhenNextVisible() { |
| // if there is one already: toggling twice is the identity |
| if (fFoldingRunner != null) { |
| fFoldingRunner.cancel(); |
| return; |
| } |
| IWorkbenchPartSite site = getSite(); |
| if (site != null) { |
| IWorkbenchPage page = site.getPage(); |
| if (!page.isPartVisible(ScriptEditor.this)) { |
| // if we're not visible - defer until visible |
| fPage = page; |
| fFoldingRunner = this; |
| page.addPartListener(this); |
| return; |
| } |
| } |
| // we're visible - run now |
| toggleFolding(); |
| } |
| |
| /** |
| * Remove the listener and clear the field. |
| */ |
| private void cancel() { |
| if (fPage != null) { |
| fPage.removePartListener(this); |
| fPage = null; |
| } |
| if (fFoldingRunner == this) |
| fFoldingRunner = null; |
| } |
| |
| /* |
| * @seeorg.eclipse.ui.IPartListener2#partVisible(org.eclipse.ui. |
| * IWorkbenchPartReference) |
| */ |
| @Override |
| public void partVisible(IWorkbenchPartReference partRef) { |
| if (ScriptEditor.this.equals(partRef.getPart(false))) { |
| cancel(); |
| toggleFolding(); |
| } |
| } |
| |
| /* |
| * @seeorg.eclipse.ui.IPartListener2#partClosed(org.eclipse.ui. |
| * IWorkbenchPartReference) |
| */ |
| @Override |
| public void partClosed(IWorkbenchPartReference partRef) { |
| if (ScriptEditor.this.equals(partRef.getPart(false))) { |
| cancel(); |
| } |
| } |
| |
| @Override |
| public void partActivated(IWorkbenchPartReference partRef) { |
| } |
| |
| @Override |
| public void partBroughtToTop(IWorkbenchPartReference partRef) { |
| } |
| |
| @Override |
| public void partDeactivated(IWorkbenchPartReference partRef) { |
| } |
| |
| @Override |
| public void partOpened(IWorkbenchPartReference partRef) { |
| } |
| |
| @Override |
| public void partHidden(IWorkbenchPartReference partRef) { |
| } |
| |
| @Override |
| public void partInputChanged(IWorkbenchPartReference partRef) { |
| } |
| } |
| |
| /** |
| * Creates folding structure provider to use in this editor. Default |
| * implementation queries the |
| * <code>org.eclipse.dltk.ui.folding/structureProvider</code> extension |
| * point. |
| * |
| * @return folding structure provider or <code>null</code>. |
| */ |
| protected IFoldingStructureProvider createFoldingStructureProvider() { |
| return getFoldingStructureProvider(); |
| } |
| |
| /** |
| * Returns folding structure provider. |
| * |
| * @return |
| */ |
| @Deprecated |
| protected IFoldingStructureProvider getFoldingStructureProvider() { |
| return FoldingProviderManager.getStructureProvider(getNatureId()); |
| } |
| |
| private boolean isEditorHoverProperty(String property) { |
| return PreferenceConstants.EDITOR_TEXT_HOVER_MODIFIERS.equals(property); |
| } |
| |
| /* |
| * Update the hovering behavior depending on the preferences. |
| */ |
| private void updateHoverBehavior() { |
| SourceViewerConfiguration configuration = getSourceViewerConfiguration(); |
| String[] types = configuration |
| .getConfiguredContentTypes(getSourceViewer()); |
| |
| for (int i = 0; i < types.length; i++) { |
| |
| String t = types[i]; |
| |
| ISourceViewer sourceViewer = getSourceViewer(); |
| if (sourceViewer instanceof ITextViewerExtension2) { |
| // Remove existing hovers |
| ((ITextViewerExtension2) sourceViewer).removeTextHovers(t); |
| |
| int[] stateMasks = configuration |
| .getConfiguredTextHoverStateMasks(getSourceViewer(), t); |
| |
| if (stateMasks != null) { |
| for (int j = 0; j < stateMasks.length; j++) { |
| int stateMask = stateMasks[j]; |
| ITextHover textHover = configuration |
| .getTextHover(sourceViewer, t, stateMask); |
| ((ITextViewerExtension2) sourceViewer) |
| .setTextHover(textHover, t, stateMask); |
| } |
| } else { |
| ITextHover textHover = configuration |
| .getTextHover(sourceViewer, t); |
| ((ITextViewerExtension2) sourceViewer).setTextHover( |
| textHover, t, |
| ITextViewerExtension2.DEFAULT_HOVER_STATE_MASK); |
| } |
| } else |
| sourceViewer.setTextHover( |
| configuration.getTextHover(sourceViewer, t), t); |
| } |
| } |
| |
| @Override |
| protected void handlePreferenceStoreChanged(PropertyChangeEvent event) { |
| String property = event.getProperty(); |
| try { |
| |
| ISourceViewer sourceViewer = getSourceViewer(); |
| if (sourceViewer == null) { |
| return; |
| } |
| boolean newBooleanValue = false; |
| Object newValue = event.getNewValue(); |
| |
| if (isEditorHoverProperty(property)) |
| updateHoverBehavior(); |
| |
| if (newValue != null) |
| newBooleanValue = Boolean.valueOf(newValue.toString()) |
| .booleanValue(); |
| if (PreferenceConstants.EDITOR_SYNC_OUTLINE_ON_CURSOR_MOVE |
| .equals(property)) { |
| if (newBooleanValue) |
| selectionChanged(); |
| return; |
| } |
| |
| if (occurrencesFinder != null && occurrencesFinder |
| .handlePreferenceStoreChanged(property, newBooleanValue)) { |
| return; |
| } |
| |
| if (CodeFormatterConstants.FORMATTER_TAB_SIZE.equals(property) |
| || CodeFormatterConstants.FORMATTER_INDENTATION_SIZE |
| .equals(property) |
| || CodeFormatterConstants.FORMATTER_TAB_CHAR |
| .equals(property)) { |
| if (CodeFormatterConstants.FORMATTER_TAB_CHAR |
| .equals(property)) { |
| if (isTabsToSpacesConversionEnabled()) |
| installTabsToSpacesConverter(); |
| else |
| uninstallTabsToSpacesConverter(); |
| } |
| updateIndentPrefixes(); |
| StyledText textWidget = sourceViewer.getTextWidget(); |
| int tabWidth = getSourceViewerConfiguration() |
| .getTabWidth(sourceViewer); |
| if (textWidget.getTabs() != tabWidth) |
| textWidget.setTabs(tabWidth); |
| return; |
| } |
| if (PreferenceConstants.EDITOR_SMART_TAB.equals(property)) { |
| if (getPreferenceStore() |
| .getBoolean(PreferenceConstants.EDITOR_SMART_TAB)) { |
| setActionActivationCode(DLTKActionConstants.INDENT_ON_TAB, |
| SWT.TAB, -1, SWT.NONE); |
| } else { |
| removeActionActivationCode( |
| DLTKActionConstants.INDENT_ON_TAB); |
| } |
| } |
| |
| if (isFoldingPropertyEvent(property) |
| && sourceViewer instanceof ProjectionViewer) { |
| handleFoldingPropertyEvent(property); |
| } |
| |
| final ScriptSourceViewerConfiguration ssvc = (ScriptSourceViewerConfiguration) getSourceViewerConfiguration(); |
| final IContentAssistant c = ((AdaptedSourceViewer) sourceViewer) |
| .getContentAssistant(); |
| if (c instanceof ContentAssistant) { |
| ssvc.changeContentAssistantConfiguration((ContentAssistant) c, |
| event); |
| } |
| ssvc.handlePropertyChangeEvent(event); |
| } finally { |
| super.handlePreferenceStoreChanged(event); |
| } |
| if (AbstractDecoratedTextEditorPreferenceConstants.SHOW_RANGE_INDICATOR |
| .equals(property)) { |
| // superclass already installed the range indicator |
| Object newValue = event.getNewValue(); |
| ISourceViewer viewer = getSourceViewer(); |
| if (newValue != null && viewer != null) { |
| if (Boolean.valueOf(newValue.toString()).booleanValue()) { |
| // adjust the highlightrange in order to get the magnet |
| // right after changing the selection |
| Point selection = viewer.getSelectedRange(); |
| adjustHighlightRange(selection.x, selection.y); |
| } |
| } |
| } |
| } |
| |
| @Override |
| protected boolean affectsTextPresentation(PropertyChangeEvent event) { |
| return ((ScriptSourceViewerConfiguration) getSourceViewerConfiguration()) |
| .affectsTextPresentation(event) |
| || super.affectsTextPresentation(event); |
| } |
| |
| protected void handleFoldingPropertyEvent(String property) { |
| // NOTE: 'initially fold' preferences do not require handling |
| if (PreferenceConstants.EDITOR_FOLDING_ENABLED.equals(property)) { |
| ToggleFoldingRunner runner = new ToggleFoldingRunner(); |
| runner.runWhenNextVisible(); |
| } else { |
| fProjectionModelUpdater.initialize(false); |
| } |
| } |
| |
| protected final boolean isFoldingPropertyEvent(String property) { |
| if (isHandledPropertyEvent(property, GLOBAL_FOLDING_PROPERTIES)) { |
| return true; |
| } |
| |
| if (isHandledPropertyEvent(property, getFoldingEventPreferenceKeys())) { |
| return true; |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Returns a string array containing the language specific folding |
| * preference keys that should be handed when a property change event is |
| * fired. |
| * |
| * <p> |
| * Default implementation returns an empty array. Subclasses should override |
| * this method to return folding keys that are language specific. |
| * </p> |
| */ |
| protected String[] getFoldingEventPreferenceKeys() { |
| return CharOperation.NO_STRINGS; |
| } |
| |
| /** |
| * Text navigation action to navigate to the next sub-word. |
| * |
| * |
| */ |
| protected abstract class NextSubWordAction extends TextNavigationAction { |
| protected DLTKWordIterator fIterator = new DLTKWordIterator(); |
| |
| /** |
| * Creates a new next sub-word action. |
| * |
| * @param code |
| * Action code for the default operation. Must be an action |
| * code from |
| * @see org.eclipse.swt.custom.ST. |
| */ |
| protected NextSubWordAction(int code) { |
| super(getSourceViewer().getTextWidget(), code); |
| } |
| |
| /* |
| * @see org.eclipse.jface.action.IAction#run() |
| */ |
| @Override |
| public void run() { |
| // Check whether we are in ascriptcode partition and the preference |
| // is enabled |
| final IPreferenceStore store = getPreferenceStore(); |
| if (!store.getBoolean( |
| PreferenceConstants.EDITOR_SUB_WORD_NAVIGATION)) { |
| super.run(); |
| return; |
| } |
| final ISourceViewer viewer = getSourceViewer(); |
| final IDocument document = viewer.getDocument(); |
| fIterator.setText((CharacterIterator) new DocumentCharacterIterator( |
| document)); |
| int position = widgetOffset2ModelOffset(viewer, |
| viewer.getTextWidget().getCaretOffset()); |
| if (position == -1) |
| return; |
| int next = findNextPosition(position); |
| if (next != BreakIterator.DONE) { |
| setCaretPosition(next); |
| getTextWidget().showSelection(); |
| fireSelectionChanged(); |
| } |
| } |
| |
| /** |
| * Finds the next position after the given position. |
| * |
| * @param position |
| * the current position |
| * @return the next position |
| */ |
| protected int findNextPosition(int position) { |
| ISourceViewer viewer = getSourceViewer(); |
| int widget = -1; |
| while (position != BreakIterator.DONE && widget == -1) { // TODO: |
| // optimize |
| position = fIterator.following(position); |
| if (position != BreakIterator.DONE) |
| widget = modelOffset2WidgetOffset(viewer, position); |
| } |
| return position; |
| } |
| |
| /** |
| * Sets the caret position to the sub-word boundary given with |
| * <code>position</code>. |
| * |
| * @param position |
| * Position where the action should move the caret |
| */ |
| protected abstract void setCaretPosition(int position); |
| } |
| |
| /** |
| * Text navigation action to navigate to the next sub-word. |
| */ |
| protected class NavigateNextSubWordAction extends NextSubWordAction { |
| /** |
| * Creates a new navigate next sub-word action. |
| */ |
| public NavigateNextSubWordAction() { |
| super(ST.WORD_NEXT); |
| } |
| |
| @Override |
| protected void setCaretPosition(final int position) { |
| getTextWidget().setCaretOffset( |
| modelOffset2WidgetOffset(getSourceViewer(), position)); |
| } |
| } |
| |
| /** |
| * Text operation action to delete the next sub-word. |
| */ |
| protected class DeleteNextSubWordAction extends NextSubWordAction |
| implements IUpdate { |
| /** |
| * Creates a new delete next sub-word action. |
| */ |
| public DeleteNextSubWordAction() { |
| super(ST.DELETE_WORD_NEXT); |
| } |
| |
| @Override |
| protected void setCaretPosition(final int position) { |
| if (!validateEditorInputState()) |
| return; |
| final ISourceViewer viewer = getSourceViewer(); |
| final int caret, length; |
| Point selection = viewer.getSelectedRange(); |
| if (selection.y != 0) { |
| caret = selection.x; |
| length = selection.y; |
| } else { |
| caret = widgetOffset2ModelOffset(viewer, |
| viewer.getTextWidget().getCaretOffset()); |
| length = position - caret; |
| } |
| try { |
| viewer.getDocument().replace(caret, length, ""); //$NON-NLS-1$ |
| } catch (BadLocationException exception) { |
| // Should not happen |
| } |
| } |
| |
| @Override |
| protected int findNextPosition(int position) { |
| return fIterator.following(position); |
| } |
| |
| /* |
| * @see org.eclipse.ui.texteditor.IUpdate#update() |
| */ |
| @Override |
| public void update() { |
| setEnabled(isEditorInputModifiable()); |
| } |
| } |
| |
| /** |
| * Text operation action to select the next sub-word. |
| * |
| * |
| */ |
| protected class SelectNextSubWordAction extends NextSubWordAction { |
| /** |
| * Creates a new select next sub-word action. |
| */ |
| public SelectNextSubWordAction() { |
| super(ST.SELECT_WORD_NEXT); |
| } |
| |
| @Override |
| protected void setCaretPosition(final int position) { |
| final ISourceViewer viewer = getSourceViewer(); |
| final StyledText text = viewer.getTextWidget(); |
| if (text != null && !text.isDisposed()) { |
| final Point selection = text.getSelection(); |
| final int caret = text.getCaretOffset(); |
| final int offset = modelOffset2WidgetOffset(viewer, position); |
| if (caret == selection.x) |
| text.setSelectionRange(selection.y, offset - selection.y); |
| else |
| text.setSelectionRange(selection.x, offset - selection.x); |
| } |
| } |
| } |
| |
| /** |
| * Text navigation action to navigate to the previous sub-word. |
| * |
| * |
| */ |
| protected abstract class PreviousSubWordAction |
| extends TextNavigationAction { |
| protected DLTKWordIterator fIterator = new DLTKWordIterator(); |
| |
| /** |
| * Creates a new previous sub-word action. |
| * |
| * @param code |
| * Action code for the default operation. Must be an action |
| * code from |
| * @see org.eclipse.swt.custom.ST. |
| */ |
| protected PreviousSubWordAction(final int code) { |
| super(getSourceViewer().getTextWidget(), code); |
| } |
| |
| /* |
| * @see org.eclipse.jface.action.IAction#run() |
| */ |
| @Override |
| public void run() { |
| // Check whether we are in ascriptcode partition and the preference |
| // is enabled |
| final IPreferenceStore store = getPreferenceStore(); |
| if (!store.getBoolean( |
| PreferenceConstants.EDITOR_SUB_WORD_NAVIGATION)) { |
| super.run(); |
| return; |
| } |
| final ISourceViewer viewer = getSourceViewer(); |
| final IDocument document = viewer.getDocument(); |
| fIterator.setText((CharacterIterator) new DocumentCharacterIterator( |
| document)); |
| int position = widgetOffset2ModelOffset(viewer, |
| viewer.getTextWidget().getCaretOffset()); |
| if (position == -1) |
| return; |
| int previous = findPreviousPosition(position); |
| if (previous != BreakIterator.DONE) { |
| setCaretPosition(previous); |
| getTextWidget().showSelection(); |
| fireSelectionChanged(); |
| } |
| } |
| |
| /** |
| * Finds the previous position before the given position. |
| * |
| * @param position |
| * the current position |
| * @return the previous position |
| */ |
| protected int findPreviousPosition(int position) { |
| ISourceViewer viewer = getSourceViewer(); |
| int widget = -1; |
| while (position != BreakIterator.DONE && widget == -1) { // TODO: |
| // optimize |
| position = fIterator.preceding(position); |
| if (position != BreakIterator.DONE) |
| widget = modelOffset2WidgetOffset(viewer, position); |
| } |
| return position; |
| } |
| |
| /** |
| * Sets the caret position to the sub-word boundary given with |
| * <code>position</code>. |
| * |
| * @param position |
| * Position where the action should move the caret |
| */ |
| protected abstract void setCaretPosition(int position); |
| } |
| |
| /** |
| * Text navigation action to navigate to the previous sub-word. |
| */ |
| protected class NavigatePreviousSubWordAction |
| extends PreviousSubWordAction { |
| /** |
| * Creates a new navigate previous sub-word action. |
| */ |
| public NavigatePreviousSubWordAction() { |
| super(ST.WORD_PREVIOUS); |
| } |
| |
| @Override |
| protected void setCaretPosition(final int position) { |
| getTextWidget().setCaretOffset( |
| modelOffset2WidgetOffset(getSourceViewer(), position)); |
| } |
| } |
| |
| /** |
| * Text operation action to delete the previous sub-word. |
| */ |
| protected class DeletePreviousSubWordAction extends PreviousSubWordAction |
| implements IUpdate { |
| /** |
| * Creates a new delete previous sub-word action. |
| */ |
| public DeletePreviousSubWordAction() { |
| super(ST.DELETE_WORD_PREVIOUS); |
| } |
| |
| @Override |
| protected void setCaretPosition(int position) { |
| if (!validateEditorInputState()) |
| return; |
| final int length; |
| final ISourceViewer viewer = getSourceViewer(); |
| Point selection = viewer.getSelectedRange(); |
| if (selection.y != 0) { |
| position = selection.x; |
| length = selection.y; |
| } else { |
| length = widgetOffset2ModelOffset(viewer, |
| viewer.getTextWidget().getCaretOffset()) - position; |
| } |
| try { |
| viewer.getDocument().replace(position, length, ""); //$NON-NLS-1$ |
| } catch (BadLocationException exception) { |
| // Should not happen |
| } |
| } |
| |
| @Override |
| protected int findPreviousPosition(int position) { |
| return fIterator.preceding(position); |
| } |
| |
| @Override |
| public void update() { |
| setEnabled(isEditorInputModifiable()); |
| } |
| } |
| |
| /** |
| * Text operation action to select the previous sub-word. |
| */ |
| protected class SelectPreviousSubWordAction extends PreviousSubWordAction { |
| /** |
| * Creates a new select previous sub-word action. |
| */ |
| public SelectPreviousSubWordAction() { |
| super(ST.SELECT_WORD_PREVIOUS); |
| } |
| |
| @Override |
| protected void setCaretPosition(final int position) { |
| final ISourceViewer viewer = getSourceViewer(); |
| final StyledText text = viewer.getTextWidget(); |
| if (text != null && !text.isDisposed()) { |
| final Point selection = text.getSelection(); |
| final int caret = text.getCaretOffset(); |
| final int offset = modelOffset2WidgetOffset(viewer, position); |
| if (caret == selection.x) |
| text.setSelectionRange(selection.y, offset - selection.y); |
| else |
| text.setSelectionRange(selection.x, offset - selection.x); |
| } |
| } |
| } |
| |
| /* |
| * @see AbstractTextEditor#createNavigationActions() |
| */ |
| @Override |
| protected void createNavigationActions() { |
| super.createNavigationActions(); |
| final StyledText textWidget = getSourceViewer().getTextWidget(); |
| |
| IAction action = new NavigatePreviousSubWordAction(); |
| action.setActionDefinitionId( |
| ITextEditorActionDefinitionIds.WORD_PREVIOUS); |
| setAction(ITextEditorActionDefinitionIds.WORD_PREVIOUS, action); |
| textWidget.setKeyBinding(SWT.CTRL | SWT.ARROW_LEFT, SWT.NULL); |
| |
| action = new NavigateNextSubWordAction(); |
| action.setActionDefinitionId(ITextEditorActionDefinitionIds.WORD_NEXT); |
| setAction(ITextEditorActionDefinitionIds.WORD_NEXT, action); |
| textWidget.setKeyBinding(SWT.CTRL | SWT.ARROW_RIGHT, SWT.NULL); |
| |
| action = new SelectPreviousSubWordAction(); |
| action.setActionDefinitionId( |
| ITextEditorActionDefinitionIds.SELECT_WORD_PREVIOUS); |
| setAction(ITextEditorActionDefinitionIds.SELECT_WORD_PREVIOUS, action); |
| textWidget.setKeyBinding(SWT.CTRL | SWT.SHIFT | SWT.ARROW_LEFT, |
| SWT.NULL); |
| |
| action = new SelectNextSubWordAction(); |
| action.setActionDefinitionId( |
| ITextEditorActionDefinitionIds.SELECT_WORD_NEXT); |
| setAction(ITextEditorActionDefinitionIds.SELECT_WORD_NEXT, action); |
| textWidget.setKeyBinding(SWT.CTRL | SWT.SHIFT | SWT.ARROW_RIGHT, |
| SWT.NULL); |
| |
| action = new DeletePreviousSubWordAction(); |
| action.setActionDefinitionId( |
| ITextEditorActionDefinitionIds.DELETE_PREVIOUS_WORD); |
| setAction(ITextEditorActionDefinitionIds.DELETE_PREVIOUS_WORD, action); |
| textWidget.setKeyBinding(SWT.CTRL | SWT.BS, SWT.NULL); |
| markAsStateDependentAction( |
| ITextEditorActionDefinitionIds.DELETE_PREVIOUS_WORD, true); |
| |
| action = new DeleteNextSubWordAction(); |
| action.setActionDefinitionId( |
| ITextEditorActionDefinitionIds.DELETE_NEXT_WORD); |
| setAction(ITextEditorActionDefinitionIds.DELETE_NEXT_WORD, action); |
| textWidget.setKeyBinding(SWT.CTRL | SWT.DEL, SWT.NULL); |
| markAsStateDependentAction( |
| ITextEditorActionDefinitionIds.DELETE_NEXT_WORD, true); |
| } |
| |
| @Override |
| protected final ISourceViewer createSourceViewer(Composite parent, |
| IVerticalRuler verticalRuler, int styles) { |
| |
| IPreferenceStore store = getPreferenceStore(); |
| ISourceViewer viewer = createScriptSourceViewer(parent, verticalRuler, |
| getOverviewRuler(), isOverviewRulerVisible(), styles, store); |
| |
| if (DLTKCore.DEBUG) { |
| System.err.println("Create help contexts"); //$NON-NLS-1$ |
| } |
| // ScriptUIHelp.setHelp(this, viewer.getTextWidget(), |
| // IScriptHelpContextIds.JAVA_EDITOR); |
| |
| ScriptSourceViewer scriptSourceViewer = null; |
| if (viewer instanceof ScriptSourceViewer) |
| scriptSourceViewer = (ScriptSourceViewer) viewer; |
| |
| /* |
| * This is a performance optimization to reduce the computation of the |
| * text presentation triggered by {@link #setVisibleDocument(IDocument)} |
| */ |
| if (scriptSourceViewer != null && isFoldingEnabled() && (store == null |
| || !store.getBoolean(PreferenceConstants.EDITOR_SHOW_SEGMENTS))) |
| scriptSourceViewer.prepareDelayedProjection(); |
| |
| ProjectionViewer projectionViewer = (ProjectionViewer) viewer; |
| fProjectionSupport = new ProjectionSupport(projectionViewer, |
| getAnnotationAccess(), getSharedColors()); |
| fProjectionSupport.addSummarizableAnnotationType( |
| "org.eclipse.ui.workbench.texteditor.error"); //$NON-NLS-1$ |
| fProjectionSupport.addSummarizableAnnotationType( |
| "org.eclipse.ui.workbench.texteditor.warning"); //$NON-NLS-1$ |
| final IDLTKLanguageToolkit toolkit = this.getLanguageToolkit(); |
| fProjectionSupport.setHoverControlCreator(shell -> { |
| int shellStyle = SWT.TOOL | SWT.NO_TRIM | getOrientation(); |
| String statusFieldText = EditorsUI.getTooltipAffordanceString(); |
| return new SourceViewerInformationControl(shell, shellStyle, |
| SWT.NONE, statusFieldText, toolkit); |
| }); |
| fProjectionSupport.setInformationPresenterControlCreator(shell -> { |
| int shellStyle = SWT.RESIZE | SWT.TOOL | getOrientation(); |
| int style = SWT.V_SCROLL | SWT.H_SCROLL; |
| return new SourceViewerInformationControl(shell, shellStyle, style, |
| toolkit); |
| }); |
| |
| fProjectionSupport.install(); |
| |
| fProjectionModelUpdater = createFoldingStructureProvider(); |
| if (fProjectionModelUpdater != null) |
| fProjectionModelUpdater.install(this, projectionViewer, |
| getPreferenceStore()); |
| |
| // ensure source viewer decoration support has been created and |
| // configured |
| getSourceViewerDecorationSupport(viewer); |
| |
| return viewer; |
| } |
| |
| protected ISourceViewer createScriptSourceViewer(Composite parent, |
| IVerticalRuler verticalRuler, IOverviewRuler overviewRuler, |
| boolean isOverviewRulerVisible, int styles, |
| IPreferenceStore store) { |
| return new AdaptedSourceViewer(parent, verticalRuler, |
| getOverviewRuler(), isOverviewRulerVisible(), styles, store); |
| } |
| |
| /** |
| * Resets the foldings structure according to the folding preferences. |
| */ |
| public void resetProjection() { |
| if (fProjectionModelUpdater != null) { |
| fProjectionModelUpdater.initialize(); |
| } |
| } |
| |
| /** |
| * Collapses all foldable members if supported by the folding structure |
| * provider. |
| * |
| * |
| */ |
| public void collapseMembers() { |
| if (fProjectionModelUpdater instanceof IFoldingStructureProviderExtension) { |
| IFoldingStructureProviderExtension extension = (IFoldingStructureProviderExtension) fProjectionModelUpdater; |
| extension.collapseMembers(); |
| } |
| } |
| |
| /** |
| * Collapses all foldable comments if supported by the folding structure |
| * provider. |
| * |
| * |
| */ |
| public void collapseComments() { |
| if (fProjectionModelUpdater instanceof IFoldingStructureProviderExtension) { |
| IFoldingStructureProviderExtension extension = (IFoldingStructureProviderExtension) fProjectionModelUpdater; |
| extension.collapseComments(); |
| } |
| } |
| |
| /* |
| * @see AbstractTextEditor#rulerContextMenuAboutToShow(IMenuManager) |
| */ |
| @Override |
| protected void rulerContextMenuAboutToShow(IMenuManager menu) { |
| super.rulerContextMenuAboutToShow(menu); |
| IMenuManager foldingMenu = new MenuManager( |
| DLTKEditorMessages.Editor_FoldingMenu_name, "projection"); //$NON-NLS-1$ |
| menu.appendToGroup(ITextEditorActionConstants.GROUP_RULERS, |
| foldingMenu); |
| |
| IAction action = getAction("FoldingToggle"); //$NON-NLS-1$ |
| if (action != null) { |
| foldingMenu.add(action); |
| } |
| action = getAction("FoldingExpandAll"); //$NON-NLS-1$ |
| if (action != null) { |
| foldingMenu.add(action); |
| } |
| action = getAction("FoldingCollapseAll"); //$NON-NLS-1$ |
| if (action != null) { |
| foldingMenu.add(action); |
| } |
| action = getAction("FoldingRestore"); //$NON-NLS-1$ |
| if (action != null) { |
| foldingMenu.add(action); |
| } |
| action = getAction("FoldingCollapseMembers"); //$NON-NLS-1$ |
| if (action != null) { |
| foldingMenu.add(action); |
| } |
| action = getAction("FoldingCollapseComments"); //$NON-NLS-1$ |
| if (action != null) { |
| foldingMenu.add(action); |
| } |
| } |
| |
| /* |
| * @see org.eclipse.ui.texteditor.AbstractTextEditor#performRevert() |
| */ |
| @Override |
| protected void performRevert() { |
| ProjectionViewer projectionViewer = (ProjectionViewer) getSourceViewer(); |
| projectionViewer.setRedraw(false); |
| try { |
| |
| boolean projectionMode = projectionViewer.isProjectionMode(); |
| if (projectionMode) { |
| projectionViewer.disableProjection(); |
| if (fProjectionModelUpdater != null) |
| fProjectionModelUpdater.uninstall(); |
| } |
| |
| super.performRevert(); |
| |
| if (projectionMode) { |
| if (fProjectionModelUpdater != null) |
| fProjectionModelUpdater.install(this, projectionViewer, |
| getPreferenceStore()); |
| projectionViewer.enableProjection(); |
| } |
| |
| } finally { |
| projectionViewer.setRedraw(true); |
| } |
| } |
| |
| protected String getNatureId() { |
| return getLanguageToolkit().getNatureId(); |
| } |
| |
| @Override |
| public abstract IDLTKLanguageToolkit getLanguageToolkit(); |
| |
| protected IDLTKUILanguageToolkit getUILanguageToolkit() { |
| return DLTKUILanguageManager.getLanguageToolkit(getNatureId()); |
| } |
| |
| /** |
| * Return identifier of call hierarchy. Used by call hierarchy actions. |
| * |
| * @return |
| */ |
| public String getCallHierarchyID() { |
| return null; |
| } |
| |
| /* |
| * @see AbstractTextEditor#performSave(boolean, IProgressMonitor) |
| */ |
| @Override |
| protected void performSave(boolean overwrite, |
| IProgressMonitor progressMonitor) { |
| IDocumentProvider p = getDocumentProvider(); |
| if (p instanceof ISourceModuleDocumentProvider) { |
| ISourceModuleDocumentProvider cp = (ISourceModuleDocumentProvider) p; |
| cp.setSavePolicy(fSavePolicy); |
| } |
| try { |
| super.performSave(overwrite, progressMonitor); |
| } finally { |
| if (p instanceof ISourceModuleDocumentProvider) { |
| ISourceModuleDocumentProvider cp = (ISourceModuleDocumentProvider) p; |
| cp.setSavePolicy(null); |
| } |
| } |
| } |
| |
| /* |
| * @see AbstractTextEditor#doSave(IProgressMonitor) |
| */ |
| @Override |
| public void doSave(IProgressMonitor progressMonitor) { |
| |
| IDocumentProvider p = getDocumentProvider(); |
| if (p == null) { |
| // editor has been closed |
| return; |
| } |
| |
| if (p.isDeleted(getEditorInput())) { |
| |
| if (isSaveAsAllowed()) { |
| |
| /* |
| * 1GEUSSR: ITPUI:ALL - User should never loose changes made in |
| * the editors. Changed Behavior to make sure that if called |
| * inside a regular save (because of deletion of input element) |
| * there is a way to report back to the caller. |
| */ |
| performSaveAs(progressMonitor); |
| |
| } else { |
| |
| /* |
| * 1GF5YOX: ITPJUI:ALL - Save of delete file claims it's still |
| * there Missing resources. |
| */ |
| Shell shell = getSite().getShell(); |
| MessageDialog.openError(shell, |
| DLTKEditorMessages.SourceModuleEditor_error_saving_title1, |
| DLTKEditorMessages.SourceModuleEditor_error_saving_message1); |
| } |
| |
| } else { |
| |
| setStatusLineErrorMessage(null); |
| |
| updateState(getEditorInput()); |
| validateState(getEditorInput()); |
| |
| IWorkingCopyManager manager = DLTKUIPlugin.getDefault() |
| .getWorkingCopyManager(); |
| ISourceModule unit = manager.getWorkingCopy(getEditorInput()); |
| |
| if (unit != null) { |
| // synchronized (unit) { |
| performSave(false, progressMonitor); |
| // } |
| } else |
| performSave(false, progressMonitor); |
| } |
| } |
| |
| /** |
| * Returns the signed current selection. The length will be negative if the |
| * resulting selection is right-to-left (RtoL). |
| * <p> |
| * The selection offset is model based. |
| * </p> |
| * |
| * @param sourceViewer |
| * the source viewer |
| * @return a region denoting the current signed selection, for a resulting |
| * RtoL selections length is < 0 |
| */ |
| protected IRegion getSignedSelection(ISourceViewer sourceViewer) { |
| StyledText text = sourceViewer.getTextWidget(); |
| Point selection = text.getSelectionRange(); |
| |
| if (text.getCaretOffset() == selection.x) { |
| selection.x = selection.x + selection.y; |
| selection.y = -selection.y; |
| } |
| |
| selection.x = widgetOffset2ModelOffset(sourceViewer, selection.x); |
| |
| return new Region(selection.x, selection.y); |
| } |
| |
| protected final static char[] BRACKETS = { '{', '}', '(', ')', '[', ']' }; |
| |
| protected static boolean isBracket(char character) { |
| for (int i = 0; i != BRACKETS.length; ++i) |
| if (character == BRACKETS[i]) |
| return true; |
| return false; |
| } |
| |
| protected static boolean isSurroundedByBrackets(IDocument document, |
| int offset) { |
| if (offset == 0 || offset == document.getLength()) |
| return false; |
| |
| try { |
| return isBracket(document.getChar(offset - 1)) |
| && isBracket(document.getChar(offset)); |
| |
| } catch (BadLocationException e) { |
| return false; |
| } |
| } |
| |
| private ICharacterPairMatcher fBracketMatcher; |
| |
| /** |
| * Returns the bracket matcher for this editor, delegates to |
| * {@link #createBracketMatcher()} to actually create it. |
| * |
| * @return the bracket matcher or <code>null</code> |
| */ |
| protected final ICharacterPairMatcher getBracketMatcher() { |
| if (fBracketMatcher == null) { |
| fBracketMatcher = createBracketMatcher(); |
| } |
| return fBracketMatcher; |
| } |
| |
| /** |
| * Override in your editor class to create bracket matcher for your |
| * language. |
| * |
| * @return |
| */ |
| protected ICharacterPairMatcher createBracketMatcher() { |
| return null; |
| } |
| |
| @Override |
| protected void configureSourceViewerDecorationSupport( |
| SourceViewerDecorationSupport support) { |
| configureBracketMatcher(support); |
| super.configureSourceViewerDecorationSupport(support); |
| } |
| |
| protected void configureBracketMatcher( |
| SourceViewerDecorationSupport support) { |
| final ICharacterPairMatcher bracketMatcher = getBracketMatcher(); |
| if (bracketMatcher != null) { |
| support.setCharacterPairMatcher(bracketMatcher); |
| support.setMatchingCharacterPainterPreferenceKeys(MATCHING_BRACKETS, |
| MATCHING_BRACKETS_COLOR); |
| } |
| } |
| |
| /** |
| * Jumps to the matching bracket. |
| */ |
| public void gotoMatchingBracket() { |
| final ICharacterPairMatcher bracketMatcher = getBracketMatcher(); |
| if (bracketMatcher == null) { |
| return; |
| } |
| ISourceViewer sourceViewer = getSourceViewer(); |
| IDocument document = sourceViewer.getDocument(); |
| if (document == null) |
| return; |
| |
| IRegion selection = getSignedSelection(sourceViewer); |
| |
| int selectionLength = Math.abs(selection.getLength()); |
| if (selectionLength > 1) { |
| setStatusLineErrorMessage( |
| DLTKEditorMessages.ScriptEditor_nobracketSelected); |
| sourceViewer.getTextWidget().getDisplay().beep(); |
| return; |
| } |
| |
| // #26314 |
| int sourceCaretOffset = selection.getOffset() + selection.getLength(); |
| if (isSurroundedByBrackets(document, sourceCaretOffset)) |
| sourceCaretOffset -= selection.getLength(); |
| |
| IRegion region = bracketMatcher.match(document, sourceCaretOffset); |
| if (region == null) { |
| setStatusLineErrorMessage( |
| DLTKEditorMessages.ScriptEditor_noMatchingBracketFound); |
| sourceViewer.getTextWidget().getDisplay().beep(); |
| return; |
| } |
| |
| int offset = region.getOffset(); |
| int length = region.getLength(); |
| |
| if (length < 1) |
| return; |
| |
| int anchor = bracketMatcher.getAnchor(); |
| // http://dev.eclipse.org/bugs/show_bug.cgi?id=34195 |
| int targetOffset = (ICharacterPairMatcher.RIGHT == anchor) ? offset + 1 |
| : offset + length; |
| |
| boolean visible = false; |
| if (sourceViewer instanceof ITextViewerExtension5) { |
| ITextViewerExtension5 extension = (ITextViewerExtension5) sourceViewer; |
| visible = (extension.modelOffset2WidgetOffset(targetOffset) > -1); |
| } else { |
| IRegion visibleRegion = sourceViewer.getVisibleRegion(); |
| // http://dev.eclipse.org/bugs/show_bug.cgi?id=34195 |
| visible = (targetOffset >= visibleRegion.getOffset() |
| && targetOffset <= visibleRegion.getOffset() |
| + visibleRegion.getLength()); |
| } |
| |
| if (!visible) { |
| setStatusLineErrorMessage( |
| DLTKEditorMessages.ScriptEditor_matchingBracketIsOutsideSelectedElement); |
| sourceViewer.getTextWidget().getDisplay().beep(); |
| return; |
| } |
| |
| if (selection.getLength() < 0) |
| targetOffset -= selection.getLength(); |
| |
| sourceViewer.setSelectedRange(targetOffset, selection.getLength()); |
| sourceViewer.revealRange(targetOffset, selection.getLength()); |
| } |
| |
| public void updatedTitleImage(Image image) { |
| setTitleImage(image); |
| } |
| |
| private ListenerList<IScriptReconcilingListener> fReconcilingListeners = new ListenerList<>( |
| ListenerList.IDENTITY); |
| |
| /** |
| * Mutex for the reconciler. See |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=63898 for a description of |
| * the problem. |
| * <p> |
| * XXX remove once the underlying problem |
| * (https://bugs.eclipse.org/bugs/show_bug.cgi?id=66176) is solved. |
| * </p> |
| */ |
| private final Object fReconcilerLock = new Object(); |
| |
| @Override |
| public void aboutToBeReconciled() { |
| |
| // Notify AST provider |
| // JavaPlugin.getDefault().getASTProvider().aboutToBeReconciled( |
| // getInputJavaElement()); |
| |
| // Notify listeners |
| for (IScriptReconcilingListener listener : fReconcilingListeners) |
| listener.aboutToBeReconciled(); |
| } |
| |
| /* |
| * @see |
| * org.eclipse.jdt.internal.ui.text.java.IJavaReconcilingListener#reconciled |
| * (CompilationUnit, boolean, IProgressMonitor) |
| * |
| * @since 3.0 |
| */ |
| @Override |
| public void reconciled(ISourceModule ast, boolean forced, |
| IProgressMonitor progressMonitor) { |
| |
| // see: https://bugs.eclipse.org/bugs/show_bug.cgi?id=58245 |
| // JavaPlugin javaPlugin= JavaPlugin.getDefault(); |
| // if (javaPlugin == null) |
| // return; |
| // |
| // // Always notify AST provider |
| // javaPlugin.getASTProvider().reconciled(ast, getInputJavaElement(), |
| // progressMonitor); |
| |
| // Notify listeners |
| for (IScriptReconcilingListener listener : fReconcilingListeners) |
| listener.reconciled(ast, forced, progressMonitor); |
| |
| // Update Outline page selection |
| if (!forced && !progressMonitor.isCanceled()) { |
| Shell shell = getSite().getShell(); |
| if (shell != null && !shell.isDisposed()) { |
| shell.getDisplay().asyncExec(() -> selectionChanged()); |
| } |
| } |
| } |
| |
| public void addReconcileListener( |
| IScriptReconcilingListener semanticHighlightingReconciler) { |
| fReconcilingListeners.add(semanticHighlightingReconciler); |
| } |
| |
| public void removeReconcileListener( |
| IScriptReconcilingListener semanticHighlightingReconciler) { |
| fReconcilingListeners.remove(semanticHighlightingReconciler); |
| } |
| |
| private SemanticHighlightingManager fSemanticManager; |
| |
| private void installSemanticHighlighting() { |
| ScriptTextTools textTools = getTextTools(); |
| if (fSemanticManager == null && textTools != null) { |
| final ISemanticHighlightingUpdater updater = textTools |
| .getSemanticPositionUpdater(getNatureId()); |
| if (updater != null) { |
| fSemanticManager = new SemanticHighlightingManager(updater); |
| fSemanticManager.install(this, |
| (ScriptSourceViewer) getSourceViewer(), |
| textTools.getColorManager(), getPreferenceStore()); |
| } |
| } |
| } |
| |
| private void updateSemanticHighlighting() { |
| final IModelElement element = getInputModelElement(); |
| if (!(element instanceof ISourceModule)) { |
| return; |
| } |
| Job job = new Job( |
| DLTKEditorMessages.ScriptEditor_InitializeSemanticHighlighting) { |
| @Override |
| protected IStatus run(IProgressMonitor monitor) { |
| if (fSemanticManager != null) { |
| SemanticHighlightingReconciler reconciler = fSemanticManager |
| .getReconciler(); |
| if (reconciler != null) |
| reconciler.reconciled((ISourceModule) element, false, |
| monitor); |
| } |
| return Status.OK_STATUS; |
| } |
| }; |
| job.setPriority(Job.DECORATE); |
| job.setSystem(true); |
| job.schedule(); |
| } |
| |
| /** |
| * Uninstall Semantic Highlighting. |
| * |
| * @since 3.0 |
| */ |
| private void uninstallSemanticHighlighting() { |
| if (fSemanticManager != null) { |
| fSemanticManager.uninstall(); |
| fSemanticManager = null; |
| } |
| } |
| |
| @Override |
| public int getOrientation() { |
| return SWT.LEFT_TO_RIGHT; |
| } |
| |
| @Override |
| protected String[] collectContextMenuPreferencePages() { |
| final List<String> result = new ArrayList<>(); |
| final IDLTKUILanguageToolkit uiToolkit = getUILanguageToolkit(); |
| addPages(result, uiToolkit.getEditorPreferencePages()); |
| addPages(result, super.collectContextMenuPreferencePages()); |
| return result.toArray(new String[result.size()]); |
| } |
| |
| private void addPages(final List<String> result, final String[] pages) { |
| if (pages != null) { |
| for (int i = 0; i < pages.length; ++i) { |
| if (!result.contains(pages[i])) { |
| result.add(pages[i]); |
| } |
| } |
| } |
| } |
| |
| /* |
| * @see AbstractDecoratedTextEditor#isTabsToSpacesConversionEnabled() |
| */ |
| @Override |
| protected boolean isTabsToSpacesConversionEnabled() { |
| return getPreferenceStore() != null |
| && CodeFormatterConstants.SPACE.equals(getPreferenceStore() |
| .getString(CodeFormatterConstants.FORMATTER_TAB_CHAR)); |
| } |
| |
| private boolean isHandledPropertyEvent(String property, String[] handled) { |
| for (int i = 0; i < handled.length; i++) { |
| if (handled[i].equals(property)) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| protected String getSymbolicFontName() { |
| return getFontPropertyPreferenceKey(); |
| } |
| |
| /* |
| * Increase visibility for this package - called from {@link |
| * OccurrencesFinder} |
| */ |
| @Override |
| protected IProgressMonitor getProgressMonitor() { |
| return super.getProgressMonitor(); |
| } |
| |
| } |
