com.bbn.openmap
Class LayerHandler

java.lang.Object
  com.bbn.openmap.MapHandlerChild
      com.bbn.openmap.OMComponent
          com.bbn.openmap.LayerHandler

All Implemented Interfaces:

LightMapHandlerChild, PropertyConsumer, SoloMapComponent, java.beans.beancontext.BeanContextChild, java.beans.beancontext.BeanContextMembershipListener, java.io.Serializable, java.util.EventListener

public class LayerHandler
extends OMComponent
implements SoloMapComponent, java.io.Serializable

The LayerHandler is a component that keeps track of all Layers for the MapBean, whether or not they are currently part of the map or not. It is able to dynamically add and remove layers from the list of available layers. Whether a layer is added to the MapBean depends on the visibility setting of the layer. If Layer.isVisible() is true, the layer will be added to the MapBean. There are methods within the LayerHandler that let you change the visibility setting of a layer.

The LayerHandler is able to take a Properties object, and create layers that are defined within it. The key property is "layers", which may or may not have a prefix for it. If that property does have a prefix (prefix.layers, i.e. openmap.layers), then that prefix has to be known and passed in to the constructor or init method. This layers property should fit the general openmap marker list paradigm, where the marker names are listed in a space separated list, and then each marker name is used as a prefix for the properties for a particular layer. As a minimum, each layer needs to have the class and prettyName properties defined. The class property should define the class name to use for the layer, and the prettyName property needs to be a name for the layer to be used in the GUI. Any other property that the particular layer can use should be listed in the Properties, with the applicable marker name as a prefix. Each layer should have its available properties defined in its documentation. For example:

           <p/>
             openmap.layers=marker1 marker2 (etc)
             marker1.class=com.bbn.openmap.layer.GraticuleLayer
             marker1.prettyName=Graticule Layer
             # false is default
             marker1.addToBeanContext=false
           <p/>
             marker2.class=com.bbn.openmap.layer.shape.ShapeLayer
             marker2.prettyName=Political Boundaries
             marker2.shapeFile=pathToShapeFile
             marker2.spatialIndex=pathToSpatialIndexFile
             marker2.lineColor=FFFFFFFF
             marker2.fillColor=FFFF0000
           <p/>
 

The LayerHandler is a SoloMapComponent, which means that for a particular map, there should only be one of them. When a LayerHandler is added to a BeanContext, it will look for a MapBean to connect to itself as a LayerListener so that the MapBean will receive LayerEvents - this is the mechanism that adds and removes layers on the map. If more than one MapBean is added to the BeanContext, then the last MapBean added will be added as a LayerListener, with any prior MapBeans added as a LayerListener removed from the LayerHandler. The MapHandler controls the behavior of multiple SoloMapComponent addition to the BeanContext.

See Also:

Serialized Form

Field Summary

protected java.util.List<Layer>	allLayers The list of all layers, even the ones that are not part of the map.
protected LayerConfigurationListenerSupport	layerConfigListeners LayerConfigurationListenerSupport for LayerConfigurationListeners.
static java.lang.String	layersProperty Property for space separated layers.
protected LayerSupport	listeners The object holding on to all LayerListeners interested in the layer arrangement and availability.
static java.util.logging.Logger	logger
protected PropertyHandler	propertyHandler This handle is only here to keep it appraised of layer prefix names.
static java.lang.String	startUpLayersProperty Property for space separated layers to be displayed at startup.
static java.lang.String	SynchronousThreadingProperty Flag to set synchronous threading on the LayerHandler, telling it to react to layer order changes and layer visibility requests within the calling thread.

Fields inherited from class com.bbn.openmap.OMComponent

i18n, propertyPrefix

Fields inherited from class com.bbn.openmap.MapHandlerChild

beanContextChildSupport, isolated

Fields inherited from interface com.bbn.openmap.PropertyConsumer

EditorProperty, initPropertiesProperty, LabelEditorProperty, ScopedEditorProperty

Constructor Summary

LayerHandler()
If you use this constructor, the LayerHandler expects that the layers will be created and added later, either by addLayer() or init().

LayerHandler(Layer[] layers)
Start the LayerHandler with configured layers.

LayerHandler(java.util.Properties props)
Start the LayerHandler, and have it create all the layers as defined in a properties file.

LayerHandler(java.lang.String prefix, java.util.Properties props)
Start the LayerHandler, and have it create all the layers as defined in a properties file.

