Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Eclipse Platform Release 3.0
PREV NEXT | FRAMES NO FRAMES

## 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.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.runtime | Provides core support for plug-ins and the plug-in 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.core.sourcelookup.containers |
org.eclipse.debug.ui | Provides a generic debugger user interface that clients may customize via standard workbench extension points.
org.eclipse.search.ui | Provides classes and interfaces to run search queries and manage their results.
org.eclipse.team.core | Application programming interfaces for defining and working with repository providers.
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.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.intro | Application programming interfaces for interaction with and extension of the Eclipse Platform User Interface.
org.eclipse.ui.intro.config |
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.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.texteditor | Provides a framework for text editors obeying to the desktop rules.
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.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.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.

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.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` | `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 metadata 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.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` | `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.

Classes in org.eclipse.debug.core.model that implement IAdaptable
`class` | `Breakpoint` Abstract implementation of a breakpoint.
`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` | `DefaultSourceContainer` A source container that computers 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.core.sourcelookup.containers

Classes in org.eclipse.debug.internal.core.sourcelookup.containers that implement IAdaptable
`class` | `org.eclipse.debug.internal.core.sourcelookup.containers.ContainerSourceContainer` A container in the workspace.

Uses of IAdaptable in org.eclipse.debug.ui

Subinterfaces of IAdaptable in org.eclipse.debug.ui
`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.

Methods in org.eclipse.debug.ui that return IAdaptable
`static IAdaptable` | `DebugUITools.getDebugContext()` Returns the currently selected element in the debug view of the current workbench page, or `null` if there is no current debug context, or if not called from the UI thread.

Uses of IAdaptable in org.eclipse.search.ui

Subinterfaces of IAdaptable in org.eclipse.search.ui
`interface` | `ISearchResultView` Deprecated. Use `ISearchResultViewPart` 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` | `RepositoryProvider` A concrete subclass of `RepositoryProvider` is created for each project that is associated with a repository provider.

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` A saveable workbench part is a visual component that can be shown within different contexts (e.g a dialog, workbench page).

Classes in org.eclipse.team.ui that implement IAdaptable
`class` | `SaveablePartAdapter` This adapter provides default implementations for methods on `ISaveableWorkbenchPart` and `IWorkbenchPart`.

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

Subinterfaces of IAdaptable in org.eclipse.team.ui.synchronize
`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` | `ParticipantPageSaveablePart` Displays a synchronize participant page combined with the compare/merge infrastructured.
`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` | `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` | `IViewPart` A view is a visual component within a workbench page.
`interface` | `IViewSite` The primary interface between a view part and the workbench.
`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` | `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.

Methods in org.eclipse.ui that return IAdaptable
`IAdaptable[]` | `IWorkingSet.getElements()` Returns the elements that are contained in this working set.
`IAdaptable` | `IWorkbenchPropertyPage.getElement()` Returns the object that owns the properties shown in this page.
`IAdaptable` | `IWorkbenchPage.getInput()` Returns the input for this page.
`IAdaptable` | `IElementFactory.createElement(IMemento memento)` Re-creates and returns an object from the state captured within the given memento.

Methods in org.eclipse.ui with parameters of type IAdaptable
`IWorkingSet` | `IWorkingSetManager.createWorkingSet(String name, IAdaptable[] elements)` Creates a new working set.
`void` | `IWorkingSet.setElements(IAdaptable[] elements)` Sets the elements that are contained in this working set.
`IWorkbenchPage` | `IWorkbenchWindow.openPage(String perspectiveId, IAdaptable input)` Creates and opens a new workbench page.
`IWorkbenchPage` | `IWorkbenchWindow.openPage(IAdaptable input)` Creates and opens a new workbench page.
`void` | `IWorkbenchPropertyPage.setElement(IAdaptable element)` Sets the object that owns the properties shown in this page.
`IWorkbenchWindow` | `IWorkbench.openWorkbenchWindow(String perspectiveId, IAdaptable input)` Creates and opens a new workbench window with one page.
`IWorkbenchWindow` | `IWorkbench.openWorkbenchWindow(IAdaptable input)` Creates and opens a new workbench window with one page.
`IWorkbenchPage` | `IWorkbench.showPerspective(String perspectiveId, IWorkbenchWindow window, IAdaptable input)` Shows the specified perspective to the user.
`IResource` | `IContributorResourceAdapter.getAdaptedResource(IAdaptable adaptable)` Return the resource that the supplied adaptable adapts to.

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
`OpenPerspectiveMenu(IWorkbenchWindow window, IAdaptable input)` Deprecated. Constructs a new instance of `OpenNewPageMenu`.
`OpenNewWindowMenu(IWorkbenchWindow window, IAdaptable input)` Deprecated. Constructs a new instance of `OpenNewPageMenu`.
`OpenNewPageMenu(IWorkbenchWindow window, IAdaptable input)` Deprecated. Constructs a new instance of `OpenNewPageMenu`.
`OpenInNewWindowAction(IWorkbenchWindow window, IAdaptable input)` Creates a new `OpenInNewWindowAction`.
`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.

Uses of IAdaptable in org.eclipse.ui.console

Subinterfaces of IAdaptable in org.eclipse.ui.console
`interface` | `IConsoleView` A view that displays consoles registered with the console manager.

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
`void` | `PropertyPage.setElement(IAdaptable element)` Sets the element that owns properties shown on this 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.

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 text editor for file resources (`IFile`).

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.

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

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.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` | `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 a input for a MultiEditor.
`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)`
`IAdaptable` | `FileEditorInputFactory.createElement(IMemento memento)`

Uses of IAdaptable in org.eclipse.ui.progress

Classes in org.eclipse.ui.progress that implement IAdaptable
`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.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.
`class` | `StatusTextEditor` Capable of handling input elements that have an associated status with them.

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

