% jfig/doc/CHANGES,   04.05.2003


This file contains jfig bug, status and change log information.
For information on how to use or configure jfig, see the README
and the FAQ documents.


--------------------------------------------------------------------------
Status: (jfig 2.04 / 1.63). 

* all FIG 3.2 object types
* all FIG object attributes (rendering requires Java2D)
* all basic xfig editor commands
* xfig library function 
* read FIG 3.2, FIG 3.1, FIG 2.1, write FIG 3.2, FIG 3.1, format conversion
* Postscript export via Java/Java2D printing (still many Java bugs here)
* Postscript, Latex, ... export via external fig2dev program
* user interface to fig2dev, see /doc/export-fig2dev.txt
* support for Manhattan and LaTeX style geometry
* both Swing and "traditional" AWT versions available
* both Java2D and "traditional" AWT 1.1 object rendering
* experimental "TeX mode" for direct rendering of attributed strings
* layer manager (Swing version only)

jfig features and bugs:

* multiple-line text objects (strings with '\n' chars) are not supported
* suboptimal rubberbanding for rotated ellipses
* default installation uses Times/Helvetica/Courier fonts only
* Java related print problems (especially for the jfig applet)
* stacked object selection not fully implemented 


--------------------------------------------------------------------------
Notation:

  JB   Java (but not jfig) bug
  K    killer bug
  B    bug
  I    feature, low priority bug
  F    fix
  N    new feature/function


--------------------------------------------------------------------------

JB
   JDK 1.4.x on Linux has problems with non-US keyboards, again.
   As the JDK does not deliver KeyEvents for such keys, you may
   have difficulties to enter text. For example, entering German
   umlauts does not work on my system. This, however, may also be
   a locale / kernel-related problem.

JB
   in JDK 1.4.x, the new FocusManager appears to be broken on Linux.
   In some cases, the FigSwingCanvas stops processing keyPressed
   events after other jfig dialog windows (namely, ExportOptionsDialog)
   were shown and closed again. This is annoying, as it is no longer
   possible to create text objects after the bug occurs. Note that
   gotFocus() reports that the FigSwingCanvas actually has the
   keyboard focus- but processKeyEvent does not receive any key
   strokes. Textfields in Dialog windows continue to work, however.
   Workaround1: Save your files via the menu and restart jfig.
   Workaround2: Use JDK 1.3.x

I
   should add utility methods to jfig.objects.FigObjectFactory,
   in order to ease creating FIG objects from scripts or Java code.



---------------


04.05.03

F
   fix undo/redo for jfig.commands.UpdateCommand - repeated undo/redo
   should now work.

N
   slightly improved object selection; JModularEditor.findObjectAt()
   now calls minDistanceEuclid for all polylines that fall into the
   2*snapGrid selection region. Still not optimal for abutting 
   rectangles and lines, but somewhat better than before.

F
   fixed jfig.utils.PresentationPDFWriter to actually parse and 
   include all slides from the index (.jpt) file, including the
   first and last slide :-)

30.04.03

N
   updated jfig.utils.PresentationPDFWriter to work with the new
   FreeHep 1.1 API; due to problems/features in PDFGraphics2D we
   cannot recycle the Graphics object but must create a new clone
   for each individual drawing operation. This is currently broken
   for compound objects.

14.04.03

F
   fix inconsistent mouse-button handling (click vs. middle click
   vs. shift left click) in PasteFromClipboardCommand. Also added
   missing repaint after cancel().

11.04.03

F
   changed jfig.objects.FigParser.collect_object_comment() to
   avoid a trailing newline on comments. This is especially useful
   for one-line comments, and should not harm multiline comments.
   (Note that FigWriter already includes a check to add a missing
   newline after a FIG object comment).

N
   first Jython support code for easy jfig scripting (MMKH stuff)

08.04.03

F
   small fix in jfig.commands.PasteFromClipboardCommand.undo()

07.04.03

N
   new class jfig.commands.EditCommentCommand and corresponding GUI
   (menu entry and callbacks) to edit FIG object comments.

N
   added option to break the pasted clipboard selection to
   jfig.commands.PasteFromClipBoardCommand (use middle-click).

F
   fixed FigWriter to enforce a trailing newline when writing 
   per-object comments.

28.03.03

F
   added missing calls to close() input and output streams after using
   them to avoid file locking on Windows (but reported by A.Siebert).

11.03.03

F
   changed JExportOptionsDialog to supply "-eps" option to fig2dev
   for fig2devEPS export. This should work with all recent versions
   of fig2dev.


09.03.03

F
   check for non-null but zero-length strings in jfig.java2d.Fig-
   TextRenderer, because JDK 1.4.1 throws an IllegalArgumentException
   in this situation. 

F
   minor change in jfig.gui.JLayerManager.isSelectedLayer() to avoid 
   a NPE when accessing the layer hashtable.

F
   changed jfig.gui.JModularEditor.findObjectAt() to respect the
   JLayerManager, so that only selected layers are checked for objects.

F
   always use solid lines (instead of dotted, dashed, etc) for arrow-
   heads in jfig.java2d.FigArrow2D.


23.02.03

N
   added FigObject.getComment() and setComment() method, corresponding
   implementation in FigBaseObject and FigPolyline. 

N
   added jfig.objects.FigWriter.write_fig31_object_comment(), as well as
   FigParser.collect_object_comment() and check_add_object_comment(). 
   NOTE: the latter methods are possibly high-risk, as they may break 
   the FIG parser. Also, the global (per file) comment inside the FIG
   header is not yet supported.

21.02.03

N
   new class jfig.gui.JEditVertexDialog to specify x-spline control
   parameters. Not integrated into the editor yet, though.

23.01.03

F
   removed the erroneos "static" modifier for the RULER_XX variables 
   in jfig.canvas.FigBasicCanvas and FigSwingCanvas.

F
   changed jfig.objects.FigParser.parse_fig_file() to tolerate
   empty input lines - which seem to be generated by libwmf.
   Otherwise, this change should not hurt legal FIG files.

10.01.03

F
   replaced some calls to Java2 convenience methods from java.io.File 
   and java.util.Random with their Java 1.1 compatible predecessors,
   which restores JDK 1.1.8 and MS jview compatibility for jfig and
   jfig2...  (Note that JFontConfigurationDialog is still not Java 1.1
   compatible. This will not be fixed.)

07.01.03

F
   some new wordings in /jfig/doc/FAQ

F
   removed a lot of unnecessary "synchronized" modifiers from jfig.
   canvas.FigSwingCanvas. After all, jfig now adhers to the Swing
   single-thread rule, which means that all operations in FigSwingCanvas
   are executed by the event handler thread.
   The only exception is the use of drawAllObjects() for printing,
   but that also is called by the event handler thread.

06.01.03

F
   fix undo and redo in jfig.commands.RotateObjectCommand

N
   added GeometryManager support to CreatePolygonCommand

N
   Many improvements to JFontConfigurationDialog, including callbacks,
   interface to FontCache, tooltips, ...
   Also, integrated JFontConfigurationDialog into JModularEditor

N
   better tool tip texts for JLayerManager

N
   use RegistrationKeyManager to enable layer management and mouse
   wheel listerener...

03.01.03

F
   changed some menu accelerator keys for better Windows compatibility;
   even using CTRL-O for open now... (jfig2 only)

F
   special case to handle zero line width in all Java2D FigRenderer
   classes. The extra check is necessary because Java2D BasicStroke 
   interprets a zero line width as the smallest line possible for the 
   given rendering context.

02.01.03

N
   more infrastructure for checkRegistrationReminder

N
   new class jfig.gui.JTextViewerDialog

01.01.03

I
   the editor does not yet inform JLayerManager when objects are
   created or deleted; if necessary you will have to use the
   "reload" button in JLayerManager to update it. The place to
   integrate an automatic update is probably handleCommandCallback,
   but it is not clear that this function is worth the additional 
   complexity required to implement it...

F
   finally fix push and pop in jfig.gui.JStatusCanvas.
  
N
   first infrastructure for jfig.utils.RegistrationKeyManager. 

N
   added menu items and callbacks to show or hide the JLayerManager
   to jfig.gui.JModularEditor and JEditorMenuBar. The default value
   is taken from the SetupManager property "jfig.showLayerManager".
   Note that this controls only whether the JLayerManager is visible;
   it will only be enabled in a registered copy of jfig.

N
   experimental support for MouseWheelEvent in JStateButton, 
   allowing to increase or decrease the button's state via the
   mouse wheel when using JDK 1.4+. The implementation uses an inner
   class for compatibility with older JDKs.
   Set "jfig.gui.Editor.EnableMouseWheelSupport" to false in .jfigrc
   if you don't want to enable mouse wheel events.

28.12.02

N
   new class jfig.gui.JLayerManager.

N
  added new method jfig.utils.ShellSort.shellSort( int[] ).

F
  call repaint() from jfig.gui.JNumericStateButton.setState(),
  in order to reflect the changed value on the GUI.


23.12.02

F
   (finally) fixed the silly "suppressing future messages" bug in
   jfig.objects.FigParser.

F
   added some more pre-defined rotation angles to the rotationAngle
   button in both jfig.gui.AttribsControls (AWT) and JAttribsControls-
   Factory (Swing). Also added the 360 degrees value, so that rotation
   angles between 270 and 360 degrees can be used.

N
   rotation-aware implementation of jfig.commands.CreateTextCommand.
   executeAndStartNewText(). The new code examines the rotation angle
   of the previous text object to calculate the correct base line
   and position of the next line of text. The spacing of the two
   text objects is (1.2*font height), which seems necessary as the
   FontMetrics returned by the JDKs use a zero value for the leading.

N
   new, rotation-aware implementation of FigText.minDistance().
   The current algorithm calculates the Manhattan distance of the
   given target point to the text object base point, the text object
   axis-parallel bounding box. If the target lies inside the bounding
   box, it next checks whether the target also lies inside the rotated
   bounding box. If so, it uses a fixed distance of 0.9*magnetic grid.
   It then returns the minimum of those distances, which allows to
   easily select the text object, but does not hide other objects.

N
   use lazy initialization for the "JExportOptionsDialog". This
   saves some resources and startup time for users that do not
   use this dialog (like myself), and also enforces the Swing
   single-thread rule for window initialization.

N
   new SetupManager option "jfig.gui.Editor.EnableToolTipManager"
   to enable (default) or disable all Swing tooltips on the jfig
   editor and its dialog windows. Unfortunately, it may be necessary
   to disable the tooltips due to problems (=Java bugs) in the 
   interaction of Swing tooltips and the native window system.
   For example, some versions of the JDK on Windows and MacOS X
   lose the keyboard focus if a Swing tooltip appears that extends
   beyond its parent window...


22.12.02

N
   changed jfig.objects.FigText to always use the full calculation
   (including rotation) for update_bbox() and setCursor().
   This change implies that including text objects in a compound
   will now result in the correct size for that compound, and it
   means that right-clicking a text in CreateTextCommand should
   position the text cursor at the correct character. However,
   it also means that selection of nested rotated text objects 
   may be a little bit more difficult that before.

N
   changed JConsole.println(), message(), consoleMessage(), and
   setText() to comply with the Swing "single-thread" rule.

N
   changed JExportOptionsDialog to use the editor JConsole to
   print warning and error messages.

N
   new SetupManger property "jfig.gui.Editor.ModalEditDialogs" to
   select whether to use modal dialogs for the "edit object" 
   command. Non-modal dialogs improve compatibility with MacOS and
   several X11 window-managers, but should be used with caution.

   For example, command sequences like opening an edit-dialog,
   delete object, edit dialog apply, can lead to unexpected 
   behaviour, especially when combined with undo/redo :-)

F
   some new try-catch blocks in jfig.canvas.FigSwingCanvas to avoid
   problems due to NullPointerExceptions in drawTmpObjects(),
   clippedDrawTmpObject(), and paint().

20.12.02

F
   cleanups and more comments in jfig.utils.SimpleLatexParser.
   Changed the makefile to include SimpleLatexParser.java in the
   jfig2.jar class archive. Updated the jfig/doc/TeX-support.txt
   file to list and document most of the currenly supported macros.
   Added a few macros, e.g. \mathrm.

F
   disable TeX mode when using the AWT renderers; also indicate
   this by disabling the corresponding menu items when using AWT.

19.12.02

N
   new class jfig.gui.JEditXSplineDialog with support to specify
   the control factors for FigGeneralXSpline objects; note that
   the control factors for FigBezierXSpline and FigNormalXSpline
   are shown in the GUI, too, but edits are ignored.

N
   new class jfig.objects.GeneralXSpline.java; this new subclass is
   required to allow us to override the FigPolyline implementation
   of insertPoint() and deletePoint(), while BezierXSpline (cubic) 
   and NormalXSpline (quadratic) should retain the FigPolyline
   methods. Corresponding changes in jfig.objects.FigParser and
   jfig.objects.FigWriter.
   jfig should now be *fully* compatible with xfig X-splines.

F
   improved accuracy for arrowheads on polylines and splines

N
   use "ALT-T" as menu accelerator key to toggle the "TeX" display mode
   in jfig.gui.JModularEditor

