Package oracle.ide.inspector

Contains interfaces and classes that integrators may use to make their objects editable from the property inspector.

See: Description

Interface Summary

Interface	Description
ComponentLevelActions	ComponentLevelActions is an interface for retrieving the actions that should be represented as buttons on the Property Inspector toolbar.
Extension	The Extension interface is used when registering a concrete implementation of an interface for a given property type for use by the InspectorWindow.
Inspectable	An Inspectable provides information describing the property settings of a given selection.
Inspectable2	Inspectable2 is a replacement API for Inspectable and offers a custom dialog hook in lieu of a Customizer.
InspectableFactory	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	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.
LayoutOnlyInspectable	Inspectable that indicates whether properties in a PropertyModel that are not present in a layout should be rendered or not in the "Other" category.
PropertyDisplay	Displays the description of a property.
PropertyEditorFinder	Understands finding a property editor for a given property.
PropertyEditorRegistrar	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.
PropertyEditorUpdater	Understands updating a property editor for a given inline editor.
PropertyLayoutProvider
PropertyModelFactory	Creates property models from a given IDE context.

Class Summary

Class	Description
AbstractAdditionalPage
CompositeInspectable
ContextActionPanel
ContextActionPanelHost
CustomEditorButton
DefaultInspectable	Deprecated Clients need to provide their own Inspectables and PropertyModels.
DefaultModel	Deprecated Clients need to subclass oracle.bali.inspector.PropertyModel
DisplayValues	Understands utility methods related to "display values" for a particular inline editor in the Property Inspector.
IdeMultiObjectModel	The IdeMultiObjectModel is a PropertyModel implementation capable of handling undoable property sets on one or more objects.
IdePropertyModel	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.
IdePropertyModelFactory
InspectableViewRegistry	Registers Views that can be inspected by the Property Inspector.
InspectorBundle
InspectorBundle_de
InspectorBundle_en
InspectorBundle_es
InspectorBundle_fr
InspectorBundle_it
InspectorBundle_ja
InspectorBundle_ko
InspectorBundle_pt_BR
InspectorBundle_zh_CN
InspectorBundle_zh_TW
InspectorContext	Provides typesafe getter and setter methods for Context data specific to the property inspector.
InspectorFactory	The InspectorFactory class is a singleton class that provides a registry for registering Inspectable implementations on a class by class basis.
InspectorManager	The InspectorManager manages property inspector views.
InspectorWindow	The InspectorWindow is a View consisting of a Toolbar area, a main body area and a status area.
LayoutInspectable	The LayoutInspectable class must be extended by Inspectable implementations that define property form layout information in an extension manifest.
LazyLoadMenuButton
MultiInspectable	A MultiInspectable amalgamates one or more Inspectable instances into a single model for use by the InspectorWindow.
NotObservableSubjectRegistry	Registry of Subjects that should not be observed by the Property Inspector.
PropertyCheckBox	Represents a check box in the Property Inspector UI that can participate in find text operations.
PropertyDisplayPanel	Panel that understands how to render properties in a similar way as the Property Inspector.
PropertyDisplayPanelLayout	Specifies which properties should be displayed in a PropertyDisplayPanel, and how such properties should be rendered.
PropertyHelp
PropertyHelpTextArea	Sets the description of a property in the help text area at the bottom of the Property Inspector.
PropertyInfo
PropertyInspector
PropertyLabel
PropertyRadioButton	Represents a radio button in the Property Inspector UI that can participate in find text operations.
PropertySetCommand	The PropetySetCommand implements a property set, handling the undoing of the property set and sending out all relevant notifications.
SingletonPropertyEditorUpdater
UserSelectedCategories

Package oracle.ide.inspector Description

Contains interfaces and classes that integrators may use to make their objects editable from the property inspector.

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:

• An Inspectable implementation has been registered for the underlying data type.
• The underlying data is itself an instance of Inspectable.
• The underlying data is an instance of oracle.ide.model.SupportsInspection, in which case a DefaultInspectable will be used for its representation.

Likewise, as changes to the selected object are applied from either the InspectorWindow or from any other Editor (e.g. change background property from red to blue), the property value displayed in the InspectorWindow (e.g. background) is immediately updated to reflect those changes.

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:

1. InspectorWindow receives a ViewSelectionEvent describing a change of selection in the active View.
2. InspectorWindow fetches Context from the active View.
3. InspectorWindow asks InspectorFactory for a MultiInspectable for the Context received from the View.
4. InspectorFactory constructs a MultiInspectable with the Context.
5. MultiInspectable asks InspectorFactory for a single Inspectable capable of handling the entire selection of the Context.
6. InspectorFactory looks for a registered InspectableFactory capable of handling the Context. If found, returns to the MultiInspectable the Inspectable provided by the InspectableFactory. Otherwise, returns null.
7. Upon receiving an Inspectable for the entire selection back from the InspectorFactory, the MultiInspectable wraps the PropertyModel provided by that Inspectable into an IdePropertyModel. The MultiInspectable is now ready to be returned by the InspectorFactory to the calling InspectorWindow.
8. Otherwise, MultiInspectable iterates through the selection of the Context and asks the InspectorFactory for a separate Inspectable for each Element in the selection.
9. The InspectorFactory will call getData upon the given Element and look for a registered Inspectable for that type (e.g. if the result of Element.getData() was an instance of MyData it would determine whether MyData was itself an Inspectable or whether an Inspectable has been explicitly registered for MyData). If the data type is not itself an Inspectable and no Inspectable has been explicitly registered for the data type but the data type does implement SupportsInspection, then an instance of DefaultInspectable is returned.
10. Upon receiving any Inspectable for each of the selected objects back from the InspectorFactory, the MultiInspectable wraps each of their PropertyModel instances collectively into a single IdePropertyModel. The MultiInspectable is now ready to be returned by the InspectorFactory to the calling InspectorWindow.
11. Upon receiving the MultiInspectable from the InspectorFactory, the InspectorWindow will construct a PropertyInspector page initialized with the IdePropertyModel of the MultiInspectable to display the properties of the inspectable selection. If the MultiInspectable represents a single Inspectable instance, the InspectorWindow will also display any additional pages provided by that Inspectable's getAdditionalTabPages method. The same condition applies for the display of any Customizer.

If the default implementation of PropertyModel is not sufficient, integrators are encouraged to extend DefaultModel. The integrator would then have to implement an Inspectable (extending DefaultInspectable is encouraged) which returned an instance of that model.. That Inspectable would then have to be registered with the InspectorFactory for the applicable data type.

Related Documentation

See Extending JDeveloper Using the Addin API for detailed information.