1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
|
/*******************************************************************************
* Copyright (c) 2016, 2017 Red Hat Inc. and others.
*
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*
* Contributors:
* Sopot Cela, Mickael Istria (Red Hat Inc.) - initial implementation
* Lucas Bullen (Red Hat Inc.) - Bug 508829 custom reconciler support
* - Bug 521382 default highlight reconciler
* Simon Scholz <simon.scholz@vogella.com> - Bug 527830
* Angelo Zerr <angelo.zerr@gmail.com> - [generic editor] Default Code folding for generic editor should use IndentFoldingStrategy - Bug 520659
*******************************************************************************/
package org.eclipse.ui.internal.genericeditor;
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Set;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.content.IContentType;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.text.AbstractReusableInformationControlCreator;
import org.eclipse.jface.text.DefaultInformationControl;
import org.eclipse.jface.text.IAutoEditStrategy;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IDocumentPartitioningListener;
import org.eclipse.jface.text.IInformationControl;
import org.eclipse.jface.text.ITextHover;
import org.eclipse.jface.text.contentassist.ContentAssistant;
import org.eclipse.jface.text.contentassist.IContentAssistProcessor;
import org.eclipse.jface.text.contentassist.IContentAssistant;
import org.eclipse.jface.text.presentation.IPresentationReconciler;
import org.eclipse.jface.text.quickassist.IQuickAssistAssistant;
import org.eclipse.jface.text.quickassist.QuickAssistAssistant;
import org.eclipse.jface.text.reconciler.IReconciler;
import org.eclipse.jface.text.source.ISourceViewer;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.editors.text.TextSourceViewerConfiguration;
import org.eclipse.ui.internal.editors.text.EditorsPlugin;
import org.eclipse.ui.internal.genericeditor.folding.DefaultFoldingReconciler;
import org.eclipse.ui.internal.genericeditor.hover.CompositeTextHover;
import org.eclipse.ui.internal.genericeditor.markers.MarkerResoltionQuickAssistProcessor;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.ui.texteditor.spelling.SpellingCorrectionProcessor;
/**
* The configuration of the {@link ExtensionBasedTextEditor}. It registers the
* proxy composite for hover, completion, syntax highlighting, and then those
* proxy take care of resolving to the right extensions on-demand.
*
* @since 1.0
*/
@SuppressWarnings("restriction")
public final class ExtensionBasedTextViewerConfiguration extends TextSourceViewerConfiguration
implements IDocumentPartitioningListener {
private ITextEditor editor;
private Set<IContentType> contentTypes;
private IDocument document;
private ContentAssistant contentAssistant;
private List<IContentAssistProcessor> processors;
/**
*
* @param editor the editor we're creating.
* @param preferenceStore the preference store.
*/
public ExtensionBasedTextViewerConfiguration(ITextEditor editor, IPreferenceStore preferenceStore) {
super(preferenceStore);
this.editor = editor;
this.editor.addPropertyListener((source, propId) -> {
if (propId == IEditorPart.PROP_INPUT) {
watchDocument(editor.getDocumentProvider().getDocument(editor.getEditorInput()));
}
});
}
private Set<IContentType> getContentTypes() {
if (this.contentTypes == null) {
this.contentTypes = new LinkedHashSet<>();
Queue<IContentType> types = new LinkedList<>(Arrays
.asList(Platform.getContentTypeManager().findContentTypesFor(editor.getEditorInput().getName())));
while (!types.isEmpty()) {
IContentType type = types.poll();
this.contentTypes.add(type);
IContentType parent = type.getBaseType();
if (parent != null) {
types.add(parent);
}
}
}
return this.contentTypes;
}
@Override
public ITextHover getTextHover(ISourceViewer sourceViewer, String contentType) {
List<ITextHover> hovers = GenericEditorPlugin.getDefault().getHoverRegistry().getAvailableHovers(sourceViewer,
editor, getContentTypes());
if (hovers == null || hovers.isEmpty()) {
return null;
} else if (hovers.size() == 1) {
return hovers.get(0);
} else {
return new CompositeTextHover(hovers);
}
}
@Override
public IContentAssistant getContentAssistant(ISourceViewer sourceViewer) {
ContentAssistProcessorRegistry registry = GenericEditorPlugin.getDefault().getContentAssistProcessorRegistry();
contentAssistant = new ContentAssistant(true);
contentAssistant.setContextInformationPopupOrientation(ContentAssistant.CONTEXT_INFO_BELOW);
contentAssistant.setProposalPopupOrientation(ContentAssistant.PROPOSAL_REMOVE);
contentAssistant.setAutoActivationDelay(0);
contentAssistant.enableColoredLabels(true);
contentAssistant.enableAutoActivation(true);
this.processors = registry.getContentAssistProcessors(sourceViewer, editor, getContentTypes());
if (this.processors.isEmpty()) {
this.processors.add(new DefaultContentAssistProcessor());
}
for (IContentAssistProcessor processor : this.processors) {
contentAssistant.addContentAssistProcessor(processor, IDocument.DEFAULT_CONTENT_TYPE);
}
if (this.document != null) {
associateTokenContentTypes(this.document);
}
contentAssistant.setInformationControlCreator(new AbstractReusableInformationControlCreator() {
@Override
protected IInformationControl doCreateInformationControl(Shell parent) {
return new DefaultInformationControl(parent);
}
});
return contentAssistant;
}
@Override
public IPresentationReconciler getPresentationReconciler(ISourceViewer sourceViewer) {
PresentationReconcilerRegistry registry = GenericEditorPlugin.getDefault().getPresentationReconcilerRegistry();
List<IPresentationReconciler> reconciliers = registry.getPresentationReconcilers(sourceViewer, editor,
getContentTypes());
if (!reconciliers.isEmpty()) {
return reconciliers.get(0);
}
return super.getPresentationReconciler(sourceViewer);
}
void watchDocument(IDocument document) {
if (this.document == document) {
return;
}
if (this.document != null) {
this.document.removeDocumentPartitioningListener(this);
}
this.document = document;
associateTokenContentTypes(document);
document.addDocumentPartitioningListener(this);
}
@Override
public void documentPartitioningChanged(IDocument document) {
associateTokenContentTypes(document);
}
private void associateTokenContentTypes(IDocument document) {
if (contentAssistant == null || this.processors == null) {
return;
}
for (String legalTokenContentType : document.getLegalContentTypes()) {
for (IContentAssistProcessor processor : this.processors) {
contentAssistant.addContentAssistProcessor(processor, legalTokenContentType);
}
}
}
@Override
public IQuickAssistAssistant getQuickAssistAssistant(ISourceViewer sourceViewer) {
QuickAssistAssistant quickAssistAssistant = new QuickAssistAssistant();
CompositeQuickAssistProcessor processor = new CompositeQuickAssistProcessor(
Arrays.asList(new MarkerResoltionQuickAssistProcessor(), new SpellingCorrectionProcessor()));
quickAssistAssistant.setQuickAssistProcessor(processor);
quickAssistAssistant.setRestoreCompletionProposalSize(
EditorsPlugin.getDefault().getDialogSettingsSection("quick_assist_proposal_size")); //$NON-NLS-1$
quickAssistAssistant.setInformationControlCreator(
parent -> new DefaultInformationControl(parent, EditorsPlugin.getAdditionalInfoAffordanceString()));
return quickAssistAssistant;
}
@Override
public IReconciler getReconciler(ISourceViewer sourceViewer) {
ReconcilerRegistry registry = GenericEditorPlugin.getDefault().getReconcilerRegistry();
List<IReconciler> reconcilers = registry.getReconcilers(sourceViewer, editor, getContentTypes());
// Fill with highlight reconcilers
List<IReconciler> highlightReconcilers = registry.getHighlightReconcilers(sourceViewer, editor,
getContentTypes());
if (!highlightReconcilers.isEmpty()) {
reconcilers.addAll(highlightReconcilers);
} else {
reconcilers.add(new DefaultWordHighlightReconciler());
}
// Fill with folding reconcilers
List<IReconciler> foldingReconcilers = registry.getFoldingReconcilers(sourceViewer, editor, getContentTypes());
if (!foldingReconcilers.isEmpty()) {
reconcilers.addAll(foldingReconcilers);
} else {
reconcilers.add(new DefaultFoldingReconciler());
}
if (!reconcilers.isEmpty()) {
return new CompositeReconciler(reconcilers);
}
return null;
}
@Override
public IAutoEditStrategy[] getAutoEditStrategies(ISourceViewer sourceViewer, String contentType) {
AutoEditStrategyRegistry registry = GenericEditorPlugin.getDefault().getAutoEditStrategyRegistry();
List<IAutoEditStrategy> editStrategies = registry.getAutoEditStrategies(sourceViewer, editor,
getContentTypes());
if (!editStrategies.isEmpty()) {
return editStrategies.toArray(new IAutoEditStrategy[editStrategies.size()]);
}
return super.getAutoEditStrategies(sourceViewer, contentType);
}
@Override
protected Map<String, IAdaptable> getHyperlinkDetectorTargets(ISourceViewer sourceViewer) {
Map<String, IAdaptable> targets = super.getHyperlinkDetectorTargets(sourceViewer);
targets.put("org.eclipse.ui.genericeditor.GenericEditor", editor); //$NON-NLS-1$
return targets;
}
}
|