Method Summary

void	addLayer(Layer layer) Add a layer to the bottom of the layer stack.
void	addLayer(Layer layer, int position) Add a layer to a certain position in the layer array.
void	addLayerConfigurationListener(LayerConfigurationListener lcl) Add a LayerConfigurationListener, so a component can make adjustments to new layer configurations before they get sent to the map.
void	addLayerListener(LayerListener ll) Add a LayerListener to the LayerHandler, in order to be told about layers that need to be added to the map.
void	addLayersToBeanContext(java.util.List<Layer> layers) Add layers to the BeanContext, if they want to be.
void	findAndInit(java.lang.Object someObj) Called from childrenAdded(), when a new component is added to the BeanContext, and from setBeanContext() when the LayerHandler is initially added to the BeanContext.
void	findAndUndo(java.lang.Object someObj) A BeanContextMembershipListener interface method, which is called when new objects are removed from the BeanContext.
java.util.List<Layer>	getLayerList() Returns a copy of the List of all the available layers.
protected java.lang.String	getLayerNamesFromArray(java.util.List<Layer> lArray)
Layer[]	getLayers() Get a layer array, of potential layers that CAN be added to the map, not the ones that are active on the map.
protected Layer[]	getLayers(java.util.Properties p) This is the method that gets used to parse the layer properties from an openmap.properties file, where the layer marker names are listed under a layers property, and each layer is then represented by a marker.class property, and a maker.prettyName property.
protected Layer[]	getLayers(java.lang.String prefix, java.util.Properties p) This is the method that gets used to parse the layer properties from an openmap.properties file, where the layer marker names are listed under a prefix.layers property, and each layer is then represented by a marker.class property, and a maker.prettyName property.
static Layer[]	getLayers(java.util.Vector<java.lang.String> layerList, java.util.Vector<java.lang.String> visibleLayerList, java.util.Properties p) A static method that lets you pass in a Properties object, along with two Vectors of strings, each Vector representing marker names for layers contained in the Properties.
protected LayerSupport	getListeners() Returns the object responsible for holding on to objects listening to layer changes.
Layer[]	getMapLayers() Get the layers that are currently part of the Map - the ones that are visible.
java.util.Properties	getProperties(java.util.Properties props) PropertyConsumer method, to fill in a Properties object, reflecting the current values of the OMComponent.
PropertyHandler	getPropertyHandler()
java.util.Properties	getPropertyInfo(java.util.Properties props) Method to fill in a Properties object with values reflecting the properties able to be set on this PropertyConsumer.
boolean	hasLayer(Layer l)
void	init(Layer[] layers) Initialize from an array of layers.
void	init(java.util.List<Layer> layers)
void	init(java.lang.String prefix, java.util.Properties props) Initialize the LayerHandler by having it construct it's layers from a properties object.
void	init(java.lang.String prefix, java.net.URL url) Initialize the LayerHandler by having it construct it's layers from a URL containing an openmap.properties file.
void	init(java.net.URL url) Initialize the LayerHandler by having it construct it's layers from a URL containing an openmap.properties file.
protected boolean	isForegroundUnderBackgroundLayer(java.util.List<Layer> layers) Checks to see if there are background layers on top of foreground layers.
boolean	isSynchronousThreading()
boolean	moveLayer(Layer layer, int toPosition) Move a layer to a certain position.
protected java.util.List<Layer>	organizeBackgroundLayers(java.util.List<Layer> layers) Does the check to see of foreground layers are below background layers, and then iterates through the Layer[] switching layers around until they are in the appropriate order.
void	removeAll() Remove all the layers (that are marked as removable).
void	removeLayer(int index) Remove a layer from the list of potentials.
void	removeLayer(Layer layer) Remove a layer from the list of potentials.
protected void	removeLayer(Layer[] currentLayers, int index) The version that does the work.
void	removeLayerConfigurationListener(LayerConfigurationListener lcl) Remove a LayerConfigurationListener.
void	removeLayerListener(LayerListener ll) Add a LayerListener to the LayerHandler, in order to be told about layers that need to be added to the map.
void	removeLayersFromBeanContext(java.util.List<Layer> layers) Add layers to the BeanContext, if they want to be.
void	setBeanContext(java.beans.beancontext.BeanContext in_bc) Called when the LayerHandler is added to a BeanContext.
void	setLayerList(java.util.List<Layer> layers)
void	setLayers() If you are futzing with the layer visibility outside the purview of the LayerHandler (not using the turnLayerOn() methods) then you can call this to get all the listeners using the current set of visible layers.
void	setLayers(Layer[] layers) Set all the layers held by the LayerHandler.
void	setProperties(java.lang.String prefix, java.util.Properties props) Extension of the OMComponent.
void	setPropertyHandler(PropertyHandler ph)
void	setSynchronousThreading(boolean s)
boolean	turnLayerOn(boolean setting, int index) Take a layer that the LayersMenu knows about, that may or may not be a part of the map, and change its visibility by adding/removing it from the MapBean.
boolean	turnLayerOn(boolean setting, Layer layer) Take a layer that the LayersMenu knows about, that may or may not be a part of the map, and change its visibility by adding/removing it from the MapBean.

Methods inherited from class com.bbn.openmap.OMComponent

getPropertyPrefix, setProperties, setPropertyPrefix

Methods inherited from class com.bbn.openmap.MapHandlerChild

addPropertyChangeListener, addVetoableChangeListener, childrenAdded, childrenRemoved, findAndInit, firePropertyChange, fireVetoableChange, getBeanContext, isIsolated, removePropertyChangeListener, removeVetoableChangeListener, setIsolated

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

logger

public static java.util.logging.Logger logger

layersProperty

public static final java.lang.String layersProperty

Property for space separated layers. If a prefix is needed, just use the methods that let you use the prefix - don't worry about the period, it will be added automatically.

See Also:

Constant Field Values

startUpLayersProperty

public static final java.lang.String startUpLayersProperty

Property for space separated layers to be displayed at startup. If a prefix is needed, just use the methods that let you use the prefix - don't worry about the period, it will be added automatically.

See Also:

Constant Field Values

SynchronousThreadingProperty

public static final java.lang.String SynchronousThreadingProperty

Flag to set synchronous threading on the LayerHandler, telling it to react to layer order changes and layer visibility requests within the calling thread. By default, this action is true. Setting it to false may eliminate pauses in GUI reactions by off-loading work done by layers being added to the MapBean, but there have been reports that the asynchronous nature of the threading queue may be causing an unexpected state in layer order and/or availability under certain intense layer management conditions (created by automated processes, for example).

See Also:

Constant Field Values

listeners

protected transient LayerSupport listeners

The object holding on to all LayerListeners interested in the layer arrangement and availability. Not expected to be null.

layerConfigListeners

protected transient LayerConfigurationListenerSupport layerConfigListeners

LayerConfigurationListenerSupport for LayerConfigurationListeners.

allLayers

protected java.util.List<Layer> allLayers

The list of all layers, even the ones that are not part of the map.

propertyHandler

protected PropertyHandler propertyHandler

This handle is only here to keep it appraised of layer prefix names.

Constructor Detail

LayerHandler

public LayerHandler()

If you use this constructor, the LayerHandler expects that the layers will be created and added later, either by addLayer() or init().

LayerHandler

public LayerHandler(java.util.Properties props)

Start the LayerHandler, and have it create all the layers as defined in a properties file.

Parameters:

props - properties as defined in an openmap.properties file.

LayerHandler

public LayerHandler(java.lang.String prefix,
                    java.util.Properties props)

Start the LayerHandler, and have it create all the layers as defined in a properties file.

Parameters:

prefix - the prefix for the layers and startUpLayers properties, as if they are listed as prefix.layers, and prefix.startUpLayers.

props - properties as defined in an openmap.properties file.

LayerHandler

public LayerHandler(Layer[] layers)

Start the LayerHandler with configured layers.

Method Detail

setProperties

public void setProperties(java.lang.String prefix,
                          java.util.Properties props)

Extension of the OMComponent. If the LayerHandler is created by the ComponentFactory (via the PropertyHandler), this method will be called automatically. For the OpenMap applications, this method is rigged to handle the openmap.layers property by calling init("openmap", props). If you are using the LayerHandler in a different setting, then you might want to just call init() directly, or extend this class and have setProperties do what you want.

Specified by:

setProperties in interface PropertyConsumer

Overrides:

setProperties in class OMComponent

Parameters:

prefix - the token to prefix the property names

props - the Properties object

init

public void init(java.lang.String prefix,
                 java.util.Properties props)

Initialize the LayerHandler by having it construct it's layers from a properties object. The properties should be created from an openmap.properties file.

Parameters:

prefix - the prefix to use for the layers and startUpLayers properties.

props - properties as defined in an openmap.properties file.

init

public void init(java.net.URL url)

Initialize the LayerHandler by having it construct it's layers from a URL containing an openmap.properties file.

Parameters:

url - a url for a properties file.

init

public void init(java.lang.String prefix,
                 java.net.URL url)

Initialize the LayerHandler by having it construct it's layers from a URL containing an openmap.properties file.

Parameters:

prefix - the prefix to use for the layers and startUpLayers properties.

url - a url for a properties file.

init

public void init(Layer[] layers)

Initialize from an array of layers. This will cause the LayerListeners, if they exist, to update themselves with the current list of layers. This will check to add layers to the MapHandler.

Parameters:

layers - the initial array of layers.

init

public void init(java.util.List<Layer> layers)

setPropertyHandler

public void setPropertyHandler(PropertyHandler ph)

getPropertyHandler

public PropertyHandler getPropertyHandler()

getLayers

protected Layer[] getLayers(java.util.Properties p)

This is the method that gets used to parse the layer properties from an openmap.properties file, where the layer marker names are listed under a layers property, and each layer is then represented by a marker.class property, and a maker.prettyName property.

Parameters:

p - properties containing layers property, the startupLayers property listing the layers to make visible immediately, and the layer properties as well.

Returns:

Layer[] of layers created from the properties.

getLayers

protected Layer[] getLayers(java.lang.String prefix,
                            java.util.Properties p)

This is the method that gets used to parse the layer properties from an openmap.properties file, where the layer marker names are listed under a prefix.layers property, and each layer is then represented by a marker.class property, and a maker.prettyName property.

Parameters:

prefix - the prefix to use to use for the layer list (layers) property and the startUpLayers property. If it is not null, this will cause the method to look for prefix.layers and prefix.startUpLayers.

p - the properties to build the layers from.

Returns:

Layer[]

getLayers

public static Layer[] getLayers(java.util.Vector<java.lang.String> layerList,
                                java.util.Vector<java.lang.String> visibleLayerList,
                                java.util.Properties p)

A static method that lets you pass in a Properties object, along with two Vectors of strings, each Vector representing marker names for layers contained in the Properties.

If a PlugIn is listed in the properties, the LayerHandler will create a PlugInLayer for it and set the PlugIn in that layer.

Parameters:

layerList - Vector of marker names to use to inspect the properties with.

visibleLayerList - Vector of marker names representing the layers that should initially be set to visible when created, so that those layers are initially added to the map.

p - Properties object containing the layers properties.

Returns:

Layer[]

addLayerListener

public void addLayerListener(LayerListener ll)

Add a LayerListener to the LayerHandler, in order to be told about layers that need to be added to the map. The new LayerListener will receive two events, one telling it all the layers available, and one telling it which layers are active (visible).

Parameters:

ll - LayerListener, usually the MapBean or other GUI components interested in providing layer controls.

addLayerConfigurationListener

public void addLayerConfigurationListener(LayerConfigurationListener lcl)

Add a LayerConfigurationListener, so a component can make adjustments to new layer configurations before they get sent to the map.

Parameters:

lcl - LayerConfigurationListener

removeLayerListener

public void removeLayerListener(LayerListener ll)

Add a LayerListener to the LayerHandler, in order to be told about layers that need to be added to the map.

Parameters:

ll - LayerListener, usually the MapBean or other GUI components interested in providing layer controls.

removeLayerConfigurationListener

public void removeLayerConfigurationListener(LayerConfigurationListener lcl)

Remove a LayerConfigurationListener.

Parameters:

lcl - LayerConfigurationListener

setLayers

public void setLayers(Layer[] layers)

Set all the layers held by the LayerHandler. The visible layers will be sent to listeners interested in visible layers (LayerEvent.REPLACE), and the list of all layers will be sent to listeners interested in LayerEvent.ALL events. Calling this method from other GUI components could break the non-removable contract that previous layers had. The previous layers aren't checked against this list to insure that non-removable layers are still on this list and visible. GUI components that may call this need to set up their GUI controls to not allow non-removable layers to be eliminated from the application.

