| /*=============================================================================# |
| # Copyright (c) 2005, 2020 Stephan Wahlbrink and others. |
| # |
| # This program and the accompanying materials are made available under the |
| # terms of the Eclipse Public License 2.0 which is available at |
| # https://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0 |
| # which is available at https://www.apache.org/licenses/LICENSE-2.0. |
| # |
| # SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 |
| # |
| # Contributors: |
| # Stephan Wahlbrink <sw@wahlbrink.eu> - initial API and implementation |
| #=============================================================================*/ |
| |
| package org.eclipse.statet.r.ui.sourceediting; |
| |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.eclipse.core.runtime.IAdaptable; |
| import org.eclipse.jface.preference.IPreferenceStore; |
| import org.eclipse.jface.text.IAutoEditStrategy; |
| import org.eclipse.jface.text.ITextDoubleClickStrategy; |
| import org.eclipse.jface.text.ITextHover; |
| import org.eclipse.jface.text.information.IInformationProvider; |
| import org.eclipse.jface.text.reconciler.IReconciler; |
| import org.eclipse.jface.text.reconciler.IReconcilingStrategy; |
| import org.eclipse.jface.text.rules.ITokenScanner; |
| import org.eclipse.jface.text.source.ISourceViewer; |
| import org.eclipse.ui.editors.text.EditorsUI; |
| import org.eclipse.ui.texteditor.spelling.SpellingReconcileStrategy; |
| import org.eclipse.ui.texteditor.spelling.SpellingService; |
| |
| import org.eclipse.statet.ecommons.preferences.core.util.PreferenceUtils; |
| import org.eclipse.statet.ecommons.text.ICharPairMatcher; |
| import org.eclipse.statet.ecommons.text.IIndentSettings; |
| import org.eclipse.statet.ecommons.text.core.sections.DocContentSections; |
| import org.eclipse.statet.ecommons.text.ui.presentation.SingleTokenScanner; |
| import org.eclipse.statet.ecommons.text.ui.settings.TextStyleManager; |
| import org.eclipse.statet.ecommons.ui.ColorManager; |
| import org.eclipse.statet.ecommons.ui.ISettingsChangedHandler; |
| |
| import org.eclipse.statet.base.ext.ui.text.CommentScanner; |
| import org.eclipse.statet.internal.r.ui.RUIPlugin; |
| import org.eclipse.statet.internal.r.ui.editors.REditor; |
| import org.eclipse.statet.internal.r.ui.editors.REditorInformationProvider; |
| import org.eclipse.statet.internal.r.ui.editors.REditorTextHover; |
| import org.eclipse.statet.internal.r.ui.editors.RQuickOutlineInformationProvider; |
| import org.eclipse.statet.ltk.ui.LTKUIPreferences; |
| import org.eclipse.statet.ltk.ui.sourceediting.EcoReconciler2; |
| import org.eclipse.statet.ltk.ui.sourceediting.EditorInformationProvider; |
| import org.eclipse.statet.ltk.ui.sourceediting.ISourceEditorAddon; |
| import org.eclipse.statet.ltk.ui.sourceediting.SourceEditor1; |
| import org.eclipse.statet.ltk.ui.sourceediting.SourceEditorViewer; |
| import org.eclipse.statet.ltk.ui.sourceediting.SourceEditorViewerConfiguration; |
| import org.eclipse.statet.ltk.ui.sourceediting.SourceUnitReconcilingStrategy; |
| import org.eclipse.statet.ltk.ui.sourceediting.assist.ContentAssist; |
| import org.eclipse.statet.ltk.ui.sourceediting.assist.ContentAssistComputerRegistry; |
| import org.eclipse.statet.ltk.ui.sourceediting.assist.ContentAssistProcessor; |
| import org.eclipse.statet.ltk.ui.sourceediting.assist.InfoHoverDescriptor; |
| import org.eclipse.statet.ltk.ui.sourceediting.assist.InfoHoverRegistry; |
| import org.eclipse.statet.ltk.ui.sourceediting.assist.QuickAssistProcessor; |
| import org.eclipse.statet.nico.ui.console.ConsolePageEditor; |
| import org.eclipse.statet.r.core.RCore; |
| import org.eclipse.statet.r.core.RCoreAccess; |
| import org.eclipse.statet.r.core.source.RDocumentConstants; |
| import org.eclipse.statet.r.core.source.RDocumentContentInfo; |
| import org.eclipse.statet.r.core.source.RHeuristicTokenScanner; |
| import org.eclipse.statet.r.ui.editors.IRSourceEditor; |
| import org.eclipse.statet.r.ui.editors.REditorOptions; |
| import org.eclipse.statet.r.ui.text.r.IRTextTokens; |
| import org.eclipse.statet.r.ui.text.r.RBracketPairMatcher; |
| import org.eclipse.statet.r.ui.text.r.RDefaultTextStyleScanner; |
| import org.eclipse.statet.r.ui.text.r.RDoubleClickStrategy; |
| import org.eclipse.statet.r.ui.text.r.RInfixOperatorScanner; |
| import org.eclipse.statet.r.ui.text.r.RoxygenScanner; |
| |
| |
| /** |
| * Default Configuration for SourceViewer of R code. |
| */ |
| public class RSourceViewerConfiguration extends SourceEditorViewerConfiguration { |
| |
| |
| private static final String[] CONTENT_TYPES= RDocumentConstants.R_CONTENT_TYPES.toArray( |
| new String[RDocumentConstants.R_CONTENT_TYPES.size()] ); |
| |
| |
| private RDoubleClickStrategy fDoubleClickStrategy; |
| private RAutoEditStrategy fAutoEditStrategy; |
| |
| private RCoreAccess fRCoreAccess; |
| |
| |
| public RSourceViewerConfiguration(final int flags, |
| final IPreferenceStore store, final ColorManager colorManager) { |
| this(RDocumentContentInfo.INSTANCE, flags, null, null, store, null); |
| } |
| |
| public RSourceViewerConfiguration(final DocContentSections documentContentInfo, final int flags, |
| final IRSourceEditor sourceEditor, |
| final RCoreAccess access, |
| final IPreferenceStore preferenceStore, final TextStyleManager textStyles) { |
| super(documentContentInfo, flags, sourceEditor); |
| setCoreAccess(access); |
| setup((preferenceStore != null) ? preferenceStore : RUIPlugin.getInstance().getEditorPreferenceStore(), |
| LTKUIPreferences.getEditorDecorationPreferences(), |
| LTKUIPreferences.getAssistPreferences() ); |
| setTextStyles(textStyles); |
| } |
| |
| protected void setCoreAccess(final RCoreAccess access) { |
| this.fRCoreAccess = (access != null) ? access : RCore.getWorkbenchAccess(); |
| } |
| |
| |
| @Override |
| protected IRSourceEditor getSourceEditor() { |
| return (IRSourceEditor) super.getSourceEditor(); |
| } |
| |
| |
| @Override |
| protected void initTextStyles() { |
| setTextStyles(RUIPlugin.getInstance().getRTextStyles()); |
| } |
| |
| @Override |
| protected void initScanners() { |
| final TextStyleManager textStyles= getTextStyles(); |
| |
| addScanner(RDocumentConstants.R_DEFAULT_CONTENT_TYPE, |
| new RDefaultTextStyleScanner(textStyles) ); |
| addScanner(RDocumentConstants.R_INFIX_OPERATOR_CONTENT_TYPE, |
| new RInfixOperatorScanner(textStyles) ); |
| addScanner(RDocumentConstants.R_STRING_CONTENT_TYPE, |
| new SingleTokenScanner(textStyles, IRTextTokens.STRING_KEY) ); |
| addScanner(RDocumentConstants.R_COMMENT_CONTENT_TYPE, |
| new CommentScanner(textStyles, IRTextTokens.COMMENT_KEY, IRTextTokens.TASK_TAG_KEY, |
| this.fRCoreAccess.getPrefs()) ); |
| addScanner(RDocumentConstants.R_ROXYGEN_CONTENT_TYPE, |
| new RoxygenScanner(textStyles, this.fRCoreAccess.getPrefs()) ); |
| } |
| |
| @Override |
| protected ITokenScanner getScanner(String contentType) { |
| if (contentType == RDocumentConstants.R_QUOTED_SYMBOL_CONTENT_TYPE) { |
| contentType= RDocumentConstants.R_STRING_CONTENT_TYPE; |
| } |
| return super.getScanner(contentType); |
| } |
| |
| |
| public RCoreAccess getRCoreAccess() { |
| return this.fRCoreAccess; |
| } |
| |
| @Override |
| public List<ISourceEditorAddon> getAddOns() { |
| final List<ISourceEditorAddon> addons = super.getAddOns(); |
| if (this.fAutoEditStrategy != null) { |
| addons.add(this.fAutoEditStrategy); |
| } |
| return addons; |
| } |
| |
| @Override |
| public void handleSettingsChanged(final Set<String> groupIds, final Map<String, Object> options) { |
| options.put(ISettingsChangedHandler.PREFERENCEACCESS_KEY, this.fRCoreAccess.getPrefs()); |
| super.handleSettingsChanged(groupIds, options); |
| } |
| |
| |
| @Override |
| public String[] getConfiguredContentTypes(final ISourceViewer sourceViewer) { |
| return CONTENT_TYPES; |
| } |
| |
| |
| @Override |
| public ICharPairMatcher createPairMatcher() { |
| return new RBracketPairMatcher( |
| RHeuristicTokenScanner.create(getDocumentContentInfo()) ); |
| } |
| |
| @Override |
| public ITextDoubleClickStrategy getDoubleClickStrategy(final ISourceViewer sourceViewer, final String contentType) { |
| if (this.fDoubleClickStrategy == null) { |
| this.fDoubleClickStrategy= new RDoubleClickStrategy( |
| RHeuristicTokenScanner.create(getDocumentContentInfo()) ); |
| } |
| return this.fDoubleClickStrategy; |
| } |
| |
| @Override |
| public String[] getDefaultPrefixes(final ISourceViewer sourceViewer, final String contentType) { |
| return new String[] { "#", "" }; //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| |
| @Override |
| protected IIndentSettings getIndentSettings() { |
| return this.fRCoreAccess.getRCodeStyle(); |
| } |
| |
| |
| @Override |
| public boolean isSmartInsertSupported() { |
| return true; |
| } |
| |
| @Override |
| public boolean isSmartInsertByDefault() { |
| return PreferenceUtils.getInstancePrefs().getPreferenceValue( |
| REditorOptions.SMARTINSERT_BYDEFAULT_ENABLED_PREF ); |
| } |
| |
| |
| @Override |
| public IAutoEditStrategy[] getAutoEditStrategies(final ISourceViewer sourceViewer, final String contentType) { |
| if (getSourceEditor() == null) { |
| return super.getAutoEditStrategies(sourceViewer, contentType); |
| } |
| if (this.fAutoEditStrategy == null) { |
| this.fAutoEditStrategy = createRAutoEditStrategy(); |
| } |
| return new IAutoEditStrategy[] { this.fAutoEditStrategy }; |
| } |
| |
| protected RAutoEditStrategy createRAutoEditStrategy() { |
| return new RAutoEditStrategy(this.fRCoreAccess, getSourceEditor()); |
| } |
| |
| |
| @Override |
| public IReconciler getReconciler(final ISourceViewer sourceViewer) { |
| final IRSourceEditor editor= getSourceEditor(); |
| if (!(editor instanceof SourceEditor1 || editor instanceof ConsolePageEditor)) { |
| return null; |
| } |
| final EcoReconciler2 reconciler = new EcoReconciler2(editor); |
| reconciler.setDelay(500); |
| reconciler.addReconcilingStrategy(new SourceUnitReconcilingStrategy()); |
| |
| if (editor instanceof REditor) { |
| final IReconcilingStrategy spellingStrategy = getSpellingStrategy(sourceViewer); |
| if (spellingStrategy != null) { |
| reconciler.addReconcilingStrategy(spellingStrategy); |
| } |
| } |
| |
| return reconciler; |
| } |
| |
| protected IReconcilingStrategy getSpellingStrategy(final ISourceViewer sourceViewer) { |
| if (!(this.fRCoreAccess.getPrefs().getPreferenceValue(REditorOptions.PREF_SPELLCHECKING_ENABLED) |
| && this.fPreferenceStore.getBoolean(SpellingService.PREFERENCE_SPELLING_ENABLED)) ) { |
| return null; |
| } |
| final SpellingService spellingService = EditorsUI.getSpellingService(); |
| if (spellingService.getActiveSpellingEngineDescriptor(this.fPreferenceStore) == null) { |
| return null; |
| } |
| return new SpellingReconcileStrategy(sourceViewer, spellingService); |
| } |
| |
| |
| @Override |
| public void initContentAssist(final ContentAssist assistant) { |
| final ContentAssistComputerRegistry registry = RUIPlugin.getInstance().getREditorContentAssistRegistry(); |
| final IRSourceEditor editor= getSourceEditor(); |
| |
| final ContentAssistProcessor codeProcessor = new RContentAssistProcessor(assistant, |
| RDocumentConstants.R_DEFAULT_CONTENT_TYPE, registry, editor); |
| codeProcessor.setCompletionProposalAutoActivationCharacters(new char[] { '$', '@' }); |
| codeProcessor.setContextInformationAutoActivationCharacters(new char[] { ',' }); |
| assistant.setContentAssistProcessor(codeProcessor, RDocumentConstants.R_DEFAULT_CONTENT_TYPE); |
| |
| final ContentAssistProcessor symbolProcessor = new RContentAssistProcessor(assistant, |
| RDocumentConstants.R_QUOTED_SYMBOL_CONTENT_TYPE, registry, editor); |
| assistant.setContentAssistProcessor(symbolProcessor, RDocumentConstants.R_QUOTED_SYMBOL_CONTENT_TYPE); |
| |
| final ContentAssistProcessor stringProcessor = new RContentAssistProcessor(assistant, |
| RDocumentConstants.R_STRING_CONTENT_TYPE, registry, editor); |
| assistant.setContentAssistProcessor(stringProcessor, RDocumentConstants.R_STRING_CONTENT_TYPE); |
| |
| final ContentAssistProcessor commentProcessor = new RContentAssistProcessor(assistant, |
| RDocumentConstants.R_COMMENT_CONTENT_TYPE, registry, editor); |
| assistant.setContentAssistProcessor(commentProcessor, RDocumentConstants.R_COMMENT_CONTENT_TYPE); |
| |
| final ContentAssistProcessor roxygenProcessor = new RContentAssistProcessor(assistant, |
| RDocumentConstants.R_ROXYGEN_CONTENT_TYPE, registry, editor); |
| roxygenProcessor.setCompletionProposalAutoActivationCharacters(new char[] { '@', '\\' }); |
| assistant.setContentAssistProcessor(roxygenProcessor, RDocumentConstants.R_ROXYGEN_CONTENT_TYPE); |
| } |
| |
| @Override |
| protected QuickAssistProcessor createQuickAssistProcessor() { |
| final IRSourceEditor editor= getSourceEditor(); |
| if (editor != null) { |
| return new RQuickAssistProcessor(editor); |
| } |
| return null; |
| } |
| |
| @Override |
| protected boolean isInfoHoverDefaultContentType(final String contentType) { |
| return RDocumentConstants.R_CODE_CONTENT_CONSTRAINT.matches(contentType); |
| } |
| |
| @Override |
| protected InfoHoverRegistry getInfoHoverRegistry() { |
| return RUIPlugin.getInstance().getREditorInfoHoverRegistry(); |
| } |
| |
| @Override |
| protected ITextHover createInfoHover(final InfoHoverDescriptor descriptor) { |
| final IRSourceEditor editor= getSourceEditor(); |
| if (editor != null) { |
| return new REditorTextHover(editor, descriptor, this); |
| } |
| return null; |
| } |
| |
| @Override |
| protected EditorInformationProvider getInformationProvider() { |
| final IRSourceEditor editor= getSourceEditor(); |
| if (editor != null) { |
| return new REditorInformationProvider(editor); |
| } |
| return null; |
| } |
| |
| |
| @Override |
| protected void collectHyperlinkDetectorTargets(final Map<String, IAdaptable> targets, |
| final ISourceViewer sourceViewer) { |
| targets.put("org.eclipse.statet.r.editorHyperlinks.REditorTarget", getSourceEditor()); //$NON-NLS-1$ |
| } |
| |
| |
| @Override |
| protected IInformationProvider getQuickInformationProvider(final ISourceViewer sourceViewer, |
| final int operation) { |
| final IRSourceEditor editor= getSourceEditor(); |
| if (editor == null) { |
| return null; |
| } |
| switch (operation) { |
| case SourceEditorViewer.SHOW_SOURCE_OUTLINE: |
| return new RQuickOutlineInformationProvider(editor, operation); |
| default: |
| return null; |
| } |
| } |
| |
| } |
