Inspecting an object boils down to examining its properties. In general, to inspect a property, an inspector panel uses the following pair of components: an accessor and an editor.

The accessor interfaces with the inspected property while the editor interfaces with a gadget that represents it graphically in the inspector panel (an IlvTextField, for example). In the context where an accessor is paired with an editor, the accessor is responsible for fetching the property value and displaying it via the editor. The editor for its part notifies the accessor whenever its content changes. In other words, inspecting a property means initializing the accessor when the inspector is initialized, and requesting the accessor to apply modifications made to the editor’s content. In this context, only a list of accessors is required to inspect an object.

Certain editors, however, do not need to be linked with accessors to work. For example, a combo box used to show or hide a set of gadgets does not need to access data to be initialized. Similarly, changing the selected item in the combo box does not affect the data. Because these stand-alone editors are not initialized by accessors, they must be initialized explicitly.

To handle both the pairs accessors/editors and stand-alone editors, an inspector panel makes use of a main editor defined by the class IlvStIMainEditor. Actually, inspection operations, including managing the Apply button present in each inspector panel, which are carried out by the inspector panel, are processed by the main editor.

The following figures illustrate respectively:

An inspector panel handles accessors of the class IlvStIAccessor, which is the base class of all the accessor classes. It performs two actions on accessors by calling the methods initialize and apply. Calling the first method initializes the calling accessors, while apply brings into effect the modifications made to the inspected object.

Most of the time, accessors are used to inspect object properties. In fact, if you take a look at the accessor class hierarchy illustrated below, you’ll see that IlvStIPropertyAccessor, a subclass of IlvStIAccessor, is the base class for all types of accessors in the library.

Property accessors manipulate properties via the class IlvStIProperty in which they are encapsulated. For example, to manipulate a property of the type IlvValue, an accessor uses an object of the type IlvStIValueProperty deriving from the class IlvStIProperty, in which the IlvValue object is encapsulated.

Accessors inspect properties using two different modes:

Since the initialize and apply methods of the property accessor utilize these parameters, you must not redefine them when subclassing IlvStIPropertyAccessor. Instead redefine the methods getOriginalValue and applyValue, which are invoked by initialize and apply, respectively.

The following example shows how to subclass IlvStIPropertyAccessor to access the label of a gadget item:

Certain inspected properties directly depend on other inspected properties. For example, the user should not be able to inspect the intermediate state of a toggle button if the intermediate mode was not set for it. In other words, the accessor to the “intermediate state” property should always be aware of the value set for the accessor to the “intermediate mode” property, and its associated editor should appear gray or not depending on that value. This means that if the accessor to the “intermediate mode” property is initialized or is modified, the accessor to the “intermediate state” must be reinitialized accordingly. For this initialization precedence order to be achieved, the accessor to the “intermediate state” property should be made dependent on the accessor to the “intermediate mode” property using the method addDependentAccessor.

This dependency mechanism is also used by combined accessors, which are described in the next section.

A combined accessor is an instance of the class IlvStICombinedAccessor, a subclass of IlvStIPropertyAccessor, which is used to inspect the property of an object that is returned by another accessor. For example, let us consider a name accessor used to inspect the name of a gadget item. By combining this accessor with a gadget item accessor, you can use it to inspect both an element selected in a gadget item list or a gadget item in a message label. Combined accessors are usually implemented as dependent accessors since they must be reinitialized whenever the property they access through another accessor is itself reinitialized. In our example, changing the current selection in a gadget item list would cause the name accessor to be reinitialized.

The example given in the section Accessors has been rewritten below to illustrate combined accessors. It shows how to subclass IlvStICombinedAccessor to access the label of a gadget item:

A list accessor is an instance of the class IlvStIPropertyListAccessor, which derives from IlvStICombinedAccessor. A list accessor is used to inspect a list of properties. It allows you to add, remove, or modify a property in a list. This type of accessor works in conjunction with instances of the class IlvStIPropertyListEditor. Editors of this kind handle gadgets that are used to edit lists, that is, list gadgets, and the following four buttons: Add After, Add Before, Remove, and Clean.

The following code sample shows how to access a list of gadget items that are contained in a gadget item holder:

A tree accessor is an instance of the class IlvStIPropertyTreeAccessor, which derives from IlvStICombinedAccessor. A tree accessor is used to inspect a tree of properties. It allows you to add, remove, or modify a property in a tree. This type of accessors works in conjunction with instances of the class IlvStIPropertyTreeEditor. Editors of this kind handle gadgets that are used to edit trees, that is, tree gadgets, and the following five buttons: Add After, Add Before, Add Child, Remove, and Clean.

The following code sample shows how to access a tree of gadget items that are contained in a tree gadget: