LayerHandler (OpenMap API)
Date: 2016-12-09

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## 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.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright (C) BBNT Solutions LLC; See http://openmap.bbn.com/ for details