Changed between GEV v04 and v05.

1. Spawning a new editor frame now uses
"this.getClass().newInstance()", so the implementation of clone() in
Editor can now be used in subclasses. That is to say, if you define a
subclass of Editor, you no longer have to override clone(), although
you now must provide a constructor with no arguments.

2. When Perspectives are deleted, they remove themselves as Observers
on their parent NetNode in the net level model. ArcPerspectives now
add themselves as Observers when constructed and remove themselves as
Observers in removeFrom().

3. NetNode and NetArc now send notifications when they are
disposed. Perspective and ArcPerspective catch these notifications and
remove themselves.

4. Changed all calls to notifyObservers and all implementations of
update such that if they used a String to indicate what had happend
(e.g., "remove" to indicate a DiagramElement had been removed) then
they will now use unique String constants defined in class
Globals.

5. Fixed a bug that prevented event processing in an editor read from
disk. Basically the _eventQueue and _eventHandler instance variables
in Editor are transient so that they will not be serialized. My
original intent was to reinitialize their values when the Editor was
read from disk. However, I mistakenly forgot to add the
reinitialization.

6. Fixed a somewhat mysterious bug that caused the MenuBar to overlap
the drawing area in the first window opened when running
BasicApplication. Apparently overlap happens when the menubar of a
frame is set before a panel is added to the frame. Changing the order
of operations seems to have solved the problem.

7. Totally reimplemented the property sheet to be faster and simpler
and better documented. The new property sheet uses the new IProps interface.

8. Replaced existing graphical attribute access methods with a new
implementation. Originally DiagramElements implemented
getGraphicalAttribute() and setGraphicalAttribute() where the key was a
string and the value was an Object and the interpretation of that
Object was hard coded in various places. In implementing the original
PropertySheet, new code was added getProperties() and setProperties() that
used vectors of UiProperty objects that contained a key, value, and
UiType object that indicated how the value object was to be
interperted. Having code for both systems of attributes caused a lot
of duplicated and confusing code. Now I have returned to something
closer to the original design, but more efficent. DiagramElements
implement interface IProps which defines some simple access methods
(various forms of get() and put()) as well as separate methods for
meta-data about what properties are available and which are read-write
(as opposed to read-only). The new system is somewhat faster for these
reasons: property names are interned strings that can be compared with
== instead of using String.equals(); the properties are broken into
categories so that the property sheet does not need to display them
all; fewer Vector, Integer and Boolean objects are created.

9. Fixed several errors that prevented serialization from working
properly under JDK1.0.2 and JDK1.1. Now all classes that need to have
instances saved implement interface GEF (see below). Also under
JDK1.1 the observers of an Observable object are not saved. For this
reason I now use Observable/Observer pairs only for relationships that
will not be saved (e.g., the PropSheet is an observer of a currently
selected DiagramElement). Logic that did use Observable/Observer
relationships now uses direct pointers in addition. For example,
DiagramElement now has a pointer to the Layer that contains it. And
all Layers notify Editors that are editing them directly, change
notifications no longer walk up the nested LayerComposite hierarchy.

10. Added interface GEF. Many classes implement interface GEF. GEF
defines constants that I want to be available in all classes, and it
can also extend "marker interfaces" such as java.io.Serializable or
Cloneable. Since some marker interfaces are not present in JDK1.0.2, I
have provided an m4 file that can generate two versions of GEF.java
(one for jdk1.0.2 and one for jdk1.1).

11. Many (but not all) classes now use getXXX() and setXXX() names for
their accessor methods. This makes the code closer to widely accepted
coding standards. This naming convention also helps to open
possibilities for integrating with JavaBeans, although I do not have
any real plans for that yet.

12. Fixed a typo in EditorMenus "Preferences" is now spelled correcly.

13. Increased the default refresh rate in RedrawManager, also
increased the maximum refresh rate that can be set. I think this is a
good idea because the framework is now faster and I would like to show
off that speed. If you find that you are getting ahead of the editor,
you can lower the refresh rate through the preferences dialog box.

14. Added properties in FigText to support underline, strike out, and
shadowed text. These are not implemented yet and would make excelent
small projects for people that want to contribute to GEF.

