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.

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.

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