Describes how to assign graphic objects to a manager.

The purpose of the manager is to manage a large set of graphic objects. Each graphic object can be managed by only one manager at a time, which means that you cannot add the same graphic object to two different managers.

The following methods allow you to add a graphic object to a manager.

The following example creates a rectangle object and adds it to a manager:

The second addObject method does not specify the layer where the object must be inserted. The reason for this is that there is a default insertion layer which allows you to add objects without specifying the layer at every call. The initial value for the default insertion layer is 0 but it can be modified using the following methods:

Once an object has been added to a manager, you can remove it with:

You can also remove the objects from the manager or from a specific layer using one of the following methods:

The following method can be used to know whether a graphic object is managed by the current manager:

You can access all the objects of the manager or of a specified layer using one of the following methods:

These methods return an IlvGraphicEnumeration object facilitating the enumeration of the contents of the manager (or layer). You may use it in the following manner:

Other useful methods will give you the number of objects in the manager or in a layer:

For every operation that leads to a modification of the bounding box of a graphic object, you must use the applyToObject method of the IlvManager class. As this method notifies the manager of the modification of the bounding box, you never directly call the moveObject and reshapeObject methods of IlvGraphic:

For these basic operations, the manager has methods that call applyToObject for you:

Example: Moving an object

The following code gets a reference to an object named test from the manager. If the object exists, it is moved to the point (10, 20) and redrawn (fourth parameter set to true ).

The moveObject method is equivalent to the following code:

This code calls the applyToObject method with object as a parameter and an anonymous class that implements the IlvApplyObject interface. The arg parameter is an IlvPoint object that gives the new location of the object.

The method applyToObject is defined in the IlvGraphicBag interface, so you may call applyToObject directly from a graphic object using:

Modifying multiple graphic objects

To apply an operation to many graphic objects repeatedly, call:

This applies the operation specified by the IlvApplyObject f to each graphic object contained in the input vector.

To apply complex operations that affect the bounding box of many graphic objects to many objects once only, call:

This applies the operation specified by the IlvApplyObjects f once only. This is useful for complex operations that affect the bounding box of many objects.

To apply a user-defined function to objects that are located either partly or wholly within a specific region, use the following IlvManager methods:

The IlvManager class contains the following methods, which allow you to control the editing and selecting properties of an object added to a manager:

These properties can be specified for graphic objects that are handled by an IlvSelectInteractor object. An IlvSelectInteractor object allows objects to be interactively selected in the manager, to be moved around, and to have their graphic properties edited.

A special manager feature minimizes the cost of drawing tasks to be done after geometric operations have been performed. This is useful in situations where you want to see the results of your work. This feature uses a region of invalidated parts of the display called the update region. The update region stores the appropriate regions before any modifications are carried out on objects, as well as those regions that are relevant after these modifications have been carried out for each view.

To successfully apply an applicable function, you must mark the regions where the objects are located as invalid, apply the function, and then invalidate the regions where the objects involved are now located (applying the function may change the location of the objects). This mechanism is greatly simplified by a set of methods of the IlvManager class. Regions to be updated are only refreshed when the method reDrawViews is called. This means that refreshing the views of a manager is done by marking regions to be redrawn in a cycle of initReDraws and reDrawViews.

These cycles can be nested so that only the last call to the method reDrawViews actually updates the display. The IlvManager methods that help you optimize drawing tasks are:

This mechanism is used in the applyToObject method.

In fact the call:

is equivalent to:

The invalidateRegion method works with the bounding box of the object given as a parameter. When an operation applied to the object modifies its bounding box, invalidateRegion must be called twice: once before and once after the operation. For example, for a move operation, you must invalidate the initial region where the object was before being moved and invalidate the final region so that the object can be redrawn. In other situations, such as changing the background, only the call after the operation is necessary.

When the content of the manager changes, the manager will fire a ManagerContentChangedEvent event. Any class can listen for the modification of the content of the manager by implementing the ManagerContentChangedListener interface.

This interface contains only the contentsChanged method.

This method is called when an object is added to or removed from the manager, or when the visibility, the bounding box, or the layer of a graphic object changes. A class that implements this interface will register itself by calling the addManagerContentChangedListener method of the manager.

A ManagerContentChangedEvent can be of several types depending on the type of modification in the manager. For each type, there is a corresponding subclass of the class ManagerContentChangedEvent. The type of the event can be retrieved with the getType method of the class. The list of these subclasses is indicated below along with the type of change in the manager that is responsible for it:

A listener will cast the event depending on the type:

As ManagerContentChangedEvent events can be sent very often (especially when numerous objects are being added as in the case of reading a file), the manager provides a way to notify the listeners that it is currently doing a series of modifications. In this case, the event will contain a flag telling the listener that the manager is currently performing several modifications. This flag can be tested using the isAdjusting method of the ManagerContentChangedEvent class. The manager will notify the listeners of the end of a series by sending a final ManagerContentsChangedEvent of type ADJUSTMENT_END.

Thus, a listener can decide to react to global modifications, but not to all individual modifications using the following code:

When making numerous modifications in a manager, you may want to be able to notify the listeners in the same way. To do so, you can use the setContentsAdjusting method of the manager in the following way:

All operations done between the two calls to setContentsAdjusting will fire a ManagerContentChangedEvent event with the isAdjusting flag set to true. A call to the setContentsAdjusting method with the parameter set to false can send the file ADJUSTMENT_END event.

This mechanism can also help the internal listeners of Rogue Wave JViews to work in a more efficient way, so you are recommended to use it.

Events related to imminent content changes

Since JViews 8.1, IlvManager fires events when a graphic object is about to change or about to be deleted. These events are fired before the graphic objects are changed or deleted. To listen for these events, you need to implement the following interface.

As this interface extends ManagerContentChangedListener, you can install a ManagerContentMonitor by calling addManagerContentChangedListener. IlvManager will call the method contentAboutToChange() that you have implemented when a graphic object is about to change or about to be deleted.