ComponentLevelActions is an interface for retrieving the actions that should be represented as buttons on the Property Inspector toolbar.
The Extension interface is used when registering a concrete implementation of an interface for a given property type for use by the InspectorWindow.
An Inspectable provides information describing the property settings of a given selection.
Inspectable2 is a replacement API for Inspectable and offers a custom dialog hook in lieu of a Customizer.
An InspectableFactory may be registered with the InspectorFactory such that a Context selection made up entirely of instances of a single data type may be collectively described to the InspectorWindow via an instance of a single Inspectable whose PropertyModel amalgamates the property settings of the entire selection.
InspectorPage is an interface which allows GUI 'pages' hosted in the InspectorWindow the opportunity to interact with the hosting InspectorWindow with respect to populating toolbars and receiving focus.
Inspectable that indicates whether properties in a
Displays the description of a property.
Understands finding a property editor for a given property.
The PropertyEditorRegistrar interface offers a means for IDE implementations to register 'out of the box' PropertyEditor implementations with the java.beans.PropertyEditorManager such that they will be available for use by the Property Inspector.
Understands updating a property editor for a given inline editor.
Creates property models from a given IDE context.
Clients need to provide their own Inspectables and PropertyModels.
Clients need to subclass oracle.bali.inspector.PropertyModel
Understands utility methods related to "display values" for a particular inline editor in the Property Inspector.
The IdeMultiObjectModel is a PropertyModel implementation capable of handling undoable property sets on one or more objects.
The IdePropertyModel class extends MultiObjectModel to add additional methods required to make the model more IDE friendly with respect to responding to and sending observer updates.
Provides typesafe getter and setter methods for Context data specific to the property inspector.
The InspectorFactory class is a singleton class that provides a registry for registering Inspectable implementations on a class by class basis.
The InspectorManager manages property inspector views.
The InspectorWindow is a View consisting of a Toolbar area, a main body area and a status area.
A MultiInspectable amalgamates one or more Inspectable instances into a single model for use by the InspectorWindow.
Represents a check box in the Property Inspector UI that can participate in find text operations.
Panel that understands how to render properties in a similar way as the Property Inspector.
Specifies which properties should be displayed in a
Sets the description of a property in the help text area at the bottom of the Property Inspector.
Represents a radio button in the Property Inspector UI that can participate in find text operations.
The InspectorWindow displays the properties of the selected object(s) of the active View. As the selection within the active View changes (e.g. from obj1 to obj2), the InspectorWindow will refresh to display the properties of the new selection (e.g. obj2) providing that the underlying data meets one of the following conditions:
The collection of available properties upon a given type are described by a PropertyModel. A PropertyModel is made available from the Inspectable implementation associated with that type. The Inspectable implementation for that type is registered with the InspectorFactory.
In the simplest case, the collective Inspectable instances, one for each object in the current selection where the selection is made of one or more objects of similar or dissimilar typess, are wrapped inside of a MultiInspectable. The MultiInspectable in turn wraps the collection of PropertyModel instances, one from each Inspectable, into an IdePropertyModel. The MultiInspectable is ultimately the object that is handed to the InspectorWindow and its IdePropertyModel is the model used for display.
In the case where a given data type is known to only ever be selectable in conjunction with other instances of that data type (i.e. it can be stated with certainty that instances of the data type will never appear in a selection with instances of any other data type, as might be the case from an Editor that only ever operates on private tokens of its own construction, a single Inspectable may be used to represent the entire selection. In such cases, an InspectableFactory may be registered that provides the single Inspectable instance based upon a given Context. The PropertyModel of the single Inspectable is still wrapped inside of an IdePropertyModel by the MultiInspectable for handing off to the InspectorWindow as described in the simplest case above.
Default implementations of PropertyModel and Inspectable are provided by the framework where the default Inspectable returns an instance of the default PropertyModel. In the simplest case, integrators need only ensure that their underlying data implements SupportsInspection in order for it to participate in property inspection. If the underlying data cannot be made to implement SupportsInspection, or it is undesirable to do so for some other reason, integrators may still simply register DefaultInspectable for their data type as would have been the case if the data type had implemented SupportsInspection.
The default implementation of PropertyModel, DefaultModel, uses the JavaBeans design pattern for determining the properties of the underlying data type. It is important to note that the underlying data referred to above is that returned from Element.getData(), not the Element itself, where the Element(s) are those found in Context.getSelection() and the Context is the result of View.getContext() called upon the active View in response to a ViewSelectionEvent.
The activity flow is as follows:
See Extending JDeveloper Using the Addin API for detailed information.