Eclipse Platform Release 3.7

## Uses of Interface
org.eclipse.core.runtime.IAdaptable

Packages that use IAdaptable
org.eclipse.compare: Provides support for performing structural and textual compare operations on arbitrary data and displaying the results.
org.eclipse.compare.contentmergeviewer: Support for compare and merge viewers which show the content side-by-side.
org.eclipse.compare.structuremergeviewer: Provides support for finding and displaying the differences between hierarchically structured data.
org.eclipse.core.commands.operations: Classes for the creation of undoable operations which can be added to an operations history and later be undone and redone.
org.eclipse.core.filesystem: Provides an interface for interacting with a file system.
org.eclipse.core.filesystem.provider: Provides an API to be extended by a file system implementation.
org.eclipse.core.internal.jobs
org.eclipse.core.internal.resources
org.eclipse.core.resources: Provides basic support for managing a workspace and its resources.
org.eclipse.core.resources.mapping: Provides APIs for integrating application models with the workspace Package Specification This package specifies the APIs in the Resources plug-in that are used to integrate application models with the workspace.
org.eclipse.core.runtime: Provides support for the runtime platform, core utility methods and the extension registry.
org.eclipse.core.runtime.jobs: Provides core support for scheduling and interacting with background activity.
org.eclipse.debug.core: Provides support for launching programs, breakpoint management, expression management, and debug events.
org.eclipse.debug.core.model: Defines interfaces for debug model elements, source lookup, and launching.
org.eclipse.debug.core.sourcelookup: Provides support for source lookup.
org.eclipse.debug.core.sourcelookup.containers: Provides implementations of common source containers supporting source lookup.
org.eclipse.debug.internal.ui.views.memory.renderings
org.eclipse.debug.ui: Provides a generic debugger user interface that clients may customize via standard workbench extension points.
org.eclipse.debug.ui.memory: Provides classes and interfaces to render memory blocks in the memory view.
org.eclipse.debug.ui.sourcelookup: Provides a user interface for debug platform source lookup facilities.
org.eclipse.equinox.p2.operations: Describes high level provisioning operations that can be resolved and performed either modally or in the background.
org.eclipse.equinox.p2.repository: Defines common API for querying and modifying provisioning repositories.
org.eclipse.equinox.p2.repository.artifact: Defines artifact repository.
org.eclipse.equinox.p2.repository.artifact.spi: Defines SPI for registering new implementations of artifact repositories.
org.eclipse.equinox.p2.repository.metadata: Defines metadata repository.
org.eclipse.equinox.p2.repository.metadata.spi: Defines SPI for registering new implementations of metadata repositories.
org.eclipse.equinox.p2.repository.spi: Defines common types for handling repositories.
org.eclipse.equinox.p2.ui: Provides provisioning user interface classes that can be used for assembling a provisioning UI.
org.eclipse.jface.text.hyperlink: Provides support for detecting and displaying hyperlinks in `ISourceViewer`s.
org.eclipse.ltk.core.refactoring: Application programmer interface to implement semantic preserving workspace transformations.
org.eclipse.ltk.core.refactoring.history: Application programming interface to query refactoring history information from the refactoring infrastructure.
org.eclipse.ltk.core.refactoring.model: Application programming interface to support logical models.
org.eclipse.ltk.core.refactoring.participants: Application programming interface to participant in existing rename, move and delete refactorings if the refactoring provider supports participation.
org.eclipse.ltk.core.refactoring.resource: Application programmer interface to implement resource dependend refactorings.
org.eclipse.ltk.ui.refactoring: Application programming interface to implement a wizard based user interface for refactorings.
org.eclipse.search.ui: Classes and interface required to contribute search dialog pages and search result view pages.
org.eclipse.team.core: Application programming interfaces for defining and working with repository providers.
org.eclipse.team.core.mapping.provider: Application programming interfaces for working with resource mappings.
org.eclipse.team.core.subscribers: Application programming interfaces for generating and refreshing synchronization state.
org.eclipse.team.core.synchronize: Application programming interfaces for managing synchronization state.
org.eclipse.team.core.variants: Application programming interfaces for accessing and managing resource variants.
org.eclipse.team.ui: Provides basic support for managing Team providers.
org.eclipse.team.ui.history: Application programming interfaces for working with history.
org.eclipse.team.ui.mapping: Application programming interfaces for working with resource mappings.
org.eclipse.team.ui.synchronize: Contains the team synchronization presentation framework and support for the Synchronize View.
org.eclipse.ui: Application programming interfaces for interaction with and extension of the Eclipse Platform User Interface.
org.eclipse.ui.actions: Classes for actions and operations used in a workbench window, page, or part in the Eclipse Platform User Interface.
org.eclipse.ui.application: Application-level APIs for configuring and controling the Eclipse Platform User Interface.
org.eclipse.ui.console: Application programming interfaces for interaction with the Eclipse console.
org.eclipse.ui.dialogs: Classes for standard dialogs, wizards, and preference pages in the Eclipse Platform User Interface.
org.eclipse.ui.editors.text: Provides a standard text editor and concrete document providers based `IFileBuffer` and others directly handling `IFile` and `IStorage` as editor input.
org.eclipse.ui.forms.editor: Support for forms-based multi-page editors.
org.eclipse.ui.ide: APIs for the IDE-specific portion of the Eclipse Platform User Interface.
org.eclipse.ui.ide.undo: APIs that provide undo and redo behavior for operations that manipulate the workspace.
org.eclipse.ui.internal.views.markers
org.eclipse.ui.intro: Application programming interfaces for interaction with and extension of the product introduction parts.
org.eclipse.ui.intro.config: Provides support for customizing welcome content and presentation.
org.eclipse.ui.model: Provides a workbench adapter for displaying workbench elements in the UI without having to know the concrete type of the element, and various label providers for workbench-specific objects like editors, views, and perspectives.
org.eclipse.ui.navigator: Provides the Common Navigator framework.
org.eclipse.ui.navigator.resources: Provides reusable components for clients that need to expand on the capabilities provided by the reference Common Navigator Resources extension.
org.eclipse.ui.operations: Classes that provide the basic workbench UI support for undo and redo of operations.
org.eclipse.ui.part: Classes for the creation of workbench parts that integrate with the Eclipse Platform User Interface.
org.eclipse.ui.progress: Application programming interfaces for interaction with and extension of the Eclipse Platform User Interface.
org.eclipse.ui.statushandlers: Application programming interfaces for interaction with and extension of the Eclipse Platform User Interface.
org.eclipse.ui.texteditor: Provides a framework for text editors obeying to the desktop rules.
org.eclipse.ui.texteditor.templates: Application programming interfaces for interaction with the Eclipse text editor template support.
org.eclipse.ui.views: Application programming interfaces for interaction with and extension of the Eclipse Platform User Interface.
org.eclipse.ui.views.bookmarkexplorer: Provides the standard Bookmarks view which displays bookmarks on resources.
org.eclipse.ui.views.contentoutline: Provides the standard Content Outline view which can show the active editor's custom outline for the document being edited.
org.eclipse.ui.views.markers: Utility classes for working with markers in views
org.eclipse.ui.views.navigator: Provides the standard Resource Navigator view which presents the tree of resources in the workspace.
org.eclipse.ui.views.properties: Provides the standard Property Sheet view which displays custom properties of the active workbench part's current selection.
org.eclipse.ui.views.tasklist: Provides the standard Task List view for displaying tasks and problem annotations on resources.
org.eclipse.ui.wizards: Application programming interfaces for interaction with and extension of the Eclipse Platform User Interface wizard support.
org.eclipse.update.configuration: Provides support for accessing local installation information.
org.eclipse.update.core: Provides support for extending the base installation and update services.
org.eclipse.update.core.model: Provides model support for extending the base installation and update services.

Uses of IAdaptable in org.eclipse.compare