F
   changed jfig.gui.ModularEditor initialization so that disabling
   Java2D via "jfig.allowJava2D false" actually works. Also added
   new command line option "-awt" to jfig.gui.Editor.

N
   added "Show TeX strings" GUI control and callback to jfig.gui.
   ModularEditor.

18.12.02

N
   changed jfig.gui.JAttribsControlsFactory and JAttribsButtonPanel
   to create and use a JStateButton instead of a JComboBox to
   select normal/special (TeX) text object support.
   Also added such JStateButton to JEditTextDialog.

N
   added support to display the individual boxes around the 
   characters in jfig.utils.SimpleLatexParser; activate via the
   "-boxes" command line flag. 

N
   changed jfig.utils.SimpleLatexParser to create one Box per
   character; this avoids problems with the (very) inaccurate
   measurements returned by FontMetrics.stringWidth(), because
   the measurement errors do not add up to large values. 
   Several of my test strings look quite acceptable now on Linux
   JDK 1.3.x and JDK 1.4.x. 

17.12.02

N
   lots of new code in jfig.utils.SimpleLatexParser, which now
   handles basic text formatting, FIG colors like \darkgreen, 
   simple TeX macros like \$ or \ , German umlauts ("a"o"u"A"O"U"s),
   supports many math symbols, nested superscripts and subscripts.
   This already allows to render all of my (simple) test formulae.
   The optical appearance is not optimal, however, because the math
   symbols and greek letters are only available in upright 
   Dialog and SansSerif fonts, but not in the better suited
   Serif italic fonts (not to mention the CM or AMS math fonts).

N
   new classes jfig.java2d.FigEllipseRenderer and jfig.objects.
   AWTEllipseRenderer; corresponding cleanups in FigEllipse.
   The AWT renderer now supports rotated ellipses, too, at the price
   of slightly lower performance. Rendering of the "control points"
   is still not optimal for rotated ellipses. The latter, however,
   will not be fixed unless someone complains about it.

F
   minor fixes in jfig.java2d.FigTextRenderer 

I
   looked at a few example FIG files generated by ps2edit, in order
   to decide whether X-Spline (object types 3.4 and 3.5) support
   would be worthwile. It seems that ps2edit generates these objects
   to avoid the "ugly-notches" problem with pure interpolated X-splines.
   Perhaps we should switch back to the old FIG 3.1 style splines :-)


15.12.02

N
   added some code and lots of macros to support mathematical symbols
   via the corresponding Unicode chars in jfig.utils.SimpleLatexParser.

14.12.02

N
   new class jfig.utils.SimpleLatexParser; intended to support
   attributed strings and TeX/LaTeX compatible rendering of text
   objects.

11.12.02

N
   new separate renderer classes for FigImage.

F
   added missing callbacks to handle the line "dash length"
   attribute in jfig.gui.JEditImageDialog

10.12.02

I
   Just to put the information somewhere... On JDK 1.3 Linux, the
   Java VM seems to use an overhead of 12 bytes per object and
   16 bytes per array. For example, an array of 1000 double values
   takes 8016 bytes, an array of 1000 Point[]s takes 20016 bytes,
   a FigAttribs[] takes about 220 bytes, a FigText around 600
   (depending on the String, naturally), and a FigPolyline with
   10 vertices about 900 bytes. Splines are more expensive, for
   example, a 10 vertex 100 interpolated points Xspline requires
   around 3 KB for storage.
   Note that the memory requirements inside Java2D for rendering
   are not included in these figures. On my Athlon-based system,
   loading files with 10.000 objects takes about one second,
   which is fast enough for most of my applications.

N
   changed JSelectFromLibraryDialog to use BorderLayout for the
   JTree panel. Should look better when maximised.

N
   changed jfig.objects.FigRectangle and FigImage to use the
   new class hierarchy. However, support in FigImage is incomplete,
   as filled rectangles may be visible below transparent images.
   (solutions: either override setAttributes() in FigImage, or
   change the rendering to not use the rectangle's fill and rounded
   corners...)

N
   changed jfig.objects.FigArc to use the new class hierarchy;
   corresponding new classes jfig.java2d.FigArcRenderer and
   jfig.objects.AWTArcRender. All polyline objects are now using
   the new architecture.

F
   minor bug fixes in the new FigRenderer subclasses.

09.12.02

N
   next attempt to clean up the jfig class hierarchy, and to avoid
   the ugly mixing and inner-class handling of AWT and Java2D
   rendering. The new architecture encapsulates most of the 
   structural editing functions (constructors, move, copy, addPoint,
   insertPoint, etc.) in the "old" classes like jfig.objects.
   FigPolyline, FigBezier, FigXSpline. 
   Actual rendering, however, is deferred to new classes, which
   come in two flavors, AWT and Java2D. Currently, the AWT 
   rendering classes are in package jfig.objects, while the new
   Java2D renderers have their own, new package, jfig.java2d.
   The decision which renderer is to be used is made by the new
   class jfig.objects.FigObjectFactory which currently has two
   independent (inner) subclasses, AWTObjectFactory and Java2D-
   ObjectFactory.

   Note that the required render classes for FigArc and FigSpline 
   are not ready, yet.

I
   Unfortunately, the memory-savings due to the above changes are
   less than expected. Most importantly, Xsplines still require
   too much memory, partly due to the data representation as Point[]
   instead of int[].
   Also, Java2D GeneralPath objects seem too use quite substantial
   amounts of memory. transit.fig still scrolls slower than in xfig.

N
   new command line options "-awt" and "-old" for jfig.gui.
   JModularEditor, which switch back to AWT1.1 (vs Java2D)
   rendering and old-style splines (vs XSplines).

08.12.02

F 
   fixed a bug in the Q(s) function in jfig.utils.Xspline; standard
   approximated and interpolated splines should now look *exactly*
   the same in xfig, jfig, and fig2dev generated outputs.

06.12.02

I
   the bounding box for filled arc objects is not calculated from the
   full arc (as would be necessary), but only from the control points.
   This may result in "disappearing" objects at certain zoom factors,
   if the control points fall outside the currently visible screen
   coordinates, but the whole arc would not... 
   It is not clear that this should be fixed, because the current
   behaviour seems more intuitive for non-filled arc objects.

F
  changed jfig.gui.JFontConfigurationDialog to use the actual font
  screenshots already available via JFontButton.

N
  some code for RegistrationKeyManager.

F
  change jfig.gui.JSelectFromLibraryDialog to print a warning when
  the specified library base directory cannot be found. Also changed
  the default library directory to ".", that is the current working
  directory. This should allow Windows users to play with the
  select library object command.

N
  improvements to jfig.utils.Gremlins; more tests, some fixes.
  Somehow, the selftest runs very slowly under JDK 1.4.1 on Linux.

05.12.02

F
   fix jfig.commands.CreateArcCommand to handle p1=p2 correctly.


04.12.02

N
   another attempt to use java.awt.Robot for quality testing.
   Still not satisfying, because of (1) WindowManager problems,
   resulting in random events delivered to the wrong components,
   (2) problems to fine-tune the ratio between mouse clicks,
   mouse moves, and key events for the different jfig commands.

03.12.02

N
   new implementation of findObjectAt() in JModularEditor, which
   improves the selection of abutted objects, especially rectangles.
   It also slightly changes the radius used to search for objects.

N
   changed jfig.objects.FigText.minDistance() to use the minimum
   of bbox.minDistance() or the current magnetic snap grid if
   the target point is inside the text.

N
   changed jfig.objects.FigRectangle.minDistance() to dispatch
   to the revised FigBBox.minDistanceInside().

N
   new implementation of jfig.objects.FigBbox.minDistanceInside()
   and minDistanceInsideZero(). As this changes a final method,
   it might be necessary to re-compile dependent classes.

N
   changed jfig.gui.JModularEditor to accept both "-v" and "-vv"
   command line options, where the latter is new and set the
   editor's debug flag (lots of diagnostic output).

29.11.02

   new implementation of jfig.objects.FigBbox.minDistanceInside()
   and minDistanceInsideZero().
F
  add measured font "string with" data (from 12pt 100% magnification)
  to jfig.gui.FontCache, and use this in JFontConfigurationDialog
  to estimate whether the selected locally available TrueType fonts 
  match the size of their FIG Postscript counterparts.
  Still needs more work to (a) understand how the JDKs actually 
  implement Font.derive(), (b) add corresponding GUI controls to access
  bold and italic variants of base fonts, (c) might add a "font size 
  scale factor" to improve jfig vs. xfig layout compatibility.


F
  new findObjectAt() algorithm in JModularEditor which tries to
  improve selection of stacked and abutted objects.

F
  fix jfig.gui.JPropertiesViewer to handle backslash characters
  correctly and to use the JConsole for information/error messages.


28.11.02

N
  first code for jfig.gui.JFontConfigurationDialog.

N
  new SetupManager property "jfig.LookAndFeelClassName", which can
  be used to select the look and feel to be used with jfig2.
  If the property is not set, the default LNF (Metal) will be used.
  On Windows, you may want to uncomment the Windows LnF.

F
  how to calculate the bounding box for "restrictedBboxRubber":
  if the magnetic grid is on, the original object will be some 
  distance (offset_x, offset_y) from the initial mouse click world 
  coordinates position (base_x, base_y).  The object position 
  corresponding to a given mouse position (cur_x, cur_y) is then:
  (delta) = (cur) - (base).
  if (Math.abs(delta_x) > Math.abs(delta_y)) pos = (cur_x, click_y)
  else                                       pos = (click_x, cur_y)
  Therefore, the current clip rectangle is (x,y,w,h):
  pos_x+offset_x, pos_y+offset_y, pos_x+offset_x+bbox.width, 
  pos_y+offset_y+bbox.height
  The total clip region is the union of the object bounding box at 
  the current (cur) and previous (old) mouse positions and the 
  current and old cursor positions. Seems to work now :-)

F
  made "manhattan.gif" transparent

27.11.02

N
  complete re-write of the background color initialization in all
  jfig.gui.J* (Swing) classes. Buttons should now be transparent,
  and all GUI component use the platform default background, unless
  overridden by specifying the "jfig.gui.Editor.BackgroundColor"
  SetupManager property.
  (Note that the JStateButton$SelectDialog classes currently don't
  set their background. Should probably be fixed, too.)

N
  added new methods jfig.commands.Command.getModifiedObjects()
  to allow external programs to query a command object about what
  objects have been modified by the command.
  Corresponding implementation of this method in all command
  subclasses.

F
  changed PasteFromClipboardCommand to set the message console 
  for the FigParser; the command should now work in jfig2.


25.11.02

F
  update status information, indicating experimental nature of jfig2

F
  removed unnecessary reference to FigStatusCanvas from jfig.commands.
  PasteFromClipboardCommand

22.11.02

F 
  second attempt to fix the too-small clip rectangle returned by
  FigCanvasRubberband.getRubberBoundingBox() in bboxRubber mode.
  It turned out that the offset from mouse position to magnetic grid
  position needs to be included into the clip rectangle calculation...

B
  similar to above, FigCanvasRubberband.getRubberBoundingBox()
  returns a wrong (too small) bounding box for restrictedBboxRubber.
  This is especially noticable when playing with large x/y offsets
  near to the x=y diagonal, because the object then changes its
  place radically.


21.11.02

F
  in JModularEditor.main() and Editor.main(), update the editor's 
  directory name when an initial file is specified on the command
  line, in order to get the "open next" and "open previous" file
  shortcuts working. 
  This currently calls java.io.File.getCanonicalFile(), which might
  introduce new, platform dependent, bugs...

F
  fix too-small rubberband clip region when moving objects in
  jfig.canvas.FigSwingCanvas.

11.11.02

F
  changed jfig.gui.JStateButton.mousePressed() to check isMiddleClick()
  before isRightClick(), to get consistent behaviour across all AWT
  and Swing "state buttons" in jfig. Using <shift>+click should now
  decrement the button state in the default MouseMapper settings.

06.11.02

F  
   improve jfig.gui.JAboutDialog to support subclasses.

04.11.02

F
   fix jfig.canvas.FigSwingCanvas to correctly handle mouse clicks
   when top/left rulers are selected.

31.10.02

F
   some more debugging to get the Swing based editor ("jfig2") 
   running under JDK1.1+Swing1.1. It seems that the Swing-internal
   NullPointerExceptions were related to Graphics.dispose() calls
   in FigSwingCanvas. After removing those calls, the Swing-based 
   jfig now works with the swingall.jar from Swing-1.1.1.  

   However, the JTextViewer seems to be missing the scrollbars, 
   until the text viewer window is resized manually.

30.10.02

F
   support top-left rulers in jfig.gui.FigSwingCanvas. 

29.10.02

N
   documented "open next file" in the FAQ.

F
   fixed calculation of bounding box for geometryManagedRubber
   in jfig.canvas.FigCanvasRubberband. Manhattan and Latex style
   restricted geometry should now work in create polyline.

N
   GeometryManager support in jfig.commands.CreatePolylineCommand.
   Note that the geometry mode can not be changed during creation
   of one polyline object.

28.10.02

