All Classes and Interfaces
Class
Description
The base implementation for tools which create a connection.
The base implementation for 
ConnectionEditPart.The baseline implementation for the 
EditPart interface.Iterates over a 
List of EditPolcies, skipping any
 null values encountered.The base implementation for EditPartViewer.
The default implementation of 
EditPolicy.Default implementation for 
GraphicalEditPart.Base implementation for handles.
The base implementation for 
Tools.Allows the user to access mouse and keyboard input.
An abstract implementation of 
TransferDragSourceListener
 associated with an EditPartViewerAn abstract implementation of TransferDropTargetListener for use with
 
EditPartViewers.Deprecated.
Use TreeContainerEditPolicy
Default implementation for 
TreeEditParts used in GEF
 TreeViewers.This class provides keyboard accessibility support for Anchors.
This class provides Accessibility support for 
EditParts.Contributes actions to the workbench. !!
A container for editor actions.
An action to align the selected parts.
A request to align multiple objects.
A helper returned from a 
GraphicalEditPart.Used with EditPartViewers to find the AutoexposeHelper at a Point.
A BendpointHandle that is used to create a new bendpoint.
Used to add bendpoint handles on a 
ConnectionEditPart.A handle for bendpoints on a connection.
A BendpointHandle that is used to move an existing bendpoint.
A request to alter a bendpoint.
Constraint for placing 
CellEditors.A Request to change the bounds of the EditPart(s).
This action toggles the "Use Large Icons" option for the current layout mode
 of the palette.
A GEF clipboard for cut/copy/paste actions between GEF editors.
A combination of a 
PaletteTemplateEntry and ToolEntry.An Abstract implementation of 
Command.An implementation of a command stack.
Instances of this class are sent whenever stack events occur.
A listener interface for receiving notification before and after commands are
 executed, undone, or redone.
Deprecated, for removal: This API element is subject to removal in a future version.
Use 
CommandStackEventListener instead and filter for
             post-events using CommandStack.POST_MASK.A model-based EditPolicy for components within a container.
An aggregation of multiple 
Commands.Combines multiple SnapToHelpers into one compound helper.
A tracker for creating new bendpoints or dragging existing ones.
The default creation tool for connections.
A palette ToolEntry for a
 
ConnectionCreationTool.A connection creation tool that implements DragTracker.
A specialization of 
GraphicalEditPart for
 representing connections.A model-based EditPolicy for connections.
Deprecated.
A selection handle policy for placing handles at the two ends of a
 ConnectionEditPart.
A handle used at the start or end of the
 
Connection.A DragTracker that moves the endpoint of a connection to another location.
The base implementation for handles used with editparts whose figure is a
 
Connection.Deprecated.
For use with 
LayoutManager that require a constraint.An EditPolicy for use with container editparts.
A adapter for an outline page containing a single EditPartViewer.
Extends MenuManager to allow populating the menu directly from the manager
 itself.
Deprecated.
Use org.eclipse.ui.actions.ActionFactory instead
Copies the currently selected template in the palatte to the system
 clipboard.
Deprecated.
this class is no longer used
A Request to create a new Connection.
An Action that creates a guide on a ruler and reveals it.
A Request to create a new object.
A factory used to create new objects.
The CreationTool creates new 
EditParts via a
 CreationFactory.A palette ToolEntry for a 
CreationTool.This action launches the PaletteCustomizerDialog for the given palette.
A default implementation of 
EditDomain.This is a default implementation of the 
EntryPage interface.This is the default implementation for PaletteViewerPreferences.
A DragSourceListener that maintains and delegates to a set of
 
TransferDragSourceListeners.A 
DropTargetListener that manages and delegates to a set of
 TransferDropTargetListeners.An action to delete selected objects.
A DragTracker whose job it is to deselect all 
EditParts.An action to perform direct editing on a selected part.
Manages the direct edit operation by creating and maintaining the
 
CellEditor and executing the resulting
 command if the cell editor value has changed.The border used to 'frame' the cell editor.