15. Added actions ActionSelectAll and ActionSelectInvert to help the
user select DiagramElements. I added these to a Select submenu under
the Edit menu. Also ActionSelectNext has been modified to accept its
direction argument in its constructor so that it can be added to the
menu. ActionSelectSuchThat is not implemented yet, but it would make
an excelent small project for people that want to contribute to
GEF. The intent is to put up a dialog box that lets the user specify a
query based on DiagramElement properties, DiagramElements that match
the query will be selected.

16. Added a title instance variable to Editor intented to store the
desired window title. However the concept of a document needs to be
more fully developed in order for this to make much sense.

17. Updated uci/graphedit/Makefile and uci/Makefile.config to handle
m4 preprocessor files better.

18. Defined FigInk so that it will never be filled and never be
rectilinear and always have line width of (at least) 1.

19. Added a work-around in Editor#createImage to try to avoid getting a
null Image. I call addNotify() if the peer has not already been
set. This work-around can itself generate a NullPointerException in
the AWT peer classes, I don't know why, but it seems harmless and the
createImage() call seems to work even if addNotify() raised an
exception.

20. Changed the way borders are drawn on FigRect, FigCircle, and
FigRRect. Now the line width is taken into account so that the line
fits inside the Fig's bbox.

21. Chaged the number of rows in the PrefsEditor so that it looks much
better.

22. Added a status bar in the Editor. This only appears if you let the
Editor make its own panel and frame and if you are not in an
applet. This Needs-More-Work.

23. Added a work around for loading documents with images. The images
are not saved and are not loaded back when the document is
loaded. Instead I draw a simple rectangle. This Needs-More-Work.

24. Guarded some operations that require an applet context with code
to check if there is an AppletContext available. For example,
PaletteFig will not show the two image buttons if you run
BasicApplication.

25. Added code to RedrawManager to avoid making new Images on each
redraw. Instead, several fixed size Images are allocated when first
needed and then reused. The disadvantage is that I redraw a little
more area than is really damaged. The advantage is that I avoid
allocating Images (which are large and complex objects) and creating
garbage. 

26. Added line spacing and margins to FigText. Also, FigText can
resize to fit the text more tightly. In previous GEF versions, the
FigText bounding box only got bigger, never smaller. Now this behavior
is controled by a boolean in FigText.

27. Fixed a bug that caused FigText to not update multiple views when
you added or removed characters. Basically, all Fig's should call
startTrans() and endTrans(), they should not make direct calls to
Editor#damage() because that only updates one Editor.

28. Added a Makefile option to compile with or without some widget
code from Symantec. In the property sheet I would like to have tabs
to select various catagories of properties. I achieved this by using
the classes that come with Symantec VisualCafe. It is my understanding
that I am allowed to redistribute the Symantec .class files, but no
their source code. I have included the needed .class files in the
current GEF distribution. If you don't want to use the Symantec
classes you can change Makefile.config and regenerate
uci/ui/TabPropFrame.java, or you can just edit that file. If you do
not use the Symantec tabs, there will be a Choice of categories
instead.

29. Changed the way that arcs and nodes are added and removed, so that
these operations can be initiated from th euser interface, or from
some other code. I had always intended this to work, but previously I
had only tested adding and removing from the UI. As soon as I tried
doing it programmatically, I realized several problems.

30. Updated my version of Sun's ObjectSerialization libary, and much
to my dispare I found that saving and loading no longer work under
jdk1.0.2. The problem is that classes such as java.util.Hashtable must
implement java.io.Serializable, but they do not in jdk1.0.2. So there
is really nothing I can do, other than stop using Hashtables and
Vectors. Instead I just use jdk1.1.1 for building applications.
(Applets cannot currently load or save anyway, but adding the ability
to use a URL would be a good project).

31. Editing a node now opens a property sheet on that node by
default. Previously, I just printed a message so that users could find
the method that they should override to define their own node editing
capabilities. For an example, perform "Edit Node" on a CPU node when
running uci/graphedit/demo/EquipmentApplet.html.

32. Enhanced the EquipmentApplet example to show off more GEF
features. It also shows what a pain it is to define new properties,
but this is the best I can do for now. Look at the CPU node and the
data cable to see some properties.