Editoraktionen registrieren

Das Gerüst für den Texteditor stellt viele Dienstprogrammklassen zur Verfügung, die für die Darstellung und Aktualisierung von Text und Quellcode hilfreich sind. Der folgende Abschnitt beschäftigt sich mit der Workbench, in der der Editor nur eine Komponente von vielen ist, und beantwortet die Frage, wie der Editor mit anderen Workbenchkomponenten (z. B. Kontextmenüs, Menüleisten und Symbolleisten) interagiert.

Editoraktionen in der Menüleiste

Im Abschnitt org.eclipse.ui.editors ist beschrieben, wie Editoren sich selbst in der Workbench registrieren und Aktionen für die Menüleiste der Workbench bereitstellen.  Diese Informationen sollen an dieser Stelle nicht wiederholt werden.  Zur Erinnerung sind im Folgenden lediglich die Konfigurationsbefehle angegeben, in denen der Java-Beispieleditor seinen Editor registriert.

<extension
      point="org.eclipse.ui.editors">
   <editor
         name="%javaEditorName"
         icon="icons/obj16/java.png"
         extensions="jav"
         contributorClass="org.eclipse.ui.examples.javaeditor.JavaActionContributor"
         class="org.eclipse.ui.examples.javaeditor.JavaEditor"
         id="org.eclipse.ui.JavaEditor">
   </editor>
</extension>

Aktionen für die Workbenchmenüleiste werden durch den JavaActionContributor ergänzt.  Er implementiert Aktionen, die in das Menü Bearbeiten und die Symbolleiste der Workbench gestellt werden.

public JavaActionContributor() {
	super();
	fContentAssistProposal= new RetargetTextEditorAction(JavaEditorMessages.getResourceBundle(), "ContentAssistProposal."); //$NON-NLS-1$
	...
	fContentAssistTip= new RetargetTextEditorAction(JavaEditorMessages.getResourceBundle(), "ContentAssistTip."); //$NON-NLS-1$
	...
	fTogglePresentation= new PresentationAction();
}

Die ersten beiden Aktionen sind als Texteditoraktionen definiert, die erneut als Ziele verwendet werden können. Das Prinzip hat Ähnlichkeit mit den durch die Workbench bereitgestellten Aktionen, die erneut als Ziele verwendet werden können. Solche Texteditoraktionen stellen Menüoptionen dar, die die Aktionsergänzung dynamisch an die entsprechenden Optionen bindet, welche durch den aktiven Editor bereitgestellt werden. Sobald sich der aktive Editor ändert, ändert sich auch die Aktion, an die eine umlenkbare Texteditoraktion gebunden ist. Der folgende Ausschnitt veranschaulicht, dass die Editoraktionsergänzung die entsprechende Aktion ermittelt, indem vom Editor eine Aktion für eine bestimmte ID abgefragt wird:

protected final IAction getAction(ITextEditor editor, String actionId) {
return (editor == null ? null : editor.getAction(actionId));
} public void setActiveEditor(IEditorPart part) {
super.setActiveEditor(part);
ITextEditor editor= null;
if (part instanceof ITextEditor)
editor= (ITextEditor) part;
fContentAssistProposal.setAction(getAction(editor, "ContentAssistProposal"));
fContentAssistTip.setAction(getAction(editor, "ContentAssistTip"));
fTogglePresentation.setEditor(editor);
fTogglePresentation.update();
}

Die ID muss mit der ID identisch sein, unter der die Aktion im Editor registriert ist, wie dies im Beispiel für JavaTextEditor der Fall ist. (Siehe auch den nächsten Abschnitt):

protected void createActions() {
	super.createActions();
		
	IAction a= new TextOperationAction(JavaEditorMessages.getResourceBundle(), "ContentAssistProposal.", this, ISourceViewer.CONTENTASSIST_PROPOSALS); //$NON-NLS-1$
	a.setActionDefinitionId(ITextEditorActionDefinitionIds.CONTENT_ASSIST_PROPOSALS);
	setAction("ContentAssistProposal", a); 
		
	a= new TextOperationAction(JavaEditorMessages.getResourceBundle(), "ContentAssistTip.", this, ISourceViewer.CONTENTASSIST_CONTEXT_INFORMATION);  //$NON-NLS-1$
	a.setActionDefinitionId(ITextEditorActionDefinitionIds.CONTENT_ASSIST_CONTEXT_INFORMATION);
	setAction("ContentAssistTip", a); 
}

Die dritte Aktion in der Ergänzung ist eine konkrete Aktion, die zur Symbolleiste der Workbench hinzugefügt wird. Sie schaltet den Status des Editors zwischen dem Anzeigen des hervorgehobenen Bereichs (wie durch die Inhaltsgliederung des Java-Beispiels vorgegeben) und dem Anzeigen der gesamten Datei um.  Diese Aktion ist nur in der Symbolleiste vorhanden.

Kontextmenüs für Editoren

Die Kontextmenüs für Editoren werden im Gerüst von AbstractTextEditor und TextEditor erstellt und verwaltet.