This method will not add the layers to the MapHandler, so you can call this if you know the layers are already in the MapHandler or don't need to be. If you want layers to be added to the MapHandler (if the LayerHandler knows about it), call init(Layer[]) instead.

Also, this method will disregard layer non-removable status for any layers currently held, and will simply replace all layers with the ones provided. If you want the non-removable flag to be adhered to, call init(Layers[]).

Parameters:

layers - Layer array of all the layers to be held by the LayerHandler.

setLayerList

public void setLayerList(java.util.List<Layer> layers)

getLayerNamesFromArray

protected java.lang.String getLayerNamesFromArray(java.util.List<Layer> lArray)

isForegroundUnderBackgroundLayer

protected boolean isForegroundUnderBackgroundLayer(java.util.List<Layer> layers)

Checks to see if there are background layers on top of foreground layers.

Parameters:

layers -

Returns:

true if background layers need to be pushed down

organizeBackgroundLayers

protected java.util.List<Layer> organizeBackgroundLayers(java.util.List<Layer> layers)

Does the check to see of foreground layers are below background layers, and then iterates through the Layer[] switching layers around until they are in the appropriate order.

Parameters:

layers -

Returns:

Layer[] of layers with background layers moved to back.

getListeners

protected LayerSupport getListeners()

Returns the object responsible for holding on to objects listening to layer changes.

Returns:

LayerSupport containing pointers to all objects interested in the status (order, visibility) of the available layers.

setLayers

public void setLayers()

If you are futzing with the layer visibility outside the purview of the LayerHandler (not using the turnLayerOn() methods) then you can call this to get all the listeners using the current set of visible layers.

getLayers

public Layer[] getLayers()

Get a layer array, of potential layers that CAN be added to the map, not the ones that are active on the map. A new array is returned, containing the current layers.

Returns:

new Layer[] containing new layers.

getLayerList

public java.util.List<Layer> getLayerList()

Returns a copy of the List of all the available layers.

Returns:

List of Layers

getMapLayers

public Layer[] getMapLayers()

Get the layers that are currently part of the Map - the ones that are visible.

Returns:

an Layer[] of visible Layers.

moveLayer

public boolean moveLayer(Layer layer,
                         int toPosition)

Move a layer to a certain position. Returns true if the layer exists in the LayerHandler, false if is doesn't. No action is taken if the layer isn't already added to the LayerHandler stack. If the position is 0 or less the layer is moved on top. If the position is greater or equal to the number of layers, the layer is moved to the bottom of the pile.

Parameters:

layer - the layer to move.

toPosition - the array index to place it, shifting the other layers up or down, depending on where the layer is originally.

Returns:

true if the layer is already contained in the LayerHandler, false if not.

addLayer

public void addLayer(Layer layer)

Add a layer to the bottom of the layer stack. If the layer is already part of the layer stack, nothing is done.

Parameters:

layer - the layer to add.

addLayer

public void addLayer(Layer layer,
                     int position)

Add a layer to a certain position in the layer array. If the position is 0 or less, the layer is put up front (on top). If the position is greater than the length of the current array, the layer is put at the end, (on the bottom). A Layer can only be added once. If you add a layer that is already added to the LayerHandler, it will be moved to the requested position.

Parameters:

layer - the layer to add.

position - the array index to place it.

removeLayer

public void removeLayer(Layer layer)

Remove a layer from the list of potentials.

Parameters:

layer - to remove.

removeLayer

public void removeLayer(int index)

Remove a layer from the list of potentials.

Parameters:

index - of layer in the layer array. Top-most is first.

hasLayer

public boolean hasLayer(Layer l)

removeAll

public void removeAll()

Remove all the layers (that are marked as removable).

removeLayer

protected void removeLayer(Layer[] currentLayers,
                           int index)

The version that does the work. The other two functions do sanity checks. Calls setLayers(), and removes the layer from the BeanContext.

Parameters:

currentLayers - the current layers handled in the LayersMenu.

index - the validated index of the layer to remove.

turnLayerOn

public boolean turnLayerOn(boolean setting,
                           int index)

Take a layer that the LayersMenu knows about, that may or may not be a part of the map, and change its visibility by adding/removing it from the MapBean.

Parameters:

setting - true to add layer to the map.

index - the index of the layer to turn on/off.

Returns:

true of index represented a layer, false if not or if something went wrong.

turnLayerOn

