2008-02-27 Don Dietrick * Updated the PropertyHandler to have it's 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 openmap.properties 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 adjustments. 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 used. - 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 com.bbn.openmap.io.FileInputReader 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 OMScalingRasters. 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 added. 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 package. * The ProjectionSupport threading model was improved, adding a more robust threading lock mechanism during projection change notifications. * The PanMouseMode image management and projection handling was improved. * 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 added. * 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 class. * 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 '.layers' property first, where 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 lists. * 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 continuing. * 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 package. 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 images. * 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 better. * 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 files. * 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 properties. "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 http://www.globalimagination.com). 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 images. * 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 setting. * 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 map. * 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 appropriately. * 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_.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 I18N.properties files will be created without the locale setting. Added the I18nFileCreateMenuItem that will tell the BasicI18n class to create the new files. The openmap.properties 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 com.bbn.openmap.tools.symbology.milStd2525 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 http://xml.apache.org/batik. 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 implementations. * 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 types. * 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 LayerControlButtonPanel. * 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 well. Because the change to openmap.properties might catch some people by surprise, particularly those who use their own openmap.properties 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 ProjectionLoaders. Lastly, the Projection property defined in the openmap.properties 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 openmap.properties comments next to that property, and the BasicMapPanel has been configured to complain about using the old style. * 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 InformationDelegator. 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 com.bbn.openmap.layer.asrp.ASRPLayer. * 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 openmap.properties 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 openmap.properties 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) (com.bbn.openmap.tools.roads), along with two layers that provide routes based on the OMGraphics created from their data sources (com.bbn.openmap.layer.shape.MultiRoadLayer and com.bbn.openmap.layer.vpf.VPFRoadLayer). 2004-02-11 Bill Mackiewicz * OpenMap 4.6 released. 2004-02-09 Don Dietrick * 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 component. * 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 openmap.properties 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 yet. * 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 (com.bbn.openmap.layer.link) 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 intervals. * Simon Bowen provided updates to the MIF package (com.bbn.openmap.layer.mif), including support for text and point objects. * Uwe Baier provided the MySQL layer package, com.bbn.openmap.layer.mysql. * 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 installation. * 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 OMGraphicHandlerLayer. * 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 Kaminski. * 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 classes. * 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 interface. * 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 programmatically). * 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 (com.bbn.openmap.tools.icon), 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 com.bbn.openmap.tools.symbology.SymbolChooser 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 com.bbn.openmap.omGraphics.FilterSupport. * Added the com.bbn.openmap.tools.icon 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 class. * 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 openmap.properties 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 com.bbn.openmap.gui.menu.MenuList component, which can create a set of menus from properties, and can provide a JMenuBar or JMenu containing those menus. Maintains order of the menus. * 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 .html. * 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 components. * 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 com.bbn.openmap.gui.menu.DataBoundsViewMenuItem 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. openmap.properties - 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 package. 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 themselves. - 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 com.bbn.openmap.gui.menu.OMBasicMenu 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 look. - 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 tool. * 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 iteration. * 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 details. * 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 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 quad