Shows DirectEdit feedback and creates the Command to perform a "direct edit".
A request to perform direct editing on the receiver of the Request.
Marks objects that should be disposed of when no longer in use.
A special event dispatcher that will route events to the 
EditDomain
 when appropriate.A DragTracker that moves 
EditParts.A specialization of Tool that is used by the
 
SelectionTool during a Mouse Drag.Specializes selection to do nothing, the native Tree provides selection for
 free.
The default entry page for drawers.
A request that requires a location in order to drop an item.
The collective state of a GEF "application", loosely defined by a
 CommandStack, one or more EditPartViewers, and the active Tool.
EditParts are the building blocks of GEF Viewers.
A factory for creating new EditParts.
The listener interface for receiving basic events from an EditPart.
Listeners interested in just a subset of Events can extend this stub
 implementation.
Utility class comprising functions related to 
EditPartsAn object which evaluates an EditPart for an arbitrary property.
A pluggable contribution implementing a portion of an EditPart's behavior.
An 
EntryPage displays properties of a PaletteEntry.An 
EntryPageContainer allows an EntryPage to report
 errors to it.An adapter on an 
EditPart used to expose a descendant
 contained in that EditPart.Helps display connection feedback during drags of the connection ends.
A structure for storing multiple flags compactly using a 32-bit
 
int.An EditPolicy for use with 
FlowLayout.The FlyoutPaletteComposite is used to show a flyout palette alongside another
 control.
FlyoutPreferences is used to save/load the preferences for the flyout
 palette.
A Request to be forwarded to another EditPart.
A CompoundCommand that performs undo on its contained Commands in the same
 order in which they were executed.
A graphical root that uses 
FreeformFigures as the layers in the diagram.Deprecated.
in 3.1 This class will be removed in future releases.
Defines the names of those actions which are preregistered with the
 
GraphicalEditor.A collection of color-related constants.
Deprecated.
The GEF plugin class must not be referenced by clients.
This class serves as a quick starting point for clients who are new to GEF.
This class serves as a quick starting point for clients who are new to GEF.
This class serves as a quick starting point for clients who are new to GEF.
A Specialization of 
EditPart for use with GraphicalViewers.A 
GraphicalEditPolicy is used with a GraphicalEditPart.A GraphicalNodeEditPolicy is responsible for creating and reconnecting
 connections graphically.
Deprecated.
this class will be deleted, use ScrollingGraphicalViewer with
             ScalableRootEditPart instead
Specializes 
EditPartViewer adding the ability to hit-test
 Handles.An EditPartViewer implementation based on 
Figures.An extended KeyHandler which processes default keystrokes for common
 navigation in a GraphicalViewer.
This is a layer that displays the grid.
A Request from multiple EditParts.
This is a layer where the guide lines are displayed.
An interface used by the 
SelectionTool to
 obtain a DragTracker.Identifies figures which use an alternative rectangle to place their handles.
Should be implemented by EditParts, to which an
 
ScrollableSelectionFeedbackEditPolicy is to be registered, as it
 grants the edit policy type-safe access to the edit part's
 IScrollableFigure.The KeyHandler should handle all normal keystrokes on an
 
EditPartViewer.Encapsulates a Keyboard gesture (press or release) from the User.
The constants used to identify typical layers in a graphical application.
Responsible for locating layers in a 
GraphicalViewer.A static helper
This action allows to switch between the various supported layout modes for
 the given palette.
Provides support for interacting with children
 
GraphicalEditParts with the host figure's current
 LayoutManager.A Request that needs to keep track of a location.
A marqueeSelectionTool that implements the DragTracker interface.
A Tool which selects multiple 
EditParts inside a rectangular area of
 a Graphical Viewer.A palette ToolEntry for a 
MarqueeSelectionTool.An action that matches the height of all selected EditPart's Figures to the
 width of the Primary Selection EditPart's Figure.