Classes in org.eclipse.compare that implement IAdaptable
`class` `CompareEditorInput` A compare operation which can present its results in a special editor.
`class` `CompareViewerPane` A `CompareViewerPane` is a convenience class which installs a `CLabel` and a `Toolbar` in a `ViewForm`.
`class` `CompareViewerSwitchingPane` A custom `CompareViewerPane` that supports dynamic viewer switching.

Methods in org.eclipse.compare with parameters of type IAdaptable
`static Image` `CompareUI.getImage(IAdaptable adaptable)` Returns a shared image for the given adaptable.

Uses of IAdaptable in org.eclipse.compare.contentmergeviewer

Classes in org.eclipse.compare.contentmergeviewer that implement IAdaptable
`class` `TextMergeViewer` A text merge viewer uses the `RangeDifferencer` to perform a textual, line-by-line comparison of two (or three) input documents.

Uses of IAdaptable in org.eclipse.compare.structuremergeviewer

Classes in org.eclipse.compare.structuremergeviewer that implement IAdaptable
`class` `DocumentRangeNode` A document range node represents a structural element when performing a structure compare of documents.
`class` `StructureRootNode` A node that acts as the root of the tree returned from a `StructureCreator`.

Uses of IAdaptable in org.eclipse.core.commands.operations

Methods in org.eclipse.core.commands.operations with parameters of type IAdaptable
`protected IStatus` `LinearUndoEnforcer.allowLinearRedoViolation(IUndoableOperation operation, IUndoContext context, IOperationHistory history, IAdaptable uiInfo)`
`protected abstract IStatus` `LinearUndoViolationDetector.allowLinearRedoViolation(IUndoableOperation operation, IUndoContext context, IOperationHistory history, IAdaptable info)` Return a status indicating whether a linear redo violation is allowable.
`protected IStatus` `LinearUndoEnforcer.allowLinearUndoViolation(IUndoableOperation operation, IUndoContext context, IOperationHistory history, IAdaptable uiInfo)`
`protected abstract IStatus` `LinearUndoViolationDetector.allowLinearUndoViolation(IUndoableOperation operation, IUndoContext context, IOperationHistory history, IAdaptable info)` Return a status indicating whether a linear undo violation is allowable.
`IStatus` `TriggeredOperations.execute(IProgressMonitor monitor, IAdaptable info)`
`IStatus` `IUndoableOperation.execute(IProgressMonitor monitor, IAdaptable info)` Execute the operation.
`abstract IStatus` `AbstractOperation.execute(IProgressMonitor monitor, IAdaptable info)`
`IStatus` `IOperationHistory.execute(IUndoableOperation operation, IProgressMonitor monitor, IAdaptable info)` Execute the specified operation and add it to the operations history if successful.
`IStatus` `DefaultOperationHistory.execute(IUndoableOperation operation, IProgressMonitor monitor, IAdaptable info)`
`IStatus` `IOperationApprover2.proceedExecuting(IUndoableOperation operation, IOperationHistory history, IAdaptable info)` Return a status indicating whether the specified operation should be executed.
`IStatus` `LinearUndoViolationDetector.proceedRedoing(IUndoableOperation operation, IOperationHistory history, IAdaptable info)`
`IStatus` `IOperationApprover.proceedRedoing(IUndoableOperation operation, IOperationHistory history, IAdaptable info)` Return a status indicating whether the specified operation should be redone.
`IStatus` `LinearUndoViolationDetector.proceedUndoing(IUndoableOperation operation, IOperationHistory history, IAdaptable info)`
`IStatus` `IOperationApprover.proceedUndoing(IUndoableOperation operation, IOperationHistory history, IAdaptable info)` Return a status indicating whether the specified operation should be undone.
`IStatus` `TriggeredOperations.redo(IProgressMonitor monitor, IAdaptable info)`
`IStatus` `IUndoableOperation.redo(IProgressMonitor monitor, IAdaptable info)` Redo the operation.
`abstract IStatus` `AbstractOperation.redo(IProgressMonitor monitor, IAdaptable info)`
`IStatus` `IOperationHistory.redo(IUndoContext context, IProgressMonitor monitor, IAdaptable info)` Redo the most recently undone operation in the given context.
`IStatus` `DefaultOperationHistory.redo(IUndoContext context, IProgressMonitor monitor, IAdaptable info)`
`IStatus` `IOperationHistory.redoOperation(IUndoableOperation operation, IProgressMonitor monitor, IAdaptable info)` Redo the specified operation.
`IStatus` `DefaultOperationHistory.redoOperation(IUndoableOperation operation, IProgressMonitor monitor, IAdaptable info)`
`IStatus` `TriggeredOperations.undo(IProgressMonitor monitor, IAdaptable info)`
`IStatus` `IUndoableOperation.undo(IProgressMonitor monitor, IAdaptable info)` Undo the operation.
`abstract IStatus` `AbstractOperation.undo(IProgressMonitor monitor, IAdaptable info)`
`IStatus` `IOperationHistory.undo(IUndoContext context, IProgressMonitor monitor, IAdaptable info)` Undo the most recently executed operation in the given context.
`IStatus` `DefaultOperationHistory.undo(IUndoContext context, IProgressMonitor monitor, IAdaptable info)`
`IStatus` `IOperationHistory.undoOperation(IUndoableOperation operation, IProgressMonitor monitor, IAdaptable info)` Undo the specified operation.
`IStatus` `DefaultOperationHistory.undoOperation(IUndoableOperation operation, IProgressMonitor monitor, IAdaptable info)`

Uses of IAdaptable in org.eclipse.core.filesystem

Subinterfaces of IAdaptable in org.eclipse.core.filesystem
`interface` `IFileStore` A file store is responsible for storage and retrieval of a single file in some file system.
`interface` `IFileSystem` This is the main interface to a single file system.

Uses of IAdaptable in org.eclipse.core.filesystem.provider

Classes in org.eclipse.core.filesystem.provider that implement IAdaptable
`class` `FileStore` The abstract superclass of all `IFileStore` implementations.
`class` `FileSystem` The common superclass for all file system implementations.

Uses of IAdaptable in org.eclipse.core.internal.jobs

Classes in org.eclipse.core.internal.jobs that implement IAdaptable
`class` `org.eclipse.core.internal.jobs.InternalJob` Internal implementation class for jobs.

Uses of IAdaptable in org.eclipse.core.internal.resources

Classes in org.eclipse.core.internal.resources that implement IAdaptable
`class` `org.eclipse.core.internal.resources.InternalWorkspaceJob` Batches the activity of a job as a single operation, without obtaining the workspace lock.

Uses of IAdaptable in org.eclipse.core.resources

Subinterfaces of IAdaptable in org.eclipse.core.resources
`interface` `IBuildConfiguration` Build Configurations provide a mechanism for orthogonal configuration specific builds within a single project.
`interface` `IContainer` Interface for resources which may contain other resources (termed its members).
`interface` `IEncodedStorage` A storage that knows how its contents are encoded.
`interface` `IFile` Files are leaf resources which contain data.
`interface` `IFileState` A previous state of a file stored in the workspace's local history.
`interface` `IFolder` Folders may be leaf or non-leaf resources and may contain files and/or other folders.
`interface` `IMarker` Markers are a general mechanism for associating notes and meta-data with resources.
`interface` `IProject` A project is a type of resource which groups resources into buildable, reusable units.
`interface` `IResource` The workspace analog of file system files and directories.
`interface` `IResourceDelta` A resource delta represents changes in the state of a resource tree between two discrete points in time.
`interface` `IStorage` A storage object represents a set of bytes which can be accessed.
`interface` `IWorkspace` Workspaces are the basis for Eclipse Platform resource management.
`interface` `IWorkspaceRoot` A root resource represents the top of the resource hierarchy in a workspace.

Classes in org.eclipse.core.resources that implement IAdaptable
`class` `WorkspaceJob` A job that makes an atomic modification to the workspace.

