% jfig/doc/FAQ (16.07.2001)


Frequently asked questions about jfig:


-----------

Q: What is in this FAQ?

A: Contents:

   o What is jfig? What is xfig? 
   o jfig status?

   o jfig installation, CLASSPATH settings
   o I can't get it running
   o jfig and the JRE
   o version information
   o documentation
   o license

   o FIG format and compatibility
   o import and export filters
   o object selection 
   o object rotation
   o font problems
   o known bugs in jfig
   o reporting new errors

   o bindkeys
   o customization (fonts, etc.)
   o integrating jfig in your application
   o running on a notebook (800x600)

   o running a jfig presentation
   o building a jfig presentation


--------


Q: What is xfig? What is jfig?

A: xfig is a very popular 2D-graphics and diagram editor for the X11
   (X-windows) system. It is the de-facto standard editor on Unix and
   Linux systems and often used to create graphics for LaTeX documents. 
   Check www.xfig.org for documentation and the latest version of xfig.

   xfig supports all common drawing objects like boxes, polylines with
   arrows, arcs, bezier splines, text objects, and embedded images.
   xfig uses its own text-based file format, called FIG. A companion
   program transfig/fig2dev provides export filters to several popular 
   file formats like Postscript.

   The user interface of xfig is mode-oriented and can be used very
   efficiently. However, the user interface concept differs from most 
   Windows-based graphics editors and requires some practice to get
   used to.


   jfig is a Java-based clone of xfig. It uses a very similar user
   interface, includes the same edit operations, and reads and writes 
   FIG files. Unlike xfig, jfig should run on all Java compatible
   platforms - and especially on PCs/notebooks under Windows 9x/NT/2000.

   jfig can also be used as a class library in other Java applications. 
   For example, the jfig simple applet allows to include and display 
   FIG files in web pages.  The jfig presentation viewer (and builder) 
   allos to construct slide shows from a set of individual FIG files. 

   For details and the latest version of jfig check the jfig homepage,
   tech-www.informatik.uni-hamburg.de/applets/jfig/


--------


Q: What is the current status of jfig?

A: Status (jfig 1.53):


                                       xfig 3.1   xfig 3.2   jfig 1.53
   FIG formats
     2.1                                   +          +           +
     3.1                                   +          +           +
     3.2                                   -          +           +

   object types
     rectangle (also round corners)        +          +           +
     polyline, polygon                     +          +           +
     circle, ellipse                       +          +           +
     arc                                   +          +           + (B)
     spline                                +          -           +
     interpolated spline                   +          -           +
     X-spline                              -          +           +
     text                                  +          +           +
     embedded image                        +          +           +
     group (compound)                      +          +           +
     user-defined objects                  -          -           +
 

   object attributes
     line and fill colors                  +          +           +
     line style (solid, dash, ...)         +          +           +
     arrow (forward, backward, styles)     +          +           +
     fill patters                          +          +           + (0)
     rotated text                          +          +           + (0)
     rotated ellipse                       +          +           + (0)

   image formats
     PNG                                   -          +           +
     GIF, JPEG, XBM                        +          +           +
     XPM, PPM                              +          +           - (1)
     Postscript                            +          +           - (1)

   text fonts
     LaTeX                                 +          +           -
     31 Postscipt                          +          +           + (2)
     Math, Symbols                         +          +           +
     other TrueType                        -          -           + (3)

   edit operations
     create object                         +          +           +
     move, copy                            +          +           +
     delete, delete region                 +          +           +
     edit attributes                       +          +           + (4)
     update attributes (with mask)         +          +           +
     scale object                          +          +           +
     rotate (cw/ccw)                       +          +           +
     mirror x/y (flip)                     +          +           +
     move/add/delete point on polyline     +          +           +
     align objects in compound             +          +           +
     smart-links move                      -          +           +
     convert polyline <-> spline           +          +           +
     create / destroy compound (group)     +          +           +
     open compound (temporarily)           -          +           +
     add library object                    -          +           +
     undo                                  +          +           + 

     clipboard copy/cut/insert             +          +           +
     import text file                      -          -           +
     snap object to magnetic grid          -          -           +
     attribute cache                       -          -           +

     canvas with grid and zoom             +          +           +
     magnetic grid                         +          +           +
     negative coordinates allowed          -          +           +
     Manhattan / LaTeX geometry            +          +           -
     antialiasing                          -          +           + (0)
     high-quality image display (zoomed)   -          -           + (0)

     bindkeys / accelerators               +          +           + 
     uses three-button mouse               +          +           +

     print                                 + (5)      + (5)       + (6)
     screen shot                           -          +           + 
     export via transfig/fig2dev           +          +           +
     

   Notes:

   (B) format problem: jfig uses FIG 3.2.3c spec, which changed in FIG 3.2.3d
   (0) requires Java2D: only partially rendered with Java 1.1
   (1) depends on the installed Java import filters
   (2) if font installed on the system, otherwise rendered with similar font
   (3) see font installation in this FAQ
   (4) Java "nested dialog" problem
   (5) Postscript only
   (6) all printers on systems / low quality with Java 1.1

