public class TLcdGXYLayer extends TLcdLayer implements ILcdGXYEditableLabelsLayer
ILcdGXYEditableLabelsLayer
interface.
The minimal setup of a TLcdGXYLayer
comprises setting a
model and a
painter provider.
It is also recommended to set an appropriate pen. It may be convenient to use
asFactory(Predicate, Consumer)
or create(ILcdModel)
to assist with this.
ILcdGXYLayer
, the geometry representations for objects are determined
by painters. The used ILcdGXYPainter
for each object is determined by a
painter provider.
ILcdGXYEditor
for each object is determined by an
editor provider. Similarly, label editors are retrieved from
a label editor provider.
getBounds
and when iterating over the objects
using the applyOnInteract*
methods.
applyOnInteract*
methods defined in ILcdGXYEditableLabelsLayer
.
minimum object size
can be set to improve the painting speed of large models. The setting is used
when painting, in the selection, and when iterating over the objects
using the applyOnInteract*
methods.
applyOnInteract*
methods.
label scale ratio interval
can be used to avoid
displaying out-of-date labels, when label positions are calculated asynchronously. The setting is
used when painting.
setSelectionLabeled(boolean)
determines if labels are shown for the selected objects, in case
the layer itself is not labeledsetModelElementComparator(java.util.Comparator)
determines the order in which object
elements are handled by this layer. It will influence the paint order, as well as the
applyOnInteract() methods behavior.PLACED_LABELS
Constructor and Description |
---|
TLcdGXYLayer()
Constructs an empty layer.
|
TLcdGXYLayer(ILcdModel aModel)
Constructs an empty layer with the given model.
|
TLcdGXYLayer(ILcdModel aModel,
String aLabel)
Constructs a layer with the given label and model.
|
TLcdGXYLayer(ILcdModel aModel,
String aLabel,
ILcdGXYPen aGXYPen)
Constructs a layer with the given label, model and pen.
|
TLcdGXYLayer(String aLabel)
Constructs an empty layer with the given label.
|
TLcdGXYLayer(String aLabel,
ILcdGXYPen aGXYPen)
Constructs an empty layer with the given label and pen.
|
Modifier and Type | Method and Description |
---|---|
int |
applyOnInteract(ILcdFunction aFunction,
Graphics aGraphics,
int aPaintMode,
ILcdGXYView aGXYView)
Applies the function to (at the least) all objects that are contained (partially or completely) in
the bounds of the view.
|
protected int |
applyOnInteract(ILcdFunction aFunction,
Graphics aGraphics,
int aPaintMode,
ILcdModel aModel,
ILcdGXYView aGXYView)
Applies the function to (at the least) all objects from the given model that are contained
(partially or completely) in the bounds of the view.
|
int |
applyOnInteract(ILcdFunction aFunction,
Rectangle aBounds,
boolean aStrictInteract,
ILcdGXYView aGXYView)
Applies the function to (at the least) all objects that are contained (partially or completely) in the bounds of the view.
|
int |
applyOnInteractLabels(ILcdFunction aLabelFunction,
Graphics aGraphics,
int aPaintMode,
ILcdGXYView aGXYView)
Applies the function to (at the least) all labels that are contained (partially or completely)
in the bounds of the view.
|
static ILcdGXYLayerFactory |
asFactory(Predicate<ILcdModel> aAcceptableModel,
Consumer<TLcdGXYLayer> aPostConstructCustomization)
Creates a layer factory that creates
TLcdGXYLayer instances that are already partially initialized:
The model is set.
It derives a sensible layer name based on the
model descriptor.
It provides a pen with sensible default settings.
It sets up a suitable painter if the model's metadata
only contains shape or raster data.
It offers a hook for further customization, such as setting a painter with custom styling. |
static TLcdGXYLayer |
create(ILcdModel aModel)
Creates a layer that is already partially initialized:
The model is set.
It derives a sensible layer name based on the
model descriptor.
It provides a pen with sensible default settings, generally more accurate than what
TLcdGXYLayer(com.luciad.model.ILcdModel) would.
It sets up a suitable painter if the model's metadata
only contains shape or raster data.
It returns a TLcdGXYLayerTreeNode (without any children) if the model implements ILcdModelTreeNode .
The layer can be further customized after it is created, for example by setting a painter: |
ILcdBounds |
getBounds(int aMode,
ILcdGXYView aGXYView)
Returns the view bounds of this
ILcdGXYLayer content,
the bounds of all the drawings (for the supplied mode) that represent the Objects contained in
the ILcdModel of this ILcdGXYLayer . |
ILcdGXYEditor |
getGXYEditor(Object aObject)
Returns the editor to use to modify the object via a view.
|
ILcdGXYEditorProvider |
getGXYEditorProvider()
Gets the current
ILcdGXYEditorProvider attached to this TLcdGXYLayer . |
ILcdGXYLabelEditor |
getGXYLabelEditor(Object aObject)
Retrieves the label editor for the given object.
|
ILcdGXYLabelEditorProvider |
getGXYLabelEditorProvider()
Gets the current
ILcdGXYLabelEditorProvider attached to this TLcdGXYLayer . |
ILcdGXYLabelingAlgorithm |
getGXYLabelingAlgorithm(TLcdLabelIdentifier aLabel)
Returns the label algorithm to use for the given label ID.
|
ILcdGXYLabelLabelingAlgorithmProvider |
getGXYLabelingAlgorithmProvider()
Returns the current labeling algorithm provider responsible for determining the position of the labels.
|
ILcdGXYLabelPainter |
getGXYLabelPainter(Object aObject)
Returns the label painter to use to paint the objects label in a view.
|
ILcdGXYLabelPainterProvider |
getGXYLabelPainterProvider()
Gets the current
ILcdGXYLabelPainterProvider attached to this TLcdGXYLayer . |
ILcdGXYLayerLabelPainter |
getGXYLayerLabelPainter() |
ILcdGXYPainter |
getGXYPainter(Object aObject)
Returns the painter to use to render the object in a view.
|
ILcdGXYPainterProvider |
getGXYPainterProvider()
Returns the current
ILcdGXYPainterProvider attached to this TLcdGXYLayer . |
ILcdGXYPainterProvider[] |
getGXYPainterProviderArray()
Returns an array containing all painter providers for this layer
|
Enumeration |
getGXYPainters(Object aObject)
Returns all the painters for this object.
|
ILcdGXYPen |
getGXYPen()
Returns the pen to use when performing basic painting operations for objects in this layers model.
|
ILcdIcon |
getIcon()
Returns a visual indication of the contents of this layer.
|
int |
getInteractMargin()
Returns the largest possible difference (in pixels) between an object's model bounds and its
representation.
|
ALcdLabelLocations |
getLabelLocations()
Returns the
ALcdLabelLocations instance which contains all the information
about the labels of this layer. |
TLcdDimensionInterval<TLcdMapScale> |
getLabelMapScaleRange()
Returns the map ratio scale range for which to display labels for elements of the model.
|
ILcdInterval |
getLabelScaleRange()
Returns the toolkit scale range for which to display labels for elements of the model.
|
TLcdDimensionInterval<TLcdMapScale> |
getMapScaleRange()
Returns the map ratio scale range for which to display elements of the model.
|
double |
getMinimumObjectSizeForPainting()
Returns the minimum size of an object in the view for it to be painted and handled otherwise.
|
Comparator |
getModelElementComparator()
Returns the comparator that defines an order between object elements.
|
TLcdModelQueryConfiguration |
getModelQueryConfiguration()
Returns the model query configuration which is used by this layer to retrieve the filters to query the model with during
a paint operation.
|
Class |
getModelXYWorldTransfoClass()
Returns the transformation class that to use to transform points and bounds from model space to world space and
back.
|
ILcdInterval |
getPaintLabelsScaleRatioInterval()
Returns the scale ratio interval in which the placed labels are painted.
|
ILcdInterval |
getScaleRange()
Returns the toolkit scale range for which to display elements of the model.
|
boolean |
isEditableSupported()
Returns
true if the layer supports editing its objects. |
boolean |
isLabeled()
Returns whether objects should be represented as text.
|
boolean |
isLabeledSupported()
Returns whether this layer supports representing objects as text.
|
boolean |
isLabelsEditable()
This flag determines if the labels are editable, i.e. if they can be moved by the user.
|
boolean |
isLabelsEditableSupported()
This property determines whether the layer is equipped to let the user edit the labels.
|
boolean |
isPaintFromOverlaps() |
boolean |
isSelectionLabeled()
Returns whether selected objects are labeled when
isLabeled() returns false. |
protected boolean |
isStopPainting()
Returns whether painting of the layer should be stopped.
|
boolean |
isTraceOn()
Deprecated.
This method has been deprecated. It is recommended to use the
standard Java logging framework directly.
|
static String |
modeToString(int aMode)
Utility method that provides a human readable form of the layer mode.
|
void |
paint(Graphics aGraphics,
int aMode,
ILcdGXYView aGXYView)
Paints the combined representation of the layer's objects for a view, taking into account the mode.
|
protected void |
paintFromModel(Graphics aGraphics,
int aMode,
ILcdModel aModel,
ILcdGXYContext aGXYContext)
Paints the objects in the passed model by iterating over all the model's objects,
in the order determined by the model.
|
protected void |
paintFromOverlaps(Graphics aGraphics,
int aMode,
ILcd2DBoundsIndexedModel a2DBoundsIndexedModel,
ILcdGXYContext aGXYContext)
Paints the objects in the passed model by applying a painting function
to all
Object of the ILcd2DBoundsIndexedModel that interact
with the view clip. |
static void |
setClassTraceOn(boolean aClassTraceOn)
Deprecated.
This method has been deprecated. It is recommended to use the
standard Java logging framework directly.
|
void |
setFilter(ILcdFilter aFilter)
Sets the
ILcdFilter to filter the Object on this
ILcdLayer . |
void |
setGXYEditorProvider(ILcdGXYEditorProvider aGXYEditorProvider)
Sets an
ILcdGXYEditorProvider to this TLcdGXYLayer . |
void |
setGXYLabelEditorProvider(ILcdGXYLabelEditorProvider aGXYLabelEditorProvider)
Sets an
ILcdGXYLabelEditorProvider to this TLcdGXYLayer . |
void |
setGXYLabelingAlgorithmProvider(ILcdGXYLabelLabelingAlgorithmProvider aGXYLabelingAlgorithmProvider)
Configures the given labeling algorithm provider responsible for determining the position of the labels.
|
void |
setGXYLabelPainterProvider(ILcdGXYLabelPainterProvider aGXYLabelPainterProvider)
Sets an
ILcdGXYLabelPainterProvider to this TLcdGXYLayer . |
void |
setGXYLayerLabelPainter(ILcdGXYLayerLabelPainter aGXYLayerLabelPainter)
Deprecated.
label algorithm providers offer more flexibility for labeling
|
void |
setGXYPainterProvider(ILcdGXYPainterProvider aGXYPainterProvider)
Sets an
ILcdGXYPainterProvider to this TLcdGXYLayer . |
void |
setGXYPainterProviderArray(ILcdGXYPainterProvider[] aGXYPainterProviderArray)
Like,
setGXYPainterProvider(com.luciad.view.gxy.ILcdGXYPainterProvider) , but sets an array of ILcdGXYPainterProvider
to this TLcdGXYLayer . |
void |
setGXYPen(ILcdGXYPen aGXYPen)
Sets the pen to use to perform basic rendering operations.
|
void |
setIcon(ILcdIcon aIcon)
Sets a visual indication of the contents of this layer.
|
void |
setInteractMargin(int aInteractMargin)
Sets the largest possible difference (in pixels) between an object's model bounds and its
representation.
|
void |
setLabeled(boolean aLabeled)
Sets whether objects should be represented as text.
|
void |
setLabelLocations(ALcdLabelLocations aLabelLocations)
Sets the
ALcdLabelLocations used by this layer to store the locations of all labels, and which
labels are painted. |
void |
setLabelMapScaleRange(TLcdDimensionInterval<TLcdMapScale> aLabelMapScaleRange)
Sets the map scale range for which to paint labels for the elements of the model.
|
void |
setLabelScaleRange(ILcdInterval aNewLabelScaleRange)
Sets the scale range in which this
ILcdGXYLayer will paint
the labels of its elements if they have to be drawn at all. |
void |
setLabelsEditable(boolean aLabelsEditable)
This flag determines if the labels are editable, i.e. if they can be moved by the user.
|
void |
setMapScaleRange(TLcdDimensionInterval<TLcdMapScale> aMapScaleRange)
Sets the map scale range for which to paint the elements of the model.
|
void |
setMinimumObjectSizeForPainting(double aMinimumObjectSizeForPainting)
Sets the minimum size of an object in the view for it to be painted and handled otherwise.
|
void |
setModel(ILcdModel aModel)
Sets the
ILcdModel to this ILcdLayer . |
void |
setModelElementComparator(Comparator<Object> aObjectElementComparator)
Sets a comparator on this layer that defines an order between object elements.
|
void |
setModelQueryConfiguration(TLcdModelQueryConfiguration aModelQueryConfiguration)
Sets the model query configuration which defines the filters to query the model with during
a paint operation.
|
void |
setModelXYWorldTransfoClass(Class aModelXYWorldTransfoClass)
Sets the transformation class that should be used to transform coordinates of objects
in the model to XY world coordinates of the view this layer will be part of.
|
void |
setPaintFromOverlaps(boolean aNewPaintFromOverlaps)
Sets whether the
paint method should try to paint all objects (paintFromModel) or only the objects that
are visible in the context passed to the paint method (paintFromOverlaps), by taking advantage of
the ILcd2DBoundsIndexedModel interface. |
void |
setPaintLabelsScaleRatioInterval(ILcdInterval aInterval)
Sets the scale ratio interval in which the placed labels are painted when
paint(java.awt.Graphics, int, ILcdGXYView) is called with the
ILcdGXYEditableLabelsLayer.PLACED_LABELS flag. |
void |
setScaleRange(ILcdInterval aNewScaleRange)
Sets the scale range in which this
ILcdGXYLayer will paint its elements. |
void |
setSelectionLabeled(boolean aNewSelectionLabeled)
Sets whether selected objects are labeled when
isLabeled() returns false. |
void |
setTraceOn(boolean aTraceOn)
Deprecated.
This method has been deprecated. It is recommended to use the
standard Java logging framework directly.
|
void |
setVisible(boolean aVisible)
Sets whether or not the layer's content is painted.
|
protected void |
startPainting()
Indicates that rendering should no longer be stopped.
|
void |
stopPainting()
Inform the layer that it should terminate the current paint operation.
|
addPropertyChangeListener, addSelectionListener, clearSelection, fireCollectedSelectionChanges, firePropertyChangeEvent, getFilter, getLabel, getModel, getSelectionCount, invalidate, isEditable, isSelectable, isSelectableSupported, isSelected, isVisible, removePropertyChangeListener, removeSelectionListener, selectedObjects, selectObject, selectObjects, setEditable, setLabel, setSelectable, setSelectableSupported, toString
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
clearSelection, fireCollectedSelectionChanges, getLabel, getModel, isEditable, isSelectable, isSelectableSupported, isVisible, selectObject, setEditable, setLabel, setSelectable
addSelectionListener, getSelectedObjects, getSelectionCount, isSelected, removeSelectionListener, selectedObjects
addPropertyChangeListener, removePropertyChangeListener
public TLcdGXYLayer()
create(ILcdModel)
.public TLcdGXYLayer(ILcdModel aModel)
create(ILcdModel)
, which in addition sets a sensible default pen.aModel
- the model to visualize. Never null.public TLcdGXYLayer(String aLabel)
create(ILcdModel)
.aLabel
- a textual representation of this layer.public TLcdGXYLayer(ILcdModel aModel, String aLabel)
create(ILcdModel)
.aModel
- contains the objects that should be rendered in this layer.aLabel
- a textual representation of this layer.public TLcdGXYLayer(String aLabel, ILcdGXYPen aGXYPen)
create(ILcdModel)
.aLabel
- a textual representation of this layer.aGXYPen
- the pen to use to render basic geometries (lines, points, arcs).public TLcdGXYLayer(ILcdModel aModel, String aLabel, ILcdGXYPen aGXYPen)
create(ILcdModel)
.aLabel
- a textual representation of this layer.aModel
- contains the objects that should be rendered in this layer.aGXYPen
- the pen to use to render basic geometries (lines, points, arcs).public static ILcdGXYLayerFactory asFactory(Predicate<ILcdModel> aAcceptableModel, Consumer<TLcdGXYLayer> aPostConstructCustomization)
TLcdGXYLayer
instances that are already partially initialized:
null
if aAcceptableModel returns false
.aAcceptableModel
- Returns true
if a layer should be created for this model, false
if
null
should be returned. The ILcdModel
to test is never null
.aPostConstructCustomization
- Callback to do further customization. For example
layer -> layer.setGXYPainterProvider(myPainter)
public static TLcdGXYLayer create(ILcdModel aModel)
TLcdGXYLayer(com.luciad.model.ILcdModel)
would.TLcdGXYLayerTreeNode
(without any children) if the model implements ILcdModelTreeNode
.
TLcdGXYLayer layer = TLcdGXYLayer.create(aModel);
layer.setGXYPainterProvider(myPainter);
See also TLcdGXYShapePainter
for styling options, or
TLcdGXYImagePainter
if your model contains imagery.public static void setClassTraceOn(boolean aClassTraceOn)
true
then all log messages are recorded, otherwise only
the informative, warning and error messages are recorded.aClassTraceOn
- if true then all log messages are recorded,
otherwise only the informative, warning and error messages are recorded.public void setTraceOn(boolean aTraceOn)
true
or false
as argument automatically turns
off tracing for all other class instances for which
setTraceOn
has not been called.
If the argument is false
then only the informative, warning
and error log messages are recorded.setTraceOn
in class TLcdLayer
aTraceOn
- if true then all log messages are recorded for this
instance. If false, then only the informative, warning and
error log messages are recorded.public boolean isTraceOn()
true
if tracing is enabled for this class.public void setModel(ILcdModel aModel)
TLcdLayer
ILcdModel
to this ILcdLayer
.public void setModelXYWorldTransfoClass(Class aModelXYWorldTransfoClass)
Sets the transformation class that should be used to transform coordinates of objects
in the model to XY world coordinates of the view this layer will be part of. The default class
is TLcdDefaultModelXYWorldTransformation
, which covers the built-in LuciadLightspeed transformations.
This layer will create instances of this Class using Class#newInstance().
aModelXYWorldTransfoClass
- the transformation class should be consistent with the
model reference of the model of the layer and the XY world reference of the view this layer will be part of.
The class passed should implement the interface ILcdModelXYWorldTransformation
.getModelXYWorldTransfoClass()
public Class getModelXYWorldTransfoClass()
getModelXYWorldTransfoClass
in interface ILcdGXYLayer
setModelXYWorldTransfoClass(Class)
public ILcdGXYPen getGXYPen()
getGXYPen
in interface ILcdGXYLayer
setGXYPen(ILcdGXYPen)
public void setGXYPen(ILcdGXYPen aGXYPen)
TLcdGXYPen
.aGXYPen
- the pen to use to perform basic rendering.getGXYPen()
public ALcdLabelLocations getLabelLocations()
Returns the ALcdLabelLocations
instance which contains all the information
about the labels of this layer. You can use this instance to retrieve which labels have been drawn
and where these labels are located
.
This instance can also be used to alter
the
location of the labels. As this method always returns the same instance, changes made to the
returned ALcdLabelLocations
instance immediately effect all other clients of this
layer.
If the location of a label is changed, the layer should be invalidated using the
invalidateGXYLayer
method of
the ILcdGXYView
.
getLabelLocations
in interface ILcdGXYEditableLabelsLayer
ALcdLabelLocations
instance. It never is null
.setLabelLocations(com.luciad.view.ALcdLabelLocations)
public void setLabelLocations(ALcdLabelLocations aLabelLocations)
ALcdLabelLocations
used by this layer to store the locations of all labels, and which
labels are painted.aLabelLocations
- The ALcdLabelLocations
.getLabelLocations()
public double getMinimumObjectSizeForPainting()
setMinimumObjectSizeForPainting(double)
public void setMinimumObjectSizeForPainting(double aMinimumObjectSizeForPainting)
applyOnInteract
(which is for example used during selection).
A value of 0 will always paint all objects, no matter how small they appear.
Larger values can discard more objects. This typically improves the painting
speed, although it might leave undesirable gaps in models containing many
small objects. The default value is 1 pixel.aMinimumObjectSizeForPainting
- The minimal size, expressed in pixels.getMinimumObjectSizeForPainting()
public int getInteractMargin()
setPaintFromOverlaps(boolean)
is true).setInteractMargin(int)
public void setInteractMargin(int aInteractMargin)
setPaintFromOverlaps(boolean)
is true).
It ensures, for example, that a model element is still painted if its visual representation
falls inside the view, but its model bounds do not.
If for example icons are used to represent points on the
map, the icon could be 16 by 16 pixels, whereas the object itself is a
point, having a zero size. Depending on where the point is located in the icon, the required
interact margin for this example can be up to 16 pixels.
The drawback of setting a too large value is a performance loss. The
drawback of setting a too small value is that objects (e.g. icons) disappear when they are
located partly outside the view.
The default value is 32.aInteractMargin
- the margin (in pixels) to take into account when interacting with the
modelgetInteractMargin()
public void setGXYLayerLabelPainter(ILcdGXYLayerLabelPainter aGXYLayerLabelPainter)
ILcdGXYLayer.LABELS
, and only the labels marked in the
label locations when used with painting mode ILcdGXYEditableLabelsLayer.PLACED_LABELS
.aGXYLayerLabelPainter
- a layer label painter to declutter labels.getGXYLayerLabelPainter()
public ILcdGXYLayerLabelPainter getGXYLayerLabelPainter()
setGXYLayerLabelPainter(ILcdGXYLayerLabelPainter)
public ILcdGXYLabelingAlgorithm getGXYLabelingAlgorithm(TLcdLabelIdentifier aLabel)
label algorithm provider
.getGXYLabelingAlgorithm
in interface ILcdGXYEditableLabelsLayer
aLabel
- the identifier defining the label and its associated domain objectnull
.public void setLabeled(boolean aLabeled)
ILcdGXYLayer.isLabeledSupported()
returns false.
Objects for which the GXYLabelPainterProvider does
not return a ILcdGXYLabelPainter
or which do not pass the filter
will not have their labels rendered.setLabeled
in interface ILcdGXYLayer
aLabeled
- true to have a textual representation of the objects in the model, false to have no such
representation.setGXYLabelPainterProvider(ILcdGXYLabelPainterProvider)
public boolean isLabeled()
ILcdGXYLayer.isLabeledSupported()
returns false.isLabeled
in interface ILcdGXYLayer
setLabeled(boolean)
public boolean isLabeledSupported()
isLabeledSupported
in interface ILcdGXYLayer
true
if getGXYLabelPainterProvider()
returns a non null
value,
false
otherwise.setGXYLabelPainterProvider(ILcdGXYLabelPainterProvider)
public void setLabelsEditable(boolean aLabelsEditable)
ILcdGXYLabelEditor
or which do not pass the filter will not have their labels edited.setLabelsEditable
in interface ILcdGXYEditableLabelsLayer
aLabelsEditable
- true to allow editing labels for all objects in the model for which the ILcdGXYLabelEditorProvider
returns a ILcdGXYLabelEditor
. False to not have labels editable for any object in the model.setGXYLabelEditorProvider(ILcdGXYLabelEditorProvider)
,
isLabelsEditable()
public boolean isLabelsEditable()
isLabelsEditable
in interface ILcdGXYEditableLabelsLayer
true
if the labels can be moved and reshaped by the user,
false
otherwise.setLabeled(boolean)
,
setLabelsEditable(boolean)
public boolean isLabelsEditableSupported()
ILcdGXYLabelEditor
for its objects.
This layer supports editing labels when the ILcdGXYLabelEditorProvider is set to a non null value.isLabelsEditableSupported
in interface ILcdGXYEditableLabelsLayer
true
if getGXYLabelEditorProvider()
returns a non null
value,
false
otherwise.setGXYLabelEditorProvider(ILcdGXYLabelEditorProvider)
public boolean isEditableSupported()
true
if the layer supports editing its objects.
This implementation always returns true. Override this method if editing behavior is restricted.
This layer supports editing when the GXYEditorProvider to this layer is set to a non null value.isEditableSupported
in interface ILcdLayer
isEditableSupported
in class TLcdLayer
true
if getGXYEditorProvider()
returns a non null
value,
false
otherwise.setGXYEditorProvider(ILcdGXYEditorProvider)
public void setGXYPainterProvider(ILcdGXYPainterProvider aGXYPainterProvider)
ILcdGXYPainterProvider
to this TLcdGXYLayer
.
During painting, the provider will be queried to return a painter for the relevant domain
objects. If no painter provider is set to this layer, nothing will be rendered.
This call overwrites the painter provider array with a new one containing the given provider.
Note that no property change listeners can be added to the painter provider, so the layer is not automatically
notified when a property on the painter provider has changed. To notify the layer and its listeners, a property
change event has to be fired, using the method TLcdLayer.firePropertyChangeEvent(java.beans.PropertyChangeEvent)
.
aGXYPainterProvider
- the new painter providersetGXYPainterProviderArray(com.luciad.view.gxy.ILcdGXYPainterProvider[])
,
getGXYPainterProvider()
public void setGXYPainterProviderArray(ILcdGXYPainterProvider[] aGXYPainterProviderArray)
setGXYPainterProvider(com.luciad.view.gxy.ILcdGXYPainterProvider)
, but sets an array of ILcdGXYPainterProvider
to this TLcdGXYLayer
. Painting is done for each of the providers (in the order of
the array), each time for the whole set of elements.
This can be useful to perform multiple painting passes.aGXYPainterProviderArray
- a sequence of painter providersgetGXYPainterProviderArray()
,
setGXYPainterProvider(com.luciad.view.gxy.ILcdGXYPainterProvider)
public ILcdGXYPainterProvider getGXYPainterProvider()
ILcdGXYPainterProvider
attached to this TLcdGXYLayer
.setGXYPainterProvider(ILcdGXYPainterProvider)
public ILcdGXYPainterProvider[] getGXYPainterProviderArray()
setGXYPainterProviderArray(ILcdGXYPainterProvider[])
public void setGXYEditorProvider(ILcdGXYEditorProvider aGXYEditorProvider)
ILcdGXYEditorProvider
to this TLcdGXYLayer
.
This allows an eternal entity (for example, an ILcdGXYController
to edit
the domain objects of this layer by retrieving an editor for it.
Editing of objects in the model through the layer is only possible for objects for which the editor provider
returns an ILcdGXYEditor
. By default the editor provider is null and no editing is possible.
Note that no property change listeners can be added to the editor provider, so the layer is not automatically
notified when a property on the editor provider has changed. To notify the layer and its listeners, a property
change event has to be fired, using the method TLcdLayer.firePropertyChangeEvent(java.beans.PropertyChangeEvent)
.
aGXYEditorProvider
- the new editor providergetGXYEditorProvider()
,
TLcdLayer.isEditable()
,
isEditableSupported()
public ILcdGXYEditorProvider getGXYEditorProvider()
ILcdGXYEditorProvider
attached to this TLcdGXYLayer
.setGXYEditorProvider(com.luciad.view.gxy.ILcdGXYEditorProvider)
public ILcdGXYPainter getGXYPainter(Object aObject)
ILcdGXYLayer
setObject
in ILcdGXYPainter.getGXYPainter
in interface ILcdGXYLayer
aObject
- the object to return a painter for.getGXYPainterProvider.getGXYPainter(aObject)
for the first provider that returns a non-null one,
null
otherwise. The returned painter is properly initialized
to the given aObject
.setGXYPainterProvider(ILcdGXYPainterProvider)
,
setGXYPainterProvider(com.luciad.view.gxy.ILcdGXYPainterProvider)
public Enumeration getGXYPainters(Object aObject)
aObject
- the object to retrieve painters forsetGXYPainterProviderArray(com.luciad.view.gxy.ILcdGXYPainterProvider[])
public ILcdGXYEditor getGXYEditor(Object aObject)
ILcdGXYLayer
setObject
in ILcdGXYEditor.getGXYEditor
in interface ILcdGXYLayer
aObject
- the object to find an editor for.getGXYEditorProvider.getGXYEditor(aObject)
if getGXYEditorProvider
returns a non null value, null
otherwise.setGXYEditorProvider(com.luciad.view.gxy.ILcdGXYEditorProvider)
public void setGXYLabelPainterProvider(ILcdGXYLabelPainterProvider aGXYLabelPainterProvider)
ILcdGXYLabelPainterProvider
to this TLcdGXYLayer
.
During painting, the provider will be queried to return a label painter for the relevant domain
objects. If no label painter provider is set to this layer, no labels will be rendered.
Note that no property change listeners can be added to the label painter provider, so the layer is not automatically
notified when a property on the label painter provider has changed. To notify the layer and its listeners, a property
change event has to be fired, using the method TLcdLayer.firePropertyChangeEvent(java.beans.PropertyChangeEvent)
.
aGXYLabelPainterProvider
- the new label painter providergetGXYLabelPainterProvider()
public ILcdGXYLabelPainterProvider getGXYLabelPainterProvider()
ILcdGXYLabelPainterProvider
attached to this TLcdGXYLayer
.setGXYLabelPainterProvider(ILcdGXYLabelPainterProvider)
public ILcdGXYLabelPainter getGXYLabelPainter(Object aObject)
ILcdGXYLayer
setObject
in ILcdGXYLabelPainter.getGXYLabelPainter
in interface ILcdGXYLayer
aObject
- the object to find a label painter for.getGXYLabelPainterProvider.getGXYLabelPainter(aObject)
if getGXYLabelPainterProvider
returns a non null value, null
otherwise. The returned painter is properly initialized
to the given aObject
.setGXYLabelPainterProvider(com.luciad.view.gxy.ILcdGXYLabelPainterProvider)
public void setGXYLabelEditorProvider(ILcdGXYLabelEditorProvider aGXYLabelEditorProvider)
ILcdGXYLabelEditorProvider
to this TLcdGXYLayer
.
This allows an eternal entity (for example, an ILcdGXYController
to edit
the labels of domain objects of this layer by retrieving a
label editor for it.
If no label editor provider is set, no labels can be edited for any object in the model.
The default value is null.
Note that no property change listeners can be added to the label editor provider, so the layer is not automatically
notified when a property on the label editor provider has changed. To notify the layer and its listeners, a property
change event has to be fired, using the method TLcdLayer.firePropertyChangeEvent(java.beans.PropertyChangeEvent)
.
aGXYLabelEditorProvider
- the new label editor providergetGXYLabelEditorProvider()
public ILcdGXYLabelLabelingAlgorithmProvider getGXYLabelingAlgorithmProvider()
setGXYLabelingAlgorithmProvider(com.luciad.view.gxy.labeling.algorithm.ILcdGXYLabelLabelingAlgorithmProvider)
public void setGXYLabelingAlgorithmProvider(ILcdGXYLabelLabelingAlgorithmProvider aGXYLabelingAlgorithmProvider)
Note that no property change listeners can be added to the label algorithm provider, so the layer is not automatically notified when a property on the label algorithm provider has changed. To notify the layer and its listeners, fire a property change event.
aGXYLabelingAlgorithmProvider
- the new label algorithm providergetGXYLabelingAlgorithmProvider()
public ILcdGXYLabelEditorProvider getGXYLabelEditorProvider()
ILcdGXYLabelEditorProvider
attached to this TLcdGXYLayer
.setGXYLabelEditorProvider(ILcdGXYLabelEditorProvider)
public ILcdGXYLabelEditor getGXYLabelEditor(Object aObject)
ILcdGXYEditableLabelsLayer
aObject
to a different location.getGXYLabelEditor
in interface ILcdGXYEditableLabelsLayer
aObject
- The object for which to retrieve the label editor. This object should not be
null
and should be contained in the model of this layer.getGXYLabelEditorProvider.getGXYLabelEditor(aObject)
if getGXYLabelEditorProvider
returns a non null value, null
otherwise. The returned painter is properly initialized
to the given aObject
.setGXYLabelEditorProvider(com.luciad.view.gxy.ILcdGXYLabelEditorProvider)
public ILcdIcon getIcon()
ILcdLayer
public void setIcon(ILcdIcon aIcon)
ILcdLayer
setIcon
in interface ILcdLayer
setIcon
in class TLcdLayer
aIcon
- a visual indication of the contents of this layer.ILcdLayer.getIcon()
public void setPaintFromOverlaps(boolean aNewPaintFromOverlaps)
paint
method should try to paint all objects (paintFromModel) or only the objects that
are visible in the context passed to the paint method (paintFromOverlaps), by taking advantage of
the ILcd2DBoundsIndexedModel
interface.aNewPaintFromOverlaps
- if true
, the paint method uses paintFromOverlaps()
for models implementing ILcd2DBoundsIndexedModel
. If false
, it uses paintFromModel
.paintFromModel(java.awt.Graphics, int, com.luciad.model.ILcdModel, com.luciad.view.gxy.ILcdGXYContext)
,
paintFromOverlaps(java.awt.Graphics, int, com.luciad.model.ILcd2DBoundsIndexedModel, com.luciad.view.gxy.ILcdGXYContext)
public boolean isPaintFromOverlaps()
true
, if the paint method uses paintFromOverlaps()
for models
implementing ILcd2DBoundsIndexedModel
, false
if it uses
paintFromModel.setPaintFromOverlaps(boolean)
,
setPaintFromOverlaps(boolean)
public void setModelElementComparator(Comparator<Object> aObjectElementComparator)
Comparator.compare(Object,Object)
method will be called using object
elements. The given comparator will influence the order in which the applyOnInteract
methods will apply a function on the object elements. This will also influence the
paint order.
For example, when the given comparator defines that object1 < object2, applyOnInteract() will apply its function first on object1, and only then on object2. Furthermore, object2 will be painted after object1, so it is painted on top.
When the given comparator is null
, the order in which applyOnInteract() applies
its function on the object elements will be undefined.
aObjectElementComparator
- a comparator that defines an order between object elementsgetModelElementComparator()
public Comparator getModelElementComparator()
setModelElementComparator(java.util.Comparator)
public void setScaleRange(ILcdInterval aNewScaleRange)
ILcdGXYLayer
will paint its elements.
The paint method of an ILcdGXYLayer
shall not perform any action when:aGXYContext.getGXYView().getScale() < getScaleRange().getMin()
aGXYContext.getGXYView().getScale() > getScaleRange().getMax()
unitless map scale range
instead.aNewScaleRange
- the new scale range, in toolkit pixels/world unit.
The minimum (smallest) value is the most zoomed out, the maximum (largest) value is the most zoomed in.setLabelScaleRange(com.luciad.util.ILcdInterval)
,
getScaleRange()
public ILcdInterval getScaleRange()
view.getScale()
< getScaleRange().getMin()
or
view.getScale()
>= getScaleRange().getMax()
.
This does not imply that all objects in the model should be painted when the scale is inside this range as
other restrictions may apply. For example, a layer may have a filter which defines which objects should be painted.
For most use cases, we recommended using the unitless map scale range
instead.
This property is mutually exclusive with the map scale range:
only one of them has a non-null
value.getScaleRange
in interface ILcdGXYLayer
ILcdInterval
containing the minimum and maximum value of view scales for which objects
should be rendered, excluding the maximum. null
if the scale constraints are determined by ILcdGXYLayer.getMapScaleRange()
.
The scales are expressed in toolkit pixels/world unit.setScaleRange(com.luciad.util.ILcdInterval)
public void setLabelScaleRange(ILcdInterval aNewLabelScaleRange)
ILcdGXYLayer
will paint
the labels of its elements if they have to be drawn at all.
The paint method of an ILcdGXYLayer
shall not draw any labels when:aGXYContext.getGXYView().getScale() < getScaleRange().getMin()
aGXYContext.getGXYView().getScale() < getLabelScaleRange().getMin()
aGXYContext.getGXYView().getScale() >= getScaleRange().getMax()
aGXYContext.getGXYView().getScale() >= getLabelScaleRange().getMax()
unitless map scale range
instead.aNewLabelScaleRange
- the new label scale range, in toolkit pixels/world unit, or null
to disable all scale constraints
The minimum (smallest) value is the most zoomed out, the maximum (largest) value is the most zoomed in.getLabelScaleRange()
public ILcdInterval getLabelScaleRange()
view.getScale()
< getLabelScaleRange().getMin()
or
view.getScale()
>= getLabelScaleRange().getMax()
.
This does not imply that labels for all objects in the model should be painted when the scale is inside this range
as other restrictions may apply. For example, a layer may decide not to paint any labels for objects whose body is
not painted.
For most use cases, we recommended using the unitless map scale range
instead.
This property is mutually exclusive with the label map scale range:
only one of them has a non-null
value.getLabelScaleRange
in interface ILcdGXYLayer
ILcdInterval
containing the minimum and maximum value of view scales for which
labels should be rendered, excluding the maximum.
null
if the scale constraints are determined by ILcdGXYLayer.getLabelMapScaleRange()
The scales are expressed in toolkit pixels/world unit.setLabelScaleRange(com.luciad.util.ILcdInterval)
public TLcdDimensionInterval<TLcdMapScale> getMapScaleRange()
ILcdGXYLayer
The paint method won't render objects in a view if the view's map scale is outside the scale range.
This does not imply that all objects in the model should be painted when the scale is inside this range as other restrictions may apply. For example, a layer may have a filter which defines which objects should be painted.
This property is mutually exclusive with thetoolkit scale range
:
only one of them has a non-null
value.getMapScaleRange
in interface ILcdGXYLayer
null
if the scale constraints are determined by ILcdGXYLayer.getScaleRange()
public void setMapScaleRange(TLcdDimensionInterval<TLcdMapScale> aMapScaleRange)
aMapScaleRange
- the new map scale range, or null
to disable any scale constraintspublic TLcdDimensionInterval<TLcdMapScale> getLabelMapScaleRange()
ILcdGXYLayer
map scale range
and inside the given map label scale range.
This does not imply that labels for all objects in the model should be painted when the scale is inside this range
as other restrictions may apply. For example, a layer may decide not to paint any labels for objects whose body is
not painted.
This property is mutually exclusive with the toolkit label scale range
:
only one of them has a non-null
value.getLabelMapScaleRange
in interface ILcdGXYLayer
null
if the scale constraints are determined by ILcdGXYLayer.getScaleRange()
public void setLabelMapScaleRange(TLcdDimensionInterval<TLcdMapScale> aLabelMapScaleRange)
The paint method will render labels for objects in a view if the view's map scale
is both inside the map scale range
and inside the given map label scale range.
This does not imply that all objects in the model should be painted when the scale is inside this range as other restrictions may apply. For example, a layer may have a filter which defines which objects should be painted.
This method overrides any configured toolkit label scale range.aLabelMapScaleRange
- the new map scale rangepublic ILcdInterval getPaintLabelsScaleRatioInterval()
setPaintLabelsScaleRatioInterval(com.luciad.util.ILcdInterval)
public void setPaintLabelsScaleRatioInterval(ILcdInterval aInterval)
paint(java.awt.Graphics, int, ILcdGXYView)
is called with the
ILcdGXYEditableLabelsLayer.PLACED_LABELS
flag.
If the ratio between the current scale and the scale in which the labels were placed is within this interval, the labels are painted, otherwise they are not. Omitting labels can be useful when the locations of labels are not always up-to-date, for example, if they are calculated asynchronously.
By default placed labels are painted when the scale ratio is within the interval
[0.5, Double.Max_Value]
.
aInterval
- The scale ratio interval.getPaintLabelsScaleRatioInterval()
public void setSelectionLabeled(boolean aNewSelectionLabeled)
isLabeled()
returns false.aNewSelectionLabeled
- true if selected objects should always be labeled, regardless of
isLabeled
isSelectionLabeled()
public boolean isSelectionLabeled()
isLabeled()
returns false.isLabeled
setSelectionLabeled(boolean)
public ILcdBounds getBounds(int aMode, ILcdGXYView aGXYView) throws TLcdNoBoundsException
ILcdGXYLayer
content,
the bounds of all the drawings (for the supplied mode) that represent the Objects contained in
the ILcdModel
of this ILcdGXYLayer
.
For this operation, this ILcdGXYLayer
is to be considered
as part of aGXYView
.
Outside of the layers bounds no interaction with any object of the layer via its representation is possible. Note that these bounds do not necessarily encompass the representation of all objects in the model, only the objects for which there is a representation in the view.
getBounds
in interface ILcdGXYLayer
aMode
- a bitwise combination of ALL or SELECTION and one or more of BODIES and HANDLES.
The ILcdGXYLayer.LABELS
mode is not supported.aGXYView
- the view in which the layer could be placed. This enables taking into account the views settings,
for example the scale.TLcdNoBoundsException
- if the layer doesn't have any valid bounds,
for example when none of the elements have a representation for the views current settings.public int applyOnInteract(ILcdFunction aFunction, Rectangle aBounds, boolean aStrictInteract, ILcdGXYView aGXYView)
The function shall be applied successively to all objects in the bounds as long as the function returns
true
for an object. This allows developers to indicate a stop condition. Note that the order in
which the objects are passed to the function is not specified.
When strict interaction is required, only objects whose representation lies within the given bounds, completely or partially, are candidates to be passed to the function. An object whose representation does not interact with the bounds should not be passed to the function. Applying non strict interaction can be useful to avoid heavy computations to determine whether an objects representation lies within the bounds.
This method behaves similar to the paint method, and as such is allowed to omit small or invisible objects for performance reasons.
Objects smaller than the set minimum object size may be omitted.
applyOnInteract
in interface ILcdGXYLayer
aFunction
- the function to apply. When the function returns false, no more objects should be passed to
the function.aBounds
- all objects who lie partially or completely in this area in the view are candidates to be passed to
the function.aStrictInteract
- if true
, the ILcdFunction
shall be applied only to the objects
interacting with the given bounds. When false is passed, other objects may be taken into account too.
When applying the function to an object consumes less time than checking whether an objects representation
interacts with the bounds, non-strict interaction is generally faster.aGXYView
- the view in whose bounds the objects representations should be in order to be passed to the
function.public int applyOnInteract(ILcdFunction aFunction, Graphics aGraphics, int aPaintMode, ILcdGXYView aGXYView)
ILcdGXYEditableLabelsLayer
The function shall be applied successively to all objects in the bounds as long as the function
returns true
for an object. This allows developers to indicate a stop condition.
Note that the order in which the objects are passed to the function is not specified.
The mode indicates what objects of the model should be taken into account. The objects to be taken into account shall be one of:
The representations provided shall be a combination of one or more of:
The mode supplied shall be a bitwise 'or' combination of a constant of the first group and a combination of constants of the second group.
applyOnInteract
in interface ILcdGXYEditableLabelsLayer
aFunction
- the function to apply. When the function returns false
, no
more objects should be passed to the function.aGraphics
- the graphicsaPaintMode
- the paint mode.aGXYView
- the view in whose bounds the objects representations should be in order to be
passed to the function. Note that for efficiency reasons (e.g. to avoid
expensive bounds calculations) objects may be passed that are not inside
the view bounds.public int applyOnInteractLabels(ILcdFunction aLabelFunction, Graphics aGraphics, int aPaintMode, ILcdGXYView aGXYView)
ILcdGXYEditableLabelsLayer
The function shall be applied successively to all labels in the bounds as long as the function
returns true
for a label. This allows developers to indicate a stop condition.
Note that the order in which the labels are passed to the function is not specified.
The mode indicates what labels should be taken into account. The labels to be taken into account shall be one of:
The representations provided shall be a combination of one or more of:
The mode supplied shall be a bitwise 'or' combination of a constant of the first group and a combination of constants of the second group.
applyOnInteractLabels
in interface ILcdGXYEditableLabelsLayer
aLabelFunction
- the function to apply. When the function returns false
, no
more labels should be passed to the function. The Object passed to this
function is always a TLcdLabelIdentifier
.aGraphics
- the graphicsaPaintMode
- the paint mode.aGXYView
- the view in whose bounds the objects representations should be in order
passed to the function. Note that for efficiency reasons (e.g. to avoid
expensive bounds calculations) objects may be passed that are not inside
the view bounds.public final TLcdModelQueryConfiguration getModelQueryConfiguration()
null
.public final void setModelQueryConfiguration(TLcdModelQueryConfiguration aModelQueryConfiguration)
aModelQueryConfiguration
- The non-null
model query configurationpublic void setFilter(ILcdFilter aFilter)
Sets the ILcdFilter
to filter the Object
on this
ILcdLayer
. Operations on this layer will only be applied to objects of the model
that pass the filter. This includes painting, labeling, selection, editing, ...
If the filter implements ILcdChangeSource
, the layer will listen to changes in the filter to
keep, for example, the selection up to date.
Setting a null
filter, lets all objects pass for rendering. By default the filter is null
.
The filtering performed by this filter is done inside the JVM, after the
data has been queried from the model and been passed to the layer.
Use the setModelQueryConfiguration(TLcdModelQueryConfiguration)
if you
have filters which should be evaluated on the model side.
For example when using a database model, this would allow the database to do the filtering.
setFilter
in class TLcdLayer
aFilter
- the filter that accepts only those objects that should be taken into account.TLcdLayer.getFilter()
protected int applyOnInteract(ILcdFunction aFunction, Graphics aGraphics, int aPaintMode, ILcdModel aModel, ILcdGXYView aGXYView)
For more information on this method, see the javadoc of
applyOnInteract
.
This method is called by
So it is possible to customise these methods by overriding this method. This can be used to e.g. customize the model content for painting of customise the model content for label placement.aFunction
- the function to apply. When the function returns false
, no
more objects should be passed to the function.aGraphics
- the graphicsaPaintMode
- the paint mode.aModel
- the model for whose objects the given function is applied.aGXYView
- the view in whose bounds the objects representations should be in order to be
passed to the function. Note that for efficiency reasons (e.g. to avoid
expensive bounds calculations) objects may be passed that are not inside
the view bounds.public void paint(Graphics aGraphics, int aMode, ILcdGXYView aGXYView)
The mode indicates what objects of the model should be taken into account and what representation should be provided. The objects to be taken into account shall be one of:
Note that the combined representation may contain less than the representation of all objects that were taken into account, as some objects may be disregarded for various reasons (filters, scale, ... ). When the views scale is outside the scale range (BODIES or HANDLES mode) or the label scale range (LABELS mode) nothing shall be painted.
The representations provided shall be one or more of:
The mode supplied shall be a bitwise or combination of a constant of the first group and one or more of the
second group. When painting in BODIES or HANDLES mode, painting of an object shall be delegated to the
painter
for that object, when the LABELS mode is passed, painting shall be delegated
to the labelpainter
for that object.
The view is passed to provide contextual information: some of the objects may have a different representation depending on the view, or depending on a property of the view, for example, the scale of the view.
The combined representation of the objects has to be painted on the Graphics supplied, as these may be different from the Graphics provided by the view (due to double buffering, for example).
When stopPainting
is called, the current painting operation should be aborted.
If this layer is asked to paint its labels, it must inform its
ALcdLabelLocations
instance as to which labels have been painted and which haven't
been.
The paint mode may contain ILcdGXYEditableLabelsLayer.PLACED_LABELS
.
This is a paint mode to indicate that only labels that are already placed should be painted. The
already placed labels can be retrieved from the ALcdLabelLocations
retrieved using
ILcdGXYEditableLabelsLayer.getLabelLocations()
.
This implementation calls paintFromOverlaps
or paintFromModel
, depending on whether
isPaintFromOverlaps()
returns true
or false
.
This method also calls applyOnInteract(com.luciad.util.ILcdFunction, java.awt.Graphics, int, ILcdGXYView)
and applyOnInteractLabels(com.luciad.util.ILcdFunction, java.awt.Graphics, int, ILcdGXYView)
to determine which objects or labels should be painted. Customizing these methods will also
customize the painting behavior.
Objects smaller than the set minimum object size may be omitted.
paint
in interface ILcdGXYEditableLabelsLayer
paint
in interface ILcdGXYLayer
aGraphics
- the Graphics to paint on.aMode
- indicates what should be painted and how it should be painted.aGXYView
- the view to paint for.setPaintFromOverlaps(boolean)
,
paintFromModel(java.awt.Graphics, int, com.luciad.model.ILcdModel, com.luciad.view.gxy.ILcdGXYContext)
,
paintFromOverlaps(java.awt.Graphics, int, com.luciad.model.ILcd2DBoundsIndexedModel, com.luciad.view.gxy.ILcdGXYContext)
public void setVisible(boolean aVisible)
ILcdLayer
setVisible
in interface ILcdLayer
setVisible
in class TLcdLayer
aVisible
- true
if the layer should be visible, false
otherwise.ILcdLayer.isVisible()
protected final void startPainting()
isStopPainting()
public void stopPainting()
Thread
and needs to be
stopped in a safe state from another Thread.stopPainting
in interface ILcdGXYLayer
isStopPainting()
,
Thread.interrupt()
,
startPainting()
protected final boolean isStopPainting()
stopPainting()
or the method startPainting()
The value of this property is checked when starting to paint:
stopPainting()
protected void paintFromModel(Graphics aGraphics, int aMode, ILcdModel aModel, ILcdGXYContext aGXYContext)
aGraphics
- the graphics to paint onaMode
- see ILcdGXYLayer.paint
.aModel
- see getModel()
aGXYContext
- the ILcdGXYContext
to consider for painting.protected void paintFromOverlaps(Graphics aGraphics, int aMode, ILcd2DBoundsIndexedModel a2DBoundsIndexedModel, ILcdGXYContext aGXYContext)
Object
of the ILcd2DBoundsIndexedModel
that interact
with the view clip.
The paint order is determined by the model.aGraphics
- the graphics to paint onaMode
- see ILcdGXYLayer.paint
.a2DBoundsIndexedModel
- the model to paintaGXYContext
- the ILcdGXYContext
to consider for painting.public static String modeToString(int aMode)
aMode
- a combination of the constants
ILcdGXYLayer.BODIES, ILcdGXYLayer.LABELS, ILcdGXYLayer.HANDLES and ILcdGXYLayer.SELECTION