
This is until, a graphics editor written by Glenn Gribble, ported to
UNIX by Steven DeWeerth, and maintained under Unix by John Lazzaro.
Unix is distributed under the GNU General Public License; see file
COPYING in this directory for more information.

If you have a web browser, the best way to learn about what until is
and how to install it is to pick up the latest version of the webdoc
Web pages (webdocX.XX.tar.gz, where X.XX is a version number) from the
same place you picked up this file. Once you have this Web tree
untarred, point your Web browser (examples of Web browsers include
Mosaic, Lynx, Netscape, and tkWWW) to webdoc/index.html for the home
page of the Chipmunk tools, and to webdoc/compile/compile.html for
compilation instructions.

The rest of this file is written assuming that you don't have access
to a Web browser -- all text is copied from webdoc pages
verbatim. I'll do my best to keep this file up to date, but the Web
tree is now the primary documentation for all aspects of the Chipmunk
system.

---------

Until 
-----

Until is a graphics editor written by Glen Gribble,
incorporating code from an earlier graphics editor written by
John Wawryznek and Telle Witney. The primary purpose of
the tool is to generate publication-quality graphics: all of the
figures in Carver Mead's book Analog VLSI and Neural
Systems were drawn in Until, and imported into LaTex.
Features of Until include: 

Many drawing modes 
   Bezier curves, circles, ellipses, polygons, arrows, and
   several types of boxes can all be drawn with Until.
   Control points for Bezier curves can be viewed and
   directly altered. Mixed hierarchy is supported:
   instances of figures and primitive elements can be
   mixed on a page. Instances can be rotated, scaled, and
   flattened as needed. Text is supported with many fonts. 

Input compatibility 
   Until accepts graphical output from the Chipmunk
   tools Log and View , so that output from these tools can
   be annotated before inclusion into documents. 

Output compatibility 
   Until can generate two types of Postscript. One output
   type is standard encapsulated Postscript, including all
   text labels; this type of Postscript is compatible with
   the psfig macros included with dvips . A second output
   type splits the figure into two files: a Postscript file for
   graphics, and a TeX file for labels, including placement
   information in TeX. An included macro package, 
   psmac, overlays these two files in a TeX document,
   allowing the fonts in a figure to match the fonts in the
   main text. 

Edit-extend mode 
   Edit-extend mode is another special feature of Until; it
   lets the user change parameters for graphics objects
   using text input. In this way, graphical and textual
   manipulation can be combined as convenient during
   figure creation. 

For users with simple illustration requirements, Until can be a
cost-free alternative to commercial tools like Framemaker,
when used in conjunction with TeX. Compatibility with
Analog and View formats, and the special functionality of the
psmac TeX macros, are two other reasons users choose Until. 

Platforms and Requirements 
--------------------------

The Chipmunk tools require an ANSI c compiler (typically GCC) and
X11 (R4, R5, or R6). Color displays with 8 bits per pixel work best for
Chipmunk (other than 8bpp can be problematic), although Log supports
black-and-white displays. An HTML browser (like Mosaic or Lynx or
Netscape) is also necessary to access the Chipmunk documentation.

These are the currently supported platforms, with details of
platform-specific requirements: 

   AmigaOS. Requires ADE X or AmiWin X11.
   Apple Macintosh, OS/X. 
   Apple Macintosh, AU/X. 
   DEC MIPS-based DECstations 
   HP Series 300/400, HPUX. 
   HP Series 700, HPUX. The HP-supplied cc, with extra-cost
   ANSI option, will also compile Chipmunk. 
   IBM PC and Compatibles, FreeBSD. 
   IBM PC and Compatibles, Linux, Slackware. 
   IBM RS/6000. The IBM xlc compiler is known to compile
   Chipmunk; gcc has not been tested. 
   SGI. Chipmunk known to work on Indigo and Challenge, no
   others were tested. The SGI cc is recommended. 
   Sun SPARC, Solaris 1.X (SunOS 4.X). 
   Sun SPARC, Solaris 2.X (SunOS 5.X). 
   IBM PC and Compatibles, OS/2. 

     OS/2 Requirements 

     Only the Log system (diglog, analog and loged) is ported. However,
     porting Log meant porting Psys: if you are an OS/2 user who is 
     interested in porting Until, the Log port gives you a good head
     start.

     The icc compiler. Not known if gcc will work also, please let
     me know if you try gcc. 

     OS/2 with TCPIP and X11 (PMX). OS/2 revisions 2.1 and higher
     should work, but all current testing has been done using WARP.
     TCPIP version 2.0 with the "latest CSD's" to the Base kit is also
     needed, as is the X-server (PMX) kit. 

