All Classes and Interfaces

Class
Description
This class consists exclusively of static methods and constants that operate on sections for "about" information.
Use this annotation to act on to the list of dynamically shown entries within a DynamicMenuContributionItem.
Use this annotation to provide MMenuElements to the list of dynamically shown entries within a DynamicMenuContributionItem.
Some common functionality to share between implementations of IAction.
The common base class for all artifact repository implementations.
This class provides an abstract implementation of the AttributeCondition interface.
An event that carries with it two or more boolean values.
Common function for breakpoint organizer delegates.
A class which contributes a button to the help webapp
Abstract class for ICodeMining.
A codemining provider that can provide adapters through a context that can be set by the creator of this codemining provider.
The AbstractColumnLayout is a Layout used to set the size of a table in a consistent way even during a resize unlike a TableLayout which only sets initial sizes.
This class provides an abstract implementation of the CombinatorCondition interface.
Abstract factory for composites.
Abstract base class for all IConcurrentModel implementations.
Common function for consoles.
An AbstractContentExtensionProvider is a mechanism to provide arbitrary content extensions (e.g. contributions to anchors or element replacements).
An AbstractContextProvider is a mechanism to provide arbitrary context-sensitive help for any part of the UI.
Helper class for contributions to the org.eclipse.ui.texteditor.rulerColumns extension point.
ContributionFactories are used by the IMenuService to populate ContributionManagers.
Common super class for HandledContributionItem and DirectContributionItem
Deprecated.
As of 3.2, replaced by Platform UI's field assist support
Abstract factory for controls.
 
An AbstractCriteriaDefinitionProvider is a mechanism to provide display name for criteria attached to toc or topic.
AbstractCriteriaProvider is a mechanism for assigning criteria to ITopic and IToc elements independent of a table of contents file.
Abstract CSS Engine manage style sheet parsing and store the CSSStyleSheet into DocumentCSS.
Abstract CSS Node.
Abstract CSSParser implementation.
Abstract CSS property composite background which is enable to dispatch to well CSS Property background-color, background-image...
Abstract CSS property background which is enable to manage apply CSS Property background, background-color, background-image...
Abstract class which dispatch border CSS Property defined to call the applyCSSProperty methods CSS Properties border-color, border-style, border-width.
Abstract CSS property background which is enable to manage apply CSS Property border, border-color, border-style...
 
Abstract class which manage CSS Property composite like border:solid black 1px; It dispatch
 
Abstract class which dispatch font CSS Property defined to call the applyCSSProperty methods CSS Properties font-style, font-family, font-weight, font-size.
 
Abstract CSS Property handler.
 
 
Abstract CSS Property SWT Handler to check if the element coming from applyCSSProperty and retrieveCSSProperty methods is SWT Control.
 
CSS SWT Engine implementation which configure CSSEngineImpl to apply styles to SWT widgets.
Abstract base class for converters.
Abstract implementation of a debug command handler.
Abstract implementation of a debug context provider.
Common function for views related to debugging.
An intermediate editor comprising functionality not present in the leaner AbstractTextEditor, but used in many heavy weight (and especially source editing) editors, such as line numbers, change ruler, overview ruler, print margins, current line highlighting, etc.
Preference constants used in the extended text editor preference store.
This class provides an abstract implementation of the DescendantSelector interface.
Abstract default implementation of IDocument and its extension interfaces IDocumentExtension, IDocumentExtension2, IDocumentExtension3, IDocumentExtension4, as well as IRepairableDocument.
An abstract implementation of a sharable document provider.
Operation created by the document provider and to be executed by the providers runnable context.
An abstract class to select elements out of a list of elements.
This class provides an abstract implementation of the ElementSelector interface.
Abstract base class that provides the enabled state, where changing the state fires the HandlerEvent.
The abstract superclass of field editors used to set an encoding.
This internal class serves as a foundation for any handler that would like its enabled state controlled by core expressions and the IEvaluationService.
AbstractField is the abstract superclass for fields.
The abstract base class for all file info matchers.
AbstractFormPart implements IFormPart interface and can be used as a convenient base class for concrete form parts.
A view which contributes a frame to the help webapp
Abstract superclass for group marker classes.
An event fired from a NamedHandleObject.
This class is a partial implementation of IHandler.
An abstract implementation of IObjectWithState.
Abstract class representing a help display which can be used to override the Eclipse help system UI using the extension point org.eclipse.help.base.display.
Represents a scope which can be used to specify which topics are shown in the table of contents and which entries will show in the index.
Abstract base class for the help system UI.
An information control manager that shows information in response to mouse hover events.
This is the base class for custom hyperlink widget.
A hyperlink detector that can provide adapters through a context that can be set by the creator of this hyperlink detector.
This class abstracts the communications with the identity repository, and will be mainly used for ssh-agent.
An AbstractIndexProvider is a mechanism to provide arbitrary content to the keyword index.
An abstract information control that can show content inside a shell.
Manages the life cycle, visibility, layout, and contents of an IInformationControl.
Constitutes entities to enumerate anchors for the layout of the information control.
Interface of an information control closer.
Abstract class for inlined annotation.
Base class for adding controls to cheat sheet items.
AbstractItemFactory<F extends AbstractItemFactory<?,?,?>,I extends Item,P extends Widget>
Abstract factory for items.
An abstract implementation of a key formatter that provides a lot of common key formatting functionality.
Common function for launch configuration tabs.
Common function for launch configuration tab groups.
Abstract implementation of an action that displays a drop-down launch history for a specific launch group.
A launch history action that also includes launch shortcut actions (run/debug as), and an action to open the launch configuration dialog.
Abstract implementation of ILineTracker.
Combines the information of the occurrence of a line delimiter.
Representation of replace and set requests.
Abstract base class for viewers that contain lists of items (such as a combo or list).
Abstract implementation of a marker-based annotation model.
Abstract implementation of a memory rendering.
Common function for a dynamic memory rendering bindings provider.
The common base class for all metadata repositories.
A class that encapsulates the persisted state of a repository.
A AbstractMultiEditor is a composite of editors.
An event fired from a NamedHandleObject.
 
 
Subclasses should override at least get(int index) and size().
This class is thread safe.
Abstract implementation of IObservableSet.
This class is thread safe.
Abstract implementation for an undoable operation.
An abstract implementation of a section in a tab that overrides the tabs that are provided by the tabbed property registry with a new list of tabs.
Supports conversion between objects and strings for command parameter values.
Abstract class used to aid in default preference value initialization.
Abstract class which can be used to help provide an alternate storage mechanism for Eclipse preferences.
An abstract implementation of a section in a tab in the tabbed property sheet page.
 
Abstract implementation of IReconciler.
Abstract implementation of a reconcile step.
Partial implementation of a resource mapping for a refactoring descriptor object.
Partial implementation of a resource mapping for a refactoring history object.
AbstractRepository defines common properties that may be provided by various kinds of repositories.
Partial implementation of a refactoring-aware resource mapping merger.
Abstract class resources registry which implement basic cache with Map.
An implementation of IResourceVariantTree that provides the logic for refreshing the tree and collecting the results so they can be cached locally.
Abstract class for a reusable information control creators.
This class serves as an adapter for actions contributed to the vertical ruler's context menu.
Abstract implementation of a IVerticalRulerColumn that uses a Canvas to draw the ruler contents and which handles scrolling and mouse selection.
This class is responsible for handling any pre or post search processing events, including query manipulation and output to the search frame.
An abstract implementation of a section descriptor for the tabbed property view.
The abstract implementation of a selection dialog.
A factory for creating services for use with the org.eclipse.ui.services extension point.
This class provides an abstract implementation of the SiblingSelector interface.
Common function for source containers.
Common implementation for source container browsers.
Common function for source container type delegates.
Directs source lookup among a collection of source lookup participants, and a common collection of source containers.
Common super class for implementations of source lookup participants.
An implementation of ISourceProvider that provides listener support.
Base class for splash implementations.
A status area provider creates an area that displays detailed information about StatusAdapter or IStatus.
Status handlers are part of the status handling facility.
Partial implementation of a refactoring-aware synchronization compare adapter.
Partial implementation of a refactoring-aware synchronization content provider.
Partial implementation of a refactoring-aware synchronization label provider.
A label provider wrapper that adds synchronization image and/or text decorations to the image and label obtained from the delegate provider.
This class is the abstract base class for all synchronize view participants.
Abstract superclass of resource scopes for SubscriberParticipant instances.
An abstract implementation of a tab descriptor for the tabbed property view.
Abstract implementation of a table rendering.
This is a widget independent class implementors of Table like widgets can use to provide a viewer on top of their widget implementations.
Abstract default implementation for ITemplatesPage.
Abstract base implementation of a text editor.
Implements the ruler column support of for the given editor.
Maps an action definition id to an StyledText action.
This text editor's savable.
Abstract implementation of a rendering that translates memory into text, displayed in a table.
An abstract base implementation for text-match based search results.
An abstract base implementation for classes showing AbstractTextSearchResult instances.
An AbstractTocProvider is a mechanism to provide arbitrary content to the table of contents (TOC).
Abstract base implementation for tree-structure-oriented viewers (trees and table trees).
This extension to the IWidget interface allows clients adding elements to the trim to receive notifications if the User moves the widget to another trim area.
Default implementation of a type mapper.
Abstract base class for plug-ins that integrate with the Eclipse platform UI.
This class is thread safe.
A view which contributes a view to the help webapp
 
Clients that supply implementation of the workbench browser support should extend this class for web browser instances they manage.
AbstractWidgetFactory<F extends AbstractWidgetFactory<?,?,?>,W extends Widget,P extends Widget>
Abstract factory for widgets.
Implements IWorkbenchBrowserSupport while leaving some methods to the implementors.
Extension for trim widgets contributed to the workbench.
Abstract baseclass for IWorkingSet implementations.
Abstract implementation of IWorkingSetManager.
An AbstractWorkspaceOperation represents an undoable operation that affects the workspace.
Class ACC contains all the constants used in defining an Accessible object.
Filter that accepts everything.
AcceptLicensesWizardPage shows a list of the IU's that have licenses that have not been approved by the user, and allows the user to approve them.
Instances of this class provide a bridge between application code and assistive technology clients.
This adapter class provides default implementations for the methods in the AccessibleActionListener interface.
Instances of this class are sent as a result of accessibility clients sending AccessibleAction messages to an accessible object.
Classes which implement this interface provide methods that handle AccessibleAction events.
This adapter class provides default implementations for the methods described by the AccessibleListener interface.
This adapter class provides default implementations for the methods in the AccessibleAttributeListener interface.
Instances of this class are sent as a result of accessibility clients sending AccessibleAttribute messages to an accessible object.
Classes which implement this interface provide methods that handle AccessibleAttribute events.
This adapter class provides default implementations for the methods described by the AccessibleControlListener interface.
Instances of this class are sent as a result of accessibility clients sending messages to controls asking for detailed information about the implementation of the control instance.
Classes that implement this interface provide methods that deal with the events that are generated when an accessibility client sends a message to a control.
This adapter class provides default implementations for the methods in the AccessibleEditableTextListener interface.
Instances of this class are sent as a result of accessibility clients sending AccessibleEditableText messages to an accessible object.
Classes which implement this interface provide methods that handle AccessibleEditableText events.
Instances of this class are sent as a result of accessibility clients sending messages to controls asking for information about the control instance.
This adapter class provides default implementations for the methods in the AccessibleHyperlinkListener interface.
Instances of this class are sent as a result of accessibility clients sending AccessibleHyperlink messages to an accessible object.
Classes which implement this interface provide methods that handle AccessibleHyperlink events.
Classes that implement this interface provide methods that deal with the events that are generated when an accessibility client sends a message to a control.
This adapter class provides default implementations for the methods in the AccessibleTableListener interface.
This adapter class provides default implementations for the methods in the AccessibleTableCellListener interface.
Instances of this class are sent as a result of accessibility clients sending AccessibleTableCell messages to an accessible object.
Classes which implement this interface provide methods that handle AccessibleTableCell events.
Instances of this class are sent as a result of accessibility clients sending AccessibleTable messages to an accessible object.
Classes which implement this interface provide methods that handle AccessibleTable events.
This adapter class provides default implementations for the methods described by the AccessibleTextListener interface.
Instances of this class are sent as a result of accessibility clients sending AccessibleAttribute or AccessibleEditableText messages to an accessible object.
Instances of this class are sent as a result of accessibility clients sending messages to controls asking for detailed information about the implementation of the control instance.
This adapter class provides default implementations for the methods in the AccessibleTextExtendedListener interface.
Classes which implement this interface provide methods that handle AccessibleTextExtended events.
Classes that implement this interface provide methods that deal with the events that are generated when an accessibility client sends a message to a control.
This adapter class provides default implementations for the methods in the AccessibleValueListener interface.
Instances of this class are sent as a result of accessibility clients sending AccessibleValue messages to an accessible object.
Classes which implement this interface provide methods that handle AccessibleValue events.
The standard abstract implementation of an action.
Public base class for configuring the action bars of a workbench window.
An ActionContext represents the context used to determine which actions are added by an ActionGroup, and what their enabled state should be.
A contribution item which delegates to an action.
Abstract base implementation of IActionDelegate and IActionDelegate2 for a client delegate action.
When 'action' tag is found in the registry, an object of this class is created.
An ActionExpression is used to evaluate the enablement / visibility criteria for an action.
Access to standard actions provided by the workbench.
Interface for a workbench action.
An ActionGroup represents a group of actions which are added to a context menu, or the action bars of a part, together.
This class adapts instances of IAction to IHandler.
Manage the configurable actions for one window.
This class represents the action bars for an action set.
This class marks a sub contribution item as belonging to an action set.
Maintains a reference counted set of action sets, with a visibility mask.
An EditorMenuManager is used to sort the contributions made by an editor so that they always appear after the action sets.
This class represents a pseudo-group defined by an action set.
An event indicating changes to the action sets in a particular workbench window.
Activates the most recently used editor in the current window.
 
 
 
This annotation can be added to injectable fields ands methods to indicate that the injected value should come from the active context.
An expression that checks the active shell variable.
Preference page that allows configuration of the activity set.
Activities preference page that primarily shows categories and can optionally show an advanced dialog that allows fine-tune adjustmenet of activities.
An instance of this class describes changes to an instance of IActivity.
An instance of this class describes changes to an instance of IActivityManager.
A modifiable list of IAdaptable objects.
An adapter can adapt an object to the specified type, allowing clients to request domain-specific behavior for an object.
 
Provides a standard way to request adapters from adaptable objects
Annotation that can be used for components to specify the provided adapter types. example use case
Standard action for adding a bookmark to the currently selected file resource(s).
 
 
Action for creating a marker of a specified type for the editor's input element based on the editor's selection.
A cascade menu to add a memory rendering to the memory view.
An implementation of the model object 'Addon'.
Standard action for adding a task to the currently selected file resource(s).
Creates a new task marker.
The Adapter Factory for the model.
An implementation of the model Factory.
The Package for the model.
Defines literals for the meta objects that represent each class, each feature of each class, each operation of each class, each enum, and each data type
An advanced section that is intended to show the original table format properties view provided by base Eclipse.
The Switch for the model's inheritance hierarchy.
This class can be used to aggregate status values from a data binding context into a single status value.
 
Class which contributes a checkbox to an intro page which allows welcome to show on startup.
 
 
Deprecated.
As of Eclipse 2.1, use ProgressBar with the style SWT.INDETERMINATE Styles:VERTICAL, HORIZONTAL, BORDER
 
 
 
Deprecated.
as of 3.3, this class is no longer used.
Annotation managed by an IAnnotationModel.
A bag of annotations.
This manager controls the layout, content, and visibility of an information control in reaction to mouse hover events issued by the vertical ruler of a source viewer.
Deprecated.
Standard implementation of IAnnotationModel and its extension interfaces.
Specification of changes applied to annotation models.
Paints decorations for annotations provided by an annotation model and/or highlights them in the associated source viewer.
Box text style strategy.
 