Uses of IAdaptable in org.eclipse.core.resources.mapping

Classes in org.eclipse.core.resources.mapping that implement IAdaptable
`class` `CompositeResourceMapping` A resource mapping that obtains the traversals for its model object from a set of child mappings.
`class` `ModelProvider` Represents the provider of a logical model.
`class` `ResourceMapping` A resource mapping supports the transformation of an application model object into its underlying file system resources.

Uses of IAdaptable in org.eclipse.core.runtime

Classes in org.eclipse.core.runtime that implement IAdaptable
`class` `PlatformObject` An abstract superclass implementing the `IAdaptable` interface.

Uses of IAdaptable in org.eclipse.core.runtime.jobs

Classes in org.eclipse.core.runtime.jobs that implement IAdaptable
`class` `Job` Jobs are units of runnable work that can be scheduled to be run with the job manager.

Uses of IAdaptable in org.eclipse.debug.core

Subinterfaces of IAdaptable in org.eclipse.debug.core
`interface` `ILaunch` A launch is the result of launching a debug session and/or one or more system processes.
`interface` `ILaunchConfiguration` A launch configuration describes how to launch an application.
`interface` `ILaunchConfigurationType` Describes and creates instances of a specific type of launch configuration.
`interface` `ILaunchConfigurationWorkingCopy` An editable copy of a launch configuration.

Classes in org.eclipse.debug.core that implement IAdaptable
`class` `Launch` A launch is the result of launching a debug session and/or one or more system processes.

Uses of IAdaptable in org.eclipse.debug.core.model

Subinterfaces of IAdaptable in org.eclipse.debug.core.model
`interface` `IBreakpoint` A breakpoint is capable of suspending the execution of a program at a specific location when a program is running in debug mode.
`interface` `IDebugElement` A debug element represents an artifact in a program being debugged.
`interface` `IDebugTarget` A debug target is a debuggable execution context.
`interface` `IErrorReportingExpression` An expression that can report errors which occurred during the expression's evaluation.
`interface` `IExpression` An expression is a snippet of code that can be evaluated to produce a value.
`interface` `IIndexedValue` A value containing an indexed collection of variables - for example, an array.
`interface` `ILineBreakpoint` A breakpoint that can be located at a specific line of source code.
`interface` `IMemoryBlock` A contiguous segment of memory in an execution context.
`interface` `IMemoryBlockExtension` Extensions to `IMemoryBlock`.
`interface` `IProcess` A process represents a program running in normal (non-debug) mode.
`interface` `IRegister` A register is a special kind of variable that is contained in a register group.
`interface` `IRegisterGroup` A register group is a group of registers that are assigned to a stack frame.
`interface` `IStackFrame` A stack frame represents an execution context in a suspended thread.
`interface` `IThread` A thread is a sequential flow of execution in a debug target.
`interface` `IValue` A value represents the value of a variable.
`interface` `IVariable` A variable represents a visible data structure in a stack frame or value.
`interface` `IWatchExpression` A watch expression is an expression that is evaluated in the context of a specific stack frame, thread, debug target, process, or launch.
`interface` `IWatchpoint` A breakpoint that suspends when an associated variable is read or written.

Classes in org.eclipse.debug.core.model that implement IAdaptable
`class` `Breakpoint` Abstract implementation of a breakpoint.
`class` `DebugElement` Implementation of common function for debug elements.
`class` `LineBreakpoint` Abstract implementation of a line breakpoint.
`class` `RuntimeProcess` Standard implementation of an `IProcess` that wrappers a system process (`java.lang.Process`).

Uses of IAdaptable in org.eclipse.debug.core.sourcelookup

Subinterfaces of IAdaptable in org.eclipse.debug.core.sourcelookup
`interface` `ISourceContainer` A source container is a container of source code.

Uses of IAdaptable in org.eclipse.debug.core.sourcelookup.containers

Classes in org.eclipse.debug.core.sourcelookup.containers that implement IAdaptable
`class` `AbstractSourceContainer` Common function for source containers.
`class` `ArchiveSourceContainer` Archive source container for an archive in the workspace.
`class` `CompositeSourceContainer` A source container of source containers.
`class` `ContainerSourceContainer` A source container for a container in the workspace.
`class` `DefaultSourceContainer` 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.
`class` `DirectorySourceContainer` A directory in the local file system.
`class` `ExternalArchiveSourceContainer` An archive in the local file system.
`class` `FolderSourceContainer` A folder in the workspace.
`class` `LocalFileStorage` Implementation of storage for a local file (`java.io.File`).
`class` `ProjectSourceContainer` A project in the workspace.
`class` `WorkspaceSourceContainer` All projects in the workspace.
`class` `ZipEntryStorage` Storage implementation for zip entries.

Uses of IAdaptable in org.eclipse.debug.internal.ui.views.memory.renderings

Classes in org.eclipse.debug.internal.ui.views.memory.renderings that implement IAdaptable
`class` `org.eclipse.debug.internal.ui.views.memory.renderings.AbstractBaseTableRendering` Internal base class to allow AbstractTableRendering and AbstractAsyncTableRendering to share actions and dialogs.

Uses of IAdaptable in org.eclipse.debug.ui

Subinterfaces of IAdaptable in org.eclipse.debug.ui
`interface` `IBreakpointTypeCategory` Represents a breakpoint's type to support organization of breakpoints by type in the breakpoints view.
`interface` `IDebugView` Common function for debug views.

Classes in org.eclipse.debug.ui that implement IAdaptable
`class` `AbstractDebugView` Common function for views related to debugging.
`class` `BreakpointTypeCategory` Default implementation for a breakpoint type category.

Methods in org.eclipse.debug.ui that return IAdaptable
`IAdaptable[]` `IBreakpointOrganizerDelegate.getCategories()` Returns all categories managed by this organizer, or `null`.
`IAdaptable[]` `AbstractBreakpointOrganizerDelegate.getCategories()`
`IAdaptable[]` `IBreakpointOrganizerDelegate.getCategories(IBreakpoint breakpoint)` Returns objects representing the categories of the specified breakpoint or `null` if this organizer cannot classify the breakpoint.
`static IAdaptable` `DebugUITools.getDebugContext()` Returns the element of the currently selected context in the active workbench window.
`static IAdaptable` `DebugUITools.getPartDebugContext(IWorkbenchPartSite site)` Returns the currently active context for the given workbench part.

Methods in org.eclipse.debug.ui with parameters of type IAdaptable
`void` `IBreakpointOrganizerDelegate.addBreakpoint(IBreakpoint breakpoint, IAdaptable category)` Adds the specified breakpoint to the given category.
`void` `AbstractBreakpointOrganizerDelegate.addBreakpoint(IBreakpoint breakpoint, IAdaptable category)`
`void` `IBreakpointOrganizerDelegateExtension.addBreakpoints(IBreakpoint[] breakpoints, IAdaptable category)` Adds the specified breakpoints to the given category.
`boolean` `IBreakpointOrganizerDelegate.canAdd(IBreakpoint breakpoint, IAdaptable category)` Returns whether the given breakpoint can be categorized in the specified category.
`boolean` `AbstractBreakpointOrganizerDelegate.canAdd(IBreakpoint breakpoint, IAdaptable category)`
`boolean` `IBreakpointOrganizerDelegate.canRemove(IBreakpoint breakpoint, IAdaptable category)` Returns whether the given breakpoint can be removed from the given category.
`boolean` `AbstractBreakpointOrganizerDelegate.canRemove(IBreakpoint breakpoint, IAdaptable category)`
`protected void` `AbstractBreakpointOrganizerDelegate.fireCategoryChanged(IAdaptable category)` Fires a property change notification for the given category.
`void` `IBreakpointOrganizerDelegate.removeBreakpoint(IBreakpoint breakpoint, IAdaptable category)` Removes the specified breakpoint from the given category.
`void` `AbstractBreakpointOrganizerDelegate.removeBreakpoint(IBreakpoint breakpoint, IAdaptable category)`
`void` `IBreakpointOrganizerDelegateExtension.removeBreakpoints(IBreakpoint[] breakpoints, IAdaptable category)` Removes the specified breakpoints from the given category.

