You are on page 1of 37


UI framework for plug-ins

JFace provides classes for handling

common UI programming tasks:

Viewers handle the drudgery of populating,

sorting, filtering, and updating widgets.
Actions and contributions introduce
semantics for defining user actions and
specifying where to make them available.
Image and font registries provide common
patterns for handling UI resources.
Dialogs and wizards define a framework for
building complex interactions with the user.

JFace and the workbench

The workbench attempts to remain "JFace

neutral" wherever possible, allowing
programmers to use the parts of JFace
they find useful.
For example, the workbench part model (
IWorkbenchPart) is designed to be
independent of JFace.
For example, the JFace interfaces for
IMenuManager, IToolBarManager, and
IStatusLineManager show up as types
in the workbench IActionBar methods.

JFace and SWT

JFace is designed to provide common

application UI function on top of the
SWT library.
JFace does not try to "hide" SWT or
replace its function.
It provides classes and interfaces that
handle many of the common tasks
associated with programming a dynamic
UI using SWT.


Viewers act as adapters on SWT widgets,

handling the common code for handling
widget events that you would otherwise
have to implement yourself.
Example: ReadmeSectionsView
public void createPartControl(Composite parent) {
viewer = new ListViewer(parent);

The term viewer does not imply that they

are only useful for implementing views.

Standard viewers

JFace provides viewers for most of the

non-trivial widgets in SWT. Viewers are
most commonly used for list, tree, table,
and text widgets.
This widget can be created implicitly by
supplying the parent Composite in a
convenience viewer constructor, or
explicitly by creating it first and supplying
it to the viewer in its constructor.

List-oriented viewers

Lists, trees, and tables share many

common capabilities from a user's point
of view, such as population with objects,
selection, sorting, and filtering.
These viewers keep a list of domain
objects (called elements) and display
them in their corresponding SWT widget.
A list viewer knows how to get a text
label from any element in the list.

It obtains the label from an ILabelProvider

which can be set on the viewer.
List viewers know how to map from the
widget callbacks back into the world of
elements known by the viewer client.
Filtering and sorting capability is handled by
designating a viewer sorter (ViewerSorter
) and/or viewer filter (ViewerFilter) for the


A ListViewer maps elements in a

list to an SWT List control.


A TreeViewer displays
hierarchical objects in an SWT
Tree widget. It handles the details
for expanding and collapsing


A TableViewer is very similar to a list

viewer, but adds the ability to view
multiple columns of information for each
element in the table.
The table viewer handles the creation and
placement of these widgets when needed
for user editing. This is done using the
CellEditor classes, such as
TextCellEditor and CheckboxCellEditor.

Text viewer

Text widgets have many common semantics

such as double click behavior, undo,
coloring, and navigating by index or line.
A TextViewer is an adapter for an SWT
StyledText widget. Text viewers provide a
document model to the client and manage
the conversion of the document to the
styled text information provided by the text

Viewer architecture

An input element is the main object

that the viewer is displaying (or editing).
A content viewer is a viewer that has a
well defined protocol for obtaining
information from its input element.
Content viewers use two specialized
helper classes, the IContentProvider
and ILabelProvider, to populate their
widget and display information about the
input element.

Viewers and the


The flexibility provided by viewers, content

providers, and label providers can be
demonstrated by looking at how the
workbench uses them.
The WorkbenchContentProvider
provides tree contents for objects that have
the IWorkbenchAdapter adapter
The WorkbenchLabelProvider is a label
provider that obtains an
IWorkbenchAdapter from an object in
order to find its text and image.

Actions and contributions

The action classes allow you to

define user commands
independently from their
presentation in the UI.
The contribution classes are used to
manage the actual UI items
representing the commands.


An action (IAction) represents a

command that can be triggered by the
end user.
Actions are typically associated with
buttons, menu items, and items in tool
When the user triggers the action in the
UI, the action's run method is invoked to
do the actual work.

You should not directly implement the

IAction interface. Instead, you should
subclass the Action class. Browse the
subclasses of this class to see many of
the common patterns for actions.
The code below implements the "About"
action. It is one of the simpler actions in
the workbench.
public void run() {
new AboutDialog(workbenchWindow.getShell()).open();

Contribution items

A contribution item (IContributionItem)

represents an item that is contributed to
a shared UI resource such as a menu or
tool bar. More specifically, it represents
an item that is contributed to a shared UI
resource such as a menu or tool bar.
You don't have to worry about creating a
contribution item when you are
contributing actions to the workbench UI.

Contribution managers

A contribution manager (
IContributionManager) represents a
collection of contribution items that will
be presented in the UI.
JFace provides contribution managers for
menus (IMenuManager), tool bars (
IToolBarManager), and status lines (
As a plug-in developer, you do not need
to implement these interfaces.

User interface resources

The org.eclipse.jface.resource
package defines classes that help
plug-ins manage UI resources such
as fonts and icons.


We've also seen code that describes images

on the fly. The following is from the readme
tool's ReadmeEditorActionBarContributor.

public ReadmeEditorActionBarContributor() {
action1 = new

Image descriptors and the


The SWT Image class represents an image

from the operating system's perspective.
Because most GUI operating systems have
a limit on the number of images that can
be open at once
By using the JFace ImageDescriptor and
ImageRegistry classes instead of the
SWT image, plug-ins can generally avoid
creating, managing, and disposing these
images directly.

Image descriptor

The ImageDescriptors class can be used

as a lightweight description of an image. It
specifies everything that is needed to
create an image, such as the URL or
filename where the image can be obtained.
ImageDescriptors do not allocate an
actual platform image unless specifically
requested using the createImage()

Image registry

The ImageRegistry class is used to keep a

list of named images. Clients can add
image descriptors or SWT images directly to
the list.
When an image is requested by name from
the registry, the registry will return the
image if it has been created, or create one
from the descriptor. This allows clients of
the registry to share images.
Images that are added to or retrieved from
the registry must not be disposed by any

Plug-in patterns for using


Specifying the image in the

Explicit creation
Image registry
Label providers
Plug-in wide image class

Specifying the image in

the plugin.xml

Where possible, specify the icon

for your plug-in's UI objects in the
plugin.xml file.
Since the icons are typically kept in
your plug-in's directory, this allows
you to specify the icons and
manage the files all in one place.

Explicit creation

Explicitly creating an image is the

best strategy when the image is
infrequently used and not shared.
The image can be created directly in
SWT and disposed after it is used.
Images can also be created explicitly
using an ImageDescriptor and
invoking the createImage() method.

Image registry

When an image is used frequently in a

plug-in and shared across many different
objects in the UI, it is useful to register the
image descriptor with an ImageRegistry.
The disadvantage of using the registry is
that images in the registry are not
disposed until the GUI system shuts down.
The class AbstractUIPlugin includes
protocol for creating a plug-in wide image

Label providers

When an icon is used frequently to

display items in a particular viewer, it
can be shared among similar items in
the viewer using a label provider.
The label provider can use any of the
previously discussed techniques to
produce an image. If you browse the
various implementations of getImage()
in the LabelProvider subclasses, you
will see a variety of approaches including
caching a single icon for objects and
maintaining a table of images by type.

Plug-in wide image class

When fine-tuning a plug-in, it is common

to experiment with all of these different
image creation patterns.
It can be useful to isolate the decision
making regarding image creation in a
separate class and instruct all clients to
use the class to obtain all images.
This way, the creation sequence can be
tuned to reflect the actual performance
characteristics of the plug-in.

Font registry

The FontRegistry class keeps a table of

fonts by their name. It manages the
allocation and disposal of the font.
It is very common to allow users to specify
their preferences for the application's
fonts in a preference page. In these
cases, the FontFieldEditor should be
used to obtain the font name from the
user, and a FontRegistry may be used to
keep the font. The FontFieldEditor is
only used in preference pages.


The class JFaceResources

controls access to common
platform fonts and images. It
maintains an internal font and
image registry so that clients can
share named fonts and images.

Long-running operations

package defines interfaces for
long-running operations that
require progress indicators or allow
user cancellation of the operation.

Runnables and progress

IRunnableWithProgress is the
interface for a long-running operation.
The run method for this interface has
an IProgressMonitor parameter that is
used to report progress and check for
user cancelation.
IRunnableContext is the interface for
the different places in the UI where
progress can be reported.

ProgressMonitorDialog implements
this interface by showing a progress
IWorkbenchWindow implements this
interface by showing progress in the
workbench window's status line.
WizardDialog implements this
interface to show long running
operations inside the wizard status line.

Modal operations

The ModalContext class is

provided to run an operation that is
modal from the client code's
When you run an operation in a
modal context, you can choose to
fork the operation in a different