Package oracle.ide.palette2

Contains interfaces and classes that allow for palette integration.

See: Description

Interface Summary

Interface	Description
PaletteConsumer	The PaletteConsumer interface should be implemented by a client View (EG.
PaletteListener	The PaletteListener interface should be implemented by clients that are interested in receiving notifications about PaletteWindow instances being opened, closed, selectionChanged, or Item Pressed.
PalettePageContext
PalettePagesListener	Clients that are interested in receiving notifications about updates to PalettePages instances should implement the PalettePagesListener interface.
PaletteSearch	Interface callback that is invoked by Palette Search to determine if a search string is associated with a component.
PaletteTransferable	Interface that permits Context to be added to a transferable.

Class Summary

Class	Description
AbstractPaletteObjectBuilder<T>	The AbstractPaletteObjectBuilder aids in building objects related to the component palette.
DefaultPaletteGroup	DefaultPaletteGroup - class provides a default PaletteGroup model implementation that can be extended by client extension developers.
DefaultPaletteGroup.Builder
DefaultPaletteItem	DefaultPaletteItem - class provides a default PaletteItem model implementation that can be extended by client extension developers.
DefaultPaletteItem.Builder
DefaultPalettePage	DefaultPalettePage - class provides a default PalettePage model implementation that can be extended by client extension developers.
DefaultPalettePage.Builder
DefaultPalettePage.PageRecord	Holds parameters passed during the creation a page.
DefaultPalettePage.ShowForTypeRecord	Holds information about what document types are associated with this page.
DefaultPaletteSection	DefaultPaletteSection - class provides a default PaletteSection model implementation that can be extended by client extension developers.
DefaultPaletteSection.Builder
Palette	Palette represents the root model class for the Component Palette.
PaletteEvent	The PaletteEvent class is used with the PaletteListener to return state information.
PaletteGroup	Palette Group is the second level the Component Palette model and is the "child" of PalettePage.
PaletteItem	Palette Item is the leaf of the Component Palette model and is the "child" of PaletteSection.
PaletteManager	The PaletteManager class is the Component Palette Controller.
PalettePage	Palette Page is an abstract class and is the first level of the Component Palette model and a "child" of PalettePages.
PalettePageProvider	PalettePageProvider returns an instance of class PalettePages given a display context.
PalettePages	PalettePages is an abstract class that comprises the list of PalettePage's given a display context.
PaletteSection	Palette Section is the third level the Component Palette model and is the "child" of PaletteGroup.
PaletteWindow	The PaletteWindow class is the Component Palette View.

Package oracle.ide.palette2 Description

Contains interfaces and classes that allow for palette integration.

These classes provide the means to dynamically update the Component Palette at runtime. It is, recommended that static palette components be defined to the Component Palette using a Palette extension point schema (palette-hook) in lieu of using these classes. Please reference file componentpalette-hook.xsd for a description of the elements that comprise a Palette extension point schema.

Model, View, Controller

The palette model is organized in a hierarchy of Palette (the model), Page, Group, Section, and Item. The relationships are: Item is a child of Section, Section is a child of Group, and Group is a child of Page.

Model relationships to Component Palette:

Page appears in the Palette window selection combo box.

Group is a dockable windows within the Component Palette window.

Section is a subgrouping within Group and if named displays as a separator

Item is a component which may be dragged and dropped onto a client window.

Noteworthy of this implementation is that the Palette model maintains a collection of PageProvider's instead of Pages. This is because Palette2 uses a "provider" design pattern that allows extension writers to supply Pages to the Component Palette given a display context. This provides complete flexibility with regards to which components are displayed by the Component Palatte.

Class files that comprise the Palette Model, For additional information see the JavaDoc for each class.

Class name	Description
Palette	Concrete class that implements Palette. PalettePageProvider's are registered with this class.
PalettePageProvider	Asbstract class that returns an instance of class PalettePages given a display context. This class is implemented by extension writers.
PalettePages	Abstract class that comprises a list of PalettePage's. This class is created by PalettePageProvider and is implemented by extension writers. The Palette registers a PalettePagesListener with this class in order to receive notification when a page provider updates its list of associated pages. This notification will cause the palette to update the view.
PalettePage	Abstract class for a Page and is a child of PalettePages. This class is implemented by extension writers.
PaletteGroup	Abstract class for a Group and is a child of PalettePage. This class is implemented by extension writers.
PaletteSection	Abstract class for a Section and is a child of PaletteGroup. This class is implemented by extension writers.
PaletteItem	Abstract class for a Item (component) and is a child of PaletteSection. This class is implemented by extension writers.

Class PaletteWindow provides the palette view API's. Clients may register a listener (see PaletteListener)are interested in receiving notifications related to palette open, palette close, and component selection.

Class PaletteManager provides the palette controller API's.

Drag and Drop notes.

The default data flavor is PaletteItem.PALETTE_ITEM_FLAVOR and the transferable data is PaletteItem.

For backwards compatibility with Palette1 and existing implementations a class that extends PaletteTransferable can be provided for an Item. Class DefaultPaletteItem should be used since the class name is supplied using the Editor element. The Component Palette will instantiate a newInstance of this class setting the selected PaletteItem as context dat. The newInstance is used as the drag source transferable.

Default concrete classes

Class file names starting with DefaultPalette are concrete implementations of the Palette Model that may be extended. These classes support the Palette extension point implementation but may provide a useful starting point for extension writers.

Regarding Palette1 data migration

It is recognized that it will take time to migrate existing Palette1 extensions to Palette2. To assist with the transition the following will be provided:

Page provider DeclaredPalette1PageProvider will automatically pull Palette1 Pages and Components to Palette2.

To block a Page from being pulled from Palette1 add the page name to the palette-hook palette1PaletteExclusions list.

Extensions may continue to call Palette1 APIs. Updates of the Palette1 model will result in the page provider re-pulling Palette1 data to Palette2. APIs which affect the UI, like PaletteWindow reset(), will be noops (no operations).

Still being investigated. The plan is support the display dialogs when components are selected.