--------


Q: jfig installation, CLASSPATH settings

A: See the README file for latest information about jfig installation.
 
   JDK/JRE 1.3:
 
   In general, jfig looks best with a Java2D compatible Java virtual
   machine, like JDK/JRE 1.3 from Sun Microsystems, www.javasoft.com.
   Variants of the JDK from other vendors like IBM should work, too.
   If you have JDK/JRE 1.3 correctly installed on your system, you
   can directly run JAR-archives without any further installation.

   From a shell, just run 

   java -jar /path/to/jfig.jar [filename.fig]
   java -jar c:\path\to\jfig.jar [filename.fig]

   where the filename argument is optional.

   On Windows, you can also double-click on the "jfig.jar" icon
   in the explorer. You may want to drop a link from jfig.jar
   to your desktop or the Windows start menu.



   Microsoft jview:
 
   To run jfig with the Microsoft (Internet Explorer) VM, open a
   MSDOS command shell, and type

   jview /cp c:\path\to\jfig.jar jfig.gui.Editor [filename.fig]


   JDK/JRE 1.1.8

   You will need to set your CLASSPATH variable. See the README
   file for details.


--------


Q: I can't get it running!

A: If you really can't get jfig running, please try the following:

   1. Check that you have a Java 1.1 compatible Java virtual machine
      (or higher). Try to run "java -version" and check the output. 
      All versions of 1.1.7 or higher, or 1.2.2 or higher are ok.
      Older versions of Java are *not* able to run jfig.

      Unfortunately, all versions of the JDK including JDK 1.3.x and
      also Microsofts VM still have several bugs. See the "CHANGES"
      and "jvm-compatibility.txt" for additional information.
    
   2. Try to run another Java program. If this doesn't work either,
      probably your Java installation is broken.

   3. Check that you have an intact jfig class archive 
      "jfig.jar" or "jfig.zip". 

      Try to list the archive contents with WinZIP, unzip, or JAR. 
      This should show several hundred files in subdirectories 
      "jfig/canvas, jfig/commands, jfig/doc, jfig/gui, 
      jfig/objects.

      If you can't read the contents of the jfig class archive file, 
      try to download it again (make sure to use binary transfer mode).

   4. Ask your local Java guru for help.

   5. Submit a detailed bug report (see below).


--------


Q: Can I use jfig in combination with the JRE?

A: No problem. Read the preceding paragraph for general information 
   about jfig and the required CLASSPATH settings.

   However, the JRE does not use the CLASSPATH environment variable. 
   Instead, you have to supply the current classpath settings to the 
   virtual machine in the "-classpath" command line option. 

   For example, on a Windows'95 system with JRE 1.1.8 installed to 
   C:\programs\jre118 and the jfig class archive installed to 
   c:\java\lib\jfig.zip, you would start jfig as follows:

   jre -classpath c:\java\lib\jfig.jar; jfig.gui.Editor


--------


Q: What version of jfig have I got?

A: Start jfig and select the "Help->About" menu item. This should 
   display a dialog window with general information about jfig and 
   with the software version.

   Check the jfig homepage on

   http://tech-www.informatik.uni-hamburg.de/applets/jfig/

   for upgrades and the latest version.


--------


Q: Where do I find documentation about jfig or xfig?

A: Select the "Help->documentation" menu item. This opens a dialog 
   window with pointers to online documentation about jfig, xfig,
   the FIG file format, and the transfig/fig2dev programs.


--------


Q: What are the licensing terms for jfig?

A: Select the "Help->license" menu item. This shows a dialog window
   with the current version of the jfig license.


--------


Q: What are the known bugs in jfig?

A: The following list is unsorted. Please study all entries before
   submitting a new bug report. For a list of recent changes and
   updates to jfig, see the "jfig/doc/CHANGES" file in the jfig.jar
   archive or on the jfig homepage.

   o jfig does NOT use the same ordering as xfig for rendering objects
     on the same layer (depth). Indeed, it even reverses this ordering
     during some operations (like opening a compound) for performance
     reasons.

     This means that the appearance of drawings with overlapping
     objects on the same layer is essentially undefined and may very.
     Please correct your drawings to avoid such problems. Just update
     overlapping objects to use different layers.


   o Keyboard-input suffers from many Java virtual machine bugs,
     especially in combination with non-US keyboards. The current
     version of jfig contains a number of workarounds to get the
     most important keys working, but you may still encounter problems.

     For example, the Sun JDK for Windows ignores key-pressed events 
     on the 'DEL' key, and IBMs JDK for Linux crashes when pressing 
     the ALT-GR (=META) key on German keyboards... 


   o Rendering of advanced attributes (like rotated texts, antialiased
     text, fill patterns, dash-dotted lines) requires the Java2D
     library.

     On systems without Java2D, jfig will still maintain and manage
     those attributes, but it cannot display them correctly.


   o Fonts may have to be substituted by (similar) fonts available on 
     your system. See the font question and answer below.


   o Not all of the embedded image formats from xfig are supported.
     As jfig directly uses the Java image import filters, the list
     of supported image formats depends on your Java virtual machine,
     and the list of optionally installed Java packages. 

     At least the XBM, GIF, and JPEG formats should be supported on
     all platforms. Newer JDKs also offer PNG support.

     Unfortunately, embedded Postscript files cannot be displayed.
     Please tell me about any new image filters for Java, especially 
     for TIFF and EPS/PS format.


   o Object selection is a little restrictive, especially for stacked 
     objects. For details, see the section on "object selection" below.


   o Filled arc objects are not rendered correctly. They always use
     the pie-wedge style (no "open-ended arc"), and arrows may be
     lost.

     "Normal" arc objects should work with arrows and all line-styles.    


   Minor and Cosmetic bugs:

   o Corner-markers and rubberbanding are not displayed correctly
     for rotated text and ellipse objects.
   
   o Lines are not clipped below arrowheads (this is just a cosmetic
     problem for thick lines).

   o Multi-line text objects (i.e. strings with '\n' chars) are not
     supported.

   o Manhattan and LaTeX-style geometry is not supported.

   o "Flipped" images are not supported. Workaround: flip the image
     in an external image manipulation program.


   Java-related bugs:

   o No color chooser available. If necessary, edit the FIG file
     with a text editor to include a user-defined color, and reload
     the FIG file in jfig. It will then offer the user-defined color
     in its color dialog.

   o Redrawing is slow under JDK 1.2 and JDK 1.3.

     jfig uses off-screen buffers to improve screen rendering.
     Unfortunately, the image redrawing algorithms used by JDK 1.2.x 
     and JDK 1.3.x are much slower than those used by JDK 1.1.x.
     This is a known JDK bug, which should be fixed in JDK 1.4.

     Workaround: use JDK 1.1.8 or MS jview, resize the jfig window
     to the minimal useful size, and use a fast computer.

   o Nested dialog windows don't work.

     This problem occurs when trying to modify attributes from the
     EditObject dialog window: the additional dialog window may or may
     not appear, it may or may not have the keyboard focus, etc.

     Workaround: only use the "increment/decrement" attribute function
     (=middle or right mouse button) from the EditObject dialog window,
     but not the "select attribute" (=left click) function.

     When trying to change a layer by more than say 10 levels, it might
     be better to select the new layer as the current global layer,
     and then do an "update object" instead of "edit object".

   o Java2D related problems in font rendering: rotation only available
     for TrueType fonts, wrong font substitution, ugly default fonts.

   o Java2D fails to print fillpatterns


--------



Q: I just found another bug in jfig. How shall I report it?

