Package Name | Comment |
org.eclipse.jface.text |
text infrastructure
Provides a framework for creating and manipulating text documents.
Package Specification
IDocument is the major text
model abstraction. It provides content management, position management using
position categories, document partition management, and change notification.
In order to be notified about document changes, an object must implements IDocumentListener
and must be registered with the document. Position
updating in responds to a document change is performed by implementers of IDocumentPositionUpdater.
Partition updating in responds to a document change is performed by implements
of IDocumentPartitioner. In order
to be notified about document partition changes, objects must implement IDocumentParititoningListener
and must be registered with the document.
The package contains default implementations for document position updaters
and for documents. AbstractDocument
uses ITextStorage for storing
and managing its content and ILineTracker
to maintain a line structure of its content. As defaults a gap text implementation
of ITextStore is provided, together
with a line tracker understanding the three standard line delimiters ("\r",
"\n", "\r\n") and a line tracker which can be freely configured
to consider any given set of strings as valid line delimiters.
|
org.eclipse.jface.text.link |
Linked Position Infrastructure
Application programming interfaces for interaction
with the Eclipse Java User Interface text support.
Linked Position Infrastructure
package org.eclipse.jface.text.link
The Linked Position Infrastructure lets one set up a mode in an editor
in which regions in a document (or several documents) are linked,
i.e. editions
of one linked position will be reflected in the others.
Classes
LinkedPositionGroup : a set of linked positions. Add
positions to a group using the addPosition method. See LinkedPosition and ProposalPosition
for a position type that lets one attach ICompletionProposal s to
be shown when the position is hit.
LinkedModeModel : umbrellas several LinkedPositionGroup s,
e.g. in a template that has several groups of linked positions. Handles
the forwarding of updates received via an IDocumentListener . Add LinkedPositionGroup s
to
an model using the addGroup method. Existence of a LinkedModeModel can be
tested by one of the static methods.
LinkedModeUI : The UI for linked mode (for one
model, to be precise). Monitors key etc. activity, monitors exit
conditions, creates a painter etc.
Properties:
- cycling mode (whether to jump to the first position
after the last): either of
CYCLE_ALWAYS , CYCLE_NEVER
and CYCLE_WHEN_NO_PARENT (default).
- exit position: where to jump upon leaving the linked
mode (e.g. using Enter, or Tab from the last position when not
cycling). Set
isTabStop to true if tabbing
should stop over when cycling.
- position listener:
extending classes may register a position listener which will get
notified whenever
the focus position changes. An example is
org.eclipse.ui.texteditor.link.EditorLinkedModeUI.EditorHistoryUpdater
which will store the edit location in the editor navigation history.
Example
IDocument doc1, doc2;
ITextViewer viewer1, viewer2;
/* create groups - this step is independent of the linked mode */
LinkedPositionGroup group1= new LinkedPositionGroup();
group1.addPosition(new LinkedPosition(doc1, 3, 4));
group1.addPosition(new LinkedPosition(doc1, 7, 8));
LinkedPositionGroup group2= new LinkedPositionGroup();
group2.addPosition(new LinkedPosition(doc1, 15, 25));
group2.addPosition(new LinkedPosition(doc2, 0, 10));
/* set up linked mode */
LinkedModeModel model= new LinkedModeModel();
model.addGroup(group1);
model.addGroup(group2);
model.forceInstall();
/* create UI */
LinkedModeUI ui= new LinkedModeUI(model, new ITextViewer[] { viewer1, viewer2 });
ui.enter();
|
org.eclipse.jface.text.projection |
projections
This package provides an implementation of projection documents. Projection
is a specific master/slave mapping. Non-overlapping fragments if a master document
form the segments of a slave document. The slave document is completely built
out of segments, i.e. there are no gaps between two neighboring segments. The
segments have exactly the same sequence in which they apprear as fragments in
the master document.
Package Specification
ProjectionDocument is custom
IDocument implementation that
uses a ProjectionTextStore. The
content of the ProjectionDocument
is defined by the ProjectionMapping.
The ProjectionDocumentManager
manages the life cycle of ProjectionDocuments
and their relation to their master documents.
|
org.eclipse.jface.text.source |
annotation models
Provides a support for managing annotations attached to a document.
Package Specification
IAnnotationModels manage Annotations.
When an annotation model is connected to an IDocument,
any change to the document is reflected in the position of the managed annotations.
Implementers of IAnnotationModelListener
registered with an IAnnotationModel
object get informed about changes of the model in respect to annotations.
|
org.eclipse.jface.text.templates |
Templates
Application programming interfaces for interaction
with the Eclipse Java User Interface text support.
Templates
Packages
- org.eclipse.jface.text.templates
- org.eclipse.ui.workbench.texteditor.templates
- org.eclipse.ui.editors.templates
Introduction
Templates are shortcuts for frequently used fragments of text such as
code patterns or complex text entities. They may contain variables
which are only resolved at the time when the template is inserted
within a context. Together with linked mode, inserting a template can
create a on-the-fly edit mask within a text viewer.
Templates are specified as text, variables are defined using the ${variable}
notation known from
Ant, for example. The following snippet shows an example template for
an instance check in Java:
if (${name} instanceof ${type}) {
${type} ${new_name} = (${type})${name};
${cursor}
}
In this template, the variables (name,type, ...) are resolved
when inserted into java source and changing one variable instance will
also change the other. When leaving linked mode, the caret is placed at
the cursor variable.
Template functionality can be added to a custom text editor by offering
TemplateProposals as content assist choices, which is
simplified by using a subclass of TemplateCompletionProcessor. User template management can be
offered by including a TemplatePreferencePage which uses a TemplateStore and ContextTypeRegistry as the
underlying model to store templates. The org.eclipse.ui.editors.templates
extension point can be used to allow other plug-ins to contribute
templates to an editor. This is accomplished by using the ContributionTemplateStore and ContributionContextTypeRegistry
subclasses of the above types.
Template variables are resolved by a TemplateVariableResolver. GlobalTemplateVariables offers
some default variables such as date, user, and selection, but advanced
features such as resolving to language constructs can be performed in
subclasses.
Classes
- Template a template consists of name, context
type identifier, and a pattern.
- TemplateTranslator and TemplateBuffer are used to
parse the template grammar and don't need to be used usually.
- A TemplateProposal can be
offered in content assist, possibly created by a subclass of TemplateCompletionProcessor.
- TemplateStore and ContextTypeRegistry manage a
set of templates within a plug-in and offer ways to store them in the
preferences or externally in XML streams via a TemplateReaderWriter.
- ContributionTemplateStore and ContributionContextTypeRegistry
add awareness for the org.eclipse.ui.editors.templates
extension point.
- TemplatePreferencePage allows
the user to access the templates within a TemplateStore.
Example
See the Template Editor Example in the org.eclipse.ui.examples.javaeditor project.
|
org.eclipse.text.edits |
Text Edits
Provides support for describing and applying textual document editions.
A complex textual edition can be described by a tree of TextEdits. An edit
can be applied to an IDocument by calling TextEdit.apply or by
using a TextEditProcessor. Applying a text edit can record a reverse edit
description that can be used to undo the edition.
Use the standard edit kinds to describe the basic document editing operations:
- replace a document range: ReplaceEdit
- delete a document range: DeleteEdit
- insert text: InsertEdit
- track a range while the document is being modified: RangeMarker
Other subclasses of TextEdit exist for specialized tasks. Use MultiTextEdit to
compose a complex edit tree, or subclass it to provide a custom edit.
|
org.eclipse.text.tests | |
org.eclipse.text.tests.link | |
org.eclipse.text.tests.templates | |
org.eclipse.text.undo |
Document Undo Support
Provides undo and redo support for a document.
Package Specification
When an IDocumentUndoManager is connected to an IDocument,
any change to the document is recorded and can then be undone and redone later.
Clients which are interested in undo/redo events can register an IDocumentUndoistener
with the IDocumentUndoManager.
|