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.
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.
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.
use
AnnotationRulerColumn(int)
instead.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.
As of 3.4, replaced by
AnnotationPainter.UnderlineStrategyUnderline 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
IBaseLabelProviderUsing 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 regionsThe 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
TableViewerThis 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.
This class is used in the win32 implementation only to support
adjusting widgets in the common package to DPI changes
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 color config to format the CSSValue string color.
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 insteadA 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 insteadDefault 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
TextViewerUndoManagerContent 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.
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.
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
ProjectExplorerAction 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.
Deprecated.
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 directlyA 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 activationA 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.
ICSSPropertyHandler2 delegate.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.Extension to
IDocumentInformationMapping.Extension to
IDocumentInformationMapping.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, useImplementers 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 interfaceA 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 fileRepresents 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 insteadAn 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
IInformationControlCreatorExtension 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 proxy to an
ILaunchConfigurationDelegate.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
ImageUtilitiesManaged 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 instances of
CommonDragAdapterAssistant and
CommonDropAdapterAssistant for the associated
INavigatorContentService.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.
Use
RepositoryProviderType.getProjectSetCapability()
to obtain an instance of ProjectSetCapability instead.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.
This interface describes public credentials added by the Equinox login
modules.
The root interface for all queries that can be performed on an
IQueryable.An IQueryable contains objects, and is able to perform queries on those
objects.
A listener for changes to the set of search queries.
An IQueryResult represents the results of a query.
An extension of the
IQuery that allows use of indexes.Implementations of this interface are used to compute some extra content for
the Quick Access features, using extension point
org.eclipse.ui.quickaccess.Extension interface for
IQuickAccessComputer that provides ability to
compute a new extra set of proposals whenever filter change.An
IQuickAssistAssistant provides support for quick fixes and quick assists.Extends
IQuickAssistAssistant with the following function:
allows to get a handler for the given command identifier
allows to enable support for colored labels in the proposal popup
Context information for quick fix and quick assist processors.
Quick assist processor for quick fixes and quick assists.
The protocol a reference provider for Quick Diff has to implement.
Allows an annotation to tell whether there are quick fixes
for it and to cache that state.
For breaking an object to compare into a sequence of comparable entities.
Extension interface for actions.
Tagging interface for a model that can get reconciled during a
reconcile step.
An
IReconciler defines and maintains a model of the content of the text viewer's
document in the presence of changes applied to this document.Tagging interface for the reconcile step
result's array element type.
Extends
IReconciler with
the ability to be aware of documents with multiple partitionings.A reconcile step is one of several steps of a
reconcile strategy that
consists of several steps.
A reconciling strategy is used by an reconciler to reconcile a model based on text of a
particular content type.
Extends
IReconcilingStrategy
with the following functions:
usage of a progress monitor
initial reconciling step: if a reconciler runs as periodic activity in the background, this
methods offers the reconciler a chance for initializing its strategies and achieving a
reconciled state before the periodic activity starts.
Status codes used by the refactoring core plug-in.
Interface for refactoring execution listeners.
Control which is capable of displaying parts of a refactoring history.
Interface for refactoring history listeners.Clients may register a
refactoring history listener with the
IRefactoringHistoryService
obtained by calling RefactoringCore.getHistoryService() in order to
get informed about refactoring history events.Interface for a refactoring history service.
Comparator class to compare two refactoring status entries.
Status codes used by the refactoring UI plug-in.
An
IRefreshMonitor monitors trees of IResources
for changes in the local file system.An
IRefreshResult is provided to an auto-refresh
monitor.A region describes a certain range in an indexed text store.
A register is a special kind of variable that is contained
in a register group.
A register group is a group of registers that are
assigned to a stack frame.
Registry change events describe changes to the extension registry.
Note: for new implementations consider using
IRegistryEventListener.A registry event listener is notified of changes to extension points.
Implement this interface to specify a contributed extension registry.
Tagging interface to be implemented by
IDocument implementers that offer a line
repair method on the documents.Extension interface for
IRepairableDocument.An extension interface to
ISearchPage.A memory rendering that can be repositioned.
A p2 repository contains either metadata or artifacts related to software
provisioning.
The common base class for metadata and artifact repository managers.
Common base interface for an asynchronously processed request.
Requestor represents an atomary operation performed during the injection.
A requirement represents some external constraint on an
IInstallableUnit.A memory rendering that can be reset.
The workspace analog of file system files
and directories.
Describes the public attributes for a resource and the acceptable values
each may have.
This factory is used to build a resource delta that represents a proposed
change that can then be passed to the
ResourceChangeValidator.validateChange(IResourceDelta, IProgressMonitor)
method in order to validate the change with any model providers stored in
those resources.Resource change events describe changes to resources.
A resource change listener is notified of changes to resources in the
workspace.
A resource delta represents changes in the state of a resource tree
between two discrete points in time.
An objects that visits resource deltas.
A resource diff represents the changes between two resources.
A resource diff tree provides access to a tree of
IDiff instances
that either contain IResourceDiff nodes or IThreeWayDiff
nodes that contain IResourceDiff nodes as the local and remote
changes.A description of a resource filter.
Resources locator to get
InputStream or Reader from an URI.An
IResourceMapper provides methods to map an original
resource to its refactored counterparts.The purpose of this interface is to provide support for model level
auto-merging.
This interface documents the property constants used by the resource
property source.
A lightweight interface for requesting information about a resource.
This interface is implemented by objects that visit resource trees.
A resource rule factory returns scheduling rules for API methods
that modify the workspace.
Resources locator manage to register/unregister
IResourceLocator.IResourceSnapshot is a lightweight snapshot that describes the common
attributes of a resource to be created.
Interface Resources Registry to cache Resources and dispose it if need.
Represents status related to resources in the Resources plug-in and
defines the relevant status code constants.
Provides internal access to the workspace resource tree for the purposes of
implementing the move and delete operations.
This interface describes a utility that is used to load ImageDesc's from
URIsThis interface is used by
SyncInfo instances
to provide access to the base and remote resources that correspond to
a local resource.An
IResourceVariantComparator is provided by a Subscriber
and used by a SyncInfo to calculate the sync
state of the workspace resources.A handle that provides access to locally cached resource variants that
represent a resource line-up such as a project version or branch.
This interface is implemented by objects that visit resource trees.
A restart command allows the debugger to quickly restart the current debug
session without terminating and re-launching.
A resume handler typically resumes execution of a suspended thread or target.
Interface for reusable editors.
A listener which is notified when revision information changes.
A vertical ruler column capable of displaying revision (annotate) information.
Extension interface for
IRevisionRulerColumn.Rendering mode type-safe enum.
A target publishing the required functions to modify a document that is displayed
in a text viewer.
Defines the interface for a rule used in the scanning of text for the purpose of document
partitioning or text styling.
Interface for UI components which can execute a long-running operation
in the form of an
IRunnableWithProgress.The
IRunnableWithProgress interface should be implemented by any
class whose instances are intended to be executed as a long-running operation.The
IRunnableWithProgress interface should be implemented by any
class whose instances are intended to be executed as a long-running operation.An adapter for a "run to line" operation.
SAC parser factory interface to get instance of SAC
Parser.Safe runnables represent blocks of code and associated exception handlers.
Runs a safe runnables.
Safe runnables represent blocks of code and associated exception handlers.
A filter for selecting Saveables.
Workbench parts implement or adapt to this interface to participate in the
enablement and execution of the
Save and Save As
actions.Workbench parts implement or adapt to this interface to participate in
actions that require a prompt for the user to provide input on what to do
with unsaved data when the part is closed or the Workbench is shut down.
Listener for events fired by implementers of
ISaveablesSource.Represents a source of Saveable objects (units of saveability).
Deprecated.
Clients should use a subclass of
CompareEditorInput
and CompareUI.openCompareDialog(org.eclipse.compare.CompareEditorInput)A context for workspace
save operations.A data structure returned by
IWorkspace.addSaveParticipant(org.eclipse.core.runtime.Plugin, ISaveParticipant)
containing a save number and an optional resource delta.A participant in the saving of the workspace.
Interface defines API for checking if an object, preferably an instance of
Saveable, is being saved.An interface to mark an operation that needs an
ISchedulingRule.Scheduling rules are used by jobs to indicate when they need exclusive access
to a resource.
A scheduling rule provider provides a scheduling rule which
can be used when running operations.
An instance of
ISchemeListener can be used by clients to
receive notification of changes to one or more instances of
IScheme.IScmUrlImportWizardPage defines the interface that users of the extension
point
org.eclipse.team.ui.scmUrlImportPages must implement.Clients contributing a scope to the Eclipse preference system must implement
this interface to aid Eclipse in creating a new node for the hierarchy.
Clients implement this interface to provide context to a particular scope.
Container class for associating AbstractHelpScopes with an ID
A scroll lock provider allows a client to control the scroll lock state of
its container, e.g. a view.
Represents a document in the search index.
This interface allows editors to provide customized access to editor internals for the
search implementation to highlight matches.
A search engine that is a participant in the help search.
An extension of the search engine interface that provides for opening of the results.
A search result created by the help search engine.
An extension of the search result interface that allows engines to define engine result icon for
each search result.
A collector for the search hits (asynchronously) returned by the help search
participants.
Interface to be implemented by contributors to the extension point
org.eclipse.search.searchPages.Offers client access to the search dialog.
Computes a score that is used by the search dialog
to find the best fitting page for a selection when opened.
Represents a particular search query (in a Java example, a query might be
"find all occurrences of 'foo' in workspace").
This class holds information for a single Search Result
Implementors of this interface represent the result of a search.
Listener interface for changes to an
ISearchResult.Interface to be implemented by contributors to the extension point
org.eclipse.search.searchResultViewPages.
Interface for the search result view.
The generic search scope object.
Creates search scope objects from the provided preference store.
Preference pages that are used for editing help search scope settings should
implement this interface.
Interface for parts providing an adapter to
ISaveablePart objects
created or managed originally by other parts.Represents a section of properties for a given input.
Represents a section descriptor on the tabbed property sections extensions.
Represents a section descriptor provider for tabbed property sections.
This interface describes functionality provided by secure preferences.
Interface for a selection.
A listener which is notified when a viewer's selection changes.
A service that is capable of converting a selection into resources.
Interface for listening to selection changes.
Interface common to all objects that provide a selection.
A selection service tracks the selection within an object.
Used in selection dialogs to validate selections
A selection validator allows clients to test whether the selection they
received during selection changed notification is valid.
For validating selections in some selection dialogs.
A component with which one or more services are registered.
Different levels of service locators supported by the workbench.
A service that responds to changes in one or more sources.
Listener for changes to observable sets.
Interface for set-typed properties
Interface for views which support reveal and select.
A tagging interface to share a concrete
RefactoringParticipant instance across
multiple elements to be refactored.An
ISharedDocumentAdapter is used to map an
ITypedElement to a shared document for the purposes of editing.Images that are available for providers to re-use.
A registry for common images used by the workbench which may be useful to
other plug-ins.
Manages SWT color objects.
Interface for objects that can return a shell.
Shows the given editor input.
Parts which need to provide a particular context to a Show In... target can
provide this interface.
This interface must be provided by Show In targets (parts listed in the Show
In prompter).
Show In sources which need to provide additional entries to the Show In list
of targets can provide this interface.
An
ISideEffect allows you to run code whenever one or more
observables change.
A factory to create
ISideEffect objects, which are applied to the
given Consumer in ISideEffectFactory.createFactory(Consumer).Listener for changes to properties on a particular source object
Interface implemented by objects that are capable of computing a preferred
size.
Slave documents are documents whose contents is defined in terms of a master
document.
Extension interface for
ISlaveDocumentManager.Extension interface to
IRefactoringHistoryControl which provides
facilities to set the sort mode of a refactoring history control.A source container is a container of source code.
Creates and edits source containers for a source lookup director.
A source container type represents a kind of container of source code.
A source container type delegate represents a kind of container of source code.
Displays source for a debug model element.
A source locator locates source elements for stack frames.
A source lookup director directs the source lookup process
among a set of participants and source containers.
A source lookup participant participates in source lookup by searching an ordered
list of source containers for source elements corresponding to a debug artifact.
The result of performing source lookup on a debug artifact.
A source modifier can be used to modify the source of
a move or copy edit before it gets inserted at the target
position.
A source path computer computes the default source lookup path (set of source
containers that should be considered) for a launch configuration.
A source path computer delegate computes the default source lookup path
(set of source containers that should be considered) for a launch
configuration.
A source presentation is used to resolve an editor in which to display a
debug model element, breakpoint, or source element.
A provider of notifications for when a change has occurred to a particular
type of source.
A listener to changes in a particular source of information.
A service from which all of the source providers can be retrieved.
A source is type of event change that can occur within the workbench.
In addition to the text viewer functionality a source viewer supports:
visual annotations based on an annotation model
visual range indication
management of text viewer add-ons
explicit configuration
It is assumed that range indication and visual annotations are shown inside the same presentation
area.
Extension interface for
ISourceViewer.Extension interface for
ISourceViewer.Extension interface for
ISourceViewer.Extension interface for
ISourceViewer.Extension interface for
ISourceViewer.A spelling engine that can be contributed to the
org.eclipse.ui.workbench.texteditor.spellingEngine extension
point.Contributors to the
org.eclipse.ui.texteditor.spellingEngine
extension point can specify an implementation of this interface to be
displayed on the spelling preference page, if the corresponding engine is
selected.A collector of
SpellingProblems.A stack frame represents an execution context in a suspended thread.
Listener for staleness events.
An Intro standby part.
Plug-ins that register a startup extension will be activated after the
Workbench initializes and have an opportunity to run code that can't be
implemented using the normal contribution mechanisms.
A listener to changes in some state.
Implementers of
IFileBuffer may also
implement IStateValidationSupport in order to allow a
IFileBufferManager to batch the stages
of state validation when calling
IFileBufferManager.validateState(IFileBuffer[], org.eclipse.core.runtime.IProgressMonitor, Object).A status object represents the outcome of an operation.
This interface contains common constants important for
StatusAdapter.Viewer to present the context object of a refactoring status entry.
Interface of a status field of a text editor.
Extends
IStatusField with the following
concepts:
set error text and image
set tool tip
control visibility
A status handler registers to handle a specific status - error or otherwise.
The
IStatusLineManager interface provides protocol for
displaying messages on a status line, for monitoring progress, and for
managing contributions to the status line.Provides the ability to step into, over, and return
from the current execution location.
Provides the ability to filter out steps based on some object.
Support for step filters for a debug target.
A step filters handler typically toggles the use of step filters
in a debug session based on the user preference setting.
A step into handler typically steps into the next instruction to
be executed.
A step over handler typically steps over the next instruction or line
of code to be executed.
A step return handler typically steps out of the current method or function
that the debugger is suspended in.
Supplemental view interface that describes various sticky characteristics
that a view may possess.
A storage object represents a set of bytes which can be accessed.
Document provider for
IStorage based domain elements.Interface for a
IStorage input to an editor.This interface defines a single operation for performing a three-way merge on three
instances of
IStorage.An
IStreamContentAccessor object represents a set of bytes which can be
accessed by means of a stream.Implementations of
NodeList that implemented
NodeList.getLength() and NodeList.item(int) can use this
interface to optimize the streaming of their children.A stream listener is notified of changes
to a stream monitor.
Deprecated.
Clients should use
org.eclipse.team.core.mapping.IStorageMerger instead.A stream monitor manages the contents of the stream a process
is writing to, and notifies registered listeners of changes in
the stream.
A streams proxy acts as proxy between the streams of a
process and interested clients.
Extension to a streams proxy that allows closing of the output stream
connected to the standard input stream of a proxy's process.
A simple interface for mappings from a string (usually a file name or a file
extension) and a content type (typically
Team.TEXT,
Team.BINARY or Team.UNKNOWN.A variable that can be referenced in an expression, which resolves to a
string value.
Registry for string variables.
Interface used to compare hierarchical structures.
Interface used to create a hierarchical structure of
IStructureComparators for a given input object.An extension to the
IStructureCreator interface that supports the
use of shared documents.An interface to content providers for structured viewers.
A selection containing elements.
Provides advanced methods for processing bidirectional text with a specific
structure to ensure proper presentation.
Used in
FilteredItemsSelectionDialog to highlight matches in the list
of matching itemsDeprecated.
As of 3.2, replaced by Platform UI's field assist support
Deprecated.
As of 3.2, replaced by Platform UI's field assist support
Deprecated.
As of 3.2, replaced by Platform UI's field assist support
Deprecated.
As of 3.2, replaced by Platform UI's field assist support
A change event that describes a change in a resource that is or was
supervised by a subscriber.
A subscriber change listener is notified of changes to resources
regarding their subscriber synchronization state.
A suspend handler typically suspends an executing thread or target.
Provides the ability to suspend and resume a thread
or debug target.
A suspend trigger notifies listeners when a launch suspends at a context
where debugging should begin.
Listeners are notified when a launch has suspended at a context
where debugging should begin.
IObservable observing an SWT widget.IObservableList observing an SWT widget.IObservableValue observing an SWT widget.Interface for text related objects which may be used in the multi-threaded
context and thus must provide a way to prevent concurrent access and
manipulation.
The compare adapter provides compare support for the model objects
associated with a model provider.
This interface defines extensions to the
ICompareInput
interface that are used for compare inputs that are returned from the
ISynchronizationCompareAdapter.asCompareInput(org.eclipse.team.core.mapping.ISynchronizationContext, Object)
method.A file buffer manager (see
IFileBufferManager) uses an
ISynchronizationContext in order to execute commands encapsulated as
Runnable.Allows a model provider to build a view of their model that includes
synchronization information with a remote location (usually a repository).
Interface which defines the protocol for translating a set of
ResourceMapping objects representing a view selection into the
complete set of resources to be operated on.Listener for synchronization scope changes.
A scope manager is responsible for ensuring that the resources contained
within an
ISynchronizationScope stay up-to-date with the model
elements (represented as ResourceMapping instances) contained in the
scope.A scope participant is responsible for ensuring that the resources contained
within an
ISynchronizationScope that overlap with the participant's
model provider stay up-to-date with the model elements (represented as
ResourceMapping instances) contained in the scope.Factory interface for creating a participant for use with an
ISynchronizationScopeManager.Manages synchronization view participants.
Listener that gets informed when the model created by the model provider is created or updated.
These are elements created to display synchronization state to the user.
Interface for
Page subclasses that can appear in
the synchronize view ISynchronizeView and other views, editors or
dialogs that display synchronization information.Configures the model, actions and label decorations of an
ISynchronizePage.A site which provides access to the context in which this page
is being displayed.
A synchronize participant is a visual component that can be displayed within any
control (e.g. view, editor, dialog).
A participant descriptor contains the content of the
synchronizeParticipants extension section for
for a registered participant type in the declaring plug-in's
manifest (plugin.xml) file.A synchronize participant listener is notified when participants are added or
removed from the synchronize manager.
A reference is a light weight handle used by the
ISynchronizeManager
to manage registered participants.A synchronizer which maintains a list of registered partners and, on behalf of
each partner, it keeps resource level synchronization information
(a byte array).
Listener that can receive notification from a
ThreeWaySynchronizer
when the synchronization state of one or more resources has changed.A synchronize scope defines the set of resources involved in a
synchronization.
A view that displays synchronization participants that are registered with the
synchronize manager.
An event generated when a
SyncInfoSet collection is changed.Classes which implement this interface provide methods that deal with the
change events that are generated by a
SyncInfoSet.This is a change event that provides access to changes in subtrees
that contain the out-of-sync resources.
Collects the system information for the "about"-related functionality.
Extensions to
org.eclipse.ui.systemSummaryExtensions must
provide an implementation of this interface.Constants used by the implementors of ITabbedPropertySection.
Interface for a workbench part to contribute content to the tabbed property
view.
Represents a tab descriptor for the tabbed property view.
Represents a tab descriptor provider for the tabbed property view.
Represents a tab to be displayed in the tab list in the tabbed property sheet
page.
Interface to provide color representation for a given cell within
the row for an element in a table.
The ITableFontProvider is a font provider that provides fonts to
individual cells within tables.
Extends
IBaseLabelProvider with the methods
to provide the text and/or image for each column of a given element.A listener interested in tab selection events that occur for the tabbed
property sheet page.
ITags can be used to hang additional repository information for IFileRevisions.
ITaskListResourceAdapter is an adapter interface that
supplies the resource to query for markers to display in the task list.A description of a single extension registered with the
org.eclipse.team.ui.teamContentProviders
extension pointThe team content provider manager provides access to the content
extenstions registered with the
org.eclipse.team.ui.teamContentProviders
extension point.A description of the team state changes that have occurred.
A listener registered with an
TeamStateProvider in order to
receive change events when the team state of any
resources change.A description of the the state of a logical model element with respect to a
team repository.
A team state provider is used by the
SynchronizationStateTester
to obtain the team state for model elements.Defines the status codes used in the status of exceptions and errors relating to Team.
This class is the abstract superclass of all non-windowed
user interface objects that occur within specific controls.
CSSStylableElement implementation which wrap SWT Item.An implementation of the model object 'Item'.
Interface for a templates page.
Extension interface for
ITemplatesPage.A representation of the literals of the enumeration 'Item Type',
and utility methods for working with them.
Provides the ability to terminate an execution
context - for example, a thread, debug target or process.
A terminate handler typically terminates an executing thread or target.
Represents a test case element.
Common protocol for test elements.
A failure trace of a test.
Result states of a test.
Represents an arbitrary test harness.
An interface to be implemented by a Test Runner Client.
Represents a test run session.
Represents a test suite element.
Interface to be implemented by a Test View Support to be returned by
org.org.eclipse.unittest.unittestViewSupport extension.
Text content describers extend basic content describers to provide
the ability of scanning character streams (readers).
A text double click strategy defines the reaction of a text viewer to mouse
double click events.
Interface to a text editor.
Defines the names of those actions which are pre-registered with the
AbstractTextEditor.Defines the definitions ids for the text editor actions.
Interface to be implemented by SWT drop target listeners to be used with
AbstractTextEditor.Extension interface for
ITextEditor.Extension interface for
ITextEditor.Extension interface for
ITextEditor.Constitutes entities to enumerate the editor insert modes.
Extension interface for
ITextEditor.Extension interface for
ITextEditor.Extension interface for
ITextEditor.Help context IDs for the text editor.
A text file buffer is a file buffer for text files.
A text file buffer manager manages text file buffers for files whose contents
is considered text.
Computes the information to be shown in a hover popup which appears on top of the text viewer's
text widget when a hover event occurs.
Extension interface for
ITextHover.Extension interface for
ITextHover.Text input listeners registered with an
ITextViewer are informed if the document
serving as the text viewer's model is replaced.Text listeners registered with a text viewer are informed about all
modifications of an
ITextViewer by means of
text events.Defines the target for text operations.
Extension interface for
ITextOperationTarget.Text presentation listeners registered with an
ITextViewer are informed when a
TextPresentation is about to be applied to the
text viewer.This interface represents a textual selection.
Interface for storing and managing text.
A text viewer connects a text widget with an
IDocument.Extension interface for
ITextViewer.Extension interface for
ITextViewer.Deprecated.
replaced by
ITextViewerExtension5Extension interface for
ITextViewer.Extension interface for
ITextViewer.Extension interface for
ITextViewer.Extension interface for
ITextViewer.Extension interface for
ITextViewer.Type-safe enum of the available enrich modes.
Extension interface for
ITextViewer.ITextViewer lifecycle API to track install / uninstall of a given ITextViewer for
the given contribution which extends ITextViewerLifecycle:
IReconciler
IPresentationReconciler
IHyperlinkPresenter
DefaultInformationControl.IInformationPresenter
IContentAssistant
It is possible too to implement ITextViewerLifecycle to track install / uninstall of a
given ITextViewer for implementation of:
IReconcilingStrategy
IAutoEditStrategy
A theme which is composed of stylesheets and resources
A theme is a collection of colors, fonts and supporting data that may be used
by plugins to help provide uniform look and feel to their components.
The theme engine collects available themes (who are composed of stylesheets)
and provides the possibility to change the theme
The IThemeEngine may broadcast an event using the OSGi EventAdmin
service, if available, to notify of theme changes.
Manages the theme engines for displays.
A theme manager is an object that contains references to usable
ITheme objects and maintains a reference to the currently active
theme.Interface used by theme element developers to preview the usage of their
elements within the colors and fonts preference page.
A thread is a sequential flow of execution in a debug target.
A thread listener is an object that is interested in receiving notifications
of thread changes.
A three-way delta that describe the synchronization state between two
contributors and an ancestor.
An
IToc represents the root node of a toc, for either a complete
toc (book) or a part of one to be assembled into a larger one.IToc2 extends IToc by adding methods to support functionality
for criteria, topic sorting and custom iconsRepresents either a complete or partial table of contents, as well as
its metadata.
An adapter to support breakpoint creation/deletion for an active part
or selection within an active part.
Extension interface for
IToggleBreakpointsTarget.Extension interface for
IToggleBreakpointsTargetExtension.A toggle breakpoints target factory creates one or more toggle breakpoint
targets.
Organizes the toggle breakpoints target factories contributed through the
extension point and keeps track of the toggle breakpoints target that
the factories produce.
Listener for changes in the preferred toggle targets in the toggle
breakpoints target manager.
A token to be returned by a rule.
For performing a so-called "token compare" on a line of text.
A token scanner scans a range of a document and reports about the token it finds.
The
IToolBarManager interface provides protocol for managing
contributions to a tool bar.Interface to provide tool tip information for a given element.
An
ITopic is one topic in the table of contents, which may
contain subtopics.ITopic2 extends ITopic by adding methods to support functionality
for criteria, topic sorting and custom iconsITouchpoint data instances contain the additional information needed by a touchpoint
to execute each engine phase it participates in.
A touchpoint instruction contains either a sequence of instruction statements
to be executed during a particular engine phase, or some simple string value
that is needed by a touchpoint to execute its phases.
Identifies a particular touchpoint.
An interface to content providers for tree-structure-oriented
viewers.
An interface to content providers for tree-structure-oriented viewers that
provides content based on the path of elements in the tree viewer.
An extension to
ILabelProvider that is given the
path of the element being decorated, when it is available.A selection containing tree paths.
A listener which is notified when a tree viewer expands or collapses
a node.
TriggerPoint is a breakpoint property which defines a dependency relationship
between all the breakpoints of a workspace and trigger points defined in a
workspace.
A trigger point represents a place within the Workbench that has the
potential to enable activities.
The trigger point advisor is a mechanism provided by the workbench that is
consulted whenever code that is considered a trigger point is hit.
Contains a collection of known trigger points.
A two-way diff represents the changes between two states of the same object,
referred to as the "before" state and the "after" state.
Interface for getting the name, image, and type for an object.
A command parameter that has a declared type.
Describes a region of an indexed text store such as a document or a string.
Allows property sheet page contributors to map the input object type to a
domain model type.
An element in a UA document, which may have conditional enablement (may be
filtered based on certain conditions) and may have sub-elements, or children.
This class allows to deserialize
IInstallableUnits that have been serialized with IUSerializer.This interface represents a strategy for choosing an IEditorDescriptor for a
given file name.
IUndoableOperation defines an operation that can be executed, undone, and
redone.
An undo context is used to "tag" operations as being applicable to a certain
context.
An undo manager is connected to at most one
ITextViewer.An undo manager keeps track of performed changes.
Extension interface for
IUndoManager.Listener to monitor state changes of an
IUndoManager.Indicates the support of an update method.
An update descriptor is attached to an installable unit to describe what that
installable unit is capable of acting as an update for.
A query that searches for
IInstallableUnit instances that have
a property associated with the specified profile, whose value matches the provided value.This interface defines an editor input based on a URI.
Interface URI resolver to resolve URI.
This class allows to serialize a collection of
IInstallableUnits.A query interface to decide if a undo change whose validation check
returned a status unequal
RefactoringStatus.OK
should be executed or not.A factory to create
IValidationCheckResultQuery objects.Simple interface to provide a validation message text and a message type for
a given
ValidationStatusProvider.A validator.
A value represents the value of a variable.
Listener for changes to observable values.
Listener for pre-change events for observable values.
Notified of detailed value descriptions.
Provides the ability to modify the value of a variable in
a target.
Interface for value-typed properties
A variable with a value that can be set and retrieved.
Value variable initializers compute an initial value for a value
variable contributed by an extension, which is not defined with an initial
value.
A string variable listener is notified of variables as they are added
and removed from the string variable manager.
A variable represents a visible data structure in a stack frame
or value.
A variable resolver can be used to add additional variable resolving
strategies to an
EvaluationContext.A variable value editor allows the user to edit a variable's value.
An interface representing a (id,version) pair.
The IVersionFormat represents the Omni Version Format in compiled form.
This interface defines a visual component which may serve text viewers as an annotation
presentation area.
A vertical ruler column is an element that can be added to a composite
vertical ruler (
CompositeRuler).Extension interface for
IVerticalRuler.A vertical ruler is a visual component which may serve text viewers as an
annotation presentation area.
Extension interface for
IVerticalRulerInfo.Interface for listening to annotation related events happening on a vertical ruler.
An observable value whose changes can be vetoed by listeners.
Interface for an action that is contributed into a view's local tool bar,
pulldown menu, or popup menu.
Represents a categorization of views.
This is a view descriptor.
A factory object for
Viewer.A factory object for creating a
Viewers from a descriptor.Extends
IBaseLabelProvider with the methods
to update the label for a given element.IListProperty for observing a JFace viewerIObservable observing a JFace Viewer.IObservableList observing a JFace Viewer.IObservableSet observing a JFace Viewer.IObservableValue observing a JFace Viewer.ISetProperty for observing a JFace viewerA strategy interface for updating the elements in a
StructuredViewer.IValueProperty for observing a JFace viewerRepresents the layout info for a view or placeholder in an
IPageLayout.A view is a visual component within a workbench page.
Registered with a text viewer, view port listeners are informed about changes of a text viewer's
view port.
Defines a reference to an IViewPart.
The view registry maintains a list of views explicitly registered against the
view extension point..
The primary interface between a view part and the workbench.
A watch expression is an expression that is evaluated in the context
of a specific stack frame, thread, debug target, process, or launch.
A delegate which computes the value of a watch expression
when provided a context.
An optional adapter used to create a watch expression for a selected variable.
An optional adapter used to create a watch expression for a selected element.
Optional extension to the watch expression factory adapter to dynamically enable the
'Create Watch Expression' action, based on the selected variable.
A watch expression listener is notified when an
org.eclipse.debug.core.model.IWatchExpressionDelegate
completes an evaluation.The result of an evaluation performed by an
org.eclipse.debug.core.model.IWatchExpressionDelegate.A breakpoint that suspends when an associated variable is
read or written.
An opened Web browser instance (either internal or external).
Defines the interface by which
WhitespaceRule
determines whether a given character is to be considered
whitespace in the current context.
Provides a hook by which third-party code can contribute SWT widgets to a
menu, tool bar or status line.
IListProperty for observing an SWT WidgetA widget token keeper may require a widget token from an
IWidgetTokenOwner and release the token to the
owner after usage.Extension interface for
IWidgetTokenKeeper.In order to display information in a temporary window, a widget token must be
acquired.
Extension interface for
IWidgetTokenOwner.IValueProperty for observing an SWT WidgetA handler that can be inserted into the context of the application or a particular window to
determine whether the window should be closed or not.
Interface for listening to window lifecycle events.
Interface for a wizard.
A wizard category may contain other categories or wizard elements.
Interface for containers that can host a wizard.
IWizardContainer2 is a supplement to
IWizardContainer that adds a method for updating the size of
the wizard shell based on the contents of the current page.Base interface for all wizards defined via workbench extension points.
A wizard node acts a placeholder for a real wizard in a wizard
selection page.
Interface for a wizard page.
A registry describing all wizard extensions known to the workbench.
Defines the interface by which
WordRule
determines whether a given character is valid as part
of a word in the current context.A running instance of the workbench.
A workbench is the root object for the Eclipse Platform user interface.
Action ids for standard actions, groups in the workbench menu bar, and global
actions.
Defines the definitions ids for workbench actions.
An instance of this interface provides support for managing
IWorkbench activities.This adapter interface provides visual presentation and hierarchical
structure for workbench elements, allowing them to be displayed in the UI
without having to know the concrete type of the element.
Extension interface for
IWorkbenchAdapter that allows for color
and font support.Extension interface for
IWorkbenchAdapter that allows for
StyledString support.Web browser support.
Constants for all commands defined by the Eclipse workbench.
Interface providing special access for configuring the workbench.
General constants used by the workbench.
Deprecated.
Please use
IBindingService and
IContextService instead.Allow a menu contribution to be initialized with the appropriate service
locator.
This class defines constants for looking up resources that are available only
within the Eclipse UI and Eclipse UI Standard Components projects.
Help context ids for the workbench.
The interface that is used to access the workbench help system.
Interface for listening to workbench lifecycle events.
An instance of this interface provides support for managing a a shared
operations history and an shared undo context at the
IWorkbench
level.A workbench page consists of an arrangement of views and editors intended to
be presented together to the user in a single workbench window.
A workbench part is a visual component within a workbench page.
Extends
IWorkbenchPart, adding the name and status text properties.A part can provide arbitrary properties.
This interface describes the constants used for
IWorkbenchPart properties.Description of a workbench part.
The IWorkbenchPartOrientation is the interface that defines the orientation
of the part.
Implements a reference to a IWorkbenchPart.
The primary interface between a workbench part and the workbench.
This interface provides methods that allow introspection of workbench parts.
Preference ids exposed by the Eclipse Platform User Interface.
IWorkbenchPreferenceContainer is the class that specifies the workbench
specific preferences support.
Interface for workbench preference pages.
Interface for workbench property pages.
This interface is similar to
IWorkbenchPropertyPage with the addition
of support for multiple selection.The common interface between the workbench and its parts, including pages
within parts.
IWorkbenchPartProgressService is an IProgressService that adds API for jobs
that change the state in a IWorkbenchPartSite while they are being run.
A source of color/font/theme data constants used throughout the workbench.
Interface used for IWidget's contributed to the Workbench.
A workbench window is a top level window in a workbench.
Interface for an action that is contributed into the workbench window menu or
tool bar.
Interface providing special access for configuring workbench windows.
Interface for a pulldown action that is contributed into the workbench window
tool bar.
Extension of IWorkbenchWindowPulldownDelegate that allows the delegate
dropdown menu to be a child of a Menu item.
Implementors represent creation wizards that are to be contributed to the
workbench's creation wizard extension point.
IWorkingCopyManager is the interface for the working copy support for
references to shared preference nodes.
A working set holds a number of IAdaptable elements.
A working set edit wizard allows editing a working set using the
IWorkingSetPage associated with the working set.
Interface that describes a mechanism that may be provided by working set
extensions to help manage the addition of elements to working sets.
A working set manager stores working sets and provides property change
notification when a working set is added or removed.
A working set new wizard allows creating new working sets using a plug-in
specific working set page.
A working set page allows the user to edit an existing working set and create
a new working set.
A working set selection dialog displays the list of working sets available in
the workbench.
An
IWorkingSetUpdater can be used to dynamically update the
content of a working set.IWorkingSetUpdater2 can be used to restore the content of a
working set, if the working set content shouldn't be persisted by the framework.Workspaces are the basis for Eclipse Platform resource management.
Data structure for holding the multi-part outcome of
IWorkspace.computeProjectOrder.A workspace description represents the workspace preferences.
A root resource represents the top of the resource hierarchy in a workspace.
This interface is structurally equivalent to
ICoreRunnable.
JettyConfigurator provides API level access for creating configured instances
of a Jetty-based Http Service.
Provides configuration constants for use with JettyConfigurator.
Jetty Customizer allows one to customize Jetty contexts and connectors.
JFaceColors is the class that stores references
to all of the colors used by JFace.
JFacePreferences is a class used to administer the preferences used by JFace
objects.
Helper class for providing
IObservableValue instances for properties
of an object that fires property changes events to an
IPropertyChangeListener.Utility methods to access JFace-specific resources.
A collection of JFace Text functions.
Jobs are units of runnable work that can be scheduled to be run with the job
manager.
This adapter class provides default implementations for the
methods described by the
IJobChangeListener interface.JobGroups support throttling, join, cancel, combined progress and error reporting
on a group of jobs.
Action for joining two or more lines together by deleting the
line delimiters and trimming the whitespace between them.
The JSPFactory can be used in conjunction with
org.eclipse.equinox.http.registry and the Servlets extension point to allow
the use of JSPs declaratively with the extension registry.
JSPServlet wraps the Apache Jasper Servlet making it appropriate for running
in an OSGi environment under the Http Service.
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
This adapter class provides default implementations for the
methods described by the
KeyListener interface.
A dialog displaying a list of key bindings.
A keyboard shortcut.
Controls the keyboard input into the workbench key binding architecture.
An implementation of the model object 'Key Binding'.
This service provides a nestable implementation of a key binding service.
Helper class to make navigation key bindings work for the content assistant
and the quick assist assistant while the editor has focus.
NOTE: This interface defines an element that could be inserted into an
internal class called
KeyedHashSet.Instances of this class are sent as a result of
keys being pressed and released on the keyboard.
A cache for formatters.
Deprecated, for removal: This API element is subject to removal in a future version.
Please use org.eclipse.jface.bindings.keys.KeyFormatterFactory
Classes which implement this interface provide methods
that deal with the events that are generated as keys
are pressed on the system keyboard.
A factory class for
ILookup instances.
A
KeySequence is defined as a list of zero or more
KeyStrokes, with the stipulation that all
KeyStroke objects must be complete, save for the last one,
whose completeness is optional.Deprecated, for removal: This API element is subject to removal in a future version.
Please use org.eclipse.jface.bindings.keys.KeySequence
A wrapper around the SWT text widget that traps literal key presses and
converts them into key sequences for display.
A
KeyStroke is defined as an optional set of modifier keys
followed optionally by a natural key.Deprecated, for removal: This API element is subject to removal in a future version.
Please use org.eclipse.jface.bindings.keys.KeyStroke
A key that can be used to extract a localized property for a specified Locale
Instances of this class represent a non-selectable
user interface object that displays a string or image.
The LabelDecorator is an abstract superclass of ILabelDecorators
that support IDecorationContext.
This class provides a convenient shorthand for creating and initializing
Label.A label provider implementation which, by default, uses an element's
toString value for its text and null for its image.Event object describing a label provider state change.
A
LabelRetargetAction extends the behavior of RetargetAction.A special child node of a
TextEditChangeNode to represent
language elements which don't have an associated TextEditChangeGroup
.
Parses the preference that specifies which editor should be used when opening
a large file.
An editor and file size pair.
A launch is the result of launching a debug session
and/or one or more system processes.
Launches a launch configuration in a specific mode.
Deprecated.
The use of perspective based launch shortcuts has been deprecated
in the 3.1 release.
Default implementation of a launch configuration delegate.
A cascading sub-menu that shows all launch shortcuts pertinent to a
selection.
Action that launches a URL in a browser.
A layout controls the position and size
of the children of a composite widget.
Caches the preferred sizes of an array of controls
Contains various layout constants to be used in dialogs.
This is a specialized tool control used by the TrimBarLayout to modify the
layout mechanisms.
A LRU based ResourceManager Wrapper.
This object maintains a collection of elements, sorted by a comparator
given in the constructor.
This class encapsulates the functionality necessary to manage stacks of parts
in a 'lazy loading' manner.
Some static utility methods for handling labels on actions.
An expression encapsulating all of the information from legacy handler
submissions.
Provides access to resource-specific classes, needed to provide backwards
compatibility for resource-specific functions which could not be moved up
from the generic workbench layer to the IDE layer.
LicenseManager defines a service which records the licenses that have been
accepted in the course of installing or updating software.
An operation approver that enforces a strict linear undo.
An abstract class for detecting violations in a strict linear undo/redo
model.
An operation approver that prompts the user to see if linear undo violations
are permitted.
LineAttributes defines a set of line attributes that
can be modified in a GC.This event is sent when a line is about to be drawn.
Classes which implement this interface provide a method
that can provide the background color for a line that
is to be drawn.
Abstract implementation of a line breakpoint.
A hover for line oriented diffs.
Inlined annotation which is drawn in the line content and which takes some place with a given
width.
Abstract class for line content code mining.
A code mining that is positioned on end of a line.
Inlined annotation which is drawn before a line and which takes some place with a given height.
Abstract class for line header code mining.
A vertical ruler column displaying line numbers and serving as a UI for quick diff.
A vertical ruler column displaying line numbers.
Default implementation of
ILineRange.This event is sent when a line is about to be drawn.
Classes which implement this interface provide a method
that can provide the style information for a line that
is to be drawn.
Instances of this class represent a selectable
user interface object that displays a text with
links.
The model for linked mode, umbrellas several
LinkedPositionGroups.The UI for linked mode.
Exit flags returned if a custom exit policy wants to exit linked mode.
An exit policy can be registered by a caller to get custom exit
behavior.
Listener that gets notified when the linked mode UI switches its focus position.
A link target consists of a viewer and gets notified if the linked mode UI on
it is being shown.
A
Position on a document that knows which document it is
registered with and has a sequence number for tab stops.A group of positions in multiple documents that are simultaneously modified -
if one gets edited, all other positions in a group are edited the same way.
This class provides a convenient shorthand for creating and initializing
Link.Manages the link helpers which are used to define the behavior of
the link with editor function.
Instances of this class represent a selectable user interface
object that displays a list of strings and issues notification
when a string is selected.
List change event describing an incremental change of an
IObservableList object.Contains
Step interfaces for the fluent databinding API common for
one-way and two-way IObservableList bindings.Step for setting the from-end observable.
A config step for the end of a binding where data is read.
Step for setting the to-end observable.
Step for converting between from- and to-types.
Step for configuring the end of a binding where data is written.
A specialized content provider to show a list of editor parts.
A dialog that prompts for one element out of a list of elements.
Object describing a diff between two lists.
A single addition of an element to a list or removal of an element from a
list.
A visitor for processing differences in a ListDiff.
An abstract field editor that manages a list of input values.
Implementers of
Listener provide a simple
handleEvent() method that is used internally
by SWT to dispatch events.This class is a thread safe list that is designed for storing lists of
listeners.
The ListenerQueue is used to snapshot the list of listeners at the time the event
is fired.
Contains
Step interfaces for the fluent databinding API for one-way
IObservableList bindings.ListOneWaySteps.ListOneWayBindWriteConfigStep<F,T,THIS extends ListOneWaySteps.ListOneWayBindWriteConfigStep<F,T,THIS>>
Step for configuring the to-end and creating the binding.
Step for converting between from- and to-types.
Refines the return types of the
ListCommonSteps.ListFromStep methods for use with
one-way bindings.Step for setting the to-end observable.
Step for settings to-end observable using default converters.
Abstract implementation of IListProperty.
A standard dialog which solicits a list of selections from the user.
The Builder to create
ListSelectionDialog instances.Observable set backed by an observable list.
Contains
Step interfaces for the fluent databinding API for two-way
IObservableList bindings.ListTwoWaySteps.ListTwoWayBindConfigStep<F,T,THIS extends ListTwoWaySteps.ListTwoWayBindConfigStep<F,T,THIS>>
Step from configuring the to-end and creating the binding.
ListTwoWaySteps.ListTwoWayConfigStep<F,T,THIS extends ListTwoWaySteps.ListTwoWayConfigStep<F,T,THIS>>
Step from configuring the from-end.
Step for setting the to-from direction converter.
ListTwoWaySteps.ListTwoWayConvertToStep<F,THIS extends ListTwoWaySteps.ListTwoWayConvertToStep<F,THIS>>
Step for setting the from-to direction converter.
Refines the return types of the
ListCommonSteps.ListFromStep methods for use with
two-way bindings.Step for setting the to-end observable.
Step for settings to-end observable using default converters.
A concrete viewer based on an SWT
List control.A job that loads a set of metadata repositories and caches the loaded
repositories.
An
IObservableValue<LocalDateTime> which supports
scenarios where the date and time are presented as separate elements in the
user interface.Context function to provide the LocaleChangeServiceImpl to the application context.
Default implementation of
ILocaleChangeService that changes the Locale in the
specified IEclipseContext and additionally fires an event on the event bus.A service that is used to determine what the current locale is for a
particular context or session.
Implementation of storage for a local file
(
java.io.File).This class provides set of utility method that can be useful in typical
localization scenarios.
A local registry that shares its resources with some global registry.
A LocalSelectionTransfer may be used for drag and drop operations
within the same instance of Eclipse.
A Location represents a URL which may have a default value, may be read only, may
or may not have a current value and may be cascaded on to a parent location.
This adapter class provides default implementations for the
methods described by the
LocationListener interface.A
LocationEvent is sent by a Browser to
LocationListener's when the Browser
navigates to a different URL.Type-safe enum of the available location kinds.
This listener interface may be implemented in order to receive
a
LocationEvent notification when a Browser
navigates to a different URL.A lock listener is notified whenever a thread is about to wait
on a lock, and when a thread is about to release a lock.
A
LogFilter is used to pre-filter log requests before sending events to a LogListener.Logging warnings, errors, information, as well as capturing debug and trace information.
Provides named logger support for the OSGi LogService.
The LoginContextFactory class is the entry point for the login support for
the platform.
Indicates a bundle's authority to log on behalf of other bundles.
Stores a set of
LogPermission permissions.A representation of the model object 'Addon'.
The Factory for the model.
Thrown to indicate that an edit got added to a parent edit
but the child edit somehow conflicts with the parent or
one of it siblings.
Managed form wraps a form widget and adds life cycle methods for form parts.
Represents a managed output stream for target managed by a storage manager.
This class represents a single manifest element.
This class is used to localize manifest headers for a revision.
Map change event describing an incremental change of an
IObservableMap object.Deprecated.
This class is deprecated.
A representation of the model object 'Application'.
A representation of the model object 'Element'.
The Factory for the model.
Abstract implementation of IMapProperty
A representation of the model object 'Area'.
Paints a vertical line (margin line) after a given column respecting the text
viewer's font.
An action to handle emacs-like marked regions.
Annotation representing a marker on a resource in the workspace.
Objects of this class provide access to all extensions declared for the
markerAnnotationSpecification extension point.MarkerField is the abstract superclass of the definition of the content
providers for columns in a Markers View.
A MarkerFieldFilter is a filter on a particular marker field.
MarkerFilter is the class that defines a filter on markers in a
MarkerView.
MarkerGroupingEntry is the configuration object for the markerGroupingEntry
extension.
The MarkerItem class is the class that represents the objects displayed at
IMarker related views.MarkerMessages is the class that handles the messages for the markers.
The MarkerNode class is the class that handles category nodes and
concrete markers.
Dialog to allow the user to select from a list of marker resolutions.
A ruler action which can add and remove markers which have a visual
representation in the ruler.
Deprecated.
use
MarkerRulerAction insteadMarkerSupportConstants is a static class that supplies commonly used constants.
The ProblemFilterRegistryReader is the registry reader for declarative
problem filters.
The MarkerSupportView is a view that supports the extensions
in the markerSupport extension point.
A
MarkerTransfer is used to transfer an array of
IMarkers from one part to another in a drag and drop operation.Represents a marker type.
Maintains a model of all known marker types.
Utility class for accessing marker attributes.
MarkerViewHandler is the abstract class of the handlers for the
MarkerSupportViewUtility class for showing markers in the marker views.
Default implementation of
IMarkRegionTarget using ITextViewer
and IStatusLineManager.Default implementation of
IMarkSelection.Allows for the observation of an attribute, the detail, of an observable
representing selection or another transient instance, the master.
This class implements the 'master/details' UI pattern suitable for inclusion
in a form.
A textual match in a given object.
An event object describing addition and removal of matches.
A match filter is used to evaluate the filter state of a match (
Match.isFiltered().Highlights the peer character matching the character near the caret position, or a pair of peer
characters enclosing the caret position.
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.The Factory for the model.
The Factory for the model.
A representation of the model object 'Binding Context'.
A representation of the model object 'Bindings'.
A representation of the model object 'Binding Table'.
A representation of the model object 'Binding Table Container'.
A representation of the model object 'Category'.
A representation of the model object 'Command'.
A representation of the model object 'Command Parameter'.
The Factory for the model.
A representation of the model object 'Composite Part'.
A representation of the model object 'Context'.
A representation of the model object 'Contribution'.
A representation of the model object 'Core Expression'.
Deprecated.
A representation of the model object 'Direct Menu Item'.
A representation of the model object 'Direct Tool Item'.
A representation of the model object 'Dirtyable'.
A representation of the model object 'Dynamic Menu Contribution'.
A representation of the model object 'Element Container'.
A byte of memory in a memory block.
Defines constants for memory event handlers.
A memory rendering element represents a set of memory bytes being
rendered in a memory rendering.
Instances of this class are user interface objects that contain
menu items.
This adapter class provides default implementations for the
methods described by the
MenuListener interface.The Adapter Factory for the model.
An implementation of the model object 'Contribution'.
Instances of this class are sent whenever the platform-
specific trigger for showing a context menu is detected.
Classes which implement this interface provide methods
that deal with the events that are generated when the
platform-specific trigger for showing a context menu is
detected.
An implementation of the model object 'Element'.
Instances of this class are sent as a result of
menus being shown and hidden.
An implementation of the model Factory.
An implementation of the model object 'Menu'.
A descriptive construct to relay information about a menu insertion point;
including the name of the insertion point and whether the item should be
rendered as a separator or group marker.
Instances of this class represent a selectable user interface object
that issues notification when pressed and released.
An implementation of the model object 'Item'.
Classes which implement this interface provide methods
that deal with the hiding and showing of menus.
A menu manager is a contribution manager which realizes itself and its items
in a menu control; either as a menu bar, a sub-menu, or a context menu.
MenuManagerHideProcessor provides hooks for renderer processing
before and after the MenuManager calls out to its
IMenuManagerListener2 for the menuAboutToHide
events.Create a contribute part.
MenuManagerShowProcessor provides hooks for renderer processing
before and after the MenuManager calls out to its
IMenuManagerListener2 for the menuAboutToShow
events.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 implementation of the model object 'Separator'.
The Switch for the model's inheritance hierarchy.
Provides utilities and constants for use with the new menus API.
An abstract superclass that enables models to create handlers
for the basic merge operations (merge, overwrite and mark-as-merged).
Provides the context for an
IResourceMappingMerger.Wraps a JFace SourceViewer and add some convenience methods.
A special status that is returned when the return code
of the
merge method is CONFLICTS.Adapts any
ContentMergeViewer to work on an ICompareInput
e.g. a DiffNode.Annotation for message classes to control
contribution uri to point to resource bundles in a different location
caching behavior
Caching behaviors.
Instances of this class are used to inform or warn the user.
A console that displays messages.
Used to write messages to a message console.
Consumer interface that is used to bind a method of an object (e.g. a SWT
control) to a field of a Messages instance.
A dialog for showing messages to the user.
A message dialog which also allows the user to adjust a toggle setting.
Function interface that is used to bind a property of an object (e.g. a SWT
control) to a field of a Messages instance.
A message line displaying a status.
A message page display a message in a pagebook view.
Supplier interface that is used to bind a method of an object (e.g. a SWT
control) to a field of a Messages instance.
A factory class for instantiating various p2 metadata objects.
A description containing information about an installable unit.
A description containing information about an installable unit fragment.
A description containing information about an installable unit patch.
A metadata repository factory is responsible for creating and loading instances
of a particular type of metadata repository.
A representation of the model object 'Expression'.
The Factory for the model.
A representation of the model object 'Generic Stack'.
A representation of the model object 'Generic Tile'.
A representation of the model object 'Generic Trim Container'.
A representation of the model object 'Handled Item'.
A representation of the model object 'Handled Menu Item'.
A representation of the model object 'Handled Tool Item'.
A representation of the model object 'Handler'.
A representation of the model object 'Handler Container'.
A representation of the model object 'Imperative Expression'.
This class just swaps the left and right input for display.
A representation of the model object 'Item'.
A representation of the model object 'Key Binding'.
A representation of the model object 'Key Sequence'.
A representation of the model object 'Localizable'.
A representation of the model object 'Menu'.
A representation of the model object 'Contribution'.
A representation of the model object 'Contributions'.
A representation of the model object 'Element'.
The Factory for the model.
A representation of the model object 'Item'.
A representation of the model object 'Separator'.
A representation of the model object 'Model Fragment'.
A representation of the model object 'Model Fragments'.
Utility class for supporting modal operations.
An implementation of the model object 'Model Fragment'.
An implementation of the model object 'Model Fragments'.
A model operation that executes a merge according to the merge lifecycle
associated with an
IMergeContext and IResourceMappingMerger
instances obtained from the model providers involved.An abstract operation that uses an
ISynchronizationScopeManager to
create an operation scope that includes the complete set of mappings that
must be included in the operation to ensure model consistency.Model provider actions for use with a
ModelSynchronizeParticipant.A model merge operation that uses a participant to preview the changes
in either a dialog or the Synchronize view.
This is a convenience class for creating wizards for use with the
org.eclipse.team.ui.synchronizeWizard extension point
that create a ModelSynchronizeParticipant.Represents the provider of a logical model.
A status returned by a model from the resource operation validator.
Synchronize participant that obtains it's synchronization state from
a
ISynchronizationContext.Action group that contributes the merge actions to the model
synchronize participant.
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
Instances of this class are sent as a result of
text being modified.
Classes which implement this interface provide a method
that deals with the events that are generated when text
is modified.
A module represents a set of revisions installed in a module
container.An enumeration of persistent settings for a module
The possible start options for a module
An enumeration of the possible
states a module may
be in.The possible start options for a module
An implementation of
BundleCapability.Hook used to determine if a module revision being installed or updated will
cause a collision
A container for installing, updating, uninstalling and resolve modules.
Adapts the behavior of a container.
Event types that may be
published for a container.A database for storing modules, their revisions and wiring states.
A module loader is what connects a
ModuleWiring to a real
classloader.An implementation of
BundleRequirement.An implementation of
BundleRevision.A builder for creating module
ModuleRevision objects.Provides information about a capability or requirement
An implementation of
BundleWire.An implementation of
BundleWiring.Instances of this class are descriptions of monitors.
Standard implementation of
IReconciler.This adapter class provides default implementations for the
methods described by the
MouseListener interface.Instances of this class are sent whenever mouse
related actions occur.
Classes which implement this interface provide methods
that deal with the events that are generated as mouse buttons
are pressed.
Classes which implement this interface provide a method
that deals with the events that are generated as the mouse
pointer moves.
This adapter class provides default implementations for the
methods described by the
MouseTrackListener interface.Classes which implement this interface provide methods
that deal with the events that are generated as the mouse
pointer passes (or hovers) over controls.
Classes which implement this interface provide a method
that deals with the event that is generated as the mouse
wheel is scrolled.
Move arguments describe the data that a processor
provides to its move participants.
Moves files and folders.
Action for moving selected lines in an editor.
This event is sent when a new offset is required based on the current
offset and a movement type.
This listener is invoked when a new offset is required based on the current
offset and a movement type.
A participant to participate in refactorings that move elements.
A special processor that performs move operations.
The MoveProjectAction is the action designed to move projects specifically as
they have different semantics from other resources.
A MoveProjectOperation represents an undoable operation for moving a
project's content to a different location.
A generic move refactoring.
Change that moves and renames a resource.Refactoring descriptor for the move/rename resource refactoring.
Standard action for moving the currently selected resources elsewhere
in the workspace.
Change that moves a resource.Refactoring descriptor for the move resource refactoring.
A MoveResourcesOperation represents an undoable operation for moving one or
more resources in the workspace.
A wizard for the move resources refactoring.
A move source edit denotes the source of a move operation.
A move target edit denotes the target of a move operation.
A representation of the model object 'Parameter'.
A representation of the model object 'Part'.
A representation of the model object 'Part Descriptor'.
A representation of the model object 'Part Descriptor Container'.
A representation of the model object 'Part Sash Container'.
A representation of the model object 'Part Sash Container Element'.
A representation of the model object 'Part Stack'.
A representation of the model object 'Perspective'.
A representation of the model object 'Perspective Stack'.
A representation of the model object 'Placeholder'.
A representation of the model object 'Popup Menu'.
A simple/quick/small implementation of an MRU (Most Recently Used) list to
keep track of open BundleFiles.
A representation of the model object 'Snippet Container'.
A representation of the model object 'Stack Element'.
A representation of the model object 'String Model Fragment'.
A representation of the model object 'Tool Bar'.
A representation of the model object 'Tool Bar Contribution'.
A representation of the model object 'Tool Bar Contributions'.
A representation of the model object 'Tool Bar Element'.
A representation of the model object 'Tool Bar Separator'.
A representation of the model object 'Tool Control'.
A representation of the model object 'Tool Item'.
A representation of the model object 'Trim Bar'.
A representation of the model object 'Trim Contribution'.
A representation of the model object 'Trim Contributions'.
A representation of the model object 'Trim Element'.
A representation of the model object 'Trimmed Window'.
A representation of the model object 'UI Element'.
The Factory for the model.
A representation of the model object 'UI Label'.
A MultiEditor is a composite of editors.
The colors used to draw the title bar of the inner editors
Implements an input for a
AbstractMultiEditor.A rule for detecting patterns which begin with a given
sequence and may end with a given sequence thereby spanning
multiple lines.
An observable list backed by an array of observable lists.
A list property for observing multiple list properties in sequence in a
combined list.
Abstract base class for managing the installation/deinstallation of global
actions for multi-page editors.
A multi-page editor is an editor with multiple pages, each of which may
contain an editor or an arbitrary SWT control.
Site for a nested editor within a multi-page editor.
Manages the current selection in a multi-page editor by tracking the active
nested editor within the multi-page editor.
A checked exception indicating one or more workbench parts could not be
initialized correctly.
Content formatter for edit-based formatting strategies.
A hyperlink presenter capable of showing multiple hyperlinks in a hover.
A MultiRule is a compound scheduling rule that represents a fixed group of child
scheduling rules.
A multi state text file change is a special change object that applies a sequence of
text edit trees to a document.A concrete multi-status implementation, suitable either for instantiating or
subclassing.
Fast matcher to find the occurrences of any of a fixed set of constant strings.
A Builder for creating a
MultiStringMatcher.Describes a match result of
MultiStringMatcher.indexOf(CharSequence, int), giving
access to the matched string and the offset in the text it was matched at.A multi-text edit can be used to aggregate several edits into
one edit.
Multi-text edit with progress reporting.
A validator for cross-constraints between observables.
A representation of the model object 'Window'.
A representation of the model object 'Window Element'.
Deprecated.
A handle object that carries with it a name and a description.
Comparator for instances of
NamedHandleObject for display to
an end user.A label provider for instances of
NamedHandlerObject, which
exposes the name as the label.This class represents a native code description.
This class represents a native code specification.
Formats the key sequences and key strokes into the native human-readable
format.
Abstract INativePropertyListener implementation
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
A
NavigationAction is used to navigate through the individual
differences of a CompareEditorInput.Implementation of the back and forward actions.
The
NavigationHistoryAction moves navigation history back and
forward.Keeps the info to save, restore or identify and editor.
Default implementation of INavigationLocation.
Provides context menu items and
IActionBars contributions for a particular abstract
viewer.Provides a factory pattern for creating
INavigatorContentServices
for given viewer ids.A NestedDirBundleFile uses another BundleFile as its source but accesses all
of its resources relative to a nested directory within the other BundleFile
object.
Standard action for launching the create project selection
wizard.
The NewFolderDialog is used to create a new folder.
Standard action for launching the create project selection
wizard.
A facade for access to the new search UI facilities.
Invoke the resource creation wizard selection Wizard.
Action which, when run, will open the new wizard dialog.
A
NewWizardMenu augments BaseNewWizardMenu with IDE-specific
actions: New Project...Common superclass for all message bundle classes.
An operation approver that prompts the user to see if a non-local undo should
proceed inside an editor.
Signals that an attempt was made to access the properties of an undefined
object.
Signals that an attempt was made to access the properties of an undefined
object.
Deprecated.
Please use the "org.eclipse.core.commands" plug-in instead.
Signals that an attempt was made to execute a command that is not enabled.
Signals that an attempt was made to access the properties of an unhandled
object.
NotificationPopup is a default implementation of
AbstractNotificationPopup.The Builder to create NotificationPopup instances.
A refactoring change that does nothing.
A default progress monitor implementation suitable for subclassing.
Used whenever the input is null or no viewer can be found.
An implementation of
IRule detecting a numerical value.Converts a Number to a String using
Format.format(...).This class describes the object contribution element within the popup menu
action registry.
This manager is used to populate a popup menu manager with actions for a
given type.
This reader loads the popup menu manager with all the popup menu contributors
found in the workbench registry.
This class is a default implementation of
IObjectContributorManager.An ObjectFilterTest is used to read an object filter from XML, and evaluate
the results for a given object.
An object action extension in a popup menu.
An undo context that can be used to represent any given object.
Abstract event object for events fired by
IObservable objects.Abstract implementation of
IObservableList, based on an underlying
regular list.A
content provider for
AbstractTableViewer or AbstractListViewer that provides
elements of an IObservableList when set as the viewer's input.An
ITreeContentProvider for use with an AbstractTreeViewer,
which uses the provided list factory to obtain the
elements of a tree.
This class is thread safe.
A label provider based on one or more observable maps that track attributes
that this label provider uses for display.
A label provider based on one or more observable maps that track attributes
that this label provider uses for display.
Contains static methods to operate on or return
Observables.Abstract implementation of
IObservableSet.A
content provider for
AbstractTableViewer or AbstractListViewer that provides
elements of an IObservableSet when set as the viewer's input.An
ITreeContentProvider for use with an AbstractTreeViewer,
which uses the provided set factory to obtain the
elements of a tree.An observables manager can be used for lifecycle management of
IObservable objects.This class makes it possible to monitor whenever an IObservable is read from.
EditingSupport using the JFace Data Binding concepts to handle the
updating of an element from a CellEditor.OLE contains all the constants used to create an ActiveX Control or an OLE Document.
OleAutomation provides a generic mechanism for accessing functionality that is
specific to a particular ActiveX Control or OLE Document.
OleClientSite provides a site to manage an embedded OLE Document within a container.
OleControlSite provides a site to manage an embedded ActiveX Control within a container.
OleFrame is an OLE Container's top level frame.
Implementers of
OleListener provide a simple
handleEvent() method that is used internally
by SWT to dispatch events.Helper for opening editors on the viewer's selection and link the selection
with the editor.
Action for opening a cheat sheet.
Live help action for launching a cheat sheet from a help book.
Event object describing an open which may be generated from a
selection or default selection event.
Standard action for opening an editor on the currently selected file
resource(s).
Opens a new window.
Opens the launch configuration dialog in the context of a launch group.
Deprecated.
Workbench no longer exposes the concept of "pages" in the user ui
model.
Deprecated.
See IWorkbench.showPerspective methods.
Opens a perspective.
Deprecated.
See IWorkbench.showPerspective methods.
Tests if any Perspective is open or not.
Open the preferences dialog
Standard action for opening the currently selected project(s).
Implementation of single-click and double-click strategies.
Standard action for opening a system editor on the currently selected file
resource.
This listener interface may be implemented in order to receive
a
WindowEvent notification when a new Browser
needs to be provided by the application.A menu for opening files in the workbench.
This exception is thrown to blow out of a long-running method when the user
cancels it.
OperationFactory provides a set of helpers to simplify dealing with the running installation.
OperationHistoryActionHandler implements common behavior for the undo and
redo actions.
OperationHistoryEvent is used to communicate changes that occur in a
DefaultOperationHistory, including the addition or removal of operations, and
the execution, undo, and redo of operations.
This class is used to maintain the instance of the operation history that
should be used by classes that access the undo or redo history and add
undoable operations to the history.
OperationStatus describes the status of a request to execute, undo, or redo
an operation.
This annotation can be applied to methods, fields, and parameters to mark
them as optional for the dependency injection.
A method or field of type
BundleContext and annotated with
OSGiBundle will be injected with the BundleContext from the bundle
containing the class if the bundle's state is Bundle.ACTIVE.A query matching every
IInstallableUnit that describes an OSGi bundle.A factory for creating
ModuleRevisionBuilders based on OSGi bundle
manifests.The preference store implementation that uses OSGi preference node as an
enclosed storage.
Class which allows content merge viewer to provide a structure viewer that can be used in the outline
view.
An overlaying preference store.
Enumeration of the OverridePolicy values supported by the Common Navigator.
Ruler presented next to a source viewer showing all annotations of the viewer's annotation model
in a compact format.
OwnerDrawLabelProvider is an abstract implementation of a label provider that
handles custom draw.
Abstract base superclass for pages in a pagebook view.
A pagebook is a composite control where only a single control is visible at a
time.
Abstract superclass of all multi-page workbench views.
A data structure used to store the information about a single page within a
pagebook view.
Event object describing a page selection change.
Event object describing an
IDialogPage in the midst of changing.Abstract class for hosting a page based structure input view for the purposes
of feeding compare viewers.
The abstract superclass for actions that listen to page activation and
open/close events.
Part listener list.
Provides debug view selection management/notification for a debug view in a
specific workbench page.
Deprecated.
Clients should use a subclass of
CompareEditorInput
and CompareUI.openCompareDialog(org.eclipse.compare.CompareEditorInput)This implementation of
IPageSite provides a site for a page
within a PageBookView.Provides the implementation for switching pages in a view.
Instances of this class are sent as a result of
visible areas of controls requiring re-painting.
Classes which implement this interface provide methods
that deal with the events that are generated when the
control needs to be painted.
Manages the
IPainter object registered with an
ITextViewer.This event is sent when an object needs to be drawn.
This listener is invoked when an object needs to be drawn.
Instances of this class describe the color data used by an image.
An implementation of the model object 'Parameter'.
A parameter with a specific value.
A command that has had one or more of its parameters specified.
Like a
Runnable, an object which captures a block of code which can
be passed around and executed.
Provides information about the type of a command parameter.
An instance of this class describes changes to an instance of
ParameterType.Signals that a problem occurred while converting a command parameter value
from string to object, or object to string.
Signals that a problem has occurred while trying to create an instance of
IParameterValues.This exception is thrown when parse errors are encountered.
An exception indicating problems while parsing formal string representations
of either
KeyStroke or KeySequence objects.Deprecated, for removal: This API element is subject to removal in a future version.
Please use org.eclipse.jface.bindings.keys.ParseException
Exception used when SAC parser is not retrieved.
An implementation of the model object 'Part Descriptor'.
The abstract superclass for actions that listen to part activation and
open/close events.
A
ParticipantExtensionPoint is used to manage contributions of participants.Facade to access the rename, move, delete, create and copy participant
extension point provided by the org.eclipse.ltk.core.refactoring plug-in.
Displays a synchronize participant page combined with the compare/merge infrastructure.
Deprecated.
Stand alone presentation of a participant page within a view pane.
Deprecated.
Clients should use a subclass of
PageCompareEditorInput
and CompareUI.openCompareDialog(org.eclipse.compare.CompareEditorInput)This is a convenience class for creating wizards for use with the
org.eclipse.team.ui.synchronizeWizard extension point.An implementation of the model object 'Part'.
A checked exception indicating a workbench part cannot be initialized
correctly.
This class adds to the PluginAction support by setting itself up for work
within a WorkbenchPart.
An implementation of the model object 'Part Sash Container'.
An intermediate selection listener that filters selection change events based
on one or more predicates and forwards it to the functional selection
listener.
PartSite is the general implementation for an
IWorkbenchPartSite.An implementation of the model object 'Part Stack'.
Password provider modules should extend this class.
Builder for creating IFilePatch2 and IHunk objects as well as building
relationship between them.
A patch configuration allows clients to set parameters that control how a
patch is applied.
Helper class for parsing patches.
The standard implementation of the
IPath interface.Instances of this class represent paths through the two-dimensional
coordinate system.
Instances of this class describe device-independent paths.
A field editor to edit directory paths.
An interface that variable providers should implement in order
to extends the default path variable list used to resolve relative
locations of linked resources.
A selection dialog which shows the path variables defined in the workspace.
Instances of this class represent patterns to use while drawing.
Based on org.eclipse.ui.dialogs.PatternFilter.
A filter used in conjunction with
FilteredTree.An event describing a pattern match in a text console.
Standard implementation of
IPredicateRule.The PendingUpdateAdapter is a convenience object that can be used by a
BaseWorkbenchContentProvider that wants to show a pending update.
PerformanceStats collects and aggregates timing data about events such as
a builder running, an editor opening, etc.
A performance listener is periodically notified after performance events occur
or after events fail.
Operation that, when run, performs a
Change object.Operation that, when run, executes a series of refactoring sequentially.
Operation that, when run, executes a refactoring.
Permission Storage interface for managing a persistent storage of bundle
permissions.
Parts can specify this annotation on one of the methods to tag it as the method that performs
"save" operation.
A
ResourceVariantByteStore that caches the variant bytes using
the org.eclipse.core.resources.ISynchronizer so that the tree is
cached across workbench invocations.
This is a state that can be made persistent.
Parts can specify this annotation on one of the methods to tag it as the
method that performs the "visual state persit" operation
Abstract superclass of actions which are enabled iff there is an active
perspective in the window.
This adapter class provides default implementations for the methods described
by the
IPerspectiveListener interface and its extension
interfaces.A strategy to read perspective extension from the registry.
An implementation of the model object 'Perspective'.
A table label provider implementation for showing workbench perspectives
(objects of type
IPerspectiveDescriptor) in table- and
tree-structured viewers.Perspective listener list.
A menu for perspective selection.
An implementation of the model object 'Perspective Stack'.
Class to handle perspective switching in the UI.
Utility class for tracking the active perspective in a window.
A service for managing and searching
keys.Pins the properties view instance to the current selection.
Indicates how a shape modification should be transformed when applied to the
tree.
A pipelined viewer update should map requests to refresh or update elements
in the viewer to their correct, modified structure.
PixelConverter performs various conversions from device-independent units
(such as DLUs or characters) to pixels.
An implementation of the model object 'Placeholder'.
The PlainMessageDialog represents a message dialog with a clear, simple API
to create dialogs with message, buttons and image.
The Builder to create PlainMessageDialog instances.
The central class of the Eclipse Platform Runtime.
Convenience class to query for the current OS.
Framework service which allows bundle programmers to inspect the bundles and
packages known to the Framework.
An abstract superclass implementing the
IAdaptable interface.The central class for access to the Eclipse Platform User Interface.
The PlatformUIPreferenceListener is a class that listens to changes in the
preference store and propogates the change for any special cases that require
updating of other values within the workbench.
The abstract superclass of all plug-in runtime class implementations.
A PluginAction is a proxy for an action extension.
This class contains shared functionality for reading action contributions
from plugins into workbench parts (both editors and views).
Helper class to collect the menus and actions defined within a contribution
element.
Contribution item for actions provided by plugins via workbench action
extension points.
Contribution item for actions provided by plugins via workbench action
extension points.
A PluginActionSet is a proxy for an action set defined in XML.
This builder reads the actions for an action set from the registry.
Used by the workbench window extension handler to unhook action sets from
their associated window.
Custom exception for errors that can happen during plugin conversion.
A plug-in convertor is able to convert plug-in manifest files
(
plugin.xml) and fragment manifest files
(fragment.xml) to bundle manifest files
(MANIFEST.MF).Adapter for adding handling of the
PluginTransfer drag and drop
transfer type to a drop action.This class can be used to transfer an instance of
PluginTransferData between two parts in a workbench in a drag
and drop operation.Record for transferring data during a drag and drop operation between
different plug-ins.
Deprecated, for removal: This API element is subject to removal in a future version.
clients should use
Version insteadInstances of this class represent places on the (x, y)
coordinate plane.
A factory for creating properties for POJOs (plain old java objects) that
conform to idea of an object with getters and setters but does not provide
property change events on change.Policy implements NLS convenience methods for the plugin and
makes progress monitor policy decisions
The Policy class handles settings for behaviour, debug flags and logging
within JFace Data Binding.
The Policy class is used to specify application specific policies that should
be used in the standard p2 UI class libraries.
The Policy class handles settings for behaviour, debug flags and logging
within JFace.
The PopulateFilesOperation is an operation used to populate a FileSystemElement one
level deep rather than the whole way.
A lightweight, transient dialog that is popped up to show contextual or
temporal information and is easily dismissed.
A PopupList is a list of selectable items that appears in its own shell positioned above
its parent shell.
This class extends a single popup menu
An implementation of the model object 'Popup Menu'.
All the possible positioning values which can be used to contribute
elements into the wanted place of a list.
Positions describe text ranges of a document.
A holder class for the full information to position an element in a list.
Utilities class to retrieve position.
Use this annotation to describe methods that will participate in the
application lifecycle.
Use this annotation to describe methods that will participate in the
application lifecycle.
Provides a tree model for
PreferenceManager content.A utility class for dealing with preferences whose values are common SWT
objects (color, points, rectangles, and font data).
A preference dialog is a hierarchical presentation of preference pages.
Class which represents and preference filter entry to be used during
preference import/export (for example).
Provides labels for
IPreferenceNode objects.The PreferenceLinkArea is the link area used to open a specific preference
page.
A preference manager maintains a hierarchy of preference nodes and
associated preference pages.
A utility to change and remember preference values and later restore there
original value.
The preference metadata provides the information needed to configure
everything about the preference except the preference value itself.
This class provides a hook into the preference service before particular
operations on the global preference tree.
A concrete implementation of a node in a preference dialog tree.
Abstract base implementation for all preference page implementations.
Connects the validation result from the given data binding context to the
given preference page, updating the preference page's valid state and its
error message accordingly.
Deprecated.
This class is replaced by
IEclipsePreferences.Listener for property changes.
An event object describing a change to a named property.
A concrete preference store implementation based on an internal
java.util.Properties object, with support for persisting the
non-default preference values to files or streams.The PreferencesUtil class is the class that opens a properties or preference
dialog on a set of ids.
Use this annotation to describe methods that will participate in the
application lifecycle.
Standard implementation of
IPresentationReconciler.The base class for an "object supplier" - something that knows how to
instantiate objects corresponding to the object descriptor.
Instances of this class allow the user to select
a printer and various print-related parameters
prior to starting a print job.
Instances of this class are used to print to a printer.
Instances of this class are descriptions of a print job
in terms of the printer, and the scope and type of printing
that is desired.
Enumeration of the Priority values supported by the Common Navigator.
ProblemFilters are the filters used in the problems view.
Use this annotation to describe methods that will participate in the
application lifecycle.
An base implementation for refactorings that are split into
one refactoring processor and 0..n participants.
Use this annotation to describe methods that will participate in the
application lifecycle.
Stores information about the product.
A class that converts the strings returned by
org.eclipse.core.runtime.IProduct.getProperty to the appropriate
class.ProfileChangeOperation describes a provisioning operation that modifies a profile.
Helper method to decide on the way the installable units are being included.
A job that modifies a profile according to a specified provisioning plan.
A profile scope contains the preferences associated with a particular profile
in a provisioned system.
Instances of this class represent programs and
their associated file extensions in the operating
system.
This adapter class provides default implementations for the
methods described by the
ProgressListener interface.Instances of the receiver represent an unselectable
user interface object that is used to display progress,
typically in the form of a bar.
A
ProgressEvent is sent by a Browser to
ProgressListener's when a progress is made during the
loading of the current URL or when the loading of the current
URL has been completed.A control for showing progress feedback for a long running operation.
This listener interface may be implemented in order to receive
a
ProgressEvent notification when a Browser
makes a progress in loading the current URL or when the
current URL has been loaded.A modal dialog that displays progress during a long running operation.
A standard implementation of an IProgressMonitor.
Contains static methods for constructing and manipulating progress monitors.
An abstract wrapper around a progress monitor which, unless overridden,
forwards
IProgressMonitor and
IProgressMonitorWithBlocking methods to the wrapped progress
monitor.The progress provider supplies the job manager with progress monitors for
running jobs.
This interface contains a set of methods that allow to configure an existing
or future project, for example to add and configure natures when creating a
new project.
Provides a resolution for warning markers on projects without an explicit
encoding setting.
Represents information about a project within an Ant build file.
Annotation used to represent the projection of a master document onto a
ProjectionDocument.A projection annotation model.
A
ProjectionDocument represents a projection of its master
document.This event is sent out by an
ProjectionDocumentwhen it is
manipulated.A
ProjectionDocumentManager is one particular implementation
of ISlaveDocumentManager.Internal class.
Supports the configuration of projection capabilities a
ProjectionViewer.A projection source viewer is a source viewer which supports multiple visible
regions which can dynamically be changed.
The ProjectLocationMoveDialog is the dialog used to select the location of a
project for moving.
The ProjectLocationSelectionDialog is the dialog used to select the name and
location of a project for copying.
Object representing the project scope in the Eclipse preferences
hierarchy.
An object for serializing and deserializing
references to projects.
The context in which project serialization occurs.
A project in the workspace.
Deprecated.
since 3.0 not longer in use, no longer supported
Deprecated.
no longer supported
Contains static methods to operate on or return IProperty objects.
Represents a Ant property.
Represents a property for widgets, like text, enabled state, image, ...
An event object describing a change to a named property.
A column label provider that returns label text and images based on a
IPropertySourceProvider, forwarding requests for text and image to
the label provider returned from the property descriptor for the given
property id.Standard implementation for property descriptors.
Standard action for opening a Property Pages Dialog on the currently selected
element.
A concrete subclass of
EditingSupport that implements cell editing
support for column-based viewers (such as e.g.Abstract base implementation of a workbench property page (
IWorkbenchPropertyPage).Main class for the Property Sheet View.
PropertySheetEntry is an implementation of
IPropertySheetEntry which uses IPropertySource
and IPropertyDescriptor to interact with domain model objects.The standard implementation of property sheet page which presents
a table of property names and values obtained from the current selection
in the active workbench part.
Class used by
PropertySheetPage to
sort properties.Carries the context for the Show In action.
Abstract superclass of all property testers.
LinkedPosition with added completion proposals.
Decorator for
ILaunchConfiguration prototypes.Launch configuration tab used to specify the prototype associated with a
launch configuration, and also listed attributes from prototype shared with
the launch configuration.
A checked exception indicating a recoverable error occurred while provisioning.
An action that performs one step of a provisioning operation for a particular
Touchpoint.A provisioning context defines the scope in which a provisioning operation
occurs.
Abstract class representing provisioning jobs.
ProvisioningSession provides the context for a provisioning session, including
the provisioning services that should be used.
ProvisioningUI defines the provisioning session, UI policy, and related
services for a provisioning UI.
Qualified names are two-part names: qualifier and local name.
Helper class for query related tasks.
A QuickAccessElement describes one of the possible actions to show in Quick
Access.
Default implementation of
IQuickAssistAssistant.Access class for the quick diff reference provider extension point.
Action to toggle the line number bar's quick diff display.
An Intro content provider that populates a list of frequently-used commands
from an extension point.
Abstract class that is capable of creating a context menu.
Deprecated.
the IDE now uses the new intro mechanism
A field editor for an enumeration type preference.
A piece of boolean state grouped with other boolean states.
This state supports a radio-button like command, where the value of the
parameterized command is stored as state.
A custom servlet context helper type providing support for predicting the
need for ranged content responses based on the content type and the user
agent.
Description of a change between two or three ranges of comparable entities.
A
RangeDifferencer finds the differences between two or three IRangeComparators.A range marker can be used to track positions when executing
text edits.
Abstract class for creating readers.
The ReadOnlyStateChecker is a helper class that takes a set of resource
some of which may be read only and queries the user as to whether or
not they wish to continue the operation on it.
A realm defines a context from which objects implementing
IObservable
must be accessed, and on which these objects will notify their listeners.An action to handle emacs-like recenter.
Standard implementation of
IReconciler.Instances of this class represent rectangular areas in an
(x, y) coordinate system.
A simple resource visitor that allows to find one or more files by name in a
IContainer
RedoActionHandler provides common behavior for redoing an operation, as well
as labelling and enabling the menu item.
Deprecated.
This action is now longer needed.
Abstract super class for all refactorings.
A generic super class of all refactoring specific argument
classes.
A
RefactoringChangeDescriptor describes changes created by a
refactoring.
Refactoring context is a disposable object that can be used by a refactoring to hold resources
that have to be explicitly released.
Partial implementation of refactoring contribution objects which are capable
of creating refactoring descriptors or refactoring arguments.
Central access point to access resources managed by the refactoring
core plug-in.
Descriptor object of a refactoring.
Proxy of a refactoring descriptor.
Event object to communicate refactoring execution notifications.
Object which represents a sequence of executed refactorings with optional time
information.
Tree content provider to display a refactoring history.
Configuration object for a refactoring history control.
Event object to communicate refactoring history notifications.
Label provider to display a refactoring history.
A default implementation of a refactoring history wizard.
A refactoring participant can participate in the condition checking and
change creation of a
RefactoringProcessor.An abstract base class defining the protocol between a refactoring and
its associated processor.
Descriptor object of a refactoring session.
A
RefactoringStatus object represents the outcome of a
condition checking operation.A
RefactoringStatusContext can be used to annotate a
RefactoringStatusEntry with additional information
typically presented in the user interface.An immutable object representing an entry in the list in
RefactoringStatus.Refactoring-aware synchronization action provider which contributes an action
to accept pending refactorings during team synchronization.
Implementors of refactorings uses instances of
RefactoringTickProvider
to specify the tick distribution during progress reporting when executing the
check conditions, create change and change initialization steps.Central access point to access resources managed by the refactoring UI
plug-in.
An abstract base implementation of a refactoring wizard.
A helper class to open a refactoring wizard dialog.
An abstract base implementation of a refactoring wizard page.
This class makes use of the org.eclipse.core.expressions.definitions
extension point to evaluate the current context against pre-defined
expressions.
InputStream subclass which provides a reference (via File) to the data rather
than allowing the input stream to be directly read.
Describes an extension to the
quickdiff.referenceprovider extension point.URLConnection for the reference protocol.
Standard action for refreshing the workspace from the local file system for
the selected resources and all of their descendants.
The abstract base class for all auto-refresh providers.
A launch configuration tab which allows the user to specify
which resources should be refreshed when the launch
terminates.
Utilities for launch configurations that persist, restore, and refresh
collections of resources.
The default implementation of the
IRegion interface.Instances of this class represent areas of an x-y coordinate
system that are aggregates of the areas covered by a number
of polygons.
This class describes a registry contributor which is an entity that supplies
information to the extension registry.
A simple
IElementProvider that is configured by an extension point.Use this class to create or obtain an extension registry.
A radio state that can be read from the registry.
This is the basic registry strategy.
A toggle state that can be read from the registry.
Re-launches the last launch.
EXPERIMENTAL.
EXPERIMENTAL.
EXPERIMENTAL.
EXPERIMENTAL.
A remote mapping context provides a model element with a view of the remote
state of local resources as they relate to a repository operation that is in
progress.
An event indicating that all matches have been removed from a
AbstractTextSearchResult.A text file buffer operation that removes all trailing whitespace.
Rename arguments describe the data that a processor
provides to its rename participants.
A participant to participate in refactorings that rename elements.
A special processor that performs rename operations.
A generic rename refactoring.
Standard action for renaming the selected resources.
Change that renames a resource.Refactoring descriptor for the rename resource refactoring.
A wizard for the rename resource refactoring.
A dynamic menu item which supports to switch to other Windows.
Objects of this class can be used as a log to trace the
execution of refactorings like copy and paste
Text edit to replace a range in a document with a different
string.
Page that allows users to update, add, remove, import, and
export repositories.
A concrete subclass of
RepositoryProvider is created for each
project that is associated with a repository provider.This class represents things you can ask/do with a type of provider.
Concrete implementation of a repository reference.
RepositoryTracker defines a service that retrieves repositories, tracks their status, and
reports errors.
Base class for resizable Dialogs with persistent window bounds.
A resolution report is associated with a single resolve process.
A resolution report listener gets called an the end of resolve process
in order to receive a resolution report.
An implementation of a resolver which resolves the constraints of the bundles
in a system.
ResolverErrors represent a single error that prevents a bundle from resolving
in a
State object. *A runtime exception thrown by a resolver to indicate that a resolver hook
threw an unexpected exception and the resolve operation terminated.
This class is the abstract superclass of all graphics resource objects.
An action which configures its label, image, tooltip, and description from
a resource bundle using known keys.
This class represents platform specific attributes of files.
The interface of the service that gets
ResourceBundle objects from a given bundle with a
given locale.Abstract change for resource based changes.
A resource operation checker is a shared checker to collect all
changes done by the refactoring and the participants to resources
so that they can be validated as one change.
The resource change validator is used to validate that changes made to
resources will not adversely affect the models stored in those resources.
Comparator for viewers that display items of type
IResource.Deprecated.
Replaced by IResourceSnapshot and ResourceSnapshotFactory in the
org.eclipse.core.resources.undo.snapshot package
Implementation of
IResourceDiff.Implementation of
IResourceDiffTree.Clients may reference this class in the dragAssistant element of a
org.eclipse.ui.navigator.viewer extension point.
Clients may reference this class in the dropAssistant element of a
org.eclipse.ui.navigator.navigatorContent extension point.
The ResourceEncodingFieldEditor is a field editor for editing the encoding of
a resource and does not use a preference store.
Shows a list of resources to the user with a text entry field for a string
pattern used to filter the list of resources.
This class contains a collection of helper methods for finding JFace
resources in bundles.
This class manages SWT resources.
A resource mapping supports the transformation of an application model
object into its underlying file system resources.
A resource mapping context is provided to a resource mapping when traversing
the resources of the mapping.
Abstract implementation of
IResourceMappingMerger.A marker annotation model whose underlying source of markers is
a resource in the workspace.
An annotation model factory for resource marker annotation models.
A
ResourceNode wraps an IResources so that it can be used
as input for the differencing engine (interfaces IStructureComparator and ITypedElement)
and the ReplaceWithEditionDialog (interfaces ITypedElement and IModificationDate).A Resource property source.
Abstract base class for various JFace registries.
Default implementation of IResourceRuleFactory.
A saveable filter where the given savable must either match one of the given roots or be a direct
or indirect child of one of the roots.
A synchronize scope whose roots are a set of resources.
A standard resource selection dialog which solicits a list of resources from
the user.
Provides utilities for checking the validity of selections.
Resources locator manager implementation.
ResourceSnapshotFactory provides utility methods for creating snapshots of
resources or markers.
The plug-in runtime class for the Resources plug-in.
The
ResourceTransfer class is used to transfer an array of
IResources from one part to another in a drag and drop operation
or a cut, copy, paste action.A resource traversal is simply a set of resources and the depth to which
each is to be traversed.
Workbench-level composite that combines a CheckboxTreeViewer and CheckboxListViewer.
Utility class for manipulating resources and determining correspondences
between resources and workbench objects.
The purpose of a
ResourceVariantByteStore is to support the caching of
the synchronization bytes for the resource variants that represent
a resource line-up of interest such as a version, baseline or branch.Provides caching for a
AbstractResourceVariantTree using a
ResourceVariantByteStore.A specialization of Subscriber that uses
IResourceVariantTree objects
to manage the base (for three-way) and remote trees.A resource working set filter filters resources from a view that
are neither a parent nor children of a working set element.
A
RetargetAction tracks the active part in the workbench.Action used by an editor action bar contributor to establish placeholders in
menus or action bars which can be retargeted to dynamically changing actions,
for example, those which come from the active editor.
RevertProfilePage displays a profile's configuration history in an
Installation Page.
Action for abandoning changes made in the text editor since the last save
operation.
Describes a revision of a document.
Helper class that coordinates the selection behavior between an editor
revision ruler and a history list such as one shown in the history view.
Informs about a change of revision information.
Encapsulates revision information for one line-based document.
An unmodifiable line range that belongs to a
Revision.A text edit processor that brackets the application of edits into a document rewrite session.
Instances of this class are descriptions of colors in
terms of the primary additive color model (red, green and
blue).
Instances of this class are descriptions of colors in
terms of the primary additive color model (red, green and
blue).
Instances of this class are descriptions of colors in
terms of the primary additive color model (red, green, blue
and alpha).
A reusable
IColorFactory that may be used to blend two colors.Clients that contribute search scope root page to the search engine
definition must extend this class and implement
createScopeContents method.Each control controlled by a
RowLayout can have its initial
width and height specified by setting a RowData object
into the control.This class provides a convenient shorthand for creating and initialising
RowData.
Instances of this class determine the size and position of the
children of a
Composite by placing them either in
horizontal rows or vertical columns within the parent Composite.RowLayoutFactory creates and initializes row layouts.
The class
RTFTransfer provides a platform specific mechanism
for converting text in RTF format represented as a java String
to a platform specific representation of the data and vice versa.Deprecated.
use
DefaultDamagerRepairerDeprecated.
use
FastPartitioner insteadScanner that exclusively uses predicate rules.
A generic scanner which can be "programmed" with a sequence of rules.
Abstract action that works on breakpoints in the vertical ruler.
Deprecated.
Should use BreakpointTypesContribution instead.
The description of an extension to the
org.eclipse.ui.workbench.texteditor.rulerColumns extension point.Manages the preferences for ruler contributions stored in a preference store.
A registry for all extensions to the
rulerColumns extension point.Toggles enablement of a breakpoint in a vertical ruler.
A run to line action that can be contributed to a an editor or view.
Toggles a breakpoint when ruler is double-clicked.
Action to launch the last launch configuration that was successfully
launched, in run mode.
Instances of this class contain behavior that is executed within an
IEclipseContext.Standard implementation of an
IProcess that wrappers a system
process (java.lang.Process).Action to run to line in a vertical ruler of a workbench part containing a
document.
A run to line action that can be contributed to a an editor or view.
Handles a run to line operation.
SAC Constants Parsers.
SAC Parser Factory.
SAC Parser factory implementation.
Implements a default implementation of ISafeRunnable.
Runs the given ISafeRunnable in a protected mode: exceptions and certain
errors thrown in the runnable are logged and passed to the runnable's
exception handler.
Standard shell provider that always returns the shell containing the given
control.
Instances of the receiver represent a selectable user interface object
that allows the user to drag a rubber banded outline of the sash within
the parent control.
This class provides a convenient shorthand for creating and initializing
Sash.The SashForm is a composite control that lays out its children in a
row or column arrangement (as specified by the orientation) and places
a Sash between each child.
This class provides a convenient shorthand for creating and initializing
SashForm.Default SWT renderer responsible for a MPartSashContainer.
A
Saveable represents a unit of saveability, e.g. an editable
subset of the underlying domain model that may contain unsaved changes.A compare editor input that makes use of a
Saveable to manage the save
lifecycle of the editor input.A saveable comparison is used to buffer changes made when comparing
or merging model elements.
Helper class for prompting to save dirty views or editors.
Deprecated.
Clients should use a subclass of
CompareEditorInput
and CompareUI.openCompareDialog(org.eclipse.compare.CompareEditorInput)Deprecated.
Clients should use a subclass of
CompareEditorInput
and CompareUI.openCompareDialog(org.eclipse.compare.CompareEditorInput)Event object describing a change to a set of Saveable objects.
The model manager maintains a list of open saveable models.
Provides
Saveable objects to the common navigator, and allows to map
between elements in the tree and models.Deprecated.
As of 3.5, replaced by
ActionFactory.SAVEA standard "Save As" dialog which solicits a path from the user.
Instances of the receiver represent a selectable user
interface object that present a range of continuous
numeric values.
CSSStylableElement implementation which wrap SWT Scale.A field editor for an integer type preference.
It is allowed to schedule an application based on a specific event.
An instance of
IScheme is a handle representing a binding
scheme as defined by the extension point org.eclipse.ui.bindings.An instance of this class describes changes to an instance of
IScheme.Describes how a bundle import will be executed.
The ScopedPreferenceStore is an IPreferenceStore that uses the scopes
provided in org.eclipse.core.runtime.preferences.
This class is the abstract superclass of all classes which
represent controls that have standard scroll bars.
Instances of this class are selectable user interface
objects that represent a range of positive, numeric values.
A ScrolledComposite provides scrollbars and will scroll its content when the user
uses the scrollbars.
ScrolledForm is a control that is capable of scrolling an instance of the
Form class.
ScrolledFormText is a control that is capable of scrolling an instance of the
FormText class.
ScrolledPageBook is a class that is capable of stacking several composites
(pages), while showing one at a time.
Deprecated.
This class is obsolete; there is no support in the workspace
for scrubbing local content.
Participant in the help search.
An abstract search participants for adding XML documents to the search index.
Class that implements this interface is used to store data obtained during the parsing phase.
A search pattern defines how search results are found.
This class is a storage container for search processing
The common superclass of all events sent from
ISearchResults.A variation of the expandable composite that adds optional description below
the title.
This class provides a convenient shorthand for creating and initializing
Section.Section part implements IFormPart interface based on the Section widget.
Utility class to execute common privileged code.
Use this class to access secure preferences.
Internal class.
This event is sent to SegmentListeners when a text content is to be modified.
This listener interface may be implemented in order to receive
SegmentEvents.
A ruler action which can select the textual range of an annotation that has a
visual representation in a vertical ruler.
Operation responsible for traversing a specified file system position
recursively and building
- a tree that represents the container structure
- a collection containing all files meeting a specified extension criteria
This is implemented as an Operation in order to provide an escape to the user
(the Cancel button) if the operation drags on for too long
This adapter class provides default implementations for the
methods described by the
SelectionListener interface.Adapts ISelection instances to either IIterable or ICountable.
Event object describing a selection change.
The SelectionConversionService is the service that converts the selection to
IResources.
The abstract implementation of a selection dialog.
Determines the enablement status given a selection.
Instances of this class are sent as a result of
widgets being selected.
Classes which implement this interface provide methods
that deal with the events that are generated when selection
occurs in a control.
The abstract superclass for resource-based actions that listen to selection
change events.
Selection listeners are notified of all selections in the workbench.
A model containing selection values.
Static class to hold the predicates for this factory.
The abstract superclass for actions that listen to selection changes from a
particular selection provider.
An abstract base class for dialogs with a status bar and ok/cancel buttons.
A ruler action which can select the textual range of a marker that has a visual representation in
a vertical ruler.
Deprecated.
As of 2.1, replaced by
SelectMarkerRulerActionAn observable value which behaves similarly to the <select> and
<option> HTML tags.
Selector to find element
Adapter for the select marker action.
A separator is a special kind of contribution item which acts
as a visual separator and, optionally, acts as a group marker.
Create a contribute part.
Deprecated.
since 3.3 as
GapTextStore performs better even for sequential rewrite scenariosSignals that an exception occured while serializing a
ParameterizedCommand to a string or deserializing a String to a
ParameterizedCommand.Annotation to use with DI to support dynamics and multiple services
ServiceCaller provides functional methods for invoking OSGi services
in two different ways
Single invocations which happen only once or very rarely.A
ResourceVariantByteStore that caches the variant bytes in
memory and does not persist them over workbench invocations.List change event describing an incremental change of an
IObservableSet object.Contains
Step interfaces for the fluent databinding API common for
one-way and two-way IObservableSet bindings.Step for setting the from-end observable.
A config step for the end of a binding where data is read.
Step for setting the to-end observable.
Step for converting between from- and to-types.
Step for configuring the end of a binding where data is written.
Describes the difference between two sets
Use this annotation to tag a method to call the handler setEnabled method.
Trivial implementation of an
IConcurrentModel.Contains
Step interfaces for the fluent databinding API for one-way
IObservableSet bindings.SetOneWaySteps.SetOneWayBindWriteConfigStep<F,T,THIS extends SetOneWaySteps.SetOneWayBindWriteConfigStep<F,T,THIS>>
Step for configuring the to-end and creating the binding.
Step for converting between from- and to-types.
Refines the return types of the
SetCommonSteps.SetFromStep methods for use with
one-way bindings.Step for setting the to-end observable.
Step for settings to-end observable using default converters.
Abstract implementation of ISetProperty
The SettingsTransfer is the abstract superclass of settings transfers used
when switching workspaces.
Contains
Step interfaces for the fluent databinding API for two-way
IObservableSet bindings.SetTwoWaySteps.SetTwoWayBindConfigStep<F,T,THIS extends SetTwoWaySteps.SetTwoWayBindConfigStep<F,T,THIS>>
Step from configuring the to-end and creating the binding.
Step from configuring the from-end.
Step for setting the to-from direction converter.
Step for setting the from-to direction converter.
Refines the return types of the
SetCommonSteps.SetFromStep methods for use with
two-way bindings.Step for setting the to-end observable.
Step for settings to-end observable using default converters.
An opaque list to manage sharable participants.
An implementation of
ISharedDocumentAdapter that provides default behavior for the
methods of that interface.An implementation of
ISharedDocumentAdapter that wraps another
shared document adapter.A variation of
FormEditor, this editor has a stable header that does
not change when pages are switched.Common images used by the workbench which may be useful to other plug-ins.
This class is used to provide common scrolling services to a number of
controls in the toolkit.
Instances of this class represent the "windows"
which the desktop or "window manager" is managing.
This adapter class provides default implementations for the
methods described by the
ShellListener interface.CSSStylableElement implementation which wrap SWT Shell.Instances of this class are sent as a result of
operations being performed on shells.
This class provides a convenient shorthand for creating and initializing
Shell.Classes which implement this interface provide methods
that deal with changes in state of
Shells.Action for shifting code to the right or left by one indentation level.
Carries the context for the Show In action.
The show in command, which only needs a target id.
A
ShowInMenu is used to populate a menu manager with Show In
actions.Show the menu on top of the icon in the view or editor label.
Shows the given perspective.
Action to show the global refactoring history.
Shows the given view.
A
ShowViewMenu is used to populate a menu manager with Show View
actions.Shows the View Menu
This action toggles the display of whitespace characters by
attaching/detaching an
WhitespaceCharacterPainter to the
associated text editor.A representation of the literals of the enumeration 'Side Value',
and utility methods for working with them.
A
SignedContent object represents content which may be signed.A
SignedContentEntry represents a content entry which may be
signed.A factory used to create
SignedContent objects.A
SignerInfo object represents a single signer chain.An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (without unicode processing).
SimpleContentProposalProvider is a class designed to map a static list of
Strings to content proposals.
Simplified abstract implementation of IListProperty.
Simplified abstract implementation of IMapProperty.
An annotation representing a marker.
A simple compiled pattern.
Event object events in the properties API
Simplified abstract implementation of ISetProperty.
A simple template variable resolver, which always evaluates to a defined string.
Simplified abstract implementation of IValueProperty.
Implements an algorithm for very simple pattern matching in a string.
Moved into this package from
org.eclipse.jface.internal.text.revisions.A specific configuration of pattern rule whereby
the pattern begins with a specific sequence and may
end with a specific sequence, but will not span more
than a single line.
Caches the preferred size of an SWT control
A slave document event represents a master document event as a slave-relative
document event.
A part service which delegates all responsibility to the parent service.
default implementation of a
SlicedProgressMonitor that synchronizes
on the given monitor to report workInstances of this class are selectable user interface
objects that represent a range of positive, numeric values.
A dialog for editing the source lookup path of a
source lookup director.
A launch configuration tab that displays and edits the source
lookup path for a launch configuration.
SWT based implementation of
ISourceViewer and its extension
interfaces.This class bundles the configuration space of a source viewer.
Support class used by text editors to draw and update decorations on the
source viewer and its rulers.
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
Spelling annotation.
A spelling context allows a
ISpellingEngine to retrieve information
about the spelling check it has to perform.Spelling correction processor used to show quick
fixes for spelling problems.
Describes an extension to the
spellingEngine extension point.A spelling problem as reported by the
SpellingService service to the
ISpellingProblemCollector.Reconcile strategy used for spell checking.
System wide spelling service.
Instances of this class are selectable user interface
objects that allow the user to enter and modify numeric
values.
This class provides a convenient shorthand for creating and initializing
Spinner.Our sample handler extends AbstractHandler, an IHandler base class.
The Splitter adds support for nesting to a SashForm.
Display the values that can be used in the keybindings page and quick access.
This class provides access to the public constants provided by
StyledText.This Layout stacks all the controls one on top of the other and resizes all controls
to have the same size and location.
SWT default renderer for a MPartStack model elements
Style bits for the underlying CTabFolder can be set via the
IPresentation.STYLE_OVERRIDE_KEY key
Generic event denoting that the state of an
IObservable object is
about to change.Service interface used to monitor the startup process.
A piece of state information that can be shared between objects, and might be
persisted between sessions.
The state of a system as reported by a resolver.
A state delta contains all the changes to bundles within a state.
A helper class that provides convenience methods for manipulating state
objects.
A factory for states and their component objects.
A state wire represents a decision made by a resolver to wire a requirement
to a capability.
A concrete status implementation, suitable either for instantiating or
subclassing.
The StatusAdapter wraps an instance of IStatus subclass and can hold
additional information either by using properties or by adding a new adapter.
An abstract base class for dialogs with a status bar and OK/CANCEL buttons.
A mechanism to handle statuses throughout JFace.
A contribution item to be used with status line managers.
Contribution item for the status line.
Represents the layout data object for
Control within the status line.A status line manager is a contribution manager which realizes itself and its items
in a status line control.
StatusManager is the entry point for all statuses to be reported in the user
interface.
This interface allows for listening to status handling framework changes.
This interface declares types of notification.
Handling warnings or errors, with the intent of making the end user aware of these.
Capable of handling input elements that have an associated status with them.
This listener interface may be implemented in order to receive
a
StatusTextEvent notification when the status text for
a Browser is changed.Classes marked with this interface are steps in a fluent API chain.
Shared document provider specialized for
IStorages.This class describes an exception that could be produced by the secure
preferences.
Storage managers provide a facility for tracking the state of a group of files having
relationship with each others and being updated by several entities at the same time.
A utility class with some generally useful static methods for adaptor hook
implementations
An abstract field editor for a string type preference that presents
a string input field with a change button to its right to edit the
input field's content.
Helper class for converting various data types to and from
strings.
A field editor for a string type preference.
A string pattern matcher.
Start and end positions of a shortest match found by
StringMatcher.find(String, int, int).An implementation of the model object 'String Model Fragment'.
Converts a String to a Number using
NumberFormat.parse(...).An implementation of the model object 'String To Object Map'.
An implementation of the model object 'String To String Map'.
Helper for String.
A dialog that prompts the user to choose and configure a string
substitution variable.
Base class for custom variable filters.
An object pool backed by strong references.
An
IStructureCreator2 that attempts to use an IDocumentProvider
to obtain a shared document for an ITypedElement.A factory proxy for creating a StructureCreator.
A diff tree viewer that can be configured with a
IStructureCreator
to retrieve a hierarchical structure from the input object (an ICompareInput)
and perform a two-way or three-way compare on it.A concrete implementation of the
IStructuredSelection interface,
suitable for instantiating.Provides services related to OSGi bundles.
Provides services related to the bidi classification of characters.
A base handler for structured text composed of text segments separated by
separators where the text segments may include delimited parts within which
separators are treated like regular characters.
A base handler for structured text composed of text segments separated by
separators where the text segments may include delimited parts within which
separators are treated like regular characters and the delimiters may be
escaped.
Describes the environment within which structured text strings are processed.
Obtains IStructuredTextExpert instances.
Implementation for IStructuredTextExpert.
Provides various services related to managing the array of offsets where
directional formatting characters should be inserted in a source string.
Provides methods to process bidirectional text with a specific structure.
Segment listener that implements bidi-structured text reordering.
A base handler for structured text composed of two parts separated by a
separator.
Records strings which contain structured text.
Generic handler to be used as superclass (base class) for specific structured
text handlers.
Provides access to registered structured text handlers.
Provides services related to registered structured text handlers.
Abstract base implementation for structure-oriented viewers (trees, lists,
tables).
This class is not part of the public API of JFace.
Nothing to see here.
A node that acts as the root of the tree returned from a
StructureCreator.A
StyledCellLabelProvider supports styled labels by using owner
draw.A mutable string with styled ranges.
A styler will be asked to apply its styles to one ore more ranges in the
StyledString.The default implementation of
IStyledStringHighlighter.A StyledText is an editable user interface object that displays lines
of text.
Clients may implement the StyledTextContent interface to provide a
custom store for the StyledText widget content.
This adapter class provides a default drag under effect (eg. select and scroll)
when a drag occurs over a
StyledText.Line spacing provider used to customize different line spacing for some lines
of
StyledTextUse StyledTextPrintOptions to specify printing options for the
StyledText.print(Printer, StyledTextPrintOptions) API.
StyleRange defines a set of styles for a specified
range of text.StyleSheetList implementation.Generic implementation of the
IActionBars interface.A implementation of the extended
IActionBars2 interface.A
SubContributionItem is a wrapper for an IContributionItem.A
SubContributionManager is used to define a set of contribution
items within a parent manager.A
SubCoolBarManager monitors the additional and removal of
items from a parent manager so that visibility of the entire set can be changed as a
unit.Deprecated.
As of 3.2, replaced by Platform UI's field assist support *
Deprecated.
As of 3.2, replaced by Platform UI's field assist support
A
SubMenuManager is used to define a set of contribution
items within a parent manager.
A progress monitor that uses a given amount of work ticks from a parent
monitor.
Deprecated.
use
SubMonitor insteadA Subscriber provides synchronization between local resources and a
remote location that is used to share those resources.
A concrete implementation of
ISubscriberChangeEvent that can
be used by clients.A merge context that uses a subscriber to populate the diff tree
used by the context.
A synchronize participant that displays synchronization information for local resources that are
managed via a
Subscriber.This is a convenience class for creating wizards for use with the
org.eclipse.team.ui.synchronizeWizard extension point
that create a SubscriberParticipant.A resource mapping context that provides the client access to the remote state
of local resources using a subscriber.
A
ISynchronizationScopeManager that uses a Subscriber to provide
a RemoteResourceMappingContext and to notify participants when the
remote state of resources change.A team state provider that makes use of a
Subscriber to determine the synchronization
state.A
SubStatusLineManager is used to define a set of contribution
items within a parent manager.Reads the text contents from a reader and computes for each character
a potential substitution.
A
SubToolBarManager monitors the additional and removal of
items from a parent manager so that visibility of the entire set can be changed as a
unit.A dynamic menu item to switch to other opened workbench windows.
This class provides access to a small number of SWT system-wide
methods, and in addition defines the public constants provided
by SWT.
This class provides a bridge between SWT and AWT, so that it
is possible to embed AWT components in SWT and vice versa.
A method that returns a result and may throw a checked exception of the given
type.
SWT Helper to link w3c Element with SWT widget.
Returns the CSS class which is responsible for styling a SWT widget
Registered via the "org.eclipse.e4.ui.css.core.elementProvider" extension
point for the SWT widgets
IElementProvider SWT implementation to retrieve w3c Element
Element linked to SWT widget.This error is thrown whenever an unrecoverable error
occurs internally in SWT.
This interface is the cross-platform version of the
java.util.EventListener interface.
This runtime exception is thrown whenever a recoverable error
occurs internally in SWT.
This internal class is used to provide and cache fonts scaled for different zoom levels in the win32
implementation.
This class is used in the win32 implementation only to support
re-usage of fonts.
w3c Element which wrap SWT widget to manage HTML/XUL selectors.
IElementProvider SWT implementation to retrieve w3c Element
SWTHTMLElement linked to SWT widget.
A look-up table for the formal grammar for keys, and the integer values they
represent.
A utility class for converting SWT events into key strokes.
Deprecated, for removal: This API element is subject to removal in a future version.
Please use
SWTKeySupportSWT Resources Registry to cache SWT Resource like Color, Cursor and Font and
dispose it.
A method that returns no result and may throw a checked exception of the given
type.
SWT Helper to get SWT styles
Widget as String.An action group that can be used by models to contribute actions
to a team synchronization viewer.
An abstract implementation of
ISynchronizationCompareAdapter.Abstract team aware content provider that delegates to another content provider.
Abstract implementation of the
ISynchronizationContext interface.A label provider wrapper that adds synchronization image and/or text decorations
to the image and label obtained from the delegate provider.
This operation class can be used by model providers when performing
merge operations triggered from a synchronize participant page
associated with a synchronization or merge context.
Class for translating a set of
ResourceMapping objects
representing a view selection into the complete set of resources to be
operated on.A state change tester is used by logical models to communicate the
synchronization state of their logical model elements to
the lightweight label decorator of a team provider.
This action provides utilities for performing operations on selections that
contain
ISynchronizeModelElement
instances.A specialized team operation that operates on
ISynchronizeModelElementelements.A
SynchronizeOperation describes an operation that will modify the installation to
exclusively include the InstallableUnit mentioned.Used to add one or more actions to the context menu, toolbar or view menu
of an
ISynchronizePage.Instances of this class provide synchronization support
for displays.
Marker interface to denotes a log listener that should be called on the logging thread
Describes the synchronization of a local resource relative to a
remote resource variant.
A
SyncInfo editor input used as input to a two-way or three-way
compare viewer.A
SyncInfoFilter tests a SyncInfo for inclusion,
typically in a SyncInfoSet.Selects
SyncInfo whose local and remote contents match.A dynamic collection of
SyncInfo objects that provides
change notification to registered listeners.This event keeps track of the changes in a
SyncInfoSetProvides addition API for accessing the
SyncInfo in the set through
their resource's hierarchical relationships.A special kind of module that represents the system module for the container.
A property sheet page that provides a tabbed UI.
A FormToolkit customized for use by tabbed property sheet page.
A property tab is composed by one or more property sections and is used to
categorize sections.
Instances of this class implement the notebook user interface
metaphor.
Instances of this class represent a selectable user interface object
corresponding to a tab for a page in a tab folder.
Instances of this class implement a selectable user interface
object that displays a list of images and strings and issues
notification when selected.
Instances of this class represent a column in a table widget.
This class provides a convenient shorthand for creating and initializing
TableColumn.TableColumnViewerLabelProvider is the mapping from the table based providers
to the ViewerLabelProvider.
A TableCursor provides a way for the user to navigate around a Table
using the keyboard.
This class provides default implementations to display a source image
when a drag is initiated from a
Table.This class provides a default drag under effect (eg. select, insert and scroll)
when a drag occurs over a
Table.A TableEditor is a manager for a Control that appears above a cell in a Table and tracks with the
moving and resizing of that cell.
This class provides a convenient shorthand for creating and initializing
Table.Instances of this class represent a selectable user interface object
that represents an item in a table.
CSSStylableElement implementation which wrap SWT TableItem.A layout for a table.
A concrete viewer based on a SWT
Table control.ViewerColumn implementation for TableViewer to enable column-specific label
providers and editing support.
This is an editor-implementation for
TableThis class is responsible to provide the concept of cells for
Table.TableViewerRow is the Table specific implementation of ViewerRow
Layout data used in conjunction with
TableWrapLayout.This implementation of the layout algorithm attempts to position controls in
the composite using a two-pass autolayout HTML table algorithm recommended by
HTML 4.01 W3C specification (see
http://www.w3.org/TR/html4/appendix/notes.html#h-B.5.2.2).
Auto edit strategy that converts tabs into spaces.
Represents information about a target within an Ant build file.
Represents an Ant task.
Instances of this class represent the system task bar.
Instances of this class represent a task item.
Represents a marker visible in the Tasks view.
Shows the properties of a new or existing task, or a problem.
Adapter for the marker ruler action creating/removing tasks.
The Team class provides a global point of reference for the global ignore set
and the text/binary registry.
This exception is thrown by the team provider API.
A general hook class for operations that team providers may be
interested in participating in.
TeamImages provides convenience methods for accessing shared images
provided by the org.eclipse.team.ui plug-in.
An operation that can be configured to run in the foreground using
the
IProgressService or the background
as a Job.An implementation of
ITeamStateChangeEvent.An implementation of
ITeamStateDescription.A team state provider is used by the
SynchronizationStateTester to obtain
the team state for model elements.Status that is returned from some Team operations or is the payload of
some TeamExceptions.
TeamUI contains public API for generic UI-based Team functionality.
A template consisting of a name and a pattern.
A template buffer is a container for a string and variables.
A completion processor that computes template proposals.
Provides the context for a
Template being resolved.A context type defines a context within which templates are resolved.
Thrown when a template cannot be validated.
Deprecated.
TemplatePersistenceData stores information about a template.
A template preference page allows configuration of the templates for an
editor.
Dialog to edit a template.
A template completion proposal.
Deprecated.
Serializes templates as character or byte stream and reads the same format
back.
A collection of templates.
A collection of templates.
The Templates view.hosts
ITemplatesPages that shows the templates for
the currently active editor part.The template translator translates a string into a template buffer.
A
TemplateVariable represents a set of positions into a
TemplateBuffer with identical content each.A
TemplateVariableResolver resolves TemplateVariables
of a certain type inside a TemplateContext.Value object that represents the type of a template variable.
A testable object.
Instances of this class are selectable user interface
objects that allow the user to enter and modify text.
Handles the redirection of the global Cut, Copy, Paste, and Select All
actions to either the current inline text control or the part's supplied
action handler.
Description of textual attributes such as color and style.
A cell editor that manages a text entry field.
A text change is a special change object that applies a
text edit tree to a document.This event is sent by the StyledTextContent implementor when a change to
the text occurs.
The StyledText widget implements this listener to receive
notifications when changes to the model occur.
This event is sent by the StyledTextContent implementor when a change
to the text is about to occur.
An abstract text console that supports regular expression matching and
hyperlinks.
A page for a text console.
Default viewer used to display a
TextConsole.An
IControlContentAdapter for SWT Text controls.Deprecated.
As of 3.2, replaced by Platform UI's field assist support
Deprecated.
As of 3.3, clients should use
ControlDecoration instead
of DecoratedField.A text edit describes an elementary text manipulation operation.
An abstract base implementation of a change which is based on text edits.
This class is a wrapper around a
TextEditGroup
adding support for marking a group as active and inactive.This class is a wrapper around a
TextEditGroup
adding support for marking a group as active and inactive.A special preview node to represent
TextEditBasedChanges in the
preview tree.Copies a tree of text edits.
A text edit group combines a list of
TextEdits
and a name into a single object.The standard/default text editor.
Skeleton of a standard text editor action.
Manages the installation and de-installation of global actions for the default text editor.
Preference constants used in the default text editor preference store.
Deprecated.
As of 2.1, fonts are managed by the workbench, no longer supported
A
TextEditProcessor manages a set of edits and applies
them as a whole to an IDocument.A visitor for text edits.
CSSStylableElement implementation which wrap SWT Text.This event is sent to implementers of
ITextListener.This class provides a convenient shorthand for creating and initializing
Text.Abstraction for a file buffer operation that works on text file buffers.
A special
TextChange that operates on a IFile.Shared document provider specialized for
IFile based domain elements.Operation created by the document provider and to be executed by the providers runnable context.
Deprecated.
As of 3.3 - do not use
Text quick assist invocation context.
TextLayout is a graphic object that represents
styled text.A text merge viewer uses the
RangeDifferencer to perform a
textual, line-by-line comparison of two (or three) input documents.A factory object for the
TextMergeViewer.An
Action wrapper for text widget navigation and selection actions.An action which gets a text operation target from its text editor.
Describes the presentation styles for a section of an indexed text such as a
document or string.
This class is used to process strings that have special semantic meaning
(such as file paths) in RTL-oriented locales so that they render in a way
that does not corrupt the semantic meaning of the string but also maintains
compliance with the Unicode BiDi algorithm of rendering Bidirectional text.
Descriptor for a property that has a value which should be edited with a text
cell editor.
A
TextSearchEngine searches the content of a workspace file resources
for matches to a given search pattern.Action group that adds a sub-menu with text search actions to a context menu.
A
TextSearchMatchAccess gives access to a pattern match found by the TextSearchEngine.Abstract base class for text search query providers supplied via the
org.eclipse.search.textSearchQueryProvider extension point.Specified the input for a search query.
Collects the results from a search engine query.
A
TextSearchScope defines the scope of a search.Standard implementation of
ITextSelection.Represents the text selection context marked for the user in the navigation history.
Source viewer configuration for the text editor.
A piece of state carrying a single
String.An abstract base implementation of a status context viewer that presents
textual context information.
TextStyle defines a set of styles that can be applied
to a range of text.The class
TextTransfer provides a platform specific mechanism
for converting plain text represented as a java String
to a platform specific representation of the data and vice versa.A collection of text functions.
SWT based implementation of
ITextViewer and its extension interfaces.Common function for actions that operate on a text viewer.
A factory object for the
TextMergeViewer.A delete line target.
Action to position a text viewer to a specific line.
Implementation of
IUndoManager using the shared
document undo manager.ThemeDefinitionElement<T extends org.eclipse.e4.ui.internal.css.swt.definition.IThemeElementDefinitionOverridable<?>>
Implementation of
IThreeWayDiff.A resource variant tree that caches and obtains its bytes from the remote slot
in a three-way synchronizer.
A resource comparator that uses the
ThreeWaySynchronizer
to compare local resources to their resource variants.A resource variant tree subscriber whose trees use an underlying
ThreeWaySynchronizer to store and manage the
synchronization state for the local workspace.This class manages the synchronization between local resources and their
corresponding resource variants.
A utility class that throttles the execution of a runnable in the UI thread.
Starts a task which will dump stack trace information and a screenshot after
some time.
A dialog that has a title area for displaying a title and an image as well as
a common area for displaying a description, a message, or an error message.
Connects the validation result from the given data binding context to the
given TitleAreaDialog, updating the dialog's error message accordingly.
A
TitleEvent is sent by a Browser to
TitleListener's when the title of the current document
is available or when it is modified.This listener interface may be implemented in order to receive
a
TitleEvent notification when the title of the document
displayed in a Browser is known or has been changed.Class for administering the Toc system.
Action to toggle a breakpoint in a vertical ruler of a workbench part
containing a document.
Hides or shows the editor area within the current perspective of the
workbench page.
A custom selectable control that can be used to control areas that can be
expanded or collapsed.
A toggle method breakpoint action that can be contributed an object
contribution.
A piece of state storing a
Boolean.A toggle watchpoint action that can be contributed an object
contribution.
Describes the input token stream.
Standard implementation of
IToken.Implements the
ITokenComparator interface for words (or tokens)
in a string.Instances of this class support the layout of selectable
tool bar items.
An implementation of the model object 'Tool Bar Contribution'.
The
ToolBarContributionItem class provides a wrapper for tool
bar managers when used in cool bar managers.CSSStylableElement implementation which wrap SWT CTabFolder.An implementation of the model object 'Tool Bar Element'.
An implementation of the model object 'Tool Bar'.
A tool bar manager is a contribution manager which realizes itself and its
items in a tool bar control.
Create a contribute part.
An implementation of the model object 'Tool Bar Separator'.
An implementation of the model object 'Tool Control'.
Create a contribute part.
Instances of this class represent a selectable user interface object
that represents a button in a tool bar.
CSSStylableElement implementation which wrap SWT TableItem.An implementation of the model object 'Tool Item'.
This class gives implementors to provide customized tooltips for any control.
Instances of this class represent popup windows that are used
to inform or warn the user.
Instances of this class are created in response to a
touch-based input device being touched.
Instances of this class are sent in response to
a touch-based input source being touched.
Classes which implement this interface provide methods
that deal with the events that are generated as touches
occur on a touch-aware input surface.
A touchpoint is responsible for executing the required provisioning steps
for each phase corresponding to a particular targeted system (eclipse, native).
Instances of this class represent sources of touch input that generate
Touch objects.Deprecated, for removal: This API element is subject to removal in a future version.
Instances of this class implement rubber banding rectangles that are
drawn onto a parent
Composite or Display.Transfer provides a mechanism for converting between a java
representation of data and a platform specific representation of data and
vice versa.The
TransferData class is a platform specific data structure for
describing the type and the contents of data being converted by a transfer agent.Instances of this class represent transformation matrices for
points expressed as (x, y) pairs of floating point numbers.
Annotation used in conjunction with
Inject to mark injected valuesFactory for translation providers.
Provides localization service.
Instances of this class are sent as a result of
widget traversal actions.
Classes which implement this interface provide a method
that deals with the events that are generated when a
traverse event occurs in a control.
Instances of this class represent the system tray that is part
of the task bar status area on some operating systems.
A
TrayDialog is a specialized Dialog that can contain
a tray on its side.Instances of this class represent icons that can be placed on the
system tray or task bar status area.
Instances of this class provide a selectable user interface object
that displays a hierarchy of items and issues notification when an
item in the hierarchy is selected.
This adapter class provides default implementations for the
methods described by the
TreeListener interface.Instances of this class represent a column in a tree widget.
This class provides a convenient shorthand for creating and initializing
TreeColumn.TreeViewerLabelProvider is the ViewerLabelProvider that handles TreePaths.
A TreeCursor provides a way for the user to navigate around a Tree with columns using the
keyboard.
This class provides default implementations to display a source image
when a drag is initiated from a
Tree.This class provides a default drag under effect (eg. select, insert, scroll and expand)
when a drag occurs over a
Tree.A TreeEditor is a manager for a Control that appears above a cell in a Tree and tracks with the
moving and resizing of that cell.
Instances of this class are sent as a result of
trees being expanded and collapsed.
Event object describing a tree node being expanded
or collapsed.
This class provides a convenient shorthand for creating and initializing
Tree.Frame for tree viewers.
Instances of this class represent a selectable user interface object
that represents a hierarchy of tree items in a tree widget.
Classes which implement this interface provide methods
that deal with the expanding and collapsing of tree
branches.
A simple data structure that is useful for implemented tree models.
A custom selectable control that can be used to control areas that can be
expanded or collapsed.
A content provider that expects every element to be a
TreeNode.A tree path denotes a model element in a tree viewer.
A viewer sorter that is provided extra context in the form of the path of the
parent element of the elements being sorted.
A concrete implementation of the
ITreeSelection interface,
suitable for instantiating.Instances of this class can be used to improve accuracy and performance of an
ObservableListTreeContentProvider or an
ObservableSetTreeContentProvider.A concrete viewer based on an SWT
Tree control.ViewerColumn implementation for TreeViewer to enable column-specific label
providers and editing support.
This is an editor implementation for
TreeThis class is responsible to provide the concept of cells for
Tree.Frame source for tree viewers, which uses
TreeFrame to capture
the state of the tree viewer.TreeViewerRow is the Tree implementation of ViewerRow.
The abstract class for any object that can be used as a trigger for a binding.
Triggered operations are a specialized implementation of a composite
operation that keeps track of operations triggered by the execution of some
primary operation.
A sequence of one or more triggers.
An implementation of the model object 'Trim Bar'.
This class manages the
Layout of the applications' TrimBar.An implementation of the model object 'Trim Contribution'.
This arranges its controls into 5 'slots' defined by its composite children
Top: spans the entire width and abuts the top of the container
Bottom: spans the entire width and abuts the bottom of the container
Left: spans the space between 'top' and 'bottom' and abuts the left of
the container
Right: spans the space between 'top' and 'bottom' and abuts the right of
the container
Center: fills the area remaining once the other controls have been
positioned
NOTE: All the child controls must exist.
An implementation of the model object 'Trimmed Window'.
Simple class to provide some common internal Trim support.
A
TrustEngine is used to establish the authenticity of a
Certificate chain.A custom selectable control that can be used to control areas that can be
expanded or collapsed.
A list selection dialog with two panes.
Implementation of
ITwoWayDiff.Represents an Ant type.
This is the super class for all typed event classes provided
by SWT.
Instances of this class are internal SWT implementation
objects which provide a mapping between the typed and untyped
listener mechanisms that SWT supports.
Convenience class for positions that have a type, similar to
ITypedRegion.Default implementation of
ITypedRegion.The TypeFilteringDialog is a SelectionDialog that allows the user to select a
file editor.
The TypeMarkerGroup is a MarkerGroup used for the sorting by type which
cannot be expressed currently using the markerSupport extension point.
This class provides the ability to filter out user assistance model elements
that support filtering (e.g.
The Adapter Factory for the model.
Allow a command or application to provide feedback to a user through updating
a MenuItem or ToolItem.
An implementation of the model object 'UI Element'.
E4 UI events and event topic definitions.
E4 UI Event argument attribute keys.
E4 UI Event Types.
E4 UI life cycle events.
This annotation can be applied to arguments and fields that want to receive
notifications on the specified event topic.
An implementation of the model Factory.
The UIJob is a Job that runs within the UI Thread via an asyncExec.
The UI lock listener is used to prevent the UI thread from deadlocking on a
lock when the thread owning the lock is attempting to syncExec.
The Queue is the construct that keeps track of Semaphores.
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 plug-in class for the org.eclipse.ui plug-in.
Implementation of the UI plugin's preference extension's customization
element.
Service used for prompting for user information from within lower level code.
Authentication information returned from an authentication prompt request.
Trust information returned from a trust request.
The Switch for the model's inheritance hierarchy.
Widget toolkit abstract to synchronize back into the UI-Thread from other
threads
UndoActionHandler provides common behavior for performing an undo, as well as
labelling and enabling the undo menu item.
A simple, lightweight undo context that can be used to tag any operation.
This class encapsulates the reverse changes of an executed text
edit tree.
This adapter class provides default implementations for the
methods defined by the
IUndoManagerListener interface.
UndoRedoActionGroup provides standard undo and redo action handlers for a
workbench part site.
Deprecated.
This action is now longer needed.
A change to perform the reverse change of a
TextFileChange.An UninstallOperation describes an operation that uninstalls
IInstallableUnits from
a profile.Represents a set consisting of the union of elements from one or more other
sets.
A set property for observing the union of multiple set properties a combined
set.
The plug-in runtime class for the Unit Test plug-in.
Defines constants which are used to refer to values in the plugin's
preference store.
Exception used when java Class CSS property is not retrieved.
Exception used when CSS property handler is not retrieved.
Generic "Up" action which goes to the parent frame for the current frame.
A simple data structure describing a possible update.
Customizes a
Binding between two observable
lists.An UpdateMarkersOperation represents an undoable operation for updating one
or more markers in the workspace with one or more sets of attributes.
An UpdateOperation describes an operation that updates
IInstallableUnits in
a profile.Customizes a
Binding between two observable
sets.Customizes a
Binding between two observable
values.A representation of a Uniform Resource Identifier (URI), as specified by
RFC 2396, with certain
enhancements.
This class provides utility methods for comparing, inspecting, and manipulating
URIs.
A utility class for manipulating URIs.
The interface of the service that allows client-defined protocol
URLs to be converted to native file URLs on the local file system.
URL hyperlink.
URL hyperlink detector.
Simple label provider that knows how to load images from a URL.
The class
URLTransfer provides a platform specific mechanism
for converting text in URL format represented as a java String
to a platform specific representation of the data and vice versa.A
UserInfo prompter implementation that can be used when connecting a
Session.An abstract wizard page that is to be used to implement user input pages presented
inside a
refactoring wizard.A query matching all the
IInstallableUnits that are marked visible to the user.
A static class providing utility methods to all of JFace.
The Util class is the class of general utilities used by the marker support.
Convenience and utility methods.
A validate edit checker is a shared checker to collect files
to be validated all at once.
Deprecated.
No longer used, create a
CoreException insteadStandard implementation of the
IValidationMessageProvider interface.Convenience class for creating status objects.
A validation status provider tracks the state of zero or more target
observables and zero or more model observables and produces a validation
result.
An object that encapsulates the result of performing a provisioning action.
Value change event describing a change of an
IObservableValue
object's current value.Value changing event describing a pending change of an
IObservableValue object's current value.Contains
Step interfaces for the fluent databinding API common for
one-way and two-way IObservableValue bindings.Step for setting the from-end observable.
ValueCommonSteps.ValueReadConfigStep<F,T,THIS extends ValueCommonSteps.ValueReadConfigStep<F,T,THIS>>
A config step for the end of a binding where data is read.
Step for setting the to-end observable.
Step for converting between from- and to-types.
ValueCommonSteps.ValueWriteConfigStep<F,T,THIS extends ValueCommonSteps.ValueWriteConfigStep<F,T,THIS>>
Step for configuring the end of a binding where data is written.
Contains
Step interfaces for the fluent databinding API for one-way
IObservableValue bindings.ValueOneWaySteps.ValueOneWayBindWriteConfigStep<F,T,THIS extends ValueOneWaySteps.ValueOneWayBindWriteConfigStep<F,T,THIS>>
Step for configuring the to-end and creating the binding.
ValueOneWaySteps.ValueOneWayConvertStep<F,THIS extends ValueOneWaySteps.ValueOneWayConvertStep<F,THIS>>
Step for converting between from- and to-types.
Refines the return types of the
ValueCommonSteps.ValueFromStep methods for use with
one-way bindings.Step for setting the to-end observable.
Step for settings to-end observable using default converters.
Abstract implementation of IValueProperty
Contains
Step interfaces for the fluent databinding API for two-way
IObservableValue bindings.ValueTwoWaySteps.ValueTwoWayBindConfigStep<F,T,THIS extends ValueTwoWaySteps.ValueTwoWayBindConfigStep<F,T,THIS>>
Step from configuring the to-end and creating the binding.
ValueTwoWaySteps.ValueTwoWayConfigStep<F,T,THIS extends ValueTwoWaySteps.ValueTwoWayConfigStep<F,T,THIS>>
Step from configuring the from-end.
Step for setting the to-from direction converter.
ValueTwoWaySteps.ValueTwoWayConvertToStep<F,THIS extends ValueTwoWaySteps.ValueTwoWayConvertToStep<F,THIS>>
Step for setting the from-to direction converter.
Refines the return types of the
ValueCommonSteps.ValueFromStep methods for use with
two-way bindings.Step for setting the to-end observable.
Step for settings to-end observable using default converters.
The plug-in runtime class for the Core Variables plug-in.
A Variant is a generic OLE mechanism for passing data of different types via a common interface.
Instances of this class are sent as a result of
widgets handling keyboard events
Classes which implement this interface provide a method
that deals with the event that is generated when a
key is pressed.
Classes which implement this interface provide a method
that deals with the events that are generated when text
is about to be modified.
A class that represents a Version in the Omni Version format.
VersionConstraints represent the relationship between two bundles (in the
case of bundle requires) or a bundle and a package (in the case of
import/export).
An object representing a (id,version) pair.
Exception thrown when parsing Omni Version formats.
This class represents a version range with Omni Version bounds.
This class represents a version range.
A vertical ruler which is connected to a text viewer.
An event sent to
IVerticalRulerListener instances when annotation
related event occurs on the vertical ruler.This class reads the registry for extensions that plug into 'viewActions'
extension point.
ViewCSS implementation used to compute CSSStyleDeclaration.A viewer is a model-based adapter on a widget.
This class reads the registry for extensions that plug into 'popupMenus'
extension point and deals only with the 'viewerContribution' elements.
The ViewerCell is the JFace representation of a cell entry in a ViewerRow.
Instances of this class represent a column of a
ColumnViewer.A viewer comparator is used by a
StructuredViewer to
reorder the elements provided by its content provider.Creates
Viewers from an IConfigurationElement.This adapter class provides generic drag-and-drop support for a viewer.
A viewer filter is used by a structured viewer to extract a subset of
elements provided by its content provider.
The ViewerLabel is the class that is passed to a viewer to handle updates of
labels.
Abstract list property implementation for
Viewer properties.A factory for creating properties of JFace
viewers.ViewerRow is the abstract superclass of the part that represents items in a
Table or Tree.
Abstract set property implementation for
Viewer properties.Deprecated.
use
ViewerComparator instead.Helper methods for binding observables to a
StructuredViewer or
AbstractTableViewer.Abstract value property implementation for
Viewer properties.Instances of this class implement a Composite that positions and sizes
children and allows programmatic control of layout and border parameters.
Simple view that will wrap an
IIntroPart.Abstract base implementation of all workbench views.
This class extends regular plugin action with the additional requirement that
the delegate has to implement interface IViewActionDeelgate.
The ViewPreferencesAction is the action for opening a view preferences dialog
on a class.
The ViewSettingsDialog is an abstract class that provides some common
functionality for view preferences.
A view container manages the services for a view.
This adapter class provides default implementations for the
methods described by the
VisibilityWindowListener interface.This listener interface may be implemented in order to receive
a
WindowEvent notification when a window hosting a
Browser needs to be displayed or hidden.Default SWT renderer responsible for an instance of MWindow.
An object pool backed by weak references.
A painter for drawing visible characters for (invisible) whitespace
characters.
An implementation of
IRule capable of detecting whitespace.This class is the abstract superclass of all user interface objects.
CSSStylableElement implementation which wrap SWT Widget.This class provides a convenient shorthand for creating and initializing
factories for SWT widgets.
Abstract list property implementation for
Widget properties.A factory for creating properties of SWT
widgets.A factory for the creation of an
ISideEffectFactory, which internally
manages the created ISideEffects in an CompositeSideEffect.Helper class to allow widget creation and disposal monitoring
Default implementation simply collects all created and not disposed widgets
Custom callback to register widget creation / disposal
Represents a supplier for widgets.
Abstract value property implementation for
Widget properties.A JFace window is an object that has no visual representation (no widgets)
until it is told to open.
This interface defines a Exception Handler which can be set as a global
handler and will be called if an exception happens in the event loop.
A
WindowEvent is sent by a Browser when
a new window needs to be created or when an existing window needs to be
closed.An implementation of the model object 'Window'.
A manager for a group of windows.
A start-up event handler that, if running on Windows, suggests the user to
exclude the current installation directory from being scanned by the Windows
Defender, if it is active on the computer.
An abstract base implementation of a wizard.
Populates context menus with shortcut actions for defined wizards.
The common superclass for wizard import and export pages.
A dialog to show a wizard to the end user.
Abstract superclass for a typical export wizard's main page.
Standard main page for a wizard that creates a project resource from whose
location already contains a project.
Standard main page for a wizard that creates a file resource.
Standard main page for a wizard that creates a folder resource.
Standard resource link page for a wizard that creates a file or folder
resource.
Standard main page for a wizard that is creates a project resource.
Standard project reference page for a wizard that creates a project resource.
An abstract base implementation of a wizard page.
Connects the validation result from the given data binding context to the
given wizard page, updating the wizard page's completion state and its error
message accordingly.
The wizard property page can wrap a property page around a wizard.
The abstract superclass for a typical import wizard's main page.
An abstract implementation of a wizard page that manages a
set of embedded wizards.
A specific single line rule which stipulates that the start
and end sequence occur within a single word, as defined by a word detector.
An implementation of
IRule capable of detecting words.The workbench class represents the top of the Eclipse user interface.
A utility class that contains helpful methods for interacting with the
activities API.
Abstract base class with basic implementations of the IWorkbenchAdapter
interface.
Public base class for configuring the workbench.
Deprecated.
since 3.0 not longer in use, no longer supported, use a
ChainedPreferenceStore to access preferences from the
org.eclipse.ui.editors plug-in.Internal class providing special access for configuring the workbench.
Tree content provider for resource objects that can be adapted to the
interface
IWorkbenchAdapter.Opens a dialog showing all open editors and the recently closed editors.
WorkbenchEncoding is a utility class for plug-ins that want to use the list
of encodings defined by default in the workbench.
This is a default workbench error handler.
A proxy handler which passes all statuses to handler assigned to current
application workbench advisor.
A checked exception indicating a recoverable error occured internal to the
workbench.
This class provides convenience access to many of the resources required by
the workbench.
Workbench implementation of the IIntroManager interface.
WorkbenchJob is a type of job that implements a done listener and does the
shutdown checks before scheduling.
Provides basic labels for adaptable objects that have the
IWorkbenchAdapter adapter associated with them.The WorkbenchSettings handles the recording and restoring of workbench
settings.
WorkbenchMarkerResolution is the resolution that can be grouped
with others that are similar to allow multi selection.
Message class for workbench messages.
A collection of views and editors in a workbench.
Abstract base implementation of all workbench parts.
A table label provider implementation for showing workbench views and editors
(objects of type
IWorkbenchPart) in tree- and table-structured
viewers.This class represents the TOP of the workbench UI world A plugin class is
effectively an application wrapper for a plugin & its classes.
Implementation of the workbench plugin's preferences extension's
customization element.
Factory methods for creating properties for the Workbench.
The
WorkbenchStatusDialogManager is a utility class for displaying
one or more messages (errors, warnings or infos) to the user.Create singleton services to make the Workbench singletons available.
Workbench implementation prompts the user with a dialog unless they've said
that they don't want to be prompted.
A viewer comparator that sorts elements with registered workbench adapters by
their text property.
EXPERIMENTAL.
Deprecated.
as of 3.3, use
WorkbenchViewerComparator insteadA window within the workbench.
Public base class for configuring a workbench window.
Internal class providing special access for configuring workbench windows.
Abstract base class from which all controls contributions to the workbench
through the 'org.eclipse.ui.menus' extension point must derive.
Shows a list of open editor and parts in the current or last active workbook.
A worker performs a set of tasks in order and accumulates any errors
that may have occurred.
WorkingCopyManager is a concrete implementation of an IWorkingCopyManager.
A control for setting the working directory associated with a launch
configuration.
A working set holds a number of IAdaptable elements.
Compares two working sets by name.
Instances of this class provide a reusable composite with controls that allow
the selection of working sets.
A WorkingSetFactory is used to recreate a persisted WorkingSet object.
Adds working set filter actions (set / clear / edit)
Instances of this class provide a
WorkingSetConfigurationBlock
wrapped with an SWT Group container.A working set manager stores working sets and provides property change
notification when a working set is added or removed.
Menu contribution item which shows a working set.
A synchronize scope whose roots are defined by a working set.
A working set in the workspace.
A work queue maintains a list of tasks that need to be run.
The abstract superclass for actions which invoke commands implemented in
org.eclipse.core.* on a set of selected resources.
A job that makes an atomic modification to the workspace.
An operation which delegates its work to a runnable that modifies the
workspace.
An operation which potentially makes changes to the workspace.
Provides the headers required to create a workspace patch.
A synchronize scope whose roots are the workspace.
All projects in the workspace.
WorkspaceUndoUtil defines common utility methods and constants used by
clients who create undoable workspace operations.
Mutable observable list backed by an ArrayList.
This class is thread safe.
Mutable (writable) implementation of
IObservableSet.Mutable (writable) implementation of
IObservableValue that will
maintain a value and fire change events when the value changes.This class extends regular plugin action with the additional requirement that
the delegate has to implement interface
IWorkbenchWindowActionDelegate.A workbench window pulldown action.
A content describer for XML files.
This class represents the default implementation of the
IMemento
interface.XML processing which prohibits external entities.
Deprecated.
Use
XMLRootElementContentDescriber2 insteadA content describer for detecting the name of the top-level element,
its namespace and the DTD system identifier in an XML file.
Deprecated.
Providing Cancel in addition to Yes/No is confusing.
A BundleEntry represented by a ZipEntry in a ZipFile.
A BundleFile that uses a ZipFile as it base file.
Storage implementation for zip entries.
Standard workbench wizard for exporting resources from the workspace to a zip
file.
Standard workbench wizard for importing resources from a zip file into the
workspace.
This implementation of the
IStructureCreator interface
makes the contents of a zip archive available as a
hierarchical structure of IStructureComparators.This class provides information regarding the context structure and
content of specified zip file entry objects.