A LabelRetargetAction for MatchHeightAction.
An action that matches the size of all selected EditPart's Figures to the
 size of the Primary Selection EditPart's Figure.
A LabelRetargetAction for MatchSizeAction.
An action that matches the width of all selected EditPart's Figures to the
 width of the Primary Selection EditPart's Figure.
A LabelRetargetAction for MatchWidthAction.
MouseWheelHandlers can be
 
registered
 on an EditPartViewer with keys generated by the KeyGenerator.A utility class used to generate keys from a given stateMask.
MouseWheelHelpers provide each EditPart to handle mouse-wheel events in their
 own desired way.
A MouseWheelHandler that zooms the given viewer.
A Handle used for moving 
GraphicalEditParts.A Locator used to place 
MoveHandles.A specialized 
GraphicalEditPart that supports both target
 and source ConnectionEditParts.The listener interface for receiving Connection events from EditParts that
 serve as connection nodes.
Provide support for selecting and positioning a non-resizable editpart.
Deprecated.
this handle type is no longer used
A set of utility methods to create Handles for NonResizable Figures.
A LayoutEditPolicy for use with 
LayoutManagers that take no
 constraints.Default colors used by the 
PaletteViewer which are used when painting
 the palette figures.Default implementation of PaletteContainer
Abstract factory for 
PaletteContainersProvides the context menu for a palette.
PaletteCustomizationActions are used to manipulate the palette
 model.PaletteCustomizer is the PaletteCustomizerDialog's
 interface to the model.This class implements a default dialog that allows customization of the
 different entries/items on a GEF palette, i.e. the model behind the palette.
A PaletteDrawer is a collapsible container that can have other non-container
 palette entries.
Factory to create 
categoriesFactory to create EditParts for different PaletteEntries.
Root class (statically) for the palette model.
A PaletteEntryFactory creates certain type of
 
PaletteEntries.A PaletteGroup consists of a group of
 
PaletteEntry objects that are uncollapsible .Factory to create 
groupsListens to changes in the palette.
An interface representing a page to be used in the PaletteView.
Serves as the root 
PaletteEntry for the
 palette model.A separator for the palette 
 
Separators can also be used as markers.
Separators can also be used as markers.
Factory to create 
PaletteSeparators.The model object for a PaletteStack - A stack of tools.
Factory to create 
PaletteStackA PaletteGroup consists of a group of
 
PaletteEntry objects that are uncollapsible .The GEF palette view
Graphical viewer for the GEF palette.
KeyHandler for the 
Palette.The default page for the PaletteView that works in conjunction with a
 PaletteViewerProvider.
PaletteViewerPreferences is used to store/persist the various
 settings of a GEF palette.PaletteViewerProvider provides a standard way of creating palette viewers
 that can be shared across different clients that need to create a palette
 (PaletteViewerPage and FlyoutPaletteComposite, for instance).
A subclass of the SelectionTool that allows panning by holding down the space
 bar.
A ToolEntry for a 
PanningSelectionTool.Deprecated.
Use org.eclipse.ui.actions.ActionFactory instead
If the current object on the clipboard is a valid template, this action will
 paste the template to the viewer.
An action that can be used to pin the given pinnable palette editpart (drawer
 or stack) open.
A Request to reconnect a connection.
An action to redo the last command.
Similar to 
RelativeLocator, but adds support for
 the HandleBounds interface.An Object used to communicate with EditParts.
The set of constants used to identify 
Requests by their
 type.Provides support for selecting, positioning, and resizing an edit part.
A set of utility methods to create Handles for the common locations on a
 figure's bounds.
A Handle used to resize a GraphicalEditPart.
A Tracker for dragging a resize handle.
The root component cannot be removed from its parent.
A RootEditPart is the root of an EditPartViewer.
The root editpart for a 
TreeViewer.RulerChangeListeners can be added to RulerProviders
 to receive notification about changes in the ruler/guide properties.Stub for the RulerChangeListener interface.
