Décomposeurs de contenu

Les éditeurs comportent souvent des décomposeurs de contenu correspondants qui fournissent une vue structurée du contenu de l'éditeur et aident l'utilisateur à naviguer dans le contenu de l'éditeur.

C'est à cette fin que le plan de travail fournit une vue Structure standard. L'utilisateur du plan de travail contrôle si cette vue est visible à l'aide du menu Fenêtre > Afficher la vue.

Comme la méthode TextEditor générique ne connaît pas la structure de son texte, elle ne peut pas fournir de comportement pour une vue de structure intéressante. De ce fait, la vue Structure par défaut, illustrée ci-dessous, ne sert pas à grand chose.

Décomposeur de contenu par défaut

 

Dans la structure de texte, les éditeurs peuvent offrir leur propre page de décomposeur de contenu à la vue Structure. Le décomposeur d'un éditeur est précisé lorsque le plan de travail demande un adaptateur de type 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);
}

Une page de décomposeur de contenu doit implémenter IContentOutlinePage.  Cette interface combine l'envoi de notifications aux modules d'écoute de changement de sélection (ISelectionProvider) et le comportement d'une page dans une vue (IPage).  Les décomposeurs de contenu sont généralement implémentés à l'aide d'afficheurs JFace. L'implémentation par défaut d'un décomposeur de contenu (ContentOutlinePage) sollicite un afficheur d'arborescence JFace pour montrer la représentation hiérarchique de la structure. Cette représentation est adaptée à divers décomposeurs structurés, dont JavaContentOutlinePage.

Observez l'implémentation de la page. Lorsque la page de structure est créée par l'éditeur dans le fragment de code précédent, son élément d'entrée équivaut à celui de l'éditeur. Cette entrée peut souvent être directement transmise à l'afficheur de la page de structure, comme ci-après.

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

La création d'un afficheur d'arborescence provient de ContentOutlinePage. Le fournisseur d'étiquette standard est utilisé. Le fournisseur de contenu est fourni dans JavaContentOutlinePage et est chargé d'analyser l'entrée de l'éditeur dans des segments individuels à chaque modification.

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

Le texte est analysé par plages, appelées segments, dans le document.  Ces segments sont affichés par nom dans la vue Structure.

Décomposeur d'exemple Java

Lorsque la sélection change, le segment sélectionné est extrait. Ses décalages servent à définir la plage en évidence dans l'éditeur.

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