Registrando Ações do Editor

A estrutura do editor de texto fornece várias classes de utilitário que auxiliam na apresentação e atualização do texto e do código fonte.  Agora nós concentraremos nossa atenção no workbench no qual o editor é apenas uma parte.  Como o editor interage com outros recursos do workbench, como menus de contexto, barras de menus e barras de ferramentas?

Ações da Barra de Menus do Editor

Para entender como os editores se registram com o workbench e fornecem ações para a barra de menus do workbench, consulte a seção que descreve o org.eclipse.ui.editors.  Nós não iremos refazer essas informações aqui.  Apenas examinaremos rapidamente a marcação em que o editor de exemplo Java registra seu 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>

As ações da barra de menus do workbench são contribuídas pelo JavaActionContributor.  Isso implementa ações que são colocadas no menu Editar do workbench e na barra de ferramentas do 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();
}

As primeiras duas ações são definidas como ações redestináveis do editor de texto. O princípio é semelhante às ações redestináveis fornecidas pelo workbench. As ações redestináveis do editor de texto representam entradas do menu que o contribuidor de ações liga dinamicamente a ações correspondentes fornecidas pelo editor ativo. Quando o editor ativo é alterado, a ação à qual uma ação redestinável do editor de texto está ligada também é alterada. O trecho a seguir mostra que o contribuidor de ações do editor localiza a ação correspondente solicitando ao editor uma ação de um determinado ID:

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

O ID deve ser o mesmo sob o qual a ação é registrada no editor, conforme fornecido aqui para o JavaTextEditor. (Consulte também a próxima seção.):

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

A terceira ação no contribuidor é uma ação concreta adicionada à barra de ferramentas do workbench.  Ela comuta o estado do editor entre mostrar o intervalo realçado (conforme prescrito pelo outline de conteúdo do exemplo Java) e mostrar o arquivo inteiro.  Esta ação aparece apenas na barra de ferramentas.

Menus de Contexto do Editor

Os menus de contexto do editor são criados e gerenciados na estrutura AbstractTextEditor e TextEditor .

O método createActions é utilizado para registrar ações com o editor.  Isso inclui ações apropriadas para os menus de contexto do editor ou quaisquer ações contribuídas nas definições de extensão.  No editor de exemplo Java, apenas as ações que estão ligadas às ações redestináveis são criadas.  No entanto, o editor de exemplo Java também herda as ações criadas por TextEditor e suas superclasses.  Estas ações podem ser utilizadas nos menus de contexto do editor.

O TextEditormétodo editorContextMenuAboutToShow é utilizado na estrutura para permitir que os editores incluam ações no menu de contexto para a área de edição.  Você pode utilizar um caminho de menu para decidir exatamente onde sua ação deverá aparecer.  Os caminhos válidos de menu dentro do menu de contexto do editor são definidos na implementação deste método em AbstractTextEditor.

Há várias maneiras de adicionar uma ação a este menu.  A primeiro maneira é adicionando uma ação que utiliza apenas o ID sob o qual está registrado no editor.  Por exemplo, o JavaTextEditor adiciona suas ações da assistência ao conteúdo para o menu quando este método é chamado.  As ações não aparecerão no menu quando nenhuma ação estiver registrada sob o ID utilizado.

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

A superclasse TextEditor adiciona ações de uma segunda maneira - especificando um grupo de menus no menu de contexto para aplicar a ação.  Neste caso, as ações (Shift Esquerda, Shift Direita) aparecem no menu de contexto no grupo definido por 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 de contexto do editor

O método rulerContextMenuAboutToShow é utilizado da mesma maneira antes do menu de contexto da régua ser mostrado.  A implementação deste método em AbstractTextEditor define os grupos em que itens podem ser adicionados ao menu.

IDs de Menu

Os menus de contexto do editor e de contexto da régua podem ser atribuídos de modo que outros plug-ins possam contribuir com esses menus em suas extensões.  O esquema para estabelecer IDs de menu está mais flexível desde a versão original da plataforma.  No entanto, a estrutura pode executar em um modo de compatibilidade para permanecer compatível com os plug-ins desenvolvidos para a versão original.  Você pode utilizar AbstractTextEditor.setCompatibilityMode() para controlar esse comportamento.  A definição padrão é true.

IDs de Menu Compatíveis com 1.0

Quando o modo de compatibilidade é true, os IDs dos menus de contexto do editor e da régua podem ser definidos utilizando o protocolo AbstractTextEditor.   Os métodos setEditorContextMenuId e setRulerContextMenuId podem ser utilizados para essa finalidade. A redefinição dos IDs pode ser útil se você desejar prevenir a herança de menus que foram contribuídos para os menus de superclasse.  Por exemplo, o JavaTextEditor no exemplo redefine seus IDs de menu de contexto para que sejam específicos do Java, para prevenir a herança de quaisquer contribuições genéricas de texto de outros plug-ins.

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

Se nenhum ID for configurado em qualquer parte na hierarquia concreta, os IDs padrão definidos por AbstractTextEditor serão utilizados.

IDs de Menu Não-Compatíveis com 1.0

O ID do menu de contexto do editor é sempre <editor id>.EditorContext, em que <editor id> é o ID do editor . O ID de um editor é definido na declaração xml do editor. O ID do menu de contexto é sempre <editor id>.RulerContext.