A: Please check first whether the bug is already described in the 
   "known bugs" section of this FAQ list. If it is, complain without 
   detailed error-messages to "hendrich@informatik.uni-hamburg.de" - 
   so that I know which bugs/features are really annoying to users.

   If the bug is new, please send an email with the bug-report to 
   "hendrich@informatik.uni-hamburg.de" and include all of the following 
   information:
   
   1. General description of the bug

   2. System and version information:

      2a. jfig version used
      2b. Host system (Operation system, Java virtual machine, memory, etc.),
          e.g. Windows NT 4.0, JDK 1.1.8, 64 MByte main memory, 
               true color (24bit) display
      2c. Are you running jfig as a standalone application or from inside
          a browser. If the latter, which browser?
      2d. If you suspect a configuration problem, please include all of 
          the "jfig.cnf" or ".jfigrc" configuration files from your jfig 
          installation, your home directory and working directory.

   3. Please include an example FIG file that allows to reproduce the error.

 
--------


Q: Object selection does not work for some objects?

A: Mostly, it should work, but unfortunately, sometimes it does not.
   The editor tries its best to find the object nearest to the mouse 
   position during edit commands, but sometimes the algorithm fails,
   especially in complex situations with overlapping objects:

   o Note that some operations in jfig/xfig require that you select
     an object by clicking on its "control points". For example, to
     move a polygon you may have to click on a polygon point instead
     of clicking to its inside.
 
   o If you receive messages like "please click directly on <xxx>" 
     during operations like move-point, try to change the magnetic
     grid settings (window->magnetic grid->value) or try to click
     also a little to the left/right/top/bottom of the target vertex. 

   o Also, with layered objects, sometimes the wrong object is found
     first. As a workaround, move the "annoying object" away, edit
     the target object, move the annnying object back.


--------



Q: Why can't I rotate objects?

A: Object rotation works. However, you have probably used the default 
   rotation angle, which is 0 (zero) degrees. Just select a non-null 
   rotation angle in the "rotation angle" control button in the 
   attribute panel. Either use the middle or right mouse buttons to 
   step through the set of predefined values, or click the button and 
   enter the rotation angle value numerically.

   Also note that images cannot be rotated and that rectangles can only 
   be rotated by multiples of 90 degrees. 

   While jfig always stores the object rotation angle internally, 
   it requires a Java 2 compatible virtual machine (e.g. JDK/JRE 1.3) 
   in order to render rotated text and ellipse objects to the screen.  
   On JDK 1.1.x and the Microsoft virtual machine, texts and ellipses 
   will be displayed unrotated.

   Finally, rubberbanding for rotated ellipses is broken (and will not 
   be fixed soon, unless somebody else volunteers to do it).  Just 
   select the "corner" points for the rotated ellipse as usual. 
   The created ellipse will be displayed correctly.
  



--------



Q: It seems that jfig has problems with some fonts?

A: This is due to restrictions in the Java graphics API and several
   Java bugs. Also, the status of font rendering has changed greatly 
   with each new version of Java. Finally, the required fonts are not
   installed on all systems. Therefore, the answer on your question 
   depends on the Java virtual machine and the font installation on 
   your system.

   First, note that jfig always stores and maintains all font attributes 
   internally, even when the font cannot be displayed correctly.
   Therefore, you can open existing FIG files in jfig without fear that
   attributes will be lost. If jfig detects that it cannot display
   a selected font (e.g. Bookman-DemiItalic), it will substitute another
   and (and hopefully similar) font.


   Java 1.1 / jview:

   With a Java 1.1 virtual machine (e.g. JDK 1.1.8 or Microsoft Jview),
   an application can only use a fixed set of basic fonts for rendering.
   This set includes Times, Helvetica, Courier with bold and italic
   variants. Therefore, jfig maps the fonts used in your drawings
   to the "best match" of the available fonts. The mapping is compiled
   into jfig and cannot be changed.

   Also, a Java 1.1 virtual machine cannot render rotated text objects. 
   In this case, jfig will store the text rotation angle, but it will 
   render the text without rotation. When loading a FIG file with rotated 
   texts on a Java 1.1 VM, jfig will print a corresponding warning message.


   Java 2 (JDK 1.2, JDK 1.3, JDK 1.4):

   Since JDK 1.2, Java font rendering has improved greatly, with 
   TrueType font support, font antialiasing, and arbitrary coordinate
   transformations. However, all current virtual machines up to JDK 1.4
   still have severe bugs in the font rendering.

   On Windows systems, TrueType fonts are the default for rendering, 
   and the JVM can access and use all installed TrueType fonts.
   However, not all fonts used by xfig are installed on a typical
   Windows system. Therefore, the default setting for jfig is *not*
   to use other fonts than (Times, Helvetica, Courier).

   You can change that behaviour via a set of properties, one for each
   Postscript font, in the .jfigrc (jfig.cnf) configuration file.
   Just uncomment and edit the property for each additional font that
   you have. The property key is the Postscript font name, and the
   property value (the right String on each line) should be the name
   of an available TrueType font and the font shape, e.g. 
   "Verdana,plain".

   jfig.gui.FontCache.AvantGarde-BookOblique   ItcAvantGardeGothic,italic
   jfig.gui.FontCache.Times-Roman              Verdana,plain
   ... 

   Via this mapping, you can also use additional symbol fonts. For
   example, I have used the following setting to access the Cubase.ttf
   font with musical notes and symbols from jfig:

   jfig.gui.FontCache.Helvetica-Oblique        Cubase,plain

   On Windows systems, and possibly on Macintosh systems, uncommenting
   and setting the properties should be enough to get the right fonts.


   On Unix (Linux, Solaris) systems, the situation is even less
   user-friendly, because the JVM uses a special directory to look
   for fonts. Please consult the release notes and documentation for 
   your specific VM (e.g. IBM JDK 1.3 or Blackdown JDK 1.3 for Linux).
   It may be necessary to copy existing TrueType fonts to the special
   JVM font directory, and it may even be necessary to rebuild the
   fonts.dir information (which is too complex to be covered here).
   
   LaTeX-fonts are currently not supported by jfig. 