N
   new class jfig.utils.Gremlins using java.awt.Robot to experiment
   with pseudo-random stress-test of jfig. Robot works, but a
   meaningful test of dialog windows seems difficult. It appears
   that a useful test strategy would have to enumerate all GUI
   components of the topmost currently visible window, and then
   generate events based on the component types. 

   Also, Robot has no support to "leave the WindowManager alone",
   which incurs significant risk of damanging files due to random
   mouse clicks outside of the Java application under test.

N
   working version of jfig.utils.ManhattanGeometryManager, which
   supports Latex line, Latex vector, Manhattan, Mountain, and
   MountHattan geometries. However, not enabled in JModularEditor
   yet.

N
   GUI support for constrained (e.g. Manhattan or LaTeX arrow)
   geometry, but only in the Swing version. This affects classes
   jfig.gui.JAttribsControlsFactory and JAttribsButtonPanel.

27.10.02

JB
   some debugging to find out where in Swing the FigSwingCanvas
   loses the keyboard focus after ExportOptionsDialog was visible.
   Seems to be some kind of bad interaction with the ctwm window-
   manager, again. JDK 1.4.1 seems to work reliably, though.

N
   updates to all documentation files in the /jfig/doc directory.

N
   several makefile updates, added "make swingzip" target which
   created a Swing-only "jfig2.jar" archive.

N 
   triple buffering option is jfig.canvas.FigSwingCanvas. This
   allows to trade-off reduced flickering vs. render performance.

26.10.02

F
   removed now unused AWT-only methods from jfig.canvas.FigSwingCanvas.

F
   removed several anonymous inner classes from jfig.gui classes, to
   avoid the excessive code size bloat implied by inner classes.

25.10.02

N
   experimental class jfig.utils.PresentationPDFWriter based on
   PDFWriter, which parser a JPT presentation index file and
   generates a multi-page PDF script from it. Works astonishingly
   well.

N
   experiments to access the PDFWriter and PDFGraphics2D classes
   from the org.freehep class library, in order to provide 
   pure Java export to PDF. Mostly works, but no integration yet.
   However, printing fill patterns seems to be broken; also,
   printing graphics that are larger than one DIN-A4 / letter
   page seems to result in curious overflows.

24.10.02

F
   minor fixes in jfig.canvas.FigBasicCanvas, TopLeftRulerCanvas,
   and FigSwingCanvas to behave correctly when showRulers(boolean)
   is called:  
   o remove redundant variables from subclasses, 
   o call setRulersOffsets() from showRulers(), 
   o implement the correct values for the RULER_OFFSETS, 
   o disable drawRulers() when showRulers is false.

N
   new class jfig.utils.FileTreeNode to represent (FIG) files in
   a Swing JTree. Also implemented the traverseFileSystem() method
   to recursively find all FIG files below the given root directory.
   This will be used for the SelectObjectFromLibrary command.
   Note: searching through a file system can take a while; this 
   should probably print a warning if the number of files is very
   large...

F
   removed "without a visible AWT parent" warning from jfig.gui.
   ImageHelper if a JDK of version 1.3+ is detected. 

N
   added new method setCaretPosition() to jfig.gui.JTextViewer.
   This allows to scroll a loaded file/resource text to any position.

N
   full implementation of jfig.commands.JEditObjectCommand and the
   jfig.gui.JEditBaseobjectDialog, JEditRectangleDialog, 
   JEditImageDialog, JEditEllipseDialog, JEditTextDialog,
   JEditCompoundDialog, and JEditPolylineDialog windows.
   Note that JEditTriggerDialog is not yet implemented.

N
   use RenderingHints.KEY_INTERPOLATION besides RENDERING_QUALITY

23.10.02

F
   added unused colors to buttons.gif, because JDK 1.3+ on Windows
   seems to think that 2-color GIFs are always black and white.

F
   avoid StackOverflowError due to Swing calling CheckBoxMenuItem
   setState -> fireItemEvent -> Editor.itemStateChanged -> setFigVersion
   -> CheckBoxMenuItem.setState...  This seems to be fixed in JDK 1.4,
   but in JDK 1.3.x the only workaround seems to be removing the
   ItemListeners from the MenuItems, updating the MenuItems, then
   adding back the ItemListeners.
 
F
   call setIconImage() on all instances of JPropertiesViewer, JConsole, 
   and JTextViewer

F
   implement missing functionality in JEditRectangleDialog and
   JEditImageDialog

F
   fix wrong callback name (doUpdateObject) in KeyHandler/ModularEditor

F
   use slightly shorter tooltip texts in JAttribsControlsFactory, 
   to avoid window manager problems on MS Windows: a modal dialog may
   lose focus if a tooltip text appears that doesn't fit into the
   parent frame window... (JDK1.3.1/Windows)

22.10.02

N
   new Swing GUI classes jfig.gui.JEditBaseobjectDialog, 
   JEditRectangleDialog, JEditEllipseDialog, JEditPolylineDialog,
   JEditImageDialog, JEditTextDialog

N
   started new class jfig.commands.JEditObjectCommand, but not
   finished yet.

N  
   new classes jfig.utils.FigFileFilter (*.fig, *.txt) and 
   jfig.utils.ImageFileFilter (*.gif, *.jpg, *.png, *.ppm, *.xbm).
   Changed JModularEditor and JCreateImageCommand to use these
   filters.

N
   new class jfig.gui.JExportOptionsDialog - this is just a 1:1
   Swing copy of ExportOptionsDialog. The rewrite does not yet fix
   the "command line quoting problem".

N
   major cleanups in jfig.canvas.FigSwingRubberband. Now again using
   the naive drawing algorithm for drawGrid(), checking canvas size
   changes in paintComponent(), etc.

F
   added missing support for Rubberband "noRubber" mode to 
   jfig.canvas.FigCanvasRubberband.getRubberBoundingBox()
  

21.10.02

N
   use reflection in jfig.commands.AlignObjectsCommand to avoid 
   strict dependence on ModularEditor.

N
   use JFileChooser instead of java.awt.FileDialog throughout
   jfig.gui.JModularEditor. Try to consistently use the new API
   of javax.swing.JFileChooser.

F
   changed jfig.gui.JModularEditor.doSaveToConsole() to use the
   Swing JConsole instead of AWT jfig.gui.Console.

N
   new class jfig.gui.JStringDialog, use in JModularEditor.
   doSelectURL() and doMergeURL().

N
   new classes jfig.gui.JCreateImageDialog and jfig.commands.
   JCreateImageCommand, support for JFileChooser.

N
   first attempt at jfig.gui.JSelectFromLibraryDialog. However, it
   seems that using a JTree presentation of the FIG libraries would
   result in a much better implementation that just copying the old
   FIG 3.2 style AWT dialog window.

I
   should fix the remaining call to Console.getConsole() in FigParser, 
   which needs to check whether to create the AWT or Swing based console 
   window. The current solution is to call FigParser.setConsole()
   from JModularEditor, which also works (if less robust).

F
   made jfig.gui.(J)NumericStateButton.selectDialog a modal dialog.
   This seems to fix the "nested dialog" window focus problem. Ooops.

N
   new class jfig.gui.JEditGlobalAttributesDialog

F
   created jfig.commands.JOpenCompoundCommand 

N
   changed jfig.gui.JModularEditor to use a JColorChooser instead
   of jfig.gui.AddUserColorDialog.

F
   removed unused class jfig.gui.AboutImageCanvas

F
   changed jfig.commands.MoveObjectCommand to retrieve the status
   of "smart links mode" via reflection, to support both the AWT
   and Swing (J)ModularEditor. This in turn uncovered a missing
   initialization and missing getSmartLinksMode() method in
   (J)AttribsControls(Factory) and (J)AttribsButtonPanel.


20.10.02

N
   changed jfig.gui.JModularEditor to use the (modified) KeyHandler,
   JConfirmDialog, JPropertiesViewer, and JConsole classes. 
   Also fixed all "help" callbacks to call the new utility function 
   showTextViewer(), which now creates a JTextViewer instead of a 
   SimpleTextViewer.

N
   changed jfig.gui.KeyHandler to expect a FigBasicEditor instead
   of ModularEditor - this allows to use KeyHandler for the Swing
   based JModularEditor, too. Note that this is only a short-term
   solution. Using the call() method from FigBasicEditor, a much
   better and extensible string->command hashtable based solution 
   is possible. KeyHandler would construct a mapping from strings
   like "CNTL-ALT-x" to the corresponding editor function, and
   construct the key used for lookup from the KeyEvent modifiers
   and keyCode/keyChar.

19.10.02

N
   added method call( String, Object) to jfig.commands.FigBasicEditor,
   which should make the AWT->Swing conversion much easier, as it
   is possible to directly use the existing callback mechanism in
   (J)ModularEditor.

N
   changed jfig.commands.OpenCompoundCommand to support both the
   AWT and Swing (J)CloseCompoundDialog windows, made possible via
   reflection.

B
   WARNING:  JConsole is not currently thread-safe, because the
   println() etc. methods directly call JTextArea.setText().
   This needs to be fixed via (1) adding separate methods like
   printlnThreadSafe(), or (2) (better and more complicated) by
   changing println() to check for the calling Thread and using
   SwingUtililities.invokeLater() automatically.

N
   new Swing classes jfig.gui.JConsole, JPropertiesViewer, 
   JConfirmDialog, JCloseCompoundDialog


17.10.02

N
   changed jfig.commands.UndoStack for Swing compatibility. The class
   now gets Objects instead of MenuItems and accesses them via
   reflection.

N
   Swing re-implemantation of AttribsControls using the newly
   created Jxxx components. Name change to JAttribsControlsFactory.

N
   more Swing updates: jfig.gui.JStateButton, JColorButton, 
   JUpdateModeButton, JFontButton, JFillPatternButton,
   JNumericStateButton, JAboutDialog, JTextViewer.


16.10.02

N
   new classes jfig.gui.JModeButtonPanel and JAttribsButtonPanel,
   using pure Swing (JComponent) subclasses.

N
   new class jfig.gui.JEditorMenuBar, a Swing-based re-implementation
   of EditorMenuBar. This in turn required JRecentFileManager,
   as MenuItem and JMenuItem only share the Component base class...

N
   some more experiments to improve FigSwingCanvas rendering - the
   current implementation leads to a lot of flickering under JDK 1.3+
   on Windows. Unfortunately, this behaviour is the same as that of
   the original Sun demos (like BezierAnim), and may be unavoidable.
   There really should be documentation about those issues.
   Also fixed inconsistent initialization for very small canvas size
   in FigBasicCanvas.initializeOffscreenBuffers.

15.10.02

N
   xfig 3.2.3d compatible implementation of the "draw freehand line" 
   command. The new implementation does not use the existing class
   CreateFreehandCommand, but integrates the MouseMotionListener stuff
   from CreateFreehandCommand right into CreatePolylineCommand.
   The resulting class fully implements the xfig user interface with
   left click: polyline, middle click: freehand line, right click: 
   cancel functions.

   Note that CreatePolygonCommand does not (yet) include the freehand
   option, because the straight-lined-closed freehand polygons from
   xfig seem kind of funny to me. Please don't hesitate to complain
   if you should actually require the freehand polygons.

N  
   first infrastructure to collect editor usage statistics - to
   be used with a registration / shareware fee reminder, soon.

B
   Note that FigSwingCanvas.setShowRulers( false ) does not work
   perfectly: the rulers are correctly hidden, but the grid does
   not fill the freed space. Needs to be fixed soon.

F
   renamed FigDemo (created yesterday) to jfig.gui.EmbeddedFigDemo;
   the file now relies on Swing instead of AWT components only, uses
   the new doZoomFit() method in FigCanvas, and has a new method to
   create (random) rectangles.

F
   the multitude of doZoomRegion() and doZoomFit() behaviours found
   across the different subclasses of FigCanvas still needs to be
   cleaned up. However, the new doZoomFit() method should help in
   many cases.

N
   added the doZoomFit() method to jfig.canvas.FigCanvas, as this 
   method is useful im most editors and viewers. Added (working)
   implementations to both FigBasicCanvas and FigSwingCanvas.
   The behaviour of subclasses that already implemented doZoomFit()
   previously (PresentationViewerCanvas and hades.gui.ObjectCanvas)
   should be unchanged, because of method overriding. 

I
   looked at the "transit.fig" example again, it seems that most
   of the Xsplines used in that file require about 200..1000 points
   for rendering. Obviously, recalculation of all points after a
   simple viewport panning is not very efficient.
   Also note that the current implementation of FigCompound.paint()
   still does not do visibiliy checks for its children - because
   it doesn't have the viewport bounding box coordinates. 
   Calculating the viewport bounding box would be possible via 
   getObjectPainter().getViewportBoundingBox(), but as many compound
   objects hold only a few children, it is not clear that this overhead 
   is really worth it. 

F
   extra try-catch in RecentFileManager to workaround JDK118/linux
   MenuItem.setLabel problems...

F
   restructured the editor menus for better xfig compatibility;
   the "window" menu is now called "view" and also includes the
   Java2D rendering options.

F
   better bounding-box calculation in FigCanvasRubberband for
   lineRubber and rectRubber with "show line lengths" enabled;
   required to get artefact-free rendering in FigSwingCanvas.

