Eclipse Platform
Release 3.1

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.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.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.debug.ui.memory   
org.eclipse.debug.ui.sourcelookup Provides a user interface for debug platform source lookup facilities. 
org.eclipse.ltk.core.refactoring Application programmer interface to implement semantic preserving workspace transformations. 
org.eclipse.ltk.core.refactoring.participants Application programmer interface to participant in existing rename, move and delete refactorings if the refactoring provider supports participation. 
org.eclipse.ltk.ui.refactoring Application programmer 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.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.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.texteditor Provides a framework for text editors obeying to the desktop rules.  
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.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.  
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.commands.operations
 

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

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 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.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 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.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 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(IBreakpoint breakpoint)
          Returns objects representing the categories of the specified breakpoint or null if this organizer cannot classify the breakpoint.
 IAdaptable[] IBreakpointOrganizerDelegate.getCategories()
          Returns all categories managed by this organizer, or null.
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.
 IAdaptable[] AbstractBreakpointOrganizerDelegate.getCategories()
           
 

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 IBreakpointOrganizerDelegate.removeBreakpoint(IBreakpoint breakpoint, IAdaptable category)
          Removes the specified breakpoint from the given category.
 boolean IBreakpointOrganizerDelegate.canAdd(IBreakpoint breakpoint, IAdaptable category)
          Returns whether the given breakpoint can be categorized in the specified category.
 boolean IBreakpointOrganizerDelegate.canRemove(IBreakpoint breakpoint, IAdaptable category)
          Returns whether the given breakpoint can be removed from the given category.
 void AbstractBreakpointOrganizerDelegate.addBreakpoint(IBreakpoint breakpoint, IAdaptable category)
           
 boolean AbstractBreakpointOrganizerDelegate.canAdd(IBreakpoint breakpoint, IAdaptable category)
           
 boolean AbstractBreakpointOrganizerDelegate.canRemove(IBreakpoint breakpoint, IAdaptable category)
           
 void AbstractBreakpointOrganizerDelegate.removeBreakpoint(IBreakpoint breakpoint, IAdaptable category)
           
protected  void AbstractBreakpointOrganizerDelegate.fireCategoryChanged(IAdaptable category)
          Fires a property change notification for 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.
 

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 WorkingSetSourceContainer
          A working set in the workspace.
 

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 NullChange
          A refactoring change that does nothing.
 class Refactoring
          Abstract super class for all refactorings.
 class TextChange
          A text change is a special change object that applies a text edit tree to a document.
 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.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 abstract 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 refactoring processor.
 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.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 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 infrastructure.
 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 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 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 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
 void PropertyPage.setElement(IAdaptable element)
          Sets the element that owns properties shown on this page.
static PreferenceDialog PreferencesUtil.createPropertyDialogOn(Shell shell, IAdaptable element, String propertyPageId, String[] displayedIds, Object data)
          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.
 

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.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
 IStatus NonLocalUndoUserApprover.proceedRedoing(IUndoableOperation operation, IOperationHistory history, IAdaptable uiInfo)
           
 IStatus NonLocalUndoUserApprover.proceedUndoing(IUndoableOperation operation, IOperationHistory history, IAdaptable uiInfo)
           
protected  IStatus LinearUndoViolationUserApprover.allowLinearRedoViolation(IUndoableOperation operation, IUndoContext context, IOperationHistory history, IAdaptable uiInfo)
           
protected  IStatus LinearUndoViolationUserApprover.allowLinearUndoViolation(IUndoableOperation operation, IUndoContext context, 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 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 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)
           
 

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
 

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
          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.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
          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 ISiteWithMirrors
          An extension of ISite that supports mirrors.
 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.
 


Eclipse Platform
Release 3.1

Guidelines for using Eclipse APIs.

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