Uses of IAdaptable in org.eclipse.debug.ui.memory

Subinterfaces of IAdaptable in org.eclipse.debug.ui.memory
`interface` `IMemoryRendering` An arbitrary rendering of a memory block.
`interface` `IRepositionableMemoryRendering` A memory rendering that can be repositioned.
`interface` `IResettableMemoryRendering` A memory rendering that can be reset.

Classes in org.eclipse.debug.ui.memory that implement IAdaptable
`class` `AbstractMemoryRendering` Abstract implementation of a memory rendering.
`class` `AbstractTableRendering` Abstract implementation of a table rendering.
`class` `AbstractTextRendering` Abstract implementation of a rendering that translates memory into text, displayed in a table.

Uses of IAdaptable in org.eclipse.debug.ui.sourcelookup

Classes in org.eclipse.debug.ui.sourcelookup that implement IAdaptable
`class` `CommonSourceNotFoundEditor` Default editor displayed when source is not found.
`class` `CommonSourceNotFoundEditorInput` Editor input for the `CommonSourceNotFoundEditor`.
`class` `WorkingSetSourceContainer` A working set in the workspace.

Uses of IAdaptable in org.eclipse.equinox.p2.operations

Classes in org.eclipse.equinox.p2.operations that implement IAdaptable
`class` `ProfileModificationJob` A job that modifies a profile according to a specified provisioning plan.
`class` `ProvisioningJob` Abstract class representing provisioning jobs.

Uses of IAdaptable in org.eclipse.equinox.p2.repository

Subinterfaces of IAdaptable in org.eclipse.equinox.p2.repository
`interface` `ICompositeRepository<T>` A composite repository doesn't directly contain any contents, but rather contains only a list of child repositories.
`interface` `IRepository<T>` A p2 repository contains either metadata or artifacts related to software provisioning.

Uses of IAdaptable in org.eclipse.equinox.p2.repository.artifact

Subinterfaces of IAdaptable in org.eclipse.equinox.p2.repository.artifact
`interface` `IArtifactRepository` A repository containing artifacts.
`interface` `IFileArtifactRepository` An artifact repository whose artifacts are available in the local file system.

Uses of IAdaptable in org.eclipse.equinox.p2.repository.artifact.spi

Classes in org.eclipse.equinox.p2.repository.artifact.spi that implement IAdaptable
`class` `AbstractArtifactRepository` The common base class for all artifact repository implementations.

Uses of IAdaptable in org.eclipse.equinox.p2.repository.metadata

Subinterfaces of IAdaptable in org.eclipse.equinox.p2.repository.metadata
`interface` `IMetadataRepository` A metadata repository stores information about a set of installable units This interface is not intended to be implemented by clients.

Uses of IAdaptable in org.eclipse.equinox.p2.repository.metadata.spi

Classes in org.eclipse.equinox.p2.repository.metadata.spi that implement IAdaptable
`class` `AbstractMetadataRepository` The common base class for all metadata repositories.

Uses of IAdaptable in org.eclipse.equinox.p2.repository.spi

Classes in org.eclipse.equinox.p2.repository.spi that implement IAdaptable
`class` `AbstractRepository<T>` AbstractRepository defines common properties that may be provided by various kinds of repositories.

Uses of IAdaptable in org.eclipse.equinox.p2.ui

Classes in org.eclipse.equinox.p2.ui that implement IAdaptable
`class` `LoadMetadataRepositoryJob` A job that loads a set of metadata repositories and caches the loaded repositories.

Uses of IAdaptable in org.eclipse.jface.text.hyperlink

Methods in org.eclipse.jface.text.hyperlink with parameters of type IAdaptable
`void` `AbstractHyperlinkDetector.setContext(IAdaptable context)` Sets this hyperlink detector's context which is responsible to provide the adapters.

Uses of IAdaptable in org.eclipse.ltk.core.refactoring

Classes in org.eclipse.ltk.core.refactoring that implement IAdaptable
`class` `Change` An abstract base implementation for object representing a generic change to the workbench.
`class` `CompositeChange` Represents a composite change.
`class` `DocumentChange` A text change that operates directly on instances of `IDocument`.
`class` `MultiStateTextFileChange` A multi state text file change is a special change object that applies a sequence of `text edit trees` to a document.
`class` `NullChange` A refactoring change that does nothing.
`class` `Refactoring` Abstract super class for all refactorings.
`class` `RefactoringDescriptorProxy` Proxy of a refactoring descriptor.
`class` `TextChange` A text change is a special change object that applies a `text edit tree` to a document.
`class` `TextEditBasedChange` An abstract base implementation of a change which is based on text edits.
`class` `TextFileChange` A special `TextChange` that operates on a `IFile`.
`class` `UndoTextFileChange` A change to perform the reverse change of a `TextFileChange`.

Methods in org.eclipse.ltk.core.refactoring with parameters of type IAdaptable
`IValidationCheckResultQuery` `IValidationCheckResultQueryFactory.create(IAdaptable context)` Creates a new query.

Uses of IAdaptable in org.eclipse.ltk.core.refactoring.history

Classes in org.eclipse.ltk.core.refactoring.history that implement IAdaptable
`class` `RefactoringHistory` Object which represents a sequence of executed refactorings with optional time information.

Uses of IAdaptable in org.eclipse.ltk.core.refactoring.model

Classes in org.eclipse.ltk.core.refactoring.model that implement IAdaptable
`class` `AbstractRefactoringDescriptorResourceMapping` Partial implementation of a resource mapping for a refactoring descriptor object.
`class` `AbstractRefactoringHistoryResourceMapping` Partial implementation of a resource mapping for a refactoring history object.

Uses of IAdaptable in org.eclipse.ltk.core.refactoring.participants

Classes in org.eclipse.ltk.core.refactoring.participants that implement IAdaptable
`class` `CopyParticipant` A participant to participate in refactorings that copy elements to a shared clipboard.
`class` `CopyProcessor` A special processor that performs copy operations.
`class` `CopyRefactoring` A generic copy refactoring.
`class` `CreateParticipant` A participant to participate in refactorings that create elements.
`class` `DeleteParticipant` A participant to participate in refactorings that delete elements.
`class` `DeleteProcessor` A special processor that performs delete operations.
`class` `DeleteRefactoring` A generic delete refactoring.
`class` `MoveParticipant` A participant to participate in refactorings that move elements.
`class` `MoveProcessor` A special processor that performs move operations.
`class` `MoveRefactoring` A generic move refactoring.
`class` `ProcessorBasedRefactoring` An base implementation for refactorings that are split into one refactoring processor and 0..n participants.
`class` `RefactoringParticipant` A refactoring participant can participate in the condition checking and change creation of a `RefactoringProcessor`.
`class` `RefactoringProcessor` An abstract base class defining the protocol between a refactoring and its associated processor.
`class` `RenameParticipant` A participant to participate in refactorings that rename elements.
`class` `RenameProcessor` A special processor that performs rename operations.
`class` `RenameRefactoring` A generic rename refactoring.

Uses of IAdaptable in org.eclipse.ltk.core.refactoring.resource

Classes in org.eclipse.ltk.core.refactoring.resource that implement IAdaptable
`class` `DeleteResourceChange` `Change` that deletes a resource.
`class` `MoveResourceChange` `Change` that moves a resource.
`class` `RenameResourceChange` `Change` that renames a resource.
`class` `ResourceChange` Abstract change for resource based changes.

Uses of IAdaptable in org.eclipse.ltk.ui.refactoring

Methods in org.eclipse.ltk.ui.refactoring with parameters of type IAdaptable
`protected void` `TextStatusContextViewer.updateTitle(IAdaptable element)` Updates the title image and text of the pane surrounding the source viewer.

