Java tutorial
/** * This file Copyright (c) 2005-2008 Aptana, Inc. This program is * dual-licensed under both the Aptana Public License and the GNU General * Public license. You may elect to use one or the other of these licenses. * * This program is distributed in the hope that it will be useful, but * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or * NONINFRINGEMENT. Redistribution, except as permitted by whichever of * the GPL or APL you select, is prohibited. * * 1. For the GPL license (GPL), you can redistribute and/or modify this * program under the terms of the GNU General Public License, * Version 3, as published by the Free Software Foundation. You should * have received a copy of the GNU General Public License, Version 3 along * with this program; if not, write to the Free Software Foundation, Inc., 51 * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Aptana provides a special exception to allow redistribution of this file * with certain other free and open source software ("FOSS") code and certain additional terms * pursuant to Section 7 of the GPL. You may view the exception and these * terms on the web at http://www.aptana.com/legal/gpl/. * * 2. For the Aptana Public License (APL), this program and the * accompanying materials are made available under the terms of the APL * v1.0 which accompanies this distribution, and is available at * http://www.aptana.com/legal/apl/. * * You may view the GPL, Aptana's exception and additional terms, and the * APL in the file titled license.html at the root of the corresponding * plugin containing this source file. * * Any modifications to this file must keep this entire header intact. */ package com.aptana.ide.editors.unified; import java.io.File; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Vector; import org.eclipse.core.resources.IFile; import org.eclipse.core.runtime.CoreException; 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.help.IContextProvider; import org.eclipse.jface.action.Action; import org.eclipse.jface.action.IMenuManager; import org.eclipse.jface.action.Separator; import org.eclipse.jface.dialogs.MessageDialog; import org.eclipse.jface.preference.IPreferenceStore; import org.eclipse.jface.preference.PreferenceConverter; import org.eclipse.jface.preference.PreferenceStore; import org.eclipse.jface.text.IDocument; import org.eclipse.jface.text.IDocumentExtension3; import org.eclipse.jface.text.IRegion; import org.eclipse.jface.text.ISynchronizable; import org.eclipse.jface.text.ITextListener; import org.eclipse.jface.text.ITextViewerExtension2; import org.eclipse.jface.text.ITextViewerExtension5; import org.eclipse.jface.text.ITypedRegion; import org.eclipse.jface.text.Position; import org.eclipse.jface.text.Region; import org.eclipse.jface.text.TextEvent; import org.eclipse.jface.text.TextPresentation; import org.eclipse.jface.text.WhitespaceCharacterPainter; 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.IAnnotationModelExtension; import org.eclipse.jface.text.source.IOverviewRuler; import org.eclipse.jface.text.source.ISharedTextColors; import org.eclipse.jface.text.source.ISourceViewer; import org.eclipse.jface.text.source.IVerticalRuler; import org.eclipse.jface.text.source.IVerticalRulerColumn; import org.eclipse.jface.text.source.SourceViewer; import org.eclipse.jface.text.source.SourceViewerConfiguration; import org.eclipse.jface.text.source.UnifiedLineNumberChangeRulerColumn; import org.eclipse.jface.text.source.UnifiedOverviewRuler; import org.eclipse.jface.text.source.projection.ProjectionAnnotation; import org.eclipse.jface.text.source.projection.ProjectionAnnotationModel; import org.eclipse.jface.text.source.projection.ProjectionViewer; import org.eclipse.jface.text.source.projection.UnifiedProjectionSupport; import org.eclipse.jface.text.source.projection.UnifiedRulerColumn; import org.eclipse.jface.util.IPropertyChangeListener; import org.eclipse.jface.util.PropertyChangeEvent; import org.eclipse.jface.util.SafeRunnable; import org.eclipse.jface.viewers.IPostSelectionProvider; import org.eclipse.jface.viewers.ISelectionChangedListener; import org.eclipse.jface.viewers.ISelectionProvider; import org.eclipse.jface.viewers.SelectionChangedEvent; import org.eclipse.swt.SWT; import org.eclipse.swt.custom.LineStyleEvent; import org.eclipse.swt.custom.LineStyleListener; import org.eclipse.swt.custom.StyleRange; import org.eclipse.swt.custom.StyledText; import org.eclipse.swt.custom.TextChangeListener; import org.eclipse.swt.custom.TextChangedEvent; import org.eclipse.swt.custom.TextChangingEvent; import org.eclipse.swt.custom.VerifyKeyListener; import org.eclipse.swt.events.ControlAdapter; import org.eclipse.swt.events.ControlEvent; import org.eclipse.swt.events.FocusAdapter; import org.eclipse.swt.events.FocusEvent; import org.eclipse.swt.events.KeyEvent; import org.eclipse.swt.events.KeyListener; import org.eclipse.swt.events.MouseEvent; import org.eclipse.swt.events.MouseListener; import org.eclipse.swt.events.PaintEvent; import org.eclipse.swt.events.PaintListener; import org.eclipse.swt.events.SelectionAdapter; import org.eclipse.swt.events.SelectionEvent; import org.eclipse.swt.events.SelectionListener; import org.eclipse.swt.events.TraverseEvent; import org.eclipse.swt.events.TraverseListener; import org.eclipse.swt.events.VerifyEvent; import org.eclipse.swt.graphics.Color; import org.eclipse.swt.graphics.GC; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.graphics.ImageData; import org.eclipse.swt.graphics.PaletteData; import org.eclipse.swt.graphics.Point; import org.eclipse.swt.graphics.RGB; import org.eclipse.swt.widgets.Caret; import org.eclipse.swt.widgets.Composite; import org.eclipse.swt.widgets.Control; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Event; import org.eclipse.swt.widgets.Listener; import org.eclipse.swt.widgets.ScrollBar; import org.eclipse.ui.IEditorInput; import org.eclipse.ui.IEditorPart; import org.eclipse.ui.IEditorSite; import org.eclipse.ui.IFileEditorInput; import org.eclipse.ui.IPartListener; import org.eclipse.ui.IPathEditorInput; import org.eclipse.ui.IURIEditorInput; import org.eclipse.ui.IWorkbench; import org.eclipse.ui.PartInitException; import org.eclipse.ui.PlatformUI; import org.eclipse.ui.internal.editors.text.EditorsPlugin; import org.eclipse.ui.internal.editors.text.NonExistingFileEditorInput; import org.eclipse.ui.navigator.CommonNavigator; import org.eclipse.ui.plugin.AbstractUIPlugin; import org.eclipse.ui.progress.UIJob; import org.eclipse.ui.texteditor.AbstractDecoratedTextEditorPreferenceConstants; import org.eclipse.ui.texteditor.AbstractTextEditor; import org.eclipse.ui.texteditor.AnnotationPreference; import org.eclipse.ui.texteditor.BookmarkRulerAction; import org.eclipse.ui.texteditor.ChainedPreferenceStore; import org.eclipse.ui.texteditor.IDocumentProvider; import org.eclipse.ui.texteditor.ITextEditorActionDefinitionIds; import org.eclipse.ui.texteditor.SourceViewerDecorationSupport; import org.eclipse.ui.texteditor.TaskRulerAction; import org.eclipse.ui.texteditor.TextOperationAction; import org.eclipse.ui.views.contentoutline.IContentOutlinePage; import com.aptana.ide.core.IdeLog; import com.aptana.ide.core.StringUtils; import com.aptana.ide.core.ui.CoreUIUtils; import com.aptana.ide.core.ui.editors.ISaveAsEvent; import com.aptana.ide.core.ui.editors.ISaveEvent; import com.aptana.ide.editors.UnifiedEditorsPlugin; import com.aptana.ide.editors.actions.OpenDeclarationAction; import com.aptana.ide.editors.formatting.UnifiedBracketInserterManager; import com.aptana.ide.editors.managers.FileContextManager; import com.aptana.ide.editors.preferences.IPreferenceConstants; import com.aptana.ide.editors.unified.actions.CodeFormatAction; import com.aptana.ide.editors.unified.actions.GotoMatchingBracketAction; import com.aptana.ide.editors.unified.actions.UnifiedActionContributor; import com.aptana.ide.editors.unified.colorizer.LanguageColorizer; import com.aptana.ide.editors.unified.colorizer.UnifiedCursorLinePainter; import com.aptana.ide.editors.unified.contentassist.ContentAssistAction; import com.aptana.ide.editors.unified.context.ContextItem; import com.aptana.ide.editors.unified.context.IContextAwareness; import com.aptana.ide.editors.unified.errors.ExternalFileErrorListener; import com.aptana.ide.editors.unified.errors.FileErrorListener; import com.aptana.ide.editors.unified.errors.ProjectFileErrorListener; import com.aptana.ide.editors.unified.folding.FoldingExtensionPointLoader; import com.aptana.ide.editors.unified.folding.LanguageProjectAnnotation; import com.aptana.ide.editors.unified.help.LexemeUIHelp; import com.aptana.ide.editors.unified.messaging.UnifiedMessages; import com.aptana.ide.editors.untitled.BaseTextEditor; import com.aptana.ide.lexer.IRange; import com.aptana.ide.lexer.Lexeme; import com.aptana.ide.lexer.LexemeList; import com.aptana.ide.lexer.TokenCategories; import com.aptana.ide.parsing.IParseState; import com.aptana.ide.views.outline.UnifiedOutlinePage; import com.aptana.ide.views.outline.UnifiedQuickOutlinePage; /** * UnifiedEditor */ public abstract class UnifiedEditor extends BaseTextEditor implements IUnifiedEditor, IPropertyChangeListener, ISelectionChangedListener, IRedrawRangeListener { /** * ADD_BOOKMARK */ public static final String ADD_BOOKMARK = "AddBookmark"; //$NON-NLS-1$ /** * ADD_TASK */ public static final String ADD_TASK = "AddTask"; //$NON-NLS-1$ /** * ctrlDown */ public static boolean ctrlDown; /** * outlinePage */ protected UnifiedOutlinePage outlinePage; /** * Auto activate for code assist, used for ContentAssistant AutoActivation listener */ protected boolean autoActivateCodeAssist = true; /** * File service change listeners */ protected ListenerList fileServiceChangeListeners = new ListenerList(); private UnifiedColorizer _colorizer; private IUnifiedEditorContributor _baseContributor; private FileErrorListener _errorListener; private WhitespaceCharacterPainter _whitespacePainter; private EditorFileContext _fileContextWrapper; // private UnifiedBracketMatcher bracketMatcher; private ArrayList<ISaveAsEvent> _saveAsListeners; private ArrayList<ISaveEvent> _saveListeners; private CommonNavigator _fileExplorerView; // private TextColorer textColorer; private IPreferenceStore _prefStore; private IPartListener _partListener; private UnifiedProjectionSupport _projectionSupport; private Listener _keyUpListener; private VerifyKeyListener _verifyKeyListener; private UnifiedViewer _viewer; private IContextAwareness _contextAwareness; private boolean _isDisposing = false; private boolean _hasKeyBeenPressed = false; private LineStyleListener _lineStyleListener; private TextChangeListener _textChangeListener; private PairMatcher _pairMatcher; private Image _caretImage; private UnifiedCursorLinePainter _painter; private int _maxColorizingColumns; private boolean _extendedStylesEnabled; private SelectionAdapter _selectionListener; private FocusAdapter _focusListener; private ITextListener _textListener; private IPreferenceStore _runtimeStore = new PreferenceStore(); private UnifiedBracketInserterManager _bracketInserterManager; private CodeFormatAction _formatAction; /** * UnifiedEditor */ public UnifiedEditor() { super(); addPluginToPreferenceStore(UnifiedEditorsPlugin.getDefault()); this._saveListeners = new ArrayList<ISaveEvent>(); this._saveAsListeners = new ArrayList<ISaveAsEvent>(); // bracketMatcher = new UnifiedBracketMatcher(); /** * See UnifiedEditor.init for comments regarding the movement of object creation/abstract method calling from * this constructor to that method. */ } /** * @see org.eclipse.ui.texteditor.AbstractTextEditor#init(org.eclipse.ui.IEditorSite, org.eclipse.ui.IEditorInput) */ public void init(IEditorSite site, IEditorInput input) throws PartInitException { /** * The following lines of code were moved from the default constructor to allow anonymous UnifiedEditors to be * created from the GenericTextEditor. This code was moved to this specific method since the calling of this * method signifies the beginning of the editors life-cycle and it called following the call to the constructor. * See comments for AbstractTextEditor.init for more details about the timing of this method call. */ this._baseContributor = createLocalContributor(); this._colorizer = UnifiedColorizer.getInstance(); setSourceViewerConfiguration(new UnifiedConfiguration(this, getPreferenceStore())); // Keeping in, as it may have side effects getFileServiceFactory(); this._prefStore = UnifiedEditorsPlugin.getDefault().getPreferenceStore(); this._prefStore = (this._prefStore == null) ? null : this._prefStore; // make compiler happy // TODO: Actuate change // setDocumentProvider(UnifiedDocumentProvider.getInstance()); setDocumentProvider(createDocumentProvider()); this._fileContextWrapper = new EditorFileContext(); // Update the base contributor with the file context this._baseContributor.setFileContext(this._fileContextWrapper); /** * This marks the end of the moved lines from the default UnifiedEditor constructor */ syncFoldingPreferenceStore(); super.init(site, input); setEditorContextMenuId(getSite().getId() + "#UnifiedEditorContext"); //$NON-NLS-1$ setRulerContextMenuId(getSite().getId() + "#UnifiedRulerContext"); //$NON-NLS-1$ IPreferenceStore localPreferenceStore = this.getPreferenceStore(); if (localPreferenceStore != null) { autoActivateCodeAssist = localPreferenceStore .getBoolean(IPreferenceConstants.CODE_ASSIST_AUTO_ACTIVATION); } IUnifiedEditorContributor[] contributors = this._baseContributor.getChildContributors(); // Process children for auto activate code assist if the parent is not // already requesting it if (contributors != null && !autoActivateCodeAssist) { for (int i = 0; i < contributors.length; i++) { autoActivateCodeAssist = autoActivateCodeAssist || contributors[i].isAutoActivateContentAssist(); // Once we find a language that wants it we just break and it // will be setup to listen if (autoActivateCodeAssist) { break; } } } } /** * This method circumvents that the line change ruler on AbstractDecoratedTextEditor is private. A placeholder pref * store is used to sync our colorization values with the Eclipse values that this ruler pulls from. */ private void syncFoldingPreferenceStore() { if (this._baseContributor != null) { String language = this._baseContributor.getLocalContentType(); LanguageColorizer colorizer = LanguageRegistry.getLanguageColorizer(language); if (colorizer != null && colorizer.getFoldingBg() != null) { this._runtimeStore.setDefault(PREFERENCE_COLOR_BACKGROUND_SYSTEM_DEFAULT, true); this._runtimeStore.setValue(PREFERENCE_COLOR_BACKGROUND_SYSTEM_DEFAULT, false); PreferenceConverter.setValue(this._runtimeStore, PREFERENCE_COLOR_BACKGROUND, colorizer.getFoldingBg().getRGB()); } } } /** * @see org.eclipse.ui.texteditor.AbstractDecoratedTextEditor#rulerContextMenuAboutToShow(org.eclipse.jface.action.IMenuManager) */ protected void rulerContextMenuAboutToShow(IMenuManager menu) { menu.add(getAction(ADD_BOOKMARK)); menu.add(getAction(ADD_TASK)); menu.add(new Separator("source"));// TODO: add this constant //$NON-NLS-1$ menu.add(_formatAction); _formatAction.setActiveEditor(null, this); menu.add(new Separator()); super.rulerContextMenuAboutToShow(menu); FoldingExtensionPointLoader.fillRulerContextMenu(this, menu); } /** * @see org.eclipse.ui.texteditor.AbstractTextEditor#editorContextMenuAboutToShow(org.eclipse.jface.action.IMenuManager) */ protected void editorContextMenuAboutToShow(IMenuManager menu) { menu.add(new Separator("debug")); // TODO: find where this constant is defined //$NON-NLS-1$ super.editorContextMenuAboutToShow(menu); IUnifiedEditorContributor contributor = getBaseContributor(); if (contributor != null) { String mimeType = contributor.getLocalContentType(); if (mimeType != null && LanguageRegistry.getCodeFormatter(mimeType) != null) { menu.add(new Separator("source")); // TODO: add this constant //$NON-NLS-1$ menu.add(_formatAction); _formatAction.setActiveEditor(null, this); } OpenDeclarationAction openDelcaration = new OpenDeclarationAction(); openDelcaration.setActiveEditor(this, this.getFileContext().getLanguageService(mimeType)); menu.add(openDelcaration); } } /** * Adds the specified plugin to the list of plugin stores to check when searching for preference * * @param plugin * The plugin to add */ protected void addPluginToPreferenceStore(AbstractUIPlugin plugin) { setPreferenceStore(new ChainedPreferenceStore( new IPreferenceStore[] { this._runtimeStore, getPreferenceStore(), plugin.getPreferenceStore() })); } /** * @see org.eclipse.ui.IWorkbenchPart#createPartControl(org.eclipse.swt.widgets.Composite) */ public void createPartControl(Composite parent) { super.createPartControl(parent); ProjectionViewer viewer = (ProjectionViewer) getSourceViewer(); if (viewer.canDoOperation(ProjectionViewer.TOGGLE)) { viewer.doOperation(ProjectionViewer.TOGGLE); } // TODO refactor to new colorizer system this._maxColorizingColumns = getPreferenceStore().getInt(IPreferenceConstants.COLORIZER_MAXCOLUMNS); linkColorer(); linkPairMatcher(); // Keyword/variable highlight this._extendedStylesEnabled = getPreferenceStore() .getBoolean(IPreferenceConstants.COLORIZER_TEXT_HIGHLIGHT_ENABLED); if (this._extendedStylesEnabled) { installTextOccurrenceHighlightSupport(); } // Overridden here, as this matches what JavaEditor does. Can be done at // any point after // text widget is created. LexemeUIHelp.setHelp(this, this.getViewer().getTextWidget(), getFileContext()); // Add support for custom colors for background, selection, line // highlight, and caret setEditorOptions(); } private void setEditorOptions() { // Check in case init hasn't been called yet or creating the contributor // failed if (getBaseContributor() == null || this.getViewer() == null || this.getViewer().getTextWidget() == null) { return; } String language = getBaseContributor().getLocalContentType(); LanguageColorizer colorizer = LanguageRegistry.getLanguageColorizer(language); if (colorizer != null && colorizer.getLineHighlightColor() != null && colorizer.getCaretColor() != null && colorizer.getBackground() != null && colorizer.getSelectionForeground() != null && colorizer.getSelectionBackground() != null) { if (this.getViewer() instanceof ITextViewerExtension2) { ITextViewerExtension2 highlightEditor = (ITextViewerExtension2) this.getViewer(); if (this.getViewer().getTextWidget() != null) { if (this._painter != null) { highlightEditor.removePainter(this._painter); } this._painter = new UnifiedCursorLinePainter(this, this.getViewer()); this._painter.setHighlightColor(colorizer.getLineHighlightColor()); highlightEditor.addPainter(this._painter); if (this._selectionListener != null) { this.getViewer().getTextWidget().removeSelectionListener(this._selectionListener); } if (this._focusListener != null) { this.getViewer().getTextWidget().removeFocusListener(this._focusListener); } if (this._textListener != null) { this.getViewer().removeTextListener(this._textListener); } this._selectionListener = new SelectionAdapter() { public void widgetSelected(SelectionEvent e) { StyledText text = getViewer().getTextWidget(); if (_painter != null && text != null && !text.isDisposed()) { Point p = text.getSelectionRange(); if (p.y == 0) { _painter.paintLines(0, text.getLineCount()); text.redraw(); text.update(); } } } }; this._focusListener = new FocusAdapter() { public void focusGained(FocusEvent e) { StyledText text = getViewer().getTextWidget(); if (_painter != null && text != null && !text.isDisposed()) { Point p = text.getSelectionRange(); if (p.y > 0) { _painter.paintLines(0, text.getLineCount()); } } } }; this._textListener = new ITextListener() { public void textChanged(TextEvent event) { StyledText text = getViewer().getTextWidget(); if (_painter != null && text != null && !text.isDisposed()) { Point p = text.getSelectionRange(); if (p.y > 0) { _painter.paintLines(0, text.getLineCount()); } } } }; this.getViewer().addTextListener(this._textListener); this.getViewer().getTextWidget().addFocusListener(this._focusListener); this.getViewer().getTextWidget().addSelectionListener(this._selectionListener); if (isWordWrapEnabled()) { this.getViewer().getTextWidget().setWordWrap(true); this.getViewer().getTextWidget().addControlListener(new ControlAdapter() { public void controlResized(ControlEvent e) { if (_projectionSupport != null) { UnifiedRulerColumn column = _projectionSupport.getRulerColumn(); if (column != null) { column.redraw(); } } IVerticalRuler ruler = getVerticalRuler(); if (ruler instanceof CompositeRuler) { Iterator columnIter = ((CompositeRuler) ruler).getDecoratorIterator(); while (columnIter.hasNext()) { Object column = columnIter.next(); if (column instanceof AnnotationRulerColumn) { ((AnnotationRulerColumn) column).redraw(); } } } if (fLineNumberRulerColumn != null) { fLineNumberRulerColumn.redraw(); } IOverviewRuler overviewRuler = getOverviewRuler(); if (overviewRuler != null) { overviewRuler.update(); } } }); } } } // Apply the folding background and forground colors setFoldingColors(colorizer); // Removing caret support on Carbon since it causes lag if (!Platform.getWS().equals(Platform.WS_CARBON)) { if (this.getViewer().getTextWidget() != null) { Caret caret = this.getViewer().getTextWidget().getCaret(); // Correct cursor color accordining to line highlight color RGB converted = new RGB(0, 0, 0); converted.red = Math .abs(colorizer.getCaretColor().getRed() - colorizer.getLineHighlightColor().getRed()); converted.blue = Math .abs(colorizer.getCaretColor().getBlue() - colorizer.getLineHighlightColor().getBlue()); converted.green = Math.abs( colorizer.getCaretColor().getGreen() - colorizer.getLineHighlightColor().getGreen()); PaletteData data = new PaletteData(new RGB[] { converted }); int x = caret.getSize().x; int y = caret.getSize().y; // Apparently the current caret may have invalid sizings // that will cause errors when an attempt to // change the color is made. So perform the check and catch // errors and exceptions so caret coloring // doesn't affect opening the editor. if (x > 0 && y > 0) { try { ImageData iData = new ImageData(x, y, 1, data); caret.setImage(null); if (this._caretImage != null) { this._caretImage.dispose(); this._caretImage = null; } this._caretImage = new Image(caret.getDisplay(), iData); caret.setImage(this._caretImage); } catch (Error e) { } catch (Exception e) { } } } } Color bg = colorizer.getBackground(); Color deadSpace = createDeadSpaceColor(bg); if (deadSpace != null && !deadSpace.isDisposed()) { this.getViewer().getTextWidget().setBackground(deadSpace); } else { this.getViewer().getTextWidget().setBackground(bg); } this.getViewer().getTextWidget().setSelectionBackground(colorizer.getSelectionBackground()); this.getViewer().getTextWidget().setSelectionForeground(colorizer.getSelectionForeground()); } else { IPreferenceStore store = EditorsPlugin.getDefault().getPreferenceStore(); RGB background = PreferenceConverter.getColor(store, AbstractTextEditor.PREFERENCE_COLOR_BACKGROUND); RGB selectionFg = PreferenceConverter.getColor(store, AbstractTextEditor.PREFERENCE_COLOR_SELECTION_FOREGROUND); RGB selectionBg = PreferenceConverter.getColor(store, AbstractTextEditor.PREFERENCE_COLOR_SELECTION_BACKGROUND); Color eclipseBackgroundColor = UnifiedColorManager.getInstance().getColor(background); if (store.getBoolean(AbstractTextEditor.PREFERENCE_COLOR_BACKGROUND_SYSTEM_DEFAULT)) { eclipseBackgroundColor = null; } Color eclipseSelectionFgColor = UnifiedColorManager.getInstance().getColor(selectionFg); if (store.getBoolean(AbstractTextEditor.PREFERENCE_COLOR_SELECTION_FOREGROUND_SYSTEM_DEFAULT)) { eclipseSelectionFgColor = null; } Color eclipseSelectionBgColor = UnifiedColorManager.getInstance().getColor(selectionBg); if (store.getBoolean(AbstractTextEditor.PREFERENCE_COLOR_SELECTION_BACKGROUND_SYSTEM_DEFAULT)) { eclipseSelectionBgColor = null; } Color deadSpace = createDeadSpaceColor(eclipseBackgroundColor); if (deadSpace != null) { this.getViewer().getTextWidget().setBackground(deadSpace); } else { this.getViewer().getTextWidget().setBackground(eclipseBackgroundColor); } this.getViewer().getTextWidget().setSelectionBackground(eclipseSelectionBgColor); this.getViewer().getTextWidget().setSelectionForeground(eclipseSelectionFgColor); Caret caret = this.getViewer().getTextWidget().getCaret(); caret.setImage(null); if (this._caretImage != null) { this._caretImage.dispose(); this._caretImage = null; } if (this.getViewer() instanceof ITextViewerExtension2) { ITextViewerExtension2 highlightEditor = (ITextViewerExtension2) this.getViewer(); if (this._painter != null) { highlightEditor.removePainter(this._painter); } } } } /** * Apply the forground and the background colors of the folding markers and bar. * * @param colorizer */ protected void setFoldingColors(LanguageColorizer colorizer) { if (colorizer.getFoldingFg() != null) { SourceViewerConfiguration config = this.getSourceViewerConfiguration(); if (config instanceof UnifiedConfiguration) { UnifiedReconcilingStrategy strategy = ((UnifiedConfiguration) config).getStrategy(); if (strategy != null) { strategy.setFoldingAnnotationHoverColor(colorizer.getFoldingFg()); } } } if (colorizer.getFoldingBg() != null) { if (this._projectionSupport != null) { UnifiedRulerColumn column = this._projectionSupport.getRulerColumn(); if (column != null) { column.setBackground(colorizer.getFoldingBg()); } } if (fLineNumberRulerColumn != null && fLineNumberRulerColumn.getControl() != null && !fLineNumberRulerColumn.getControl().isDisposed()) { if (fLineNumberRulerColumn instanceof UnifiedLineNumberChangeRulerColumn) { ((UnifiedLineNumberChangeRulerColumn) fLineNumberRulerColumn) .setTextWidget(getViewer().getTextWidget()); ((UnifiedLineNumberChangeRulerColumn) fLineNumberRulerColumn).setSourceViewer(getViewer()); } fLineNumberRulerColumn.setBackground(colorizer.getFoldingBg()); fLineNumberRulerColumn.redraw(); } } } private boolean isWordWrapEnabled() { return UnifiedEditorsPlugin.getDefault().getPreferenceStore() .getBoolean(IPreferenceConstants.ENABLE_WORD_WRAP); } /** * @see org.eclipse.ui.texteditor.AbstractDecoratedTextEditor#createLineNumberRulerColumn() */ protected IVerticalRulerColumn createLineNumberRulerColumn() { if (isWordWrapEnabled()) { if (isPrefQuickDiffAlwaysOn()) { UnifiedLineNumberChangeRulerColumn column = new UnifiedLineNumberChangeRulerColumn( getSharedColors()); if (getViewer() != null) { column.setSourceViewer(getViewer()); column.setTextWidget(getViewer().getTextWidget()); } column.setHover(createChangeHover()); // initializeChangeRulerColumn(column); fLineNumberRulerColumn = column; } else { fLineNumberRulerColumn = new UnifiedLineNumberChangeRulerColumn(getSharedColors()); if (getViewer() != null) { ((UnifiedLineNumberChangeRulerColumn) fLineNumberRulerColumn).setSourceViewer(getViewer()); ((UnifiedLineNumberChangeRulerColumn) fLineNumberRulerColumn) .setTextWidget(getViewer().getTextWidget()); } } initializeLineNumberRulerColumn(fLineNumberRulerColumn); return fLineNumberRulerColumn; } else { return super.createLineNumberRulerColumn(); } } /** * @see org.eclipse.ui.texteditor.AbstractDecoratedTextEditor#createOverviewRuler(org.eclipse.jface.text.source.ISharedTextColors) */ protected IOverviewRuler createOverviewRuler(ISharedTextColors sharedColors) { if (isWordWrapEnabled()) { IOverviewRuler ruler = new UnifiedOverviewRuler(getAnnotationAccess(), VERTICAL_RULER_WIDTH, sharedColors); Iterator e = EditorsPlugin.getDefault().getMarkerAnnotationPreferences().getAnnotationPreferences() .iterator(); while (e.hasNext()) { AnnotationPreference preference = (AnnotationPreference) e.next(); if (preference.contributesToHeader()) ruler.addHeaderAnnotationType(preference.getAnnotationType()); } return ruler; } else { return super.createOverviewRuler(sharedColors); } } private Color createDeadSpaceColor(Color bg) { if (bg != null) { int factor = 4; boolean canGoDarker = bg.getRed() - factor > 0 || bg.getGreen() - factor > 0 || bg.getBlue() - factor > 0; boolean canGoLighter = bg.getRed() + factor > 0 || bg.getGreen() + factor > 0 || bg.getBlue() + factor > 0; int red = 0; int green = 0; int blue = 0; if (canGoDarker) { red = bg.getRed() - factor > 0 ? (int) (bg.getRed() - factor) : bg.getRed(); green = bg.getGreen() - factor > 0 ? (int) (bg.getGreen() - factor) : bg.getGreen(); blue = bg.getBlue() - factor > 0 ? (int) (bg.getBlue() - factor) : bg.getBlue(); } else if (canGoLighter) { red = bg.getRed() + factor > 0 ? (int) (bg.getRed() + factor) : bg.getRed(); green = bg.getGreen() + factor > 0 ? (int) (bg.getGreen() + factor) : bg.getGreen(); blue = bg.getBlue() + factor > 0 ? (int) (bg.getBlue() + factor) : bg.getBlue(); } if (canGoDarker || canGoLighter) { Color deadSpace = UnifiedColorManager.getInstance().getColor(new RGB(red, green, blue)); return deadSpace; } } return null; } private void installTextOccurrenceHighlightSupport() { ISelectionProvider selectionProvider = getSelectionProvider(); if (selectionProvider instanceof IPostSelectionProvider) { IPostSelectionProvider provider = (IPostSelectionProvider) selectionProvider; provider.addPostSelectionChangedListener(this); } else { selectionProvider.addSelectionChangedListener(this); } this._extendedStylesEnabled = true; } private void uninstallTextOccurrenceHighlightSupport() { ISelectionProvider selectionProvider = getSelectionProvider(); if (selectionProvider != null) { if (selectionProvider instanceof IPostSelectionProvider) { IPostSelectionProvider provider = (IPostSelectionProvider) selectionProvider; provider.removePostSelectionChangedListener(this); } else { selectionProvider.removeSelectionChangedListener(this); } } removeMarkedOccurrences(); this._extendedStylesEnabled = false; } private IRange underLine; private Annotation[] fOccurrenceAnnotations; /** * removing given range from underlined state * * @param range */ void removeUnderlinedRange(IRange range) { underLine = range; StyledText textWidget = getViewer().getTextWidget(); try { textWidget.redrawRange(range.getStartingOffset(), range.getLength(), true); } catch (IllegalArgumentException e) { // Do nothing if the range being invalid causes an exception } } /** * @see com.aptana.ide.editors.unified.IRedrawRangeListener#redrawRange(com.aptana.ide.lexer.IRange) */ public void redrawRange(final IRange range) { if (range != null) { final StyledText textWidget = getViewer().getTextWidget(); Display display = textWidget.getDisplay(); display.asyncExec(new Runnable() { public void run() { try { textWidget.redrawRange(range.getStartingOffset(), range.getLength(), true); } catch (IllegalArgumentException e) { // Do nothing if the range being invalid causes an exception } } }); } } /** * sets current range to be underlined * * @param range */ void setUnderlinedRange(IRange range) { if (range != null) { underLine = null; StyledText textWidget = getViewer().getTextWidget(); try { textWidget.redrawRange(range.getStartingOffset(), range.getLength(), true); } catch (IllegalArgumentException e) { // Do nothing if the range being invalid causes an exception } } } private void linkColorer() { if (this._lineStyleListener == null) { this._lineStyleListener = new LineStyleListener() { /** * @see org.eclipse.swt.custom.LineStyleListener#lineGetStyle(org.eclipse.swt.custom.LineStyleEvent) */ public void lineGetStyle(LineStyleEvent e) { EditorFileContext fileContext = getFileContext(); // wrapper could be non-null, but interior is. if (fileContext == null || fileContext.getFileContext() == null) { return; } IParseState parseState = fileContext.getParseState(); if (parseState == null) { return; } LexemeList lexemeList = parseState.getLexemeList(); if (lexemeList == null) { IdeLog.logError(UnifiedEditorsPlugin.getDefault(), Messages.UnifiedEditor_LexemeListIsNull); return; } int orgOffset = e.lineOffset; int offset = orgOffset; int extra = 0; int lineLength = e.lineText.length(); // need to get actual offset values in the doc, // as widget offsets do not include potentially folded code if (_viewer instanceof ITextViewerExtension5) { ITextViewerExtension5 v5 = (ITextViewerExtension5) _viewer; offset = v5.widgetOffset2ModelOffset(e.lineOffset); extra = offset - e.lineOffset; } int maxLineLength = !isWordWrapEnabled() && lineLength > _maxColorizingColumns ? _maxColorizingColumns : lineLength; Lexeme[] lexemes = null; synchronized (lexemeList) { int startingIndex = lexemeList.getLexemeCeilingIndex(offset); int endingIndex = lexemeList.getLexemeFloorIndex(offset + maxLineLength); if (startingIndex == -1 && endingIndex != -1) { startingIndex = endingIndex; } if (endingIndex == -1 && startingIndex != -1) { endingIndex = startingIndex; } if (startingIndex != -1 && endingIndex != -1) { lexemes = lexemeList.cloneRange(startingIndex, endingIndex); } } if (lexemes != null) { Vector<StyleRange> styles = new Vector<StyleRange>(); _colorizer.createStyles(parseState, styles, lexemes, _extendedStylesEnabled); StyleRange[] styleResults = styles.toArray(new StyleRange[] {}); // move styles back to actual widget offsets in case of // folding if (extra > 0) { for (int i = 0; i < styleResults.length; i++) { StyleRange range = styleResults[i]; range.start -= extra; } } if (underLine != null) { for (int a = 0; a < styleResults.length; a++) { StyleRange styleRange = styleResults[a]; if (styleRange.start == underLine.getStartingOffset() && (styleRange.start + styleRange.length) == underLine.getEndingOffset()) { styleRange.underline = true; } } } else { for (int a = 0; a < styleResults.length; a++) { StyleRange styleRange = styleResults[a]; styleRange.underline = false; } } e.styles = styleResults; } UnifiedViewer rr = (UnifiedViewer) getViewer(); TextPresentation textPresentation = rr.getTextPresentation(); if (textPresentation != null) { TextPresentation ps = new TextPresentation(); if (e.styles != null) { ps.replaceStyleRanges(e.styles); } Iterator<?> nonDefaultStyleRangeIterator = textPresentation .getNonDefaultStyleRangeIterator(); while (nonDefaultStyleRangeIterator.hasNext()) { // Make sure that the StyleRange is at a visible location in case we have folded blocks in // the code. StyleRange clone = (StyleRange) ((StyleRange) nonDefaultStyleRangeIterator.next()) .clone(); IRegion region = new Region(clone.start, clone.length); region = rr.modelRange2WidgetRange(region); if (region != null) { clone.start = region.getOffset(); clone.length = region.getLength(); ps.mergeStyleRange(clone); } } Iterator<?> nonDefaultStyleRangeIterator2 = ps.getNonDefaultStyleRangeIterator(); ArrayList<StyleRange> rs = new ArrayList<StyleRange>(); while (nonDefaultStyleRangeIterator2.hasNext()) { StyleRange next = (StyleRange) nonDefaultStyleRangeIterator2.next(); rs.add(next); } e.styles = rs.toArray(new StyleRange[rs.size()]); } } }; } // Repaint lines if the user is making changes if (this._textChangeListener == null) { this._textChangeListener = new TextChangeListener() { public void textChanging(TextChangingEvent event) { } public void textChanged(TextChangedEvent event) { StyledText text = getViewer().getTextWidget(); redrawFrom(text, text.getLineAtOffset(text.getCaretOffset())); } // Used with complex text change events (tabbing, replacement, // etc.) public void textSet(TextChangedEvent event) { StyledText text = getViewer().getTextWidget(); redrawFrom(text, 0); } private void redrawFrom(StyledText text, int lno) { if (lno < 0 || lno >= text.getLineCount()) { return; } int height = text.getClientArea().height; int width = text.getClientArea().width + text.getHorizontalPixel(); try { text.redraw(0, 0, width, height, true); } catch (Exception e) { // Catch errors in redraw as they may be intermittent // and the subsequent redraw will complete // successfully } } }; } getViewer().getTextWidget().addLineStyleListener(this._lineStyleListener); getViewer().getTextWidget().getContent().addTextChangeListener(this._textChangeListener); } private void linkPairMatcher() { if (this._pairMatcher == null) { this._pairMatcher = new PairMatcher(); StyledText text = getViewer().getTextWidget(); text.addPaintListener(this._pairMatcher); text.addKeyListener(this._pairMatcher); text.addTraverseListener(this._pairMatcher); text.addMouseListener(this._pairMatcher); text.addSelectionListener(this._pairMatcher); ScrollBar sb = text.getVerticalBar(); if (sb != null) { sb.addSelectionListener(this._pairMatcher); } } } private void unlinkPairMatcher() { if (this._pairMatcher != null) { if (getViewer() == null) { return; } StyledText text = getViewer().getTextWidget(); if (text == null || text.isDisposed() == true) { return; } text.removePaintListener(this._pairMatcher); text.removeKeyListener(this._pairMatcher); text.removeTraverseListener(this._pairMatcher); text.removeMouseListener(this._pairMatcher); text.removeSelectionListener(this._pairMatcher); ScrollBar sb = text.getVerticalBar(); if (sb != null) { sb.removeSelectionListener(this._pairMatcher); } } } /** * @see com.aptana.ide.editors.unified.IUnifiedEditor#getPairMatch(int) */ public PairMatch getPairMatch(int offset) { IParseState parseState = this.getFileContext().getParseState(); if (parseState == null) { return null; } LexemeList lexemeList = parseState.getLexemeList(); Lexeme cursorLexeme = lexemeList.getLexemeFromOffset(offset); if (cursorLexeme == null && offset > 0) { cursorLexeme = lexemeList.getLexemeFromOffset(offset - 1); } if (cursorLexeme == null) { return null; } String language = cursorLexeme.getLanguage(); IPairFinder finder = LanguageRegistry.getPairFinder(language); PairMatch match = null; if (finder != null && !finder.doNotDisplay()) { if (finder instanceof AbstractPairFinder) { // NOTE: [KEL] loop count relates to each pair finder // implementation and should not be passed in // as an argument int loopCount = 2; match = ((AbstractPairFinder) finder).findPairMatch(offset, parseState, cursorLexeme, loopCount); } else { match = finder.findPairMatch(offset, parseState); } } if (match != null) { match.setColor(finder.getPairFinderColor()); match.setDisplayOnlyMatch(finder.displayOnlyMatch()); match.offset = offset; if (match instanceof IPairMatchExt) { List<PairMatch> subsequentMatches = ((IPairMatchExt) match).getSubsequentMatches(); for (PairMatch subMatch : subsequentMatches) { subMatch.setColor(finder.getPairFinderColor()); subMatch.setDisplayOnlyMatch(finder.displayOnlyMatch()); subMatch.offset = offset; } } // NOTE: [KEL] The following is subjective and therefore should // become a preference. Turning off for now // since this breaks the case where the matched pair on the right // touches but the matcher pair to the left // does not. In that scenario, we show no matching when we should // show the pair to the left // // This check is for the case when the pair match will border // each other which present a cluttered UI // with // // the match and the cursor // if (match.beginEnd == match.endStart || match.endEnd == // match.beginStart) // { // match = null; // } } return match; } /** * findBalancingLexeme * * @param startIndex * @param language * @param startType * @param endType * @param direction * @return Lexeme */ protected Lexeme findBalancingLexeme(int startIndex, String language, int startType, int endType, int direction) { LexemeList lexemeList = this.getFileContext().getParseState().getLexemeList(); return findBalancingLexeme(lexemeList, startIndex, language, startType, endType, direction); } /** * @param lexemeList * @param startIndex * @param language * @param startType * @param endType * @param direction * @return Lexeme */ public static Lexeme findBalancingLexeme(LexemeList lexemeList, int startIndex, String language, int startType, int endType, int direction) { Lexeme result = null; int count = 0; while (0 <= startIndex && startIndex < lexemeList.size()) { result = lexemeList.get(startIndex); if (result.getLanguage().equals(language)) { if (result.typeIndex == endType) { count--; if (count == 0) { break; } } else if (result.typeIndex == startType) { count++; } } startIndex += direction; } if (count != 0) { result = null; } return result; } /** * @author Paul Colton */ class PairMatcher implements SelectionListener, MouseListener, KeyListener, PaintListener, TraverseListener { private PairMatch _currentPair; /** * @see org.eclipse.swt.events.MouseListener#mouseDoubleClick(org.eclipse.swt.events.MouseEvent) */ public void mouseDoubleClick(MouseEvent e) { } /** * @see org.eclipse.swt.events.MouseListener#mouseDown(org.eclipse.swt.events.MouseEvent) */ public void mouseDown(MouseEvent e) { stateChanged(); } /** * @see org.eclipse.swt.events.MouseListener#mouseUp(org.eclipse.swt.events.MouseEvent) */ public void mouseUp(MouseEvent e) { } /** * @see org.eclipse.swt.events.KeyListener#keyPressed(org.eclipse.swt.events.KeyEvent) */ public void keyPressed(KeyEvent e) { stateChanged(); } /** * @see org.eclipse.swt.events.KeyListener#keyReleased(org.eclipse.swt.events.KeyEvent) */ public void keyReleased(KeyEvent e) { } /** * @see org.eclipse.swt.events.PaintListener#paintControl(org.eclipse.swt.events.PaintEvent) */ public void paintControl(PaintEvent e) { stateChanged(); pairsDraw(e.gc, this._currentPair); } /** * @see org.eclipse.swt.events.TraverseListener#keyTraversed(org.eclipse.swt.events.TraverseEvent) */ public void keyTraversed(TraverseEvent e) { stateChanged(); } /** * @see org.eclipse.swt.events.SelectionListener#widgetSelected(org.eclipse.swt.events.SelectionEvent) */ public void widgetSelected(SelectionEvent e) { stateChanged(); } /** * @see org.eclipse.swt.events.SelectionListener#widgetDefaultSelected(org.eclipse.swt.events.SelectionEvent) */ public void widgetDefaultSelected(SelectionEvent e) { } void stateChanged() { StyledText text = getViewer().getTextWidget(); if (text != null) { int offset = text.getCaretOffset(); if (getViewer() instanceof ITextViewerExtension5) { int resolved = ((ITextViewerExtension5) getViewer()).widgetOffset2ModelOffset(offset); if (resolved > -1) { offset = resolved; } } PairMatch newmatch = getPairMatch(offset); if ((newmatch == null && this._currentPair != null) || (newmatch != null && !newmatch.equals(this._currentPair))) { pairsDraw(null, this._currentPair); pairsDraw(null, newmatch); } this._currentPair = newmatch; } } void pairsDraw(GC gc, PairMatch pm) { if (pm == null) { return; } pairsDrawSingle(gc, pm); if (pm instanceof IPairMatchExt) { List<PairMatch> subsequentMatches = ((IPairMatchExt) pm).getSubsequentMatches(); if (subsequentMatches != null && subsequentMatches.size() > 0) { for (PairMatch subsequentMatch : subsequentMatches) { pairsDrawSingle(gc, subsequentMatch); } } } } void pairsDrawSingle(GC gc, PairMatch pm) { if (pm == null) { return; } StyledText text = getViewer().getTextWidget(); if (text != null) { int cursor = text.getCaretOffset(); if (pm.displayOnlyMatch() && gc != null) { if (cursor >= pm.beginStart && cursor <= pm.beginEnd) { pairDraw(gc, pm.endStart, pm.endEnd, pm.getColor()); } else if (cursor >= pm.endStart && cursor <= pm.endEnd) { pairDraw(gc, pm.beginStart, pm.beginEnd, pm.getColor()); } } else { pairDraw(gc, pm.beginStart, pm.beginEnd, pm.getColor()); pairDraw(gc, pm.endStart, pm.endEnd, pm.getColor()); } } } void pairDraw(GC gc, int start, int end, Color color) { StyledText text = getViewer().getTextWidget(); if (getViewer() instanceof ITextViewerExtension5) { ITextViewerExtension5 v5 = (ITextViewerExtension5) getViewer(); start = v5.modelOffset2WidgetOffset(start); end = v5.modelOffset2WidgetOffset(end); } if (start < 0 || end < 0 || start > text.getCharCount() || end > text.getCharCount()) { return; } if (gc != null) { try { Point left = text.getLocationAtOffset(start); Point right = text.getLocationAtOffset(end); gc.setForeground(color); gc.setLineWidth(1); gc.drawRectangle(left.x + 1, left.y + 1, right.x - left.x - 2, gc.getFontMetrics().getHeight() - 2); } catch (Exception e) { IdeLog.logError(UnifiedEditorsPlugin.getDefault(), StringUtils.format(Messages.UnifiedEditor_PairDraw, e.getMessage())); } } else { text.redrawRange(start, end - start, true); } } } /** * getDefaultFileExtension * * @return String */ public abstract String getDefaultFileExtension(); /** * @see org.eclipse.jface.util.IPropertyChangeListener#propertyChange(org.eclipse.jface.util.PropertyChangeEvent) */ public void propertyChange(PropertyChangeEvent e) { // if (textColorer == null) // return; // // if (e == null || // e.getProperty().equals(ColorizerPreferencePage.USE_BACK) || // e.getProperty().equals(ColorizerPreferencePage.HRD_SET)) // { // textColorer.setRegionMapper( // prefStore.getString(ColorizerPreferencePage.HRD_SET), // prefStore.getBoolean(ColorizerPreferencePage.USE_BACK)); // } // if (e == null || // e.getProperty().equals(ColorizerPreferencePage.FULL_BACK)){ // textColorer.setFullBackground(prefStore.getBoolean(ColorizerPreferencePage.FULL_BACK)); // } // if (e == null || // e.getProperty().equals(ColorizerPreferencePage.HORZ_CROSS) || // e.getProperty().equals(ColorizerPreferencePage.VERT_CROSS)) // { // textColorer.setCross( // prefStore.getBoolean(ColorizerPreferencePage.HORZ_CROSS), // prefStore.getBoolean(ColorizerPreferencePage.VERT_CROSS)); // } // // if (e == null || // e.getProperty().equals(ColorizerPreferencePage.PAIRS_MATCH)) { // String pairs = // prefStore.getString(ColorizerPreferencePage.PAIRS_MATCH); // int pmode = TextColorer.HLS_XOR; // if (pairs.equals("PAIRS_OUTLINE")) // pmode = TextColorer.HLS_OUTLINE; // if (pairs.equals("PAIRS_OUTLINE2")) // pmode = TextColorer.HLS_OUTLINE2; // textColorer.setPairsPainter(!pairs.equals("PAIRS_NO"), pmode); // } // if (e == null || // e.getProperty().equals(ColorizerPreferencePage.TEXT_FONT)){ // Font textFont = // JFaceResources.getFont(ColorizerPreferencePage.TEXT_FONT); // getViewer().getTextWidget().setFont(textFont); // } } /** * Are we currently the active editor? * * @return boolean */ public boolean isActiveEditor() { IEditorPart part = getEditorSite().getPage().getActiveEditor(); if (part == null) { return false; } else if (part instanceof IUnifiedEditor) { IUnifiedEditor editor = (IUnifiedEditor) part; return editor.getEditor() == this; } else { return part == this; } } /** * onKeyPressed * * @param event */ private void onKeyPressed(VerifyEvent event) { char c = event.character; StyledText styledText = (StyledText) event.widget; int keyCode = event.keyCode; // when undoing a template, the caret is not reset at this point ITypedRegion reg = this._fileContextWrapper.getPartitionAtOffset(styledText.getCaretOffset()); if (reg == null) { return; } final String contentType = reg.getType(); IUnifiedEditorContributor contributor = this._baseContributor.findChildContributor(contentType); if (contributor != null && contributor.isAutoActivateContentAssist() && contributor.isValidIdentifier(c, keyCode) && isLeftCharacterWhitespace(contributor, styledText, c, keyCode)) { getViewer().getTextWidget().setData(IContentAssistConstants.ASSIST_FORCE_ACTIVATION, true); showContentAssist(); } } /** * isLeftCharacterWhitespace * * @param styledText * @param c * @param keyCode * @return boolean */ private boolean isLeftCharacterWhitespace(IUnifiedEditorContributor contributor, StyledText styledText, char c, int keyCode) { int offset = styledText.getCaretOffset(); // Are we at beginning of file? if (offset == 0) { return true; } String line = styledText.getText(offset - 1, offset - 1); if (line.length() > 0) { return contributor.isValidActivationCharacter(line.charAt(0), keyCode); } else { return false; } } /** * showContentAssist */ private void showContentAssist() { final IWorkbench workbench = PlatformUI.getWorkbench(); final Display display = workbench.getDisplay(); display.asyncExec(new Runnable() { public void run() { try { final SourceViewer sv = (SourceViewer) getSourceViewer(); if (sv == null) { return; // guard against already closed editor } // In case you switched away Control c = display.getFocusControl(); if (c == null || c != sv.getTextWidget()) { return; } // Check if source viewer is able to perform operation if (sv.canDoOperation(SourceViewer.CONTENTASSIST_PROPOSALS)) { // Perform operation sv.doOperation(SourceViewer.CONTENTASSIST_PROPOSALS); } } catch (Exception e) { IdeLog.logError(UnifiedEditorsPlugin.getDefault(), Messages.UnifiedEditor_ErrorContentProposals, e); } } }); } /** * @see com.aptana.ide.editors.unified.IUnifiedEditor#showWhitespace(boolean) */ public void showWhitespace(boolean state) { ISourceViewer fSourceViewer = this.getSourceViewer(); if (state) { if (this._whitespacePainter == null) { if (fSourceViewer instanceof ITextViewerExtension2) { this._whitespacePainter = new WhitespaceCharacterPainter(fSourceViewer); ITextViewerExtension2 extension = (ITextViewerExtension2) fSourceViewer; extension.addPainter(this._whitespacePainter); } } } else { if (this._whitespacePainter != null) { if (fSourceViewer instanceof ITextViewerExtension2) { ITextViewerExtension2 extension = (ITextViewerExtension2) fSourceViewer; extension.removePainter(this._whitespacePainter); this._whitespacePainter.deactivate(true); this._whitespacePainter.dispose(); this._whitespacePainter = null; // this.getFileContext().removeLongDelayedFileListener(fWhitespacePainter); } } } } /** * @see com.aptana.ide.editors.unified.IUnifiedEditor#showPianoKeys(boolean) */ public void showPianoKeys(boolean state) { if (this._painter != null) { StyledText text = getViewer().getTextWidget(); this._painter.paintLines(0, text.getLineCount()); } } /** * Updates the folding structure * * @param annotations */ public void updateFoldingStructure(Map annotations) { List<Annotation> deletions = new ArrayList<Annotation>(); Collection additions = annotations.values(); ProjectionAnnotationModel currentModel = getProjectionAnnotationModel(); if (currentModel == null) { return; } for (Iterator iter = currentModel.getAnnotationIterator(); iter.hasNext();) { Object annotation = iter.next(); if (annotation instanceof ProjectionAnnotation) { Position position = currentModel.getPosition((Annotation) annotation); if (additions.contains(position)) { additions.remove(position); } else { deletions.add((Annotation) annotation); } } } if (annotations.size() != 0 || deletions.size() != 0) { currentModel.modifyAnnotations(deletions.toArray(new Annotation[deletions.size()]), annotations, null); } } /** * @see org.eclipse.ui.texteditor.AbstractTextEditor#createSourceViewer(org.eclipse.swt.widgets.Composite, * org.eclipse.jface.text.source.IVerticalRuler, int) */ protected ISourceViewer createSourceViewer(Composite parent, IVerticalRuler ruler, int styles) { // **** NOTE **** // we are not using Projection Viewer in order to get shift left working // (to shift until no // whitespace) // if this is problematic or 3.2 exposes that in a more intelligent way // (or fixes that // issue) // we can get rid of UnifiedViewer, and revert this one line of code // here (move back to // using // projectionViewer). // ISourceViewer viewer = new ProjectionViewer(parent, ruler, // getOverviewRuler(), // isOverviewRulerVisible(), // styles); this._viewer = new UnifiedViewer(parent, ruler, getOverviewRuler(), isOverviewRulerVisible(), styles); // ensure decoration support has been created and configured. getSourceViewerDecorationSupport(this._viewer); this._projectionSupport = new UnifiedProjectionSupport(this._viewer, getAnnotationAccess(), getSharedColors()); this._projectionSupport.install(); SourceViewer sv = this._viewer; Display d = this.getSite().getShell().getDisplay(); this._keyUpListener = new Listener() { public void handleEvent(Event e) { UnifiedEditor.ctrlDown = false; } }; d.addFilter(SWT.KeyUp, this._keyUpListener); this._verifyKeyListener = new VerifyKeyListener() { public void verifyKey(VerifyEvent event) { _hasKeyBeenPressed = true; onKeyPressed(event); // Check for Ctrl // note: state mask doesn't work for some reason if (event.keyCode == SWT.CTRL) { UnifiedEditor.ctrlDown = true; } else { UnifiedEditor.ctrlDown = false; } } }; sv.prependVerifyKeyListener(this._verifyKeyListener); SourceViewerConfiguration svc = this.getSourceViewerConfiguration(); if (svc instanceof UnifiedConfiguration) { UnifiedConfiguration uc = (UnifiedConfiguration) svc; this._bracketInserterManager = uc.getBracketInserterManager(sv); sv.prependVerifyKeyListener(this._bracketInserterManager); } return this._viewer; } // private IPreferenceStore fPreferenceStore; /** * @see org.eclipse.ui.texteditor.AbstractTextEditor#doSetInput(org.eclipse.ui.IEditorInput) */ protected void doSetInput(IEditorInput input) throws CoreException { // After Save As, we are getting a new IEditorInput each time // implicitly enters it into the hash of the document provider, using // input as the key super.doSetInput(input); try { // Get the document provider (which is a singleton) IDocumentProvider dp = getDocumentProvider(); if (dp == null) { throw new Exception(Messages.UnifiedEditor_DocumentProviderNull); } // Get document from input IDocument document = dp.getDocument(input); // TODO: Actuate change // UnifiedFileInfo cuInfo = (UnifiedFileInfo) // dp.getFileInfoPublic(input); // // if (cuInfo == null) // { // throw new Exception(Messages.UnifiedEditor_CuInfoIsNull); // } DocumentSourceProvider provider = new DocumentSourceProvider(document, input); if (provider == null) { throw new Exception(Messages.UnifiedEditor_ProviderIsNull); } // TODO: Actuate change // boolean isNewInput = (cuInfo.sourceProvider == null || // cuInfo.sourceProvider.equals(provider) == false); boolean isNewInput = isNewInput(input); // update various stuffs and more :-) // TODO: Actuate changes // updateFileInfo(input, provider, cuInfo, document, isNewInput); updateFileInfo(input, provider, document); // Commented out for now, as this code now lives in // UnifiedDocumentProvider // updateAnnotationModel(cuInfo); // TODO: Actuate changes // updatePartitioner(provider, cuInfo, document, isNewInput); updatePartitioner(provider, document, isNewInput); // Set the actual file context onto the wrapper this._fileContextWrapper.setFileContext(FileContextManager.get(provider.getSourceURI())); // Set up error listeners based on the the input file type setErrorListeners(input); fireNewFileServiceEvent(); // Refresh colorization if (this.getViewer() != null && this.getViewer().getTextWidget() != null) { this.getViewer().getTextWidget().redraw(); this.getViewer().getTextWidget().update(); } } catch (Exception e) { IdeLog.logError(UnifiedEditorsPlugin.getDefault(), "Unable to set input in UnifiedEditor: " //$NON-NLS-1$ + e.getMessage(), e); IStatus status = new Status(IStatus.ERROR, UnifiedEditorsPlugin.ID, IStatus.OK, "Unable to set input in Unified Editor", e);//$NON-NLS-1$ throw new CoreException(status); } } /** * @see com.aptana.ide.editors.unified.IUnifiedEditor#addFileServiceChangeListener(com.aptana.ide.editors.unified.IFileServiceChangeListener) */ public void addFileServiceChangeListener(IFileServiceChangeListener listener) { fileServiceChangeListeners.add(listener); } /** * @see com.aptana.ide.editors.unified.IUnifiedEditor#removeFileServiceChangeListener(com.aptana.ide.editors.unified.IFileServiceChangeListener) */ public void removeFileServiceChangeListener(IFileServiceChangeListener listener) { fileServiceChangeListeners.remove(listener); } /** * Updates the file service listeners with the new service */ private void fireNewFileServiceEvent() { if (this._fileContextWrapper != null && this._fileContextWrapper.getFileContext() != null) { final IFileService newService = this._fileContextWrapper.getFileContext(); // Notify file service listeners Object[] listeners = fileServiceChangeListeners.getListeners(); for (int i = 0; i < listeners.length; ++i) { final IFileServiceChangeListener l = (IFileServiceChangeListener) listeners[i]; SafeRunnable.run(new SafeRunnable() { public void run() { l.fileServiceChanged(newService); } }); } } } private void setErrorListeners(IEditorInput input) { // Project file if (input instanceof IFileEditorInput) { IFileEditorInput fileInput = (IFileEditorInput) input; IFile file = fileInput.getFile(); this._errorListener = new ProjectFileErrorListener(file); } // External file or Untitled file (not saved) else if (input instanceof IPathEditorInput || input instanceof IURIEditorInput || input instanceof NonExistingFileEditorInput) { IDocument doc = this.getDocumentProvider().getDocument(input); IAnnotationModel ann = this.getDocumentProvider().getAnnotationModel(input); this._errorListener = new ExternalFileErrorListener(ann, doc); } if (this._errorListener != null) { getFileContext().addErrorListener(this._errorListener); } } /** * updateFileInfo * * @param input * @param provider * @param document */ protected void updateFileInfo(IEditorInput input, DocumentSourceProvider provider, IDocument document) { if (isNewInput(input)) { // TODO: Actuate change // save reference to provider // cuInfo.sourceProvider = provider; IFileServiceFactory fileServiceFactory = this.getFileServiceFactory(); if (fileServiceFactory != null) { FileService context = fileServiceFactory.createFileService(provider, false); FileContextManager.add(provider.getSourceURI(), context); context.setRedrawRangeListener(this); } FileContextManager.connectSourceProvider(provider.getSourceURI(), provider); } } // private void updateAnnotationModel(UnifiedFileInfo cuInfo) // { // // Provide a simple annotation model if none has been provided // // fixes bug 156 - line numbers are not displayed for external files // // PC: not needed? cuInfo.fModel = new AnnotationModel(); // // if (cuInfo.fTextFileBuffer.getAnnotationModel() == null) // { // // when editing external files, there will not be an annotation model // attached, so we // // attach a simple one. // // This is necessary so that the source viewer's annotation bar (which // displays line // // numbers, etc) will be displayed // IUniformResource uniformResource = null; // // if (cuInfo.fElement instanceof IAdaptable) // { // uniformResource = (IUniformResource) ((IAdaptable) // cuInfo.fElement).getAdapter(IUniformResource.class); // } // // if (uniformResource != null) // { // cuInfo.fModel = new // UniformResourceMarkerAnnotationModel(uniformResource); // } // else // { // cuInfo.fModel = new AnnotationModel(); // } // } // else // { // cuInfo.fModel = cuInfo.fTextFileBuffer.getAnnotationModel(); // } // } private void updatePartitioner(DocumentSourceProvider provider, IDocument document, boolean isNewInput) { if (isNewInput) { UnifiedDocumentPartitioner partitioner = new UnifiedDocumentPartitioner(provider.getSourceURI()); // NOTE: The content types (and other stuff) will change when a user // does a Save As to another file type (i.e. JS to HTML) partitioner.setLegalContentTypes(this._baseContributor.getContentTypes()); partitioner.setPartitions(); if (document instanceof IDocumentExtension3) { // this should always be the once called ((IDocumentExtension3) document).setDocumentPartitioner(UnifiedConfiguration.UNIFIED_PARTITIONING, partitioner); } else { // document.setDocumentPartitioner(partitioner); throw new IllegalStateException(Messages.UnifiedEditor_DocumentMustBe); } } } /** * @see com.aptana.ide.editors.unified.IUnifiedEditor#getFileContext() */ public EditorFileContext getFileContext() { return this._fileContextWrapper; } /** * createLocalContributor * * @return IUnifiedEditorContributor */ protected abstract IUnifiedEditorContributor createLocalContributor(); /** * @see org.eclipse.ui.IWorkbenchPart#dispose() */ public void dispose() { if (this._isDisposing) { return; } this._isDisposing = true; if (this._lineStyleListener != null) { if (getViewer().getTextWidget() != null && getViewer().getTextWidget().isDisposed() == false) { getViewer().getTextWidget().removeLineStyleListener(this._lineStyleListener); } } if (this._textChangeListener != null) { if (getViewer().getTextWidget() != null && getViewer().getTextWidget().isDisposed() == false) { getViewer().getTextWidget().getContent().removeTextChangeListener(this._textChangeListener); } } unlinkPairMatcher(); if (this._errorListener != null) { getFileContext().removeErrorListener(this._errorListener); } if (this._partListener != null) { this.getEditorSite().getPage().removePartListener(this._partListener); this._partListener = null; } if (this._keyUpListener != null) { Display d = this.getSite().getShell().getDisplay(); d.removeFilter(SWT.KeyUp, this._keyUpListener); this._keyUpListener = null; } if (_verifyKeyListener != null) { ((SourceViewer) this._viewer).removeVerifyKeyListener(this._verifyKeyListener); this._verifyKeyListener = null; } if (this._bracketInserterManager != null) { ((SourceViewer) this._viewer).removeVerifyKeyListener(this._bracketInserterManager); this._bracketInserterManager = null; } SourceViewerConfiguration svc = this.getConfiguration(); if (svc instanceof UnifiedConfiguration) { ((UnifiedConfiguration) svc).dispose(); } if (outlinePage != null) { outlinePage.dispose(); outlinePage = null; } showWhitespace(false); if (this._whitespacePainter != null) { this._whitespacePainter.dispose(); } this._saveListeners.clear(); this._saveAsListeners.clear(); this._lineStyleListener = null; outlinePage = null; if (this._baseContributor != null) { this._baseContributor.setParentConfiguration(null); this._baseContributor = null; } this._errorListener = null; this._whitespacePainter = null; this._fileExplorerView = null; this._prefStore = null; this._contextAwareness = null; this.disposeDocumentProvider(); if (this._fileContextWrapper != null) { this._fileContextWrapper.deactivateForEditing(); // The following was commented out since: // it disconnects regardless if another file is using the file // context (two editors around same document) // Looking at this.disposeDocumentProvider() shows the proper checks // before disconnecting and so the // following line was redundant as well since the document provider // handles it correctly and so calling it // here will just ruin any other open editors using the file context // being disposed // fileContextWrapper.disconnectSourceProvider(null); } if (this._extendedStylesEnabled) { uninstallTextOccurrenceHighlightSupport(); } if (this._caretImage != null) { this._caretImage.dispose(); this._caretImage = null; } super.dispose(); } /** * getFileServiceFactory * * @return IFileServiceFactory */ public abstract IFileServiceFactory getFileServiceFactory(); /** * @see org.eclipse.core.runtime.IAdaptable#getAdapter(java.lang.Class) */ public Object getAdapter(Class adapter) { // Context is just plugin ID + name of class. Matches contexts.xml file if (adapter == IContextProvider.class) { return LexemeUIHelp.getHelpContextProvider(this, getFileContext()); } // Return our adapter for the content outline page if (IContentOutlinePage.class.equals(adapter)) { return getOutlinePage(); } return super.getAdapter(adapter); } /** * @see com.aptana.ide.editors.unified.IUnifiedEditor#getViewer() */ public ISourceViewer getViewer() { return this.getSourceViewer(); } /** * // exposing this as public for scripting access * * @see com.aptana.ide.editors.unified.IUnifiedEditor#getConfiguration() */ public SourceViewerConfiguration getConfiguration() { return this.getSourceViewerConfiguration(); } /** * @see com.aptana.ide.editors.unified.IUnifiedEditor#getContextAwareness() */ public IContextAwareness getContextAwareness() { // For editors that don't have/need a ContextAwareness service if (this._contextAwareness == null) { this._contextAwareness = new IContextAwareness() { public void update(IFileService fileService) { } public ContextItem getFileContext() { return new ContextItem(); } }; } return this._contextAwareness; } /** * Returns the content outline page adapter * * @return Returns the content outline page adapter. */ public UnifiedOutlinePage getOutlinePage() { if (this.outlinePage == null || (this.outlinePage.getControl() != null && this.outlinePage.getControl().isDisposed())) { this.outlinePage = new UnifiedOutlinePage(this); } return outlinePage; } /** * {@inheritDoc} */ public UnifiedQuickOutlinePage createQuickOutlinePage() { return new UnifiedQuickOutlinePage(this); } /** * @see org.eclipse.ui.texteditor.AbstractTextEditor#handlePreferenceStoreChanged(org.eclipse.jface.util.PropertyChangeEvent) */ protected void handlePreferenceStoreChanged(PropertyChangeEvent event) { try { ISourceViewer sourceViewer = getSourceViewer(); if (sourceViewer == null) { return; } String property = event.getProperty(); if (IPreferenceConstants.COLORIZER_MAXCOLUMNS.equals(property)) { this._maxColorizingColumns = getPreferenceStore().getInt(IPreferenceConstants.COLORIZER_MAXCOLUMNS); } else if (AbstractDecoratedTextEditorPreferenceConstants.EDITOR_TAB_WIDTH.equals(property) || IPreferenceConstants.INSERT_SPACES_FOR_TABS.equals(property)) { IPreferenceStore store = getPreferenceStore(); if (store == null) { throw new Exception(Messages.UnifiedEditor_UnableToRetrievePreferenceStore); } int prefs = store.getInt(AbstractDecoratedTextEditorPreferenceConstants.EDITOR_TAB_WIDTH); SourceViewerConfiguration sv = getSourceViewerConfiguration(); boolean tabsOrSpaces = store.getBoolean(IPreferenceConstants.INSERT_SPACES_FOR_TABS); if (sv != null && sv instanceof UnifiedConfiguration) { UnifiedConfiguration uc = (UnifiedConfiguration) sv; uc.setTabWidth(prefs, tabsOrSpaces, sourceViewer); } else { IdeLog.logInfo(UnifiedEditorsPlugin.getDefault(), Messages.UnifiedEditor_ErrorUpdateTabWidth); } } else if (IPreferenceConstants.COLORIZER_TEXT_HIGHLIGHT_ENABLED.equals(property)) { boolean textHighlightEnabled = getPreferenceStore() .getBoolean(IPreferenceConstants.COLORIZER_TEXT_HIGHLIGHT_ENABLED); if (textHighlightEnabled) { installTextOccurrenceHighlightSupport(); } else { uninstallTextOccurrenceHighlightSupport(); // remove highlights } } else if (property != null && property.startsWith(IPreferenceConstants.EDITOR_FOLDING_ENABLED)) { String language = property.substring(IPreferenceConstants.EDITOR_FOLDING_ENABLED.length() + 1, property.length()); if (this.getViewer() != null && this.getViewer() instanceof ProjectionViewer) { ProjectionViewer viewer = (ProjectionViewer) this.getViewer(); if (UnifiedEditorsPlugin.getDefault().getPreferenceStore().getBoolean(property)) { if (this.getConfiguration() instanceof UnifiedConfiguration) { UnifiedReconcilingStrategy reconciler = ((UnifiedConfiguration) this.getConfiguration()) .getStrategy(); if (reconciler != null) { reconciler.initialReconcile(); } } } else if (viewer.getProjectionAnnotationModel() != null) { List<Annotation> mods = new ArrayList<Annotation>(); Iterator annotationIterator = viewer.getProjectionAnnotationModel().getAnnotationIterator(); if (annotationIterator != null) { while (annotationIterator.hasNext()) { Annotation annotation = (Annotation) annotationIterator.next(); if (annotation instanceof LanguageProjectAnnotation) { LanguageProjectAnnotation lpa = (LanguageProjectAnnotation) annotation; if (language.equals(lpa.getLanguage())) { lpa.markDeleted(true); mods.add(lpa); } } } viewer.getProjectionAnnotationModel() .modifyAnnotations(mods.toArray(new Annotation[mods.size()]), null, null); } } } } // This updates the folding icons when the colorization changes else if (property != null && property.startsWith("Colorization")) //$NON-NLS-1$ { syncFoldingPreferenceStore(); if (this.getConfiguration() instanceof UnifiedConfiguration) { UnifiedReconcilingStrategy reconciler = ((UnifiedConfiguration) this.getConfiguration()) .getStrategy(); ProjectionAnnotationModel currentModel = getProjectionAnnotationModel(); if (reconciler != null && currentModel != null) { currentModel.removeAllAnnotations(); reconciler.initialReconcile(); } } } // boolean wordWrap = // getPreferenceStore().getBoolean(IPreferenceConstants.ENABLE_WORD_WRAP); // this.getViewer().getTextWidget().setWordWrap(wordWrap); // this can be null (? either when closing or when sourceViewer is // UndefinedViewer) StyledText viewer = sourceViewer.getTextWidget(); if (viewer != null) { sourceViewer.getTextWidget().redraw(); } } catch (Exception ex) { IdeLog.logError(UnifiedEditorsPlugin.getDefault(), Messages.UnifiedEditor_ErrorHandlingPreferenceChange, ex); } finally { super.handlePreferenceStoreChanged(event); // Editor options must be changed after super is called so that the // Eclipse editor prefs don't affect the // Aptana color prefs if the Eclipse prefs are overriden by the // language editor // Refresh editor options in case changed // Always run in UI thread! Display display = Display.getCurrent(); if (display == null) display = Display.getDefault(); display.asyncExec(new Runnable() { public void run() { setEditorOptions(); } }); } } /** * Gets the projection annotation model ( folding annotations stored here) * * @return - model or null if the viewer or model is null */ private ProjectionAnnotationModel getProjectionAnnotationModel() { ProjectionViewer viewer = (ProjectionViewer) getSourceViewer(); if (viewer != null) { return viewer.getProjectionAnnotationModel(); } return null; } /** * @see org.eclipse.ui.texteditor.AbstractTextEditor#handleCursorPositionChanged() */ protected void handleCursorPositionChanged() { // update current lexeme and index based on new cursor position StyledText styledText = getSourceViewer().getTextWidget(); int offset = styledText.getCaretOffset(); try { if (getSourceViewer() instanceof ITextViewerExtension5) { offset = ((ITextViewerExtension5) getSourceViewer()).widgetOffset2ModelOffset(offset); } } catch (Exception e) { // If can't convert offset then use caret offset uncoverted } catch (Error e) { // If can't convert offset then use caret offset uncoverted } IFileService fs = this.getFileContext(); if (fs != null) { // RD: must always account for whitespace in lexemelist LexemeList list = fs.getLexemeList(); if (list == null) { return; } int index = list.getLexemeFloorIndex(offset); if (index == -1) { index = list.getLexemeCeilingIndex(offset); if (index == -1) { return; } } Lexeme l = list.get(index); if (l != null) { IFileLanguageService ls = fs.getLanguageService(l.getLanguage()); if (ls != null && ls.getOffsetMapper() != null) { ls.getOffsetMapper().calculateCurrentLexeme(offset); } } } super.handleCursorPositionChanged(); } /** * Retrieves the current IEditorPart * * @return The current EditorPart */ public IEditorPart getEditor() { return this; } /** * @see org.eclipse.ui.texteditor.AbstractDecoratedTextEditor#initializeKeyBindingScopes() */ protected void initializeKeyBindingScopes() { setKeyBindingScopes(new String[] { "com.aptana.ide.editors.UnifiedEditorsScope" }); //$NON-NLS-1$ } /** * @see org.eclipse.ui.texteditor.AbstractDecoratedTextEditor#configureSourceViewerDecorationSupport(org.eclipse.ui.texteditor.SourceViewerDecorationSupport) */ protected void configureSourceViewerDecorationSupport(SourceViewerDecorationSupport support) { // support.setCharacterPairMatcher(bracketMatcher); // support.setMatchingCharacterPainterPreferenceKeys("matchBrackets", // "matchBracketsColor"); super.configureSourceViewerDecorationSupport(support); } // public void addBracketMatchListener(IUnifiedBracketMatcherListener obj) // { // bracketMatcher.addBracketMatchListener(obj); // } // // public void removeBracketMatchListener(IUnifiedBracketMatcherListener // obj) // { // bracketMatcher.removeBracketMatchListener(obj); // } /** * */ protected void onSaveComplete() { ISaveEvent[] listeners = null; synchronized (this._saveListeners) { listeners = this._saveListeners.toArray(new ISaveEvent[this._saveListeners.size()]); } for (int i = 0; i < listeners.length; i++) { ISaveEvent element = listeners[i]; element.onSave(this.getEditor()); } } /** * @see com.aptana.ide.editors.untitled.BaseTextEditor#onSaveAsComplete(java.io.File, java.io.File) */ protected void onSaveAsComplete(File oldFile, File newFile) { ISaveAsEvent[] listeners = null; synchronized (this._saveAsListeners) { listeners = this._saveAsListeners.toArray(new ISaveAsEvent[this._saveAsListeners.size()]); } for (int i = 0; i < listeners.length; i++) { ISaveAsEvent element = listeners[i]; element.onSaveAs(this.getEditor(), oldFile, newFile); } updateFileExplorer(); } private void updateFileExplorer() { if (this._fileExplorerView == null) { this._fileExplorerView = (CommonNavigator) CoreUIUtils .getViewInternal("com.aptana.ide.ui.io.fileExplorerView", null); //$NON-NLS-1$ } if (this._fileExplorerView == null) { return; } Display.getDefault().asyncExec(new Runnable() { public void run() { _fileExplorerView.getCommonViewer().refresh(); } }); } /** * @param listener */ public void addSaveListener(ISaveEvent listener) { this._saveListeners.add(listener); } /** * @param listener */ public void removeSaveListener(ISaveEvent listener) { if (this._saveListeners.contains(listener)) { this._saveListeners.remove(listener); } } /** * @param listener */ public void addSaveAsListener(ISaveAsEvent listener) { this._saveAsListeners.add(listener); } /** * @param listener */ public void removeSaveAsListener(ISaveAsEvent listener) { if (this._saveAsListeners.contains(listener)) { this._saveAsListeners.remove(listener); } } void showPairError() { MessageDialog.openInformation(null, Messages.UnifiedEditor_MatchingPairError, Messages.UnifiedEditor_MatchingPairErrorMessage); } /** * isHasKeyBeenPressed * * @return boolean */ public boolean isHasKeyBeenPressed() { return this._hasKeyBeenPressed; } /** * setHasKeyBeenPressed * * @param hasKeyBeenPressed */ public void setHasKeyBeenPressed(boolean hasKeyBeenPressed) { this._hasKeyBeenPressed = hasKeyBeenPressed; } /** * @see org.eclipse.ui.editors.text.TextEditor#createActions() */ protected void createActions() { super.createActions(); // Add bookmark action final BookmarkRulerAction bra = new BookmarkRulerAction(); Action bookmarkAction = new Action() { public void run() { bra.run(this); } }; bra.setActiveEditor(bookmarkAction, this); setAction(ADD_BOOKMARK, bookmarkAction); // Add task action final TaskRulerAction tra = new TaskRulerAction(); Action taskAction = new Action() { public void run() { tra.run(this); } }; tra.setActiveEditor(taskAction, this); setAction(ADD_TASK, taskAction); Action action = new ContentAssistAction(UnifiedMessages.getResourceBundle(), "ContentAssistProposal.", //$NON-NLS-1$ this); String id = ITextEditorActionDefinitionIds.CONTENT_ASSIST_PROPOSALS; action.setActionDefinitionId(id); setAction("ContentAssistProposal", action); //$NON-NLS-1$ markAsStateDependentAction("ContentAssistProposal", true); //$NON-NLS-1$ action = new GotoMatchingBracketAction(this); action.setActionDefinitionId(UnifiedActionContributor.GOTO_MATCHING_BRACKET_ID); setAction(GotoMatchingBracketAction.GOTO_MATCHING_BRACKET, action); Action actionContext = new TextOperationAction(UnifiedMessages.getResourceBundle(), "ContentAssistContextInformation.", this, ISourceViewer.CONTENTASSIST_CONTEXT_INFORMATION); //$NON-NLS-1$ actionContext.setActionDefinitionId(ITextEditorActionDefinitionIds.CONTENT_ASSIST_CONTEXT_INFORMATION); setAction("ContentAssistContextInformation", actionContext); //$NON-NLS-1$ markAsStateDependentAction("ContentAssistContextInformation", true); //$NON-NLS-1$ // PlatformUI.getWorkbench().getHelpSystem().setHelp(action, // IJavaHelpContextIds.PARAMETER_HINTS_ACTION); FoldingExtensionPointLoader.createFoldingActions(this); _formatAction = new CodeFormatAction(); } /** * @see com.aptana.ide.editors.unified.IUnifiedEditor#getBaseContributor() */ public IUnifiedEditorContributor getBaseContributor() { return this._baseContributor; } /** * isNewInput * * @param input * @return boolean */ protected boolean isNewInput(IEditorInput input) { return true; } /** * @param event */ public void selectionChanged(SelectionChangedEvent event) { ISourceViewer sourceViewer = getSourceViewer(); if (sourceViewer == null) { return; } StyledText styledText = sourceViewer.getTextWidget(); if (styledText == null) { return; } int offset = -1; // If there is a selection, we consider selection range instead of caret // position. Point selectionRange = sourceViewer.getSelectedRange(); if (selectionRange.x > -1 && selectionRange.y > 0) { offset = selectionRange.x; } if (offset < 0) { if (sourceViewer instanceof ITextViewerExtension5) { ITextViewerExtension5 extension = (ITextViewerExtension5) sourceViewer; offset = extension.widgetOffset2ModelOffset(styledText.getCaretOffset()); } else { offset = sourceViewer.getVisibleRegion().getOffset(); offset += styledText.getCaretOffset(); } } if (offset < 0) { return; } LexemeList lexemeList = getLexemeList(); if (lexemeList == null) { IdeLog.logError(UnifiedEditorsPlugin.getDefault(), Messages.UnifiedEditor_LexemeListIsNull); return; } Lexeme selectedLexeme = lexemeList.getLexemeFromOffset(offset); if (selectedLexeme == null) { return; } if (!canMarkOccurrences(selectedLexeme)) { return; } String selectedText = selectedLexeme.getText(); if (selectedText == null || selectedText.length() == 0) { return; } markOccurences(lexemeList, selectedLexeme); Job job = new UIJob("Redraw") { @Override public IStatus runInUIThread(IProgressMonitor monitor) { // TODO: Measure time to see if a precisely calculated redraw area yields significant savings getSourceViewer().getTextWidget().redraw(); return Status.OK_STATUS; } }; job.setPriority(Job.INTERACTIVE); job.setSystem(true); job.schedule(); } /** * Mark matching lexemes in the lexeme list * * @param lexemeList * @param selectedLexeme */ protected void markOccurences(LexemeList lexemeList, Lexeme selectedLexeme) { String selectedText = selectedLexeme.getText(); IAnnotationModel model = getDocumentProvider().getAnnotationModel(getEditorInput()); Map<Annotation, Position> toAdd = new HashMap<Annotation, Position>(); for (int i = 0; i < lexemeList.size(); i++) { Lexeme lexeme = lexemeList.get(i); if (lexeme != null) { if (lexeme.isHighlighted()) { lexeme.setHighlighted(false); } if (lexeme.length == selectedLexeme.length && selectedText.equals(lexeme.getText())) { lexeme.setHighlighted(true); if (model != null) { Position pos = new Position(lexeme.offset, lexeme.length); Annotation occurence = new Annotation("com.aptana.ide.annotation.occurence", false, lexeme //$NON-NLS-1$ .getText()); toAdd.put(occurence, pos); } } } } synchronized (getLockObject(model)) { if (model instanceof IAnnotationModelExtension) { ((IAnnotationModelExtension) model).replaceAnnotations(fOccurrenceAnnotations, toAdd); } else { removeOccurrenceAnnotations(); Iterator iter = toAdd.entrySet().iterator(); while (iter.hasNext()) { Map.Entry mapEntry = (Map.Entry) iter.next(); model.addAnnotation((Annotation) mapEntry.getKey(), (Position) mapEntry.getValue()); } } fOccurrenceAnnotations = (Annotation[]) toAdd.keySet().toArray(new Annotation[toAdd.keySet().size()]); } } /** * Gets the lexeme list for this editor * * @return - lexeme list */ protected LexemeList getLexemeList() { EditorFileContext fileContext = getFileContext(); // wrapper could be non-null, but interior is. if (fileContext == null || fileContext.getFileContext() == null) { return null; } IParseState parseState = fileContext.getParseState(); if (parseState == null) { return null; } LexemeList lexemeList = parseState.getLexemeList(); return lexemeList; } /** * Returns language MIME type for offset position * * @param offset * @return - language */ public String getLanguageAtOffset(int offset) { LexemeList lexemeList = getLexemeList(); if (lexemeList == null) { return null; } Lexeme lexemeAtOffset = lexemeList.getCeilingLexeme(offset); if (lexemeAtOffset == null) { return null; } return lexemeAtOffset.getLanguage(); } private void removeOccurrenceAnnotations() { IDocumentProvider documentProvider = getDocumentProvider(); if (documentProvider == null) return; IAnnotationModel annotationModel = documentProvider.getAnnotationModel(getEditorInput()); if (annotationModel == null || fOccurrenceAnnotations == null) return; synchronized (getLockObject(annotationModel)) { if (annotationModel instanceof IAnnotationModelExtension) { ((IAnnotationModelExtension) annotationModel).replaceAnnotations(fOccurrenceAnnotations, null); } else { for (int i = 0, length = fOccurrenceAnnotations.length; i < length; i++) annotationModel.removeAnnotation(fOccurrenceAnnotations[i]); } fOccurrenceAnnotations = null; } } /** * Returns the lock object for the given annotation model. * * @param annotationModel the annotation model * @return the annotation model's lock object * @since 3.0 */ private Object getLockObject(IAnnotationModel annotationModel) { if (annotationModel instanceof ISynchronizable) { Object lock = ((ISynchronizable) annotationModel).getLockObject(); if (lock != null) return lock; } return annotationModel; } /** * * */ public void removeMarkedOccurrences() { removeOccurrenceAnnotations(); LexemeList lexemeList = getLexemeList(); if (lexemeList == null) { return; } for (int i = 0; i < lexemeList.size(); i++) { Lexeme lexeme = lexemeList.get(i); if (lexeme != null && lexeme.isHighlighted()) { lexeme.setHighlighted(false); } } } /** * @param lexeme * @return - true if occurrence should be marked */ public boolean canMarkOccurrences(Lexeme lexeme) { if (lexeme.getCategoryIndex() == TokenCategories.WHITESPACE) { return false; } if (lexeme.getCategoryIndex() == TokenCategories.PUNCTUATOR) { return false; } return true; } /** * Creates the docment provider * * @return IDocumentProvider */ public abstract IDocumentProvider createDocumentProvider(); /** * Is code assist available for auto-activation * * @return - true if activating, false otherwise */ public boolean autoActivateCodeAssist() { return autoActivateCodeAssist; } public void gotoMatchingBracket() { ISourceViewer sourceViewer = getSourceViewer(); IDocument document = sourceViewer.getDocument(); if (document == null) return; Point selectedPoint = sourceViewer.getSelectedRange(); IRegion selection = new Region(selectedPoint.x, selectedPoint.y); int selectionLength = Math.abs(selection.getLength()); if (selectionLength > 1) { setStatusLineErrorMessage( com.aptana.ide.editors.unified.actions.Messages.GotoMatchingBracket_error_invalidSelection); sourceViewer.getTextWidget().getDisplay().beep(); return; } int sourceCaretOffset = selection.getOffset() + selection.getLength(); PairMatch pair = getPairMatch(sourceCaretOffset); if (pair == null) { setStatusLineErrorMessage( com.aptana.ide.editors.unified.actions.Messages.GotoMatchingBracket_error_noMatchingBracket); sourceViewer.getTextWidget().getDisplay().beep(); return; } int start = 0; int end = 0; if (sourceCaretOffset <= pair.beginEnd && sourceCaretOffset >= pair.beginStart) { start = pair.endStart; end = pair.endEnd; } else { start = pair.beginStart; end = pair.beginEnd; } int length = end - start; sourceViewer.setSelectedRange(start, length); sourceViewer.revealRange(start, length); } }