F
   after the FigCanvas cleanups, FigBasicCanvas and FigSwingCanvas
   can both be used as the main editor canvas. For performance
   reasons and (future) Swing compatibility, we use a FigSwingCanvas 
   for JDK 1.3+ and a FigBasicCanvas von JDK 1.1x and JDK 1.2x



14.10.02

F  changed the default arrow size to 3mm width and 5mm length,
   which better suits my preferences (at A4 paper size, zoom 1:1).

F
   improved and updated the information in jfig/doc/FAQ.

N
   added jfig.gui.ModularEditor.writeFigObjects( OutputStream )  
   method to complete the API required to embed jfig into other 
   applications.

N
   fully implemented the "line length" rubberbanding for both polyline
   and rectangle operations. As in xfig 3.2.3d, the line length is
   shown in the currently selected units (inches, mm, xmm).

   By the way fixed the rectangle rubberbanding bug for zero-height 
   or zero-width rectangles.

N
   new jfig-menu-window-"show line length" control to switch on/off
   the line length rubberbanding.

N
   added menu item and callback to jfig.gui.ModularEditor to include
   the new "embedding.txt" documentation into the jfig editor help 
   menu.

N
   wrote some documentation on how to integrate jfig as a viewer
   or editor component into other applications. Also added the new
   class jfig.gui.FigDemo to demonstrate how to load and display
   a FIG file. 

F
   added the doZoomFactor() method from hades.gui.Editor to
   jfig.gui.ModularEditor to cleanup the mess of different zoom
   methods. This also means the the FigCanvas interface can now 
   be stripped of some unnecessary methods.

N
   added a few methods to the FigCanvas interface to improve the API:
   requestRenderQuality(), requestAntiAliasing(), 
   setRubberbandShowLineLengths().

11.10.02

N
   experiments to improve rendering (especially rubberbanding) perormance
   on JDK 1.3 and JDK 1.4 on Linux. Seems that using the FigSwingCanvas
   based redraw algorithm is much faster on Linux that the FigBasicCanvas
   method - probably due to internal double buffering in the JDK.


N
   first tests to implement the "line length" rubberbanding available
   in xfig 3.2.3d. Basically works, but text rendering is broken in
   XORMode on JDK 1.3+ on both Windows and Linux (while PaintMode
   works. This means that the FigBasicCanvas rubberbanding does not
   work in this situation.)

30.08.02

F
   fixed writing the wrong (inverted) arc subtype field in 
   FigWrite.write_fig31_arc(). This means that saving open-ended
   arc objects with arrows should now be compatible with xfig
   and fig2dev. 

I
   set DoubleClickIsMiddleClick false in .jfigrc, as this seems
   to conflict with some JDKs. Enable this function in your 
   private .jfigrc if you want it.

21.07.02

F
   fixed MouseMapper.checkDoubleClickIsMiddleClick to also
   check for a left-button (BUTTON1_MASK) click, in order to
   avoid detecting middle- or right-button double-clicks.

19.06.02

N
   integration of RecentFileManager into ModularEditor and 
   EditorMenuBar.

N
   added class jfig.utils.RecentFileManager; API based on
   org.freehep.swing.RecentFileList

17.06.02

N
   changed MouseMapper to allow a double-left-button click as
   a substitute for a middle-button click. This might help Windows
   users and jfig newcomers...
   Set "jfig.utils.MouseMapper.DoubleClickIsMiddleClick" in the
   .jfigrc configuration file to disable/enable this feature.

14.06.02

F
   changed jfig.utils.SetupManager.<<init>> to check for a
   SecurityManager and for checkPropertiesAccess, to improve the
   applet compatibility.

31.05.02

F
   new class jfig.objects.FigGlobalAttributes as a first step
   towards the reorganization of the jfig object attributes management.
   Code refactored from jfig.commands.SelectObjectFromLibraryCommand
   and reused for ModularEditor.doMergeFile.
   This fixes the bug that would overwrite the previous global 
   attributes (e.g. paper size) when merging a file.

26.04.02

N
   Changed jfig.gui.StateButton.mousePressed() to interpret the
   <shift>+<rightclick> button combination to decrement the current 
   state, while <rightclick> still increments. This improves the
   usability on Windows or other two-button mouse systems.

   Similar changes to jfig.gui.ColorStateButton and NumericStateButton.


26.03.02

F
   Fixed jfig.commands.CreatePolylineCommand, CreateSplineCommand,
   etc. to call editor.deleteTmpObject() when the command is canceled.
   This removes the unfinished polyline objects from the canvas
   which otherwise can stay around for a long time (and only vanish
   when saving the file). Detailed bug report by M.D.Gore.

27.02.02

N
   Better support for "smart links" in jfig.commands.MoveObjectCommand, 
   which now handles polylines pointing to compound objects, too. 
   This fix was contributed by Matt Quail. Thanks!

25.02.02

I
   One user reports that Symantec Norton Antivirus detects the 
   "Backdoor.EggHead" trojan horse in the cygz.dll used for our
   Windows fig2dev3.2.3d. As far as we know, this is a false alarm, 
   but be careful.

B
   User feedback reports a printing regression for the jfig applet 
   under MSIE 5.5 on Win2000. There are also problems with applet
   printing under JDK 1.3.1.  

21.01.02

N
   added epic/eepic support to jfig.gui.ExportOptionsDialog, 
   patch submitted by Tomas Palma.

F
   changed jfig.utils.SetupManager.loadGlobalProperties to check
   for a leading slash in the filename. The method should now work
   with both "jfig/jfig.cnf" and "/jfig/jfig.cnf" style arguments.

16.01.02

N
   added jfig.objects.FigAttribs.setLineColor and setFillColor.
   These utility methods take a java.awt.Color argument and create 
   a new FIG user color if the requested color was not registered
   previously.

15.01.02

N
   implemented jfig.gui.PropertiesViewer.doApply and changed the
   doSaveXXX method to really read the current values from the
   viewer text area. This allows the user to edit the property 
   keys and values before saving them to the user- or local-
   property files.

F
   fixed method access to allow subclasses in external packages
   for jfig.gui.PropertiesViewer. 

09.01.02

N
   preliminary support for grid and magnetic grid with decimal
   subdivision (actually 1:5 for the grid) in FigBasicCanvas and
   FigTrafo2D. This means that objects edited with the default
   xfig grid settings should not be off-grid anymore.

04.01.02

N
   new key-bindings in jfig.gui.ModularEditor for the VK_PAGE_UP
   and VK_PAGE_DOWN keys. Those keys open the previous/next FIG
   file (sorted alphabetically) in the current working directory.
   This allows to browse through many files and is as fast as
   a preview function in the file dialog would be :-)

F
   new class jfig.utils.ShellSort (taken from hades.utils). 
   Replaced all local shellSort() methods used in jfig by calls to 
   ShellSort.shellSort()

02.01.02

N
   version 1.55: includes all recent fixes, "Create freehand line"
   and "Add user color" commands, new "biohazard" example.

F
   several minor makefile fixes and cleanups.

F
   changed FigBaseobject.scale() and all derived methods to use the
   absolute (positive) scalefactor values when updating object
   attributes. This avoids the "negative line thickness" bug turned
   up by Java2D.
  

30.12.01

F 
   added WindowListeners to most dialog windows, allowing to close
   them via the window-manager decorations (e.g. the Windows
   "x" button).

   Note that the "edit object" dialogs call doCancel() when 
   closing the dialog window via the window-manager. 

F
   fixed the rotate command in jfig.objects.FigEllipse, allowing
   to rotate a circle/ellipse object around arbitrary anchor points.
   Added the biohazard example file, which was created by rotate-
   and-copy of FigEllipse objects.

F
   added jfig.gui.AddUserColorDialog. The dialog expects a
   string with RGB color specification (e.g. "0xff0000" for red)
   and creates the corresponding user color.

29.12.01

N
   added the "create freehand line" command callback to UserEditor
   (run java jfig.gui.UserEditor).

N
   hacked a first version of jfig.commands.CreateFreehandCommand.

23.12.01

F
   fixed jfig.utils.PresentationBuilder to mangle the pathnames
   used in the presentation index file. The new version converts 
   backslashes (Windows style separator) to slashes always.
   This was necessary, because the jfig.utils.PresentationParser 
   parser uses StreamTokenizer, which would incorrectly interpret 
   backslashes as escape symbols...
   Creating jfig presentations on Windows should now work (tested
   on Windows XP only).

19.12.01