public boolean turnLayerOn(boolean setting,
                           Layer layer)

Take a layer that the LayersMenu knows about, that may or may not be a part of the map, and change its visibility by adding/removing it from the MapBean. If the layer is not found, it's added and the visibility depends on the setting parameter.

Parameters:

setting - true to add layer to the map.

layer - the layer to turn on.

Returns:

true if the layer was found, false if not or if something went wrong.

findAndInit

public void findAndInit(java.lang.Object someObj)

Called from childrenAdded(), when a new component is added to the BeanContext, and from setBeanContext() when the LayerHandler is initially added to the BeanContext. This method takes the iterator provided when those methods are called, and looks for the objects that the LayerHandler is interested in, namely, the MapBean, the PropertyHandler, or any other LayerListeners. The LayerHandler handles multiple LayerListeners, and if one is found, it is added to the LayerListener list. If a PropertyHandler is found, then init() is called, effectively resetting the layers held by the LayerHandler.

Specified by:

findAndInit in interface LightMapHandlerChild

Overrides:

findAndInit in class MapHandlerChild

Parameters:

someObj - an Object being added to the MapHandler/BeanContext.

findAndUndo

public void findAndUndo(java.lang.Object someObj)

A BeanContextMembershipListener interface method, which is called when new objects are removed from the BeanContext. If a LayerListener or Layer is found on this list, it is removed from the list of LayerListeners.

Specified by:

findAndUndo in interface LightMapHandlerChild

Overrides:

findAndUndo in class MapHandlerChild

Parameters:

someObj - an Object being removed from the MapHandler/BeanContext.

addLayersToBeanContext

public void addLayersToBeanContext(java.util.List<Layer> layers)

Add layers to the BeanContext, if they want to be. Since the BeanContext is a Collection, it doesn't matter if a layer is already there because duplicates aren't allowed.

Parameters:

layers - layers to add, if they want to be.

removeLayersFromBeanContext

public void removeLayersFromBeanContext(java.util.List<Layer> layers)

Add layers to the BeanContext, if they want to be. Since the BeanContext is a Collection, it doesn't matter if a layer is already there because duplicates aren't allowed.

Parameters:

layers - layers to add, if they want to be.

setBeanContext

public void setBeanContext(java.beans.beancontext.BeanContext in_bc)
                    throws java.beans.PropertyVetoException

Called when the LayerHandler is added to a BeanContext. This method calls findAndInit() to hook up with any objects that may already be added to the BeanContext. A BeanContextChild method.

Specified by:

setBeanContext in interface java.beans.beancontext.BeanContextChild

Overrides:

setBeanContext in class MapHandlerChild

Parameters:

in_bc - BeanContext.

Throws:

java.beans.PropertyVetoException

setSynchronousThreading

public void setSynchronousThreading(boolean s)

isSynchronousThreading

public boolean isSynchronousThreading()

getProperties

public java.util.Properties getProperties(java.util.Properties props)

Description copied from class: OMComponent

PropertyConsumer method, to fill in a Properties object, reflecting the current values of the OMComponent. If the component has a propertyPrefix set, the property keys should have that prefix plus a separating '.' prepended to each property key it uses for configuration.

Specified by:

getProperties in interface PropertyConsumer

Overrides:

getProperties in class OMComponent

Parameters:

props - a Properties object to load the PropertyConsumer properties into. If props equals null, then a new Properties object should be created.

Returns:

Properties object containing PropertyConsumer property values. If getList was not null, this should equal getList. Otherwise, it should be the Properties object created by the PropertyConsumer.

getPropertyInfo

public java.util.Properties getPropertyInfo(java.util.Properties props)

Description copied from class: OMComponent

Method to fill in a Properties object with values reflecting the properties able to be set on this PropertyConsumer. The key for each property should be the raw property name (without a prefix) with a value that is a String that describes what the property key represents, along with any other information about the property that would be helpful (range, default value, etc.). For Layer, this method should at least return the 'prettyName' property.

Specified by:

getPropertyInfo in interface PropertyConsumer

Overrides:

getPropertyInfo in class OMComponent

Parameters:

props - a Properties object to load the PropertyConsumer properties into. If getList equals null, then a new Properties object should be created.

Returns:

Properties object containing PropertyConsumer property values. If getList was not null, this should equal getList. Otherwise, it should be the Properties object created by the PropertyConsumer.