A drawing strategy draws the decoration for an annotation onto the text widget.
A text style painting strategy draws the decoration for an annotation onto the text widget by applying a TextStyle on a given StyleRange.
Drawing strategy that does nothing.
Deprecated.
Underline text style strategy.
An annotation preference provides all the information required for handing the preferences for the presentation of annotations of a specified type.
Provides the strategy for finding the annotation preference for a given annotation.
A vertical ruler column showing graphical representations of annotations.
Provides the strategy for determining annotation types for given markers.
The plug-in runtime class for the Ant Core plug-in.
Represents the Ant Core plug-in's preferences providing utilities for extracting, changing and updating the underlying preferences.
Entry point for running Ant builds inside Eclipse (within the same JRE).
A security exception that is thrown by the AntSecurityManager if an Ant task in some way attempts to halt or exit the Java Virtual Machine.
The Adapter Factory for the model.
This class implements permissions for manipulating applications and their instances.
An OSGi service that represents an installed application and stores information about it.
An implementation of the model object 'Element'.
This exception is used to indicate problems related to application lifecycle management.
An implementation of the model Factory.
ApplicationHandle is an OSGi service interface which represents an instance of an application.
An implementation of the model object 'Application'.
An ApplicationLauncher is used to launch ParameterizedRunnable objects using the main thread.
The Package for the model.
Defines literals for the meta objects that represent each class, each feature of each class, each operation of each class, each enum, and each data type
A parameterized runnable that can be stopped.
The Switch for the model's inheritance hierarchy.
An application window is a high-level "main window", with built-in support for an optional menu bar with standard menus, an optional toolbar, and an optional status line.
An operation that provides an interface to the Apply Patch Wizard.
Action to apply a refactoring script to the workspace.
Archive source container for an archive in the workspace.
An implementation of the model object 'Area'.
Default SWT renderer responsible for an MArea.
Instances of this class are sent as a result of a widget such as a menu item being armed.
Classes which implement this interface provide a method that deals with the event that is generated when a widget, such as a menu item, is armed.
This implementation of IStructuredContentProvider handles the case where the viewer input is an unchanging array or collection of elements.
Simple map when dealing with small amounts of entries.
 
This represents information about a given artifact stored on a particular byte server.
A general purpose query for matching IArtifactDescriptor instances that satisfy various criteria.
A general purpose query for matching IArtifactKey instances that satisfy various criteria.
An artifact repository factory is responsible for creating and loading instances of a particular type of artifact repository.
Assert is useful for for embedding runtime sanity checks in code.
AssertionFailedException is a runtime exception thrown by some of the methods in Assert.
AttributeMarkerGrouping is the configuration element for the markerAttributeGrouping extension.
An AuthenticationEvent is sent by a Browser to AuthenticationListener's when the Browser navigates to a page that requires authentication.
This listener interface may be implemented in order to receive an AuthenticationEvent notification when the Browser encounters a page that requires authentication.
AutoCompleteField is a class which attempts to auto-complete a user's keystrokes by activating a popup that filters a list of proposals according to the content typed by the user.
 
Generic "Back" action which goes back one frame,
Indicates the attempt to access a non-existing position.
Represents the attempt to refer to a non-existing document partitioning.
Indicates the attempt to access a non-existing position category in a document.
 
This class represents a base description object for a state.
BaseLabelProvider is a default concrete implementation of IBaseLabelProvider
Using this MessageRegistry allows to register controls for attributes in a Messages class.
A BaseNewWizardMenu is used to populate a menu manager with New Wizard actions for the current perspective's new wizard shortcuts, including an Other... action to open the new wizard dialog.
The abstract superclass for actions that listen to selection change events.
Tree content provider for objects that can be adapted to the interface IWorkbenchAdapter.
The Adapter Factory for the model.
The Adapter Factory for the model.
An implementation of the model Factory.
An implementation of the model Factory.
Updates a marker's positional attributes which are start position, end position, and line number.
Standard workbench wizard that create a new file resource in the workspace.
Standard workbench wizard that create a new folder resource in the workspace.
Standard workbench wizard that creates a new project resource in the workspace.
Abstract base implementation of the standard workbench wizards that create new resources in the workspace.
The Package for the model.
The Package for the model.
Defines literals for the meta objects that represent each class, each feature of each class, each operation of each class, each enum, and each data type
Defines literals for the meta objects that represent each class, each feature of each class, each operation of each class, each enum, and each data type
Basic splash implementation that provides an absolute positioned progress bar and message string that is hooked up to a progress monitor.
The Switch for the model's inheritance hierarchy.
The Switch for the model's inheritance hierarchy.
Manages the installation and removal of global actions for the same type of editors.
Merge of UIJob and WokbenchJob minus tracking whether the workbench is running - do not use for long running jobs!
Basic IWorkingSetElementAdapter implementation that allows plugins to describe simple declarative element adapters.
A factory for creating properties for Java objects that conform to the JavaBean specification for bound properties.
An
Deprecated.
This class is deprecated; use BidiObservableMap instead.
This event is sent to BidiSegmentListeners when a line is to be measured or rendered in a bidi locale.
This listener interface may be implemented in order to receive BidiSegmentEvents.
 
This class provides API to handle Base Text Direction (BTD) and Structured Text support for SWT Text widgets.
A simple compare viewer for binary files.
A factory object for the BinaryCompareViewer.
A content describer for binary formats that present some simple signature at a known, fixed offset.
This class contains static methods that are the entry points to the fluent databinding API.
This abstract class represents a binding between a model and a target.
A binding is a link between user input and the triggering of a particular command.
An implementation of the model object 'Binding Context'.
An unchecked exception indicating a binding problem.
A central repository for bindings -- both in the defined and undefined states.
An instance of this class describes changes to an instance of BindingManager.
Process contexts in the model, feeding them into the command service.
A factory for creating properties for core types in the DataBinding framework e.g.
Provide the binding and context id services as an add-on.
 
 
manage tables of bindings that can be used to look up commands from keys.
An implementation of the model object 'Binding Table'.
manage tables of bindings that can be used to look up commands from keys.
 
