Other text editor responsibilities
The Java example editor inherits a lot of useful default behavior from
AbstractTextEditor.
The text editing framework handles several other responsibilities that you can
customize by overriding methods in
AbstractTextEditor.
Browse the implementation of this class and its subclasses to see how behavior
is customized in the framework.
The following are some of the useful framework features that can be
configured.
Preference handling
Text editors typically contribute user preferences that control the
presentation and behavior of the editor. In the text framework, each text
editor instance has an associated preference store that is used for accessing
user preferences. This preference store can be set up by your editor, or
you can inherit from preference stores already used in the framework.
In the case of the Java example editor, it inherits the preference store
initialized by
TextEditor.
This is the preference store defined by the workbench editors
plug-in.
protected void initializeEditor() {
...
setPreferenceStore(EditorsPlugin.getDefault().getPreferenceStore());
}
The editors plug-in preferences can be manipulated in the
General > Editors
and
General > Editors > Text Editors
preference pages.
If you do not want to use the standard workbench text preferences for your
editor, you can set a different preference store. This is typically done
by overriding initializeEditor and setting your own preference store.
If you do use your own preference store, you will also need to override the
method handlePreferenceStoreChanged() which is triggered whenever a preference
is updated.
Key bindings
Key binding contexts are useful
for establishing a lookup order for key bindings. Having contextual key bindings
reduces the chances of different plug-ins contributing conflicting key
sequences. By default, the workbench operates in a generic context for working with
windows or dialogs. When a text editor becomes active, it is responsible
for resetting the context to the text editing context, so that editor specific key
bindings will be active.
In the platform text framework, each text editor instance has an associated array of
key binding scopes. It is responsible for setting the correct scopes when it becomes
active.
AbstractDecoratedTextEditor
defines this scope and takes care of making it active. The scope is assigned
in a method that is called from the constructor:
protected void initializeKeyBindingScopes() {
setKeyBindingScopes(new String[] { "org.eclipse.ui.textEditorScope" });
}
The argument to the method is an array of ids that have been defined for contexts.
If you want your editor to define its own key binding context, then you can
override this method in your editor class, or set the scope dynamically using setKeybindingScopes.
The context itself must be defined with the corresponding id in the
org.eclipse.ui.contexts
extension point. The following is the definition for the text editing context.
<extension
point="org.eclipse.ui.contexts">
<context
name="%context.editingText.name"
description="%context.editingText.description"
id="org.eclipse.ui.textEditorScope"
parentId="org.eclipse.ui.contexts.window">
</context>
...
(Note: We use the terms scope and context interchangeably in this
discussion. The method names in the text classes still refer to key binding contexts
as scopes. These method names reflect the original implementation of contexts as scopes
and use outdated terminology.)