Uses of IAdaptable in org.eclipse.search.ui

Subinterfaces of IAdaptable in org.eclipse.search.ui
`interface` `ISearchResultView` Deprecated. Part of the old ('classic') search result view. Since 3.0 clients can create their own search result view pages. To access the parent view, `ISearchResultViewPart` is used instead.
`interface` `ISearchResultViewPart` Interface for the search result view.

Uses of IAdaptable in org.eclipse.team.core

Classes in org.eclipse.team.core that implement IAdaptable
`class` `DefaultRepositoryProviderType`
`class` `RepositoryProvider` A concrete subclass of `RepositoryProvider` is created for each project that is associated with a repository provider.
`class` `RepositoryProviderType` This class represents things you can ask/do with a type of provider.

Uses of IAdaptable in org.eclipse.team.core.mapping.provider

Classes in org.eclipse.team.core.mapping.provider that implement IAdaptable
`class` `MergeContext` Provides the context for an `IResourceMappingMerger`.
`class` `SynchronizationContext` Abstract implementation of the `ISynchronizationContext` interface.
`class` `SynchronizationScopeManager` Class for translating a set of `ResourceMapping` objects representing a view selection into the complete set of resources to be operated on.

Uses of IAdaptable in org.eclipse.team.core.subscribers

Classes in org.eclipse.team.core.subscribers that implement IAdaptable
`class` `SubscriberMergeContext` A merge context that uses a subscriber to populate the diff tree used by the context.
`class` `SubscriberScopeManager` A `ISynchronizationScopeManager` that uses a `Subscriber` to provide a `RemoteResourceMappingContext` and to notify participants when the remote state of resources change.

Uses of IAdaptable in org.eclipse.team.core.synchronize

Classes in org.eclipse.team.core.synchronize that implement IAdaptable
`class` `SyncInfo` Describes the synchronization of a local resource relative to a remote resource variant.

Uses of IAdaptable in org.eclipse.team.core.variants

Classes in org.eclipse.team.core.variants that implement IAdaptable
`class` `CachedResourceVariant` A resource variant is a partial implementation of a remote resource whose contents and handle are cached locally.

Uses of IAdaptable in org.eclipse.team.ui

Subinterfaces of IAdaptable in org.eclipse.team.ui
`interface` `ISaveableWorkbenchPart` Deprecated. Clients should use a subclass of `CompareEditorInput` and `CompareUI.openCompareDialog(org.eclipse.compare.CompareEditorInput)`

Classes in org.eclipse.team.ui that implement IAdaptable
`class` `PageCompareEditorInput` Abstract class for hosting a page based structure input view for the purposes of feeding compare viewers.
`class` `PageSaveablePart` Deprecated. Clients should use a subclass of `CompareEditorInput` and `CompareUI.openCompareDialog(org.eclipse.compare.CompareEditorInput)`
`class` `SaveablePartAdapter` Deprecated. Clients should use a subclass of `CompareEditorInput` and `CompareUI.openCompareDialog(org.eclipse.compare.CompareEditorInput)`

Uses of IAdaptable in org.eclipse.team.ui.history

Classes in org.eclipse.team.ui.history that implement IAdaptable
`class` `HistoryPage` Abstract HistoryPage class that keeps track of the history page site.
`class` `HistoryPageCompareEditorInput` Displays a history page combined with the compare/merge infrastructure.
`class` `HistoryPageSaveablePart` Deprecated. use `HistoryPageCompareEditorInput`

Uses of IAdaptable in org.eclipse.team.ui.mapping

Classes in org.eclipse.team.ui.mapping that implement IAdaptable
`class` `SaveableComparison` A saveable comparison is used to buffer changes made when comparing or merging model elements.

Uses of IAdaptable in org.eclipse.team.ui.synchronize

Subinterfaces of IAdaptable in org.eclipse.team.ui.synchronize
`interface` `ISynchronizeParticipant` A synchronize participant is a visual component that can be displayed within any control (e.g. view, editor, dialog).
`interface` `ISynchronizeView` A view that displays synchronization participants that are registered with the synchronize manager.

Classes in org.eclipse.team.ui.synchronize that implement IAdaptable
`class` `AbstractSynchronizeParticipant` This class is the abstract base class for all synchronize view participants.
`class` `ModelSynchronizeParticipant` Synchronize participant that obtains it's synchronization state from a `ISynchronizationContext`.
`class` `ParticipantPageCompareEditorInput` Displays a synchronize participant page combined with the compare/merge infrastructure.
`class` `ParticipantPageSaveablePart` Deprecated. Clients should use a subclass of `PageCompareEditorInput` and `CompareUI.openCompareDialog(org.eclipse.compare.CompareEditorInput)`
`class` `SaveableCompareEditorInput` A compare editor input that makes use of a `Saveable` to manage the save lifecycle of the editor input.
`class` `SubscriberParticipant` A synchronize participant that displays synchronization information for local resources that are managed via a `Subscriber`.
`class` `SyncInfoCompareInput` A `SyncInfo` editor input used as input to a two-way or three-way compare viewer.

Uses of IAdaptable in org.eclipse.ui

Subinterfaces of IAdaptable in org.eclipse.ui
`interface` `IAggregateWorkingSet` Contains a set of `IWorkingSet`.
`interface` `IEditorInput` `IEditorInput` is a light weight descriptor of editor input, like a file name but more abstract.
`interface` `IEditorPart` An editor is a visual component within a workbench page.
`interface` `IEditorSite` The primary interface between an editor part and the workbench.
`interface` `IFileEditorInput` This interface defines a file-oriented input to an editor.
`interface` `IInPlaceEditor` Interface for editor parts that represent an in-place style editor.
`interface` `IInPlaceEditorInput` This interface defines an editor input for in-place editors.
`interface` `IPathEditorInput` This interface defines an editor input based on the local file system path of a file.
`interface` `IReusableEditor` Interface for reusable editors.
`interface` `IStorageEditorInput` Interface for a `IStorage` input to an editor.
`interface` `IURIEditorInput` This interface defines an editor input based on a URI.
`interface` `IViewPart` A view is a visual component within a workbench page.
`interface` `IViewSite` The primary interface between a view part and the workbench.
`interface` `IWorkbench` A workbench is the root object for the Eclipse Platform user interface.
`interface` `IWorkbenchPart` A workbench part is a visual component within a workbench page.
`interface` `IWorkbenchPart2` Extends `IWorkbenchPart`, adding the name and status text properties.
`interface` `IWorkbenchPart3` A part can provide arbitrary properties.
`interface` `IWorkbenchPartSite` The primary interface between a workbench part and the workbench.
`interface` `IWorkbenchSite` The common interface between the workbench and its parts, including pages within parts.
`interface` `IWorkingSet` A working set holds a number of IAdaptable elements.

Classes in org.eclipse.ui that implement IAdaptable
`class` `Saveable` A `Saveable` represents a unit of saveability, e.g. an editable subset of the underlying domain model that may contain unsaved changes.

Methods in org.eclipse.ui that return IAdaptable
`IAdaptable[]` `IWorkingSet.adaptElements(IAdaptable[] objects)` Transforms the supplied elements into elements that are suitable for containment in this working set.
`IAdaptable[]` `IWorkingSetElementAdapter.adaptElements(IWorkingSet ws, IAdaptable[] elements)` Converts the given elements for addition to/removal from the working set.
`IAdaptable[]` `BasicWorkingSetElementAdapter.adaptElements(IWorkingSet ws, IAdaptable[] elements)` When invoked this method will iterate over all classes specified as IExecutableExtension arguements to this class in order and compare with the elements.
`IAdaptable` `IElementFactory.createElement(IMemento memento)` Re-creates and returns an object from the state captured within the given memento.
`IAdaptable` `IWorkbenchPropertyPage.getElement()` Returns the object that owns the properties shown in this page.
`IAdaptable[]` `IWorkingSet.getElements()` Returns the elements that are contained in this working set.
`IAdaptable` `IWorkbenchPage.getInput()` Returns the input for this page.

