Registrazione delle azioni dell'editor

Il framework dell'editor di testo fornisce molte classi di utilità che agevolano la presentazione e l'aggiornamento del testo e del codice di origine.  Verrà ora illustrato il workbench di cui l'editor costituisce solo una parte.  Come interagisce l'editor con le altre funzioni del workbench quali i menu di scelta rapida, le barre dei menu e le barre degli strumenti?

Azioni delle barre dei menu dell'editor

Per comprendere le modalità con cui gli editor eseguono la registrazione con il workbench e forniscono azioni per la barra dei menu del workbench, fare riferimento alla sezione relativa a org.eclipse.ui.editors.  Queste informazioni non verranno fornite un questa sede.   Verrà invece rapidamente esaminato il tag con cui l'editor di esempio Java esegue la registrazione del rispettivo 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>

Le azioni delle barre dei menu del workbench vengono fornite da JavaActionContributor.  Questa classe implementa le azioni che si trovano nel menu Modifica del workbench e sulla barra degli strumenti del workbench.

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

Le prime due azioni sono definite come azioni dell'editor di testo ridestinabili. Il principio è simile alle azioni ridestinabili fornite dal workbench. Le azioni ridestinabili dell'editor di testo rappresentano le voci di menu che il contributor di azioni associa dinamicamente alle azioni corrispondenti fornite dall'editor attivo. Quando l'editor attivo cambia, cambia anche l'azione alla quale è associata un'azione ridestinabile dell'editor di testo. Il frammento di codice che segue mostra come il contributor di azioni dell'editor trova l'azione corrispondente richiedendo l'azione di un determinato id all'editor:

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

L'id deve essere lo stesso con il quale l'azione è stata registrata con l'editor come per JavaTextEditor. (Vedere anche la sezione successiva):

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

La terza azione nel contributor è un'azione concreta aggiunta alla barra degli strumenti del workbench.  Questa alterna lo stato dell'editor tra la visualizzazione dell'intervallo evidenziato (come indicato dalla struttura di contenuto dell'esempio Java) e la visualizzazione dell'intero file.  Questa azione è presente solo sulla barra degli strumenti.

Menu di scelta rapida dell'editor

I menu di scelta rapida dell'editor vengono creati e gestiti nel framework AbstractTextEditor e TextEditor .

Per registrare azioni con l'editor, viene utilizzato il metodo createActions.  Questo include azioni appropriate per i menu di scelta rapida dell'editor o le azioni fornite nelle definizioni dei punti di estensione.  Nell'editor di esempio Java vengono create solo le azioni associate alle azioni ridestinabili.  Tuttavia l'editor di esempio Java eredita anche le azioni create da TextEditor e dalle relative superclassi.  Tali azioni possono essere utilizzate nei menu di scelta rapida dell'editor.

Il metodo editorContextMenuAboutToShow TextEditor viene utilizzato nel framework per consentire agli editor l'aggiunta di azioni al menu di scelta rapida per l'area di modifica.  È possibile utilizzare un percorso di menu per stabilire esattamente dove visualizzare l'azione.  I percorsi di menu validi all'interno del menu di scelta rapida dell'editor sono definiti nell'implementazione di questo metodo in AbstractTextEditor.

Esistono diverse modalità per aggiungere un'azione a questo menu.  È possibile aggiungere un'azione utilizzando solo l'id con il quale l'azione è registrata con l'editor.  Ad esempio, richiamando questo metodo, JavaTextEditor aggiunge al menu le rispettive azioni per l'assistenza per i contenuti.  Se con l'id utilizzato non è stata registrata alcuna azione, le azioni non verranno visualizzate.

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

La superclasse TextEditor aggiunge azioni con una seconda procedura, ossia specificando un gruppo di menu nel menu di scelta rapida per l'inserimento dell'azione.  In questo caso le azioni(Sposta a sinistra, Sposta a destra) vengono visualizzate nel menu di scelta rapida nel gruppo definito da 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);
}

Menu di contesto dell'editor

Il metodo rulerContextMenuAboutToShow viene utilizzato allo stesso modo prima che venga visualizzato il menu di scelta rapida del righello.  L'implementazione di questo metodo in AbstractTextEditor definisce i gruppi in cui gli elementi possono essere aggiunti al menu.

Id dei menu

I menu di scelta rapida dell'editor e del righello possono essere id assegnati in modo che altri plugin possano contribuire a questi menu nei relativi punti di estensione.  Lo schema che consente di stabilire gli id di menu è più flessibile rispetto alla versione originale della piattaforma.  Tuttavia, per garantirne la compatibilità con i plugin sviluppati per la versione originale, il framework può essere eseguito in una modalità di compatibilità.  È possibile utilizzare AbstractTextEditor.setCompatibilityMode() per controllare questa funzionalità.  L'impostazione predefinita è true.

Id di menu compatibili con 1.0

Quando la modalità di compatibilità è true, è possibile impostare gli id dei menu di scelta rapida dell'editor e del righello utilizzando il protocollo AbstractTextEditor.  A questo scopo, è possibile utilizzare i metodi setEditorContextMenuId esetRulerContextMenuId.  Potrebbe risultare utile reimpostare gli id per evitare che vengano ereditati menu forniti ai menu delle superclassi.  Ad esempio, JavaTextEditor reimposta gli id del menu di scelta rapida in modo che siano specifici di Java per evitare che vengano ereditati contributi di testo generici da altri plugin.

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

Se non viene effettuata alcuna reimpostazione nella gerarchia concreta, verranno utilizzati gli id predefiniti definiti da AbstractTextEditor.

Id di menu non compatibili con 1.0

L'id del menu di scelta rapida dell'editor è sempre <id editor>.EditorContext, in cui <id editor> è l'id dell'editor. L'id di un editor viene definito nella dichiarazione xml dell'editor. Il menu di scelta rapida del righello è sempre <id editor>.RulerContext.