--------



Q: Are there bindkeys (shortcut keys) for frequently used commands?

A: Yes. First, check the jfig main menu bar for the menu shortcuts.
   These typically use combinations of <CNTL>+key or <SHIFT>+<CNTL>+key.
   The menu shortcuts are managed by the Java virtual machine and cannot
   be changed.

   Second, jfig supports the following additional and simple bindkeys
   for most frequent editing commands. These allow for very fast editing
   by selecting a command with the bindkey with the left hand while
   keeping the right hand on the mouse.

   Note that the default bindkeys are mostly but not fully xfig-
   compatible, because Java does not support CTRL-key combinations
   reliably.
   The following list is sorted by the command button panel layout:

   'e'  'c'       create an Ellipse,             create a Circle
   'S'  's'       create a closed Spline,        create a spline
   'I'  'i'       create a closed Bezier spline, create a bezier spline
   'p', 'l'       create a closed Polygon,       create a polyline
   'b',           create a Rectangle (box),
        'r'                                      create an Arc
   'J', 't'       create an Image,               create a Text

   'g'  'G'       create a Compound object,      break a Compound,
   'o',           open a Compound temporarily,
   'M', 'm'       move an object's point,        move an object,
   'a', 'C'       insert a point,                copy an object,
   'D', 'd'       cut a point,                   delete an object,
   'u', 'E'       update object attributes,      edit an object,
   'F', 'f'       mirror object along x,         mirror object y,

   'Z', 'z'       zoom in,                       zoom out. 

   Naturally, the bindkeys are disabled during editing of text objects. 


----------



Q: Can I customize the appearance and functionality of jfig?

A: Yes. On startup, the both the jfig editor and viewer will search
   for and parse five configuration files in the following order:

   1) a global configuration file "/jfig/jfig.cnf", usually packed
      in the original "jfig.jar" (or "jfig.zip") class archive.
      Depending on your installation, a "/jfig/jfig.cnf" may also
      be found on your CLASSPATH.

   2) a user configuration file called "jfig.cnf" in the user
      home directory (i.e. ~/jfig.cnf on Unix, and different
      places for different versions of Windows).

   3) a user configuration file called ".jfigrc" in the user
      home directory (i.e. ~/.jfigrc on Unix).

   4) a local configuration file "jfig.cnf" in the current working
      directory, i.e.  "./jfig.cnf".

   5) a local configuration file ".jfigrc" in the current working
      directory ( "./.jfigrc" on Unix).

   Edit the properties in either of this files to customize the behavior
   of jfig. Note that you can overwrite global settings with user
   settings, and these in turn with local settings.

   Note: You can also include your own "/jfig/jfig.cnf" with the 
   Java CLASSPATH, so that the virtual machine finds your configuration 
   file before the default configuration file. For example, put your file
   to "c:\users\joe\jfig\jfig.cnf" and 
   set CLASSPATH=c:\users\joe;c:\software\classes\jfig.jar;