B
   some more debugging for the Windows redraw problems. I am now
   fairly convinced that JDK 1.3.1 is broken both on Windows
   (tried WinXP, DirectX 8.1, nVidia and Win98, DX8, ATI) and
   Linux (same hardware configurations). The AWT is correctly
   calling Graphics.drawImage to bitblt the background buffer,
   but the drawing operation is never performed :-(

   Workaround:  Use JDK 1.3.0 which works well.

F
   changed jfig.objects.FigWriter.getLineThickness() to support 
   linewidth 0 lines. The previous version would incorrectly
   substitute linewidth 1 in this case (off-by-one bug).

N
   added support to jfig.commands.CreateImageCommand to "remember" 
   the directory last used to search for image files. This greatly
   improves the usability of jfig in cases where the FIG-files
   and the image files used for Image-Objects are not in the same
   directory.  

   As a new CreateImageCommand instance is created for every new
   object, we save the directory name in a SetupManager property
   called "jfig.gui.CurrentCreateImageDirectory".

N
   began work to implement a "file history" for jfig. This will
   include the automatic parsing and saving of a $user/.jfig-history
   file which contains the corresponding key/filename properties.
   A separate file is used, because this makes it easier to leave
   hand-written .jfigrc files intact.

   An example of the properties is saved in .jfig-history:
   jfig.gui.CurrentCreateImageDirectory c:\users\hendrich\images
   jfig.gui.CurrentFigFileDirectory c:\users\hendrich\figs
   jfig.gui.LastFigFile1 c:\users\hendrich\figs\welcome.fig
   jfig.gui.LastFigFile2
   jfig.gui.LastFigFile3
   jfig.gui.LastFigFile4

N
   lastFile1MenuItem..lastFile4MenuItem in jfig.gui.EditorMenuBar

F
   some changes in jfig.commands.CreateImageCommand to really
   show() and toFront() the image options dialog. The resulting
   behaviour works on Linux/JDK 1.3.0 and Windows/JDK 1.3.0,
   but still has problems on my Windows-XP/JDK 1.3.1 test install...


17.12.01

N
  added new methods to jfig.gui.PropertiesViewer and made the TextArea
  editable. After this changes it is possible to edit jfig properties
  directly and in the PropertiesViewer and to save them to the user-
  or local properties file.  Note that jfig will ignore the changes
  until it is restarted.

  The new methods are writeProperties() and checkShouldWriteProperty().
  Together they will write an alphabetically sorted list of all 
  "jfig" properties without the "global" and "Java" properties.
  This is achieved via checking for the property name in checkShould-
  WriteProperty. Overriding this method will allow tricks like using
  PropertiesViewer in Hades, too.

16.12.01

N
  added SetupManager variable jfig.gui.Canvas.RequestFocusOnMouseEnter
  and corresponding test in jfig.canvas.FigBasicCanvas.mouseEntered().
  You may want to set this variable to true on X11/Unix systems.

F
  some more tweaking of the Windows-JDK131 redrawing... 
  Unfortunately, there is still a flickering when showing the
  file selection dialog window.
  This seems due to a (known) JDK bug. Depending on your Windows,
  DirectX, and graphics card driver versions, you may be able
  to get rid of the flicker via the following command line option:
  java -Dsun.java2d.noddraw=true jfig.gui.Editor

13.12.01

F
  finally found the Windows-JDK131-dialog-redraw-problem. Aaarrrggghhh!
  Except for an unneccessary refresh when showing the open-file dialog,
  redrawing should now again work in Windows. As it turned out, the
  bug was a real bug in jfig.canvas.FigBasicCanvas, and not a race
  condition in the JDK, as I suspected for so long. This means that
  I was also able to remove all of the Thread.sleep() stuff inserted
  for debugging purposes, resulting in much faster canvas scrolling.

N
  added the "crop filename" options to jfig.gui.CreateImageDialog,
  in order to ease the creation of relative filenames from the
  names returned by the FileDialog.

12.12.01

F
  another attempt to fix the (annoying) redraw problem when opening
  a new file on Windows... 

03.12.01

F
  added some class documentation comments in ModularEditor.

16.10.01

N
  some documentation (FAQ, mouse-buttons, jvm-compatibility) updates
  and cleanups.

15.10.01

B
  user feedback pointed out that jfig is no longer compatible with
  the (updated FIG 3.2) specification:  with xfig 3.2.3d the specs
  for arc objects changed.

28.09.01

F
  some more nullpointer checks in jfig.canvas.FigBasicCanvas for
  better compatibility with JDK 1.3.1 and JDK 1.4 beta (Linux).

31.07.01

F
  changed jfig.objects.FigWriter to appand a trailing space character
  after writing the paper size specification in the FIG 3.2 header:
  fig2dev seems to expect this. Therefore, jfig created files should
  now also work in fig2dev (Windows) when "Letter" size paper is
  selected.

23.07.01

F
  made jfig.gui.ColorCache.getColorCache() synchronized to avoid
  race conditions with multiple FIG-applets on a single web page.

17.07.01

N
  complete website overhaul on tech-www/applets/jfig, with separate
  pages for: overview, editor, applet, presentations, download

16.07.01

N
  complete documentation overhaul (README, FAQ, ...)

13.07.01

N
  added a new (rather, restored the ancient) algorithm for drawing the
  grid in jfig.canvas.FigBasicCanvas, as the current implementation
  via calls to Graphics.copyArea has major problems with JDK 1.4 beta
  and Swing. This is due to the fact the copyArea() is implemented
  asynchronously, resulting in additional races for the drawing calls...

  The new algorithm just draws all individual grid points by so many
  calls to Graphics.drawLine. While this was very slow in JDK 1.0
  and early JDK 1.1 times, it doesn't do so bad now. Timing tests
  on my Linux box show that drawing all the points is at most a few
  milliseconds slower than the copyArea trick.

  Therefore, the drawGrid method was renamed to drawGridViaCopyArea,
  the new (=ancient) algorithm to drawGridByHand, and drawGrid now
  merely selects which variant really to call...

10.07.01

N
  another attempt to get fully xfig-compatible bindkeys. The KeyHander
  class now includes a hack which allows to specify bindkeys via
  "e" (ellipse) "CTRL-e" (edit object) or "META-f" in the jfig.cnf/.jfigrc.
  Unfortunately, the AWT still does its own mangling of keys once the
  CONTROL modifier is pressed, and so the "CTRL" key combinations still
  don't work. Most bindkeys, however, are now xfig compatible.

  If you want to keep the oder jfig settings, just edit your .jfigrc.

27.06.01

N
  changed the parsing of embedded image (GIF/JPG/...) objects in
  jfig.objects.FigParser.parse_fig_polyline to allow image filenames
  with spaces in them, e.g. "c:\Eigene Dateien\titanic.jpg".
  This was done with a quick hack and is not fully tested yet.

19.06.01

N
  first GUI support for line width 0 in jfig.gui.AttribsControls,
  also updated jfig/images/buttons.gif. However, no support in 
  the jfig.objects.* classes (yet).

N
  added initialization to the jfig.gui.EditorMenuBar menu items for
  the Java2D antialias and rendering quality hints. Also added 
  corresponding attributes to the jfig.cnf (jfig.Java2D.AntiAlias, 
  jfig.Java2D.RenderingQuality). After these changes, it is now
  possible to start jfig in "high-quality" mode.

F
  fixed an annoying problem in jfig.utils.SetupManager.getBoolean()
  which would not correctly report true/false values due to spurios
  trailing spaces.

18.06.01

N
  some more AWT and jfig related bugs listed and documented here...

15.06.01

N
  in jfig.gui.PropertiesViewer (menu->options->show properties),
  added the option to save the current jfig properties as .jfigrc
  startup files in the user's home directory or the current working
  directory. This makes it much easier to create user defined settings.

  However, the current implementation relies on java.util.Properties.
  store() which results in "unsorted" properties files.
  

06.06.01

N
  added jfig.objects.FigObject.rebuild() method stub and a first
  implementation to all FigBaseObject subclasses. This method allows
  to re-initialize any given object. The first use is to switch
  between Java2D and AWT11 (e.g. for printing from JDK 1.3 appletviewer).

05.06.01

F
  some more fixes and changes in jfig.canvas.FigBasicCanvas to 
  get applets to print in MSIE. 

02.06.01

N
  added getAppletInfo() and getParameterInfo() to SimpleFigApplet.
  Also cleaned up the popup menu initialization and added a
  help menu item together with a (very basic) help viewer.

01.06.01

F
  fixes in jfig.canvas.FigBasicCanvas to detect and handle when
  paint() is called with a PrintGraphics object. This allows to
  print the SimpleFigApplet from appletviewer and Netscape 6.
  Applet printing from MSIE seems still broken, however.

F
  fixed the statusMessage() method in jfig.objects.FigParser 
  to suppress useless messages during SimpleFigApplet initialization
  on non-Java2D browsers.

15.05.01

N
  added minDistanceEuclid to jfig.objects.FigObject, corresponding 
  dummy implementation in FigBaseObject, and real implementations
  useful for better object selection in FigPolyline, FigRectangle,
  and FigCompound. No update to Fig<xxx>Spline yet.

F
  Complete rewrite of getMinPerpendicularDistance in FigPolyline,
  which should now work (though it is currently not used in jfig).

14.05.01

N
  xfig-compatible handling of stacked-object selection in
  jfig.command.EditObjectCommand (shift+click to select,
  normal click to execute).


08.05.01

F
  renamed the "cursor snapping" (a false friend...) menu to 
  "magnetic grid"

F
  fixed the middle/right mouse button compatibility stuff
  (like <shift>+left click) in jfig.gui.StateButton

F
  workaround in jfig.objects.FigWriter to write X-splines in
  FIG 3.1 format by creating temporary FigBezier objects: this
  is slow but should work...

07.05.01

N
  allow to specify (ASCII) chars as keyboard shortcuts via
  jfig.cnf properties, e.g. "jfig.gui.KeyHandler.CreatePolyline p" 

04.05.01

F
  fixed detection of operating system from "os.name" property.
  Several workarounds should now be enabled...

F
  cleaned up the MouseMapper handling in all command.xxx classes.
  Also changed the default setting in jfig.utils.MouseMapper to use 
  ShiftDownLeftClickIsMiddleClick.

03.05.01

F
  some documentation (FAQ, mouse buttons, CHANGES) updates.


25.04.01

N 
  webpage update, added links to the simple FIG applet demo page.

F
  fixed a bug in jfig.objects.FigXSpline which resulted in wrong 
  arrowhead setup on (open) splines.

F
  fixed jfig.utils.Xspline.addPoint() to check for and ignore doubly
  added points.


24.04.01

N
  made jfig.gui.SimpleFigApplet useable: added zoom and panning
  functions, popup-menu, key- and mouse-listeners.  Also wrote 
  a simple HTML demo (/applets/jfig/applet-demos/simple-applet.html).
  Unfortunately, Netscape 4.x still has problems with the applet.

F
  makefile update: building jfig.jar now includes only the
  necessary classes. Also, we don't include xfig.ps.gz.
  Together with using javac -g:none this reduced the jfig.jar
  file size from 882905 to 609258 bytes...

20.04.01

N
  New classes jfig.objects.FigNormalXSpline and FigBezierXSpline
  to implement xfig 3.2.x compatible spline behaviour.
  There are realized as simple subclasses of FigXSpline which just
  set the scalefactors to [0,1,1,...,1,0] and [0,-1,-1,...-1,0]

N
  Added property jfig.enableXSplines to jfig.cnf: set this to "true"
  if you want to use Xsplines instead of the FIG 3.1 splines.

  Added support for X-splines to all classes used to create or
  work with spline objects: jfig.commands.Create(Closed)SplineCommand,
  Create(Closed)BezierCommand, ConvertObjectCommand,
  FigParser, FigWriter.

  At the moment, jfig and fig2dev 3.2.3 seem to interpret X-splines
  identical, while xfig draws Bezier-style X-Splines wrong...
  This seems to be due to xfig using an inadequate value for the 
  "precision" parameter during creation of the Bezier-splines.

  Warning: writing Bezier-type X-Splines in FIG 3.1 format is not
  supported.


16.04.01

N
  new class jfig.utils.Xspline to experiment with FIG 3.2 X-Splines.
  Building both open and closed splines seems to work already...
  To my surprise, it took just 2 hours to translate u_draw.c :-)


12.03.01

F
   fixed Swing 1.1.1 NullPointerExceptions under JDK 1.1.8 / jview
   in FigSwingCanvas. This requires a "hacked" version of swingall.jar,
   because the problem is in Swing (SwingGraphics.paintImmediately)
   itself.

11.03.01

N
   many changes to the jfig.objects.Fig<objecttype>.Painter2D inner
   classes to support the Swing redraw mechanism. Basically, all
   paint() operations now check for the AffineTransform preset by
   Swing in the current Graphics2D context, and preConcatenate this
   transformation to the current jfig transformation.

   This also works to support the PrinterGraphics transformation
   for Java2D printing, allowing us to remove most of the printer
   specific code in the Painter2D inner classes.

N
   display a text cursor for all text operations. This should now
   work (in principle) also for rotated texts unter Java2D, and it
   does with IBM JDK 1.3 on Linux. However, Sun JDK 1.3 has problems
   and displays the correct cursor location only for normal text
   objects, while rotated objects show an offset between the correct
   and the Sun JDK 1.3 position.

N
   reworked the tmp-text-object redraw strategy for jfig.canvas.
   FigSwingCanvas, which should now work flickerfree and with the
   correct (and minimal) text bounding box.

09.03.01

F
   a few (and so far unsuccessful) experiments to make FigSwingCanvas
   compatible with Swing 1.1.1. This currently works after some
   initial NullPointerExceptions, as long as double buffering is
   disabled for Swing components. Enabling double buffering causes
   Swing-internal NPExceptions on all of MS jview, JDK 1.1.8 Windows,
   and JDK 1.1.8 Linux.

F
   changed SetupManager to suppress the useless exception traces
   when setup files are not found. 

08.03.01

N
   some more performance tuning for FigSwingCanvas redrawing.

07.03.01

N
   added the getRubberBoundingBox() and getBase() methods to 
   jfig.canvas.FigCanvasRubberband needed to implement efficient 
   rubberbanding for Swing based GUIs. Performance is more or less
   acceptable on 400+ MHz systems under JDK 1.3, with the exception
   of diagonal lines across the canvas (which requires repainting
   the full canvas).


04.03.01

N
   new attempt to get a Swing based object canvas working - which needs
   a completely new redrawing strategy, due to the internal buffering
   of the Swing paint architecture. 
   The current implementation of jfig.canvas.FigSwingCanvas uses many
   paintImmediately() calls to repaint the rulers, rubberband, and
   tmp objects. 
   

02.01.01

F
   fix to make jfig.gui.EditCompoundDialog compatible with Java 1.1 again.


28.12.00

N
  new option to automagically change the depth (layer+=10) and color 
  (white) of embedded image objects to jfig.gui.CreateImageDialog
  and jfig.commands.CreateImageCommand. Can be preset by setting
  jfig.gui.CreateImageDialog.LayerCorrection true/false in jfig.cnf.

17.12.00

N
  implemented a 'direct text editing' function similar to xfig3.2.3c
  in EditCompoundDialog.java.


04.12.00

F
  more complex initialization: jfig now looks for property settings
  in five places:

  1. global: resource:/jfig/jfig.cnf (inside the jfig.jar archive)
  2. user:   ~/jfig.cnf              (user home directory)
  3. user:   ~/.jfigrc               (user home directory, hidden)
  4. local:  ./jfig.cnf              (local working dir.)
  5. local:  ./.jfigrc               (local working dir., hidden)

  As before, local settings override user, and user override global 
  settings.

F
  actually use the jfig.gui.SelectFromLibraryDialog.BaseDir
  property promised in the documenation, and avoid NullPointerExceptions
  for non-existent or empty library directories.

  Also added a simple hack to allow to set the library search directory
  interactively from the SelectFromLibraryDialog window: Simply
  add a new path and press <return> to search for libraries at the
  new location. 


03.12.00

N
  Implemented EditCompoundDialog, added FigCompound.setLayer... 
  function to change a compound object's layer. Might result in negative
  object layers when used with illegal parameters.


27.11.00

N
  Integrated jfig.command.SelectLibraryObjectCommand into the editor.


24.11.00

N
  First implementation of the xfig 'library' command, new classes
  jfig.gui.SelectFromLibraryDialog for the GUI and
  jfig.command.SelectLibraryObjectCommand for the command itself.


19.11.00

N
  Complete rewrite of the jfig<->fig2dev interface. All functions
  are now integrated in jfig.gui.ExportOptionsDialog. New GUI
  with TextFields for the actual fig2dev command line, allowing
  to interactively change parameters and to submit them to fig2dev.

  Added several SetupManager properties to specify the pathname
  of the fig2dev executable and several fig2dev language specific
  options. See the classdoc or the system /jfig/jfig.cnf file
  for details.
  
  Still no support for the mixed PS/Latex export, however.


12.10.00

N
  PrintManager.Manager2D checks the "jfig.gui.PrintManager.magnification" 
  property in the configuration file to set a fixed zoom-factor to use 
  for printing.  The value should be given as an percent value (e.g. "95").
  Should probably add some GUI to set the magnification.

  When the property is not set (the default), PrintManager tries to fit
  the drawing to the page.



10.10.00

N
  major improvements in jfig.objects.* and jfig.gui.PrintManager (Manager2D).
  Printing via JDK/JRE 1.3 with Java2D should now work: all objects
  use the Java2D geometry stuff to paint() themselves in the correct
  orientation and scaling to the PrinterGraphics context. 
  Default paper is now A4 size with 5mm margins.

  PrintManager reads the FigAttribs.fig_orientation variable to decide
  on Landscape or Portrait mode page orientation. You can change this
  variable via the Options->Edit global attributes dialog, if necessary.

  The only exception are fillpatterns, which still crash the virtual machine.
  Also, drawing of circles/ellipses and splines is inefficient, because
  jfig draws those objects using its own interpolation instead of using
  the corresponding Path2D methods.


09.10.00

N
  no more "write once". 
  jfig.gui.ModularEditor now checks System.getProperty( "os.name" )
  to detect the OS / JVM environment and sets the corresponding
  enable[Windows/Solaris/Linux/Netscape]Workarounds variable,
  which is then used later on...


08.10.00

B
  the "DEL" key workaround for Windows seems to break by Linux version :-(

F
  print an useful error message if PresentationViewer cannot find the
  specified presentation index (.jpt) file.

F
  added some workaround code to print useful error messages if 
  jfig.gui.ModularEditor and other jfig.gui. classes cannot find 
  the required resource images. This is especially helpful, as some
  versions of Linux unzip fail to set the correct permission bits
  on the jfig/images directory when unpacking from jfig.jar, so that
  the image files are indeed not readable...

06.10.00

N
  added (another) workaround to ModularEditor and CreateTextCommand,
  to get the DEL-key working on Windows platforms. 
  The current solution seems to work for jview and the JDK 1.3
  on Windows 95/98, so perhaps it is finally right...

N
  documentation updates. Rewrote parts of the README, and added
  information about jfig.utils.PresentationBuilder to the FAQ.

05.10.00

N
  added zoomRegion functionality to jfig.gui.PresentationViewer.
  Also cleaned up the popup menu and added the "zoom region" and
  "popup console" items. Use 'r' as the bindkey for zoom region.
  
F
  added the is/setPopupConsoleOnWEF() pattern methods to jfig.gui.Console, 
  to allow a "silent" Console window even for warning/error/fatal messages. 
  This may sometimes be helpful, e.g. on Windows, to get rid of repeated 
  and therefore useless console messages.

F
  fixed (I hope) the off-screen dialog window placement for the 
  XXXStateButton internal SelectDialog windows. This should allow to
  select colors/fillpatterns/etc. without having to move the parent
  window first...


03.10.00

B
  used jfig on Windows again, after a long time. 
  Found annoying and trivial bugs, like the off-screen placement 
  of attribute-select dialog windows.  Those will be fixed ASAP.

B
  Tried image printing on JDK 1.3 (Java2D) and found a curious scaling
  problem. Hope to fix that soon...


22.09.00

F
  minor fixes in jfig.utils.PresentationBuilder: catch exceptions from
  copyAllFilesFromZipArchive, set presentation viewer MainClass attribute 
  before copying the jfig class archive (with its possibly conflicting
  MainClass manifest entry).

19.09.00

F
  fixes in jfig.objects.FigAttribs and jfig.gui.AttribsButtonPanel
  to get the correct update mask values for text object updates
  (font style, font size, text rotation).


08.09.00

N
  new GUI and thread concept for ExportOptionsDialog and Exporter:
  we always save the current FIG file before exporting, we create a new
  worker thread to do the Runtime.exec() stuff, and we allow the user
  to specify the command line directly.

N
  version 1.42, some renaming (special menu is now options menu, prepared 
  "plugin" menu)

F
  fixed jfig.commands.MoveObjectCommand to support "smart links move" undo

F
  makefile improvements, make jfig-classes.jar instead of .zip per default,
  and include only the necessary classes, demos, and icons.

16.08.00

N
  new version of jfig.utils.MakePieChart to demonstrate the extension
  of jfig with user code. Also commented that example file.

15.08.00

F
  corrected the increment value function in jfig.gui.NumericStateButton.

F 
  (unsuccessful) attempt to replace Point[] data structures by Polygon,
  to conserve memory. However, the savings were not worthwhile, even
  for the transit.fig example.

14.08.00

N
  implemented SmartLinks Move mode. This currently handles polylines
  (arcs, beziers, splines) connected to rectangles, and text objects
  fully inside the rectangle.

F
  minor fixes to FontCache for JDK 1.1 compatibility. Corrected the
  font layout in the FontStateButton selection dialog.


13.08.00

N
  completed the redesign of jfig.gui.FontCache. The data structures and
  GUI components of jfig now support all FIG (Postscript) fonts.
  Try the Help->Demos->Fonts example and compare the output with
  the (prerendered) font selection menu.
  
  Unfortunately, the Java virtual machines available at the moment,
  like Suns or IBMs JDK 1.2.2 or JDK 1.3, still do not support all the 
  required fonts. You may have to edit the properties in jfig.cnf to
  map FIG font names to the fonts available on your system and JVM.
  Note that older Java 1.1 virtual machines only support the predefined
  Times, Helvetica, Courier set of fonts.

  Full support for LaTeX fonts is not planned at the moment - but
  don't hesitate to tell me that you really need this...


N
  first stub and a little code for "smart links" support in 
  jfig.commands.MoveObjectCommand


12.08.00

F
  removed fontName, fontStyle, currentFont attributes from FigText,
  ResizeTextCommand, FigParser, FigWriter, etc.  All hardcore Font 
  handling is in FontCache now. is in FontCache now, and all FIG
  Postscript fonts are supported (if your JVM has them).

F
  major cleanup of jfig.objects.FigAttribs with corresponding changes
  to two dozen classes... removed redundant attributes, made the update
  masks static, new Postscript font index constants, removed the 
  fontName, fontStyle, currentFont attributes, ...

N
  new class jfig.gui.NumericStateButton for xfig-compatible numeric value
  (integer) selection. Used for depth (layer), rounded rectangle corner
  radius, font size, etc. 

N
  major update to the GUI attribute controls, which now use the 
  FontStateButton, ColorStateButton, and NumericStateButton classes.
  Changed the initialization for AttribsControls, which is no longer
  a Singleton class - a first and necessary step to support multiple 
  jfig editor/viewer windows inside one virtual machine.

  Also, most commands should now display only the attribute controls
  valid for that command.

N
  GUI stuff to select all FIG Postscript fonts is now in place, but
  FontCache still needs a complete overhaul.

N
  first GUI stuff for "move with smart links" added to AttribsControls
  and AttribsButtonPanel.

F
  found (and corrected) lots of unused deprecated code and several bugs 
  in StateButton and its subclasses, AttribsButtonPanel, AttribsControls,
  and ModularEditor.
 

11.08.00

N
  new class jfig.gui.ColorStateButton for xfig-compatible color selection.
  The new button allows to select the next/previous color with right/middle
  clicks, and presents a dialog window for direct selection on a left
  button click. Still no GUI support to add user colors, however.

N
  new class jfig.gui.FontStateButton for xfig-compatible font selection.
  Prepared resource images /jfig/images/font-menu.gif (gray) and the
  original /jfig/images/font-menu-442x361.gif (white background) from
  downscaled 300dpi ghostscript rendering.

F
  better placement strategy for the SelectDialog windows (inner class)
  from jfig.gui.StateButton and jfig.gui.FillPatternsButton. 
  The dialog windows should now appear directly above the StateButton 
  and inside the visible screen area.


10.08.00

N
  first tests and initial code to support all xfig Postscript fonts.
  As most Java VMs currently don't support the Postscript fonts directly,
  this will use some user properties to map xfig fonts to Java fonts 
  for screen rendering. 
  Note that fig2dev will automatically use the Postscript fonts, whether
  the JVM has them or not.
  

09.08.00

N
  new class jfig.gui.PropertiesViewer to display the contents of a
  java.util.Properties object in a dialog window. Integrated into
  jfig to show all global/user/local property settings.
  (Menu->Special->Show Properties).
  

13.07.00

N
  changes and improvements in PresentationViewer and ImageHelper which
  allow to use the PresentationViewerApplet to read from JAR-archives
  instead from individual files on the http-server. This improves
  performance and interaction time greatly for all situations, where
  the whole presentation (.fig and .gif/.jpg/...) fits into a JAR
  archive. 

  While the current solution seems to work with JDK 1.1.8 up to JDK 1.3
  (checked Linux, Solaris, Windows and jview), it does *not* work
  with Netscape 4.7, as the Netscape VM won't allow applets to
  read classpath resources. Use appletviewer instead.


06.07.00

N
  the new version of jfig.utils.PresentationBuilder is ready.
  Still no error handling, but building a JAR archive with all
  .fig slides, .gif ... images, the .jpt index file, and the
  required presentation viewer jfig.*.* classes should work.
  The resulting JAR can be run on Java2 JVMs easily, using
  java -jar <name.jar> 

F
  some minor

F
  don't use JAX to generate the presentation viewer archive
  anymore, as neither jax33 nor jax41 nor jax61 seemed to work
  reliably for jikes compiled classes. Also, adding the icons
  and extra classes was quite painful.
  Without jax, the jfig-presentationviewer.zip is somewhat
  larger (~200 KB instead of ~150 KB), but still acceptable.

03.07.00

F
  minor fixes in the load image from resource functions in
  jfig.gui.ImageHelper. Basically, ImageHelper now checks whether
  the specified resource name starts with a '/', and tries to
  repair the resource names if not.

N
  first version of an improved presentation builder

22.06.00

F
  replaced several references like "attribs.solidLine" to 
  "FigAttribs.solidLine" to keep JDK 1.3 javac happy 
  (FigBaseobject, AttribsControls, FigText, ...).

F
  some more jfig.objects.FigImage debug code to trace imageUpdate()
  activity. Select via "jfig.objects.FigImage.verboseImageUpdate"
  SetupManager property.

F
  load global jfig SetupManager properties in 
  jfig.gui.PresentationViewerApplet.

10.05.00

N
   hacked jfig.utils.PresentationBuilder to collect all FIG files below
   some directory into a .jpt presentation file.

30.03.00

N
   changed jfig.commands.PasteFromClipboardCommand to paste to a user-
   specified position instead of fixed position (0,0). Also added cancel.

N
    first working implementation of OpenCompoundCommand


28.03.00

N
   implement right-click=cancel in jfig.commands.MoveObjectCommand and 
   CopyObjectCommand for xfig-compatible behavior

N
   first code for jfig.commands.OpenCompoundCommand, with corresponding
   changes and cleanups to ModularEditor. Updated version to 1.40


27.03.00

F
   reset filename in doStartNewDrawing (Menu->File->New...) and update
   filename in status panel

F
   added missing rotation angle TextField to jfig.gui.EditTextDialog
   and jfig.gui.EditEllipseDialog

F
   fixed jfig.objects.FigEllipse.setAttributes() and update() to react 
   to rotation angle changes

N
   implement right-click=cancel in jfig.gui.CreateXXXCommand to get xfig-
   compatible behavior

N
   added the "pick up" attributes operation from xfig (update middle button)
   to jfig.commands.UpdateCommand 

N
   MouseMapper improvements, some renaming in gui/*java and commands/*java

21.03.00

N
   major webpage update

16.03 - 18.03.00

N
   finally managed to compile a recent fig2dev.3.2.3 for Windows, 
   using the cygwin tools (sourceware.cygnus.com).  Added the 
   fig2dev-windows.zip to the webpage.


14.03.00

N
   added printf-like number formatting to jfig.objects.FigWriter.

F
   tried to fix the polygon-endpoint-double bug with changes to
   FigParser, FigWriter, FigPolyline. Not all combinations of 
   objects with FIG31 and FIG32 format checked yet. Bugs may remain.
   

04.03.00

N
   renamed (almost) everything from JavaFIG to jfig, in order to
   comply with Suns Java(TM) trademark rules, see www.javasoft.com.

N
   cleaned up the names of many SetupManager properties. In general,
   these match the class names now. See jfig.cnf for the list
   of currently available configuration options for jfig.
  
N
   makefile update and cleanups. 

N
   Renamed javafig.utilsPPMFormatParser to jfig.utils.PPMReader.
   Added new class jfig.utils.PPMWriter.

   Replaced GIF export with PPM export to avoid license issues about
   the GIF file format. While the GIFEncoder classes are not included
   with jfig/javafig, the classes may be used if preinstalled and
   found on your system.

N
   Support for JAI (java advanced imaging) export to other file formats
   is planned.



01.03.00

N
   new documentation (/jfig/doc/export-fig2dev.txt) about exporting
   and fig2dev integration; also added corresponding menu item and
   callback to EditorMenuBar and ModularEditor


28.02.00

B
   seems that JDK1.3 javac cannot compile AttribsControls.java. Hmmm :-(


26.02.00

N
   restructured the Java2D painting functions. New inner class
   FigBaseobject.Painter2D to collect common Java2D stuff like
   createTransform() and createStroke(). Only LineWrapper still
   needs its own separate Painter2D.

F  
   use Painter2D draw and fill in FigBezier instead of using FillWrapper.

24.02.00

N
   use Java2D to render Bezier-curves when available; this improves
   screen rendering a little bit, but greatly improves printing
   (if your JVM supports printing of Bezier curves via Java2D).

F
   minor fixes to attribute initialization and re-initialization after
   parsing, to get correct default values. Also fixed FigAttribs.update()
   to allow updating of arrow width/height and dash-lenght on polylines.

23.02.00

N
   included the new FillPatternButton to select fill style and pattern.
   The button works under Java 1.1 too, however, fill patterns will only
   be rendered when Java2D is available.

F
   finally fixed the shades-of-gray-style-wrong bug in EditXXXDialog,
   EditGlobalAttributesDialog, and AttribsControls.

F
   allow non-integer values for arrow width and length.



19.02.00

N 
   enabled pattern fill for FigPolyline and FigArc. Correspondingly,
   disabled the pattern fill warnings from FigParser when Java2D is 
   detected and active.

N
   changed jfig.objects.FigArc to use Arc2D instead of LineWrapper
   for Java2D-rendering. Hopefully, the coordinate translation is now
   correct... However, LineWrapper is still used to calculate arrow position.

F
   more than a dozen minor fixes to the Java2D paint methods, timestamp
   checks, BasicStroke initialization, null pointer checks, ...

F
   fixed the end-point-missing bug in FigBezier rendering, which went
   unnoticed by me for over two years...


18.02.00

F
   minor fixes to the Java2D printing - still not really useable due
   to lots of bugs in Java2D itself.


17.02.00

N
   finally implemented patterns fills for all objects (requires Java2D).

N
   first support for Java2D printing via inner class
   jfig.gui.PrintManager.Printer2D. However, Java2D printing still
   seems to have dozens of bugs.

15.02.00

N
   implemented RotateObjectCommand and added rotate() implementations
   to FigPolyline, FigText

F
   fixed bounding-box calculation for rotated text objects to improve
   text redraw during text editing

F
   renamed TmpFiles from "tmp_java<i>" to "tmp.<i>". These are valid 8.3
   DOS filenames and allow to call fig2dev on some versions of Windows.
   However, the jfig<->fig2dev interaction should still be rewritten
   completely.

F
   tried to get rid of the popup-menus inside the RotationTextField and
   DepthField GUI components when trying to increment the value by right-
   clicking on the Windows platform.

14.02.00

N
   new redraw mode in jfig.canvas.FigCanvas and CreateTextCommand,
   for less flicker when editing texts. Not fully tested yet, however.

F
   fixed spline/bezier spline solid-fill bug introduced in the Java2D 
   conversion.

13.02.00

F
   fixed minor bugs in FigPolyline and LineWrapper Java2D functions.

N
   finally added rotate() method stubs to FigObject and FigBaseObject.
   Wrote jfig.gui.RotationTextField to specify rotation angles.


12.02.00

N
   added support for dash-dot, dash-dot-dot, and dash-dot-dot-dot lines
   to jfig.objects.FigParser, FigRectangle, FigPolyline, LineWrapper,
   and jfig.gui.AttribsControls.

N
   prepared GUI stuff for the "open compound" command. 

11.02.00

N
   Java2D rendering for arrows with all standard xfig arrow heads.

N
   Java2D hack: implemented Java2D rendering for jfig.objects.LineWrapper
   and therefore for all jfig line objects (polyline, arc, spline,
   bezier spline). Splines now need much less memory than with pure AWT11
   rendering, especially for linewidth > 1 or for dashed/dotted patterns.
   However , splines and bezier splines are still using more memory
   than strictly necessary.


10.02.00

N
   implemented Java2D rendering for rectangles and round rectangles, with
   support for dashed and dotted lines.

N
   implemented Java2D rendering for circles and ellipses, with support
   for dashed and dotted lines.

N
   added inner class jfig.canvas.FigCanvas.Options2D to control
   Java2D RenderingHints for the jfig main canvas.

   added menu items "Java2D antialiasing" and "Java2D rendering quality"
   to EditorMenuBar, with corresponding callbacks to FigCanvas.Options2D
   in ModularEditor. The effect of rendering quality (vs. speed) is most
   visible for embedded high-resolution images.

09.02.00

N
   added user interface to specify the FIG "style_val", i.e. the
   dash length / dot separation for dashed/dotted lines.

F
   minor fixes to the FIG parser and writer.

06.01.00

N 
   documentation updates

22.12.99

N
   first support for rotated text (requires Java 2D).


20.12.99

F
   major renaming of all GE_xxx classes to FigXxx and similar names.

F
   switches to Jikes 1.10. The compiled classes seem to work, however,
   JAX 0.41 and javap report "null method" problems in some classes
   (e.g. jfig.gui.PresentationViewer).



17.12.99

F
   changed state button behaviour to match xfig behaviour
   (middle button decrements, right button increments)

F
   reorganized the help menu entries and source documents.
   Included help on shortcut keys.

N
   added class jfig.objects.FigPrintWriter to assure xfig/fig2dev
   compatible file format (Unix-style LF only, no CRLF).

19.11.99

N
   changed jfig.objects.Exporter to escape filenames with '"
   to support Windows-style filenames with blanks in the command
   lines for fig2dev, e.g.  "C:\My Documents\foo.fig" .

18.11.99

N
   new utility class Pathname to remove subdirectory references (..)
   from pathnames.

N
   several improvements to the PresentationViewer and ImageHelper
   to find resource files from CLASSPATH and JAR-archives better.


06.09.99

N
   implemented the font 'special' flag to support mixed Latex/Postscript
   export via fig2dev. You can set the flag both in the main editor attributes
   or the 'edit text object' dialog. 

   However, so far I didn't manage to clean up the export code in 
   jfig.objects.Exporter, too. You will have to call fig2dev -L pstex
   and fig2dev -L pstex_t by hand (or from a script).

30.07.99

F
   changed the zoom factor limits in jfig.canvas.GE_trafo and
   jfig.canvas.ViewerTrafo, new minimum is 0.03125 and maximum is 32.0;
   (Note that the ruler-formatting may look suboptimal at high zoom factors
   due to rounding errors.)

N
   added internal class 'ListEnumerator' and 'getElements()' method
   to jfig.objects.GE_olist. This list enumeraton is still _not_
   thread-safe against structural changes of the list, but at least 
   multiple enumeration can be active simultaneously.
   This should stop the intermittent HADES redraw problems.

15.07.99

F
   changed jfig.canvas.GE_canvas.getVisibleRegionBBox()
   to correct for the rulers.

30.06.99

N
   some support for greek and math symbols (xfig 'symbol' font)
   via font-recoding-hack in class jfig.objects.GE_text.
   Activated Symbol-font in jfig.gui.AttribsControls

20.05.99

N
   first implementation of AlignObjectsCommand (so far, without Undo)

F
   improved several class doc comments

19.05.99

N
   new icons for object alignment

N
   new methods in AttribsButtonPanel to display only those attribute
   controls (buttons, choice's, etc.) relevant to the current command.
   Corresponding changes to the mode and command callback methods in 
   ModularEditor.

F
  several changes / cleanups / improvements to AttribsControls
  and AttribsButtonPanel


17.05.99

F
   several fixes to the central jfig makefile.

14.05.99

N
   new class "EditGlobalAttributesDialog" and corresponding changes
   to ModularEditor to allow the user to select the default global
   editor attributes, e.g. arrow width and length.

F
   fixes in "AttribsControls" and "GE_attribs" to correctly propagate
   attribute changes to the attribute controls.

F
   fixed the object selection mechanism in "ModularEditor" to inhibit
   GE_text shadowing of all other objects inside the GE_text bounding box.
   Now, the selection mechanism will (should) correctly select any 
   polyline/object whose vertices are inside of one snap-distance, even
   if this vertex lies inside a GE_text object.

13.05.99

F
   re-enabled the "GE_canvas" status messages instead of printing them,
   as the AWT deadlock bug in JDK 1.2 seems to be independent of these
   status messages.
   

07.04.99

N
   introduced flag 'syncRepaintFlag' and accessor methods into
   jfig.objects.GE_drawable and class jfig.objects.GE_baseobject
   to support per-object synchronous repaints (e.g. in HADES).
   This feature is currently not used anywhere in jfig itself.

01.04.99

N
   new class jfig.gui.SimpleTextViewer to encapsulate the loading
   and displaying of simple ASCII text files for help, license, etc.

17.03.99

F
   removed unused (and broken) Font initialization in classes
   GE_ibutton, GE_sbutton, GE_updatemodeButton, ... to avoid
   Macintosh MRJ crashes

16.03.99

N
   added support for "resource:/slide/" URLs to the presentation
   viewer. It is now possible to include all FIG slides (and all
   embedded images) and the referring ".jpt" file into one ZIP archive
   for faster/single download.

   At the moment, however, all browsers (including JDK 1.2 appletviewer)
   have problems to access GIF/JPG images embedded into a ZIP
   archive from an applet (JDK bug).

F
   several fixes / updates to classes PresentationViewer and
   PresentationViewerApplet

N
   using jikes as the default compiler

F
   cleaned up the "about jfig" dialog window, should solve layout
   problems on Linux and Solaris

12.03.99

F
   use the non-threaded version of the FIG-parser in the editor/viewer/
   presentation viewer as a workaround against the JDK 1.2 deadloc
   on windows



11.03.99

F
   introduced setup manager variable "jfig.Parser.enableMessages" 
   to switch off the parser status messages during parsing
   (as a workaround for the JDK 1.2/Windows deadlock bug)

F
   fixed jfig.commands.CreateTextCommand.keyTyped() to handle
   key codes generated by JDK 1.2 for Windows ...

10.03.99

F
   fixed jfig.commands.CreateTextCommand.keyTyped() to ignore
   ASCII control sequences (like CNTL-S) generated by the new menu
   accelerators.

F
   fixed jfig.objects.GE_text and jfig.objects.GE_figIn to
   ignore spurious ASCII control sequences in text objects

N
   rewrote the help-page for the PresentationViewer and corrected the
   help resource-URL to reference this page

N
   new "window size" menu and callbacks in jfig.gui.PresentationViewer,
   upgraded to version 0.17

N
   changes to the panning mechanism in PresentationViewerCanvas to allow
   for very small-step panning (about 4% of window size)

F
   complete reorganization of the jfig.gui.PresentationViewer 
   menu callbacks, used symbolic String constants for everything, ...

 
F
   several fixes to jfig.utils.PresentationParser to avoid NullPointers
   on presentations without a single chapter (better initialization, many
   more checks, etc.)




23.02.99

F
   changed all calls to Graphics.drawImage() to the synchronous variant,
   as an attempt to reduce the deadlock probability

F
   fixed ClassCastException in ResizeTextCommand

F
   fixed the findNextCompound algorithm and several status messages 
   in BreakCompoundCommand

F
   added several calls to jfig.utils.AntiDeadlock in all classes
   which modify/use AWT dialog windows.


22.02.99

N
   changed version to 1.34,
   added '#' shortcut for break compound

F
   new keyboard shortcuts for 'save', 'new', ... without the SHIFT modifier

F
   new attempt to workaround the 'deadlock' problem.
   Several synchronizations added to GE_canvas, changed GE_canvas
   offscreen redrawing to the synchronous variant of Graphics.drawImage.

21.01.99

N
   added the 'g' bindkey to KeyHandler to toggle between none/medium grid.

F
   added debug messages from GE_statusCanvas; enable with SetupManager
   property 'StatusCanvas.debug'

12.01.99

F
   introduced the "jfig.Exporter.DumpStatus" setup manager property
   to wrap and enable/disable the output/error stream dumping from
   the external process. Disable for Windows, unless you like deadlocks.

11.01.99



06.01.99 - 10.01.99

F
   several changes to GE_canvas and GE_statusCanvas to get rid of
   the d**mned Windows deadlocks under JDK 1.2. Changed version to 1.33.
   Got some improvements, but it still doesn't work reliably.

04.01.99

F
    slowed down the redraw using repaint(delay) calls in GE_statusCanvas 
    to keep JDK 1.2 happy (i.e., avoid the complete Windows deadlock
    during repaints).

30.12.98

F
    use a dummy GE_statusCanvas to receive the annoying and very
    time-consuming parser messages while processing the clipboard contents
    in jfig.commands.PasteFromClipboardCommand.

F
    added a WindowListener to jfig.gui.Console to allow closing
    via the window menu.

29.12.98

F
    removed unused old class GE_console, replaced by jfig.gui.Console

F
    renamed jfig.utils.FigWriter to FilteredFigWriter

28.12.98

F
    removed useless class GE_imageLoader and the remaining dead
    references to it (use jfig.gui.ImageHelper instead)

F
    major updates to the class documentation (Java 2 style) to
    several dozen classes, including all classes from jfig.commands.*

10.12.98

N
    major rewrite of the jfig makefile, file and directory structure,
    and new WWW pages.

07.12.98

N
    added the method getTmpObjects() to GE_editor, ModularEditor, and Viewer

F
    further changes to the image loading stuff in CreateImageDialog.
    Now, the empty image object gets the correct transformation, and
    it should react to changing the aspect ratio (reload if necessary).

F
    fixed the bug introduced into editor selection algorithm for
    polyline objects.


04.12

F
    fixed the image loading stuff in CreateImageDialog, CreateImageCommand,
    and GE_image. Now, images can be loaded with fixed aspect-ratio, and
    they are shown after loading as the editor tmpObjects.

F
    again changed the editor selection algorithm. In the first pass, we
    selected the first objects whose corners are inside one snap-distance
    from the mouse position. If no object is found, we double the snap-
    distance. Also, text objects are selected if the mouse is anywhere
    inside their bounding box.
    


xx.11.98
    wrote the PresentationViewer and applet


27.10.98

F
    call parser.setObjectPainter(objectCanvas) in jfig.gui.Viewer
    to activate the ImageObserver: display images once they are loaded...


30.09.98

N
    implemented SnapToGridCommand

29.09.98

F
    improved the editor selection algorithm to use a two-pass algorithm.
    The first step will look only for objects with corners nearer than
    one snap-distance to the mouse position, while the first step will
    relax that condition: it will also select objects who cover the mouse
    position, as well.

N
    support image aspect ratio stuff in classes GE_image, CreateImageDialog,
    EditImageDialog.

F
    fixed the annyoing 'fill style off by one' bug in EditXXXcommand ---
    rewrote AttribsControl.showFillPattern().

F
    added some font size and fill pattern (shades) values to AttribsControls

28.09.98

N
    complete rewrite of commands/CreateTextCommand, to use JDK116 compatible
    keyPressed/keyTyped methods.
    When editing an existing text, this is removed from the object list
    and only used as the 'tmpObject', so that the text is no longer garbled
    until finishing the editing.
    Also, recursive undo and redo of CreateText commands should now work.

25.09.98

F
    changed GE_figOut to write out backslash-characters '\\' correctly.

20.08.98

F
    several fixes to the FIG 3.2 parser and additional checks/special cases
    to get both FIG 3.1/FIG 3.2 compatibility. The parser and writer now
    handle all of the standard xfig.3.1.4 and xfig.3.2 examples.
    (Note that xfig.3.2/Examples/transit.fig needs almost 64M of memory 
    due to inefficent memory usage in classes jfig.objects.GE_spline and
    GE_bezier. 

19.08.98 

N
     parser and writer support for FIG 3.2 format, including global FIG
     attributes (page size, orientation, ..) and spline conversion.

N
     updated class GE_colorCache and the parser/writer classes to 
     support FIG pseudocolor objects.

17.08.98

N
     editor support for GE_trigger objects (hyperlinks). New class
     CreateTriggerCommand, several fixes and updates to EditTriggerDialog,
     ModularEditor, and EditorMenuBar. New trigger icon.

F
     allow to set a new help message string in GE_ibutton/ImageButton

F
     disabled the annoying diagnostic messages from ImageHelper.


28.07.98

N
     added 'write HADES resource' functionality.

01.07.98

N
     new command "ResizeTextCommand" for easy changing of text font size
     and style, corresponding updates to ModularEditor (now version 1.30)
     and ModeButtonPanel.

07.06.98

F
     update the filename-Textfield in the ModularEditor status panel
     after a "save file as" operation.

06.06.98

N
     update object attributes (line width, arrow size, etc.) from within
     the GE_baseobject.scale() method. Also store the original attributes
     for later undo in ScaleObjectCommand.

04.06.98

N
     support for x/y restricted copies in jfig.commands.CopyObjectCommand

F
     added many try/catch blocks to all icon/button image related
     parts of ModularEditor, Viewer, ModeButtonPanel, AttribsControls,
     and ViewerButtonPanel to get Netscape to load the applets
     (however, the icon and buttons are still not loadable by Netscape).

N
     new class jfig.gui.EditorApplet - but Netscape 4.05 still is not
     able to load Java 1.1 resource files (icon/buttons) :-(
     However, the applet works with appletviewer and HotJava.


03.06.98


N
     added text fields to specify arrow width and length to
     jfig.gui.AttribsControls and jfig.gui.EditPolylineDialog

N
     support for x/y restricted moves in jfig.commands.MoveObjectCommand

F
     implemented ScaleObjectCommand, with unrestricted,
     restricted (proportional) scaling, and with respect to an objects
     center or the opposite corner.
     Implemented undo for scaling.

02.06.98

N
     several changes to jfig.canvas.GE_rubberband to support
     object scaling, and restricted moves and copies.

N
     new class jfig.commands.ScaleObjectCommand

N
     implemented method scale() in GE_baseobject. This allows to scale
     all objects except GE_compound and GE_text, which got their own
     special implementations.

N
     defined and added method scale() to GE_object.


15.04.98

F
     support for asynchronous image loading with correct 'ImageObserver'
     references in GE_image object, setObjectPainter() method in GE_figIn,
     and corresponding changes to ModularEditor

14.04.98

F
     corrected several bugs in the CreateTextCommand execute() and undo()
     methods

F
     don't switch off and on the 'object corners' during CopyCommands

01.04.98 

F
     fixed all classes to use the Java 1.1 API throughout, so that no
     deprecated methods or classes are left in jfig.

F
     removed classes and source files not longer needed for jfig 1.2,
     including the package 'jfig.editor' and several classes from
     'jfig.gui'.

27.03.98

F
     fixed the GE_image.copy() method

F
     rewrote most of the README and HTML files to reflect the recent changes.


24.03.98

N
     changed the timestamp tests in all objects (GE_baseobject ... GE_text)
     to workaround the Windows timer bug. Objects should now be displayed
     correctly even when chaining panning/zooming operations.

23.03.98

F
     changed the timestamp handling in classes jfig.objects.GE_wline
     and GE_wfill to work around the "Windows coarse time resolution" bug.
     Now, both classes will rebuild themselves when their own timestamp
     is less than OR EQUAL to the transformation's timestamp. This means
     more work and less performance, but should get of invalid objects
     due to multiple transformation changes until the timer increments.

N
     enabled the "point operations" for jfig.objects.GE_ellipse
     with the getPoints() and setPoints() method to allow for a "move
     point" / "scale" on circle/ellipse objects.

F
     fixed the UpdateCommand undo and redo functionality

F
     renamed jfig.objects.GE_oval into jfig.objects.GE_ellipse,
     with corresponding changes to all jfig classes

20.03.98

F
     changed jfig.objects.Exporter to write the FIG files as tmp files,
     in order to avoid overwriting existing FIG files.

19.03.98

N
     add findButton() method to jfig.gui.ModeButtonPanel to allow a
     visual feedback of the KeyHandler-initiated commands  by activating
     the corresponding command button.

F
     fixed the "CreateTextCommand" to allow for direct input of German
     umlauts on Solaris (english keyboard), using the <META>+ [aou AOU s]
     keys.

18.03.98

N
     new class jfig.gui.KeyHandler with support for "single key"
     shortcuts. Added bindkeys for most frequently used editing commands.
     See "doc/FAQ" for a list of the currently available bindkeys.

17.03.98

N
     added several bindkeys for the MiniEditor menu commands

N
     major changes in rewrites in jfig.canvas.GE_canvas and subclasses,
     and jfig.canvas.GE_trafo and subclasses. The grid mode and snapping
     mode should now work for all zoom factors and units.

14.03.98

F
     fixed the mouse-button bindings in jfig.commands.DeleteObjectCommand
     to be consistent with the CreateCompoundCommand and ZoomRegionCommand.
     Also corrected and added several status messages in many command object
     classes.

N
     changed the visual appearance of the GE_sbutton and GE_colorButton
     classes to the 'flat' style of Windows/Office 98.
     Also added some dummy GE_sbuttons to the AttribsButtonPanel as a means
     to add the 'update mask' flags to the Choice menus and TextFields for
     font style, font size, corner radius and layer (depth).

N
     implemented the update() method in class jfig.object.GE_attribs
     and changed all object classes in jfig.object.* to use this method
     for attribute updates.
     For the first time in jfig, the update() method in GE_attribs 
     respects the 'update mask' flags set in the AttribsButtonPanel controls. 

N
     changed the implementation of jfig.gui.AttribsButtonPanel to rely
     on the methods supplied by class jfig.gui.AttribsControls.
     The resulting code is much shorter and much more modular, because the
     main attribute control panel and the individual "edit object" dialog
     windows share the same code.

13.03.98

N
     got the edit dialog windows (EditXXXDialog) working for object classes
     for rectangles, polylines including arcs, splines, bezier splines, and
     the closed variants of these, texts, images, triggers, and circles and
     ellipses.

12.03.98

N
     first implementation of the EditPolylineDialog window for interactive
     attribute changes to polyline/spline/bezier/arc objects.

N
     first implementation of the 'edit object' command with support for
     text objects and polylines.

N
     implemented the attribute get/set (called showXXX and setXXX) methods
     in jfig.gui.AttribsControls. This is the basis for efficient design
     and implementation of the EditXXX dialogs for the 'edit object'
     commands.

N
     implemented the clipboard interface with new command classes
     jfig.commands.CopyToClipboardCommand, CutToClipboardCommand, and
     PasteFromClipboardCommand. For these commands, the selected objects
     are converted to/from FIG file format and then entered into the clipboard
     as standard Strings. 

     This also allows to read back selections from other programs, where 
     texts will be converted into GE_text objects by the parser. A typical
     application of this should be to include program fragments as listings
     into jfig drawings.

N
     implemented the 'merge file' and 'merge URL' methods, with corresponding
     updates to the FIG-file parser (new callback mechanism)


10.03.98

F
     several minor changes to command classes to get the status messages 
     right.

F
     corrected pushing and popping status messages in GE_statusCanvas.
     With this change, the status messages from the GUI buttons don't
     overwrite the status messages from the ongoing commands.

N
     implemented the 'set cursor snapping', 'set grid', and 'set units'
     methods for the Editor.


05.03.98

N
     corrected the systemresource URL to load the jfig demo page.

N
     first implementation of the 'cursor snapping' callbacks in
     jfig.gui.MiniEditor. However, it seems that class ViewerTrafo's
     setSnapRelative() method is broken for metrics other than inches
     and non-integer zoom-factors.

N
     added default font selection via SetupManager properties to classes
     jfig.gui.Console and jfig.gui.MiniEditor.
     This improves the visual aspect under standard Linux greatly.

F
     invisible GE_triggers are now copy()ed and move()d as other objects,
     even if they are invisible before and after.
     Unlike the previous behaviour, it is now possible to treat triggers
     exactly as all other objects without the need for special handling.

F
     several fixes to CreateCompoundCommand and BreakCompoundCommand,
     mostly to set the correct select/deselect/showPoints status of
     the compound members and the compounds themselves

19.01.98

N
     allow parsing of non-ASCII strings in the GE_figIn parser.
     Use SetupManager variable "jfig.Parser.enableNonASCII" to enable/disable
     this feature.

15.01.98

N
     use the threaded variant of parse_fig_file (_threaded) in the MiniEditor

N
     integrated the parseFile, parseURL, parseResource, parse methods from
     jfig.gui.MiniViewer into jfig.gui.MiniEditor.

N
     implemented the first step of the xfig user interface metapher:
     all commands will try to create a new command of their class via 
     the reflection API in handleCommandCallback.
     Note that it is currently necessary to use 'Cancel' to change the mode.

F
     switched to the new 'viewerbuttons.gif' button icons in MiniEditor,
     to use the improved 'zoom' function icons.

F
     fixed several menu items and the menu organization in EditorMenuBar.

N
     added the doUndo(), doRedo(), and doCancel() callbacks to jfig.gui.
     MiniEditor. Because of the varying menu items, doUndo() and doRedo()
     required special handling in actionPerformed, namely
     evt.getActionCommand().startsWith( "Undo")

N
     made GE_editor an subinterface of ActionListener, so that all command
     objects can use the actionPerformed() method as a callback.

F
     using the additional argument to the callback methods, the active 
     mode (create xxx, move, copy, ...) button is now highlighted in the
     jfig.gui.ModeButtonPanel. 

N
     all callback methods in jfig.gui.MiniEditor now receive one additional
     Object argument. For most methods, the triggering ActionEvent is used
     for this argument.

14.01.98

F
     fixed/disabled lots of info and error messages in jfig.gui.MiniViewer

N
     new method setImage( imagename, filename, filetype ) in class
     jfig.objects.GE_image to use the new ImageHelper functionality
     from N101.

N
     new method addActionListener() in jfig.objects.GE_figIn to
     allow Java 1.1 compatible callbacks from the parser. The command
     String generated is "FIG file ready".

N
     new method setFilenameAndType()
     in jfig.objects.GE_figIn to allow creation of GE_image objects 
     that are able to find their image data relative to their parent
     FIG file.

F
     update filename in the status line after doShowPrevious() and 
     doShowNext() in jfig.gui.MiniViewer.

F
     changed LayoutManager of the viewer status line entries to dummy
     GridLayouts to force correct layout of subcomponents in jfig.gui.
     ViewerStatusPanel. Also removed ugly 'raised' status of the main
     status panel.

F
     fixed unnecessary call to parse() for NULL InputStream and report
     an error instead in jfig.gui.MiniViewer

F
     fixed rubberband enable (pointRubber) at the end of a zoom region command
     in jfig.commands.ZoomRegionCommand

N
     added file types (FILE, URL, RESOURCE) and corresponding Stack to
     jfig.gui.MiniViewer

N
     added findImage() and related methods to jfig.gui.ImageHelper

13.01.98 and previous:

B
     no change log available.


