## Perspectives

We've already seen some ways the workbench allows the user to control the appearance of plug-in functionality. Views can be hidden or shown using the Window >Show View menu. Action sets can be hidden or shown using the Window >Customize Perspective... menu. These features help the user organize the workbench.

Perspectives provide an additional layer of organization inside a workbench window. Users can switch between perspectives as they move across tasks. A perspective defines a collection of views, a layout for the views, and the visible action sets that should be used when the user first opens the perspective.

Perspectives are implemented using IPerspectiveFactory. Implementors of IPerspectiveFactory are expected to configure an IPageLayout with information that describes the perspective and its perspective page layout.

### Workbench part layout

One of the main jobs of an IPageLayout is to describe the placement of the editor and the views in the workbench window. Note that these layouts are different than the Layout class in SWT. Although IPageLayout and Layout solve a similar problem (sizing and positioning widgets within a larger area), you do not have to understand SWT layouts in order to supply a perspective page layout.

A perspective page layout is initialized with one area for displaying an editor. The perspective factory is responsible for adding additional views relative to the editor. Views are added to the layout relative to (top, bottom, left, right) another part. Placeholders (empty space) can also be added for items that are not initially shown.

To organize related views and reduce clutter, you can use IFolderLayout to group views into tabbed folders. For example, the Resource perspective places the resource navigator inside a folder at the top left corner of the workbench. Placeholders are commonly used with folder layouts. The Resource perspective defines a placeholder for the bookmarks view in the same folder as the resource navigator. If the user shows the bookmarks view, it will appear in the same folder with the navigator, with a tab for each view.

IPageLayout also allows you to define the available actions and shortcuts inside a perspective.

- addActionSet is used to add action sets to a perspective.
- addNewWizardShortcut adds a new entry to the File >New menu for a perspective.
- addShowViewShortcut adds the names of views that should appear in the Window >Show View menu when the perspective is active.
- addPerspectiveShortcut adds the names of perspectives that should appear in the Window >Open Perspective menu when the perspective is active.

### Linking views and editors with "show-in"

Another valuable service provided by perspectives and the IPageLayout is to aid in navigation between an editor and its related views. We typically think of views as helping the user find the objects to work with in editors. However, the converse operation is also useful: a user working with an object in an editor may need to navigate to that object inside a view. This can be accomplished using the workbench Navigate > Show In menu. This command allows the user to jump to one of any number of related views in the context of the currently edited (or selected) object. For example, a user editing a file may want to jump over to that file in the resource navigator.

The plug-in architecture of the workbench allows developers to contribute views and editors in different plug-ins that are not even aware of each other. By implementing support for "show in," your view or editor can support convenient navigation to or from the views and editors contributed by other plug-ins.

This navigation allows users to move quickly between views and to easily open a view that is not usually shown in a particular perspective. For example, a user working in the Java perspective can use Navigate > Show In to view the currently edited Java file in the Navigator view.

#### Show-in source

If you want to allow users to use Navigate > Show In from your editor or view to jump to another view, you must implement IShowInSource. Your part can supply its IShowInSource directly using protocol (getShowInSource()) or as an adapter. IShowInSource allows your part to supply a context (ShowInContext) which is used by the target to decide how to show the source. The show in context for an editor is typically its input element. For a view, the context is typically its selection. Both a selection and an input element are provided in a ShowInContext to give the target flexibility in determining how to show the source.

A default context for editors is provided, so that your editor can participate in "show-in" without any special coding. For editors, the input element and selection are used to create an appropriate context.

For views, IShowInSource must be implemented by the view in order to offer Navigate > Show In functionality.

#### Show-in target

You must implement IShowInTarget if you want your view to be a valid target for a "show in" operation. The target is responsible for showing a given context in a manner appropriate for its presentation. For example, the Navigator view expands its tree to select and reveal a resource specified in the context.

A target should check the selection in the ShowInContext first in deciding what to show, since this is the more specific information. It should show the input element only if no selection is indicated.

#### Presenting appropriate targets

How is the list of available targets determined? You can specify the available targets for your perspective in its IPageLayout. Recall that a "show in" navigation may open a view that is not already present in the perspective. Using IPageLayout.addShowInPart, you can specify a valid "show in" target by id. In this way, the valid targets can be established without unnecessarily creating any views.