If your configuration is different than the ones described above,
only take the package if you feel confident in your C/Unix abilities
to do the porting required. If you do successfully port to a new
architecture or OS, send us the changes required, and we will
incorporate your port in the next release of the chipmunk tools.

Here is the know status of Chipmunk on popular platforms not currently
supported

   IBM PC-Compatibles, MS-DOS or Windows. No ports are in progress, to
   my knowledge. 
 
   IBM PC-Compatibles, NextStep. No ports are in progress, to
   my knowledge. 

   Apple Macintosh, MacOS. No ports are in progress, to my
   knowledge. 

   DEC Alpha, OSF/1 or VMS. Several Alpha ports have failed,
   because of 64-bit compatibility problems with binary file I/O. I
   don't think the port is impossible, just more difficult than the
   successful ports listed above. 

To get until running, first bring over a copy of psys-Y.YY.tar.Z (where
Y.YY is a version number), available at the same place this file was
found. Untar and make psys per instructions in the package.  After
psys is installed, you can start to install until.

Compiling Until 
---------------

This document assumes that you have successfully compiled
the Psys libraries. This document also assumes that you have
uncompressed and untarred the Until file, and installed it in the
chipmunk directory. Note that Until has not been ported to
OS/2.

Begin by descending to the until/V1.2 directory. Edit the
file Makefile, and make any necessary changes. Comments
in the Makefile will guide you through these changes; the
changes are labeled with the markers (1), (2), (3), ect. Once
these changes are made, execute the command 

make install 

If things are working correctly, a long series of compilations,
linkings, and file movements should occur without error. This
will create the program chipmunk/bin/until. 

To do a basic functional test of Until, execute the following
command in the until/V1.2 directory: 

./until welcome 

Two windows should appear, mylib and newcrt. The 
mylib window should a welcoming message which is a figure
made in Until. To leave the program, press q. To learn more
about using until, see the user documentation. 

If you have problems compiling until, I'd be happy to offer
suggestions.Send email to lazzaro@cs.berkeley.edu and include the
following information.

   Complete machine configuration, including machine type, OS
   revision, compilers, and X servers. 

   A listing of the output from the failed compilation process, or
   any messages printed by a Chipmunk program or the OS or X
   when an error occurs.
 
   Details of any changes you have made to the distribution before
   this compilation. 

   The effects of following any advice given in the compilation
   instructions. 

Documentation for Until 
-----------------------


All of the documentation for using Until is included in the webdoc
package. See:

webdoc/document/until/index.html

----

If using the Webdoc documention isn't practical, you can look directly
at a very brief manual written by Glenn Gribble, in Postscript:

until/doc/until.ps

The manual is basically untouched from the pre-Unix version of
Until. Luckily, the Macintosh-like menu system of Until makes it the
easiest of all the Chipmunk tools to learn via exploration.

Postscript generated by the PS menu command creates Postscript
that is compatibile with the psfig macros in TeX and LaTex.
Incidently, all other Chipmunk tools also create psfig-compatible
Postscript. 

Postscript generated by the PS-LBL menu command creates two files, a
Postscript file and a TeX file that contains all textual parts of the
figure. The Until package includes the macro package psmac that can
accept these two files, and produce figures where the text in the
figures is in the same font as the text in the rest of the document.
The directory chipmunk/until/designrules contains an example using
these macros in this way.

The major changes to Until in this release is increased stability on
the HP 700/800 series platforms, and the new postscript support
mentioned above.

						--john lazzaro

