Presenting Java elements in a JFace viewer
The JDT UI API provides classes that allow you to present the Java model or parts
of it in a standard JFace viewer. This functionality is provided primarily by:
Content and label providers for JFace viewers are described in detail in
If you understand the basic platform mechanism, then putting the Java content
and label providers together is quite simple:
TreeViewer viewer= new TreeViewer(parent);
// Provide members of a compilation unit or class file
ITreeContentProvider contentProvider= new StandardJavaElementContentProvider(true);
// There are more flags defined in class JavaElementLabelProvider
ILabelProvider labelProvider= new JavaElementLabelProvider(
// Using the Java model as the viewers input present Java projects on the first level.
The example above uses a Java model (
as the input element for the viewer. The
IPackageFragment, and IFolder as input elements:
Overlaying images with Java information
JavaElementImageDescriptor can be used to create an image based on an
arbitrary base image descriptor and a set of flags specifying which Java specific
adornments (e.g. static, final, synchronized, ....) are to be superimposed
on the image.
Adding problem and override decorators
When a viewer is supposed to include problem annotations, the JFace DecoratingLabelProvider
together with the
is used. The snippet below illustrates the use of
a problem label decorator.
DecoratingLabelProvider decorator= new DecoratingLabelProvider(labelProvider, new ProblemsLabelDecorator());
In the same way the
OverrideIndicatorLabelDecorator can be used to decorate a normal label provider
to show the implement and override indicators for methods.
Updating the presentation on model changes
listen to model changes. Hence, the viewer doesn't update its presentation if
the Java or resource marker model changes. The reason for pushing the update
onto the client for these classes is that there isn't yet a generic implementation
that fulfills all performance concerns. Handling Java model delta inspection
and viewer refreshing in each label decorator or provider would lead to multiple
delta inspections and unnecessary viewer updates.
So what does the client need to do in order to update their viewers ?
OverrideIndicatorLabelDecorator: the client must listen to
Java model changes (see
Responding to changes in Java elements)
and decide if the change(s) described by the delta invalidates the override
indicator of elements presented in the viewer. If so, the class inspecting
the delta should trigger a repaint of the corresponding Java elements using
the standard JFace viewer API (see update methods on StructuredViewer).
ProblemsLabelDecorator: the client should listen to changes
notified by the decorator via a
ProblemsLabelChangedEvent (see also
ProblemsLabelDecorator.addListener ). Since the marker model is resource
based, the listener has to map the resource notifications to its underlying
data model. For an example showing how to do this for viewers presenting Java
elements see the internal classes
For the same reasons enumerated for label decorators the
doesn't listen to model changes. If the viewer needs to update its presentation
according to Java model changes, then the client should add a corresponding
listener to JavaCore. If the change described by the delta invalidates the structure
of the elements presented in the viewer then the client should update the viewer
using the standard JFace API (see refresh methods on StructuredViewer, and the
add and remove methods on TableViewer and AbstractTreeViewer).
Sorting the viewer
JavaElementSorter can be plugged into a JFace viewer to sort Java elements
according to the Java UI sorting style.