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 increase 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 com.bbn.openmap.tools.beanbox 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 file. * 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 com.bbn.openmap.tools.dnd 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 OK. 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 openmap.properties 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 openmap.properties file. LayerHandler was changed to extend it. * Modified Environment.java 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 Proj.java, 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 com.bbn.openmap.layer.shape.ShapeLayer.renderDataForProjection() method. * 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 changes: - ShapeLayer2.java - 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 graphics. 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 com.bbn.openmap.tools.j3d 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 (http://java.sun.com/products/java-media/3D/index.html) 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 http://www.openmap.net (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 OpenMap.net project: ImageWebService and OpenMapWeb. ImageWebService contains the .NET XML Web Services. There are three of them: ProperService.asmx, GetMapService.asmx, and TimerService.asmx. - ProperService is responsible for starting and killing Java Image servers, updating user sessions, keeping information about layers used. - 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 section in web.config file in ImageWebService folder is used to configure web services to point to the Java OpenMap installation and openmap.properties file. The OpenMapWeb folder contains two ASP.NET files: WebMap.aspx and MapImage.aspx. - WebMap.aspx is the user interface to the project. - MapImage.aspx is used to contact a web service to get raw image data. 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 com.bbn.openmap.tools.j3d 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 (http://xml.apache.org) 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 later. 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 Quantize.java 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 com.bbn.openmap.tools.terrain 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 replaced. * 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 .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 http://dstl.bbn.com/openmap/openmap.jnlp * 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 Tester.java 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 properly. * 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 (lineColor.editor, "com.bbn.openmap.util.propertyEditor.ColorPropertyEditor") 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); shapelayer.setProperties(shapeprops); 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 openmap.properties file. It can also read in a openmap.properties 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 openmap.properties 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 openmap.properties file loaded later. 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: - DrawingAttributes.java (just so you know for your layers) - EarthquakeLayer.java GraticuleLayer.java (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 openmap.properties 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 hidden. 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: plugin_markername.class=com.bbn.openmap.plugin.PlugIn plugin_markername.prettyName=Example plugin_markername.= 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 openmap.properties 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 table. 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 components. * 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 openmap.properties 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 application. * 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 coordinates. * 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 openmap.properties 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 palette. * The TerrainLayer's LOSGenerator algorithm was improved via a submission from Mark Wigmore. 2001-08-23 Bill Mackiewicz * 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 com.bbn.openmap.io.AppletDataNugget class for more information. * Fixed a bug in the com.bbn.openmap.layer.util.LayerUtils.getResourceOrFileOrURL 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 com.bbn.openmap.io 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 management. * 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 example. * Modified the PropertyHandler to use the openmap/share directory by default to look for openmap.properties, 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 example). * 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 nextjet.com. 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 http://jakarta.apache.org/ant. 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 * 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 over-painted. * 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 openmap.properties 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 com.bbn.openmap.tools.drawing 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 OMGraphic. * 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 openmap.properties 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 openmap.properties 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 com.bbn.openmap.app 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 directories. * 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 * Modified the arrowhead output statements to be Debug statements, instead of constant output. * Added border fix to OpenMap applet as suggested by Mark Bucciarelli. 2000-05-16 Don Dietrick * Modified the RpfLayer to not burn cpu cycles on the RpfCoverageTool if the tool is not in use. Changed the coverage property so that the tool is active by default, accessable via the RpfLayer palette. 2000-04-05 Don Dietrick * Added methods in the ImageServer that lets it act as the ImageReceiver. This lets you ask it for an image directly, instead of using it to load an ImageReceiver. 2000-04-01 Don Dietrick * Fixed timing bug in ImageGenerator that caused it to hang when the same projection was provided twice in a row. Thu Mar 30 12:38:32 2000 * omGraphics/OMText2D.java: added an OMGraphic that supports rotated text. [Requires the Java2D API.] 2000-03-30 Don Dietrick * Modified the OMGraphicList select() and deselect() method behaviors - they now call selectAll() and deselectAll(). * Added the ArcCalc object to the com.bbn.openmap.omGraphics.util package, which lets you add arcs to OMLines that are set with XY coordinates. Fri Mar 24 12:41:58 2000 * Deprecate OMGraphic.setGraphicType(int) and OMGraphic.getGraphicType(). instanceof returns the same type of information as getGraphicType(), and setGraphicType() doesn't really change the type (OMPoly, OMCircle, ...) of a graphic, so its somewhat useless. OMGraphic.graphicType was made private (previously protected) so it can also go away when set/get go away. 2000-03-09 Don Dietrick * Modifed the RPF package. Fixed the transparancy problem, the layer now responds correctly to transparancy changes and settings. The RpfFrameCacheHandler now tests for colortable reusability based on the TOC entry number, instead of the map type, since there is the possibility, with MM map types, that the chart designator may be inaccurate, especially with MM map charts that represent several different map chart types. * Modified the OMRaster to handle transparancy correctly. * Modified the image package, namely the ImageMaster, the ImageServer, and the ImageGenerator. The ImageMaster and the ImageServer now reuse layers across ImageServers, when they can. The ImageServer now reuses the ImageGenerator. In addition, the ImageServer can have it's layer array modified, and requests can be made with a bit mask representing which layers should be turned on/off for the map image. 2000-02-28 Don Dietrick * Released OpenMap 3.4 2000-02-25 Donald Dietrick * Added the mapIt example, a contribution that's pretty similar to the ImageMaster class. * Added the nexrad/NextradLayer, which is a contribution that draws the rainfall over an area as stored in a nexrad file. 2000-02-24 Donald Dietrick * OMRasterObject was modified to trim unused pixels from itself before upscaling itself, instead of relying on the windowing system to clip the unused image. * Added the CSVInfoFile to the com.bbn.openmap.layer.shape package, which can read in and parse a csv file created from a shapefile's .dbf file. This CSVInfoFile is used by the areas package. Also, the shape graphics have been modified to handle Java 2D drawing attributes, and the SpatialIndex object can be given an ImageIcon to use for Point graphics. * Modified the OMGraphic2D objects to handle fill patterns, using TexturePaint objects. Also made them keep track of the modifications they make to the java Graphics object so that non-2D OMGraphics don't pick up those patterns and strokes by mistake. * Created the com.bbn.openmap.layer.location package, which takes the place of the deprecated csvLocation package, and isolates how the locations get created. Added the AbstractLocationHandler, thanks to a suggestion from a user. This package was actually included in the last OpenMap delivery, unannounced. The location package has the option of working with the DeclutterMatrix. * Modified the DeclutterMatrix to work more accurately with text. * Added the com.bbn.openmap.image.BufferedImageHelper and com.bbn.openmap.image.ImageHelper, which assist in creating and manipulating image pixels, especially BufferedImages. Moved the JPEGHelper to the image package from the util package. * Took out some funky alignment statements from some of the GUI tools, making them align correctly. * Modified the RpfLayer to not query the RpfFrameProvider for coverage tool information when the coverage tool was not being used. Fixed a problem reading in CIB A.TOC files from NIMA. The directory name lengths are incorrectly listed in the file, and the files where not being found. Added the indexed image capability to the RpfFrameProvider interface, which really helps speed in the com.bbn.openmap.layer.rpf.corba implementation for LANS. * Added the capability for the OMGraphicList to be able to read/write serialized graphics to/from streams. Helps the CacheLayer. * Added the com.bbn.openmap.shape.areas package, which lets you associate a key and a name from a column in a csv file to the graphics in a shapefile. The AreaHandler allows you to ask for all the graphics in the shapefile that have the same key, as well as define special drawing attributes for specific graphics in the openmap.properties file (or any other set of properties sent to it). The AreaShapeLayer uses the AreaHandler, and can respond to gestures by displaying the defined name of the graphic in the information line when the mouse is passed over it. The drawing attributes for the graphics can include using an image to set a texture for the fill pattern of a graphic - this requires JDK 1.2. * Modified the com.bbn.openmap.util.Debug object to be able to direct output and error statements to various places, including log files. Modified several components and layers to write their debug statements to the Debug.output() method, and their error statements to the Debug.error() method. More changes of this type to the source code is needed - just didn't get around to changing it all. * Added the openmap/contrib directory, which holds code that OpenMap components need that we didn't write. Added the Acme (http://www.acme.com) image encoders for JPEG, GIF and PPM image formats to this directory. Added the ImageFomatters to the com.bbn.openmap.image package that use the Acme encoders. * Added the ImageServer and ImageMaster, which help create specific images. The ImageServer manages the ImageGenerator and the output of the image. The ImageMaster uses ImageServers to define what you want on a map, the image format you want it in, and where you want it written when it's done. 1999-11-03 Bill Mackiewicz * Released OpenMap 3.3.5 1999-11-01 George Keith * Added CacheLayer.java to layers directory. CacheLayer.java will read and display serialized omGraphics from a file specified in the properties. 1999-09-30 Bill Mackiewicz * Updated memory management for the RPF package. The subframe caching works better in a memory-restrictive environment. * Added the com.bbn.openmap.image package. Includes the ImageServer, which uses an openmap.properties file and a projection to tell an ImageGenerator to create an image. This image is in the format specified by the ImageFormatter. * Added the LayerHandler to the gui package. Layers can be added and removed on the fly. 1999-09-07 Donald Dietrick * Added the corba package for a RpfFrameProvider. Included is the Corba RpfFrameProvider client, the Corba RpfFrameProvider server, and the idl that defines their interface. The Rpf Subframe data is transferred betweent the client and server in JPEG format. A CorbaRpfLayer was created to add a palette widget that lets you control the jpeg image quality, and thus size, during client-server transfer. The JPEG encoding and Decoding requires the com.sun.image.codec.jpeg package. Thie new package has only been tested on jdk1.2 with Visibroker 3.3. The jdk1.2 rt.jar file had the CORBA classes removed. * Overhauled RPF layer with a new separation of subframe caches and frame caches. Introduced the RpfFrameProvider interface, which isolates the RPF frame cache. The RpfFrameProvider can be a local version of the RpfFrameCache handler, or can also be some sort of server. All parts of the package have changed, and are incompatable with past interfaces. 1999-08-25 Bill Mackiewicz * Released OpenMap 3.3.3 1999-08-17 Bill Euerle * Added additional projections to that support views (projections whose parameters are recalculated when panning the map) 1999-08-06 Allan Doyle * Improved CSVLocationLayer to read values from a URL. (file:/foo.csv or http://foo.com/foo.csv) 1999-08-05 Allan Doyle * Incorporated BufferedMapBean changes to speed up refresh and fixed a NullPointerException when it's used in a JInternalFrame. Thanks to Joe Warzecha at LLNL. 1999-07-29 Thomas Mitchell * Added share/omapplet.html as a sample html file for running OpenMap as an applet via the Java Plug-in. * Added FAQ section 4, OpenMap as an Applet discussing the hows and whys of running OpenMap as an Applet. 1999-07-21 Allan Doyle * Added .shadowX and .shadowY properties to ShapeLayer.java. This allows you to make snazzy maps with an offset shadow underneath. 1999-07-20 Donald Dietrick * Added the OMgrid graphic object, which, like the other OMGraphics, handles Lat/Lon grids, X/Y grids, and Lat/Lon offset grids. Rendering to the screen depends on objects that implement the OMGridGenerator interface. A couple of generators have been added to the source tree - one assumes that the grid contents are ARGB colors, and a couple others assume that the contents are elevations. The grid can also hold other graphic objects. 1999-04-19 Donald Dietrick * Fixed a bug in RpfTocHandler that caused the A.TOC file section to be read incorrectly. 1999-04-19 * Merged patches from various contributors (thanks!) to DTED and DayNight code. * Fixed some problems with ScaleFilterLayer and DateLayer. * Added BufferedShapeLayer for nominal speed gain. 1999-04-05 Donald Dietrick * Added the CSVLocationLayer. This layer lets you give it a comma-separated value file, listing locations with their latitudes and longitudes on each row. The latitude, longitude and location name column locations have to be given to the layer via the openmap.properties file. The layer can be extended to let the locations display additional detailed information through a browser when a locaiton is clicked upon. 1999-04-05 Bill Euerle * Modified VPF code to move more of the rendering decisions into the VPFGraphicWarehouse interface, to allow more flexibility to choose what to draw, and how to draw it. * Modified VPF code to allow multiple paths to data directories. 1999-04-05 * Updated the openmap.properties file. You will want to merge the options in this file with the openmap.properties in your home directory. 1999-03-18 Donald Dietrick * Added the RPF layer to the openmap tree. RPF is the National Imagery and Mapping Agency (NIMA) format for raster products, like CADRG and CIB. The RPF layer handles these products, displaying them in the OpenMap CADRG projection. * Added the DayNightlayer, which shades the part of the earth that is experiencing nighttime. There are many parameters that can be adjusted through the openmap.properties file. See the DayNightLayer documentation for more information. * Modified the Graticule Layer to display latitude and longitude line labels, draw one and five degree lines when the scale is large enough to require them, and draws different line types in different colors. These parameters are adjustable through the openmap.properties file. See the GraticuleLayer documentation for more information. 1999-03-16 * Deprecated OMColor. Two constructors incorrectly override the Java 2 java.awt.Color. OMColor was only useful to support alpha-valued images under JDK 1.1. You shouldn't use it. Instead use regular java.awt.Colors or use the Java version-neutral com.bbn.openmap.util.ColorFactory to create colors. 1999-02-22 Aaron Culliney * Added Java 2D API OMGraphics classes to the com.bbn.openmap.omGraphics package. * The configure script now checks to see if you're using the Java 2 platform. If so, it sets up the appropriate variables in the Makefiles. 1999-02-02 Donald Dietrick * Added the com.bbn.openmap.layer.util.LayerUtils class, which provides a couple convenience functions for parsing properties for layers. * Created the coverage managers for DTED and RPF, which broke the data coverage generation functions out from the layer, so that a specialist could be made without duplicating a bunch of code. 1999-01-27 Donald Dietrick * Modified the DTED package to be able to produce indexed images (images that use colormaps, as opposed to the direct colormodel). * Modified the RPF package to do the same thing. * Added methods to the OMRasterObject that let you add image filters to manipulate the images when they are generated. 1999-01-21 Donald Dietrick * Added the Tool object in the gui package, reflecting a change in how the ToolPanel is used. The ToolPanel was also changed to accept the addition of tools. The old ToolPanel is now the OMToolSet, and is added to the ToolPanel in the OpenMap application. * Changed the setWidgets() function in OpenMap.java. setWidgets was the place to add customized derivations of the MapBean,ToolPanel, InformationDelegator and MenuPanel to the OpenMap application. If an object wasn't added, a default was, and the default widgets were connected with the assumptions they should be. Now, the interconnections should be made in setWidgets(). If setWidgets is empty, a minimal functioning version of OpenMap runs, without a ToolPanel or Gesturing. 1999-01-20 * (OLD) Changed all Swing package names from the old `com.sun.java.swing' to the new `javax.swing'. This will work with the Java 2 platform or JDK1.1.X with Swing 1.1 * Added SimpleMap examples which show how to use OpenMap for very simple Map displays. 1999-01-15 * Spruced up the EarthquakeLayer. It has a GUI palette, and now responds to gestures: click on an earthquake to get more information. It also fetches its graphics in a SwingWorker thread so it doesn't block the AWT thread. 1999-01-12 Don Dietrick * Added methods to OMGraphicList to let you select all graphics, and temporarily render all graphics in the list in their selected state. Can be used by lists serving as composite OMGraphics. * Added a getMapMouseListener() m ethod to the dted layer, since the Layer default for this method had changed to null. * Added the test in LayerPane, LayerMenu, and OpenMap to make the LayerPanel and Layer Palettes use JFrames (instead of JInternalFrames) if running as an application. If running as an applet, do it the old way. 1999-01-06 Tom Mitchell * Added box capability in OMText objects. setShowBounds(boolean) and getShowBounds() are the accessors for this functionality. 1999-01-05 Tom Mitchell * proj/Projection.java: added 'extends java.io.Serializable' per patches send by slee@bbn.com. This enables the serialization of projections for storing map settings. No testing has been done, so this should go in the category of "untested and unsupported". 1998-12-22 Tom Mitchell * gui/ToolPanel.java: Fixed a bug reported by slee@bbn.com. Apparently a cut/paste induced problem in removeZoomListener(). 1998-12-16 Aaron Culliney * Changed event/MapMouseListenerAdapter.java to event/MapMouseAdapter.java to conform to the AWT/Event/Bean naming convention. 1998-12-14 Tom Mitchell * Converted to Swing 1.1. OpenMap(tm) is now JDK 1.2 ready, but can still be used with JDK 1.1 by using the Swing 1.1 add-on package. 1998-12-11 * Added reference to www.opensource.org in the MapBean copyright message. * Reformatted and improved comments in the files of the event/ subdirectory. * Fixed the toplevel configure.in and configure to use full pathnames for java executables. * Added fixes to NavMouseMode for the mouseClicked() trickle-down, and dateline problems. In JDK1.1, mouseClicked() would get passed down to components underneath the menu when making a selection. This would cause the map to recenter in navigation mode. 1998-12-04 * Add a bunch of comments following this one on the work done in various main classes and APIs over the past several months. * Removed support for LatLon ellipses in OMGraphics and Projection because code was not being used, and was incorrect. Need to reimplement this functionality later. * Slimmed down the Projection.forwardPoly() method. Removed the `connect' variable. If you want vertices connected, (polygons), then you must do so yourself. This requirement also transfers to OMPoly, and is documented in the javadocs. * Removed older `specialist' layer code from the OpenMap tree because it requires CORBA (maybe the Visibroker variant) to build. Since we can't supply this to developers, it's not part of the core. * Removed dependency on `OverlayTable'. For the OpenMap viewer application, Layers are now specified along with other variables in the openmap.properties file. It is easier to develop different applications using the MapBean without this relic dependency. * OMGraphicList now derives from OMGraphic. This means that you can construct recursive lists and groupings of graphics. 1998-10-19 * added "nsges" parameter to OMGraphics and proj library. Use this to specify how many segments should be drawn between vertices of your vector graphic (for circles, and rhumb/greatcircle lines). 1998-08-03 * Added constructors to OMPoly() that allow you to specify that the float[] rawllpts are in reverse order. * Constructors for OMPoly and setLocation() methods that take a float[] rawllpts value now convert the array IN PLACE to lat/lon order RADIANS. This is for more efficient use of the projection code. If you need to access the original float[] values, then you should send in a copy. This is FAST! 1998-07-24 * changed OMPoly.setLocation() functions to take a units value since we allow both radians and decimal degrees (default) for coordinate units. 1998-07-22 * Added an isPlotable() method to Projection.java. This is meant to be used before projecting and rendering point objects like bitmaps. In some projections (Orthographic), the forward() will give you a valid point, but one that isn't on the visible hemisphere, thus you should first check to see if isPlotable(). NOTE that you DO NOT need to do this check for non-point objects, (lines, polys, etc), they get normalized/clipped correctly already. * override getInsets() in the MapBean to return Insets(0,0,0,0). This fixes a problem of drawing graphics at a +2 x/y offset because of a Border around the Bean (added by OpenMap.java). Note that the border still gets drawn with this fix in place. 1998-07-16 * Added a drawBackground() function to the Projection classes. The BufferedMapBean now delegates background rendering to the current projection. * Removed WhoPanel. The InformationDelegator now controls the WhoLine screen real estate. Anything that used WhoPanel should use the InformationDelegator.