Hi Everybody,
The next release of OpenMap, a beta 4.6 version, is now available via
cvs. The instructions for checking out the 4.6 code base are available
on the download page on the website at http://openmap.bbn.com.
This version of OpenMap has many new features and components, and also
many updates to the components already in the package. Some of these
changes required an update to the API, which is why the version number
was bumped up to 4.6. The most immediate change you'll notice is that
the package file structure has changed. OpenMap is increasingly
becoming dependent on third-party software, and we needed to modify the
source tree to separate out dependencies as well as provide an
organized way to include packages from other people. Future versions
of OpenMap will probably contains those packages as licenses allow.
Additionally, many OpenMap components were not Swing components in
themselves, but provided a programmatic interface to create the actual
GUI widgets. These components have been changed so that they are
themselves the GUI Swing widget, they work with the MapHandler without
assistance from parent components, and can be used any way you like.
Almost all of the layers now extend the OMGraphicHandlerLayer, which
has policy components that determine how the OMGraphicList is used and
rendering is managed. The complete list of changes is included below.
This is a beta version because there are still several submissions
we've received that we would like to incorporate into the release, and
some bugs we'd like to address as well as run some profiling
measurements and tweaking. We haven't set a date for the formal 4.6
release.
We hope you find this update helpful, and we appreciate your support
and use of OpenMap. As always, we look forward to your comments and
suggestions.
Regards,
Don
From the CHANGELOG:
2003-04-14 Don Dietrick <dietrick@bbn.com>
* 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 it's MapBean, MapHandler, 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.senario package,
which is a csv-loaded chain-of-events displayed on the map.
2003-04-05 Don Dietrick <dietrick@bbn.com>
* 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 <dietrick@bbn.com>
* 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 <dietrick@bbn.com>
* 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 <dietrick@bbn.com>
* 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.
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
Don Dietrick, BBN Technologies
10 Moulton Street, Cambridge, MA 02138
(617) 873-3200
openmap@bbn.com
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-- [To unsubscribe to this list send an email to "majdart@bbn.com" with the following text in the BODY of the message "unsubscribe openmap-users"]Received on Mon Apr 14 16:37:43 2003
This archive was generated by hypermail 2.1.8 : Thu May 12 2005 - 07:18:35 EDT