Fetching contributors…
Cannot retrieve contributors at this time
4896 lines (3808 sloc) 211 KB
2016-12-09 Don Dietrick <dietrick@hsawaknow.local>
* Tagged OpenMap 5.1.15
* MapBean internal listener support managers are final and
never get set to null, fixing a cleanup problem if listeners
try to disengage themselves from the MapBean after dispose()
has been called.
* EditableOMPoly grab points now in synchronized list to
handle rapid clicks and repaints.
* Updated MapTileLayer to have a property where the local file
cache can be saved or destroyed after use "saveCache".
* BufferedImageHelper fixed issue where images weren't getting
reloaded from the file system, a cached version of the image was
being used instead.
* MapTileCoordinateTransform has settable min/max zoom levels.
2016-08-05 Don Dietrick <dietrick@hsawaknow.local>
* Tagged OpenMap 5.1.14
* MapTileLayer can be used in LayerAddPanel.
* RPF modifications. Changed RpfProductInfo to be an enum instead
of a class, moved all defining information to it instead of being
listed in the RpfConstants class. Overhauled the RpfCoverage tool
used by RpfLayer, simplified it and the RpfCoverageManager.
Updated RpfFrameProvider to use List instead of Vector. Udpated
classes to use doubles instead of floats for coordinates.
* Modified BasicMapPanel startup order to change when startup
projection settings are read and set on MapBean.
* Update StandardMapMouseInterpreter to better handle events over
geometries. It also checks to see if the MouseEvent has been
consumed during mouseOver calls.
* EsriGraphicList can return the EsriGraphic that has a certain
attribute in a specified column.
* Removed shadow x and y and reference from ShapeLayer.
* Modified OMScalingRaster to check h/w before trying to create
image warp object.
* Added OMShape.PROJECTED class to represent shapes that are
defined in pixel space. Generation does nothing, rendering still
* Modified WebImagePlugin to warp images to match current OpenMap
projection. Also modified to make two separate queries when
crossing the dateline.
* Added method in ProjMath to add distance between points in an
array of coordinates. OMDistance now uses this and the new
LineCoordinateGenerator class. LineCoordinateGenerator class will
create interpolated coordinates between two points, for great
circle or rhumb lines.
* Updated RangeRingsMouseMode to take units property.
* Modified NatCubicSpline to have an extended CLOSED inner class.
You create one or the other from static class methods. OMSpline
updated to use new design, and one is only created when it is
* Added new app parts to OpenMapAppPartCollection, and created a
new standard OMGraphicHandlerLayer panel that can modify layer
transparency, bring up properties panel, and call doPrepare() on a
* Modified methods in ColorFactory to handle 3 character color
definitions, and to return default value passed in if a
NumberFormatException is thrown.
* Added VPFCoverageTrimmer, which will remove select tiles from
the dataset based on their location.
* Changed Length class to enum. Updated other classes to use
getValues() when needed.
* Modifcations to mapTile package. StandardMapTileFactory has an
overridable method to create desired file paths. Useful when
creating a factory with a unique naming convention for
tiles. Added TileGrabber, which will grab tiles from a server for
off-line use.
* Added ALMOST_CLEAR to OMColor, to help with rendering some
OMGraphics against transparent backgrounds.
* Modified classes to not use
OMGraphic.getAppObject()/setAppObject() methods, replaced
explicitly setting the OMGraphic.APP_OBJECT parameter in OMGraphic
* Modified files for javadoc cleanup, removing problem characters, etc.
* Added new com.bbn.openmap.omGraphics.rule package, which is
taking the Rule objects from the
com.bbn.openmap.dataAccess.shp.DbfHandler and making them more
general. The DbfHandler Rules were modified to extend classes
from this package.
2015-12-17 Don Dietrick <dietrick@hsawaknow.local>
* Tagged OpenMap 5.1.13
* Removed license language from several files that had been
inadvertently added due to IDE settings.
2015-09-01 Don Dietrick <dietrick@hsawaknow.local>
* Merged fix to EsriPolylineList to return proper type
2015-08-07 Don Dietrick <dietrick@hsawaknow.local>
* Tagged OpenMap 5.1.12
* Added the scaleOverCoverage property to the RpfLayer, and
modifying the RpfTocHandler to use it when determining the best
TOC entry for the current map query. It's true by default, but
when used for tiles (wmsservlet), the RpfLayer performs
better (fills in some empty tiles) with data it may have for
different scales.
* Updated WMSPlugIn query to use correct CRS parameter for v1.3
2015-07-20 Don Dietrick <dietrick@hsawaknow.local>
* Tagged OpenMap 5.1.11
* Added flag (defaulting to true) to RpfTocHandler to tell it to
ignore zones of entries when evaluating coverage for projection.
This fix allows the layer to avoid choosing only entries that
match the projection zone, even though other options would provide
better coverage. Not a problem since subframes are scaled and
warped as necessary to match projection. This fixes the annoying
flipping coverage problem when panning N/S and crossing zone
boundaries, when you are zoomed out past the ideal scale for a
particular chart type.
2015-03-12 Don Dietrick <dietrick@hsawaknow.local>
* Added bug fixes, including equalty check to avoid infinite loop
in EmbeddedScaleDisplayPanel, Moving to local variable in
OMPoly.generate for thread safety, updating WMSPlugIn to handle
WMS 1.3 requests. Updated OMRaster.computePixels length check.
2015-02-06 Don Dietrick <dietrick@hsawaknow.local>
* Tagged OpenMap 5.1.10
2015-01-22 Don Dietrick <dietrick@hsawaknow.local>
* Updated ProjectionFactory to use getProjClassForName instead of
trying to make a class from a general string. This way, pretty
names can be used in the properties to set the default projection
type of the app. Updated to Logger.
2015-01-21 Don Dietrick <dietrick@hsawaknow.local>
* Synchronization updates from Andrew Lloyd for OMGraphicList,
properly unsynchronizing on methods and synchronizing on
2015-01-07 Don Dietrick <dietrick@hsawaknow.local>
* Updated projections to pan using Rhumb calculations instead of
GreatCircle calculations, which was causing a slight skew to the
equator when going east-west.
2014-12-18 Don Dietrick <dietrick@hsawaknow.local>
* Tagged OpenMap 5.1.9
* Fixed the OMScalingRaster, was drawing full-sized image when the
bounds said it should be totally off the map.
2014-12-15 Don Dietrick <dietrick@hsawaknow.local>
* Tagged OpenMap 5.1.8
* Modified the OMGraphicHandlerLayer threading and locking code.
* Added ImageWarp methods to make it easier to use as a standalone
* Updated precision for Planet NM constants.
* Updated the MapBean and MapHandler listener handling code.
* Removed the iis directory and WebService. It will no longer be
maintained or tested.
2014-11-19 Don Dietrick <dietrick@hsawaknow.local>
* Tagged OpenMap 5.1.7
* Updated the MapBean, BufferedMapBean, BufferedLayerMapBean and
BufferedLayer to handle flashing better, especially with
background layers. Also fixed a problem in BufferedLayer where it
was resetting the rotation angle in the projection, causing all
the icons and labels to rotate with the map instead of staying
straight up.
* Updated com.bbn.openmap.util.WebBrowser to be an abstract class
that the InformationDelegator uses to launch web pages. If no
WebBrowser implementation is specified, the InformationDelegator
uses the simple MiniBrowser in OpenMap. If the BrowserLauncher2
jar file is in the classpath the new
com.bbn.openmap.util.BrowserLauncher2WebBrowser class can be
specified in the InforamtionDelegator properties to be used for
displaying websites. Removed the old BrowserLauncher code.
* Updated import statements to remove unused classes.
2014-10-17 dietrick <dietrick@wonkavision.local>
* Tagged OpenMap 5.1.6
* Modified Layer, BufferedLayer, BufferedLayerMapBean and MapBean
to eliminate the flashing effect caused when faster-responding
layers were paired with slower-responding layers, and the map
background would be seen briefly. Now, when the
BufferedLayerMapBean is used, its BufferedLayer is consulted to
make sure all 'background' layers are ready before repaint()
requests are forwarded to the AWT mechanism. Layers are ready
when repaint() is called on them.
2014-10-16 dietrick <dietrick@wonkavision.local>
* Tagged OpenMap 5.1.5
* Removed sinh from MoreMath, the standard Math function should be
used instead. Updated Mercator to use it. Updated
OMGraphicHandlerLayer threading model to handle workerComplete()
better. There were situations where a canceled worker could
result in two or more more threads locking up on prepare().
OMList updated so that processAllGraphics is true by default, was
causing an extra loop through graphics to check visibility for
sublists. Updated iterator methods to iterate over shallow copy
of graphics.
* Added check in OMWarpingImage.render() to check isRenderable().
2014-09-18 dietrick <dietrick@wonkavision.local>
* Tagged OpenMap 5.1.4
* Updated OpenMapFrame to use Height, Width properties defined the
same way as in the Environment class. The OpenMapFrame no longer
looks for a PropertyHandler in the MapHandler, the OpenMap class
will provide the properties to it right after it's created. The
OpenMapFrame now consistently follows the height/width settings,
and the Height/Width properties have proper
The PropertyHandler.Builder class has a build method, which is now
used by updated Main and OpenMap classes. OpenMap and Main now
have Logger member variables, moving away from Debug.
* Updated OMGraphicAdapter to handle TexturePaint masks property
during Serialization. The SerializableTexturePaint was added to
help with this.
* Modified OMScalingRaster so local handles to clipRect are used
for positioning, to help with multithreaded environment. The old
way was causing NPE to appear under certain conditions. Local
handles were also implemented in the NavMouseModes for the same
* Updated BLMapBean has been updated to use an almost entirely
transparent background so that semi-transparent layers will render
property. Previously, semi-transparent layers would not appear.
* Updated RPF catalog with entries from latest version of specification.
2014-07-28 dietrick <dietrick@wonkavision.local>
* Tagged OpenMap 5.1.3
2014-07-25 dietrick <dietrick@wonkavision.local>
* Modified OMRasterObject/OMScalingRaster/OMScalingIcon image
handling. The projected image is no longer held in memory.
Instead, the transform, created in generate(), is saved and
applied when rendering. OMScalingIcon figures out when the image
doesn't need to be scaled and just draws it in that case.
* Modified BufferedMapBean, BufferedLayer and MapBean, adjusting
the image buffers to be cleaned and reused when the size doesn't
* Some layers have been tweaked - OMGraphicHandlerLayer will print
out an information message if memory exceptions occur,
SimpleAnimationLayer moves the sprites a bit more.
2014-07-07 dietrick <dietrick@wonkavision.local>
* Tagged OpenMap 5.1.2
* change recent modifications
so that if a layer's previous and current OMGraphicList are null,
repaint isn't called on the layer. Previously, empty
OMGraphicLists prevented repaint from being called too, and that
has bad side-effects.
2014-06-18 dietrick <dietrick@wonkavision.local>
* Tagged OpenMap 5.1.1
* Made some memory usage improvements to the MapBean rotation
components, the rotated image buffer is reused under most
conditions. Added more cleanup to BufferedImageRenderPolicy.
* Added comments/README to the WMS servlet components.
* Modified the SpatialIndex to use a separate ArrayList for entry
traversal when responding to a projection change.
2014-05-14 dietrick <dietrick@wonkavision.local>
* Tagged OpenMap 5.1.0 - Since the API signatures have changed for
some components, the minor version number is being
increased. Details following.
* Updated the MapBean (and subclasses) to handle rotation better.
When a rotation angle is set on the MapBean, it starts to use a
RotationHelper (inner class) to create a new image buffer for a
projection large enough to cover the corners of the map. The
RotationHelper handles the rotated map. The paintChildren()
method has been updated to only render layers. Rendering of the
PaintListeners and Border are handled by separate methods called
from the paint() method. To get the map to render fully when
rotated, the clip area is disabled when the map is rotated.
The MapBean has new methods to use when working with rotation.
The MapBean inverse method gives you map coordinates taking into
account rotation. The getRotatedProjection provides the
projection being sent to the layers at any given time, while
getProjection always provides the original projection. The best
place to see how these methods are used is to check out the
listenerPaint methods in the MouseModes.
OMText and OMScalingRaster OMGraphics pay attention to the
OMGraphicConstants.NO_ROTATE attribute. If that attribute is set,
they will always appear at their rotated angle relative to the
MapBean boundaries. OMTextLabelers always have that attribute
set, so they will automatically correct for rotation.
* Updated Projections to have a rotationAngle member variable.
This member variable is only present to pass the setting from the
MapBean on to OMGraphics, in case they want to modify themselves
with regard to rotation. Projection objects themselves don't use
this member variable. The panning method in Projections was also
fixed. There was an issue with the pan command for directions
other than the 8 pre-defined directions. Now panning works for
all directions, and when the map is rotated.
* Added AbstractProjectionChangePolicy to handle common projection
change policy functionality. IMPORTANT: The OMGraphicHandlerLayer
SwingWorker has been modified so it doesn't automatically call
repaint on the layer when the thread is complete. The
AbstractProjectionChangePolicy handles calling repaint() on the
layer, after determining the layer has something to paint. If a
layer (before a projection change had no OMGraphics to paint, and
after the projection change still doesn't have OMGraphics to
paint) isn't contributing to the map, repaint() will not be called
on it. You can override this behavior by setting a different
ProjectionChange policy on the layer.
* Updated the OMGraphicAdapter (base class for all OMGraphics)
setLabelLocation method signatures so the projection is also
passed in. This allows OMTextLabelers to figure out how to not be
affected by map rotation. The old method signatures have been
* Updated the MouseModes to handle rotation. They have been
modified to be PaintListeners and paint directly on top of the map
instead of using XOR drawing techniques. Their code has been
refactored and their API signatures have changed slightly. TODO:
There is a known issue with the PanMouseMode map rendering when
the map is rotated. The current work-around is to have the
AzimuithPanner enabled for all projections when the map is
rotated. I've also seen a issue with the
NavMouseModes/DistanceMouseMode rendering when the 1) map is
rotated 2) on a Mac and 3) the ToolBar is visible. The rendered
graphics are offset lower than they should be (height of ToolBar).
* Modified the PaintListener interface so the source object is
also provided in the listenerPaint method signature.
* Updated EditableOMPoly setGrabPoints methods to be safer when
dealing with poly coords and projections.
2014-03-13 dietrick <dietrick@client.wonkavision.local>
* Tagged OpenMap 5.0.4
2014-03-12 dietrick <dietrick@client.wonkavision.local>
* Added a GUI button to the MapTileLayer to delete the tile cache
on disk for those layers using a ServerMapTileFactory. Disabled
for layers solely relying on a single map tile directory accessed
* Improved the property handling of the ommaptileservlet so that
the web.xml specifies a property directory instead of the
properties files themselves. Moving a new properties file into
the directory (which specifies a new tile set) and reloading the
servlet will load the new tileset or any changes. Update the
MapTileMaker to implement EmptyTileHandler, which allows
ommaptileservlet to generate tiles on the fly when they are
needed, caching them for later requests.
* Fix for Geo.azimuth(Geo) method, which provided incorrect
answsers moving away from the equator. Replaced with the
GreatCircle.sphericalAzimuth algorithm while taking advantage of
Geo's ellipsoid model.
* The com.bbn.openmap.dataAccess.shape package has some bug fixes,
including some addition null pointer exception checks, a fix for
off-by-one problem with extents, polyline/polygon M types being
incorrectly sent to the Z methods.
* WholeWorldTileHandler has improved source directory handling.
2013-11-25 dietrick <dietrick@client.wonkavision.local>
* Tagged OpenMap 5.0.3
* Added delete() method to FileUtils.
2013-11-24 dietrick <dietrick@client.wonkavision.local>
* OMGraphic interface has been updated with isRenderable, draw and
fill methods that take a Shape object as an argument. The old
implementation methods are no longer synchronized. For
BasicGeometry, the getShape() and setShape() methods are
synchronized and all instances of direct access to the shape
object have been replaced with calls to these methods. All render
methods in OMGraphic implementations have been updated to use one
getShape() call, and then use that handle to a shape for checks
and drawing. This greatly improves rendering performance. The
OMList implementations that build a single shape from parts have
been updated to have more efficient algorithms for building
* Updated the SimpleAnimationLayer for more control over the
sprites. You can set the number of sprites for a batch add, the
timer was changed to a java.util.Timer that uses a Task for
updating the sprites. The GUI was updated to use GridBagLayout
and has some new controls. Deleted the
com.bbn.openmap.graphicLoader.AnimationTester class, it was
* Updated LayersMenu to use an object lock for the layer with the
menu entries.
2013-11-12 dietrick <dietrick@client.wonkavision.local>
* Tagged OpenMap 5.0.2
* Created the MapTileRequester interface, which lets the
MapTileFactory ask it whether it should keep working. If
provided, the StandardMapTileFactory will use the requester as
tiles are fetched to determine if the tile group fetch is still
relevant. The MapTileRequester interface replaces the
MapTileFactory repaintCallback member variable.
* Reverted the Geo.intersect method to use the former algorithm.
The newer algorithm was faulty and broke code.
* Updated MapTileLayer to implement the mapTile MapTileRequestor
interface, which also uses the new wrapItUp flag discussed below.
The repaintCallback repaint() calls made in the MapTileFactory
were moved back into this layer, using the MapTileRequester
* Updated layer classes in the com.bbn.openmap.layer.test
package. The GeoIntersectionLayer was reformatted, and the
GeoTestLayer was restuctured to use more regular data.
* Added a boolean flag, wrapItUp, to the OMGraphicHandlerLayer.
Means something slightly different than interruptable. WrapItUp
gets set to true if another SwingWorker is queued to run, due to
another doPrepare() call or projection change. If interruptable
is set to true, the current SwingWorker is killed, and the state
of some things might be in flux. If a layer is marked as
uninterruptable to avoid this state of flux (think loading image
files), the wrapItUp flag lets the layer decide when to stop
working if it wishes.
* Added check to OMScalingRaster for lastProjection, so a clone of
the projection is only made if it changes.
* Added threading to FileUtils chooser methods, so if they aren't
called in the event thread they will still appear.
2013-08-19 dietrick <dietrick@client.wonkavision.local>
* Added the GoogleMapTileFactory as an example of how to extend
the MapTileFactory to contact different services. Added the
ability for MapTileLayer to display map data attribution.
2013-07-27 dietrick <dietrick@client.wonkavision.local>
* Moved default LINETYPE for shape files from GREAT_CIRLCE to
STRAIGHT. That should speed things up a bit.
* Added com.bbn.openmap.layer.learn.SimpleAnimationLayer, a little
tutorial example of doing animation on OpenMap. Borrows a lot for
the AnimationTester, which was also refreshed.
* Added OMGraphicHandler to the interfaces that
OMGraphicHandlerLayer implements. It used to implement that
interface, and should have been, obviously.
* Fixed off-by-one errors in the AreaHandler.
2013-07-03 dietrick <dietrick@client.wonkavision.local>
* Fixed some JavaDoc errors, added update to Gnomonic Projection.
2013-07-03 dietrick <dietrick@client.wonkavision.local>
* Released OpenMap 5.0.1
2013-06-19 dietrick <dietrick@client.wonkavision.local>
* Added NPE checks to BufferedImageRenderPolicy and OMScalingRaster.
* Added width acessors to OMText. Added Executor methods to
TaskService to allow customization and control for Layer
2013-05-20 dietrick <dietrick@client.wonkavision.local>
* Updates to OMScalingRaster to gracefully handle memory
exceptions if the scaled image is too big. Updated javadocs and
java comments in these classes, added Logger for ScaleFilterLayer.
* Refactored the LayerHandler so it uses a List<Layer> internally
to manage Layers. Created the LayerConfigurationListener interface
and LayerConfigurationListenerSupport object, both of which are
used by the LayerHandler to pre-notify components when the active
layers for the application are about to change. The
LayerConfigurationListener has the opportunity to make
modifications to the layer configuration, or change visibility of
other layers, etc. Added the BasicLayerConfigurationListener, an
example component that changes the projection of the MapBean to
CADRG if an RpfLayer is active.
2013-04-13 dietrick <dietrick@client.wonkavision.local>
* Cleaned up debugging. Updated LOS code API for better control.
Updated WMSPlugIn setProperties so the current values aren't
zeroed out of they aren't set.
2013-04-23 dietrick <dietrick@client.wonkavision.local>
* Moved the smarts for zoom levels out of the MapTileMaker class
and put them in the MapTileCoordinateTransform classes. Added
AbstractMapTileCoordinateTransform class to merge similar methods
and functionality for existing mtct classes. Updated other
classes to call mtc functions instead of MapTileMaker static
2013-04-16 dietrick <dietrick@client.wonkavision.local>
* Added RelayMapTileSet for MapTileServlet, which fetches tiles
from a remote server and caches them locally. Updated
TerrainLayer to eliminate some verbose error messages.
* Added Kevin's (kpfarr) fix to RpfTocHandler for merging entry
coverages properly.
2013-03-02 dietrick <dietrick@client.wonkavision.local>
* Added the ClckOrDrgUndefinedState to the omGraphics.editable
package, which is now the super class of LineUndefinedState,
RectUndefinedState and CircleUndefined state. Lines, Rects and
Circles can now be defined with a click and mouse move to next
point, or with a press and drag to the next point, just like
2013-03-01 dietrick <dietrick@client.wonkavision.local>
* Fixed the ImageTile outline behavior on projection changes.
Fixed bug in GeoTIFF code introduced via a FindBugs modification,
and tweaked the ImageTileLayer GUI to handle list selection
2013-02-28 dietrick <dietrick@client.wonkavision.local>
* Added some data/vpf vmaplv0 configuration files with more
instructions on how to use the VPFFeatureLayer.
* Fixed the VPF attribute fetching with proper indexes. The VPF
package api changed in a deep section, to allow the proper feature
id to be passed to the place where it's needed to fetch
* Added intersets method to DataBounds. Can be tested with new
BoundsTestLayer in layer.test package.
* Updated SwingWorker and PooledSwingWorker to use FutureTask
objects, reducing the number of threads that are created. Updated
OMGraphicHandlerLayer.workerComplete to take a ISwingWorker in its
* Modified DemoLayer to have separate OMGraphicList for storage,
loading aux OMGraphicList for painting.
2013-02-27 dietrick <dietrick@client.wonkavision.local>
* Made a bunch of adjustments as recommended by FindBug, regarding
null pointer checks, equality checks, stuff like that.
* Added AzimuthPanner abstract class with Standard and Shapefile
subclasses. This class is used by the PanMouseMode and
OMMouseMode for panning when the projection is Azimuthal. The
modes used to translate the map image, the new class renders
things instead. The AzimuthPanner.Standard is used if a shapefile
for the mousemode is not defined.
* Modified how the DrawingToolLayer tool buttons react to
toggling. Toggling the tool button will deactivate the drawing
tool, returning mouse control to the application.
* Updated the mapTile package, allowing the frames to be defined
by a regex that fits how to ask for tiles from a server or
directory location. Locations can include {x}{y}{z} where x,y,z
are x and y tile coordinates at z zoom level. This regex can be
defined as the rootDir of a MapTileLayer.
* Fixed the BeanBox example, since it was moved. Updated the
manifest.txt to remove outdated beans.
2012-01-27 dietrick <dietrick@client.wonkavision.local>
* Added the maptileservlet package. This servlet package provide
map tiles and can be used with the MapTileLayer using the
ServerMapTileFactory, and can also be easily be used with Leaflet.
* Misc updates to remove extra semi-colons and fixed some
compiling warnings.
* Modified OMArc to take a Point2D object instead of a
LatLonPoint. This allows it to be used with the Cartesian
* Modified WholeWorldTileHandler to have more control over how it
creates jar files holding map tiles. Can now create specific
subjars, control whether the master jar gets created, etc.
* Added TileMillMapTileFactory to
com.bbn.openmap.dataAccess.mapTile package, and also added the
sqlite jar to the ext directory. This MapTileFactory can read the
output tile database files created using the TileMill application.
* Tweaked the API, got rid of new Grey*TileFactory classes in the
com.bbn.openmap.dataAccess.mapTile package, created new
TileImagePreparer and added Grey and standard versions of that
instead. Now the StandardMapTileFactory and ServerMapTileFactory
can have different classes handing images, and those classes can
be swapped at runtime.
* Fixed build problems when ext directory was missing.
2011-12-23 Knox Rogers <krogers@Knoxs-MacBook-Pro.local>
* OpenMap 5.0 released
2011-12-06 dietrick <dietrick@client.wonkavision.local>
This entry is a summary of the changes made to OpenMap between the
4.6.5 release and the 5.0 release. The API has changed
significantly for the Projection classes, and that's the main
reason for the major version change.
The Projection classes used to translate decimal degree lat/lon
point objects to java.awt.Point x/y pixel coordinates. The new
Projection classes make translations using Point2D objects.
LatLonPoint has been moved inside the com.bbn.openmap.proj.coords
package, and now extends Point2D. The pixel locations returned
from the Projection are also Point2D objects. If you've written
any code that calls Projection methods, you may have to modify
that code to work with the changes.
Throughout the code, there have been changes to incorporate
Generic types, utilizing StringBuilder methods, moving from the
com.bbn.openmap.util.Debug class to the Java logging mechanism,
implementing equals() and hashcode() methods.
OM5 requires the Java 5 runtime.
* com.bbn.openmap
Updated BufferedMapBean to handle panning better, shifting current
map image appropriately until the layers react to the projection
The Layer class has been updated to have a GeoCoordTransformation
member variable, for data that isn't stored in decimal degree
lat/lon coordinates.
MapBean updated to have a handle on its ProjectionFactory.
Update the MapHandler class with generified methods.
Added the notion of isolation to the MapHandlerChild, so it will
ignore BeanContext events it receives from other BeanContext
objects that it doesn't know about.
Updated PropertyHandler so it's not tied to the file name.
Added a couple of new application-type classes. The Main
application represents the new OpenMap app look, and it utilizes
the new OverlayMapPanel.
The TimeFrameApp uses the HotwashPanel and some of the new time
management components.
Moved SimpleMap and SimpleMap2 here.
* com.bbn.openmap.dataAccess.cgm
Added components that all more sections of the CGM files to be
read, like constants, colormodel, colortable, marker
representation and marker size.
* com.bbn.openmap.dataAccess.mapTile
This new package deals with map image tiles, the kind that are
used in OpenStreetMap/Google/GDAL tiles, etc.
The MapTileFactory classes read tile sets for the MapTileLayer and
creates images for display on the map.
The StandardMapTileFactory reads tiles stored locally.
The ServerMapTileFactory can fetch tiles from a URL (where tiles
are stored under a root location plus z/x/y.png type location).
The ServerMapTileFactory will store the images it fetches locally
to reduce the load on the server. The
GreyStandard/ServerMapTileFactory classes convert the images to
The EmptyTileHandler classes tell the factory classes how to
handle missing tiles, whether to do nothing, create new tiles or
use a default tile to fill the area in.
The OpenStreetMap tiles are stored a little differently than tiles
that meet the TileMappingService configuration (like the tiles
GDAL creates). You can use the OSMMapTileCoordinateTransform for
OpenMap/OpenStreetMap tile sets, and the
TMSMapTileCoordinateTransform for GDAL image tile sets.
The MapTileMaker can create map tile sets from OpenMap layers.
The MapTileMakerComponent can be added to the OpenMap application
to visualy define and launch MapTileMaker tile creation.
* com.bbn.openmap.dataAccess.shape
Added a DbfTableModelFactory class that helps create DbfTableModel
for an EsriGraphicList when the data is read in.
Added ShapeGeoIndex, an ExtentIndex implementation created from a
shape file. This ExtentIndex can be used with the uses the
com.bbn.openmap.geo package components to discover intersections
with other extents (points, paths, regions, etc).
* com.bbn.openmap.event
Added two new sets of event objects. Added OMEvent class, which
is a object representing something that happens at a certain time.
The OMEvent class is accompanied by the OMEventComparator and
OMEventHandler, and some other components to aid in selection and
filtering of OMEvents. These component tie into the new
com.bbn.openmap.time components and TemporalOMGraphics.
Added Undo classes (UndoEvent, UndoStack, UndoStackSupport and
UndoStackTrigger). These components are currently used by the
drawing tool undo/redo capability, but can be used by any
component that wants to save and restore state.
Added the OMMouseMode, which is a combination of the PanMouseMode
and SelectionMouseMode. The behavior is similar to
standard/expected web map mouse behavior.
* com.bbn.openmap.examples
Removed this package. The beanbox example is now under
com.bbn.openmap.layer.beanbox. hello and crew packages were
obsolete, and the simple applications have been moved up to app.
* com.bbn.openmap.gui
Added the OverlayMapPanel, an extension of BasicMapPanel that
knows how to layer other components with the map so they appear as
if they are floating on it. The EmbeddedNavPanel and
EmbeddedScaleDisplayPanel are two components the OverlayMapPanel
uses. The DistQuickTool is used by the panel to quickly measure
distances on the map.
The HotwashPanel is a new BasicMapPanel that has sliders built
into it. It was created to house the new time controls and event
lists on the bottom and to the left.
The event subpackage contains components that manage and display
OMTime events.
* com.bbn.openmap.image.wms incorporated many changes from Tore
Haslet that added compatibility with WMS 1.3, including
capabilities queries and projection translations.
* com.bbn.openmap.layer.event
Added the EventLayer and supporting components. The EventLayer
handles TemporalOMGraphics and uses the new com.bbn.openmap.time
management components.
* com.bbn.openmap.layer.imageTile
Added the MapTileLayer. The layer uses the new
com.bbn.openmap.dataAccess.mapTile components to render
OpenStreetMap/GDAL/Google map tiles.
* com.bbn.openmap.layer
Updated OMGraphicHandlerLayer to utilize the new ISwingWorker classes.
* com.bbn.openmap.layer.policy
Added NullProjectionChangePolicy that does nothing when the
projection changes, and added the PanningImageRenderPolicy, to be
used by layers that want to redraw what they have when the
projection changes. A buffered image is reprojected and reused
until the layer can update for the new projection.
* com.bbn.openmap.layer.util
Added DataPathWanderer class, extending Wanderer, that finds valid
data paths for a data user. Base class for creating a data auto-finder.
* com.bbn.openmap.layer.vpf
Added VPFFeatureLayer and supporting classes. This layer uses
priorty files and GeoSym information/cgm files to order and render
features from VPF. New files added to share/data/vpf directory to
support DNC.
Added VPFFeatureInfoHandler that lets you get attribute
information for features. Configurable via properties. Can be
extended to display attribute in different ways. The
TTFeatureInfoHandler displays attributes in a tooltip.
* com.bbn.openmap.omGraphics
The OMGraphics have been updated to double precision.
OMGraphic is now an interface, with OMGraphicAdapter being the base class.
DrawingAttributes have new transfer methods that make it easier to
clone and copy settings. Added Builder class to make it easier to
make it more convenient to create and make settings on a new
Added GraphicUndefinedEditState to the editable subpackage, for
OMGraphics in the process of being defined by the drawing tool.
It's a state that defines when an OMGraphic is only partially
OMGraphicList and OMGeometryList extend OMList, which itself
implements the List interface. They are now iterable, and use
Generic Types to define what is held in them.
Added OMWarpingImage, which is a raster OMGraphicClass that warps
its image to the current OpenMap projection (during generate).
Added the time subpackage, which defines interfaces for OMGraphics
that change over time. TemporalOMPoint and TemporalOMScalingIcon
are two implementations of that interface.
Added ImageWarp class to the util subpackage, which does the
heaving lifting work of the OMWarpingImage.
Added RibbonMaker class to the util subpackage, which creates a
buffer area around a vector shape.
* com.bbn.openmap.proj
The proj package classes have undergone a significant API change,
as described in the summary above. For the top-level Proj class
and Projection interface, the Point references for projected
locations have been replaced with Point2D objects. The
LatLonPoint references have been replaced with Point2D references.
The old projection classes now extend the GeoProj class, and the
Point2D objects meant to indicate latitude/longitude points are
There is a Cartesian projection for standard X/Y drawing. You can
use the OMShape object for drawing things in a Cartiesian
projection. Other OMGraphics will work too, but the lat/lon
coordinates are interpreted as x/y coordinates.
Deleted the ProjectionFactoryLoader and the View classes. The
ProjectionFactory is no longer a singleton, there's a different
ProjectionFactory for each MapBean, and each MapBean can have a
different set of Projections it can handle.
* com.bbn.openmap.proj.coords
All of the coordinate point classes and methods have been moved
here, including LatLonPoint and VHTransform. Updates to GCT
LatLonPoint was rewritten to inherit from Point2D, and is modeled
after that class with Float and Double implementations. Note that
overridden Point2D methods have (x,y) signatures, while
LatLonPoint.setLocation(lat, lon) methods have (y, x) signatures.
* com.bbn.openmap.time
Created new time package, moved older time components here just to
make them more application-friendly. Added components that
understand the notion of time bounds and managing the notion of a
point in time.
Updated OMDrawingTool to use UndoStack and triggers to handle edit
undos and redos.
Added SVGSourceFileReorganizer, a class that takes the
distribution package from DISA and flattens the files out into a
target directory, renaming them as needed for the
* com.bbn.openmap.util package
Added AbstractXMLParser class, a base class for XML parsing, wraps
the DefaultHandler java class.
Added Attributable interface, describing classes that can handle
an attribute map.
Added ClasspathHacker, which adds jars to classpath at runtime.
Added MGRSCoordInfoFormatter, which formats coordinates into MGRS format.
DataBounds updated to use Point2D objects, add method added.
Added DeepCopyUtil, which handles cloning propery. OMGraphics updated to use it.
FileUtils updated to have new zip writing algorithm, methods.
Added HashCodeUtil to assist in creating proper hash code values.
Added ISwingWorker interface and updated OMGraphicHandlerLayer to
use it, so other implementions could be used in the layer. Added
PooledSwingWorker, implementing a reuseable SwingWorker. Added
TaskService to manage SwingWorkers.
PropUtils added methods to create objects from property
list (standard paradigm). parseColor method
returns a Paint object instead of a Color object.
Updated Wanderer class to be able to handle exhaustive and
non-exhaustive searches.
Moved former com.bbn.openmap.layer.util.http/html/stateMachine
packages to this util package.
2009-03-26 Don Dietrick <>
* Refined the DTED packages, removing duplicate classes in
com.bbn.openmap.layer.dted and having those classes refer to the
com.bbn.openmap.dataAccess.dted package contents. The
com.bbn.openmap.layer.dted.DTEDFrame has been changed to
DTEDSubframedFrame, and now extends the DTEDFrame class in
dataAccess.dted. The DTEDLayer is the main class in
com.bbn.openmap.layer.dted, and those classes use the
DTEDSubframedFrame. The
com.bbn.openmap.layer.dted.DTEDFrameCacheLayer uses the classes in
the com.bbn.openmap.dataAccess.dted package. The choice between
the two is memory usage (when DTED is used by other components it
can also be used by DTEDFrameCacheLayer) vs
speed (the DTEDLayer is faster).
2009-03-24 Don Dietrick <>
* Added com.bbn.openmap.omGraphics.util.ImageWarp, which takes an
image file and warps it to fit a given projection. Can be created
with a image path or BufferedImage, takes a DataBounds or
WorldFile object to specify where the image is, and also takes a
GeoCoordsTransformation to handle preprojected images. Also added
the com.bbn.openmap.omGraphic.OMWarpingImage that wraps around an
ImageWarp object to display the image on the map as an OMGraphic.
* Modified the DataBounds object to provide height and width
calculations (deltas between max and mix), and can also have an
internal DataBounds object that serves as hard limits for added
values. The hard limits override any point values that may be
* Simplified the OMApplet.html file, with simple APPLET tags.
* Removed com.bbn.openmap.LatLonPoint. The
com.bbn.openmap.proj.coords.LatLonPoint is the class to use now.
* Fixed problem where the ProjectionSupport thread continued to
run, preventing garbage collection of the MapPanel and all its
contents. That thread gets interrupted when the MapBean is
disposed. Added dispose() methods on MapPanel, MapBean,
ProjectionSupport, OpenMapFrame that release objects. Dispose
should be called on the MapHandler, and when OMComponents detect
they have been removed from the MapHandler in their findAndUndo
method, they should call dispose() on themselves if they have that
* The ProjectionFactory is no longer a singleton. A
ProjectionFactory is expected to be placed in a MapHandler, where
it will attach itself to the MapBean and can be accessed through
the MapBean. If a ProjectionFactory is not set and requested from
the MapBean, the MapBean will create a ProjectionFactory with the
default set of ProjectionLoaders. The ProjectionFactoryLoader
class has been removed, and that functionality (creating
ProjectionLoaders from Properties) has been incorporated into the
ProjectionFactory. The ProjectionFactory should be created like
any other component added to the MapHandler, via the properties or
programmatically added to the MapHandler.
2009-03-14 Don Dietrick <dietrick@wonkavision.local>
* OpenMap 5.0 released as beta via SVN repository. All further
changes will apply to version 5.0. OpenMap 5.0 requires Java 5
(jre 1.5.x).
* The com.bbn.openmap.proj.coords.LatLonPoint has been created
and it extends java.awt.Point2D. You can instantiate
LatLonPoint.Double and LatLonPoint.Float classes, just like
Point2D. Note that the Point2D methods follow the x, y ordering
of arguments, but that the setLocation() methods of LatLonPoint
follow the lat, lon ordering. The old LatLonPoint currently
extends the new LatLonPoint.Float object.
* The Proj/Projection class and interface are now based on
java.awt.Point2D objects. The GeoProj class extends Projection,
and Point2D objects in coordinate space are now LatLonPoints as
allowed with Generics. The Cartesian projection handles projected
* The OMShape object is added to handle cartesian shapes, taking
java.awt.Shape objects and managed as an OMGraphic.
2009-03-05 Don Dietrick <dietrick@wonkavision.local>
* OpenMap 4.6.5 released.
2009-02-27 Don Dietrick <dietrick@wonkavision.local>
* The CSVTokenizer was updated to properly handle empty fields in
front and end of lines.
* The projection package was updated with the DatumShiftProjection
which wraps projections to provide datum shifting. The
CoordinateReferenceSystem has been updated to use new
GeoCoordTransformation objects for different projection types.
* For OMGraphics, the EditableOMPoly, OMGraphicList and OMText all
had minor bug fixes. Polygons are now re-editable after colors
are modified, OMGraphicLists had selection problems patched, and
OMText FontSizer setter was fixed.
* MapHandler was modified with an overriding remove method that
also checks to see if an object being removed was a
BeanContextMembershipListener. The parent class was adding such
objects to a special list when they were added, but not removing
them from that list when they were removed from the context. This
was causing a memory leak of sorts.
* Added MapBean.dispose() method, which cleans up the projection
support thread and releases lingering handles on layer objects.
ProjectionSupport also has dispose() method that is called to
clean up.
* Layer.setProperties() functionality was broken out to a
setLayerProperties() method so subclasses could override
setProperties() and still get to to the superclass functionality
if desired.
* Updated the ShapeLayer and package. The SpatialIndex no longer
needs to be defined, it will be found or made next to the shape
file. The dbf file will automatically be used if found, and the
DbfFile rule handling was improved. All of the various Shape
layers in the com.bbn.openmap.layer.shape package were update to
work using the same EsriGraphicFactory mechanisms.
* BinaryFile modified with improved name handling for
FileInputReader, separating absolute path and file name queries.
ByteArrayInputReader added to allow BinaryFile to contain entire
file in memory.
* WMS package updated to have capabilies query handling, improved
layer control and new SRS handling. The WMSPlugIn was updated to
WMS version 1.1.1 and has better query handling.
* Added method to ConvexHull to allow for tolerances when trying
to determine equal points to reduce the number of unnecessary
points in the resulting polygon.
* Added the CoordInfoFormatter and CoordInfoFormatHandler to make
it easier to define how coordinates were displayed in the
InformationDelegator from CoordMouseModes.
* Updated dbf attribute type handing and handling of null cells.
Padding with spaces instead of null characters.
2008-02-29 Don Dietrick <>
* OpenMap 4.6.4 released.
2008-02-27 Don Dietrick <>
* Updated the PropertyHandler to have its own property prefix. This
property prefix is used by the PropertyHandler when it looks for a
properties file, and when it looks inside the properties file for
application level properties, like the components list, include
files, and the configuration directory. Where the PropertyHandler
used to only be able to look for an file that
contained an openmap.components property, you can now define a
different prefix for the file and property.
* The com.bbn.openmap.util.propertyEditor.Inspector was updated to
provide a simple GUI that can be inserted on behalf of a
PropertyConsumer, without providing window controls, etc. It can
be used just to provide the widgets for the PropertyConsumer
The DrawingAttributesPropertyEditor was created as an example of
creating a property editor widget that can control multiple
properties in a single GUI widget.
* The com.bbn.openmap.util.cacheHandler package was added,
allowing for a more generic caching mechanism than was provided by
the com.bbn.openmap.layer.util.cacheHandler package.
* The GeoCoordTransformation interface was added, providing a
mechanism that allows transformations from pre-projected
coordinates into lat/lon space. The
com.bbn.openmap.dataAccess.shape classes can use the
GeoCoordTransformation objects in order to display pre-projected
shape data. Several GCTs have been implemented, including
LatLonGCT, MercatorGCT, UTMGCT. A CoordinateReferenceSystem
object also uses the GCTs, and assists the WMS server code in
handling requests.
The MGRSPoint was updated to handle zone letters correctly,
instead of defaulting to UTM values.
* UTMProjection added.
* OMGraphic improvements:
- OMEllipses with XY and OFFSET rendertypes were added.
- OMGraphicHash was added.
- OMTextLabeler was updated to handle different anchor locations.
- OMPoint.Image class was added, an OMPoint that uses an Image to
mark the location. The image does not change size with respect to
map scale, as the OMScalingIcon does.
- OMGraphicList findAll() method fixed when inner vague lists were
- The EditableOMGraphic GUIs for Text and Range Rings were updated
to have better persistence across different OMGraphics.
- The DrawingAttributes GUI, including the color settings, was
moved into the pop-up menu, replacing all of the buttons. Just
the stroke button remains, and the colors on that button adjust
according to the DrawingAttributes settings.
* The DrawingToolLauncher GUI was updated to handle the
DrawingAttributes GUI changes.
* The VPFConfig class was modified to maintain knowledge of
current features set on a VPFLayer that it is modifying.
* The RPF Layer code was improved. The RPFCacheHandler was
modified to reduce the number of bytes utilized in the cache
tracking mechanism, which greatly decreases memory usage for large
datasets. The RPFFrameEntry was modified to use fewer bytes for
file name storage, also saving memory for large datasets.
The RPFLayer was modified to use the OMGraphicHandlerLayer's
transparency mechanism, replacing the colortable mechanism that
was in place.
* The Link Protocol has been updated to version 0.5, with a
greatly reduced transmission footprint by making all of the field
headers one or two characters long. A cache mechanism was added
to the protocol and on the client Java code that allows values
sent previously to be reused for later graphics.
* Added com.bbn.openmap.layer.learn package, to hold layers that
serve as examples for specific capabilities. BasicLayer and
InteractionLayer added.
* OMGraphicHandlerLayer has improved SwingWorker threading
support, including the interruption mechanism and thread locking.
Transparency can now be set on any OMGraphicHandlerLayer, and
there is a GUI widget available that can be added to any palette.
* The DrawingToolLayer has improved file support, including
reading from multiple shape files to reproduce previous savings.
* The DeclutterMatrix has improved access to a java.awt.Graphics
object that prevents locking during multi-threaded access.
* The handles reopening files
that have been closed. The BinaryFile and BinaryBufferedFile can
now read unsigned shorts upon request.
* The com.bbn.openmap.image.wms package adds much better WMS
support, including handling GetCapabilities requests.
* The com.bbn.openmap.image.ImageScaler class was added, providing
better image scaling performance in the AbstractImageFormatter and
ImageFormatters now provide their content type for web delivery.
The ColorReducer class provides support for color reduction in
images, and the PNG32ImageFormatter and PNG8ImageFormatter was
The WMS servlet was updated to handle the new web mapping server
support code.
* WindowSupport windows no longer shrink when it they are
repeatedly brought up. This fix affects the OverviewMapHandler,
LayersPanel, CoordPanel, Layer palettes, etc.
* The CoordPanel was updated to use WindowSupport, replacing the
CoordDialog and CoordInternalFrame.
* The new GeoArray object was created to improve memory management
and performance for the com.bbn.openmap.geo package components.
The ConvexHull and RadialRegion classes were also added to the
* The ProjectionSupport threading model was improved, adding a
more robust threading lock mechanism during projection change
* The PanMouseMode image management and projection handling was
* The AbstractMouseMode (affecting all mouse modes) has better
support for defining custom cursors and icons. Support for
specifying the zoom direction to mouse wheel relationship was
* The com.bbn.openmap.dataAccess.shape package was updated to add
support for all Shape types. The EsriGraphicFactory class now
creates EsriGraphics from files and streams, and both the
com.bbn.openmap.plugin.esri and com.bbn.openmap.layer.shape
componets use this com.bbn.openmap.dataAccess.shape package. The
DbfFile class was created to allow better handling of dbf files,
providing a way to limit what fields are read out of a file and
kept in memory. The DbfHandler class was created to manage
EsriGraphics and their rendering attributes/labels/tooltips/info
based on the dbf file contents. The DbfHandler class lets you set
rules for dbf file contents so you can draw map objects different
based on attribute values. The ShapeLayer was updated to use this
* iso8211 package had some bug fixes related to the DDFSubfields
and definitions.
* MapBean was updated to support ProjectionChangeVetoExceptions,
so that layers or other components can now limit what a projection
can change to.
* LayerHandler can now have it's own prefix to be used to define
layers in the properties file. Previously, the LayerHandler
looked for an 'openmap.layers' property for its layer list. While
'openmap.layers' still works, it now looks for a
'<markername>.layers' property first, where <markername> is the
keyword used to define the LayerHandler object instance in the
'openmap.components' property, or whatever Property prefix the
LayerHandler is given in the setProperties(...) method.
The LayerHandler was also updated to handle background layers
better, so that background layers show up at the bottom of layer
* Layer has hasGUI() can let component know if a GUI is available.
The LayerPanels use this to disable their palette icons if a GUI
is not available for a particular layer.
* LatLonPoint has been updated to contain many more functions to
assist with determining relationships with other
LatLonPoints (distance, etc).
* Added I18 supports for many more GUI components. This effort is
* Added support for GeoTIFF and geocoded images via the
com.bbn.openmap.dataAccess.image package. This support is for
images that are in a equal-arc WGS84 decimal degree projection.
Relies on the JAI package being available on the host system. The
ImageTile class is a subclass of OMScalingRaster that handles the
display of these files. GeoTIFFs with embedded projection
information are handled, as well as other image formats with world
files. The com.bbn.openmap.layer.imageTile.ImageTileLayer is a
layer that handles the display of ImageTiles, and serves as an
example of how to use the new com.bbbn.openmap.dataAccess.image
2006-02-14 Don Dietrick <>
* Updated LayerHandler to manage layers in the MapHandler better.
Layers will only be added to the MapHandler if they don't know
about it already. Also, calling LayerHandler.init(Layer[]) has
been updated to check to see if Layers are removable, and honors
that setting. Non-removable layers will be added to the bottom of
the layer stack as the new layers are added. These layers will
also be added to the MapHandler as needed, where they previously
weren't. This fixes the bug where layers added to the application
as a result of loading a new properties file weren't being added
to the MapHandler.
* Updated BeanContextPlugIn to remove itself from the
BeanContext/MapHandler when it sees its own PlugIn layer being
removed. Made EsriPlugIn extend BeanContextPlugIn instead of
AbstractPlugIn. Cleaned up how DataBoundsProviders were handled
as they were removed from the MapHandler. PlugIns weren't being
removed properly.
* Added an attribute Hashtable to Layer.
* Updated the MapRequestHandler and ImageServer classes to handle
background Paints better. Map requests coming through the
MapRequestHandler no longer set the default background color, and
the ImageServer API has createImage(...) methods added to allow
the passing in of background Paint objects to be used for an
image. The background color can be set in the properties.
* Updated WindowSupport to have WSDisplay inner classes that
handle the differences between showing components in JFrames,
JDialogs and JInternalFrames. Components can specify which kind
of WSDisplay they wish to use when the create their WindowSupport
object, or they can let the WindowSupport object create the
default version for them. If the Environment.useInternalFrames
flag is set, then JDialogs will be used for components that don't
specify which WSDisplays to use. If the Environment flag is not
set, then the WindowSupport.defaultWindowSupportDisplayType static
member variable dictates what kind of window will be created.
Although the JFrame class is the default, there are accessors to
change that setting (WindowSupport.Frm.class,
WindowSupport.Dlg.class or WindowSupport.IntrnlFrm.class)
to suit your application.
2006-02-01 Bill Mackiewicz <>
* OpenMap 4.6.3 released.
2006-01-24 Don Dietrick <>
* Updated the ElevationBandGenerator in the
com.bbn.openmap.omGraphics.grid package, adding the loader and
ColorGeneratorLoader for it.
* Updated the CSVTiledImagePlugIn to use
FileCacheImageInputStreams to create BufferedImages, instead of
ImageIcons. This is in an effort to reduce memory usage for tiled
* Updated the com.bbn.openmap.util.FileUtils object for better
options presented to the user, as well as methods that copy files
and zip/unzip files.
* Updated the Directory and File property editors to provide
better control over the options offered to the user.
* Added com.bbn.openmap.omGraphics.OMAbstractLine, which is now
the superclass of OMLine and OMPoly. Arrowheads were moved up to
this class, so polylines can now have arrowheads attached.
There's an editable version as well.
* EditableOMRangeRings were updated to estimate how may rings they
should have when changing units in the GUI. It used to maintain
the number it had, which could result in it being overwhelmed with
the new settings. Now it behaves as expected.
* Added bold and italic buttons to EditableOMText GUI.
* OMArrowHead was updated to allow more parameters to be chosen by
subclasses, making it easier to customize.
* Updated the OMGraphic serialization methods to handle strokes
* OMGraphicList.findAll(...) method lets you give an x,y pixel point on
the map, and retrieve all of the OMGraphics under that point
within the provided pixel range.
* Added a Text Matte Color and Stroke, which, if set, will outline
the text characters with a matting rendered with that stroke.
* Updated the com.bbn.openmap.layer.vpf.VMAP2Shape class to use
the com.bbn.openmap.dataAccess.shape components to create shape
* Set LayerUtils to be deprecated, you should use PropUtils
instead. The OpenMap components have been so updated. PropUtils
was updated to have all the same methods as LayerUtils did, with
some new ones including one that will set the proper
internationalized strings (setI18NPropertyInfo(...)) for the
getPropertyInfo() call of a PropertyConsumer.
* Added the RpfUtil class, which allows you to modify
(copy/delete/move) RPF data from RPF directories with filters that
let you specify scale, chart type, or location.
* Added Composites to the RenderPolicy API in
com.bbn.openmap.layer.policy. This allows the addition of
Composites to be added to a render policy to modify the rendering
process for that layer. You can add an AlphaComposite to a layer
this way in order to get it rendered with transparency.
* Updated AbstractLocationHandler to hold DrawingAttributes object
for names and location markers, instead of just holding a Color
for each. The Property GUI hasn't been updated yet, so the old
Color GUI still works. Added LocationHandler.NamePropertyPrefix
and LocationHandler.LocationPropertyPrefix to allow scoping for
"Fixed" the CSVLinkHandler, meaning that it works, but still needs
more work to be fully functional with property settings and
different rendering effects for lines and endpoints.
Updated CSVLocationHandler to have methods that can be overridden
when dealing with tokens and newly read info from the CSV file.
* Updated the DTEDLayer minScale property code to set the new
Layer maxScale member variable, keeping with the meaning of the
Layer's version. Removed the DTEDLayer's minScale property and
supporting methods.
* Added OMGraphicHandlerLayer.createLayerWorker() method to make
it easier to override and set customized LayerWorkers (threading
mechanism for layer work).
* Removed restriction from BinaryFile that caused it to check for
an "http://" lead on URLs.
* Added the MagicPlanetImageComponent to the com.bbn.openmap.image
package. The MagicPlanet is a spherical display system (get more
information at By adding this
component to an OpenMap application, images suitable for display
on the MagicPlanet can be created, at varing intervals and
resolution settings. The MagicPlanet's StoryTeller software can
then be told where the images are stored, and can then manage the
* Updated the AbstractImageFormatter to reset an existing
projection back on a layer after the formatter has used it to
create a image. This should help for situations where an active
map window wasn't behaving properly after being saved to a file.
Removed the AcmeJPEG* code, it didn't work and the Sun version
should be used instead.
* Updated the ScenarioGraphicLoader so that the mode settings are
more obvious, instead of being changing depending on the clock
* Updated the com.bbn.openmap.geo package, which now has the
capability to do spatial intersection and proximity analysis in
lat/lon space. The ExtentIndex (and ExtentIndexImpl) contain
collections of GeoExtents which may be queried for intersection by
other GeoExtents. The Ribbon object is an attempt at rendering
spatial areas around GeoExtents.
The com.bbn.openmap.layer.test.GeoIntersectionLayer is an example
of how to use the ExtentIndex. That layer loads shape files into
the ExtentIndex, and then lets you draw on the map to test how the
drawn objects intersect with the shape file objects.
2006-01-23 Don Dietrick <>
* Updated the com.bbn.openmap.dataAccess.shape package so its
components use the attributes of OMGraphics instead of using the
OMGraphic appObject directly. The DbfTableModel might be stored
in the EsriGraphicList's DBF_ATTRIBUTE key. In each of the
EsriGraphics, the index is stored under that EsriGraphic's
SHAPE_INDEX_ATTRIBUTE. Updated DBF output to put numbers in
English locale number format.
* Added the DTEDFrameACC object to the
com.bbn.openmap.dataAccess.dted package and DTEDFrame, to hold
DTED accuracy attribute information. This class was submitted by
Matt Revelle.
* Made the MouseModes MouseWheelListeners, and made the default
action for the OpenMap MapMouseModes to control zooming over the
* Added minScale and maxScale properties for layers, which hold
onto scale settings that the layer can use to determine if it
should react to a projection or not. Also added an Icon member
variable to the Layer. Note that the Layer doesn't actually use
the minScale and maxScale parameters, that's up to the Layer
subclass authors.
* Removed Makefiles, now that ant is the official build mechanism.
2005-05-24 Don Dietrick <>
* Refactored the FilePropertyEditor so it includes an uneditable
text area, and added callback methods for settings that all the
other file-related PropertyEditors use now. Justified the
ColorPropertyEditor and choice PropertyEditor widgets to the left
instead of centered.
2005-05-23 Don Dietrick <>
* ComponentFactory updated to contain a singleton instance, and
the static methods have been updated to use that singleton
instance. This makes it possible to change the behavior of the
ComponentFactory by setting a subclass as the singleton. The
PropUtils.createObjectFromProperties(...) method now calls the
ComponentFactory.create(...) method.
* Fixed the BasicGeometry attribute handling where the first
attribute being set was being stomped on and deleted when
subsequent attributes were added.
* Updated DrawingAttributes so it doesn't create a
BasicStrokeEditor when the stroke is being set, for those times
when a display is not available. Property output for colors now
in hex strings. OMGraphic uses static BASIC_STROKE object for
default strokes, instead of creating new object.
* Updated VPF FeatureDrawingAttributes to set String constants
when display type is set, added null checks when GUI is reset.
Fixed problem for initial settings for attribute display via
properties file.
* Added null check in ESRIPolygonRecor/ESRIPointRectord for
DrawingAttributes being set, made SpatialIndex a Closable object.
Added the connectParts() call to OMAreaList for handing holes, but
that code section still isn't active by default due to problems
with OMAreaList and very large objects.
* Updated MIFLayer to be able to read files specified as
resources, files or URLs.
* Updated Location object to have more specific
shouldRenderName(...) and shouldRenderLocation(...) methods, these
methods make it easier for subclasses to determine/control when
those parts should be drawn.
* Updated the DrawingToolLayer to have an option-filled GUI that
allows the saving and loading of a serialized OMGraphicList
to/from a file, as well as saving the properties for the layer.
Shape layer creation is also an option.
* Updated the layer ordering in the Crew and SimpleMap2 examples.
* Updated DTEDFrame and RpfFrame to call close on its file handle.
* Updated InformationDelegator to use the Environment Desktop for
internal frames.
2005-02-15 Donald Dietrick <>
* Released OpenMap 4.6.2
2005-02-15 Donald Dietrick <>
* Added the cntry02 world boundary shape files to the package and
made them the default files used in the OpenMap application.
They're bigger files, and the application runs a little slower,
but they are much more accurate than the dcwpo-browse files. The
dcwpo-browse files are still available if the old data is desired.
2005-02-11 Donald Dietrick <>
* Updated many classes for internationalization, with help from
Piotr Kaminski and Jesper Berglund.
* Updated the RpfLayer so the opaque slider works on the coverage
rectangles as well as the images. Updated the palette to enable
the modification of preference settings. Updated the MakeToc to
better check for non-RPF image files to skip them when appropriate.
* Updated FileUtils to have separate save and open methods,
updated different classes in the package to call them
* Updated the BasicI8n class so it can provide a set of
ResourceBundle properties files that can be used to
internationalize an application. If the 'i18n.create' Debug flag
is set (with a -Ddebug.i18n.create OpenMap application flag, or
by calling Debug.put("i18n.create") somewhere at the very
beginning of an application), the BasicI18n class will log all
the resource bundle properties files accessed or attempted to be
accessed, and will track the retrieved strings or their defaults
provided to the application GUI. If requested, the BasicI8n
class can create a hierarchy of I18N_<locale>.properties files in
the correct directory structure of the requesting application,
filled with key-value pairs where the values can be replaced with
language-appropriate translations for the given locale. If the
application is run with the 'i18n.default' flag also set, then files will be created without the locale
setting. Added the I18nFileCreateMenuItem that will tell the
BasicI18n class to create the new files. The
file was updated to show how to load the menu item to a generic
OMBasicMenu in order to temporarily add this class.
2005-01-10 Donald Dietrick <>
* Updated the
package, specifically, the SymbolReferenceLibrary and the
SymbolChooser, which can now create icon symbols given the
proper data source. The SymbolChooser now updates the symbol
code based on option settings, and the SymbolReferenceLibrary
uses a SymbolImageMaker to decide how to make a image based on
that code. The SVGSymbolImageMaker can use the SVG symbol
library available from DISA, and also requires the Batik
package from The
PNGSymbolImageMaker and GIFSymbolImageMaker
will create scaled icons from a gif file selection.
* Added labeling capabilties to OMGraphics, handled by their
attribute capabilities. If the OMGraphicConstants.LABEL attribute
is set with an OMLabel object (the OMTextLabel is one
implementation), labels will appear on the map for an OMGraphic.
Added OMGraphicConstants.TOOLTIP and OMGraphicConstants.INFOLINE
constants, too, that can be used by layers to look up these kind
of attributes in an OMGraphic. The VPFLayer now looks for these
attributes for it's display.
* Updated the StandardMapMouseInterpreter to handle right mouse
button clicks better, by trapping the popup trigger.
* Updated VPF package components to provide access to feature
attribute information, which can be displayed via tooltip,
information line, or label on the map. The choice of display
type and attribute type can be specified in the layer's palette
and/or properties. The VPFLayer's 'searchByFeatures' property
must be set to true for this capability.
* Added ImageIOFormatter class, a super class for creating image
files via the java imageio package. Added GIF and PNG
* Moved the LayerHandler threading support to the LayerSupport
object that also performs some queueing capability, so that the
threads lauched form layers changes are performed in order to
preserve stability.
2004-11-25 Donald Dietrick <>
* Modified the ProjectionSupport and LayerHandler to launch
threads for projection notifications to the layers and for layer
reordering, to prevent the application from getting hung up for
some of the more extensive notification event reactions.
* Updated VMAP2Shape to use EsriShapeExport class, instead of
using the Shape package stuff. Updated VPFConfig to check for
backslashes and replace them with Java-friendly forward slashes.
* Modified the ESRIPolygonRecord to include the donated code to
handle polygon holes using OMAreaList. This code is disabled,
however, because OMAreaList doesn't really handle shapes that go
around the earth yet, and having this modification breaks
world-level shapefile display. OMAreaList needs to be fixed
before this code is enabled full-time.
* Updated BasicGeometry to have the option of connecting shapes
that are appended, instead of automatically not doing that.
Updated OMAreaList to make that BasicGeometry append call with
the connect parameter.
2004-11-01 Donald Dietrick <>
* Released OpenMap 4.6.1
2004-10-15 Donald Dietrick <>
* Changed OMGrid to extend OMGraphicList instead of OMGraphic.
This provides better access to the OMGraphics that the
OMGridGenerator creates. If that access is not wanted, just set
the OMGrid (OMGraphicList) to be vague.
2004-10-05 Donald Dietrick <>
* Updated the SwingWorker to match the latest version from Sun.
* Added LambertConformalConic projection, along with it's loader
that has properties to let it describe the LCC attributes it will
create. You create a loader in the properties for a specific
state plane or other LCC definition, and that shows up as an
option to the ProjectionFactory.
* Updated the decorated OMGraphic parts, adding a circle
decoration and some weather notations. Added editable
OMScalingRaster code, submitted by Dan Bitts. Fixed FontSizer.
Added callouts to FilterSupport to handle actions on OMGraphics
that pass and fail the filter. Fixed transparency handling in
OMRaster. Updated rotation handling in OMRasterObject. Added
accessors to OMScalingRaster to get display corners. Updated
OMText so rotated text factored into distance() correctly.
* Modified LayerHandler to add layers to top of stack, if their
position is undefined.
* Update VPF components. Added feature type sublists to
warehouse support, to better control display of different feature
* Fixed MakeToc from the RPF package, it was writing bad A.TOC
files. Updated RPF coverage tools. Modified RpfFrame to check
for lower case file names if upper case isn't found, and also to
check for full pathnames when the frame is actually loaded,
instead of when the layer was created, which was really expensive.
* Modifed BufferedImageRenderPolicy to extend
RenderingHintsRenderPolicy, so buffered image could be
anti-aliased if needed.
* Modified how the OMGraphicHandlerLayer handles/locks the
SwingWorker during updates, and how it cleans up if the
SwingWorker gets interrupted. Removed synchronization notation
from some methods. Added new GRP capability to handle events
over the map.
* Fixed Location bug with label rendering.
* Modified DTEDCoverageLayer to extend OMGraphicHandlerLayer.
* Updated BufferedLayer to properly handle BeanContext with its
sub-layers, as well as responding to getProperties(). Updated
ScaleFilterLayer as well.
* Added methods to LatLonPoint that call GreatCircle class to
calculate distance/azimuth to another LatLonPoint, or to find a
LatLonPont a distance and azimuth away from the current point.
* Updated the LayersPanel initialization with the
* Added method to ProjectionFactory to let it provide the default
projection set with the Environment projection parameters.
Updated the BasicMapPanel and ImageServer/MapRequestHandler to
use that method.
* Added the com.bbn.openmap.util.FileUtils class that has a
static method for asking for a file from the user, using a JFileChooser.
* Added a save capability
com.bbn.openmap.dataAccess.shape.DbfTableModel when it's run
directly on a .dbf file. The save option was also added, enabled
with a behavior mask setting.
* Updated the com.bbn.openmap.dataAccess.dted components to be
able to handle .dt2 files.
2004-05-24 Donald Dietrick <>
* Added the OptionPropertyEditor, a base class used for
presenting properties with a limited number of choices. These
options are defined in properties, which is why the
PropertyConsumerPropertyEditor was written as the superclass.
The ComboBoxPropertyEditor is the first implementation of the
OptionPropertyEditor, using a JComboBox to display the choices.
The ColorPropertyEditor was modified to use the DrawingAttributes
fill paint button to display the color choice in addition to
showing the hex representation. The Inspector was modified to
handle PropertyConsumerPropertyEditors.
2004-05-14 Donald Dietrick <>
* Modified the ProjectionFactory to dynamically manage
projections. This involved changing the ProjectionFactory from a
class containing static methods that accessed hard-coded classes
to a singleton instance that uses the MapHandler to gather
ProjectionLoaders that it uses to create Projection objects. A
BasicProjectionLoader class has been written implementing the
ProjectionLoader interface, and 5 ProjectionLoader classes have
been written extending BasicProjectionLoader that create the
Mercator, CADRG, Orthographic, LLXY and Gnomonic projections.
The ProjectionFactoryLoader class has been written to be added to
the openmap.components property in order to put the
ProjectionFactory instance into the MapHandler. It can also be
used to define the properties for ProjectionLoaders, although
ProjectionLoaders can also be added directly to the MapHandler as
Because the change to might catch some people
by surprise, particularly those who use their own file, the BasicMapPanel has been modified to
check the MapHandler to see if a ProjectionFactory has been added
to it. If a ProjectionFactory cannot be found, the singleton
instance is automatically added with the default set of
Lastly, the Projection property defined in the
file has to be a class name, instead of a nickname of one of the
projection classes. Some available class names have been added to
the comments next to that property, and the
BasicMapPanel has been configured to complain about using the old
* Added methods to ComponentFactory so that those methods that
created components from a list of marker names and a set of
properties could be provided a prefix to place in front of the
marker name and its properties.
* Moved/Added I18n handle to OMComponent, OMComponentPanel and
AbstractOpenMapMenu, to make I18n easier to implement.
* Modified when/how tooltips are cleared and reset in the
2004-05-10 Donald Dietrick <>
* Modified the StandardPCPolicy so that has the option to be told
to always spawn a thread when a projection is received. It used
to use the number of OMGraphics on it's current list to determine
if that should happen, but that caused problems if the one
OMGraphic created took a while to create. You can pass the new
flag in a constructor, or set it later.
* Modified how PlugInLayer handles plugin with the BeanContext,
so PlugIns added to the layer at a later time still get to work
with the BeanContext.
* Added the com.bbn.openmap.dataAccess.iso8211 package that
provides support for reading ISO 8211 data files. Also added the
com.bbn.openmap.dataAccess.asrp package that reads ASRP image
data. ASRP images can be displayed using the
* Added attribute mechanism to OMGeometry/OMGraphic objects. The
attributes are stored in a hashtable in the app object of the
OMGeometry/OMGraphic and can be retrieved with new methods. The
code has been written to work with the possibility of other code
still using the setAppObject and getAppObject methods, as the app
object set as in older versions of OpenMap is now stored as an
attribute when other attributes are added. This should be
seamless to anybody that is currently using the app object.
* Created MapBeanPrinterMenuItem and added it to the FileMenu.
* Modified the BasicMapPanel so the empty constructor doesn't
create a PropertyHandler that will search for an file and fill the application with it. The
basic BasicMapHandler will create a MapHandler and
BufferedLayerMapBean, and an empty PropertyHandler. To create a
BasicMapPanel that does look for an file,
create a PropertyHandler with an empty constructor and pass it to
the BasicMapPanel.
* Added I18 contributions to gui package from Mirek Pawlowski.
* Modified the GestureResponsePolicy interface, adding the
receivesMapEvents(), mouseOver() and leftClick() methods so the
policy could receive information about mouse events that were
occuring over the background map and not over its OMGraphics. The
latter two methods only get called when the first returns true.
Modified the StandardMapMouseInterpreter to use these methods.
Modified the OMGraphicHandlerLayer to not do anything when these
methods were called.
* Added Piotr Kaminski's RhumbCalculator class that computes the
lengths of Rhumb lines.
2004-04-16 Bill Mackiewicz <>
* Replaced ext/jakarta-ant-1.5.1/ with ext/apache-ant-1.6.1/
2004-02-13 Don Dietrick <>
* Added Gordon Vidaver's route calculation package (originally
derived from Ray Tomlinson's code)
(, along with two layers that
provide routes based on the OMGraphics created from their data
sources (com.bbn.openmap.layer.shape.MultiRoadLayer and
2004-02-11 Bill Mackiewicz <>
* OpenMap 4.6 released.
2004-02-09 Don Dietrick <dietrick@jade.local>
* Fixed the problem in OMColorChooser where the preview panel
wasn't showing up in jdk 1.4.2.
* Added properties in DrawingAttributes that set the pixel radius
and oval settings of OMPoints when setTo(OMPoint) is called.
* Modified the MapHandler to contain a mechanism for handing the
addition of new components while the membership list is being
iterated over by another component. If a component using the
membership iterator adds something to the MapHandler as a result
of finding something in it, the new addition will be saved by
the MapHandler and added later, preventing a
ConcurrentModificationException from being thrown.
* Modified the MapBeans to set the clipping area (if null), and
drawing buffers, to the size of the projection, instead of the
MapBean. Usually these are the same, but just in case someone
wants to try to do something with the projection definitions, it
should work better. Since JComponents (Layer superclass) will set
clipping areas to the size of the component if they are set to be
larger, you may have to set the FullProjectionRenderPolicy in the
layers in order to get them to draw fully into the projection
area if it's bigger than the MapBean.
* The I18n interface was added, replacing an I18n class that
wasn't used. This interface describes a object that provides
localized strings based on the requesting class, component
descriptor with optional modifier, and a default string. The
BasicI18n class, which implements the I18n interface, was added
as the base implementation of localization in OpenMap. The
Environment class was modified to provide the current I18n
application instance to components at runtime. Several
properties files for different packages were added to the
distribution, as well as some Polish localized properties files.
Many thanks to Piotr Kaminski and Mirek Pawlowski for helping us
work out the Internationalization mechanism and providing
modified classes and Polish property files.
* Modified the com.bbn.openmap.SoloMapComponent interface so it
has a canAdd() method, to be asked if a component can be added.
This makes it easier to change the behavior of SoloMapComponent
objects by overriding one method.
* Upgraded the PropertyHandler so it writes out properties that
are more accurate. The original properties are used, and then
overwritten by the current components. If a component doesn't
provide its current properties, its original properties are
written. Before, no properties would have been written for that
* Added the mac source directory, which has the capability to
create a clickable Mac application. Use the 'mac' target in the
ant build file.
* Added the com.bbn.openmap.MapBeanRepaintPolicy interface, which
handles the layer's requests for repaints as well as modifying
the java.awt.Graphics object for painting. The
StandardMapBeanRepaintPolicy was added to implement the default
behavior. The HintsMapBeanRepaintPolicy was added to the package
to allow RenderingHints to be set on the MapBean.
* Added the com.bbn.openmap.proj.EqualArc interface to designate
those projections that are Equal Arc (constant degree changes in
both directions). Modified those layers that required the CADRG
projection to be use any EqualArc projection, including LLXY.
* Modified the ToolPanel so it can be told (in its properties)
which Tools to include in its interface. It also has the
capability to be told which tools to ignore and not include.
This lets you place more than one Tool in the MapHandler, and it
will show up in the right place. The ToolPanel will also make
itself invisible if all of its components are made invisible, and
reappear if any of them are made visible.
* The OpenMapFrame has been modified to set its root pane as the
root pane of the Environment if the Environment has been told to
use internal windows and the root pane hasn't been set in the
Environment yet.
* Modified the OpenMap application to have a method which assigns
a WindowListener to the application frame. The default action is
to exit the application, but this method can be overridden to
change this behavior. The OpenMap application also schedules the
Frame to be shown in the event-dispatching thread, which makes
the frame appear much more consistently.
* Modified the WindowSupport object to use JDialogs to keep the
windows floating on top of the map. The WindowSupport also now
has code that tries to make the window appear centered on the
owner window (thanks to Laura Paterson).
* Added the com.bbn.openmap.gui.ScrollPaneWindowSupport, which is
an extended WindowSupport that wraps content in a JScrollPane.
* Added the com.bbn.openmap.gui.GridBagToolBar, which is a
JToolBar with a GridBagLayout to have a more compressed look.
* Added the com.bbn.openmap.gui.dock package, which supports the
new com.bbn.openmap.gui.BasicDockPanel. This is a new MapPanel
that allows components to stack up against each other, in
addition to layering themselves within the panel.
* Added the VPFConfig class to the com.bbn.openmap.layer.vpf
package, a utility that helps configure VPFLayers. When run in
standalone mode it displays the coverages and features available
in the designated VPF library and allows the user to designate
the DrawingAttributes desired for each feature chosen. There is
an option for printing those properties so they can easily be
added to an file. The VPFConfig can be
launched from a running VPFLayer palette to change the features
the layer is displaying. It can also be run from within the
application to create a new layer and provide that layer to the
LayerHandler, although this functionality hasn't been introduced
* The EsriGraphicList and DbfTableModel classes in the
com.bbn.openmap.dataAccess.shape package have static methods
included that create an instance of themselves from URLs.
* Layers now have a removeable flag that can be set in them, that
lets GUI widgets know that they shouldn't be removed, and the
LayerHandler pays attention to that flag to prevent unremoveable
layers from being deleted from the application. Fixed bug in
palette component status events so that palette hide events get
dispersed properly.
* Added modifications to the RPF package by Kimberly Hamilton
(NGC) which added the capability to use frames from other zones
when zoomed out, to prevent that confusing lack of coverage
effect at zone boundaries.
* The com.bbn.openmap.dataAccess.dted package was greatly enhanced
with a central DTEDFrameCache that can be shared across layers and
tools. The DTEDFrame in that package provides OMGrid objects
which can use OMGridGenerators to create representations of the
data. This updated frame cache can be used by the
com.bbn.openmap.layer.dted.DTEDFrameCacheLayer, and the different
GeneratorLoaders used to display the data can be configured and
modified in the properties file. The DTEDDirectoryHandler was
added to load the DTEDFrameCache with a DTED directory, and it
also handles the configuration of a DTEDNameTranslator, which
translates how frame files are named in relation to their file
structure. This used to be hard-coded, now new classes can be
written and included in the properties.
* The com.bbn.openmap.dataAccess.dted.DTEDAdmin class can move
DTED files from one directory to another, filtering the move based
on file location and dted level.
* The Link package ( was modifed to run
in asynchronous mode, allowing servers to push OMGraphics to the
client layer on their schedule. Properties were added for stroke
patterns, fill patterns, and projection changes so the server can
control the application's projection. The LinkArc was added to
the package as well.
* A TimerLocationLayer was added to the
com.bbn.openmap.layer.location package, which includes a timer to
have the LocationHandlers reload their source data at specified
* Simon Bowen provided updates to the MIF package
(com.bbn.openmap.layer.mif), including support for text and point
* Uwe Baier provided the MySQL layer package,
* The RenderingHintsRenderPolicy was added, which lets layers
independently set java.awt.RenderingHints on the
java.awt.Graphics that its OMGraphics are painted into. The lets
the layer set anti-aliasing, etc.
* The FullProjectionRenderPolicy was added to allow the clipping
area of the java.awt.Graphics a layer is painting into be the same
as the current Projection. The JComponent code limited this to
the visible size of the Layer, this allows the layer to paint
into a bigger image buffer.
* The VPFFeatureCacheGraphicWarehouse was created to provide a
feature-based tile cache. This cache is shareable across
different layers, accessed through the LibraryBean. Each layer
gets their own copy of the feature OMGraphics so they can be
rendered independently from other layers.
* Added the VPF servlet to the package, at openmap/src/vpfservlet.
This servlet is for programmers looking to gain an understanding
of VPF data, as it provides an in-depth view into the structure
and organization of VPF databases, as well as a direct look into
the data files. It's a servlet intended to be run within Tomcat.
There's a README included in the package that describes what
files to modify to configure it for your VPF data and Tomcat
* The DrawingAttributes GUI was completely overhauled to have
dynamic color icon generated to reflect the current colors. The
BasicStrokeEditorMenu was created to compress Stroke parameter
selection, and the EditableOMGraphics now have a standard
interface to add options to the GUI, so different parameters
specific to the OMGraphic type can be modified.
* The com.bbn.openmap.omGraphics.event package was enhanced with
the addition of the MapMouseInterpreter interface and the
GestureResponsePolicy. The MapMouseInterpreter is an object that
knows how to interpret MouseEvents over OMGraphics, and calls a
GestureResponsePolicy for information on how to respond. This
elevates MouseEvent interpretation to a different level, where
the programmer only has to receive queries about what to display
for certain OMGraphics, notifications of OMGraphic selection.
This capability has been integrated into the
* The FontSizer object was added to the package, which is used by
the OMText object to resize the font based on scale.
* The OMAreaList was added, which takes different types of
OMGraphics and links them together to make one shape.
* The OMArc was added, a superclass to the OMCircle. It can be
rendered as an open arc, a chorded arc, or a pie arc.
* The OMEllipse was added, which creates a ellipse in lat/lon
space with distance axis. The EditableOMCircle can be used to
move the OMEllipse, but the axis cannot be modified yet.
* The EditableOMText object was added, a contribution from Piotr
* OMGrids now use GridData objects to represent their values,
which is a type wrapper. GeneratorLoaders were added to the
package as well. GeneratorLoaders are factories that create and
manipulate OMGridGenerators, using properties for configuration
as well as providing a GUI for runtime manipulation. Added new
SlopeGeneration capabilities to the
com.bbn.openmap.omGraphic.grid package. Colored and Greyscale
colors can be used by the SlopeGenerator.
* The InformationDelegator was modified to handle the dispersion
of messages to several information lines, with two now
incorporated into the InformationDelegator. The CoordMouseModes
use one (on the left) and layers generally use the one on the
right. The right one gets used when the caller doesn't specify a
location. Other locations can be added to the
InformationDelegator list of available lines, and the caller can
specify when line its information should appear on.
* Added the com.bbn.openmap.event.ListenerSupport class, which
provides superclass support for other event notification
* Added the MapBeanKeyListener and ProjMapBeanKeyListener classes
to the com.bbn.openmap.event package, which distribute key event
that occur when the MapBean has focus.
* MapMouseModes can now have prettyNames, which are the names that
appear in the GUI as opposed to using the modeID, which was the
previous case. The GUI components have been updated to use the
pretty name in the right cases, and to continue to use the modeID
for programmatic purposes.
* The proxy action of the AbstractMouseMode was modified so that a
mask can be provided to allow certain types of events to pass to
its targets even if it is acting as a proxy for another
MouseMode. This lets the Gestures mouse mode update the
coordinate display on the InformationDelegator while it acts as a
proxy for the OMDrawingToolMouseMode, for instance, but letting
only the mouseMoved MouseEvents pass on in a regular fashion.
Also, if you hold the shift key down while generating
MouseEvents, the proxy action is bypassed entirely.
* Added a method to the DistanceMouseMode that makes it easy to
subclass it and change the format of the string displayed in the
InformationDelegator. Thanks to Piotr Kamiski.
* The MapBeanPrinter object was added by Bart Jourquin, allowing
the MapBean to be printed and scaled directly to the Java printer
* Modified the propertyEditors that deal with file and directory
selection to check to see of a File Chooser has included "\\" in
the path, replacing them with "/" to make the work correctly if
they are written out to a properties file.
* Modified the OMDrawingToolLauncher so there are properties that
define whether to use buttons for different OMGraphic selection or
a pop-up, and if buttons are chosen the number of buttons to
display in a single row can be specified. The order of the
OMGraphic choices are now the same as they are added to the
MapHandler (in the openmap.components property or
* The OMDrawingTool was modified to be able to handle movement of
multiple OMGraphics. It uses the DrawingToolRequestorList to
notify the owners of all the OMGraphics when movement is completed.
* Added the IconFactory package (,
which creates ImageIcons from vector data and DrawingAttributes
information. You provide the factory an IconPart (or IconPartList)
which contain DrawingAttributes per part, and the size you want
the icon to be, and the factory creates the image for you. The
DrawingAttributes GUI icons are created using the OMIconFactory.
* Added the beginnings of a MIL-STD-2525 Symbology factory. It
doesn't work yet. Soon. The does show the symbol
hierarchy, though, and the symbol organization is in place. The
last bit, actually building the symbols from cgm files, needs to
be completed. The com.bbn.openmap.dataAccess.cgm package was
added to OpenMap for this purpose. The CGM package was acquired
from BBN's Cougaar code base.
2003-12-30 Bill Euerle <>
* Cleaned up numerous javadoc warnings.
* Updated the VPF layer to more fully use the Java2 Collections
API. Removed one (formerly deprecated) method from DcwRecordFile.
2003-06-26 Don Dietrick <>
* Added the com.bbn.openmap.gui.time package, which has standard
GUI controls for controlling time on the map, and
mapping time rates (real time to some other scenario time).
* Added the com.bbn.openmap.graphicLoader.scenario package, which
uses location data and activity data to manage movement, against
time, over the map. The ScenarioGraphicLoader uses a time slider
and several time control buttons.
* Misc changes and bug fixes: Added getters/setters for
AreaHandler in AreaShapeLayer. Fixed recursion bug in
* Added the package, containing new
classes that can be used to create images with pre-packaged scaleable
geometries. The application icons will be moving to use
ImageIcons created from the OMIconFactory and
IconPartCollections, instead of holding gif and png files in the
package. In support of this package, more capabilities were
added to the com.bbn.openmap.omGraphics.DrawingAttributes class,
including the ability to render a java.awt.Shape object into a
java.awt.Graphics object using its parameters.
* Moved the GraphicLoader classes in
com.bbn.openmap.plugin.graphicLoader to their own package, in
com.bbn.openmap.graphicLoader. The
com.bbn.openmap.plugin.graphicLoader package remains, for the
GraphicLoaderPlugIn and GraphicLoaderConnector, two classes that
use PlugIns and GraphicLoaders. But the new package contains
just GraphicLoader stuff, and several implementations and superclasses.
2003-04-25 Don Dietrick <>
* Heavy modifications to the CORBA classes. The build.xml file
was modified to use the jdk 1.4.1 corba tools and classes instead of
relying on VisiBroker. The idl components have been changed to
work with POA instead of BOA. Created the
com.bbn.openmap.util.corba.CORBASupport object to handle the
client-server startup and resolution functions. This code used
to be duplicated across three packages, now they all use this
* Added getToolBarGUI to EditableOMGraphic, with first
implemention in EditableOMPoly. Will be used for small GUI
accessories that can be used to modify OMGraphics.
* Moved DMSLatLonPoint, UTMPoint and MGRSPoint to
com.bbn.openmap.proj.coords, added UPSPoint, NEDFrame and
EnuFrame there too as a contribution from Robert Hayes.
2003-04-23 Don Dietrick <>
* Modified the OpenMapApplet to look for a PROPERTIES parameter
in case the properties file to use to configure the applet should
be different than the standard file. The
properties file can be specified as a resource, file or URL, but
the applet rules apply.
* Added the ScaleDisplayLayer, contributed by David Ward. Modified
it to extend OMGraphicHandlerLayer.
* Misc bug fixes - the add/delete node states for the
EditableOMPoly only change to edit cursors when over a node, it's
now consistent with actual editing behavior. The equator
distance for NM in the Planet class was modified to be 2160.
Modified CSVTokenizer to ignore quotation marks, although a
quotation mark at the start of a field forces the field to be
interpreted as a String, and escape characters force inclusion of
the next charater in a String field. RpfTocHandler ignores
commas while checking scale fields.
2003-04-16 Don Dietrick <>
* Created the CombinedCoordPanel made from the contents of the
improved CoordDialog, and modified the CoordDialog and
CoordInternalFrame to use that instead of creating their own
content. Created a CoordsMenuItem that brings up the
CombinedCoordPanel in a WindowSupport object instead of using the
CoordDialog and CoordInternalFrame. Removed support in the
NavigateMenu for the CenterListener setup of the MapBean and
specific support for the CoordDialog/CoordInternalFrame, since
that moved to the CombinedCoordPanel and setup is now supported
by the menu item.
2003-04-14 Don Dietrick <>
* Added the component, which
can create a set of menus from properties, and can provide a
JMenuBar or JMenu containing those menus. Maintains order of the
* Changed MapPanel to be an interface to a component that can
provide its MapBean, MapHandler and menu information(MenuBar
or single Menu with appropriate sub-menus). Created the
BasicMapPanel to implement the MapPanel interface. Modified
OpenMapApplet and OpenMapFrame to find a MapPanel, add it to
their content pane, and ask it for it's JMenuBar.
* Added a librarian function in the PropertyHandler so you can ask
it for objects that were created with a particular property
prefix. Applies to those components created via the
openmap.components property.
* Added the com.bbn.openmap.gui.dock package, which provides a
multi-layer layout for OpenMap components.
* Misc changes: Fixed the area calculation in LabeledOMPoly,
Location now uses an OMPoint instead of an OMRect.
* Added the com.bbn.openmap.gui.MiniBrowser component, which
displays HTML content for the InformationDelegator. It has a
back button, and a button to launch current content in the
default browser if the content is from a URL. Uses a JEditorPane
to display HTML.
* Changed the WebBrowser temporary file extension from .tmp to
* Added the com.bbn.openmap.plugin.graphicLoader.scenario package,
which is a csv-loaded chain-of-events displayed on the map.
2003-04-05 Don Dietrick <>
* Created the MapPanel component, which is now the central
OpenMap application/applet component. It takes a
PropertyHandler, or creates one if it isn't given one, and
creates and MapBean and MapHandler. It then uses the
PropertyHandler to get properties to create all of the components
for the application. The MapPanelChild interface is for
top-level components that should be added directly to the
MapPanel, and it allows the MapPanel to ask where the component
should be added in its BorderLayout. The MapPanel can be used on
any application as a regular Swing widget, basically embedding
OpenMap into an application or applet.
* Modified the OpenMapFrame so that it applies to applications
only, instead of having it be responsible for figuring out when
it was being used in an applet and have it do the layout for an
applet. The OpenMapFrame now looks for the MapPanel and adds it
to its content pane. It also looks for a JMenuBar to add to
itself. The OpenMap class creates a MapPanel, PropertyHandler
and OpenMap frame to start the OpenMap application. The
OpenMapApplet is now a BeanContextMembershipListener, so it can
use the MapHandler to find components it needs. It also creates
a MapPanel and PropertyHandler, and does its own layout of
* Added the OMControlPanel, a little all-in-one component
containing a overview map, all of the projection control widgets,
and a layers panel. By default, it likes to be added to the left
side of the MapPanel. Also added the ControlPanelToggleMenuItem,
which locates the OMControlPanel in the MapHandler and can be
used to hide/show the panel.
* Added the com.bbn.openmap.gui.WindowSupport, which provides
manangement functionality over JFrame/JInternalFrame for
components that want to emebed themselves or other components in
a window. The WindowSupport disposes windows when they are
dismissed or hidden to save memory and to prevent their existance
from keeping the jre thread active when parent components are
removed. The WindowSupport keeps track of positioning and
resizing changes and applies them to windows that are re-created
later for the same component.
* Misc: Modifed the LayerUtils.getResourceOrFileOrURL method so it can
better locate resources for applets in the code base. Fixed the
problem with the OMRasterObjects for distance triggers, making
them think they are always filled so they respond to any query
within their limits.
2003-03-25 Don Dietrick <>
* Added the com.bbn.openmap.util.DataBounds and
com.bbn.openmap.util.DataBoundsProvider interface, and modified
the GoToMenu to use the to enable the
capability to focus the map on a particular data set. For
instance, if a ShapeLayer is added to the MapHandler, it will be
picked up by the DataBoundsViewMenuItem and a menu item for that
data set will be added to the submenu, allowing the map to be
recentered and zoomed directly over the area covered by the data.
* Modified the LayersPanel and LayerPane classes, and added the
LayerControlButtonPanel. The LayerControlButtonPanel is a
configurable OMComponentPanel that contains the buttons to change
the layer order. These buttons used to be integrated into the
LayersPanel, and have been moved into their own panel that is
configurable via properties (horizontal, vertical, top, bottom,
right, left, and include/omit add/remove layer buttons). This
panel can be added to the LayersPanel in several different ways,
all configurations available via the properties, but if you don't
specifiy anything the LayersPanel will appear as before. The
LayerPane now notifies the LayersPanel when a layer entry has been
selected for movement, and that notification gets passed to the
LayersPanel and on to the LayerControlButtonPanel, and anything
else that is listening for PropertyChangeEvents. Notifications of
layer order changes also pass from the LayerControlButtonPanel to
the LayersPanel via PropertyChangeEvents.
2003-03-13 Don Dietrick <>
* The directory structure of the OpenMap package has been changed
in order to make it easier to add external code packages that
OpenMap classes rely on. The new structure of the package is:
ANT_ENV.bat - environment configuration for Ant for Windows machines.
AUTHORS - People who have contributed to OpenMap.
CHANGELOG - List of changes between versions.
INSTALL - Installation instructions for compiling.
LICENSE - OpenMap License.
Makefile - Makefile for compiling code, forwards targets to Ant.
README - Start here, information about using OpenMap.
README.win32 - additional information for Windows users.
bin - scripts for building, starting the OpenMap application.
build.xml - Ant build file for compiling code.
classes - created when code is compiled, not present by default.
doc - Java API and architecture documentation.
ext - Externally available packages that OpenMap packages rely on.
iis - .NET webpages
lib - jar files used by OpenMap, including jars created from OpenMap
code. - default configuration file for the OpenMap application.
share - misc information, applet pages, map data.
src - the OpenMap code packages.
src/openmap - the OpenMap code base, compiles with Java 2.
src/ext - external code integrated into OpenMap package, compiled into
openmap.jar file.
src/svg - OpenMap code that relies on Apache Batik SVG
src/j3d - OpenMap code that relies on Java 3D package.
src/corba - OpenMap CORBA client-server code that relies on
Inprise Visibroker package.
* OpenMap GUI components have been overhauled. Previously, most
of them created the Swing components they needed to provide their
GUIs. Now they have been written to extend the Swing classes they
used to use. Components that created many Swing objects and
managed their configuration have been broken into several new
components that can each use the MapHandler to configure
- The OMComponentPanel is a new OpenMap base class that
extends JPanel. This class implements the methods of the
MapHandlerChild (it knows how to work with the MapHandler)
and has methods that let it act as a PropertyConsumer.
- The OMToolComponent is a OMComponentPanel extension that
can provide a GUI face to let it act like an OpenMap Tool.
The OpenMap Tool behavior can be controlled through
properties that can be set on the component.
- The InformationDelegator is now an OMComponentPanel, now
uses the StatusLightPanel instead of creating and managing
the status icons itself.
- The OverviewMapHandler is an OMToolComponent, and can
now beused as a JPanel.
- The JPanel components in the OMToolSet have been
separated from the OMToolSet and made into
OMComponentPanels - the NavigatePanel, the ZoomPanel, the
ScaleTextPanel. All can be used individually. The
ProjectionStackTool can be used the same way.
The Menus have been changed, too. The AbstractOpenMapMenu is the
base class for all menus, and is capable of being configured via
properties. The menu items for all of the menus have been
converted into JMenuItems that can use the MapHandler to connect
to other components (LightMapHandlerChild objects). These
JMenuItems are stored in the new gui/menu package, and all of the
old Menus - FileMenu, ControlMenu, NavigateMenu - have been
updated to use them. The is a
menu that can be configured through the properties.
* The MapHandler has new methods that let you ask for components
using Class objects. Also, there are methods that let you receive
a Collection of objects as a result of queries if more than one
object meets the query.
The methods for the components that use the MapHandler have been
standardized to the familiar ones defined in the MapHandlerChild
class. Most OpenMap components now inherit most of the
MapHandlerChild methods from a superclass, and override the
findAndInit(Object) and findAndUndo(Object) methods. A new
interface, the com.bbn.openmap.LightMapHandlerChild, specifies
these two methods as a component that can hook up to other
components it needs.
* The MapBean now uses a MapBeanRepaintPolicy object to determine
how it will react to layer repaint requests. The
StandardMapBeaRepaintPolicy, used by default, simply forwards all
requests normally. The MapBean also forwards projection changes
in PropertyChangeEvents.
* The Layer class has changed. All references to the AWTAvailable
variable have been removed. The ImageGenerator, which used this
variable to try to track Layer threads, has been removed. The
Layer.repaint() method now calls MapBean.repaint(layer) if its
parent is a MapBean. This is to allow the MapBeanRepaintPolicy to
take effect.
* A MGRSPoint has been implemented, allowing conversions between
decimal degree lat/lon, UTM and MGRS coordinates. The UTM and
MGRS panels have been added to the CoordDialog component. The
CoordDialog, in addition to recentering the map on the entered
coordinates, also converts the coordinates to the other
representations in the different panels of the dialog.
The com.bbn.openmap.plugin.UTMGridPlugIn has been added, which
draws the UTM zones on the map, labeled below certain scales. It
also has the capability of drawing distance grid squares around
the center point of the projection. These grids are labeled with
MGRS grid lables when zoomed in.
* Thomas Paricaud contributed the e00 layer package, enabling the
reading of ArcView export formatted files.
* MouseModes now have a notion of being invisible to the GUI
(their presence is expected to be noted by another component or
tool), and also have the ability to act as a proxy for another
MouseMode. When a MapMouseMode acts as a proxy for another
MapMouseMode, it sends all its events to the hidden MapMouseMode.
This functionality has been built into the AbstractMapMouseMode.
MouseEvents are now wrapped within a MapMouseEvent by the
AbstractMapMouseMode. The MapMouseEvent provides information
about what MapMouseMode sent the event, provides a handle to the
MapBean and has a method to provide the latitude/longitude of the
MouseEvent location.
The CoordMouseMode now calls a method for setting up the text
that gets presented in the GUI for the coordinates of the mouse.
This lets you easily extend the CoordMouseMode to specify the
units and format of the string.
* The OMGraphicHandlerLayer has become the uber-layer for
OpenMap. The methods for creating and rendering OMGraphics and
handing projection changes have been standardized in the
OMGraphicHandlerLayer, and a SwingWorker added to it. Almost all
of the other OpenMap layers are now based on the OMGraphicHandler
layer, with their SwingWorkers deleted and using the one from the
super class.
The OMGraphicHandlerLayer now uses two different policy objects,
one that determines the behavior of the layer when the projection
changes (should the layer clear out the current OMGraphicList with
each projection change because it needs to repopulate it based on
the new projection or reuse all OMGraphics, and should a
SwingWorker thread be launched) and the behavior for rendering
OMGraphics. The prepare() method for an OMGraphicHandlerLayer
returns the OMGraphicList to be used for a projection, and can be
called in any thread. The doPrepare() method launches a
SwingWorker to call the prepare() method. Different OpenMap
layers set different ProjectionChangePolicy and RenderPolicy
objects depending on the behavior desired and how they gather
their OMGraphics.
The StandardRenderPolicy forwards paint() requests to the render
method of the OMGraphicList. The BufferedImageRenderPolicy keeps
track of how long it takes to paint the OMGraphicList, and if it
exceeds a threshold it will create a BufferedImage to paint the
OMGraphicList into. If paint times decrease, the buffer is
discarded automatically.
* Added many OMGraphic package improvements:
- OMGraphicList has a 'vague' variable added that controls
certain behaviors. If an OMGraphicList is vague, it acts
as a whole OMGraphic, with any child OMGraphics
contributing to the whole group. The group gets treated as
the OMGraphic for find/select requests. If an
OMGraphicList is not vague, which is the default, the
OMGraphicList acts as a pass-through, an organizational
container for the child OMGraphics. Methods that also
modify the internal List have been synchronized on the
List to avoid ConcurrentModificationExceptions.
- OMDistance has been added, an OMPolygon with labels at
each node specifying segment and total distance from the
first node.
- OMSpline, OMDecoratedSpline have been contributed by
Eric Lepicier, along with their decorations and supporting
Editable classes.
- Bart Geraci contributed new OMArrowHeads, much improved
- OMGraphics now have a getDescription() method, returning
a String that describes what they are. When called on an
OMGraphicList, you get a huge printout of the structure of
the OMGraphicList and its contents, including the contents
of any child OMGraphicLists.
- OMText now have a setUseMaxWidthForBounds() method,
which let the background area for Multi-line text appear
as a bounding box, instead of a form-fitting polygon.
* Modified the OMDrawingTool by adding a behavior mask, which
dictates how the OMDrawingTool acts. There are behavior options
for deactivating when the mouse is clicked off the edited
OMGraphic instead of using the pop-up menu or palette Done button,
presenting the palette, presenting the pop-up menu, presenting the
pop-up menu on a ctrl-click or right mouse click. This makes
using the OMDrawingTool much easier to use for the user. The
OMDrawingTool now has a canEdit() method, which lets you ask if it
can edit a particular Class of OMGraphic without invoking the
* Modified the DrawingToolLayer to have methods that ask whether
an OMGraphic should be edited (handed to the OMDrawingTool), and
what the tool tip should be for an OMGraphic. This makes it
easier to customize behavior for mouse events in layer subclasses.
* The BufferedImageHelper will use JAI if it is available to
create a BufferedImage. It uses reflection to figure this out, so
it will compile and run if the JAI is not installed.
* Added an OMGraphicDeleteTool, a button component that sits in
the tool panel and listens for events from any other component,
like the OMDrawingTool, for OMGraphics that have been selected.
If the button is pressed, the OMGraphicDeleteTool deletes the
selected OMGraphic by notifying the DrawingToolRequestor to
delete the OMGraphic. If the source of the selection is the
OMDrawingTool, the OMGraphicDeleteTool will tell the
OMDrawingTool to delete the OMGraphic, which it does by notifying
the DrawingToolRequestor when the drawing tool deactivates.
* Added the com.bbn.openmap.layer.editor package, which contains
an EditorLayer that extends the DrawingToolLayer. The EditorLayer
uses an EditTool to make modifications to its OMGraphics. Unlike
the DrawingToolLayer, the EditorTool presents a GUI in the tool
panel that controls tools specifically for that layer, with uses
and meanings designated for interaction with that layer. There
have been three EditorTools implemented - a superclass
AbstractDrawingEditorTool that creates an internal OMDrawingTool,
and two subclasses. The DrawingEditorTool loads different
EditToolLoaders into the OMDrawingTool - creating the drawing
layer that most people were expected before the drawing tool came
out, with any graphics created going directly to the layer. The
DistanceEditorTool has a button to create OMDistance objects,
which, unlike the DistanceMouseMode, creates distance lines that
are persistant. The AbstractDrawingEditorTools use the
SelectMouseMode to modify OMGraphics that are on the map. If an
OMGraphic is being edited, the SelectMouseMode is used as a proxy
for the internal OMDrawingTool, so the modifications look like
they are being managed from the Gestures mouse mode.
* ScaleFilterLayer now presents palettes for layers, forwards
MapMouseModes to active layer, status event for active layer.
* The EsriGraphicList and DbfTableModel have static methods that
take a URL to a file and provide an instance of themselves.
EsriPoint and EsriPolys are cloneable.
* VPFLayer can be told to get features from a particular library.
* New icons for the MouseModeButtonPanel.
* The com.bbn.openmap.plugin.graphicLoader package documentation
has been improved, and the GraphicLoaderConnector problem caused
by adding GraphicLoaderPlugIn/PlugInLayers to the MapHandler when
the GraphicLoader was given a handle to the LayerHandler. This
caused a concurrent modification exception. Now a list of new
PlugInLayers is maintained, and added to the MapHandler after the
* The projections have been modified to help out the
ProjUtils.getScale() method, returning the proper scale for the
particular projection type.
* ArgParser can now be told to expect '-' in arguments (for
negative numbers) instead of automatically assuming that those
arguments are command arguments.
* The ComponentFactory can now use reflection to create Objects
with arguments in their constructors.
2002-12-20 Donald Dietrick <>
* Moved the CHANGELOG to the top-level directory, in order to help
people find it.
* Added a method to the ComponentFactory that lets you ask it to
create Objects using an Object[] that serves as a set of arguments
to the constructor. The method uses reflection to figure out if
the Object[] contents make sense for the new Object type, and will
create the new Object if it can.
* Modified how com.bbn.openmap.proj.ProjUtil.getScale() works, in
order to get a better scale value. The calculation has been moved
back into the Projection objects, and the getScale() method now
queries the projection for the scale value that is appropriate for
the situation.
* Modified how the PlugInLayer works between the MapHandler and
its PlugIn. The PlugInLayer used to forward all communication to the
PlugIn, now it simply adds the PlugIn to the MapHandler and steps
out of the way.
* The VPFLayer components have been modified to read data from a
URL, and the bug that prevented data from being read from a jar
file by an applet running 1.4.1 has been fixed. The API for the
VPF components changed, so that components no longer take a File
object for the paths, but instead take a String. Also, code was
added to prevent multiple File separator characters from appearing
in file paths.
* The DrawingTool has been modified to have a notion of behaviors,
which can be set via an integer mask. The pop-up menu that used
to be required to complete modifications to an OMGraphic is no
longer needed, but remains a behavior option. By default, it
still appears with a right-click or ctrl-click. See java docs for
* Added the com.bbn.openmap.layer.editor package, which contains
the EditorLayer. The EditorLayer uses EditorTools to create a
more application-centric layer, one that needs to capture
MouseEvents exclusively, and also place a GUI in the ToolPanel
when the EditorLayer is active. A DrawingEditorTool is provided,
which provides the action most likely expected from a drawing
layer, as opposed to the flexibility that the
OMDrawingToolLauncher provides. The DrawingToolEditor makes the
EditorLayer look like a drawing layer, with the controls and mouse
events acting on its own OMGraphics.
* MapMouseModes now have a notion of not being visible, and the
OpenMap GUI components that display status of MapMouseModes honor that.
* Misc bug fixes - Layer has correct setAsBackground flag set. The
ToolPanel correctly removes Tools that have been removed from the
MapHandler. The BinaryFile pays attention to a
-Ddebug.connection_problems flag, and if it is set it will let the
Thread sleep for a second. This is a fix, suggested by Sun, for
problems that may occur by the client unexpectedly closing down a
socket too soon before all the data has been read off the stream.
The LocationLayer GUI has tabs for multiple LayerHandlers again.
* Modifed the build.xml file so compilations are performed with
debugging on.
2002-11-08 Bill Mackiewicz <>
* OpenMap 4.5.4 released.
2002-11-07 Don Dietrick <>
* Modified the openmap lauch scripts so they pick up any changes
that may have been made to the version in the top level openmap
directory. In 4.5.3, the jar had to be rebuilt to contain the
modified properties file for the changes to take effect.
* MapBean changes. Modified how the background color is handled
in a MapBean. If the background is not explicitly set in a
MapBean, the background color of the projection will be used. If
a background is set in a MapBean, that change now only affects
that particular MapBean. The OverviewMapHandler can now be set to
listen to property changes of its source MapBean in case it should
mimic background settings. The background can now be set to a
Paint object as well (use setBckgrnd() methods).
* There is now a BufferedLayer that can act as a group layer,
buffering all of its layers into an image. There are settings
that can manage how often the buffer is recreated, and these
settings depend on if the image is transparent and how often the
group layers repaint themselves between projection changes.
* There is a BufferedLayerMapBean, which uses a BufferedLayer to
contain all layers marked as background layers. This 'background'
setting has been added to Layer. When the BufferedLayerMapBean
receives a new stack of layers, it reads them and adds the
background layers to its BufferedLayer. This really helps to
decrease repaint times. This layer has not been added as the
default MapBean in penMap because there isn't a good way to manage
the layers and notify the user why the layer order may not appear
the same way as it does elsewhere in the GUI. A new LayersPanel
is needed. However, the BufferedLayerMapBean can be loaded into
the application by using the -Ddebug.blmb flag. Using the
-Ddebug.bllp puts checkboxes in the LayersPanel so you can mark
layers as background layers.
* The package was updated, and a new
example package (com.bbn.openmap.examples.beanbox) was added to
show how to configure and use the beanbox for drag and drop
additions to the map.
* EsriPlugIn got many changes and fixes. The palette will return
after the first dismissal, the horizontal scroll will appear and
the table won't be compressed. If the shp file is the only one
specified, they the shx and dbf files are assumed to be next to
it. The files can be named as files, URLs or resources (relative
pathnames). EsriPlugIns can be created dynamically.
* The Shape dataAccess package was modified. Exports are more
reliable and you can specify if the DBF file should be written.
Sublists are only created for multipart geometries. OMGraphics
created from Shape file records will be held directly in the top
level OMGraphicsList instead of being held in a sublist. Null
fields in the dbf file don't cause number exceptions.
* The GraphicLoader concept was much refined, with the creation of
an AbstractGraphicLoader that has a pre-defined timer, etc. A
GraphicLoader is a component that creates OMGraphics on it's own
schedule, and then notifies a receiver to paint the
OMGraphicList. The GraphicLoaderConnector is a component that
lives in the MapHandler and looks for GraphicLoaders in the
MapHandler that do not have a component that is receiving its
OMGraphics. If it finds on, it creates a
PlugInLayer/GraphicLoaderPlugIn automatically to display objects
on the map.
* OMGraphic modifications:
OMGraphics now have a notion of a TextureMask variable that can be
used to hold a TexturePaint object. If the TexturePaint object as
some transparency in its image, the OMGraphic's fillPaint will
show through the fill pattern.
The OMRasterObjects now correctly update their Java Shapes
correctly. This fixes the problem where icons were not responding
to gestures.
OMScalingRaster now has access to the clipping rectangle, a Java
2D rectangle that specified what part of the image is on the map.
OMArrowHeads for OMLines have their wingtip and winglength
attributes exposed so they can be adjusted. Their rendering was
improved with relation to matting, filling.
OMGraphics were modified so that fill color matters with regard to
distance. Clear shapes will be treated as lines, without
area. OMLines are never treated as being with area (affects great
circle lines) no matter what the fillPaint settings are.
* MouseModes can now provide an Icon. The MouseModeButtonPanel
can be used with those icons. If a MouseMode doesn't provide an
icon, an name will be used instead.
* Modified the SVGFormatter so it gets all the individual layer
graphics properly from a BufferedMapBean.
* Eliot Lebsack from Mitre provided a couple of new classes -
com.bbn.openmap.layer.shape.ShapeFileCrop, can create a new Shape
file with shapes from a certain area of another Shape file, and
com.bbn.openmap.gui.SaveAsVirtualImageMenuItem, which lets you
set the size of an image to create from the current map.
* The SaveAsMenuItems now add an image-appropriate suffix to file
names when an image is saved. They also check and confirm that a
duplicate image will be overwritten.
* The MapRequestHandler can now be set to use Layer visibility
settings to determine what layers should be used for an image.
* Misc layer improvements: Many Layers had properties renamed to
not have a '.' in the front of them, and their setProperties
methods have been modified to work with or without a property
prefix. GraticuleLayer has font size property. DTED file
components do better checking for null fields. ETOPOLayer updated
to read ETOPO2 data. LocationLayer has LayerHandlers access
exposed. The RpfProductInfo now has catalog static methods to
print out information on all of the various data types.
* Fixed bug where gestures were not accessing information on
AreaShapeLayer graphics where the attributes were loaded via a dbf
* Fixed the OMDrawingToolLauncher so it receives its list of
EditToolLoaders from the OMDrawingTool, instead of finding them on
its own.
2002-07-24 Bill Mackiewicz <>
* OpenMap 4.5.3 released.
2002-07-24 Bill Mackiewicz <>
* OpenMap 4.5.2 released.
2002-07-23 Bill Mackiewicz <>
* OpenMap 4.5.1 released.
2002-07-22 Donald Dietrick <>
* Added the package that contains a
global application mechanism for handling Drag and Drop events.
2002-07-21 Don Dietrick <>
* Added Oliver Hinds' OMColorChooser preview panel, so you can see
what the color looks with the transparency setting before you hit
2002-07-20 Don Dietrick <>
* Incorporated Raj Singh's updates to the WMSPlugIn, which bring
it into compliance with WMS specification version 1.1.0, including
some error handling and JPEG image quality requests.
* Incorporated Lonnie Goad's updates to the EsriPlugIn, which
improved GUI interaction, table interaction, and provided tool
tips over OMGraphics on the map that reflect the DBF contents for
that graphic.
* Fixed problems in the com.bbn.openmap.dataAccess.shape package.
The ShpOutputStream was putting in the wrong record number
(started at 0 instead of 1), and fixed a couple of problems with
export, including a problem with handling embedded lists, and
translating DrawingAttributes from OMGraphics that were converted
to EsriPolygons and EsriPolylines.
2002-07-18 Don Dietrick <>
* Added ProgressEvent, ProgressListener and ProgressSupport
classes to the com.bbn.openmap.event package. These objects
provide a way for a component to let someone else know how much of
a task is done. This has been integrated into the MakeToc class
in the RPF package.
* Added a 'matted' property in the OMGraphic object. If
setMatted(true), then the OMGraphic gets drawn with a thin, 1
pixel black line around it. Makes it more distinctive, especially
in busy backgrounds.
* Changed the graphicLoader package, making it much more
significant. The GraphicLoader is an interface, representing an
object that creates OMGraphics from some source and sending it to
a receiver that will rendering it on a map. The
AbstractGraphicLoader is an OMComponent that contains all the
basic GraphicLoader functionality, along with the basic ability to
use the MapHandler to find objects and being a PropertyConsumer,
so it's ready to be initialized with properties in the file. The MMLGraphicLoader is additionally
prepared to receive MouseEvents. The LOSGraphicLoader is the old
GraphicLoader that lets things wander on the map, while keeping
track of what objects are in LOS of each other.
2002-07-17 Don Dietrick <>
* Made modifications to OMGraphics. Made the OMLine handle arrow
heads properly. Made arrow heads bigger. Made OMGrid more
consistant and fixed bugs in column and row handling. Added an
empty sort() method on OMGraphicList which can be extended with
customized sorting criteria. Added a sort action constant mask to
OMGraphicConstants. Added setSelected() and isSelected() methods
to OMGraphic.
* Added better trapping for SVGFormatter errors in the FileMenu.
* Added the OMComponent, which is a MapHandlerChild and a
PropertyConsumer, reflective of an object being added to the
openmap.components property of the file.
LayerHandler was changed to extend it.
* Modified to handle internal frames
independently of being in applet mode.
* Modified the build.xml file. The OpenMap package builds things
differently, too. First, all compiled classes are placed in the
classes/openmap directory, except for the CORBA classes which are
placed in the classes/corba_vb directory. Second, all of the
openmap classes are placed in the openmap.jar file. omcontrib.jar
and omcore.jar are no longer created. All of the CORBA classes
are placed in the omcorba_vb.jar if the corba build target
(visibroker) is created.
* Added Jakarta Ant 1.4.1 to the OpenMap package, making OpenMap
pretty much self-compiling. All of the infrastructure for the
original Makefiles have been removed, and replaced with Makefiles
that call ant.
2002-06-21 Don Dietrick <>
* Modifed the build.xml file to handle the corba classes better.
* Created the MakeTocException, and the
com.bbn.openmap.layer.rpf.MakeToc class now throws that exception
instead of calling System.exit(), in case it is embedded into a GUI.
2002-06-18 Don Dietrick <>
* Misc bug fixes in several classes, fixing null pointer
exceptions, security access exceptions, etc.
2002-06-13 Don Dietrick <>
* Modified the EsriShapeExport class so that a GUI is not brought
up to save the files if a file path is provided.
* Fixed a bug in OMPoly that prevented internal Shape objects from
being created if soShapes == false.
2002-06-03 Bill Mackiewicz <>
* OpenMap 4.5 released.
2002-05-29 Don Dietrick <>
* Modified MIFLayer to be an OMGraphicHandlerLayer.
* Modified the clone() method in, so that the internal
Mercator projection used for complex lines gets deep cloned on
copies. This allowed removal of a synchronized block of code.
* Added edit methods on the DrawingTool that take a MouseEvent.
These additional edit methods put the EditableOMGraphic directly
into edit mode instead of selected mode, so that mouse events have
an immediate effect on the OMGraphic. Makes for quicker editing
in some cases. Also, a setAllowGUIOption method was added to
OMDrawingTool so that the palette for an EditableOMGraphic can be
brought up from the pop-up menu, if the user wants it.
* BufferedMapBean and MapBean have had their clipping restrictions
lifted, in order to provide a way to have smoother animation. Partial
maps may be drawn if another layer trys to render itself,xc not
knowing if there is a clipping rectangle set on the MapBean, so
just be aware of that if you set the clip rectangle on them.
2002-05-28 Don Dietrick <>
* Fixed that annoying NullPointerException in the
* Overhauled the com.bbn.openmap.omGraphics package. The changes
are extensive, but the use of OMGraphics is backward compatible.
The biggest change is that internally, OMGraphics represent
themselves as java.awt.Shape objects (actually, GeneralPaths)
after they are projected/generated. After generation, the Shape
object can be retrieved by OMGraphic.getShape(). The Java Shape
interface provides different spatial operations you can perform on
other shapes - contains, intersects, getBounds.
The first new thing to notice is the
com.bbn.openmap.omGraphics.OMGeometry interface, which is a basic
interface describing renderable shapes. The most basic
implementation of this interface is the abstract class
com.bbn.openmap.omGraphics.geom.BasicGeometry, which contains the
code that manages Shape creation. OMGraphic now extends
BasicGeometry, adding DrawingAttributes information to describe
how the Shape should be rendered (linePaint, fillPaint, Stroke).
There is now an OMGeometryList, which extends OMGraphicList. The
difference between them is that OMGeometryList contains OMGeometry
objects, and when an OMGeometryList is generated, all of the
OMGeometry objects contribute to a single Shape object (disjointed
or not), with the DrawingAttributes of the OMGeometryList
dictating how the Shape is drawn. The
com.bbn.openmap.omGraphics.geom package contains these OMGeometry
objects, of which there are two currently implemented -
PolygonGeometry and PolylineGeometry. When rendering an list of
graphics that share the same color and stroke types, using an
OMGeometryList with a single Shape obejct is faster than using an
OMGraphicList with separate OMGraphics.
Some other omGraphic package improvements:
- Moved the OMArrowHead calculations from OMLine to OMArrowHead.
- Removed dependency on java.awt.Toolkit from OMBitmap and
OMRaster in favor of BufferedImage.
To add control over managing OMGraphics, the OMGraphicHandler
interface was created. This interface defines methods to interact
with a component that has OMGraphics, including spatial
filtering. The FilterSupport object helps objects implement this
interface. The abstract classes OMGraphicHandlerLayer and
OMGraphicHandlerPlugIn are OMGraphicHandlers that use FilterSupport.
Layers that implement the OMGraphicHandler interface -
GraticuleLayer, DemoLayer, DrawingToolLayer, ShapeLayer.
Other layer improvements that take advantage of the OMGeometry
- - A shape layer that uses the new OMGeometry
objects. BufferedShapeLayer uses the new OMGeometryList. The
com.bbn.openmap.layer.shape.EsriRecord components handle
OMGeometryLists and OMGeometry graphics.
- The com.bbn.openmap.layer.shape.areas.AreaHandler groups all
like areas together in a OMGeometryList.
As a side note, OMRaster and OMBitmap create rectangles outlining
their shape. OMGrid hasn't been modified to do anything in
particular with it's Shape object pointer.
* Created a com.bbn.openmap.dataAccess package, which is intended
to hold components that access particular data types. As an
example, the com.bbn.openmap.plugin.esri components that were
responsible for directly reading and writing shape files, were
moved to com.bbn.openmap.dataAccess.shape. The rpf, dted, mif,
etopo, and other data components will follow. Note that the
EsriPlugIn and EsriLayer classes in the
com.bbn.openmap.plugin.esri package still exist.
* Incorporated a submission by Karl Stuempfle and Lonnie Goad
working for OptiMetrics, Inc. that provides a way to take an
OMGraphicList and export it to a (or up to three) Shape files.
The class that does this is
com.bbn.openmap.dataAccess.shape.EsriShapeExport. If a dbf file
isn't specified in the OMGraphicList.AppObject(), one will be
created for each .shp file, and it will contain the rendering
attributes for the OMGraphics. The
com.bbn.openmap.plugin.esri.EsriPlugIn reads the dbf file and
looks for these attributes in it. If they are there, they are
used, otherwise the default settings are used to render the shape
The DbfTableModel was modified, and augmented with the
MetaDbfTableModel, to allow direct editing and modification of the
Dbf files.
The DrawingToolLayer was modified to use the EsriShapeExport class
to export its graphics when a button is clicked on its palette.
* Added the package, which contains
components for creating a Java 3D scene, and creating and
controlling a viewer for that scene. This package requires that
the Java 3D extension package
( in order
to compile and run.
There are some basic components to this package:
- The OM3DManager is the abstract object that creates a 3D scene
and loads it with objects. The MapContentManager is a basic
manager that creates a view window that is controlled by the arrow
keys. The ControlledManager creates a view window that is
controlled by an outside component, and the
com.bbn.openmap.plugin.pilot.PilotPath is an example of an object
that controls it.
- The OMKeyBehavior class is a behavior class that controls
movement of the camera over the scene.
- The MapContent class controls how components are added to the
scene. Map objects are added to the scene in different ways,
check the javadocs for more information.
There is still work to do in this package. Give feedback, money
or code and guide where it goes.
* Added the com.bbn.openmap.plugin.pilot package, which is
a demo package to show how to use the j3D package. The user can
add paths for a 'pilot' to follow, and then create a view into a
3D scene that changes as the 'pilot' moves over the map.
* New OpenMap .NET XML Web Services code has been written and included
in the openmap/iis directory. A demo of this code, which is a
html OpenMap client, will be set up at (get
it?) eventually, but a link from the main OpenMap web page will
direct you to it as well.
There are two directories in the project:
ImageWebService and OpenMapWeb.
ImageWebService contains the .NET XML Web Services. There are
three of them: ProperService.asmx, GetMapService.asmx, and
- ProperService is responsible for starting and killing Java Image
servers, updating user sessions, keeping information about layers
- GetMapService service has three methods: GetMapImage,
RecenterMap, PanMap. It uses ProperService to start Java processes
as needed.
- TimerService is a utility that will call CleanServerProcs()
method in ProperService every certain number of minutes to check
whether it's time to kill some java servers.
The <appSettings> section in web.config file in ImageWebService
folder is used to configure web services to point to the Java
OpenMap installation and file.
The OpenMapWeb folder contains two ASP.NET files: WebMap.aspx and
- WebMap.aspx is the user interface to the project.
- MapImage.aspx is used to contact a web service to get raw image
To support this service, additional functionality was added to the
ImageServer class:
- the PAN, AZIMUTH, X and Y arguments were added to the parsable
argument list, allowing the client to send the server panning and
centering commands (based on the current image projection).
- if the 'layers' property is not defined for the ImageServer
(including the MapRequestHandler) to use to configure the default
layers, then the 'openmap.layers' property will be used to create
the layers available to the ImageServer, and the
'openmap.startUpLayers' property will define the default layer list.
* Modified the build files and the build.xml ant file so that
source files that require other software packages will not be
included in the general build, but can be built with modifications
to some settings. There are three main groups of addition code
that are controlled this way:
- the Java 3D components in the package,
which depend on the Java 3D package from Sun.
- the SVGFormatter in the com.bbn.openmap.image package, which depends
on Batik, see entry below regarding SVG creation.
- the CORBA components in com.bbn.openmap.layer.rpf.corba (existed),
com.bbn.openmap.layer.specialist (new) and
com.bbn.openmap.plugin.corbaImage (new) packages, which are all
configured to compile and run with the Visibroker CORBA
implementation. The are based on the BOA model, so if anyone
wants to translate that to POA and updated them to work with the
CORBA classes in the Java distributions, please do.
* SVG creation is now supported. Added the SVGFormatter class to
the image package, created from code contributed by Sebastien
Prud'homme. This class requires the installation of the Batik
package ( to compile and use. If the Batik
classes are found at runtime, the SVG option is added to the File
-> Save As menu.
* Added the com.bbn.openmap.layer.specialist package. This
package has actually been around since OpenMap started. It's a
client-server package that transfers OMGraphic-like objects.
Doesn't transfer OMGrids or OMPoints graphics. There are
implemenations of servers for DTED, Shape and VPF data. All use
the CSpecLayer for the client. The Specialist.idl file needs to
be compiled (idl2java) to create the com.bbn.openmap.CSpecialist
package, which gets compiled and put into the cspec58.jar file.
All of the other classes get put into the specialist.jar file. To
used this package, these jars, along with the Visibroker jar
files, need to be added to the classpath using the -Xbootclasspath
java flag. The rt.jar java runtime jar needs to be added to the
bootclasspath as well, but after the Visibroker jars.
* Added the com.bbn.openmap.plugin.corbaImage package, which is a
corba-based version of the SHISPlugIn/SimpleHttpImageServer
client-server setup. The package has a corba-based server that
creates image objects sent to the client plugin.
* The Corba RPF package has been improved. The server now has
settings for the maximum number of caches to use, and a timer that
cleans them up after a certain amount of time.
* Modified the examples (com.bbn.openmap.examples packages) to
show how to use the MapHandler for even simple applications.
Moved the examples away from connecting components manually.
* Added the OMScalingRaster, created from a contribution from
Adrian Lumsden (and as I understand, with help from Steve
McDonald). It's an extension to the OMRaster object that takes an
upper left and lower right coordinate, and automatically scales
its source image according to the projection in generate(). It
does *not* warp the image to match the projection, it just does
straight scaling.
Because of this class, the
com.bbn.openmap.plugin.CSVTiledImagePlugin was created to use
them. It uses a CSV file to list coverage coordinates and URLs of
images. This PlugIn does not do any real management of the images
other than to load them and use them - it doesn't drop images that
aren't used on the map, etc. Those are saved as improvements for
Also, the RpfLayer code (RpfSubframe) now uses the OMScalingRaster
for the Rpf subframe tiles.
* Added some new functionality to the com.bbn.openmap.layer.shape
package. Created the MultiShapeLayer, which can display one or
more shape files. The palette for this layer provides controls
for adding buffering and rendering behaviors. The AreaHandler in
the com.bbn.openmap.layer.shape.areas now also uses dbf files, in
addition to csv files.
* AppletDataNugget has been deprecated, it's not needed anymore.
BinaryFile has been fixed to be able to find files in jar files
from an applet as expected.
* Modified the Layer parent class, adding a Projection variable
for all subclasses to use. Accessor methods that take projection
events and projections to get to the projection variable were also
added. Added Layer.projectionChanged() method that sets this
projection variable. Most layer subclasses will probably have
their own version of the projectionChanged() method, so it can be
called if desired. The OpenMap layers that used to save a copy of
the projection have been updated to use the new method and the
Layer.projection variable.
* Added the class, written by Adam Doppelt, to the
contrib/doppelt directory. The Acme GIF creation code has been
modified to use Quanitize if the image being encoded has more than
255 colors. Because of this improvement, the GIF option has been
added to the File -> Save As menu.
* Added the com.bbn.openmap.plugin.graphicLoader package, which is
a demo package to show how to use the LOS code in the package. The user can add points
over the map, some stationary, some wandering, some following a
path, and the components figure out if they can see each other,
drawing a dynamic network on the map.
* Fixed a bug in the SoloMapComponentReplacePolicy where the
replaced SoloMapComponent wasn't actually removed before being
* Fixed a bug in LayerHandler where hasLayer() only checked the
first layer, instead if iterating through all of them.
* Updated the Link package so that OMBitmap, OMCircle, OMGrid,
OMLine, OMPoint, OMRect, OMRaster, OMText and OMPoly objects are
able to be written to the link via the LinkGraphic.write() method.
* OMDrawingTool now makes distinction between new graphics and
updated graphics when it notifies the DrawingToolRequestor. The
OMGraphicList properly handles the OMAction that reflects these
changes, adding updated graphics it doesn't currently have, adding
new graphics, and doing nothing for updated graphics it has.
* ProjectionStack now picks up changes to Background color changes
to the MapBean.
* Added a MouseModeButtonPanel to the gui package. This can be
used instead of the MouseModePanel (option menu). Right now, the
buttons display the MouseModeID text. If the <id>.gif file is
found as a resource, that image would be used on the button
instead. We haven't designed images yet.
* Misc changes:
- EarthquakeLayer default sites updated.
- Fixed layout of CoordPanel and DMSCoordPanel.
- Environment class adjusted so that for the Windows platform, the
XWindowsWorkaround for improved clipping performance is enabled.
- The Environment was also changed to handle internal windows
better. It now containes a JLayeredPane to use as a desktop. All
OpenMap components that consider using internal windows have been
updated to use the new setup.
- The DMSLatLonPoint has been updated to use floats for its
internal seconds representation, for better precision.
- app/RouteLayer was removed, it was redundant.
- Projections now use/return ArrayLists instead of Vectors.
2001-12-11 William Euerle <>
* Numerous changes to VPF layer code to make it more robust. A
few minor performance improvements. Some initial code to handle
"node" features - this code is not yet complete.
2001-11-21 Donald Dietrick <>
* Created the openmap/share/openmap.jnlp file, which demonstrates
how to set up a file to be used with Java WebStart. MacOS X users
and anyone else with Java WebStart installed can click on that
file and the openmap applet will launch and run on the desktop.
You can also use the WebStart file on our demo location at
* Added the com.bbn.openmap.omGraphics.labeled package, which will
be the future home of OMGraphics that have text labels attached to
them. Only the LabeledOMPoly was implemented. The LabeledOMPoly
lets you attach a text object to a specific node, or you can tell
it to center the text within the poly. The polygon parameters can
be modified with the OMDrawingTool, but the text attributes
cannot. The text can only be modified programmatically.
* Added typing controls in the com.bbn.openmap.plugin.esri package
to scoped things a little better. Includes fixes for the
NullPointerExceptions found in the last version. The
class was added as an example of how to use the shapefile creation
capabilities of the package.
* Fixed a NullPointer bug in the OMToolSet.
* Added the MapWindow, a simple JFrame widget that contains a
MapBean, MapHandler, MouseDelegator and LayerHandler. Easy to add
a map to your application.
* Cleaned up how layers are deleted. Fixed MapBean bug where all
layers were receiving remove() calls in certain situations.
Cleaned up how the InformationDelegator was releasing listeners to
the palette triggers. The LayerSupport and other listeners were
adding duplicates to their lists in some situations, which
hampered clean up, too.
* Fixed bug in DMSLatLonPoint where the lat/lons weren't being set
* Modified the ANT_ENV.bat file with better support for
configuring the Windows environment for Ant. Also updated the
README.win32 with instructions to set up Ant to build OpenMap.
* OpenMap 4.4.1 was released a day after 4.4, with some
modifications to the com.bbn.openmap.plugin.esri package.
2001-11-01 Bill Mackiewicz <>
* OpenMap 4.4 released.
2001-11-01 Donald Dietrick <>
* PropertyConsumer handling has been very significantly improved,
thanks to a code submission from Bernhard Reiter and Kai Lessmann.
First, there is a new package, called
com.bbn.openmap.util.propertyEditor. It contains generic
PropertyEditor classes, and an Inspector class that uses the
PropertyConsumer's methods to provide an interface to set and
modify properties.
You can run the Inspector as an application on any
PropertyConsumer class to test out what that interface looks like,
and to see if there are any problems loading the Inspector with
the contents of the PropertyConsumer's properties.
The Inspector exects that the properties returned in the
PropertyConsumer.getProperties() method will be scoped, i.e. that
if a property prefix is used, the properties will also have that
prefix in front of the properties.
The Inspector uses the PropertyConsumer.getPropertyInfo() method
of classes to get information about the properties being
displayed. The Inspector does not expect that the properties
returned in this method will be scoped - Just the base properties
should be returned as keys, with their values being a short
explaination for what the property represents. This explaination
is used as a tool tip in the interface. Also in this method,
properties can be set with the key having a '.editor' suffix, with
the value of the property being the fully qualified class name of
the PropertyEditor to use to adjust that property.
So, while a class might return a (prefix.lineColor, AARRGGBB)
property from the getProperties method, it would return a
(lineColor, "Color used for lines") property and a
property in the getPropertyInfo() method to use to adjust the
fillColor property.
The PropertyConsumer now has a EditorProperty string 'editor' and
a ScopedEditorProperty string '.editor' which makes it easier to
define PropertyEditor properties on the fly.
The submission also includes a com.bbn.openmap.gui.LayerAddPanel,
which can be brought up by the LayersMenu, or the LayersPanel. It
uses a property called openmap.addable to set a list of Layer and
PlugIn classes that can be created at runtime, and configured
using the Inspector. Each unique marker name (separate from the
marker names used in the openmap.layers list) needs to have a
.class property defined for it (what to instantiate), and a
.prettyName property (a generic GUI name for the layer). The
LayerAddPanel provides a place to actually name specific layer
instatiations, and the prefix for those layers are automatically
generated (see PropertyHandler changes).
One more note on this - You'll notice that we've changed the
property definitions so that they *DON'T* include a scoping period
at the front of them. The PropertyConsumer interface has a
setProperties(Properties) method, so the PropertyConsumer can be
configured without a property prefix.
This really applies to developers that configure their layers
programmically. If you define a Properties object that is only
used by one Layer (or other PropertyConsumer type) you don't have
to scope the properties. i.e.
ShapeLayer shapelayer = new ShapeLayer();
Properties shapeprops = new Properties();
shapeprops.put("shapeFile", shapefilepath);
shapeprops.put("lineColor", shapefilepath);
// or
// shapeprops.put(ShapeLayer.shapeFileProperty, shapefilepath);
// shapeprops.put(ShapeLayer.lineColorProperty, shapefilepath);
You could do this:
ShapeLayer shapelayer = new ShapeLayer();
Properties shapeprops = new Properties();
String shapeprefix = "uniqueshape";
shapeprops.put(shapeprefix + ".shapeFile", shapefilepath);
shapeprops.put(shapeprefix + ".lineColor", shapefilepath);
// or
// shapeprops.put(shapeprefix + "." + ShapeLayer.shapeFileProperty, shapefilepath);
// shapeprops.put(shapeprefix + "." + ShapeLayer.lineColorProperty, shapefilepath);
shapelayer.setProperties(shapeprefix, shapeprops);
But you don't have to if the shape layer is the only layer using
the Properties object.
But, if you use the Properties object for all of your properties
definitions, then you have to use the prefix to ensure that the
layer picks up the properties meant for it.
* The PropUtils had methods added that are really helpful to use
for the PropertyConsumer methods.
String prefix = PropUtils.getScopedPropertyPrefix(PropertyConsumer ps);
String prefix = PropUtils.getScopedPropertyPrefix(String prefix);
Either return an empty string ("") for null prefixes, or the
prefix with a period attached. Either way, the properties in
getProperties can be defined by calling the method above, and
simply putting it in front of the property name.
* The PropertyHandler has been updated to keep track of
usedPrefixes, and can test and modify suggestions for new prefixes
if asked. The LayerAddPanel uses this when new layers are created
at runtime.
The PropertyHandler has also been modified to take a PrintStream
and the MapHandler, and create a file. It can
also read in a file at runtime (which is
essentially loading a new map). The application components are
not affected by the contents of a newer openmap.components
property in the new file. Just the layer properties are used, and
the projection settings.
When a new file is created, the
openmap.components property that was set in the lauched properties
file is reused. New components that may have been added at
runtime have not been added. This is a temporary workaround to
the problem that occurs when pulling objects out of the MapHandler
- they do not come out in any specific order, which really affects
the look of any application that may try to load components with
that order. That's also why the application ignores the
openmap.components property of any file loaded
The FileMenu was modified to have 'Load Map...' and 'Save Map...'
options, using the SavePropertiesMenuItem.
* Modified for PropertyConsumer compliance. These are layers ready to
be created at runtime:
- (just so you know for your layers)
- (also uses Inspector for
runtime modifications via palette)
- com.bbn.openmap.layer.location
- com.bbn.openmap.layer.rpf
- com.bbn.openmap.layer.shape
The areas package has not been updated for PropertyConsumer
methods yet. However, the AreaHandler was reworked to provide
better access and control over the area definitions.
* The PlugInLayer and PlugIn were updated to use the
PropertyConsumer interface, and they resolve between themselves
how to handle properties in the different situations where the
PlugInLayer was created and defined the PlugIn, or when the PlugIn
was created and the LayerAddPanel or LayerHandler created the
PlugInLayer for it.
This makes a difference on how properties are represented in files saved by the application.
The WebImagePlugIn abstract class was created, which defines code
shared by the shis and wms plugin pacakges. This code really
affects the PropertyHandling, and the palettes, which take
advantage of the Inspector to allow modification of their
parameters at runtime. There is also a palette option to see what
the query to the web server looks like before it is actually sent.
* The Layer class has been updated so that it contains the handle
to its palette, instead of having the LayerPane manage
it. Layer.showPalette() and Layer.hidePalette() methods have been
added, and the gui components have been modified as well.
ComponentListeners to the Layer will receive events about the
palette, too, telling them when the palette has been activated or
The Layer is now an ActionListener in order to receive commands to
show and hide its palette. It also can receive commands
(Layer.DisplayPropertiesCmd) to bring up the Inspector, which uses
the PropertyConsumer interface to set the layer's properties.
The Layer.RedrawCmd has been defined, too, but individual layers
have to code how to specifically react to it.
The Layer has a new property, autoPalette, which can be used to
tell if the palette for a layer should be turned on by default.
The MapBean has a new method, MapBean.showLayerPalettes(), that
calls Layer.showPalette() on all layers with this property set to
true. MapBean.hideLayerPalettes() turns them all off.
The OpenMap application now calls this new MapBean method at
startup. The result - you can have certain layer palettes come up
automatically at application startup by setting a layer property.
The Layer had a findAndInit(Object) method added, which is called
by findAndInit(Iterator) when objects are added to the MapHandler.
See comments on changes to MapHandlerChild on why this is good.
Property handling in general for layers is improving. With the
addition of the Inspector, you should make sure that all the
PropertyConsumer methods in your layers are implemented, and that
calling setProperties() in your layer reconfigures it if needed. Not
all of the OpenMap layers have been modified yet to act properly in
this way, but many have.
* The LayerHandler was updated to be able to create PlugIn
directly from the openmap.layers property list. If the
LayerHandler finds a PlugIn, it will automatically create a
PlugInLayer for it and hook it up to the PlugIn. Likewise, the
properties for the PlugIn can be scoped in the properties file
exactly like a layer:
The former way to add PlugIns, within a PlugInLayer defined in the
openmap.layers list, still works as before.
* The MapBean has been altered to provide an option to release
Layers that have been removed from it right away. Previously, the
MapBean actually held on to layers that were removed, in case they
were added again without the projection changing. This prevented
the layer from doing unnecessary work just by being toggled on and
off the map, but we got requests to make this an option.
* Added a method to the MapHandler (BeanContext) called get(String
classname), that looks at its contents and returns an object of
that type. Handy for getting the MapBean, LayerHandler, etc. or
any SoloMapComponent from the MapHandler when it's actually
needed, without maintaining a constant handle to it. Kinda handy
for finding the first one of objects that may have sibling types,
but not so much.
* MapHandlerChild class has the findAndInit(Object) and
findAndUndo(Object) method added. This lets you override the
findAndInit(Object) method in MapHandlerChild subclasses, and be
able to provide the super class with objects from the MapHandler,
too. Previously, this was not possible because using the iterator
clears it and it couldn't be used in different places. Likewise,
the findAndUndo(Object) method was added for objects being removed
from the MapHandler.
* The OMCircle was modified to handle rotation! The rotation
angle, in radians, can defined with setRotationAngle(double), with
zero being due West. Positive and negative values can be used.
The EditableOMGraphic doesn't really handle the rotation angle
completely. You can't modify the angle at all, and the grab
points for the OMCircle actually show up where they would be with
a rotation angle of zero. But, adjusting the position of the grab
points does modify the dimensions of the rotated OMCircle, and you
can move it around. The EditableOMGraphic has commented-out code
to render the points properly, but the MouseEvent locations have
to be translated in order for them to be effective. Releasing
this class as it is was the lessor evil of the alternatives.
--- This part is important!! ---
The rotation was accomplished by changing the internal
representation of the OMCircle to be based on java.awt.Shape
objects, and then using AffineTransforms on the shape during
generation. This actually made the render and distance methods
become very generic, not relying on rendertype or what kind of
shape was being rendered. This will be a change that all
OMGraphics will be headed toward very soon.
Also, the OMCircle has a new Shape[] getShapes() method, which
lets you get the generated shape objects and then use them for
some spatial analysis operations that the java.awt.Shape interface
provides. This is really powerful, and look for this to become
part of the generic OMGraphic API. This method returns an array
of shapes because in some small world situations (really zoomed
out) there are multiple Shape objects that are used to represent
the graphic wrapping around the other side of the earth.
* Added the GoToMenu, which lets you saved named Projections,
consisting of projection type, center location and scale. You can
add to the list dynamically, and the locations get saved to the file when a map is saved. You can also add
locations by modifying the properties for the GoToMenu class.
* Added the Esri plugin package, submitted by Doug Van Auken.
This package includes and EsriLayer and EsriPlugIn, and has
support for reading and writing shape files (shp) and their
supporting files (shx and dbf). The EsriPlugIn was added to take
advantage of the SwingWorker in PlugInLayer, and also has code
that displays the contents of the dbf attribute file in the layer
palette, and will highlight graphics on the map corresponding to
any selections in the table. Likewise, and graphics on the map
selected (in Gestures mouse mode) will hightlight entries in the
There will be more improvements coming to the package soon. Among
them, support for sorting the table, use of the BinaryBufferedFile
for buffered input, and increased support for distinctive coloring
for individual graphic.
The package also contains a sample applet and application to
demonstrate how to use the different capabilities of the
* OMGraphic has the get*Color methods undeprecated. If the Paint
objects used are not Color objects, null is returned. This was
done to save casting trouble.
* OMText was updated to paint the boundary rectangle correctly.
* The DistanceMouseMode was modified to be a PropertyConsumer, and
it's parameters can be set in the file for
customized configuration - units, etc.
* The ControlMenu was modified to let you toggle the ToolPanel on
and off.
* Bill Huff submitted several memory cleanups in LayerPane and
LayersPanel, to help with GC'ing layers that were removed from the
* The NavigatePanel was updated to provide methods to set the
coordinates the map goes to when the center button of the rosette
is pressed. By default, it still goes to the starting
* The OMToolSet has properties that can be used to set which
components are visible on the ToolPanel - the NavigatePanel,
ZoomPanel and ScalePanel are optional, but on by default.
* The ImageServer now has a main method that lets you pass it an file, and it kicks out an image file. You need
to have a couple of extra properties defined, like what formatter
to use, in the properties file.
* DMSLatLonPoint longitude wrapping bug fixed.
* The status lights of the InformationDelegator where made to be
buttons that bring up the palette of the corresponding layer's
* The TerrainLayer's LOSGenerator algorithm was improved via a
submission from Mark Wigmore.
2001-08-23 Bill Mackiewicz <
* OpenMap 4.3 released.
2001-08-23 Donald Dietrick <>
* Changed the WebBrowser class to use the File methods for
creating unique and temporary files for browser display.
* Added the MIFLoader improvements submitted by Scott Nevin from
Agilent, which allows the loader to handle lines.
* Made the Location showName and showLocation variables be true by
default, so that Locations will show up as expected. The
LayerHandlers have been updated to set these to be false so the
layer settings will work as expected.
* Updated the raster Location objects to use the horizontal label
buffer, so that the text location gets updated properly when the
entire location changes.
* Added a progress bar for the DTEDCoverageManager, so progress
can be seen when the DTEDCoverageLayer is bulding the coverage file.
* Updated the DayNightLayer to be able to have the overlay time set.
* Took out the supposed XWorkaround from windows and mac
environments. The coordinate clipping changed how the map was
being rendered at some large scales.
* Added the OMDrawingToolLauncher, which calls the DrawingTool
with setting to create new OMGraphics. It's a Tool, so it can be
enabled by clicking on the pencil icon.
It uses the BeanContext to find all the EditToolLoaders, which
know how to use EditableOMGraphics to manipulate OMGraphics. It
also finds all DrawingToolRequestors, which are components able to
receive OMGraphics. The OMDrawingToolLauncher lets you choose
which component will receive the finished graphic.
Added the DrawingToolLayer as an example of how to catch graphics
from the OMDrawingToolLauncher.
* Added support for creating and editing polygons and polylines.
2001-07-27 Donald Dietrick <>
* Added a workaround for Applets trying to access data that was
being stored in its own jar file. See the class for more information.
* Fixed a bug in the
method, where files were not being handled properly for Windows
file systems.
* Fixed a bug in the EarthImagePlugIn that was coloring space, in
the Orthographic projection, to the color of the center pixel.
* Fixed a memory leak in the VPF package, started by the
FeatureClassInfo object. Thanks to Tom Peel for finding this and
reporting it.
2001-07-12 Bill Mackiewicz <>
* OpenMap 4.2.1 released.
2001-07-11 Donald Dietrick <>
* Fixed problems with 'make install' with respect to the previous
changes in the share directory structure.
* Updated the WMSPlugIn with changes submitted by Christof Krug,
with the proper TRANSPARENT request parameters and other changes.
* Added statements to the PlugIn package that says that the PlugIn
is responsible for generating its OMGraphics. Updated some of the
PlugIns to do that.
* Modifed MakeToc in the RPF package, and some of the other RPF
components to make MakeToc a little more robust with older files.
Added output statments to indicated when runtime options should be used.
* Added an openmap.Debug property to the PropertyHandler, which
takes a list of debug tokens and adds them to the Debug
Hashtable. This turns those Debug statements on throughout the
code. It's the same thing as adding -Ddebug.*token* to the start
command, except now you can add an openmap.Debug=*token* in the properties.
2001-06-19 Bill Mackiewicz <>
* OpenMap 4.2 released.
2001-06-18 Donald Dietrick <>
* Added the package, and moved all the I/O
classes from com.bbn.openmap.util into it. BinaryFile was also
reworked. This is BIG news. BinaryFile now uses a new
InputReader class to access data files, instead of using a
RandomAccessFile object. There are three new InputReaders:
FileInputReader, JarInputReader, and StreamInputReader. A
BinaryFile (and the BinaryBufferedFile) can be used to access a
local file, a file contained in a jar file, or a URL.
The constructor for a BinaryFile takes a string argument which can
be an absolute path to a file, a relative path to a file, or a
URL. The BinaryFile will use the CLASSPATH to find the file for a
relative path. If the file can be found on the local file system,
a FileInputReader (RandomAccessFile) will be used internally. If
the file is found in a jar file (the path from the internal root
of the jar should be used), the JarInputReader will be used. For
paths starting with 'http:', the StreamInputReader will be used.
The Shape, RPF, VPF and DTED packages have all been modified to
use the BinaryFile, and this data can now be accessed in a variety
of ways.
There are some issues: Windows users have to use forward slashes
in their paths (/), even for local files. We're still trying to
figure out how to get applets to use data stored in a separate jar
file in the codebase - but unpackaged data in the codebase works.
Some packages may need to be optimized for better network
performance - they were written for random access, so they may not
be so efficient when it comes to dealing with streams.
* Added the com.bbn.openmap.plugin package, replacing the
com.bbn.openmap.layer.plugin package. Plugins have been
redefined, and are the easiest way to get data on the map.
Plugins must implement the com.bbn.openmap.plugin.PlugIn
interface, but classes that extend the AbstractPlugIn can provide
data with only one method being written - that method takes a
projection and provides an OMGraphicList. PlugIns are an object
that hook up to a PlugInLayer, or to a server, or any other object
that needs an OMGraphicList. PlugIns can be written
to receive MouseEvents and/or provide a GUI, and they can work
with the BeanContext to contact other objects in the application.
* Modified the actions of the OMDrawingTool. When edits/creations
are completed on the graphic, clicking on the map brings up a
popup menu with options on what to do with the graphic.
* Fixed the LLXY projection, which happens to be the SRS EPS 4326
projection that can be used with a OGC Web Map Server.
* Updated the LayerUtils.getResourceOrFileOrURL method, so it
doesn't break on Windows file URL pathnames.
* ProfileGenerator in the TerrainLayer has been updated to display
the profile image in a JFrame, instead of trying to create a
temporary file to send to the browser. You loose the ability to
save the image this way, but it makes the layer compatible with
any environment OpenMap is running in.
* Int the RPF package: Fixed bug in MakeToc that wouldn't let you
create a A.TOC from multiple RPF directories. Commented out the
code that checks for updated RPF directories. With the inclusion
of the new BinaryFile code, this gets to be really cumbersome.
This will be replaced soon with enchanced RPF directory
* Fixed a bug in the LocationLayer so that MouseMoved events get
passed through if they aren't consumed.
* Added methods to DTEDFrame so you can ask it for an image of its
contents without the DTEDCacheHandler in the way. Also, if you
run DTEDFrame on a frame file, it will bring up a window with that
image of the data inside.
* Created the com.bbn.openmap.proj.Length class, which provides a
class standard for Length units, and coversion methods between a
given unit type and radians. Modified the MouseModes, OMGraphics
and Link package to use the Length class.
* Modified the PropertyHandler to look for the given properties
file in the CodeBase when running in an Applet environment. This
only happens if it hasn't found any properties elsewhere.
* Modified the Windows environment to use the XWindowsWorkaround
algorithm for pre-clipping OMGraphics, which gets rid of the
zoom-in delay on vector graphics.
2001-03-15 Bill Mackiewicz <>
* OpenMap 4.1.1 released.
2001-03-15 Donald Dietrick <>
* Fixed memory leak within LayerHandler. Layers were being
referenced by the LayerPane after they were removed from the
LayerHandler, and not being gc'd.
* Added getName() to the projection classes, which provides their ID.
* Fixed link in OMPoly java doc.
* Fixed bug for initial limits of bounding polygon. This was
causing more data than needed to be sent back by the LinkServer.
Thanks to Marc Bucciarelli for finding this and sending the fix.
* Added the capability in the SimpleHttpImageServer and
ImageServerUtils to be able to handle a background color request
(BGCOLOR) and transparency settings (TRANSPARENCY) in SHIS
requests. These variables are in compliance with the OpenGIS
Consortium Web Mapping Server specification. Another compliance
change is the background color for the SHIS maps is now white -
you have to specify the color you want if you want it to be different.
* Added methods to objects in the image package that let you set
the colormodel for BufferedImages.
* Fixed bug in quadtree Rect and Node, where the distance
algorithm wasn't correct.
2001-02-27 Bill Mackiewicz <>
* OpenMap 4.1 released.
2001-02-26 Donald Dietrick <>
* Added a package name to the com.bbn.openmap.examples.crew
* Modified the PropertyHandler to use the openmap/share directory
by default to look for, and it adds the share
directory to the classpaths the Environment knows about. If you
are using the openmap directory in your classpath, then files and
other resources will be found in the share directory
automatically. If you are using the openmap.jar file, then
resources will be found in the share directory, but files need to
have share/ added in front of their names (for shape files, for
* Modified the Environment and projection objects to handle the
custom background color a little better.
2001-02-23 Don Dietrick <>
* Added a ToolTip display ability to the InformationDelegator.
The Layer has convience functions to show and hide tool tips on
the map, and the InfoDisplayListener interface had methods added
to accomidate tool tip requests. This was inspired by another
Colin Mummery submission, but slightly modified.
* Modifed the DrawingTool API. Components are no longer passed in
a request to create or edit an OMGraphic. Instead, a
DrawingToolRequestor interface has been defined, where the
requstor will be notfied when an OMGraphic is completed. The
OMGraphic is provided at this time too, in addition to be provided
at request time. Methods were also added the DrawingTool
interface to supress the GUI from appearing, which will restrict
the modifications of the graphic attributes.
* Added more improvements to the VPFLayer where, when
VPFLayer.searchByFeatures is set to true, different feature types
can be colored individually. The palette also provides an
interface to change those settings on a feature by feature basis.
* Added an ETOPOJarLayer from John Watts from Also
added his improvements to the Mercator and Orthographic projections.
* Added the MapHandlerChild abstract class, which shows all the
methods and the BeanContextChildSupport object that are needed to
create an object that uses the MapHandler to find other objects.
* Added Colin Mummery's MapInfo Layer, at com.bbn.openmap.layer.mif.
* Added the build.xml file, which is a build file for the ant
package available at Ant is
great. It is a cross-platform Java project build tool, and is
easy to install and use. Highly recommended.
2001-02-06 Donald Dietrick <>
* Fixed LocationLayer bug where search direction on the graphic
list was the same as rendering direction, when it should have been
opposite, so that graphics on top are found first.
* Fixed the Makefile structure to include the drawing tool package.
* The MouseDelegator had a bug fix installed to prevent a null
pointer exception when setActive was called without a current MouseMode.
* Updated the VPFLayer and vpf package components with several
improvements. Multiple coverage types can be handled on a single
layer. With the VPFLayer.searchByFeatures property set to true,
the CoverageTable uses the Feature Tables and the Thematic Index
to find features, which avoids a problem exposed by the DNC
database where the tile data doesn't contain feature type
information. With searchByFeatures set to true, different feature
types can be rendered individually. The VPF components were also
tuned for better performance and memory management. Fixed a bug
with the old VPF paradigm where skip arrays in the warehouse were
not the same across VPF paths, and it affected rendering.
Resetting the warehouse skip arrays between paths fixed this.
2001-01-08 Don Dietrick <>
* Added the ProjectionStack, which is a projection listener that
remembers projections to reset to the MapBean when triggered.
Listens to ProjectionStackTriggers (ProjectionStackTool) to tell
it to go back and forth through the stack as applicable.
2000-12-22 Bill Mackiewicz <
* OpenMap 4.0 and OpenMap 3.7 released.
2000-12-19 Don Dietrick <>
* Modified the ShapeLayer and ESRI graphic objects to use the
DrawingAttributes object for rendering parameters, and added the
DrawingAttributes GUI to the ShapeLayer palette. You can alter
the appearance of the ShapeLayer graphics at runtime.
2000-12-18 Don Dietrick <>
* Added the com.bbn.openmap.layer.terrain layer, which provides a
LOS mask and path elevation tool. This layer will be modified in
future versions of OpenMap.
* Added a URLDecoder to the SimpleHttpImageServer, so it can
handle HTML encoding of a map request string.
* Added a method (setAction(boolean)) to the MouseModes, which
lets it know when it has been made active or inactive.
* Added the PaintListener interface to the com.bbn.openmap.event
package. The PaintListener interface can be used when a object
needs to know when another object has been painted. For instance,
the OMDrawingTool is a PaintListener to the MapBean, so it knows
when to update the edited Graphic in case it's about to be
* Added the PropertyConsumer interface, which lets the
ComponentFactory know that an object should receive the properties
from the PropertyHandler when it is created. The PropertyConsumer
interface also a method that let an object describe what
properties can be received by it, and a method to get properties
from it to describe the current state of the object. This is in
anticipation of the creation of a editor that will allow for the
runtime creation and configuration of layers and other objects,
and for the creation of files, which will
essential be saving a map for later viewing.
* Modified the VPFLayer to present the new DrawingAttributes GUI
in its palette. This lets you change the display parameters of
the layer graphics at runtime.
* Added the package, which contains
the DrawingTool interface, and the OMDrawingTool implementation of
that interface. The OMDrawingTool is a mechanism that interprets
user gestures to create or modify OMGraphics.
There are new objects in the com.bbn.openmap.omGraphics package to
help out with this process, centered on the EditableOMGraphic
class. An EditableOMGraphic is a wrapper class that knows how to
interpret MouseEvents to initialize or change the location
parameters of an OMGraphic that it contains.
The EditableOMGraphic uses GrabPoints that can be moved or set.
When a GrabPoint is moved, the EditableOMGraphic knows how to
translate the GrabPoint location to a OMGraphic parameter.
GrabPoints come in different flavors - HorizontalGrabPoints can
only be moved left-right, VerticalGrabPoints can only be moved
up-down, and OffsetGrabPoints can maintain a constant distance
from other GrabPoints. GrabPoints can be shared between
EditableOMGraphics, in case you want the movement of a GrabPoint
to modify the parameters of more than one OMGraphic.
The EditableOMGraphic also uses a state machine containing a
series of states that direct actions resulting from MouseEvents.
The com.bbn.openmap.omGraphics.editable contains the new
LineStateMachine and its states. This state machine is used by
the first instantiated class of the abstract EditableOMGraphic, the
EditableOMLine. Other EditableOMGraphic instances are
forthcoming, to manipulate other OMGraphic types.
The OMDrawingTool uses EditToolLoaders, which provide information
to the DrawingTool on which EditableOMGraphic to use for a class
name, or OMGraphic. The OMDrawingTool has two main methods that a
layer or other component calls - create(classname), or
edit(OMGraphic). Both calls return an OMGraphic that is going to
be manipulated by the DrawingTool. The DrawingTool handles the
presentation of the OMGraphic as it's being modified, and becomes
the active MouseMode. When the DrawingTool is dismissed, the
calling layer or component already has the OMGraphic, so no
further action is required programmatically.
The DemoLayer contains addition to its palette that demonstrate
the OMDrawingTool as it stands.
The OMDrawingTool is not a DrawingLayer. A DrawingLayer will be
created for the next release using the OMDrawingTool.
* Modified the DrawingAttributes object so that it contains a
simple GUI to modify its contents (line color, fill color, select
color, line width, and some line dash selections). Uses the
OMColorChooser, which extends the JColorChooser to allow
transparency adjustment for the color as well. Added the
LineChoice, LineChoiceComboBox and DashedLineComboBox to aid the
DrawingAttributes GUI interface. Also created the
GraphicAttributes object, which extends the DrawingAttributes
object to allow modification of line type and render type of an
* Modifed the com.bbn.openmap.layer.rpf.RpfFrame so that it
contains the subframe decompression code that used to reside in
the RpfFrameCacheHandler. Also added an image viewer to the
RpfFrame that lets you see the image it contains - just run the
class. Removed the RpfLayer pop-up window that notifies the user
that the RPF layer requires the CADRG projection. The InfoLine of
the InformationDelegator displays the information instead.
* Packaged OpenMap 3.7, which is an OpenMap 3.6.2 package with all
the code that requires jdk 1.2 removed. This package should
compile without modification with jdk 1.1.X.
2000-10-23 Don Dietrick <>
* Added the com.bbn.openmap.image.SimpleHttpImageServer, with the
MapRequestHandler object and a bunch of modifications to the
com.bbn.openmap.layer.util.http package. The
SimpleHttpImageServer responds to GET and POST commands,
requesting an image. The format for the request is the same as
the OpenGIS Web Mapping Server request, but we have additional
parameters to handle some OpenMap-specific parameters. This is a
work in progress, and will grow to become OGC compliant. For now,
it allows you to run a simple web server that kicks back images.
* Added the PropertyHandler, which is a component responsible for
managing properties which affect the map. When told, it looks for
properties in three places, and overwrites the properties
accordingly - the Resources, the OpenMap config directory (passed
in as an argument), and in the user's home directory.
The role of the PropertyHandler is important, especially in the
BeanContext world. It can be told to look for a property called
"openmap.components", where the value is a space separated list of
marker names, much like the model for the
layers. The PropertyHandler can take that list and use the
ComponentFactory to create objects (defined by the
markerName.class properties) to add to the Bean Context. If the
object created is a PropertyConsumer, the PropertyHandler will be
used to provide the new object with properties.
The PropertyHandler also allows for an "openmap.include" property,
which allows you to define a list of marker names for URLs. These
URLs, defined by the markerName.URL property, provide a way to
have a property file read and its values loaded BEFORE the current file is loaded. This lets the current
properties override anything in the include properties file.
You'll notice these changes have a profound effect on the ease in
which you can create applications. If a component handles the
Bean Context correctly, and is wiring itself up to other objects
it needs via those methods, then you can add the component in the
properties file, and that change will be reflected within the
application without recompilation. The MouseDelegator looks for
MouseModes, the LayerHandler looks for layers, etc., so that these
additions are pretty simple. The ToolPanel looks for objects
implementing the Tool interface, so that its GUI will be added to
the panel below the MenuBar. The MenuBar looks for MenuBarMenus
to add to itself, so adding/changing menus is pretty easy, too.
2000-10-19 Prakash Manghwani <>
* OpenMap components now use Bean Containment and Services
protocol, popularly know as BeanContext. The components look for
services and objects that it needs.
* Modified OpenMap in package so that it
demonstrates the ease of creating a reconfigurable Mapping
application from a properties file.
* Added new context enabled GUI extensible widgets that can be
added to OpenMap Mapping application from properties file thereby
providing the user with a choice of selecting only the GUI widgets
it needs.
2000-08-24 Bill Mackiewicz <>
* OpenMap 3.6.2 released.
2000-08-23 Don Dietrick <>
* Included the upgraded DistanceMouseMode as submitted by Ringo Wathelet.
* Added the UTMPoint and DMSLatLonPoint, as a contribution from
Colin Mummery. Also included the Ellipsoid class in the
projection package.
* Added a redraw button to the VPFLayer.
2000-08-22 Don Dietrick <>
* Added the ArgParser class to the utils directory, which is a
very simple attempt at parsing String[] argv arguments and assigning
string values to certain option keywords.
* Ported the code to create a A.TOC file to java, and it resides
in a class called com.bbn.openmap.layer.rpf.MakeToc. Lets you
create A.TOCs with absolute file paths, which allows you to create
a single A.TOC for multiple RPF directories without merging the
* Fixed a couple bugs in the LayerHandler, that didn't update the
LayersPanel properly when a layer was deleted from the available
layers list. Now check for null edit button before trying to add
it to the LayersMenu.
2000-08-08 Bill Mackiewicz <>
* OpenMap 3.6.1 released.
2000-08-03 Don Dietrick <>
* Added the openmap.BackgroundColor property, which lets you set
the color of the "ocean" for the MapBean. If it's not set, then
the ol' default blue is used.
* Added the DistanceMouseMode, which was a code submission from
Ringo Wathelet from the DSTO in Australia.
* Fixed the quadtree rectangle test for bounds checking, thanks to
code supplied by Paul Tomblin. Michael Los sent in the changes to
make the quadtree classes serializable.
* Added a RpfLayer redraw button on the palette, to redraw the
data with a transparancy change.
* Created an OverviewMapHandler, which manages another MapBean
that listens to a source MapBean to show a map at a different
scale. The OverviewMapHandler lets you set it's layers, the
MouseMode to use (if desired) and a status layer that lets you
draw status graphics on the map. The default status layer simply
draws a box on the map reflecting the coverage of the main map.
* Changed the appearance of the OpenMap application, with new
icons and buttons to bring up the LayersPanel and OverviewMap.
The mouse modes are now shown with a pop-up menu.
* Created the com.bbn.openmap.layer.util.DrawingAttributes object,
which can read Properties to create colors and other Java2D
drawing attributes. OMGraphics parameters can be loaded directly
from a DrawingAttributes object.
* Modified the VPFLayer so that you can specify how you want the
graphics represented. You can specify line, text, select, and
fill colors, as well as line dash patterns and images to use for
area fill patterns.
* Further modified the inner workings of the RpfLayer. Fixed a
bug with the way cached subframes were allocated for new
subframes, and fixed a couple subtle memory leaks.
* Overhauled the LayerHandler, making it the central object
managing all Layer objects. The LayersMenu and LayersPanel listen
to the LayerHandler for information about what layers are
available. The visibility of the layer now determines if the
layer is added to the MapBean to be part of the map, and the
LayersManu and LayersPanel components listen to the layer
Component visibility status to list if a layer is part of the map
or not. The Layer now has a slight hack in them that keep track
of ComponentListeners, and follow through to the listeners to let
them know if the layer has been hidden (setVisible(false)).
* Added the etopo layer package, which was submitted from Joel
A. Rand. It displays the ETOPO world elevation data set, and
provides a really cool view of the world.
2000-08-01 Bill Euerle <>
* Fix a bug that prevented DTEDFrame objects from getting garbage
collected, limited the frame cache size, and fixed an off-by-one
bug that caused an extra row of frames to get loaded. The cache
memory changes were a result of a suggestion from Davis Gillespie,
formerly from General Dynamics.
2000-07-05 Bill Euerle <>
* Removed deprecated OMGraphic methods setGraphicType(int) and
getGraphicType. setGraphicType didn't make much sense, and (obj
instanceof OMBitmap) can be used in place of the second method.
Deprecated the OMGraphic constructors that took a graphictype, and
added new constructors that don't take a graphic type. Although
now unused, the GRAPHICTYPE_* constants in OMGraphic will stay
around for the forseeable future.
2000-06-01 Don Dietrick <>
* Released OpenMap 3.5
2000-06-01 Bill Mackiewicz <>
* Added thinned VPF area and edge data to the share/ directory as
an alternative to the existing DCW shape files in that directory.
2000-05-31 Don Dietrick <>
* Added a palette option to the RpfLayer to limit the chart
selection to the one currently selected. If you find a chart type
you like, you can engage the lock, and only charts of that
particular type will be displayed.
2000-05-25 Don Dietrick <>
* Removed the csvLocation package. It has been replaced by the
location/csv package.
* Updated the ImageGenerator code with bug fixes and hardened the
thread model.
* Updated the ImageServer to have a method that uses the
ProjectionPainter interface. This will help with some of the
threading problems reported with the ImageServer.
* Added the ProjectionPainter interface. The ProjectionPainter
takes a Projection and a java.awt.Graphics object, and renders the
applicable OMGraphics onto the java.awt.Graphics map. The layers
have been updated to implement this interface, providing a path to
avoid the Swing threading model that the Layers usually use.
* Added a File->Save As->JPEG option to the MenuPanel. You can
save the current OpenMap image as a JPEG. You can also modify the
MenuPanel to use other ImageFormatters, too.
2000-05-17 Don Dietrick <>