Outlines de Conteúdo

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

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

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

Outline de conteúdo padrão

 

Os editores na estrutura de texto podem fornecer sua própria página de outline de conteúdo para a exibição de outline. 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 exibiçã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.  Os provedores padrão de conteúdo e rótulo são utilizados. Sempre que a entrada do editor for definida (ou alterada),  JavaContentOutlinePage obtém um documento para a entrada do editor e analisa o texto.

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 exibiçã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();
		}
	}
}
Copyright IBM Corporation e outros 2000, 2003.