Die Methode createActions wird verwendet, um Aktionen mit dem Editor zu registrieren.  Dies beinhaltet Aktionen, die für die Kontextmenüs für Editoren geeignet sind, sowie Aktionen, die durch Erweiterungsdefinitionen ergänzt werden.  Im Java-Beispielseditor werden nur die Aktionen erstellt, die an umlenkbare Aktionen gebunden sind.  Der Java-Beispieleditor übernimmt allerdings auch die Aktionen, die vom TextEditor und seinen Superklassen erstellt wurden.  Diese Aktionen können in den Kontextmenüs für Editoren verwendet werden.

Über die Methode editorContextMenuAboutToShow von TextEditor kann im Gerüst zugelassen werden, dass Editoren Aktionen zum Kontextmenü für den Bearbeitungsbereich hinzufügen.  Mit Hilfe eines Menüpfades können Sie genau festlegen, wo die Aktion angezeigt werden soll. Gültige Menüpfade innerhalb des Kontextmenüs für einen Editor sind in der Implementierung dieser Methode in AbstractTextEditor definiert.

Eine Aktion kann auf verschiedene Arten zu diesem Menü hinzugefügt werden.  Als erste Option kann für das Hinzufügen einer Aktion nur die ID, unter der sie beim Editor registriert ist, verwendet wird.  Der JavaTextEditor fügt beispielsweise Aktionen für Inhaltsunterstützung zum Menü hinzu, wenn diese Methode aufgerufen wird.  Aktionen erscheinen nicht im Menü, wenn keine Aktion unter der verwendeten ID registriert ist.

public void editorContextMenuAboutToShow(MenuManager menu) {
	super.editorContextMenuAboutToShow(menu);
	addAction(menu, "ContentAssistProposal"); 
	addAction(menu, "ContentAssistTip"); 
}

Die Superklasse TextEditor fügt Aktionen über eine zweite Methode hinzu, nämlich das Angeben einer Menügruppe im Kontextmenü für die Platzierung der Aktion. In diesem Fall werden die Aktionen (Nach links versetzen, Nach rechts versetzen) im Kontextmenü in der Gruppe angezeigt, die durch AbstractTextEditor definiert ist.

protected void editorContextMenuAboutToShow(IMenuManager menu) {
	super.editorContextMenuAboutToShow(menu);
	addAction(menu, ITextEditorActionConstants.GROUP_EDIT, ITextEditorActionConstants.SHIFT_RIGHT);
	addAction(menu, ITextEditorActionConstants.GROUP_EDIT, ITextEditorActionConstants.SHIFT_LEFT);
}

Kontextmenü für Editoren

Die Methode rulerContextMenuAboutToShow wird auf dieselbe Weise verwendet, bevor das Kontextmenü der Skala angezeigt wird.  Die Implementierung dieser Methode in AbstractTextEditor definiert die Gruppen, in denen Optionen zum Menü hinzugefügt werden können.

Menü-IDs

Den Kontextmenüs für Editoren und Skalen können IDs zugeordnet werden, so dass andere Plug-ins diese Menüs über ihre Erweiterungen ergänzen können.  Das Schema für die Bestimmung von Menü-IDs ist seit der ursprünglichen Version der Plattform flexibler geworden.  Das Gerüst kann allerdings im Kompatibilitätsmodus ausgeführt werden, damit es auch weiterhin mit Plug-ins, die für die ursprüngliche Version entwickelt wurde, kompatibel ist. Sie können AbstractTextEditor.setCompatibilityMode() verwenden, um dieses Verhalten zu steuern.  Die Standardeinstellung ist "true".

Mit Release 1.0 kompatible Menü-IDs

Wenn der Kompatibilitätsmodus auf 'true' steht, können die IDs der Kontextmenüs für Editoren und Skalen unter Verwendung des Protokolls AbstractTextEditor gesetzt werden.  Die Methoden setEditorContextMenuId und setRulerContextMenuId können für diesen Zweck verwendet werden.  Eine Neufestlegung dieser IDs kann nützlich sein, wenn Sie die Übernahme von Menüs verhindern wollen, die in Menüs der Superklasse ergänzt wurden.  Im Beispiel legt JavaTextEditor die eigenen Kontextmenü-IDs neu als Java-spezifisch fest, um die Übernahme von generischen Textergänzungen aus anderen Plug-ins zu verhindern..

protected void initializeEditor() {
	super.initializeEditor();
	JavaEditorEnvironment.connect(this);
	setSourceViewerConfiguration(new JavaSourceViewerConfiguration());
	setEditorContextMenuId("#JavaEditorContext"); 
	setRulerContextMenuId("#JavaRulerContext"); 
}

Wenn in der konkreten Hierarchie an keiner Stelle eine ID festgelegt ist, werden die durch AbstractTextEditor definierten Standard-IDs verwendet.

Mit Release 1.0 inkompatible Menü-IDs

Die Kontextmenü-ID des Editors lautet immer <editor-id>.EditorContext. Hierbei steht <editor-id> für die ID des Editors. Die ID eines Editors ist in der XML-Deklaration des Editors definiert. Die Kontextmenü-ID der Skala lautet immer <editor-id>.RulerContext.