Outlines de Conteúdo

Os editores geralmente possuem outlines de conteúdo correspondentes que fornecem uma visualização estruturada do conteúdo do editor e assistem o usuário na navegação pelo conteúdo do editor.

O workbench fornece uma visualização Esboço padrão com essa finalidade.  O usuário do workbench controla quando essa visualização deve ficar visível no menu Janela > Mostrar Visualização.

Já que o TextEditor genérico nada sabe sobre a estrutura de seu texto, não pode fornecer o comportamento de uma visualização de outline interessante.  Por essa razão, a visualização Esboço padrão, mostrada a seguir, não tem muita ação.

Organizador de Tópicos do Conteúdo Padrão

 

Os editores na estrutura de texto podem fornecer sua própria página de outline de conteúdo para a visualização esboço. O outline para um editor é especificado quando o workbench solicita um adaptador do tipo IContentOutlinePage.

public Object getAdapter(Class required) {
	if (IContentOutlinePage.class.equals(required)) {
		if (fOutlinePage == null) {
			fOutlinePage= new JavaContentOutlinePage(getDocumentProvider(), this);
			if (getEditorInput() != null)
				fOutlinePage.setInput(getEditorInput());
		}
		return fOutlinePage;
	}
	return super.getAdapter(required);
}

Uma página de outline de conteúdo deve implementar IContentOutlinePage.  Essa interface combina a habilidade em notificar atendentes de alteração de seleção (ISelectionProvider) com o comportamento de ser uma página em uma visualização (IPage).  Os outlines de conteúdo são normalmente implementados utilizando visualizadores JFace.  A implementação padrão de um outline de conteúdo (ContentOutlinePage) utiliza um visualizador de árvore JFace para exibir uma representação hierárquica do outline.  Essa representação é adequada para vários outlines estruturados, incluindo JavaContentOutlinePage.

Vamos olhar a implementação da página. Quando a página de outline é criada pelo editor no fragmento acima, seu elemento de entrada é definido para o elemento de entrada do editor.  Essa entrada pode normalmente ser transmitida diretamente para o visualizador de página de outline, como feito a seguir.

public void createControl(Composite parent) {

	super.createControl(parent);

	TreeViewer viewer= getTreeViewer();
	viewer.setContentProvider(new ContentProvider());
	viewer.setLabelProvider(new LabelProvider());
	viewer.addSelectionChangedListener(this);

	if (fInput != null)
		viewer.setInput(fInput);
}

A criação do visualizador de árvore é herdada de ContentOutlinePage.  O fornecedor de etiqueta padrão é utilizado. O fornecedor de conteúdo é fornecido dentro de JavaContentOutlinePage e é responsável pela análise da entrada do editor em segmentos individuais sempre que há alteração.

public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
			...
			if (newInput != null) {
				IDocument document= fDocumentProvider.getDocument(newInput);
	if (document != null) {
					document.addPositionCategory(SEGMENTS);
					document.addPositionUpdater(fPositionUpdater);
					parse(document);
				}
			}
		}

O texto é analisado em intervalos, chamados de segmentos, dentro do documento.  Esses segmentos são exibidos por nome na visualização de outline.

Organizador de Tópicos do Exemplo Java

Quando a seleção for alterada, o segmento selecionado será recuperado.  Seus deslocamentos são utilizados para definir o intervalo de realce no editor.

public void selectionChanged(SelectionChangedEvent event) {

	super.selectionChanged(event);

	ISelection selection= event.getSelection();
	if (selection.isEmpty())
		fTextEditor.resetHighlightRange();
	else {
		Segment segment= (Segment) ((IStructuredSelection) selection).getFirstElement();
		int start= segment.position.getOffset();
		int length= segment.position.getLength();
		try {
			fTextEditor.setHighlightRange(start, length, true);
		} catch (IllegalArgumentException x) {
			fTextEditor.resetHighlightRange();
		}
	}
}