Registrér editorfunktioner

Teksteditorstrukturen omfatter mange funktionsklasser, som bidrager til at præsentere og opdatere tekst og kildekode. Nu vender vi opmærksomheden mod arbejdsbænken, som editoren blot er en enkelt del af. Hvordan fungerer editoren sammen med andre arbejdsbænkfunktioner, som f.eks. kontekstmenuer, menulinjer og værktøjslinjer?

Funktioner på editorens menulinje

Hvis du vil have en forståelse af, hvordan editorer registrerer sig selv i forhold til arbejdsbænken og stiller funktioner til rådighed for arbejdsbænkens menulinje, skal du se det afsnit, der handler om org.eclipse.ui.editors. Vi gentager ikke disse oplysninger her.   Vi ser bare hurtigt på den kodning, der drejer sig om, at editoren til Java-eksemplet registrerer sin editor.

<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>

Funktioner på arbejdsbænkens menulinje bidrages vha. JavaActionContributor.  Den implementerer funktioner, som er placeret på arbejdsbænkens Redigér-menu og arbejdsbænkens værktøjslinje.

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

De to første funktioner defineres som "retargetable" teksteditorfunktioner - "målsøgende" funktioner, som er bundet til menupunkter. Principperne minder om de 'målsøgende' funktioner, der stilles til rådighed af arbejdsbænken. Målsøgende teksteditorfunktioner repræsenterer menupunkter, som bidragyderen af funktionen dynamisk binder til tilsvarende funktioner, som stilles til rådighed af den aktive editor. Når den aktive editor ændres, ændres den funktion, en målsøgende teksteditorfunktion er bundet til, også. Følgende kodesekvens viser, at bidragyderen af editorfunktionen finder den tilsvarende funktion ved at bede editoren om en given id's funktion:

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();
}

Id'en skal være den samme som den, funktionen er registreret under over for editoren, som angivet her for JavaTextEditor. (Se desuden næste afsnit.):

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); 
}

Den tredje funktion i bidragyderen er en konkret funktion, som tilføjes arbejdsbænkens værktøjslinje. Den medfører et skift i editortilstanden mellem at vise det fremhævede interval (som dikteres af Java-eksemplets indholdskontur) og vise hele filen. Denne funktion vises kun på værktøjslinjen.

Editorens kontekstmenuer

Editorens kontekstmenuer oprettes og administreres i AbstractTextEditor- og TextEditor-strukturen.

Metoden createActions bruges til at registrere funktioner over for editoren. Det omfatter funktioner, som er relevante for editorens kontekstmenuer eller funktioner, som bidrages i udvidelsesdefinitioner. I editoren til Java-eksemplet oprettes kun de funktioner, som bindes til de målsøgende funktioner. Editoren til Java-eksemplet overtager imidlertid også de funktioner, som oprettes af TextEditor og dens superklasser. Disse funktioner kan bruges i editorens kontekstmenuer.

TextEditor-metoden editorContextMenuAboutToShow bruges i strukturen til at gøre det muligt for editorer at tilføje funktioner til kontekstmenuen til redigeringsområdet. Du kan bruge en menusti til præcist at afgøre, hvor funktionen skal vises. Gyldige menustier i editorens kontekstmenu defineres i implementeringen af denne metode i AbstractTextEditor.

Du kan tilføje en funktion til denne menu på flere måder. Den første måde går ud på at tilføje en funktion kun vha. den id, funktionen er registreret under i forhold til editoren. JavaTextEditor tilføjer f.eks. sine funktioner til Indholdsassistance til menuen, når denne metode kaldes. Funktioner vises kun på menulinjen, hvis der registreres en funktion under den brugte id.

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

Superklassen TextEditor tilføjer funktioner på en anden måde - ved at angive en menugruppe i kontekstmenuen, som funktionen skal placeres i. I dette tilfælde vises funktionerne (Skift venstre, Skift højre) i kontekstmenuen i den gruppe, der er defineret af AbstractTextEditor.

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

Editorens kontekstmenu

Metoden rulerContextMenuAboutToShow bruges på samme måde, før linealens kontekstmenu vises. Implementering af denne metode iAbstractTextEditor definerer de grupper, hvor elementer kan tilføjes menuen.

Menu-id'er

Editorens og linealens kontekstmenuer kan tildeles id'er, så andre plugins kan bidrage til disse menuer vha. deres udvidelser. Systemet for fastlæggelse af menu-id'er er blevet mere fleksibelt siden den oprindelige version af platformen. Strukturen kan imidlertid udføres i kompatibilitetstilstand, så den vedbliver at være kompatibel med de plugins, som er udviklet til den oprindelige version. Du kan bruge AbstractTextEditor.setCompatibilityMode() til at styre denne funktionsmåde. Standardindstillingen er 'true'.

1.0-kompatible menu-id'er

Når kompatibilitetstilstanden er 'true', kan id'erne for editorens og linealens kontekstmenuer fastsættes vha. protokollen AbstractTextEditor. Metoderne setEditorContextMenuId og setRulerContextMenuId kan anvendes til dette formål. Nulstilling af id'erne kan være praktisk, hvis du vil forhindre overtagelse af menuer, som er bidraget til superklassemenuer. I eksemplet nulstiller JavaTextEditor f.eks. sine kontekstmenu-id'er til at være Java-specifikke for at forhindre overtagelse af eventuelle generiske tekstbidrag fra andre plugins.

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

Hvis der ikke angives nogen id et sted i det konkrete hierarki, bruges de standard-id'er, som er defineret af AbstractTextEditor.

Menu-id'er, som ikke er kompatible med 1.0

Editorens kontekstmenu-id er altid <editor id>.EditorContext, hvor <editor id> er editorens id. En editors id defineres i editorens xml-erklæring. Linealens kontekstmenu-id er altid <editor id>.RulerContext.