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.gif"
         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 Texteditoraktion gebunden ist, die erneut als Ziel verwendet werden kann. 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.

Mit der Methode createActions werden Aktionen im Editor registriert.  Dies gilt auch für Aktionen, die für die Kontextmenüs von Editoren geeignet sind, sowie alle Aktionen, die in Erweiterungsdefinitionen ergänzt werden.  Im Java-Beispieleditor werden nur die Aktionen erstellt, die an die Aktionen gebunden werden, welche erneut als Ziele verwendet werden können.  Der Java-Beispieleditor übernimmt allerdings auch die Aktionen, die durch die KlasseTextEditor und ihre Superklassen erstellt werden.  Diese Aktionen können im Kontextmenü des Editors 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.

Es gibt mehrere Möglichkeiten für das Hinzufügen einer Aktion zu diesem Menü.  Die erste Möglichkeit besteht darin, dass zum Hinzufügen einer Aktion lediglich die ID verwendet wird, unter der sie im Editor registriert ist.   JavaTextEditor fügt beispielsweise seine Aktionen für die Unterstützung für Inhalt zum Menü hinzu, sobald diese Methode aufgerufen wird.  Aktionen werden im Menü nicht angezeigt, wenn unter der verwendeten ID keine Aktion 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);
}

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

Dem Kontextmenü des Editors und der Skala können IDs zugeordnet werden, damit andere Plug-ins in ihren Erweiterungen Ergänzungen für diese Menüs bereitstellen können.  Das Schema für die Einrichtung von Menü-IDs ist seit der ursprünglichen Plattformversion flexibler geworden.  Das Gerüst kann jedoch in einem Kompatibilitätsmodus ausgeführt werden, damit es mit Plug-ins kompatibel bleibt, die für die ursprüngliche Version entwickelt wurden.  Mit AbstractTextEditor.setCompatibilityMode() können Sie dieses Verhalten steuern.  Die Standardeinstellung ist "true".

Mit Release 1.0 kompatible Menü-IDs

Wenn der Kompatibilitätsmodus auf "true" gesetzt ist, können die IDs für die Kontextmenüs des Editors und der Skala unter Verwendung des ProtokollsAbstractTextEditor festgelegt werden.  Zu diesem Zweck können Sie die Methoden setEditorContextMenuId und setRulerContextMenuId verwenden.  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 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.

Copyright IBM Corporation und Andere 2000, 2003.