Methods in org.eclipse.ui with parameters of type IAdaptable
`IAdaptable[]` `IWorkingSet.adaptElements(IAdaptable[] objects)` Transforms the supplied elements into elements that are suitable for containment in this working set.
`IAdaptable[]` `IWorkingSetElementAdapter.adaptElements(IWorkingSet ws, IAdaptable[] elements)` Converts the given elements for addition to/removal from the working set.
`IAdaptable[]` `BasicWorkingSetElementAdapter.adaptElements(IWorkingSet ws, IAdaptable[] elements)` When invoked this method will iterate over all classes specified as IExecutableExtension arguements to this class in order and compare with the elements.
`void` `IWorkingSetManager.addToWorkingSets(IAdaptable element, IWorkingSet[] workingSets)` Utility method that will add the `element` to each given working set in `workingSets` if possible.
`IWorkingSet` `IWorkingSetManager.createWorkingSet(String name, IAdaptable[] elements)` Creates a new working set.
`IResource` `IContributorResourceAdapter.getAdaptedResource(IAdaptable adaptable)` Return the resource that the supplied adaptable adapts to.
`IWorkbenchPage` `IWorkbenchWindow.openPage(IAdaptable input)` Creates and opens a new workbench page.
`IWorkbenchPage` `IWorkbenchWindow.openPage(String perspectiveId, IAdaptable input)` Creates and opens a new workbench page.
`IWorkbenchWindow` `IWorkbench.openWorkbenchWindow(IAdaptable input)` Creates and opens a new workbench window with one page.
`IWorkbenchWindow` `IWorkbench.openWorkbenchWindow(String perspectiveId, IAdaptable input)` Creates and opens a new workbench window with one page.
`void` `IWorkbenchPropertyPage.setElement(IAdaptable element)` Sets the object that owns the properties shown in this page.
`void` `IWorkingSet.setElements(IAdaptable[] elements)` Sets the elements that are contained in this working set.
`void` `IWorkbenchPropertyPageMulti.setElements(IAdaptable[] elements)` Sets the elements that own properties shown on this page.
`IWorkbenchPage` `IWorkbench.showPerspective(String perspectiveId, IWorkbenchWindow window, IAdaptable input)` Shows the specified perspective to the user.

Uses of IAdaptable in org.eclipse.ui.actions

Methods in org.eclipse.ui.actions with parameters of type IAdaptable
`void` `OpenPerspectiveMenu.setPageInput(IAdaptable input)` Deprecated. Sets the page input.
`void` `OpenNewWindowMenu.setPageInput(IAdaptable input)` Deprecated. Sets the page input.
`void` `OpenNewPageMenu.setPageInput(IAdaptable input)` Deprecated. Sets the page input.
`void` `OpenInNewWindowAction.setPageInput(IAdaptable input)` Set the input to use for the new window's page.

Constructors in org.eclipse.ui.actions with parameters of type IAdaptable
`OpenInNewWindowAction(IWorkbenchWindow window, IAdaptable input)` Creates a new `OpenInNewWindowAction`.
`OpenNewPageMenu(IWorkbenchWindow window, IAdaptable input)` Deprecated. Constructs a new instance of `OpenNewPageMenu`.
`OpenNewWindowMenu(IWorkbenchWindow window, IAdaptable input)` Deprecated. Constructs a new instance of `OpenNewPageMenu`.
`OpenPerspectiveMenu(IWorkbenchWindow window, IAdaptable input)` Deprecated. Constructs a new instance of `OpenNewPageMenu`.
`OpenWithMenu(IWorkbenchPage page, IAdaptable file)` Constructs a new instance of `OpenWithMenu`.

Uses of IAdaptable in org.eclipse.ui.application

Methods in org.eclipse.ui.application that return IAdaptable
`IAdaptable` `WorkbenchAdvisor.getDefaultPageInput()` Returns the default input for newly created workbench pages when the input is not explicitly specified.

Uses of IAdaptable in org.eclipse.ui.console

Subinterfaces of IAdaptable in org.eclipse.ui.console
`interface` `IConsolePageParticipant` A console page participant is notified of page lifecycle events such as creation, activation, deactivation and disposal.
`interface` `IConsoleView` A view that displays consoles registered with the console manager.

Classes in org.eclipse.ui.console that implement IAdaptable
`class` `TextConsolePage` A page for a text console.

Uses of IAdaptable in org.eclipse.ui.dialogs

Classes in org.eclipse.ui.dialogs that implement IAdaptable
`class` `FileSystemElement` Instances of this class represent files or file-like entities (eg.- zip file entries) on the local file system.

Methods in org.eclipse.ui.dialogs that return IAdaptable
`IAdaptable` `PropertyPage.getElement()`

Methods in org.eclipse.ui.dialogs with parameters of type IAdaptable
`static PreferenceDialog` `PreferencesUtil.createPropertyDialogOn(Shell shell, IAdaptable element, String propertyPageId, String[] displayedIds, Object data)` Creates a workbench preference dialog to a particular preference page.
`static PreferenceDialog` `PreferencesUtil.createPropertyDialogOn(Shell shell, IAdaptable element, String propertyPageId, String[] displayedIds, Object data, int options)` Creates a workbench preference dialog to a particular preference page.
`protected Object[]` `WizardExportPage.queryIndividualResourcesToExport(IAdaptable rootResource)` Deprecated. Queries the user for the individual resources that are to be exported and returns these resources as a collection.
`void` `PropertyPage.setElement(IAdaptable element)` Sets the element that owns properties shown on this page.

Constructors in org.eclipse.ui.dialogs with parameters of type IAdaptable
`ResourceSelectionDialog(Shell parentShell, IAdaptable rootElement, String message)` Creates a resource selection dialog rooted at the given element.

Uses of IAdaptable in org.eclipse.ui.editors.text

Classes in org.eclipse.ui.editors.text that implement IAdaptable
`class` `TextEditor` The standard/default text editor.

Uses of IAdaptable in org.eclipse.ui.forms.editor

Subinterfaces of IAdaptable in org.eclipse.ui.forms.editor
`interface` `IFormPage` Interface that all GUI pages need to implement in order to be added to FormEditor part.

Classes in org.eclipse.ui.forms.editor that implement IAdaptable
`class` `FormEditor` 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.
`class` `FormPage` A base class that all pages that should be added to FormEditor must subclass.
`class` `SharedHeaderFormEditor` A variation of `FormEditor`, this editor has a stable header that does not change when pages are switched.

Uses of IAdaptable in org.eclipse.ui.ide

Classes in org.eclipse.ui.ide that implement IAdaptable
`class` `FileStoreEditorInput` Implements an IEditorInput instance appropriate for `IFileStore` elements that represent files that are not part of the current workspace.

Methods in org.eclipse.ui.ide that return IAdaptable
`IAdaptable` `FileStoreEditorInputFactory.createElement(IMemento memento)`

Methods in org.eclipse.ui.ide with parameters of type IAdaptable
`ResourceMapping` `IContributorResourceAdapter2.getAdaptedResourceMapping(IAdaptable adaptable)` Return the resource mapping that the supplied adaptable adapts to.

Uses of IAdaptable in org.eclipse.ui.ide.undo

Methods in org.eclipse.ui.ide.undo that return IAdaptable
`static IAdaptable` `WorkspaceUndoUtil.getUIInfoAdapter(Shell shell)` Make an `IAdaptable` that adapts to the specified shell, suitable for passing for passing to any `IUndoableOperation` or `IOperationHistory` method that requires an `IAdaptable` `uiInfo` parameter.