Classes in org.eclipse.ui.views.bookmarkexplorer that implement IAdaptable
`class` | `BookmarkNavigator` Main class for the bookmark navigator for displaying bookmarks on resources and opening an editor on the bookmarked resource when the user commands.

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.navigator

Subinterfaces of IAdaptable in org.eclipse.ui.views.navigator
`interface` | `IResourceNavigator` This interface defines the API for the resource navigator.

Classes in org.eclipse.ui.views.navigator that implement IAdaptable
`class` | `ResourceNavigator` Implements the Resource Navigator view.

Methods in org.eclipse.ui.views.navigator that return IAdaptable
`protected IAdaptable` | `ResourceNavigator.getInitialInput()` 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.

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

Classes in org.eclipse.ui.views.tasklist that implement IAdaptable
`class` | `TaskList` Main class for the Task List view for displaying tasks and problem annotations on resources, and for opening an editor on the resource when the user commands.

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.update.configuration

Subinterfaces of IAdaptable in org.eclipse.update.configuration
`interface` | `IActivity` Install activity.
`interface` | `IConfiguredSite` Configured Site.
`interface` | `IInstallConfiguration` Installation configuration.
`interface` | `ILocalSite` Local Site.
`interface` | `ISessionDelta` Deprecated. Do not use this interface
`interface` | `IVolume` Local Volume Info.

Uses of IAdaptable in org.eclipse.update.core

Subinterfaces of IAdaptable in org.eclipse.update.core
`interface` | `IArchiveReference` Site archive interface.
`interface` | `ICategory` Feature category definition.
`interface` | `IFeature` Feature defines the packaging "container" for a group of related plug-ins, plug-in fragments, and optionally non-plug-in files.
`interface` | `IFeatureReference` Feature reference.
`interface` | `IImport` Plug-in dependency entry.
`interface` | `IIncludedFeatureReference` Included Feature reference.
`interface` | `IInstallHandlerEntry` Install handler entry.
`interface` | `INonPluginEntry` Non-plug-in entry defines an arbitrary non-plug-in data file packaged as part of a feature.
`interface` | `IPlatformEnvironment` Plug-in entry defines a packaging reference from a feature to a plug-in.
`interface` | `IPluginEntry` Plug-in entry defines a packaging reference from a feature to a plug-in.
`interface` | `ISite` Site represents a location containing some number of features (packaged or installed).
`interface` | `ISiteFeatureReference` Site Feature reference.
`interface` | `IURLEntry` URL entry is an annotated URL object.

Classes in org.eclipse.update.core that implement IAdaptable
`class` | `ArchiveReference` Convenience implementation of a site archive.
`class` | `Category` Convenience implementation of feature category definition.
`class` | `Feature` Convenience implementation of a feature.
`class` | `FeatureReference` Convenience implementation of a feature reference.
`class` | `Import` Convenience implementation of a plug-in dependency.
`class` | `IncludedFeatureReference` This is a utility class representing the options of a nested feature.
`class` | `InstallHandlerEntry` Convenience implementation of an install handler entry.
`class` | `NonPluginEntry` Convenience implementation of non-plug-in entry.
`class` | `PluginEntry` Convenience implementation of plug-in entry.
`class` | `Site` Convenience implementation of a site.
`class` | `SiteFeatureReference` Convenience implementation of a feature reference.
`class` | `SiteFeatureReferenceModel` Site Feature reference model object.
`class` | `URLEntry` Convenience implementation of an annotated URL.

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

Classes in org.eclipse.update.core.model that implement IAdaptable
`class` | `ArchiveReferenceModel` Site archive model object.
`class` | `CategoryModel` Feature category definition model object.
`class` | `ContentEntryModel` Content entry model object.
`class` | `FeatureModel` Feature model object.
`class` | `FeatureReferenceModel` Feature reference model object.
`class` | `ImportModel` Plug-in dependency model object.
`class` | `IncludedFeatureReferenceModel` Included Feature reference model object.
`class` | `InstallHandlerEntryModel` Install handler entry model object.
`class` | `ModelObject` Root model object.
`class` | `NonPluginEntryModel` Non-plug-in entry model object.
`class` | `PluginEntryModel` Plug-in entry model object.
`class` | `SiteModel` Site model object.
`class` | `URLEntryModel` Annotated URL model object.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Eclipse Platform Release 3.0
PREV NEXT | FRAMES NO FRAMES

Guidelines for using Eclipse APIs.

Copyright (c) IBM Corp. and others 2000, 2004. All rights reserved.