----------



Q: Can I integrate jfig with my own killer application?

A: In principle, this is very easy for both the editor and the viewer.
   The current version of jfig (1.5x and later) has a fully modular
   architecture, and you can easily add new commands and even new object 
   types.

   Unfortunately, there is no user documentation about this yet.

----------



Q: How to run jfig on a notebook at 800x600 pixels?

A: Depending on your OS and JVM version, the size of the Java GUI 
   components may vary slightly. Usually, jfig should be useable 
   with a display resolution of at least 800x600 pixels. 

   While the "zoom" buttons may be off-screen, this is not a major 
   problem. You may want to disable the Windows taskbar ("automatically 
   in background") or move the taskbar to the left/right of the screen.

   You may also want to set the jfig.gui.Editor.AttribsScrollPaneEnable 
   property to true, to get access to all attribute controls for the
   "update" operation. However, this needs additional screen area and
   doesn't look good, IMO.


----------



Q: What do you mean by "Unicode" support?

A: Java promises to provide Unicode characters on all supported platforms.
   Currently, Unicode is used in the Java language, all Java class 
   libraries and also jfig.
   
   Additionally, jfig uses "\uxxxx" escapes in its files to store 
   unicode characters. This is _not_ FIG 3.1/FIG 3.2 compatible,
   but it should allow to exchange jfig and xfig files without problems.

   Whether the unicode characters will be displayed correctly, depends on
   your platform and configuration. On most Unix systems, the greek and
   some math characters will be displayed correctly, but Cyrillic or
   Arabic characters will not.
   On Windows, you can install "Font packs" to get more or less complete
   Unicode fonts and support.


----------



Q: Exporting via fig2dev does not work?

A: Most xfig/jfig users want to export their drawings to Postscript
   format, to include them with TeX/LaTeX or Word documents.
   The easiest way to convert a drawing to Postscript format is to
   install a Postscript printer and to print the drawing to a file.
   Select "menu->file->print (java native)" to print the drawing
   in the current zoom factor and translation. 

   Due to severe bugs in the Java printing API, this may or  may not
   work. Also, on Java 1.1 not all object attributes are supported and
   render quality is low.

   The second way is to use the xfig companion program "fig2dev",
   which also supports many output formats beside Postscript.
   However, fig2dev is not available in a Java implementation.
   Therefore, you have to install the fig2dev program and to set up
   an interface between jfig and fig2dev.

   For information about exporting and fig2dev, please read the
   file "/jfig/doc/export-fig2dev.txt" in the class archive,
   or select "menu->help->export and fig2dev".


----------


Q: Running a jfig presentation

A: Usually, a jfig presentation JAR archive includes the jfig
   viewer software, so the following should work:

   JDK/JRE 1.3:
   java -jar c:\path\to\your\presentation.jar

   MS jview:
   jview /cp c:\path\to\your\presentation.jar jfig.gui.PresentationViewer


----------


Q: Building a jfig presentation

A: The current jfig.jar class archive includes several utility
   applications besides the jfig editor.

   One of those is the jfig presentation viewer, which allows 
   to combine several FIG files and all embedded images
   into a "Powerpoint"-style presentation.

   To build such a presentation, open a command shell and run
   the following command (assuming jfig.jar is in your CLASSPATH):

   java jfig.utils.PresentationBuilder

   This prints a short help message with all the options. The 
   typical usage is:

   java jfig.utils.PresentationBuilder -jar <dest> <dir> <viewer.zip>

   where 
   <dest> is the filename of the resulting presentation archive,

   <dir>  is the directory with all the .fig slides and .jpg, .gif,
          ... embedded images (if any),

   <viewer.zip> 
          is the absolute path to the jfig-presentationviewer.zip
          of jfig.jar archive, if you want to embed the jfig
          viewer software within the presentation archive.

   
   Because the PresentationBuilder adds the slides ordered by their
   file names, the order might not be as intended. In this case
   you would use a three step process to re-order and edit the
   presentation.

   1. First, create an index file with all the slides:
   java jfig.utils.PresentationBuilder -jpt <dir>  > tmp.jpt

   2. Edit the index file to reorder the slides or omit some:
   edit tmp.jpt

   3. Create a new presentation with the existing index file:
   java jfig.utils.PresentationBuilder -jar <dest> <dir> <viewer.zip> tmp.jpt
   
   

----------