A RulerComposite is used to show rulers to the north and west of the control
 of a given 
graphical
 viewer.This class provides an interface to interact with the ruler/guide feature
 provided in GEF.
An action to save the editor's current state.
Adds Zoom support to the standard FreeformGraphicalRootEditPart.
A graphical root composed of regular 
Layers.A 
SelectionEditPolicy, which may be registered to an
 IScrollableEditPart to provide primary selection feedback by
 rendering the hidden contents of the host figure's ScrollPane's
 nested Viewport by means of GhostImageFigures.A Graphical Viewer implementation which uses a
 
FigureCanvas for native scrolling.An action which selects all edit parts in the active workbench part.
DragTracker used to select, edit, and open 
EditParts.Superclass for an action needing the current selection.
A GraphicalEditPolicy that is sensitive to the host's selection.
A SelectionEditPolicy which manages a List of handles provided by the
 subclass.
Manages a viewer's selection model.
A request to select an edit part.
A utility for synchronizing the selection of multiple EditPartViewers.
Tool to select and manipulate figures.
A ToolEntry for a 
SelectionTool.This action sets a Tool to be the active entry in the PaletteViewer.
A command used to set or reset the value of a property.
An action to launch the Settings dialog for the given palette.
A shared collection of Cursors.
A class containing shared Images and ImageDescriptors for use by clients.
This class contains UI strings (translated, if available) that clients can
 use.
A simple drag tracker implementation that does not perform targeting.
A simple CreationFactory that takes a Class in the constructor and creates a
 new instance of this Class in 
SimpleFactory.getNewObject().Holds on to the object being transferred in a field so that
 DropTargetListeners can know what's being dragged before the drop occurs.
Default implementation of RootEditPart for GraphicalViewers.
An EditPolicy that is used to show snap feedback for guides (red lines) and
 geometry (blue lines).
A temporary helper used to perform snapping to existing elements.
A vertical or horizontal snapping point. since 3.0
A helper used to perform snapping to a grid, which is specified on the
 graphical viewer via the various properties defined in this class.
A helper used to perform snapping to guides.
A helper used temporarily by Tools for snapping certain mouse interactions.
A small square handle approximately 7x7 pixels in size, that is either black
 or white.
Superclass for actions needing access to the stack.
The base implementation for tools which perform targeting of editparts.
A request that involves a target EditPart.
Transfer object used to transfer the template of a palette tool.
Allows a single 
PaletteTemplateEntry to be
 dragged from an EditPartViewer.Performs a native Drop using the 
TemplateTransfer.An action that toggles the grid.
An action that toggles the ruler
 
visibility property on the given viewer.An action that toggles the
 
snap to geometry
 property on the given viewer.A factory for returning Tools.
Utilities for 
Tools.Deprecated, for removal: This API element is subject to removal in a future version.
use org.eclipse.jface.util.TransferDragSourceListener instead
Deprecated, for removal: This API element is subject to removal in a future version.
use org.eclipse.jface.util.TransferDropTargetListener instead
An EditPolicy for handling ADDS, MOVES, and CREATES on a 
TreeEditPart
 .A Specialization of 
EditPart for use with
 TreeViewer.An EditPartViewer implementation based on a
 
Tree.
 UndoablePropertySheetEntry provides undo support for changes made to
 IPropertySources by the PropertySheetViewer.
PropertySheetPage extension that allows to perform undo/redo of property
 value changes also in case the editor is not active.
An action to undo the last command.
A Command which can never be executed
Indicate the support of an update method.
An implementation of 
AutoexposeHelper that performs
 autoscrolling of a Viewport figure.An implementation of 
ExposeHelper for use with editparts using a
 Viewport.ViewportMouseWheelHelper is the default MouseWheelHelper that should be used
 to scroll edit parts.
Base class for actions involving a WorkbenchPart.
An EditPolicy for use with 
Figures in XYLayout.A ControlContribution that uses a 
Combo as
 its controlManage the primary zoom function in a graphical viewer.