Methods in org.eclipse.ui.ide.undo with parameters of type IAdaptable
`protected void` `CopyResourcesOperation.copy(IProgressMonitor monitor, IAdaptable uiInfo)` Move or copy any known resources according to the destination parameters known by this operation.
`protected void` `DeleteResourcesOperation.doExecute(IProgressMonitor monitor, IAdaptable uiInfo)`
`protected void` `DeleteMarkersOperation.doExecute(IProgressMonitor monitor, IAdaptable info)`
`protected abstract void` `AbstractWorkspaceOperation.doExecute(IProgressMonitor monitor, IAdaptable uiInfo)` Perform the specific work involved in executing this operation.
`protected void` `MoveResourcesOperation.doExecute(IProgressMonitor monitor, IAdaptable uiInfo)`
`protected void` `UpdateMarkersOperation.doExecute(IProgressMonitor monitor, IAdaptable info)`
`protected void` `MoveProjectOperation.doExecute(IProgressMonitor monitor, IAdaptable uiInfo)`
`protected void` `CreateMarkersOperation.doExecute(IProgressMonitor monitor, IAdaptable info)`
`protected void` `CopyProjectOperation.doExecute(IProgressMonitor monitor, IAdaptable uiInfo)`
`protected void` `CopyResourcesOperation.doExecute(IProgressMonitor monitor, IAdaptable uiInfo)`
`protected void` `DeleteResourcesOperation.doUndo(IProgressMonitor monitor, IAdaptable uiInfo)`
`protected void` `DeleteMarkersOperation.doUndo(IProgressMonitor monitor, IAdaptable info)`
`protected abstract void` `AbstractWorkspaceOperation.doUndo(IProgressMonitor monitor, IAdaptable uiInfo)` Perform the specific work involved in undoing this operation.
`protected void` `MoveResourcesOperation.doUndo(IProgressMonitor monitor, IAdaptable uiInfo)`
`protected void` `UpdateMarkersOperation.doUndo(IProgressMonitor monitor, IAdaptable info)`
`protected void` `MoveProjectOperation.doUndo(IProgressMonitor monitor, IAdaptable uiInfo)`
`protected void` `CreateMarkersOperation.doUndo(IProgressMonitor monitor, IAdaptable info)`
`protected void` `CopyProjectOperation.doUndo(IProgressMonitor monitor, IAdaptable uiInfo)`
`protected void` `CopyResourcesOperation.doUndo(IProgressMonitor monitor, IAdaptable uiInfo)`
`IStatus` `AbstractWorkspaceOperation.execute(IProgressMonitor monitor, IAdaptable uiInfo)` Execute the specified operation.
`protected Shell` `AbstractWorkspaceOperation.getShell(IAdaptable uiInfo)` Return the shell described by the specified adaptable, or the active shell if no shell has been specified in the adaptable.
`static Shell` `WorkspaceUndoUtil.getShell(IAdaptable uiInfo)` Return the shell described by the specified adaptable, or the active shell if no shell has been specified in the adaptable.
`protected void` `MoveResourcesOperation.move(IProgressMonitor monitor, IAdaptable uiInfo)` Move any known resources according to the destination parameters known by this operation.
`IStatus` `AbstractWorkspaceOperation.redo(IProgressMonitor monitor, IAdaptable uiInfo)` Redo the specified operation.
`IStatus` `AbstractWorkspaceOperation.undo(IProgressMonitor monitor, IAdaptable uiInfo)` Undo the specified operation.

Uses of IAdaptable in org.eclipse.ui.internal.views.markers

Classes in org.eclipse.ui.internal.views.markers that implement IAdaptable
`class` `org.eclipse.ui.internal.views.markers.ExtendedMarkersView` The ExtendedMarkersView is the internal implementation of the view that shows markers using the markerGenerators extension point.

Uses of IAdaptable in org.eclipse.ui.intro

Subinterfaces of IAdaptable in org.eclipse.ui.intro
`interface` `IIntroPart` The intro part is a visual component within the workbench responsible for introducing the product to new users.
`interface` `IIntroSite` The primary interface between an intro part and the workbench.

Uses of IAdaptable in org.eclipse.ui.intro.config

Classes in org.eclipse.ui.intro.config that implement IAdaptable
`class` `CustomizableIntroPart` A re-usable intro part that the Eclipse platform uses for its Out of the Box Experience.

Uses of IAdaptable in org.eclipse.ui.model

Subinterfaces of IAdaptable in org.eclipse.ui.model
`interface` `IComparableContribution` Instances of this interface represent a contribution within the workbench.

Classes in org.eclipse.ui.model that implement IAdaptable
`class` `AdaptableList` A modifiable list of `IAdaptable` objects.

Methods in org.eclipse.ui.model with parameters of type IAdaptable
`AdaptableList` `AdaptableList.add(IAdaptable adaptable)` Adds the given adaptable object to this list.
`void` `AdaptableList.remove(IAdaptable adaptable)` Removes the given adaptable object from this list.

Constructors in org.eclipse.ui.model with parameters of type IAdaptable
`AdaptableList(IAdaptable[] newChildren)` Creates a new adaptable list containing the given children.

Uses of IAdaptable in org.eclipse.ui.navigator

Subinterfaces of IAdaptable in org.eclipse.ui.navigator
`interface` `ICommonViewerSite` Provides context for extensions including a valid shell, a selection provider, and a unique identifier corresponding to the abstract viewer behind the viewer site.
`interface` `ICommonViewerWorkbenchSite` Provides a page, set of action bars, menu registration callback, and active window.
`interface` `INavigatorContentExtension` The content extension represents the components of a navigatorContent extension.

Classes in org.eclipse.ui.navigator that implement IAdaptable
`class` `CommonNavigator` This class provides the IViewPart for the Common Navigator framework in the Eclipse workbench.

Uses of IAdaptable in org.eclipse.ui.navigator.resources

Classes in org.eclipse.ui.navigator.resources that implement IAdaptable
`class` `ProjectExplorer`

Uses of IAdaptable in org.eclipse.ui.operations

Classes in org.eclipse.ui.operations that implement IAdaptable
`class` `OperationHistoryActionHandler` OperationHistoryActionHandler implements common behavior for the undo and redo actions.
`class` `RedoActionHandler` RedoActionHandler provides common behavior for redoing an operation, as well as labelling and enabling the menu item.
`class` `UndoActionHandler` UndoActionHandler provides common behavior for performing an undo, as well as labelling and enabling the undo menu item.

Methods in org.eclipse.ui.operations with parameters of type IAdaptable
`protected IStatus` `LinearUndoViolationUserApprover.allowLinearRedoViolation(IUndoableOperation operation, IUndoContext context, IOperationHistory history, IAdaptable uiInfo)`
`protected IStatus` `LinearUndoViolationUserApprover.allowLinearUndoViolation(IUndoableOperation operation, IUndoContext context, IOperationHistory history, IAdaptable uiInfo)`
`IStatus` `NonLocalUndoUserApprover.proceedRedoing(IUndoableOperation operation, IOperationHistory history, IAdaptable uiInfo)`
`IStatus` `NonLocalUndoUserApprover.proceedUndoing(IUndoableOperation operation, IOperationHistory history, IAdaptable uiInfo)`

Uses of IAdaptable in org.eclipse.ui.part

Subinterfaces of IAdaptable in org.eclipse.ui.part
`interface` `IPageSite` The primary interface between a page and the outside world.

Classes in org.eclipse.ui.part that implement IAdaptable
`class` `AbstractMultiEditor` A AbstractMultiEditor is a composite of editors.
`class` `EditorPart` Abstract base implementation of all workbench editors.
`class` `FileEditorInput` Adapter for making a file resource a suitable input for an editor.
`class` `FileInPlaceEditorInput` Adapter for making a file resource a suitable input for an in-place editor.
`class` `IntroPart` Abstract base implementation of an intro part.
`class` `MultiEditor` A MultiEditor is a composite of editors.
`class` `MultiEditorInput` Implements an input for a `AbstractMultiEditor`.
`class` `MultiPageEditor` Deprecated. Use the class `MultiPageEditorPart` instead
`class` `MultiPageEditorPart` A multi-page editor is an editor with multiple pages, each of which may contain an editor or an arbitrary SWT control.
`class` `MultiPageEditorSite` Site for a nested editor within a multi-page editor.
`class` `PageBookView` Abstract superclass of all multi-page workbench views.
`class` `PageSite` This implementation of `IPageSite` provides a site for a page within a `PageBookView`.
`class` `ViewPart` Abstract base implementation of all workbench views.
`class` `WorkbenchPart` Abstract base implementation of all workbench parts.

Methods in org.eclipse.ui.part that return IAdaptable
`IAdaptable` `FileEditorInputFactory.createElement(IMemento memento)`

Uses of IAdaptable in org.eclipse.ui.progress

Classes in org.eclipse.ui.progress that implement IAdaptable
`class` `PendingUpdateAdapter` The PendingUpdateAdapter is a convenience object that can be used by a BaseWorkbenchContentProvider that wants to show a pending update.
`class` `UIJob` The UIJob is a Job that runs within the UI Thread via an asyncExec.
`class` `WorkbenchJob` WorkbenchJob is a type of job that implements a done listener and does the shutdown checks before scheduling.

Uses of IAdaptable in org.eclipse.ui.statushandlers

Classes in org.eclipse.ui.statushandlers that implement IAdaptable
`class` `StatusAdapter` The StatusAdapter wraps an instance of IStatus subclass and can hold additional information either by using properties or by adding a new adapter.

Uses of IAdaptable in org.eclipse.ui.texteditor

Subinterfaces of IAdaptable in org.eclipse.ui.texteditor
`interface` `ITextEditor` Interface to a text editor.

Classes in org.eclipse.ui.texteditor that implement IAdaptable
`class` `AbstractDecoratedTextEditor` 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.
`class` `AbstractTextEditor` Abstract base implementation of a text editor.
`protected static class` `AbstractTextEditor.TextEditorSavable` This text editor's savable.
`class` `StatusTextEditor` Capable of handling input elements that have an associated status with them.

Methods in org.eclipse.ui.texteditor with parameters of type IAdaptable
`IHyperlinkDetector[]` `HyperlinkDetectorRegistry.createHyperlinkDetectors(String targetId, IAdaptable context)`

Uses of IAdaptable in org.eclipse.ui.texteditor.templates

Classes in org.eclipse.ui.texteditor.templates that implement IAdaptable
`class` `TemplatesView` The Templates view.hosts `ITemplatesPage`s that shows the templates for the currently active editor part.

Uses of IAdaptable in org.eclipse.ui.views

Subinterfaces of IAdaptable in org.eclipse.ui.views
`interface` `IViewDescriptor` This is a view descriptor.

Uses of IAdaptable in org.eclipse.ui.views.bookmarkexplorer

Classes in org.eclipse.ui.views.bookmarkexplorer that implement IAdaptable
`class` `BookmarkNavigator` Deprecated. This view is no longer in use as of Eclipse 3.4. The view referenced by `IPageLayout.ID_BOOKMARKS` is an `ExtendedMarkersView`.

Uses of IAdaptable in org.eclipse.ui.views.contentoutline

Classes in org.eclipse.ui.views.contentoutline that implement IAdaptable
`class` `ContentOutline` Main class for the Content Outline View.

Uses of IAdaptable in org.eclipse.ui.views.markers

Classes in org.eclipse.ui.views.markers that implement IAdaptable
`class` `MarkerSupportView` The MarkerSupportView is a view that supports the extensions in the markerSupport extension point.

Methods in org.eclipse.ui.views.markers with parameters of type IAdaptable
`void` `MarkerViewHandler.execute(IUndoableOperation operation, String title, IProgressMonitor monitor, IAdaptable uiInfo)` Execute the specified undoable operation

Uses of IAdaptable in org.eclipse.ui.views.navigator

Subinterfaces of IAdaptable in org.eclipse.ui.views.navigator
`interface` `IResourceNavigator` Deprecated. as of 3.5, use the Common Navigator Framework classes instead

Classes in org.eclipse.ui.views.navigator that implement IAdaptable
`class` `ResourceNavigator` Deprecated. as of 3.5, use the Common Navigator Framework classes instead

Methods in org.eclipse.ui.views.navigator that return IAdaptable
`protected IAdaptable` `ResourceNavigator.getInitialInput()` Deprecated. Returns the initial input for the viewer.

Uses of IAdaptable in org.eclipse.ui.views.properties

Classes in org.eclipse.ui.views.properties that implement IAdaptable
`class` `PropertySheet` Main class for the Property Sheet View.
`class` `PropertySheetPage` 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.

Uses of IAdaptable in org.eclipse.ui.views.tasklist

Classes in org.eclipse.ui.views.tasklist that implement IAdaptable
`class` `TaskList` Deprecated. This view is no longer in use as of Eclipse 3.4. The view referenced by `IPageLayout.ID_TASK_LIST` is an `MarkerSupportView`.

Methods in org.eclipse.ui.views.tasklist with parameters of type IAdaptable
`IResource` `ITaskListResourceAdapter.getAffectedResource(IAdaptable adaptable)` Returns the resource to query for the markers to display for the given adaptable.

Uses of IAdaptable in org.eclipse.ui.wizards

Subinterfaces of IAdaptable in org.eclipse.ui.wizards
`interface` `IWizardDescriptor` Base interface for all wizards defined via workbench extension points.

Uses of IAdaptable in org.eclipse.update.configuration

Subinterfaces of IAdaptable in org.eclipse.update.configuration
`interface` `IActivity` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`interface` `IConfiguredSite` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`interface` `IInstallConfiguration` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`interface` `ILocalSite` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`interface` `ISessionDelta` Deprecated. Do not use this interface This API will be deleted in a future release. See bug 311590 for details.
`interface` `IVolume` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.

Uses of IAdaptable in org.eclipse.update.core

Subinterfaces of IAdaptable in org.eclipse.update.core
`interface` `IArchiveReference` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`interface` `ICategory` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`interface` `IFeature` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`interface` `IFeatureReference` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`interface` `IImport` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`interface` `IIncludedFeatureReference` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`interface` `IInstallHandlerEntry` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`interface` `INonPluginEntry` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`interface` `IPlatformEnvironment` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`interface` `IPluginEntry` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`interface` `ISite` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`interface` `ISiteFeatureReference` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`interface` `ISiteWithMirrors` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`interface` `IURLEntry` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.

Classes in org.eclipse.update.core that implement IAdaptable
`class` `ArchiveReference` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`class` `Category` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`class` `Feature` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`class` `FeatureReference` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`class` `Import` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`class` `IncludedFeatureReference` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`class` `InstallHandlerEntry` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`class` `NonPluginEntry` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`class` `PluginEntry` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`class` `Site` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`class` `SiteFeatureReference` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`class` `SiteFeatureReferenceModel` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`class` `URLEntry` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.

Uses of IAdaptable in org.eclipse.update.core.model

Classes in org.eclipse.update.core.model that implement IAdaptable
`class` `ArchiveReferenceModel` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`class` `CategoryModel` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`class` `ContentEntryModel` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`class` `FeatureModel` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`class` `FeatureReferenceModel` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`class` `ImportModel` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`class` `IncludedFeatureReferenceModel` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`class` `InstallHandlerEntryModel` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`class` `ModelObject` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`class` `NonPluginEntryModel` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`class` `PluginEntryModel` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`class` `SiteModel` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.
`class` `URLEntryModel` Deprecated. The org.eclipse.update component has been replaced by Equinox p2. This API will be deleted in a future release. See bug 311590 for details.

Eclipse Platform Release 3.7

Guidelines for using Eclipse APIs.

Copyright (c) Eclipse contributors and others 2000, 2011. All rights reserved.