Standard implementation of IBlockTextSelection.
Provides StyledString.Styler that applies bold style on the given font.
Provides StyledString.Styler that applies bold style on the given font.
Adapter for the managing bookmark action.
A field editor for a boolean type preference.
The BooleanPropertyAction is an action that set the values of a boolean property in the preference store.
Controls the several aspects of a BorderLayout.
BorderLayout places controls in five regions
The branding properties are retrieved as strings, but often used as other types (e.g., java.net.URLs.
Abstract implementation of a breakpoint.
Default implementation for a breakpoint type category.
Breakpoint ruler pop-up action that creates a sub-menu to select the currently active breakpoint type.
Instances of this class implement the browser user interface metaphor.
This class provides a convenient shorthand for creating and initializing Browser.
Instances of this class represent java-side "functions" that are invokable from javascript.
Abstract implementation for a buffered IStreamContentAccessor.
A buffer for a workspace resource.
A buffered rule based scanner.
Standard actions for full and incremental builds of the selected project(s) and their references project build configurations.
Instances of this class represent bullets in the StyledText.
Object representing the bundle defaults scope in the Eclipse preferences hierarchy.
BundleDeltas represent the changes related to an individual bundle between two states.
This class represents a specific version of a bundle in the system.
A BundleEntry represents one entry of a BundleFile.
The BundleFile API is used by Adaptors to read resources out of an installed Bundle in the Framework.
A bundle file decorator.
Used to chain the BundleFile objects returned from BundleFileWrapperFactoryHook.
A class that converts the strings returned by org.eclipse.core.runtime.IBundleGroup.getProperty to the appropriate class.
Abstract implementation of IBundleImporterDelegate.
This object represents information of a bundle.
 
The interface of the service that gets ResourceBundle objects from a given bundle with a given locale.
The implementation of the service that gets ResourceBundle objects from a given bundle with a given locale.
URLStreamHandler the bundleentry and bundleresource protocols.
A representation of one bundle import constraint as seen in a bundle manifest and managed by a state and resolver.
URLConnection for BundleClassLoader resources.
The service implementation that allows bundleresource or bundleentry URLs to be converted to native file URLs on the local file system.
Support for showing a Busy Cursor during a long running process.
Instances of this class represent a selectable user interface object that issues notification when pressed and released.
CSSStylableElement implementation which wrap SWT Button.
This class provides a convenient shorthand for creating and initializing Button.
The class ByteArrayTransfer provides a platform specific mechanism for converting a java byte[] to a platform specific representation of the byte array and vice versa.
 
 
A resource variant is a partial implementation of a remote resource whose contents and handle are cached locally.
Instances of this class represent entry points into Java which can be invoked from operating system level callback routines.
Use this annotation to tag methods that determine if this object's Execute method can be called.
Instances of this class provide a surface for drawing arbitrary graphics.
Instances of this class provide an i-beam that is typically used as the insertion point for text.
This event is sent when the caret offset changes.
This listener interface may be implemented in order to receive CaretEvents.
Action that converts the current selection to lower case or upper case.
CaseInsensitiveDictionaryMap classes.
A special text edit group that manages an additional set of group categories.
A logical group for a set of commands.
An instance of this class describes changes to an instance of Category.
An instance of this class describes changes to an instance of ICategory.
An implementation of the model object 'Category'.
Instances of this class implement a Composite that lays out its children and allows programmatic control of the layout.
The CCombo class represents a selectable user interface object that combines a text field and a list and issues notification when an item is selected from the list.
Abstract base class for cell editors.
Struct-like layout data for cell editors, with reasonable defaults for all fields.
Handles the redirection of the global actions Cut, Copy, Paste, Delete, Select All, Find, Undo and Redo to either the current inline cell editor or the part's supplied action handler.
A factory for creating properties of JFace cell editors.
The CellLabelProvider is an abstract implementation of a label provider for structured viewers.
This class implementation the strategy how the table is navigated using the keyboard.
Preference store that composes multiple preference stores in a chain and serves a preference value from the first preference store in the chain that contains the preference.
An abstract base implementation for object representing a generic change to the workbench.
Toggles the activation of a compare filter
Descriptor of a change object.
Action for changing the encoding of the editor's input element.
Generic change event denoting that the state of an IObservable object has changed.
Instances of this class represent the input for an IChangePreviewViewer.
Toggles a boolean property of an CompareConfiguration.
A vertical ruler column displaying line numbers and serving as a UI for quick diff.
 
Change the perspective of the active page in the window to the selected one.
Supports the tracking of related changes for the purpose of grouping then using an IChangeGroupingRequestor.
 
Deprecated, for removal: This API element is subject to removal in a future version.
Please use org.eclipse.jface.bindings.keys.KeyStroke and org.eclipse.jface.bindings.keys.KeyLookupFactory
Factory for the cheat sheet's public extensions.
For monitoring the execution of a cheat sheet.
A factory for creating a cheat sheet viewer.
A cell editor that manages a checkbox.
A concrete viewer based on an SWT Table control with checkboxes on each node.
A concrete tree-structured viewer based on an SWT Tree control with checkboxes on each node.
A context that is shared between the refactoring processor and all its associated participants during condition checking.
Operation that, when run, checks the preconditions of the Refactoring passed on creation.
A class to select elements out of a tree structure.
Event object describing a change to the checked state of a viewer element.
Implementation of a child document based on ProjectionDocument.
Implementation of a child document manager based on ProjectionDocumentManager.
Elements that implement this interface contract that only a subset of their children should be styled.
A Label which supports aligned text and/or an image and different border styles.
Class utils.
Clears the output in a text console.
The Clipboard provides a mechanism for transferring data from one application to another or within an application.
A BundleFile that manages the number of open bundle files by using the MRUBundleFileList
Closes all active editors
Closes all editors except ones with unsaved changes.
Removes a console from the console manager.
Closes the active editor.
The command handler that gets invoked when the "Close User Assistance Tray" command is invoked.
Closes all editors except the one that is active.
Standard action for closing the currently selected project(s).
This action closes all projects that are unrelated to the selected projects.
This listener interface may be implemented in order to receive a WindowEvent notification when a Browser is about to be closed and when its host window should be closed by the application.
A reconciler which update code minings.
Collapse a tree viewer.
This class allows to adapt java collections to a p2 a query result and as such something queryable
A collector is a generic visitor that collects objects passed to it, and can then express the result of the visit in various forms.
Instances of this store color information.
A cell editor that manages a color field.
 
Lightweight descriptor for an SWT color.
Instances of this class allow the user to select a color from a predefined set of available colors.
A field editor for a color type preference.
Descriptor for a property that has a color value which should be edited with a color cell editor.
A color registry maintains a mapping between symbolic color names and SWT Colors.
The ColorSelector is a wrapper for a button that displays a swatch of the selected color and allows the user to change the selection using the operating system's native color chooser dialog.
Useful color utilities.
The ColumnLabelProvider is the label provider for viewers that have column support such as TreeViewer and TableViewer
This layout manager arranges children of the composite parent in vertical columns.
An abstract column layout data describing the information needed (by TableLayout) to properly lay out a table.
This class is used to store layout data for the ColumnLayout class.
Describes the width of a table column in pixels, and whether the column is resizable.
The ColumnViewer is the abstract superclass of viewers that have columns (e.g., AbstractTreeViewer and AbstractTableViewer).
This is the base for all editor implementations of Viewers.
This event is passed on when a cell-editor is going to be activated
Parties interested in activation and deactivation of editors extend this class and implement any or all of the methods
This class is responsible to determine if a cell selection event is triggers an editor activation.
This event is fired when an editor deactivated
The ColumnViewerTooltipSupport is the class that provides tool tips for ColumnViewers.
Describes the width of a table column in terms of a weight, a minimum width, and whether the column is resizable.
Instances of this class are controls that allow the user to choose an item from a list of items, or optionally enter a new value by typing it into an editable text field.
A cell editor that presents a list of items in a combo box.
An ILabelProvider that assists in rendering labels for ComboBoxPropertyDescriptors.
Descriptor for a property that has a value which should be edited with a combo box cell editor.
A cell editor that presents a list of items in a combo box.
An IControlContentAdapter for SWT Combo controls.
Deprecated.
As of 3.2, replaced by Platform UI's field assist support
A field editor for a combo box that allows the drop-down selection of one of a list of items.
A concrete viewer based either on an SWT Combo control or CCombo control.
A command is an abstract representation for some semantic behaviour.
A contribution item which delegates to a command.
A help class for the various parameters that can be used with command contributions.
An instance of this class describes changes to an instance of Command.
Signals that an exception occured within the command architecture.
An implementation of the model object 'Command'.
A command interpreter is a shell that can interpret command lines.
 
A central repository for commands -- both in the defined and undefined states.
An event indicating that the set of defined command identifiers has changed.
Indicates that an action has no command mapping.
An implementation of the model object 'Command Parameter'.
When an object wants to provide a number of commands to the console, it should register an object with this interface.
The Adapter Factory for the model.
Provide the command and handler service as an add-on.
 
 
An implementation of the model Factory.
The Package for the model.
Defines literals for the meta objects that represent each class, each feature of each class, each operation of each class, each enum, and each data type
The Switch for the model's inheritance hierarchy.
 
Provides actions from extensions for menu and IActionBars contributions.
Provides an implementation of DragSourceAdapter which uses the extensions provided by the associated INavigatorContentService.
Assist the CommonDragAdapter by providing new TransferTypes and the logic to handle setting up the transfer data.
Provides an implementation of PluginDropAdapter which uses the extensions provided by the associated INavigatorContentService.
Used by the org.eclipse.ui.navigator.navigatorContent/navigatorContent/commonDropAdapter extension point to carry out pluggable drop operations.
 
This class provides the IViewPart for the Common Navigator framework in the Eclipse workbench.
Manages the non-viewer responsibilities of the Common Navigator View Part, including the display and population of the context menu and the registration of extensions for opening content.
Default editor displayed when source is not found.
Editor input for the CommonSourceNotFoundEditor.
Contains Step interfaces for the fluent databinding API that are common for both IObservableValue, IObservableList and IObservableSet bindings.
The last step in the binding pipeline, where the CommonSteps.BindConfigStep.bind(org.eclipse.core.databinding.DataBindingContext) method is accessible.
Step for setting the to-from converter.
Step for converting between from- and to-types.
Step for setting the direction of the binding.
Step for settings the from-end observable of one-way-bindings.
 
Step for settings the from-end observable of two-way-bindings.
Step for updating the configuration for an observable that is being written to.
Launch configuration tab used to specify the location a launch configuration is stored in, whether it should appear in the favorites list, and perspective switching behavior for an associated launch.
Provides the Tree Viewer for the Common Navigator.
Allows clients to create ICommonViewerSite for a variety of contexts.
Provides an implementation of TreeViewerSorter that uses the given parent to determine the correct sort order based on the defined org.eclipse.ui.navigator.navigatorContent/navigatorContent/commonSorter elements available in the set of visible content extensions.
 
A CompareConfiguration object controls various UI aspects of compare/merge viewers like title labels and images, or whether a side of a merge viewer is editable.
 
 
This is a dialog that can host a CompareEditorInput.
A CompareEditor takes a ICompareEditorInput as input.
 
A compare operation which can present its results in a special editor.
Supports cross-pane navigation through the differences contained in a CompareEditorInput or a similar type of compare container.
A selection provider for view parts with more that one viewer.
Describes compare filter extension.
 
Links CompareEditorInput to IFiles in the CommonNavigator.
 
Supports cross-pane navigation through the differences of a compare container.
 
 
 
 
 
The class CompareUI defines the entry point to initiate a configurable compare operation on arbitrary resources.
The Compare UI plug-in defines the entry point to initiate a configurable compare operation on arbitrary resources.
A CompareViewerPane is a convenience class which installs a CLabel and a Toolbar in a ViewForm.
A custom CompareViewerPane that supports dynamic viewer switching.
 
Deprecated.
Temporarily replaced by CompareWithOtherResourceHandler.
This is a dialog that can invoke the compare editor on chosen files.
This is a temporary replacement for CompareWithOtherResourceAction which was available from "Compare With > Other Resource...".
This class is a placeholder for utility methods commonly used on J2SE platforms but not supported on some J2ME profiles.
The standard implementation of the ICompletionProposal interface.
Instances of this class are controls which are capable of containing other controls.
Represents a composite change.
CSSStylableElement implementation which wrap SWT Composite.
 
This class provides a convenient shorthand for creating and initializing Composite.
Abstract base class for image descriptors that synthesize an image from other images in order to simulate the effect of custom drawing.
A read-only observable map formed by the composition of two observable maps.
An implementation of the model object 'Composite Part'.
A resource mapping that obtains the traversals for its model object from a set of child mappings.
Standard implementation of IVerticalRuler.
Represents an ISideEffect that is composed of a bunch of component ISideEffects.
A source container of source containers.
A compound contribution is a contribution item consisting of a dynamic list of contribution items.
Resource Filter Type allowing serializing sub filters as the arguments
A queryable that holds a number of other IQueryables and provides a mechanism for querying the entire set.
A lazily calculated list that automatically computes and registers listeners on its dependencies as long as all of its dependencies are IObservable objects.
Maps objects to one of their attributes.
A lazily calculated set that automatically computes and registers listeners on its dependencies as long as all of its dependencies are IObservable objects.
A Lazily calculated value that automatically computes and registers listeners on its dependencies as long as all of its dependencies are IObservable objects.
This is a concrete class that stores the same type of information as the IMarkers used by the IDE.
Standard implementation of a generic ILineTracker.
Allows to sort an array based on their elements' configuration elements according to the prerequisite relation of their defining plug-ins.
This class contains utility methods that clients may use to obtain information about the system configuration.
Object representing the configuration scope in the Eclipse preferences hierarchy.
Deprecated, for removal: This API element is subject to removal in a future version.
The org.eclipse.update component has been replaced by Equinox p2.
Utilities for configuring columns of trees and tables in a keyboard-accessible way.
Configures a Launch configuration Working Copy with an identifier of Test View Support extension
Default console color provider for a process.
The console plug-in class.
A console session service provides the input and output to a single console session.
 
Constants used with the EnvironmentInfo service.
CheckboxTreeViewer with special behaviour of the checked / gray state on container (non-leaf) nodes: The grayed state is used to visualize the checked state of its children.
Helper class to create a container and all missing parent containers.
For creating folder resources that currently do not exist, along a given workspace path.
A standard selection dialog which solicits a container resource from the user.
A source container for a container in the workspace.
A content assist action which gets its target from its text editor.
The standard implementation of the IContentAssistant interface.
Facade to allow minimal access to the given content assistant.
ContentAssistCommandAdapter extends ContentProposalAdapter to invoke content proposals using a specified Command.
Describes the state that the content assistant is in when completing proposals.
Deprecated.
As of 3.3, clients should use ControlDecoration and ContentAssistCommandAdapter instead of this class.
Deprecated.
As of 3.2, replaced by JFace field assist support
A helper class for managing content change notification.
Standard implementation of IContentFormatter.
ContentGeneratorDescriptor is the direct representation of the markerContentGenerator extension point.
An abstract compare and merge viewer with two side-by-side content areas and an optional content area for the ancestor.
Main class for the Content Outline View.
An abstract base class for content outline pages.
A default implementation of IContentProposal that allows clients to specify a content proposal using simple constructors.
ContentProposalAdapter can be used to attach content proposal behavior to a control.
A content provider is a marker interface that is used but the framework internally to handle different kinds of bundles.
The type of the provided content
A content stamp object represent the content of an IFile.
A content viewer is a model-based adapter on a widget which accesses its model by means of a content provider and a label provider.
A context is an answer to the question "when".
Formatting strategy for context based content formatting.
An instance of this class describes changes to an instance of IContext.
Deprecated.
Please use the "org.eclipse.core.commands" plug-in instead.
Deprecated.
Please use the "org.eclipse.core.commands" plug-in instead.
The base class for all computed value implementations.
ContextHelpDialog
 
A default implementation of the IContextInformation interface.
A default implementation of the IContextInfomationValidator interface.
An injection factory is used to inject data and services from a context into a domain object.
A context manager tracks the sets of defined and enabled contexts within the application.
An event indicating that the set of defined context identifiers has changed.
Deprecated.
Please use the "org.eclipse.core.commands" plug-in instead.
A customizer that is called by the Http Whiteboard runtime in order to allow customization of context path used for servlets, resources and filters.
 
 
 
 
Deprecated.
A registry for context types.
An action delegate that builds a context menu with applicable launch shortcuts for a specific launch mode.
For a declarative editor action, see if we can link it to a command.
Default SWT renderer responsible for an MPart.
A ContributionComparator is capable of ordering IComparableContribution instances, either as a ViewerComparator (for StructuredViewers) or as a traditional Comparator.
A registry for context types.
An implementation of the model object 'Contribution'.
Instances of this class describe a contribution of an element of a certain type to the UI.
An abstract base implementation for contribution items.
Access to standard contribution items provided by the workbench.
Abstract base class for all contribution managers, and standard implementation of IContributionManager.
 
Manages templates.
The contributor factory creates new registry contributors for use in OSGi-based registries.
The contributor factory creates new registry contributors for use in a simple registry based on the String representation of the determining object.
Control is the abstract superclass of all windowed user interface classes.
This adapter class provides default implementations for the methods described by the ControlListener interface.
ControlAnimator provides a simple implementation to display or hide a control at the bottom of the parent composite.
An abstract contribution item implementation for adding an arbitrary SWT control to a tool bar.
ControlDecoration renders an image decoration near a control.
Decorates the underlying controls of the target observables of a ValidationStatusProvider with ControlDecorations mirroring the current validation status.
Controls the appearance of a ControlDecoration managed by a ControlDecorationSupport.
A ControlEditor is a manager for a Control that appears above a composite and tracks with the moving and resizing of that composite.
CSSStylableElement implementation which wrap SWT Control.
Helper class to save the enable/disable state of a control including all its descendent controls.
Instances of this class are sent as a result of controls being moved or resized.
Classes which implement this interface provide methods that deal with the events that are generated by moving and resizing controls.
Abstract base class for converters.
Deprecated.
since 3.1.
A text file buffer operation that changes the line delimiters to a specified line delimiter.
Instances of this class provide an area for dynamically positioning the items they contain.
A cool bar manager is a contribution manager which realizes itself and its items in a cool bar control.
 
Instances of this class are selectable user interface objects that represent the dynamically positionable areas of a CoolBar.
A group marker used by EditorActionBars to delineate CoolItem groups.
Copy arguments describe the data that a processor provides to its copy participants.
Perform the copy of file and folder resources from the clipboard when paste action is invoked.
A CopyingRangeMarker can be used to track positions when executing text edits.
A copy-on-write identity map.
Copy-on-write ITextStore wrapper.
A participant to participate in refactorings that copy elements to a shared clipboard.
A special processor that performs copy operations.
The CopyProjectAction is the action designed to copy projects specifically as they have different semantics from other resources.
Implementation class to perform the actual copying of project resources from the clipboard when paste action is invoked.
A CopyProjectOperation represents an undoable operation for copying a project, also specifying the location of its contents.
A generic copy refactoring.
Standard action for copying the currently selected resources elsewhere in the workspace.
A CopyResourcesOperation represents an undoable operation for copying one or more resources in the workspace.
A copy source edit denotes the source of a copy operation.
A copy target edit denotes the target of a copy operation.
A checked exception representing a failure.
An implementation of the model object 'Core Expression'.
 
 
Specifies that the target class can be created by an injector as needed.
Create arguments describe the data that a processor provides to its create participants.
Operation that, when performed, creates a Change object for a given refactoring.
Deprecated.
should use NewWizardMenu to populate a New submenu instead (see Navigator view)
A CreateFileOperation represents an undoable operation for creating a file in the workspace.
Deprecated.
should use NewWizardMenu to populate a New submenu instead (see Navigator view)
A CreateFolderOperation represents an undoable operation for creating a folder in the workspace.
A CreateMarkersOperation represents an undoable operation for creating one or more markers on one or more resources in the workspace.
A participant to participate in refactorings that create elements.
A CreateProjectOperation represents an undoable operation for creating a project in the workspace.
Action to open the dialog to create a refactoring script from the refactoring history.
This factory can be used by login modules to create Equinox public and private credentials.
CSS2 Color Helper.
CSS2 Font Helper.
 
 
 
 
Simple CSSPrimitiveValue implementation.
w3c CSS2Properties implementation.
Simple RGBColor implementation.
This class provides an implementation of the CombinatorCondition interface.
This class provides an implementation of the AttributeCondition interface.
 
This class provides an implementation of the AttributeCondition interface.
CSS Border properties interface.
CSS2 Border Helper.
CSSBorderProperties implementation.
This class provides an implementation of the DescendantSelector interface.
This class provides an implementation of the AttributeCondition interface.
CSS computed style which concatenate list of CSSComputedStyleImpl to manage styles coming from Condition Selector (ex : Label#MyId) and other selectors (ex : Label).
This class provides an implementation of the ConditionalSelector interface.
This class provides an implementation of the ConditionFactory interface.
This class provides an implementation for the DescendantSelector interface.
This class provides an implementation for the DescendantSelector interface.
This class provides an implementation for the ExtendedDocumentHandler interface.
Context of the Element which wrap the native widget (SWT widget, Swing Component...).
 
This class implements the ElementSelector interface.
CSS Engine interface used to parse style sheet and apply styles to something (UI SWT, UI Swing...).
Helper class for retrieving CSS values for a particular control so it can be used by renderers.
 
Basic interface for CSS Engine error handlers.
Basic implementation for CSS Engine error handlers which print stack trace of the exception throwed.
 
CSSExtendedProperties implementation.
 
CSS HTML Serializer configuration used by CSSSerializer to filter the attribute type of the HTML widget like input[type='text'].
This class provides an implementation of the AttributeCondition interface.
 
This class provides an implementation of the LangCondition interface.
 
This class provides an implementation of the AttributeCondition interface.
 
CSS Parser interface to parse with SAC Parser : CSS Style sheet and return CSSStyleSheet. CSS Style declaration and return CSSStyleDeclaration. CSS value and return CSSValue. CSS rule and return CSSRule.
CSS Parser factory to manage instance of ICSSParserFactory.
CSSParserFactory implementation.
CSSParser implementation.
CSS property interface.
We support some additional SWT-specific values
 
 
 
 
 
 
 
 
 
 
 
CSS property handler with lazy strategy.
CSS property handler with static strategy.
A handler which allows the styling of IHeaderCustomizationElements.
 
 
 
 
CSS property list interface.
w3c CSSPropertyList implementation.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
CSS property to influence the minimum number of characters for rendering tab text and size Can be used in CSS Scratch Pad with the property name "swt-tab-text-minimum-characters", for example: CTabFolder { swt-tab-text-minimum-characters: 20 } Default value for the property is 1.
 
 
 
 
 
 
 
This class provides an implementation of the AttributeCondition interface.
This class implements the ElementSelector interface.
CSS Resources Helper to manage IResourcesRegistry.
 
 
This class implements the SelectorFactory interface.
CSS Serializer to retrieve default CSSStyleDeclaration of the SWT Widgets.
CSS Serializer configuration used by CSSSerializer to filter the attribute of the widget like Text[style='SWT.MULTI'].
CSS stylable element interface to wrap native widget.
 
 
 
Add SWT filter to the Display to apply styles when SWT widget is resized or showed.
 
 
 
CSS SWT Engine implementation which configure CSSEngineImpl to apply styles to SWT widgets with static handler strategy.
CSS SWT Font Helper to : get CSS2FontProperties from Font of SWT Control. get Font of SWT Control from CSS2FontProperties.
SWT Helper to transform CSS w3c object (org.w3c.dom.css.RGBColor....) into SWT object (org.eclipse.swt.graphics.Color...).
 
CSSSerializerConfiguration configuration used to get style of SWT control.
 
CSS Value converter to convert : CSS Value to Boolean Boolean to String CSS Value
CSS Value converter color config to format the CSSValue string color.
 
 
 
CSS Value converter to convert : CSS Value to Color Color to String CSS Value
 
 
CSS Value converter to convert : CSS Value to FontData FontData to String CSS Value
CSS Value converter to convert : CSS Value to Gradient Gradient to String CSS Value
 
CSS Value converter to convert : CSS Value to RGB RGB to String CSS Value
 
Instances of this class implement the notebook user interface metaphor.
This adapter class provides default implementations for the methods described by the CTabFolder2Listener interface.
Classes which implement this interface provide methods that deal with the events that are generated by the CTabFolder control.
This adapter class provides a default implementation for the method described by the CTabFolderListener interface.
CSSStylableElement implementation which wrap SWT CTabFolder.
This event is sent when an event is generated in the CTabFolder.
Classes which implement this interface provide a method that deals with events generated in the CTabFolder.
Instances of this class provide all of the measuring and drawing functionality required by CTabFolder.
Instances of this class represent a selectable user interface object that represent a page in a notebook widget.
 
 
Instances of this class manage operating system resources that specify the appearance of the on-screen pointer.
A painter the draws the background of the caret line in a configured color.
A re-usable intro part that the Eclipse platform uses for its Out of the Box Experience.
This is the handler for NextEditor and PrevEditor commands.
This handler is used to switch between perspectives using the keyboard.
This handler is used to switch between parts using the keyboard.
A DataBindingContext is the point of contact for the creation and management of bindings, and aggregates validation statuses of its bindings, or more generally, its validation status providers.
An exception indicating that a string value could not be converted into the requested data type.
An IObservableValue < Date > which supports scenarios where the date and time are presented as separate elements in the user interface.
Instances of this class are selectable user interface objects that allow the user to enter and modify date or time values.
This class provides a convenient shorthand for creating and initializing DateTime.
Action to launch the last launch configuration that was successfully launched, in debug mode.
Abstract base class for re-targeting actions which delegate execution to IDebugCommandHandler handlers.
Abstract base class for re-targeting command framework handlers, which delegate execution to IDebugCommandHandler handlers.
A debug context event.
Implementation of common function for debug elements.
Deprecated.
Custom content in the debug views is no longer supported by IWorkbenchAdapter.
A debug event describes an event in a program being debugged or in a running process.
A checked exception representing a failure.
Used to get debug options settings and creating a new DebugTrace instance for a bundle to use for dynamic tracing.
A debug options listener is notified whenever one of its plug-in option-path entries is changed.
There is one instance of the debug plug-in available from DebugPlugin.getDefault().
A PopupDialog that is automatically positioned relative to a specified anchor point.
A DebugTrace is used to record debug trace statements, based on the current option settings in a corresponding DebugOptions class.
This class provides utilities for clients of the debug UI.
Deprecated.
As of 3.3, clients should use ControlDecoration instead.
A decorating label provider is a label provider which combines a nested label provider and an optional decorator.
An observable which decorates another observable
An observable collection which decorates another observable collection
An observable list which decorates another observable list.
An observable map which decorates another observable map.
An observable set which decorates another observable set.
An observable value which decorates another observable value.
A DecoratingStyledCellLabelProvider is a DelegatingStyledCellLabelProvider that uses a nested DelegatingStyledCellLabelProvider.IStyledLabelProvider to compute styled text label and image and takes a ILabelDecorator to decorate the label.
An IVetoableValue decorator for an observable value.
A concrete implementation of the IDecorationContext interface, suitable for instantiating.
A DecorationOverlayIcon is an image descriptor that can be used to overlay decoration images on to the 4 corner quadrants of a base image.
Instances of this class provide the appearance and behavior of Shells, but are not top level shells or dialogs.
Standard implementation of IAnnotationHover.
Deprecated.
since 3.1 use DefaultIndentLineAutoEditStrategy instead
A character pair matcher that matches a specified set of character pairs against each other.
A standard implementation of a syntax driven presentation damager and presentation repairer.
The standard implementation of IEncodingSupport.
 
This class is an implementation of the Help UI.
The default hyperlink presenter underlines the link and colors the line and the text with the given color.
This strategy always copies the indentation of the previous line.
Default implementation of IInformationControl.
An information presenter determines the style presentation of information displayed in the default information control.
An information presenter determines the style presentation of information displayed in the default information control.
Standard implementation of ILineTracker.
Default class for accessing marker annotation properties.
A base implementation of IOperationHistory that implements a linear undo and redo model .
Deprecated.
As of 3.1, replaced by FastPartitioner instead
Default implementation of IPositionUpdater.
Specialized annotation to indicate a particular range of text lines.
 
 
 
A default Saveable implementation that wrappers a regular workbench part (one that does not itself adapt to Saveable).
Object representing the default scope in the Eclipse preferences hierarchy.
 
 
A source container that computer the default source lookup path for a launch configuration on each launch using a launch configuration's associated source path computer.
Standard implementation of ITextDoubleClickStrategy.
Standard implementation of ITextHover.
Default implementation of ToolTip that provides an iconofied label with font and color controls by subclass.
Deprecated.
As of 3.2, replaced by TextViewerUndoManager
Content provider that performs sorting and filtering in a background thread.
Deprecated.
deferred custom content in the debug views is no longer supported by IDeferredWorkbenchAdapter.
The DeferredContentManager is a class that helps an ITreeContentProvider get its deferred input.
A DelegatingDragAdapter is a DragSourceListener that maintains and delegates to a set of TransferDragSourceListeners.
A DelegatingDropAdapter is a DropTargetListener that maintains and delegates to a set of TransferDropTargetListeners.
 
 
 
This storage merger delegates to the appropriate merger or returns a conflict if no merger is available or if a merge was not possible.
A DelegatingStyledCellLabelProvider is a StyledCellLabelProvider that delegates requests for the styled string and the image to a DelegatingStyledCellLabelProvider.IStyledLabelProvider.
Interface marking a label provider that provides styled text labels and images.
 
Delete arguments describes the data that a processor provides to its delete participants.
Text edit to delete a range in a document.
An action to delete a whole line, the fraction of the line that is left from the cursor or the fraction that is right from the cursor.
A DeleteMarkersOperation represents an undoable operation for deleting one or more markers in the workspace.
A participant to participate in refactorings that delete elements.
A special processor that performs delete operations.
A generic delete refactoring.
Standard action for deleting the currently selected resources.
Change that deletes a resource.
Refactoring descriptor for the delete resource refactoring.
A DeleteResourcesOperation represents an undoable operation for deleting one or more resources in the workspace.
A wizard for the delete resources refactoring.
 
This managed form part handles the 'details' portion of the 'master/details' block.
This class is the abstract superclass of all device objects, such as the Display device and the Printer device.
 
Instances of this class can allocate and dispose SWT resources.
Thrown when allocation of an SWT device resource fails
Manages SWT resources for a particular device.
A dialog is a specialized window used for narrow-focused communication with the user.
This class is the abstract superclass of the classes that represent the built in platform dialogs.
An abstract cell editor that uses a dialog.
Shows the properties of a new or existing marker In 3.3, this class was refactored to allow pre-existing public dialog classes to share the implementation.
The DialogMessageArea is a resusable component for adding an accessible message area to a dialog.
Abstract base implementation of a dialog page.
Connects the validation result from the given data binding context to the given dialog page, updating the page's error message accordingly.
Concrete implementation of a dialog settings (IDialogSettings) using a hash table and XML.
DialogTaskProperties is the properties dialog for tasks.
This class is the abstract superclass of all dialog trays.
Abstract implementation of IDiff that can be subclassed by clients.
The standard implementation of a diff container element.
An abstract base implementation of the IDiffElement interface.
A generic two-way or three-way differencing engine.
A DiffNodeFilter tests an IDiff for inclusion, typically in an IDiffTree.
Combines an image with an overlay.
Diff node are used as the compare result of the differencing engine.
 
Implementation of IDiffTree.
A tree viewer that works on objects implementing the IDiffContainer and IDiffElement interfaces.
A BundleFile that uses a directory as its base file.
 
An implementation of the model object 'Direct Menu Item'.
Instances of this class allow the user to navigate the file system and select a directory.
A field editor for a directory path type preference.
A directory in the local file system.
An implementation of the model object 'Direct Tool Item'.
 
A dirty region describes a document range which has been changed.
Represents a directory entry in a ZipBundleFile.
A disabled info represents a policy decision to disable a bundle which exists in a State.
Instances of this class are responsible for managing the connection between SWT and the underlying operating system.
This class provides static methods that help RCP applications interact with the Display.
This class is used to get a Realm for a certain Display.
 
Event denoting that an IObservable object was disposed.
Instances of this class are sent as a result of widgets being disposed.
Classes which implement this interface provide a method that deals with the event that is generated when a widget is disposed.
Class DND contains all the constants used in defining a DragSource or a DropTarget.
Implements the IRangeComparator interface for lines in a document.
Default document implementation.
A text change that operates directly on instances of IDocument.
Represents a text modification as a document replace command.
w3c DocumentCSS implementation.
Specification of changes applied to documents.
Factory to get instance of DocumentHandlerFactory.
This class implements the IDocumentHandlerFactory interface.
No API yet.
Event describing the change of document partitionings.
This registry manages shared document providers.
A document range node represents a structural element when performing a structure compare of documents.
A document rewrite session.
Description of the state of document rewrite sessions.
A document rewrite session type.
Instances of this class describe the context of a template as a region of a document.
Describes document changes initiated by undo or redo.
A standard implementation of a document-based undo manager that creates an undo history based on changes to its document.
This document undo manager registry provides access to a document's undo manager.
DOM exception implementation.
Event object describing a double-click.
This class hold common constants and utility functions w.r.t. to SWT high DPI functionality.
AutoScale ImageDataProvider.
Represents an element, such as some image data, at a specific zoom level.
Instances of this class are sent as a result of a drag gesture.
Classes which implement this interface provide methods that deal with the events that are generated when a drag gesture is detected.
DragSource defines the source object for a drag and drop transfer.
This adapter class provides default implementations for the methods described by the DragSourceListener interface.
This class provides default implementations to display a drag source effect during a drag and drop operation.
The DragSourceEvent contains the event information passed in the methods of the DragSourceListener.
The DragSourceListener class provides event notification to the application for DragSource events.
Implementers of Drawable can have a graphics context (GC) created for them, and then they can be drawn on by sending messages to their associated GC.
Implements a simple web style navigation metaphor for a TreeViewer.
Class DrillDownComposite implements a simple web style navigation metaphor.
Class DropTarget defines the target object for a drag and drop transfer.
This adapter class provides default implementations for the methods described by the DropTargetListener interface.
This class provides a default drag under effect during a drag and drop.
The DropTargetEvent contains the event information passed in the methods of the DropTargetListener.
The DropTargetListener class provides event notification to the application for DropTarget events.
A class to reduce an observable list to a single value in an implementation specific way.
 
An implementation of the model object 'Dynamic Menu Contribution'.
Based on org.eclipse.ui.internal.WorkbenchMessages
 
A utility class used to call #earlyStartup on the proper instance for a given configuration element.
 
This factory is used to create new context instances.
Eclipse Platform and Requirement Namespace.
 
 
 
 
 
A content provider which allows a news reader to be included in dynamic intro content.
Special startup class for the Eclipse Platform.
This service allows access to the command subsystem.
 
EditingSupport is the abstract superclass of the support for cell editing.
 
Deprecated.
Use an org.eclipse.team.ui.history.IHistoryPageSource in conjunction with the org.eclipse.team.ui.history.IHistoryView or a HistoryPageCompareEditorInput.
Standard implementation of IEditorActionBarContributor.
The action bars for an editor.
This class reads the registry for extensions that plug into 'editorActions' extension point.
Helper class that will populate the menu and toolbar with the external editor contributions.
This class is used to record "open editor" actions as they happen.
An item in the editor history.
The EditorInputTransfer class is used to transfer an IEditorInput and corresponding editorId from one part to another in a drag and drop operation.
 
A LinkedModeUI that takes care of updating the focus editor's navigation history.
An EditorMenuManager is used to sort the contributions made by an editor so that they always appear after the action sets.
Abstract base implementation of all workbench editors.
Extends PartPluginAction for usage in editor parts.
 
This class is used to allow the user to select a dialog from the set of internal and external editors.
An editor container manages the services for an editor.
Implementation for the IDragAndDropService to be used from EditorSite's.
The central class for access to this plug-in.
This class is the main entry point for clients of the Eclipse file system API.
This service enables actions on handlers.
The help service provides clients with the functionalities of dealing with the help system.
Element implementation.
An implementation of the model object 'Element Container'.
An element handler converts an IConfigurationElement into a corresponding expression object.
A class to select elements out of a list of elements.
A history page source that can create history pages for a sub-element of a file.
This is an implementation of a Selector that implements the existing 'findElements'.
Create an element from a reference
A class to select elements out of a tree structure.
A key formatter providing the Emacs-style accelerators using single letters to represent the modifier keys.
Provide for management of different menus.
This service is used to find, create and handle model elements
Deprecated.
Please use IContextService.activateContext instead.
The EncodingFieldEditor is a field editor that allows the user to set an encoding on a preference in a preference store.
Collection of helper methods.
A specific configuration of a single line rule whereby the pattern begins with a specific sequence but is only ended by a line delimiter.
 
Contains static methods the create converters for working with Enums.
A Framework service which gives access to the command line used to start this running framework as well as information about the environment such as the current operating system, machine architecture, locale and windowing system.
Launch configuration tab for configuring the environment passed into Runtime.exec(...) when a config is launched.
 
The part service provides clients with the functionalities of showing and hiding parts.
Applicable states that a part can be in.
This service is used to resolve references from MPlaceholders.
 
The System Bundle implementation for the Equinox Framework.
The framework factory implementation for the Equinox framework.
Equinox Namespace for fragment capabilities.
Equinox module data capability namespace.
A dialog to display one or more errors to the user, as contained in an IStatus object.
This part is shown instead the editors with errors.
A ErrorSupportProvider defines the area to be shown in an error dialog for extra support information.
This part is shown instead the views with errors.
This interface describes the workbench selection service
Use this annotation to tag methods that determine if MUIElements (e.g., MMenu, MToolbar and it's items etc.) should be visible or not.
A default implementation of an evaluation context.
An evaluation result represents the result of an expression evaluation.
Instances of this class provide a description of a particular event which occurred within SWT.
Use this class to obtain an instance of IEventBroker.
The EventDispatcher interface contains the method that is called by the Event Manager to complete the event delivery to the event listener.
Deprecated.
As of 3.5.
A manager to which listeners can be attached.
This class is the central class for the Event Manager.
This annotation can be applied to arguments and fields that want to receive notifications on the specified event topic.
The default exception handler shows an error dialog when one of its handle methods is called.
This handler will pass along to the workbench advisor exceptions and errors thrown while running the event loop.
DOM Exception resource.
The intent of this class is to insulate SWT from exceptions occurring in user's listeners, so that SWT remains stable and does not accidentally crash JVM or enter some very broken state.
Use this annotation to tag methods that need to be executed.
Executes a serialized parameterized command using the workbench command service.
The data object to pass to the command (and its handler) as it executes.
Signals that an exception occured during the execution of a command.
This composite is capable of expanding or collapsing a single client that is its direct child.
The expandable placeholder element to be used for viewer items that represent an expandable tree or table element.
This adapter class provides default implementations for the methods described by the ExpandListener interface.
Expand a tree viewer.
Instances of this class support the layout of selectable expand bar items.
Instances of this class are sent as a result of ExpandItems being expanded or collapsed.
Instances of this class represent a selectable user interface object that represents a expandable item in a expand bar.
Classes which implement this interface provide methods that deal with the expanding and collapsing of ExpandItems.
This adapter class provides default implementations for the methods described by the ExpansionListener interface.
Notifies listeners when expandable controls change expansion state.
Exports breakpoints to a file or string buffer.
This class represents a specific version of an exported package in the system.
Action representing a generic export operation.
Abstract base class for all expressions provided by the common expression language.
 
An expression converter converts an XML expression represented by an IConfigurationElement or Element (DOM) subtree into a corresponding expression tree.
An implementation of the model object 'Expression'.
A status object describing information about an expression tree.
A query that matches candidates against an expression.
An exception used by an expression parser that indicates that something went wrong when parsing.
A query that evaluates using an iterator as input and produces a new iterator.
Class defining the tag names of the XML elements of the common expression language.
Global access to factory, parser, and methods for introspection
This interface provides additional features to the Condition interface.
Extend CSSRule to get selector and property list.
Extend DocumentCSS to add methods like add/remove style sheet.
 
Extends DocumentHandler to get the root node.
Deprecated.
 
Extends the OSGi Log Services LogEntry object to provide additional context information.
Extends the OSGi Log Service's LogReaderService to allow better control of log listeners.
Extends the OSGi Log Service to support the use of named loggers that provide some additional context when logging.
This event is sent after a text change occurs.
Classes which implement this interface provide a method that deals with the event that is generated when text is modified.
The base class for an "object supplier" - something that knows how to instantiate objects corresponding to the object descriptor.
This interface extends the Selector.
Deprecated.
Clients who wish to contribute factories via the org.eclipse.ui.menus extension point should subclass this class rather than the AbstractContributionFactory as this class provides a default constructor.
 
Factory for the workbench's public extensions.
Factory for the intro's public extensions.
This class allows login modules specified via loginModule extension point to be included in the login configurations.
A generic implementation of IParameterValues that takes advantage of the IExecutableExtension mechanism.
 
 
Implementation of the IExtensionTracker.
A manager for a callback facility which is capable of querying external interfaces for additional information about actions and action contribution items.
A simple implementation of the ICallback mechanism that simply takes a BindingManager and a CommandManager.
Defines a callback mechanism for developer who wish to further control the visibility of legacy action-based contribution items.
A callback which communicates with the applications binding manager.
A callback mechanism for some external tool to communicate extra information to actions and action contribution items.
An overridable mechanism to filter certain IActions from the execution bridge.
A callback for executing execution events.
An archive in the local file system.
Standard workbench wizard for importing projects defined outside of the currently defined projects into Eclipse.
A specialized DiffNodeFilter that does not require a progress monitor.
A standard implementation of a document partitioner.
A specialized SyncInfoFilter that does not require a progress monitor.
Selects SyncInfo which match all child filters.
Selects SyncInfo instances that are auto-mergable.
An abstract class which contains a set of FastSyncInfoFilter instances.
Selects SyncInfo that match any of the child filters.
Selects SyncInfo instances that are pseudo-conflicts.
Selects SyncInfo whose change type match those of the filter.
Selects SyncInfo whose change direction match those of the filter.
Deprecated.
As of 3.3, this class is no longer necessary.
FieldCategory is the field for showing categories of markers.
FieldDecoration is a simple data structure class for specifying a decoration for a field.
FieldDecorationRegistry is a common registry used to define shared field decorations within an application.
Abstract base class for all field editors.
A special abstract preference page to host field editors.
File buffer operation action.
Operation handler for a file buffer.
A FileBufferOperationRunner executes IFileBufferOperation.
Facade for the file buffers plug-in.
A BundleEntry represented by a File object.
Instances of this class allow the user to navigate the file system and select or enter a file name.
Shared document provider specialized for file resources (IFile).
Adapter for making a file resource a suitable input for an editor.
Factory for saving and restoring a FileEditorInput.
A content provider for displaying of IFileEditorMapping objects in viewers.
A label provider for displaying of IFileEditorMapping objects in viewers.
A field editor for a file path type preference.
Abstract FileHistory class.
Abstract FileHistoryProvider class.
This class should be used by file system providers in their implementation of API methods that return IFileInfo objects.
A description of a file info matcher.
Adapter for making a file resource a suitable input for an in-place editor.
A hyperlink that opens a file in a text editor and selects a range of text.
This class contains a collection of helper methods for finding files in bundles.
A context that is used in conjunction with the FileModificationValidator to indicate that UI-based validation is desired.
The file modification validator is a Team-related hook for pre-checking operations that modify the contents of files.
A utility class for manipulating file system paths.
The FilePropertySource gives the extra information that is shown for files
Basic File resources locator implementation.
Abstract implementation of IFileRevision that can be implemented by clients.
A file context can be used to annotate a RefactoringStatusEntry with detailed information about a problem detected in an IFile.
The abstract superclass of all IFileStore implementations.
Implements an IEditorInput instance appropriate for IFileStore elements that represent files that are not part of the current workspace.
Factory for saving and restoring a FileStoreEditorInput.
FileStoreStructureProvider is the structure provider for IFileStore based file structures.
The common superclass for all file system implementations.
The abstract base class for all UI file system contributors.
Instances of this class represent files or file-like entities (eg.- zip file entries) on the local file system.
Standard workbench wizard for exporting resources from the workspace to the local file system.
Standard workbench wizard for importing resources from the local file system into the workspace.
This class provides information regarding the structure and content of specified file system File objects.
A text search scope used by the file search dialog.
The class FileTransfer provides a platform specific mechanism for converting a list of files represented as a java String[] to a platform specific representation of the data and vice versa.
The abstract superclass of all IFileTree implementations.
FillLayout is the simplest layout class.
FillLayoutFactory creates and initializes fill layouts.
FilterConfigurationArea is the area that the user can configure a filter in.
Shows a list of items to the user with a text entry field for a string pattern used to filter the list of items.
History stores a list of key, object pairs.
A composite widget which holds a list of elements for user selection.
The FilterMatcher is the interface used to check filtering criterea.
Shows a list of resources to the user with a text entry field for a string pattern used to filter the list of resources.
Base class to open a dialog to filter and select elements of a Table.
Class used to store items to be displayed
Based on org.eclipse.ui.dialogs.FilteredTree.
A simple control that provides a text widget and a tree viewer.
 
A MarkerFieldParameters is a class that specifies a Map of parameters to be passed to a MarkerFieldFilter.
An event object describing that the filter state of the given matches has been updated or match filters have been reconfigured.
An action which finds the next/previous occurrence of the last search or the current selection if present.
An action which opens a Find/Replace dialog.
Provides search and replace operations on IDocument.
Content assist proposal provider for the FindReplaceDocumentAdapter.
Parts can specify this annotation on one of its methods to tag it as the method to be invoked when it has been granted focus.
This adapter class provides default implementations for the methods described by the FocusListener interface.
 
A concrete implementation of FocusCellHighlighter using by setting the control into owner draw mode and highlighting the currently selected cell.
Instances of this class are sent as a result of widgets gaining and losing focus.
Classes which implement this interface provide methods that deal with the events that are generated as controls gain and lose focus.
A folder in the workspace.
Instances of this class manage operating system resources that define how text looks when it is displayed.
Instances of this class describe operating system fonts.
 
Lightweight descriptor for a font.
Instances of this class allow the user to select a font from all available fonts in the system.
A field editor for a font type preference.
Instances of this class provide measurement information about fonts including ascent, descent, height, leading space between rows, and average character width.
A font registry maintains a mapping between symbolic font names and SWT fonts.
Form is a custom control that renders a title and an optional background image above the body composite.
Formats the keys in the internal key sequence grammar.
Instances of this class are used to define the edges of a control within a FormLayout.
Default implementation of IFormattingContext.
Keys used by IFormattingContext objects to register specific properties needed during the formatting process of a content formatter implementing IContentFormatterExtension.
Manages colors that will be applied to forms and form widgets.
Instances of this class are used to define the attachments of a control in a FormLayout.
A general-purpose dialog that hosts a form.
This class forms a base of multi-page form editors that typically use one or more pages with forms and one page for raw source of the editor input.
Instances of this class control the position and size of the children of a composite control by using FormAttachments to optionally configure the left, top, right and bottom edges of each child.
A base class that all pages that should be added to FormEditor must subclass.
This class is a read-only text control that is capable of rendering wrapped text.
The toolkit is responsible for creating SWT controls adapted to work in Eclipse forms.
Generic "Forward" action which goes forward one frame.
A forwarding document provider is a document provider that forwards all requests to a known parent document provider.
Internal class.
The Adapter Factory for the model.
An implementation of the model Factory.
The Package for the model.
Defines literals for the meta objects that represent each class, each feature of each class, each enum, and each data type
The Switch for the model's inheritance hierarchy.
Generic frame, which captures the state for one frame in the frame list.
Abstract superclass for actions dealing with frames or a frame list.
Supports a web-browser style of navigation by maintaining a list of frames.
 
The FramworkLog interface.
A framework log entry used to log information to a FrameworkLog
Implements a gap managing text store.
Class GC is where all of the drawing capabilities that are supported by SWT are located.
Instances of this class are descriptions of GCs in terms of unallocated platform-specific data fields.
A description of a generic capability.
A GenericFileBufferOperationRunner executes IFileBufferOperation.
A specification which depends on a generic capability
An implementation of the model object 'Generic Stack'.
An implementation of the model object 'Generic Tile'.
An implementation of the model object 'Generic Trim Container'.
Contains static methods for performing simple geometric operations on the SWT geometry classes.
Instances of this class are sent in response to touch-based gestures that are triggered by the user.
Classes which implement this interface provide methods that deal with the events that are generated as gestures are triggered by the user interacting with a touch pad or touch screen.
GLCanvas is a widget capable of displaying OpenGL content.
The GLData class is a device-independent description of the pixel format attributes of a GL drawable.
Standard action for full and incremental builds of all projects within the workspace.
Global variables which are available in any context.
The cursor variable determines the cursor placement after template edition.
The date variable evaluates to the current date.
The dollar variable inserts an escaped dollar symbol.
The line selection variable determines templates that work on selected lines.
The selection variable determines templates that work on a selection.
The time variable evaluates to the current time.
The user variable evaluates to the current user.
The word selection variable determines templates that work on selected words, but not on selected lines.
The year variable evaluates to the current year.
Instances of this class represent glyph metrics.
Generic "Go Into" action which goes to the frame for the current selection.
Provides the Go Into action for the ProjectExplorer
Action for jumping to a particular annotation in the editor's text viewer.
Goes to last edit position.
Action for jumping to a particular line in the editor's text viewer.
Goes to next edit position, ie travels forward in the edit position history Acts as a complement to GotoLastEditPositionAction which travels backward in the history.
Generic class to store informations to manage Gradient color.
 
GridData is the layout data object associated with GridLayout.
This class provides a convenient shorthand for creating and initializing GridData.
Instances of this class lay out the control children of a Composite in a grid.
GridLayoutFactory creates and initializes grid layouts.
Instances of this class provide an etched border with an optional title.
A group category is used to annotate change groups so that they can be identified and filtered.
A special set to manage group categories.
This class provides a convenient shorthand for creating and initializing Group.
A group marker is a special kind of contribution item denoting the beginning of a group.
This annotation indicates that injection field or method supports batching of updates.
 
An implementation of the model object 'Handled Item'.
An implementation of the model object 'Handled Menu Item'.
An implementation of the model object 'Handled Tool Item'.
An object that can exist in one of two states: defined and undefined.
A manager of HandleObject instances.
URLStreamHandler the bundleentry protocol.
URLStreamHandler the bundleresource protocol.
URLStreamHandler for reference protocol.
An instance of this class describes changes to an instance of IHandler.
An implementation of the model object 'Handler'.
 
Provide an IHandler to delegate calls to.
 
Some common utilities for working with handlers in Platform UI.
Deprecated.
As of 3.13.
The Heap Status control, which shows the heap usage statistics in the window trim.
This is a standalone help system.
Wrapper for eclipse ui activity support
 
Instances of this class are sent as a result of help being requested for a widget.
Builds a help search index for a plug-in by looking for the org.eclipse.help.toc extensions in the provided manifest file.
Classes which implement this interface provide a method that deals with the event that is generated when help is requested for a control, typically when the user presses F1.
Help System Core plug-in
 
 
This class provides general access to help content contributed to the "org.eclipse.help.toc" and "org.eclipse.help.contexts" extension points.
 
 
This class is Help UI plugin.
Uses a resource bundle to load images and strings from a property file.
A completion proposal computer for hippie word completions.
A combination IFileState and ITypedElement that can be used as an input to a compare viewer or other places where an IStreamContentAccessor is needed.
Abstract HistoryPage class that keeps track of the history page site.
Displays a history page combined with the compare/merge infrastructure.
Abstract HistoryPageSource class.
A representation of one host bundle constraint as seen in a bundle manifest and managed by a state and resolver.
Provides a set of convenience methods for creating HTML pages.
 
 
 
The class HTMLTransfer provides a platform specific mechanism for converting text in HTML format represented as a java String to a platform specific representation of the data and vice versa.
The HttpContextExtensionService provides access to an HttpContext instance whose resources and implementation are added via the "httpcontexts" extension point.
 
 
Http resources locator implementation.
 
 
 
 
Deprecated.
No longer required.
 
 
 
The HttpServiceServlet is the "public" side of a Servlet that when registered (and init() called) in a servlet container will in-turn register and provide an OSGi Http Service implementation.
 
The Http Whiteboard runtime registers a service of this type to allow an external actor to invalidate a session.
Hyperlink is a concrete implementation of the abstract base class that draws text in the client area.
 
This adapter class provides default implementations for the methods described by the HyperlinkListener interface.
Describes a contribution to the 'org.eclipse.ui.workbench.texteditor.hyperlinkDetectors' extension point.
Hyperlink detector registry that manages the detectors contributed by the org.eclipse.ui.workbench.texteditor.hyperlinkDetectors extension point for targets contributed by the org.eclipse.ui.workbench.texteditor.hyperlinkDetectorTargets extension point.
Describes a contribution to the 'org.eclipse.ui.workbench.texteditor.hyperlinkDetectorTargets' extension point.
Notifies listeners about a hyperlink change.
Manages a group of hyperlinks.
 
A canvas holding a hyperlink label.
Default implementation of a hyperlink manager.
Detection strategy.
Manages color and underline mode settings for a group of hyperlinks.
Help context ids for the text editor.
An action represents the non-UI side of a command which can be triggered by the end user.
Interface providing special access for configuring the action bars of a workbench window.
Used by a part to access its menu, toolbar, and status line managers.
Interface extention to IActionBars that provides an additional cool bar manager.
Interface for actions contributed via an extension point.
Interface extension to IActionDelegate adding lifecycle methods.
Deprecated.
Use org.eclipse.ui.IActionDelegate2 instead.
An adapter which performs action filtering.
Allows a tabbed properties view to make contributions to action bars.
This interface should be implemented by all contribution items defined by an action set.
An instance of this interface is an activity as defined by the extension point org.eclipse.ui.activities.
An instance of this interface can be used by clients to receive notification of changes to one or more instances of IActivity.
An instance of this interface allows clients to manage activities, as defined by the extension point org.eclipse.ui.activities.
An instance of this interface can be used by clients to receive notification of changes to one or more instances of IActivityManager.
An instance of this interface represents a binding between an activity and a regular expression pattern.
An instance of this interface represents a binding between two activities.
An interface for an adaptable object.
An adapter factory defines behavioral extensions for one or more classes that implements the IAdaptable interface.
An adapter manager maintains a registry of adapter factories.
An adapter for an "add memory block" operation.
Adapter for the platform's retargettable "add memory rendering" action.
IAdvancedUndoableOperation defines an interface for undoable operations that modify one or more elements in a model and attempt to keep model listeners up to date with changes that occur in the undo and redo history involving particular model elements.
IAdvancedUndoableOperation2 defines a method for computing the validity of executing an operation before attempting to execute it.
An instance of this service represents the location of a provisioning agent's metadata.
Services created by IAgentServiceFactory objects can optionally implement this interface to participate in the agent lifecycle.
A factory for creating a service that forms part of a provisioning agent instance.
Contains a set of IWorkingSet.
Specifies a location in a document where other plug-ins may contribute additional content.
An annotation access provides access to information that is not available via the API of Annotation.
Extension interface for IAnnotationAccess.
Extension interface for IAnnotationAccess.
Provides the information to be displayed in a hover popup window which appears over the presentation area of annotations.
Extension interface for IAnnotationHover for providing its own information control creator providing the range of lines for which the hover for a given line is valid providing whether the information control can interact with the mouse cursor
Extension interface for IAnnotationHover for providing whether the information control can interact with the mouse wheel
Provides an image for a given annotation.
An annotation map is a map specialized for the requirements of an annotation model.
This interface defines the model for managing annotations attached to a document.
Extends IAnnotationModelwith the ability piggyback other annotation models.
Extends IAnnotationModel with the ability to retrieve a set of annotations within a given region.
Factory for text file buffer annotation models.
Interface for objects interested in getting informed about annotation model changes.
Extension interface for IAnnotationModelListener.
Interface for annotations that can take care of their own visible representation.
Represents an Ant classpath entry.
An interface that must be implemented by plug-ins that wish to contribute predefined variables to an Ant project when run from within Eclipse.
Bootstrap type for an application.
The context used to start an application.
A variable presentation extension can contribute an argument selector which is use to configure the argument for a string substitution variable.
An artifact descriptor describes an artifact stored in some artifact repository.
Provide standardised artifact information to uniquely identify the corresponding bytes (perhaps not stored as a file).
A repository containing artifacts.
A metadata repository manager is used to create, access, and manipulate IArtifactRepository instances.
Represents a request to transfer an artifact from an artifact repository.
An interface optionally implemented by UIServices to provide richer information for the users.
An auto edit strategy can adapt changes that will be applied to a text viewer's document.
Deprecated.
since 3.0, use IAutoEditStrategy directly
A label provider maps an element of the viewer's model to an optional image and optional text string used to display the element in the viewer's control.
Predefined property names used for elements displayed in viewers.
An IListProperty extension interface with convenience methods for creating nested bean properties.
An IMapProperty extension interface with convenience methods for creating nested bean properties.
Provides access to details of bean observables.
An IProperty extension interface providing access to details of bean properties.
An ISetProperty extension interface with convenience methods for creating nested bean properties.
An IValueProperty extension interface with convenience methods for creating nested bean properties.
A stream listener is notified of changes to a binary stream monitor.
A variant of IStreamMonitor which does not touch the received content and pass it as bytes instead of strings.
A variant of IStreamsProxy which does not touch the proxied content and pass it as bytes instead of strings.
Describes binding between object description and its implementation to be used by the dependency injection.
An instance of BindingManagerListener can be used by clients to receive notification of changes to an instance of BindingManager.
Provides services related to the binding architecture (e.g., keyboard shortcuts) within the workbench.
A rectangular selection in a text document.
A breakpoint is capable of suspending the execution of a program at a specific location when a program is running in debug mode.
This interface defines a breakpoint import participant.
A breakpoint listener is notified of breakpoint additions, removals, and changes.
The breakpoint manager manages the collection of breakpoints in the workspace.
A breakpoint manager listener is notified when the breakpoint manager's enablement changes.
A breakpoint organizer is used to categorize breakpoints and provides change notification when categorization has changed.
Optional enhancements to the IBreakpointOrganizerDelegate interface.
A breakpoints listener is notified of breakpoint additions, removals, and changes.
Represents a breakpoint's type to support organization of breakpoints by type in the breakpoints view.
Represents a web browser that can be used by clients to display documents for the given URLs.
Implementators of org.eclipse.help.base.browser extension points must provide implementation of this interface.
Build Configurations provide a mechanism for orthogonal configuration specific builds within a single project.
Stores information about the context in which a builder was called.
Bundle groups represent a logical collection of plug-ins (aka bundles).
These constants define the set of properties that the UI expects to be available via IBundleGroup.getProperty(String).
Bundle group providers define groups of plug-ins which have been installed in the current system.
A bundle importer represents an instance of a bundle importer extension.
A bundle importer delegate is contributed by a bundle importer extension and is capable of importing projects into the workspace from a repository based on bundle manifest entries.
A cache that is associated with a synchronization that allows clients to cache synchronization state related to their model for the duration of the operation.
Listener that, when registered with a cache, gets invoked when the cache is disposed.
An instance of this interface is a category as defined by the extension point org.eclipse.ui.activities.
An instance of this interface represents a binding between a category and an activity.
An instance of this interface can be used by clients to receive notification of changes to one or more instances of Category.
An instance of this interface can be used by clients to receive notification of changes to one or more instances of ICategory.
A listener which is notified of significant events in the life of a cell editor.
An interface for validating a cell editor's input.
A cell modifier is used to access the data model from a cell editor in an abstract way.
Interface used to allow model tooling to request that a particular set of modified files be committed together to the repository.
Listener for generic change events.
Interface that can receive change notifiecations from a Model object
Viewer to present the preview for a Change.
An IChangeRulerColumn can display quick diff information.
A character pair matcher finds to a character at a certain document offset the matching peer character.
Extension interface for ICharacterPairMatcher.
Defines the interface of a character scanner used by rules.
Cheat sheet-aware action.
Event in the life cycle of a cheat sheet.
Manages the running of a cheat sheet.
A cheat sheet viewer.
Interface for objects that support elements with a checked state.
A listener which is notified of changes to the checked state of items in checkbox viewers.
Interface to provide checked and grayed state information about data in trees or tables.
A code mining represents a content (ex: label, icons) that should be shown along with source text, like the number of references, a way to run tests (with run/debug icons), etc.
A code mining provider adds minings ICodeMining to source text.
The IColorDecorator is an interface for objects that return a color to decorate either the foreground and background colors for displaying an an object.
A factory interface that may be used to specify a color value.
Interface to provide color representation for a given element.
Provides support to modify and query the visibility of ruler columns and test whether a ruler column is supported.
A builder command names a builder and supplies a table of name-value argument pairs.
Provides services related to the command context help.
Provides a look-up facility for images associated with commands.
Represents a link with text that invokes a specific command with parameters.
An instance of this interface can be used by clients to receive notification of changes to one or more instances of Command.
An instance of this interface can be used by clients to receive notification of changes to one or more instances of ICommandManager.
Provides services related to the command architecture within the workbench.
Defines constants for the retargetable actions available in the Common Viewer context menu.
Provides access to information required for the initialization of CommonActionProviders.
Provides initialization data for a content extension.
Allows extensions to vary their behavior based on properties in the extension model and the given memento.
Provides information about a commonFilter extension.
Allows extensions to vary their behavior based on properties in the extension model and the given memento.
Defines strings used for menu insertion points.
Allows improved performance by optimizing label updates of the CommonViewer.
Provides context for extensions including a valid shell, a selection provider, and a unique identifier corresponding to the abstract viewer behind the viewer site.
Provides a page, set of action bars, menu registration callback, and active window.
Instances of this interface represent a contribution within the workbench.
A compare container is used to represent any UI that can contain compare viewers.
Help context ids for the Compare UI.
A filter that can be applied during the comparison of documents that can be used to customize the detection of text differences via the compareFilter extension point.
Interface for objects used as input to a two-way or three-way compare viewer.
Listener that gets informed if one (or more) of the three sides of an ICompareInput object changes its value.
A label provider that provides the label and image for the left, right and ancestor sides for a compare input being shown in compare/merge viewers.
A ICompareNavigator is used to navigate through the individual differences of a CompareEditorInput or another type of Compare container.
 
A completion listener is informed before the content assistant computes completion proposals.
Extends ICompletionListener with an additional notification about restarting the current code assist session.
Extends ICompletionListener with an additional notification after applying a proposal.
The interface of completion proposals generated by content assist processors.
Extends ICompletionProposal with the following functions: handling of trigger characters other than ENTER completion proposal validation for a given offset context information can be freely positioned
Extends ICompletionProposal with the following functions: handling of trigger characters with modifiers visual indication for selection of a proposal
Extends ICompletionProposal with the following functions: provision of a custom information control creator provide a custom completion text and offset for prefix completion
Extends ICompletionProposal with the following functions: specify whether a proposal is automatically insertable
Extends ICompletionProposal with the following function: Allow background computation of the additional info.
Extends ICompletionProposal with the following function: Allow styled ranges in the display string.
Extends the functionality of ICompletionProposal with the following function: Emphasize ranges in the styled display string of the proposal that match the token at the current caret offset.
An ICompletionProposalSorter provides support for sorting proposals of a content assistant.
ICompositeOperation defines an undoable operation that is composed of child operations.
A composite repository doesn't directly contain any contents, but rather contains only a list of child repositories.
The IconAndMessageDialog is the abstract superclass of dialogs that have an icon and a message as the first two widgets.
Interface for a set of unordered elements that can fire change notifications.
Interface for objects that can listen to changes in an IConcurrentModel.
A condition checker can be used to share condition checks across the main processor and all its associated participants.
A configuration element, with its attributes and children, directly reflects the content and structure of the extension section within the declaring plug-in's manifest (plugin.xml) file.
IConfigurationWizard defines the interface that users of the extension point org.eclipse.team.ui.configurationWizards must implement.
Extends IConfigurationWizard to support the sharing of multiple projects.
A console that displays output and writes input to a process.
A console.
Provides coloring for a console document.
Constants relating to the console plug-in.
A document partitioner for a text console.
Extension interface for IConsoleDocumentPartitioner.
A console factory extension is responsible for opening a console in the console view.
Deprecated.
replaced by org.eclipse.ui.console.IHyperlink
Notified of lines appended to the console.
An extension to the console line tracker interface that console line trackers may implement to be notified when output from the console is complete.
A console listener is notified when consoles are added or removed from the console manager.
The console manager manages registered consoles.
A console page participant is notified of page lifecycle events such as creation, activation, deactivation and disposal.
A view that displays consoles registered with the console manager.
Interface for resources which may contain other resources (termed its members).
IContainerSnapshot is a lightweight description that describes a container to be created.
This adapter interface provides a way to test element containment in a model-independent way.
An IContentAssistant provides support on interactive content completion.
Extends IContentAssistant with the following functions: handle documents with multiple partitions insertion of common completion prefixes
Extends IContentAssistant with the following functions: completion listeners repeated invocation mode a local status line for the completion popup control over the behavior when no proposals are available
Extends IContentAssistant with the following function: a key-sequence to listen for in repeated invocation mode
Extends IContentAssistant with the following function: allows to get a handler for the given command identifier
A content assist processor proposes completions and computes context information for a particular content type.
Extension interface of IContentAssistProcessor that allows to get additional information when queried for auto activation
A content assist subject control can request assistance provided by a subject control content assistant.
An IContentChangeListener is informed about content changes of a IContentChangeNotifier.
Interface common to all objects that provide a means for registering for content change notification.
Content describers know how to retrieve metadata from contents.
A content description object contains information about the nature of arbitrary data.
An extension of a document's content.
The interface of a document content formatter.
Extension interface for IContentFormatter.
Marker-style interface for a content outline page.
IContentProposal describes a content proposal to be shown.
This interface is used to listen to notifications from a ContentProposalAdapter.
This interface is used to listen to additional notifications from a ContentProposalAdapter.
IContentProposalProvider provides an array of IContentProposals that are appropriate for a textual dialog field, given the field's current content and the current cursor position.
A content provider mediates between the viewer's model and the viewer itself.
Content types represent and provide information on file types, such as associated file names/extensions, default charset, etc.
The content type manager provides facilities for file name and content-based type lookup and content description.
An event object which describes the details of a change to a content type.
A listener to be used to receive content type change events.
A policy for refining the set of content types that should be accepted during content type matching operations.
An object that performs content type matching queries.
Gives access to the user settings for a content type.
A context registered for context-sensitive help.
Deprecated.
Please use the "org.eclipse.core.commands" plug-in instead.
Extends IContext to provide support for styled text and topic categorization.
Extends IContext2 to provide support for related command links.
A token representing the activation of a context.
This is an expression that will need access to the global variable everything.
A context function encapsulates evaluation of some code within an IEclipseContext.
A list of well-known context identifiers.
The interface of context information presented to the user and generated by content assist processors.
Extends IContextInformation with the ability to freely position the context information.
A context information presenter determines the presentation of context information depending on a given document position.
A context information validator is used to determine if a displayed context information is still valid or should be dismissed.
An instance of this interface can be used by clients to receive notification of changes to one or more instances of IContext.
Deprecated.
Please use the "org.eclipse.core.commands" plug-in instead.
Deprecated.
Please use the "org.eclipse.core.commands" plug-in instead.
An instance of this interface can be used by clients to receive notification of changes to one or more instances of IContextManager.
Deprecated.
Please use the "org.eclipse.core.commands" plug-in instead.
Constants for menu groups used in context menus for Search views and editors.
Dynamic context provider.
IContextReplacingOperation defines an interface for undoable operations that can replace one undo context with another undo context.
Provides services related to contexts in the Eclipse workbench.
This interface is used to identify workbench views which allow other parts (typically the active part) to supply their contents.
Interface that has to be implemented by contributions to the org.eclipse.ui.texteditor.rulerColumns extension point.
 
 
A contribution item represents a contribution to a shared UI resource such as a menu or tool bar.
A contribution manager organizes contributions to such UI components as menus, toolbars and status lines.
This interface is used by instances of IContributionItem to determine if the values for certain properties have been overriden by their manager.
Instances of this interface represent a position in the contribution hierarchy into which AbstractContributionFactory instances may insert elements.
Instances of this service are capable of providing standard mechanisms that clients may use to order, display, and generally work with contributions to the Workbench.
This interface describes a registry contributor - an entity that supplies information to the extension registry.
The IContributorResourceAdapter is an interface that defines the API required to get a resource that an object adapts to for use of object contributions, decorators and property pages that have adaptable = true.
An extension to the IContributorResourceAdapter that adapts a model object to a ResourceMapping.
This interface is used to set and retrieve text content from an arbitrary control.
This interface is used by a ContentProposalAdapter in order to retrieve and set the selection range in a control.
Deprecated.
As of 3.3, clients should use ControlDecoration instead of DecoratedField.
A one-way converter.
The ICoolBarManager interface provides protocol for managing contributions to a cool bar.
ICopyable defines an interface for elements that provide copy support in a UI.
The ICopyright interface represents a software copyright.
A functional interface for a runnable that can be cancelled and can report progress using the progress monitor passed to the ICoreRunnable.run(IProgressMonitor) method.
Objects that are adaptable to ICountable can be used as the default variable in a count expression.
A directive indicating the criteria information of a Toc or Topic described in xml
ICriteriaDefinition represents the criteria definition of one plug-in.
Represents criteria definition contribution
ICriterionDefinition represents a single criterion definition of the help content.
ICriterionValueDefinition represents one criterion value definition of one criterion.
CSS Parser factory to manage instance of CSSParser.
CSS2 Background Property Handler.
CSS2 Border Property Handler.
CSS2 Classification Property Handler.
CSS Property Handler interface to manage composite CSS Property (ex: background is CSS Property composed with background-color, background-image..).
CSS2 Dimension Property Handler.
CSS2 Font Property Handler.
CSS Property Handler interface used to apply CSS Property value to an element like Swing Component, SWT Widget.
CSS Property Handler to intercept when all CSS Properties are applied.
Interface CSS Property Handler provider to manage the strategy to provide list of ICSSPropertyHandler linked to a CSS Property. the strategy to get the CSS default style declaration of an element
CSS Border Margin Handler.
CSS Padding Handler.
CSS2 Text Property Handler.
A one-way converter.
ICSSValueConverterConfig to manage format String of the RGBColor.
CSS Value converter config.
Collection of IDE-specific APIs factored out of existing workbench.
Preferences defined by the IDE workbench.
Standard shared images defined by the IDE.
Access to standard actions provided by the IDE workbench (including those of the generic workbench).
Handles a command for a debugger.
A request to execute a command on specific elements.
A debug context listener is notified of debug context events.
Manages debug context services.
Interface common to all objects that provide a debug context.
This extension to IDebugContextProvider allows clients to specify the scope that the context provider will apply to.
Debug context service for a window.
A debug model presentation may implement this interface to override standard editor positioning and annotations associated with source code display for stack frames.
A debug element represents an artifact in a program being debugged.
An event filter allows clients to intercept debug events.
A debug event set listener registers with the debug plug-in to receive event notification from programs being run or debugged.
A debug model presentation is responsible for providing labels, images, and editors associated with debug elements in a specific debug model.
Optional extension for an IDebugModelPresentation.
A debug model provider provides debug model identifiers.
A debug target is a debuggable execution context.
Constant definitions for debug UI plug-in.
Common function for debug views.
Interface for observables which decorate other observables.
Defines the result of decorating an element.
A decoration context provides additional information to a label decorator.
Manages the decorators contributed via the org.eclipse.ui.decorator extension point.
IDEEncoding is a utility class for managing encoding information that includes user preferences from the IDE and core resources.
This adapter interface provides support for lazy initialization of UI workbench elements that are displayed visually.
A delayed input change provider notifies the registered IInputChangedListener about input changes that occur after the normal operation of the provider.
A delayed label decorator is a label decorator that may not have a decoration available immediately.
An instance of this class describes changes to an instance of IIdentifier.
Label providers (as specified by the labelProvider attribute of the org.eclipse.ui.navigator.navigatorContent extension point) may choose to also implement this interface in order to provide text for the status bar at the bottom of the Eclipse window.
A detail pane is created from a detail pane factory and displays detailed information about a current selection with an SWT Control.
An extension to the detail pane interface which allows implementors to provide a selection provider instead of setting the selection provider of the view's site directly.
An extension to the detail pane interface which allows implementors to save contents of the details pane.
A detail pane factory creates one or more types of detail panes.
This interface should be implemented by clients providing pages to handle object types in DetailsPart.
The class that implements this interface provides for dynamic computation of page key and the page itself based on the input object.
The IDialogBlockedHandler is the handler used by JFace to provide extra information when a blocking has occured.
IDialogConstants is the interface for common dialog strings and ids used throughout JFace.
IDialogLabelKeys contains publicly accessible keys to the common dialog labels used throughout JFace.
Interface for a page in a multi-page dialog.
An interface to a storage mechanism for making dialog settings persistent.
Provides dialog settings without assumption on how the dialog settings should be saved or restored.
Marker interface for objects which describe a difference in state.
A diff describes differences between two or more model objects.
A change event that describes changes that have occurred in an IDiffTree.
Diff change listener that reports changes in an IDiffTree.
IDiffContainer is a IDiffElement with children.
An IDiffElement is used in the DiffTreeViewer to display the kind of change detected as the result of a two-way or three-way compare.
A diff tree provides access to a tree of IDiff instances.
An objects that visits diffs in a diff tree.
The ability to end a debug session with a target program and allow the target to continue running.
A disconnect handler disconnects the debug user interface from a debug session.
The interface that should be implemented by services that make themselves available through the IAdaptable mechanism.
Listener for dispose events.
An IDocument represents text providing support for text manipulation positions partitions line information document change listeners document partition change listeners A document allows to set its content and to manipulate it.
Adapts an IDocumentto the StyledTextContent interface.
Extension interface for IDocumentAdapter.
Extension interface for IDocument.
Interface for a post notification replace operation.
Extension interface for IDocument.
Extension interface for IDocument.
Extension interface for IDocument.
Deprecated.
As of 3.2 the "org.eclipse.core.filebuffers.documentCreation" extension point has been deprecated.
Factory interface to get instance of ExtendedDocumentHandler.
A IDocumentInformationMapping represents a mapping between the coordinates of two IDocument objects: the original and the image.
Interface for objects which are interested in getting informed about document changes.
A document partitioner divides a document into a set of disjoint text partitions.
Extension interface for IDocumentPartitioner.
Extension interface for IDocumentPartitioner.
Extension interface for IDocumentPartitioner.
Interface of objects which are interested in getting informed about changes of a document's partitioning.
Extension interface for IDocumentPartitioningListener.
Extension interface to IDocumentPartitioningListener.
A document provider maps between domain elements and documents.
Extension interface for IDocumentProvider.
Extension interface for IDocumentProvider.
Extension interface for IDocumentProvider.
Extension interface for IDocumentProvider.
Extension interface for IDocumentProvider.
Defines a subrange in a document.
Interface for objects which are interested in getting informed about document rewrite sessions.
Participates in the setup of a text file buffer document.
Extension interface for IDocumentSetupParticipant.
This interface is used to listen to notifications from a DocumentUndoManager.
Interface for a document undo manager.
A listener which is notified of double-click events on viewers.
This interface specifies the API for a service to be used by part authors to access methods which provide support for Drag and Drop operations within the workbench.
Interface for actions supplied by extensions to the org.eclipse.ui.dropActions extension point.
Provides the ability to drop to frame.
A drop to frame handler typically resets a program's instruction pointer to the first executable line of code associated with a stack frame.
This interface provides an extra degree of access to an extension registry that might be useful to registry implementers.
Implementations of this interface are capable of determining a set of projects which a given project depends upon.
A dynamic variable is a variable whose value is computed dynamically by a resolver at the time a string substitution is performed.
Resolves the value for a dynamic variable.
A context is used to isolate application code from its dependencies on an application framework or container.
This interface describes Eclipse extensions to the preference story.
A listener to be used to receive preference node change events.
A listener used to receive changes to preference values in the preference store.
An event object which describes the details of a change in the preference node hierarchy.
An event object describing the details of a change to a preference in the preference store.
Common interface for objects with editable contents.
Extends the IEditableContent interface to support validate edit.
Implemented by tools supporting the editing process.
A registry for IEditingSupports.
A editor action bar contributor defines the actions for one or more editors.
Interface for an action that is contributed into an editor-activated menu or tool bar.
Allows to override editor associations for the IDE.
Description of an editor in the workbench editor registry.
IEditorInput is a light weight descriptor of editor input, like a file name but more abstract.
An editor launcher is used to launch external editors on a file in the local file system.
This interface serves as an adapter between matches and editors.
An editor matching strategy allows editor extensions to provide their own algorithm for matching the input of an open editor of that type to a given editor input.
An editor is a visual component within a workbench page.
Implements a reference to an editor.
Registry of editors known to the workbench.
The primary interface between an editor part and the workbench.
An interface to use the status line of an editor.
IElementCollector is a type that allows for the incremental update of a collection of objects.
This interface is used to compare elements in a viewer for equality, and to provide the hash code for an element.
A factory for re-creating objects from a previously saved memento.
The IElementFilter is a interface that defines the API for filtering the current selection of a ResourceTreeAndListGroup in order to find a subset to update as the result of a type filtering.
Element provider to retrieve w3c Element which wrap the native widget (SWT Control, Swing JComponent...).
the ICommandService will return a reference for all callbacks that are registered.
Interface for parties interested in standardized element changes.
Extension interface for IElementStateListener.
An IHandler for a command that expects to provide feedback through the registered element mechanism must implement this interface.
A request to update the enabled state of a command.
A storage that knows how its contents are encoded.
Extension for IStreamContentAccessor.
Interface to be implemented by objects supporting character encodings.
The engine is a service that naively performs a set of requested changes to a provisioned system.
Descriptor of a concrete instance of a search engine.
An expression that can report errors which occurred during the expression's evaluation.
An evaluation context is used to manage a set of objects needed during XML expression evaluation.
The evaluation context.
A token representing a core expression and property change listener currently working in the IEvaluationService.
Evaluate a core expression against the workbench application context and report updates using a Boolean property.
To obtain an instance of the event broker service from the IEclipseContext context, use
Implementers can register with a text viewer and receive VerifyEvents before the text viewer they are registered with.
This handler allows clients to be notified when an exception occurs
Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.
This interface allows extension providers to control how the instances provided to extension-points are being created by referring to the factory instead of referring to a class.
A listener to the execution of commands.
A listener to the execution of commands.
Classes that implement this interface will be notified before and after the expandable control's expansion state changes.
Represents a node in the preference hierarchy which is used in the import/export mechanism.
Interface for export wizards.
An expression is a snippet of code that can be evaluated to produce a value.
A node in the expression tree
This interface provides all the factory methods needed to create the nodes of the expression tree.
An expression listener is notified of expression additions, removals, and changes.
The expression manager manages the collection of registered expressions in the workspace.
A parser that produces an expression tree based on a string representation.
An expression listener is notified of expression additions, removals, and changes.
A general purpose visitor that will visit each node in an expression tree.
An extension declared in a plug-in.
An extension activation listener is notified whenever the activation state changes for one or more content extensions.
Extension change handlers are notified of changes for a given extension point in the context of an extension tracker.
An extension delta represents changes to the extension registry.
An extension point declared in a plug-in.
The extension registry holds the master list of all discovered namespaces, extension points and extensions.
Allows clients to coordinate state across components that are part of the same logical extension.
An extension tracker keeps associations between extensions and their derived objects on an extension basis.
IField is the definition of fields for marker views.
Files are leaf resources which contain data.
An artifact repository whose artifacts are available in the local file system.
A file buffer represents a file that can be edited by more than one client.
Interface for listeners to file buffer changes.
A file buffer manager manages file buffers for files while the files are connected to the file buffer manager.
A file buffer operation performs changes of the contents of a file buffer.
This interface provides the list of status codes that are used by the file buffer plug-in when it throws CoreException.
This is the API to define mappings between file names, file extensions and content types, typically used by repository providers in order to determine whether a given file can be treated as text or must be considered binary.
This interface defines a file-oriented input to an editor.
An association between a file name/extension and a list of known editors for files of that type.
Provides a complete set of IFileRevisions that make up this IFileHistory.
This is API to access individual file histories.
A file info is a simple structure holding information about a file or directory.
This interface serves to map matches to IFile instances.
Deprecated.
clients should subclass FileModificationValidator instead of implementing this interface
A representation of a file patch that can be applied to an input stream.
A representation of a file patch that can be applied to an input stream.
A file patch result provides the results of an attempt to apply an IFilePatch2 to the contents of a file
Represents an individual revision of a file.
A previous state of a file stored in the workspace's local history.
A file store is responsible for storage and retrieval of a single file in some file system.
This is the main interface to a single file system.
This interface is used to query a tree of file stores.
Deprecated.
Use the IFileContentManager API instead.
A filter compares the given object to some pattern and returns true if the two match and false otherwise.
Filter for filtering out content of help documents delivered to the client
Interface for filters.
Deprecated.
clients should implement IStepFilters instead
An interface that combines the IExpression with the LDAP filter.
A filter descriptor contains information about a filter type obtained from the plug-in manifest (plugin.xml) files.
Defines the target for finding and replacing strings.
Extension interface for IFindReplaceTarget.
Extension interface for IFindReplaceTarget.
Extension interface for IFindReplaceTarget.
Extension interface for IFindReplaceTarget providing methods to select multiple text ranges.
Interface which provides the ability to flush the contents from the viewer model (for example, an IDocument for text based content) into the underlying compare model ( most likely an instance of IEditableContent).
Interface which provides the ability to flush the contents from the specified side of the viewer.
A stream monitor who's contents can be flushed.
Tracks focusGained and focusLost events for a Control registered with this service, and provides the control and its registered ID as variables to the application evaluation context for evaluation by the various services.
Folders may be leaf or non-leaf resources and may contain files and/or other folders.
An IFolderLayout is used to define the initial views within a folder.
Command IDs for folding commands.
The IFontDecorator is an interface for objects that return a font to decorate an object.
Interface to provide font representation for a given element.
Formatting context used in formatting strategies implementing interface IFormattingStrategyExtension.
A formatting strategy is assumed to be specialized on formatting text of a particular content type.
Extension interface for IFormattingStrategy.
A place to hold all the color constants used in the forms package.
Interface that all GUI pages need to implement in order to be added to FormEditor part.
Classes that implement this interface can be added to the managed form and take part in the form life cycle.
A frame source is the source of frames which appear in a frame list.
An adapter interface for editors, which allows the editor to reveal the position of a given marker.
A handler is the pluggable piece of a command that handles execution.
Extend the IHandler interface to provide some context for isEnabled() requests.
A token representing the activation of a handler.
Attribute constants that have special meanings within this package.
An instance of this interface can be used by clients to receive notification of changes to one or more instances of IHandler.
Provides services related to activating and deactivating handlers within the workbench.
 
Preference constants for the heap status.
Deprecated, for removal: This API element is subject to removal in a future version.
marked for deletion, see Bug 442959.
Producer capable of generating or otherwise obtaining contents for help resources.
A help resource, usually a help topic.
Producer capable of generating or otherwise obtaining AbstractHelpScopes for filtering the help system.
Represents a Lucene index for one locale.
Interface for holding Help UI plug-in constants
An adaptation for a history page for displaying comparisons triggered by history page selections.
Interface for pages that appear in the team history view.
A site which provides access to the context in which this page is being displayed.
Interface to an object which is capable of supplying a history page for display by the history view or other views, dialogs or editors that wish to display the history of an object.
This interface provides a way for clients to request the History View to display the history for a given object.
Interface that represents a hunk.
Filter that is used to determine if a hunk should be applied or not
Represents a hyperlink.
A hyperlink in a console.
Optional extension to IHyperlink.
A hyperlink detector tries to find a hyperlink at a given location in a given text viewer.
Extends IHyperlinkDetector with ability to dispose a hyperlink detector.
Extends IHyperlinkDetector with ability to specify the state mask of the modifier keys that need to be pressed for this hyperlink detector.
 
Classes that implement this interface will be notified when hyperlinks are entered, exited and activated.
A hyperlink presenter shows hyperlinks on the installed text viewer and allows to pick one on of the hyperlinks.
Extends IHyperlinkPresenter with ability to query whether the currently shown hyperlinks can be hidden.
Extends IHyperlinkPresenter with ability to distinguish between the modes in which the control either takes focus or not when visible.
Identifiers for IDE menus, toolbars and groups.
An object that is unique identifiable based on the combination of its class and its identifier.
An instance of this interface can be obtained from an instance of IActivityManagerfor any identifier.
An instance of this interface can be used by clients to receive notification of changes to one or more instances of IIdentifier.
An ignore info specifies both the pattern and the enabled state of a globally ignored pattern.
 
Interface which can provide structure and content information for an element (for example, a file system element).
Interface for import wizards.
A directive indicating the content at the given path should be included in this document, and replace this node.
This interfaces extends IncrementalProjectBuilder.
Indexed access to the elements provided by an IQueryable
IIndex represents metaphor of the book index.
Adds efficient element indexing support to ILazyContentProvider.
Represents either a complete or partial keyword index, as well as its metadata.
A value containing an indexed collection of variables - for example, an array.
IIndexEntry represents a single entry of the help index.
IIndexEntry2 is an index entry which may have see elements as children
An index provider is typically an IQueryable.
An entry that represents a see also node in the index.
A directive indicating the content at the given path should be included in this document, and replace this node.
Interface of a control presenting information.
Interface of a factory for information controls ( IInformationControl).
Extension interface for IInformationControlCreator
Extension interface IInformationControl.
Extension interface for IInformationControl.
Extension interface for IInformationControl.
Extension interface for IInformationControl.
Extension interface for IInformationControl.
An information presenter shows information available at the text viewer's current document position.
Extends IInformationPresenter with the ability to handle documents with multiple partitions.
Provides information related to the content of a text viewer.
Extends IInformationProvider with the ability to provide the element for a given subject.
Extends IInformationProvider with the ability to provide its own information presenter control creator.
An injector is used to inject data from the object supplier into a domain object.
Interface for editor parts that represent an in-place style editor.
This interface defines an editor input for in-place editors.
A listener which is notified when the target's input changes.
Interface common to all objects that provide an input.
Interface common to all objects that provide both an input and a selection.
The IInputValidator is the interface for simple validators.
An installable unit represents an atomic, indivisible unit of installable functionality in a provisioned system.
Represents a fragment that contributes additional requirements, capabilities, and other properties to some host installable unit.
An installable unit patch is an installable unit that alters the required capabilities of another installable unit.
An interface optionally implemented by UIServices to provide confirmation for the origin of installable units being installed.
Trust information returned from an authority trust request.
Interface for a container that hosts one or more installation pages ( InstallationPage).
A debug model presentation may implement this interface to override standard annotations used to display instruction pointers for stack frames.
An Intro action.
A content provider for dynamic intro content.
An interface between a content provider and its parent container.
Manages the intro part that introduces the product to new users.
The intro part is a visual component within the workbench responsible for introducing the product to new users.
The primary interface between an intro part and the workbench.
An Intro url.
A content provider for dynamic XHTML Intro content.
Objects that are adaptable to IIterable can be used as the default variable in an iterate expression.
An event describing a change to the state of a job.
Callback interface for clients interested in being notified when jobs change state.
This is a functional interface representation of Job, suitable for use in lambda expressions.
The job manager provides facilities for scheduling, querying, and maintaining jobs and locks.
Interface for runnables that can be run as jobs.
Represents status relating to the execution of jobs.
This interface provides access to the specific portions of the location string for use by ssh2 connection and the user authenticator.
A service whose purpose is to ensure that all the JSch preferences are properly pushed into JSch before a Session is created.
Deprecated.
See IContextService to manage scopes and IHandlerService to manage handlers.
Any formatter capable of taking a key sequence or a key stroke and converting it into a string.
Deprecated, for removal: This API element is subject to removal in a future version.
Please use org.eclipse.jface.bindings.keys.IKeyFormatter
A facilitiy for converting the formal representation for key strokes (i.e., used in persistence) into real key stroke instances.
A label decorator decorates the label text and image for some element.
Extends IBaseLabelProvider with the methods to provide the text and/or image for the label of a given element.
A listener which is notified when a label provider's state changes.
A launch is the result of launching a debug session and/or one or more system processes.
Interface used to tag objects as launchable.
A launch configuration describes how to launch an application.
A launch configuration delegate performs launching for a specific type of launch configuration.
Optional enhancements to the launch configuration delegate interface.
A launch configuration dialog is used to edit and launch launch configurations.
Notified when a launch configuration is created, deleted, or changed.
Responsible for migrating launch configurations between different versions of Eclipse.
A launch configuration tab is used to edit/view attributes of a specific type of launch configuration.
Optional enhancements for ILaunchConfigurationTab.
A launch configuration tab group is used to edit/view attributes of a specific type of launch configuration.
Describes and creates instances of a specific type of launch configuration.
An editable copy of a launch configuration.
A launches listener is notified of launches as they are added and removed from the launch manager.
Enhancements to the launches listener interface.
A launch group identifies a group of launch configurations by a launch mode and category.
A launch listener is notified of launches as they are added and removed from the launch manager.
The launch manager manages the set of registered launches, maintaining a collection of active processes and debug targets.
A launch mode.
A launch shortcut is capable of launching a selection or active editor in the workbench.
An extension to a standard launch shortcut (ILaunchShortcut) allowing launch shortcuts to specify how selections and editors should be launched.
Classes that extend abstract class Layout and implement this interface can take part in layout computation of the TableWrapLayout manager.
The ILazyContentProvider is the content provider for table viewers created using the SWT.VIRTUAL flag that only wish to return their contents as they are queried.
The ILazyTreeContentProvider is the content provider for tree viewers created using the SWT.VIRTUAL flag that only wish to return their contents as they are queried.
The ILazyTreePathContentProvider is a tree path-based content provider for tree viewers created using the SWT.VIRTUAL flag that only wish to return their contents as they are queried.
The ILicense interface represents a software license.
The ILightweightLabelDecorator is a decorator that decorates using a prefix, suffix and overlay image rather than doing all of the image and text management itself like an ILabelDecorator.
A breakpoint that can be located at a specific line of source code.
Protocol that allows direct access to line information.
Extension interface for ILineDiffer.
Extension interface for ILineDiffer.
Describes the change state of one line, which consists of the state of the line itself, which can be UNCHANGED, CHANGED or ADDED, and the number of deleted lines before and after this line.
Describes a range of lines.
A line tracker maps character positions to line numbers and vice versa.
Extension interface for ILineTracker.
A directive indicating a link to another toc to be inserted at (and replace) this link.
Protocol used by LinkedModeModels to communicate state changes, such as leaving linked mode, suspending it due to a child mode coming up, and resuming after a child mode has left.
Provides information to the Common Navigator on how to link selections with active editors and vice versa.
Listener for changes to observable lists.
Interface for list-typed properties.
Live Help Extension.
Service that is used to change the Locale at runtime.
A local working set manager can be used to manage a set of working sets independently from the working sets managed by the global working set manager.
This class gets the location for a given object.
Extension interface for ILocationProvider.
A lock is used to control access to an exclusive resource.
A log to which status events can be written.
A mechanism to log errors throughout JFace Data Binding.
A mechanism to log errors throughout JFace.
 
Provides logical structure types applicable to a raw implementation value from a debug model.
Provides a value representing the logical structure of a raw implementation value from a debug model.
A delegate that provides a value representing the logical structure of a raw implementation value from a debug model.
Optional extension to ILogicalStructureTypeDelegate that allows a logical structure type delegate to provide a description for a value.
Optional extension to ILogicalStructureTypeDelegate that allows a logical structure type delegate to garbage collect its logical structures once they're no longer displayed.
The ILoginContext is the central entry point for the authentication support.
This is a common interface that tags a class that can be registered as a listener for security events.
A log listener is notified of entries added to a plug-in's log.
Instances of this class are graphics which have been prepared for display on a specific device.
 
Instances of this class are device-independent descriptions of images.
Interface to provide a callback mechanism to get information about images when the application is moved from a low DPI monitor to a high DPI monitor.
An image descriptor is an object that knows how to create an SWT image.
Interface to provide a callback mechanism to get information about images when the application is moved from a low DPI monitor to a high DPI monitor.
This class extends hyperlink widget by adding the capability to render an image relative to the text.
 
Instances of this class are used to load images from, and save images to, a file or stream.
Instances of this class are sent as a result of the incremental loading of image data.
Classes which implement this interface provide methods that deal with the incremental loading of image data.
 
A factory object for the ImageMergeViewer.
An image registry maintains a mapping between symbolic image names and SWT image objects or special image descriptor objects which defer the creation of SWT image objects until they are needed.
The class ImageTransfer provides a platform specific mechanism for converting an Image represented as a java ImageData to a platform specific representation of the data and vice versa.
Provides methods for drawing images onto a canvas.
Deprecated.
As of 3.0, replaced by ImageUtilities
Managed form wraps a form widget and adds life cycle methods for form parts.
Listener for changes to observable maps.
Interface for map-typed properties
Markers are a general mechanism for associating notes and meta-data with resources.
Describes the public attributes for a marker and the acceptable values each may have.
A marker delta describes the change to a single marker.
Provides a help context for a given marker.
Registry of F1 help contexts and resolutions for markers.
Resolution for a marker.
Extends IMarkerResolution.
Creates resolutions for a given marker.
A marker resolution generator should implement this interface rather than IMarkerResolutionGenerator if it can determine whether a particular marker has any resolutions more efficiently than computing all the resolutions.
A relevance for the marker resolution.
IMarkerSnapshot is a lightweight snapshot of a marker for the purposes of undoing.
A marker updater is responsible for saving changes to markers.
A mark region target to support marked regions as found in emacs.
A mark selection can be sent out by text viewers.
A match expression is a boolean expression matching a candidate of a specific type.
Deprecated.
If possible, use one of the predefined queries in QueryUtil or use the QueryUtil.createMatchQuery(String, Object...) to create a custom expression based query.
Instances of this class represent input method editors.
This interface may be implemented by any class that wants to provide easy (high performance) access to its member to the expression evaluator.
Interface to a memento used for saving the important state of an object in a form that can be persisted in the file system.
Clients may use mementos to persist interesting state between sessions.
A contiguous segment of memory in an execution context.
Extensions to IMemoryBlock.
A memory block listener is notified of the addition and removal of memory blocks with the memory block manager.
Manages registered memory blocks in the workspace.
Supports the retrieval of arbitrary blocks of memory.
Extended capabilities for memory block retrieval.
Allows debug models to customize the rendering of addresses for its memory blocks in table and text based renderings provided by the debug platform.
An arbitrary rendering of a memory block.
A rendering bindings listener is notified of changes in the renderings provided by a rendering bindings provider.
A rendering bindings provider provides rendering type bindings for a memory block.
A memory rendering container is a container within a memory rendering site for hosting a memory renderings.
Manager for memory renderings.
A workbench site that hosts memory renderings and provides synchronization services for memory renderings.
Extension to memory site that allows a client to request a rendering container to become visible.
Provides facilities related to the synchronization of memory renderings.
Represents a type of memory rendering contributed via the memoryRenderings extension point.
A factory that creates memory renderings.
Interface for something that creates and disposes of SWT menus.
A menu listener that gets informed when a menu is about to show.
A menu listener that gets informed when a menu is about to hide.
The IMenuManager interface provides protocol for managing contributions to a menu bar and its sub menus.
Provides services related to the menu architecture within the workbench.
Workaround for bug 537046
State identifiers that should be understood by items and renderers of items.
Provides the context for an IResourceMappingMerger or a model specific synchronization view that supports merging.
A special status that is returned when the return code of the merge method is CONFLICTS.
A content provider that mediates between a ContentMergeViewer's model and the viewer itself.
An interface that provides access to the internals of a merge viewer for the purposes of testing.
This interface encapsulates a single message that can be shown in a form.
Service that is responsible for creating and managing message class instances.
This interface provides for managing typed messages in a form.
This interface computes the prefix of a message that is created in the context of a control.
Minimal interface to a message provider.
A metadata repository stores information about a set of installable units
A metadata repository manager is used to create, access, and manipulate IMetadataRepository instances.
Service component interface to be able to register model processors via OSGi services.
A model element to be added to the context used to invoke the processor.
A model provider descriptor contains information about a model provider obtained from the plug-in manifest (plugin.xml) file.
This handler allows clients load, create and save model resources
Common interface for objects with a modification date.
Primary interface for hooking the implementation of IResource.move and IResource.delete.
An implementation of the model object 'Imperative Expression'.
Imports breakpoints from a file or string buffer into the workspace.
An operation which does the actual work of copying objects from the local file system into the workspace.
A representation of one package import constraint as seen in a bundle manifest and managed by a state and resolver.
Action representing a generic import operation.
Dialog to let the user customise how files and resources are created in a project hierarchy after the user drag and drop items on a workspace container.
This interface represents a textual selection that can be made of multiple discontinued selected ranges.
An instance of this interface allows clients to manage activities, as defined by the extension point org.eclipse.ui.activities.
State identifiers that are understood by named handle objects that implement IObjectWithState.
A listener capable of adding or removing itself as a listener on a source object using the source's "native" listener API.
Interface that allow clients to navigate through the changes shown in a compare pane.
Manages a list of entries to keep a history of locations on editors, enabling the user to go back and forward without losing context.
Represents the context marked for the user in the navigation history.
Should be implemented by editors that wish to contribute to the navigation history.
Determines if an extension is active within the context of a given viewer and manages the persistence of this information.
The descriptor provides a the low-level handle to a content extension.
The content extension represents the components of a navigatorContent extension.
Manages content extensions for extensible viewers and provides reusable services for filters, sorting, the activation of content extensions, and DND.
Used by clients who would like to listen for the load event of am INavigatorContentExtension.
Provides support for managing the filters defined for a Common Navigator viewer.
Performs calculations that are necessary to determine the correct children to render in the viewer.
 
Provides an interface to extensions declared in org.eclipse.ui.navigator.navigatorContent/commonSorter.
Provides a basic metadata about the abstract viewer for a particular content service.
 
Position updater that considers any change in [p.offset, p.offset + p.length] of a Position p as belonging to the position.
An action which enters the incremental find mode like in emacs.
The abstract base class for all incremental project builders.
Deprecated.
This is now handled by IServiceLocator which can be nested.
Interface for creation wizards.
This is a standalone infocenter.
Deprecated.
since 3.0. there is no replacement, use org.eclipse.ui.forms to define a component with a similar look and function.
Standard implementation of IInformationPresenter.
The exception indicates a error that occurred while performing dependency injection.
Use this class to obtain an instance of the dependency injector.
Support to draw inlined annotations: line header annotation with LineHeaderAnnotation. line content annotation with LineContentAnnotation.
A simple input dialog for soliciting an input string from the user.
Text edit to insert a text at a given position in a document.
This action implements smart return.
A DebugPopup that can be used to inspect an IExpression object.
Abstract base implementation for an installation dialog page.
InstalledSoftwarePage displays a profile's IInstallableUnits in an Installation Page.
An InstallOperation describes an operation that installs IInstallableUnits into a profile.
Object representing the instance scope in the Eclipse preferences hierarchy.
A field editor for an integer type preference.
Some common utilities for working with handlers and IEvaluationContexts in Platform UI.
Internal class used for non-API debug flags.
 
Classes that extend this abstract class are used to configure CustomizableIntroPart.
An intro content detector is used when starting the Workbench to determine if new intro content is available.
Used to provide children of the computed gruops while constructing intro content.
Abstract base implementation of an intro part.
Factory class used to create instances of an Intro URL.
Interface for listening to null selection changes.
Indicates that signed content is invalid according to one of the signers.
An unchecked exception indicating that an attempt to access an extension registry object that is no longer valid.
This interface must be implemented in order to contribute to context (pop-up) menu for an object.
Interface for an object action that is contributed into a popup menu for a view or editor.
Objects of classes that implement this interface can be registered for certain object type in the IObjectContributorManager.
This interface describes objects created by the dependency injection.
An object that holds zero or more state objects.
An object with state that allows to listen for state changes.
Interface for observable collections.
Generates an IObservable when passed a target instance.
A list whose changes can be tracked by list change listeners.
Observable Map.
A set whose changes can be tracked by set change listeners.
Marker interface for all listener types in the observables framework.
A value whose changes can be tracked by value change listeners.
Mixin interface for IObservables that observe other objects.
A console that displays text from I/O streams.
InputStream used to read input from an IOConsole.
OutputStream used to write to an IOConsole.
Listener for open events which are generated on selection of default selection depending on the user preferences.
A listener which is notified of open events on viewers.
IOperationApprover defines an interface for approving the undo or redo of a particular operation within an operation history.
Extends IOperationApprover to approve the execution of a particular operation within an operation history.
IOperationHistory tracks a history of operations that can be undone or redone.
This interface is used to listen to notifications from an IOperationHistory.
Represents a list of tabs.
A content provider for the tabbed property sheet page's list of tabs.
This interface defines a visual component which may serve text viewers as an overview annotation presentation area.
Extension interface for IOverviewRuler.
Implementors of this interface answer one of the prescribed return codes when asked whether to overwrite a certain path string (which could represent a resource path, a file system path, etc).
This interface has been replaced by IPageBookViewPage but is preserved for backward compatibility.
Interface for a page in a pagebook view.
A listener which is notified when the current page of the multi-page dialog is changed.
Minimal interface to a page change provider.
A listener which is notified when the current page of a multi-page dialog is changing.
A page layout defines the initial layout for a perspective within a page in a workbench window.
Interface for listening to page lifecycle events.
A page service tracks the page and perspective lifecycle events within a workbench window.
The primary interface between a page and the outside world.
A painter is responsible for creating, managing, updating, and removing visual decorations on an ITextViewer's text widget.
Manages and updates positions used by IPainters.
A parameter for a command.
An instance of this interface can be used by clients to receive notification of changes to one or more instances of ParameterType.
The parameters for a command.
A participant descriptor filter allows clients to provide additional filters on participant selection.
A partition token scanner returns tokens that represent partitions.
 
Interface for listening to part lifecycle events.
Interface for listening to part lifecycle events.
Form parts can implement this interface if they want to be notified when another part on the same form changes selection state.
A part service tracks the creation and activation of parts within a workbench page.
This interface abstracts the password store.
A path is an ordered collection of string segments, separated by a standard separator character, "/".
This interface defines an editor input based on the local file system path of a file.
Describes a change in a path variable.
An interface to be implemented by objects interested in path variable creation, removal and value change events.
Manages a collection of path variables and resolves paths containing a variable reference.
A pattern match listener is registered with a TextConsole, and is notified when its pattern has been matched to contents in that console.
A pattern match listener delegate is notified of regular expression matches in a text console.
Objects implementing this interface are capable of saving their state in an IMemento.
Tagging interface for IAnnotationModel implementers that offer state persistence.
An editor can implement this interface and participate in the workbench session save/restore cycle using IMemento, similar to how IViewPart currently works.
Interface for asking an object to store its state in a memento.
A source locator that can be persisted and restored, to be used with a specific launch configuration.
Extensions to the IPersistableSourceLocator interface.
IPersistentPreferenceStore is a preference store that can be saved.
A perspective descriptor describes a perspective in an IPerspectiveRegistry.
A perspective factory generates the initial page layout and visible action set for a page.
Interface for listening to perspective lifecycle events.
Extension interface to IPerspectiveListener which adds support for listening to part-specific perspective lifecycle events.
Extension interface to IPerspectiveListener which adds support for listening to perspective open and close events.
Extension interface to IPerspectiveListener which adds support for listening to perspective pre-deactivate events.
The workbench's global registry of perspectives.
Describes a set of provisioning phases to be performed by an IEngine.
To correctly implement pipelining you should implement IPipelinedTreeContentProvider2 which provides the additional ITreeContentProvider.hasChildren(Object) method.
A pipelined content provider allows an extension to reshape the contributions of an upstream content extension.
An IPlaceholderFolderLayout is used to define the initial view placeholders within a folder.
Planners are responsible for determining what should be done to a given profile to reshape it as requested.
Deprecated.
The org.eclipse.update component has been replaced by Equinox p2.
Feature entry.
Configuration entry representing an install site.
Site policy.
Deprecated.
The org.eclipse.update component has been replaced by Equinox p2.
An interface that descriptor classes may implement in addition to their descriptor interface.
A Pool allows semantically equivalent objects to be shared.
A position updater is responsible for adapting document positions.
Selection provider extension interface to allow providers to notify about post selection changed events.
Defines the interface for a rule used in the scanning of text for the purpose of document partitioning or text styling.
The IPreferenceConstants are the internal constants used by the Workbench.
Preference filters are used to describe the relationship between the preference tree and a data set when importing/exporting preferences.
Provides metadata-based access to a preference store.
Interface to a node in a preference dialog.
This interface is implemented by objects that visit preference nodes.
An interface for a preference page.
An interface used by a preference page to talk to its dialog.
The container of the secure preferences.
The preference service provides facilities for dealing with the default scope precedence lookup order, querying the preference store for values using this order, accessing the root of the preference store node hierarchy, and importing/exporting preferences.
A monitor that can be notified about status changes.
The IPreferenceStore interface represents a table mapping named preferences to values.
A presentation damager is a strategy used by a presentation reconciler to determine the region of the document's presentation which must be rebuilt because of a document change.
The presentation engine is used to translate the generic workbench model into widgets.
An IPresentationReconciler defines and maintains the representation of a text viewer's document in the presence of changes applied to the document.
Extension interface for IPresentationReconciler.
A presentation repairer is a strategy used by a presentation reconciler to rebuild a damaged region in a document's presentation.
This interface describes private credentials added by the Equinox login modules.
A process represents a program running in normal (non-debug) mode.
A process factory is used to override default process (IProcess) creation by the debug plug-in, and can be contributed via plug-in XML.
Describes a processing step.
Products are the Eclipse unit of branding.
These constants define the set of properties that the UI expects to be available via IProduct.getProperty(String).
Product providers define products (units of branding) which have been installed in the current system.
Represents the state of a profile in a profile registry at a given moment in time.
Interface for a provisioning job that operates on a profile.
A profile change request is a description of a set of changes that a client would like to perform on a profile.
An event indicating that a profile has been added, removed, or changed.
This encapsulates the access to the profile registry.
Constants relating to progress UI functionality of the workbench plug-in.
Constants relating to progress UI functionality of the workbench plug-in.
The IProgressMonitor interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
Deprecated.
The progress service is the primary interface to the workbench progress support.
A project is a type of resource which groups resources into buildable, reusable units.
Describes the public attributes for a project and the acceptable values each may have.
A project description contains the meta-data required to define a project.
Implementers registered with a ProjectionViewer get informed when the projection mode of the viewer gets enabled and when it gets disabled.
An IProjectionPosition is a position that is associated with a ProjectionAnnotation and that is able to compute its collapsed regions.
Interface for project nature runtime classes.
A project nature descriptor contains information about a project nature obtained from the plug-in manifest (plugin.xml) file.
Deprecated.
Marker interface for all property types in the properties framework.
Listener for property changes.
Interface common to all objects that provide a means for registering for property change notification.
A descriptor for a property to be presented by a standard property sheet page (PropertySheetPage).
Interface for listening for property changes on an object.
Provides access to the details of property observables
IPropertySheetEntry describes the model interface for the property sheet.
Listener for changes in objects of type IPropertySheetEntry.
Interface for a property sheet page that appears in a property sheet view.
Interface to an object which is capable of supplying properties for display by the standard property sheet page implementation (PropertySheetPage).
Extension to the standard IPropertySource interface.
Interface used by PropertySheetEntry to obtain an IPropertySource for a given object.
A property tester can be used to add additional properties to test to an existing type.
A prototype attributes label provider is contributed as an optional attribute of a launchConfigurationType extension and is responsible for displaying launch configurations prototype attributes of that type.
Describes a capability that is exposed by an installable unit.
Sometimes it might be desirable to pass some context information to the password provider modules (such as a need to run without UI prompts).
A provisioning agent is comprised of a modular, extensible set of related services.
An OSGi service that is used to create or obtain instances of an IProvisioningAgent.
A provisioning plan describes a proposed set of changes to a profile.
Event which describes a change in the proxy information managed by the IProxyService.
A listener that, when registered with the IProxyService, gets notified when the proxy information changes.
An IProxyData contains the information that is required to connect to a particular proxy server.
Manages the proxy data and related information.