XCircuit v3.8 ----------------------------------------------------------------------------- An X11 drawing program [especially for circuit schematics] Copyright (c) 2013 Tim Edwards August 1993 -- January 2013 ----------------------------------------------------------------------------- This README file contains additional notes about the program which may or may not be of interest to anyone. ----------------------------------------------------------------------------- ASG: Versions beginning with 3.2 can be compiled with the ASG package, or "Automatic Schematic Generation". The package is derived from SPAR, written by Stephen Frezza (currently at Gannon University). SPAR is based on the same "corner-stitched tile" structures used by the EDA tool "magic", modified to encompass the probabilistic nature of auto- routing. The ASG package currently supports (to a limited extent) reading of SPICE files, but will eventually support EDIF netlist output from Verilog (and possibly VHDL) for turning netlists into schematics. Also, the ASG package will handle constrained moving, re-routing networks in response to moving elements around the schematic drawing. Toolscript: Versions beginning with 3.0 are part of a methodology known as "ScriptEDA", a call to put major open-source EDA tools into a similar framework under an interpreter, where most upper-level functions can be written as scripts. My more narrowly-defined version of ScriptEDA is called "toolscript". The rationale behind "toolscript" is to allow a single interpreter to launch multiple EDA tools, such that a single script can control multiple programs, bringing together layout tools, schematic capture, simulation, and so forth, in a highly integrated manner. "Toolscript" requires that each EDA tool should be a shared-object library of routines, that each tool should have its own command namespace, that each tool should launch itself from a "start" command in its namespace, and that the "start" command should return control to the interpreter such that the interpreter is always available from the calling terminal. Applications are encouraged to rely heavily on scripts for functions which do not require fast execution. In particular, scripts should handle most input/output functions, so that users can easily change file formats to suit their needs. The GUI for toolscript applications should be written in Tk, which integrates the graphics event loop with the interpreter, greatly simplifying handling of the interaction between the two. To synchronize the GUI with commands called from the command-line, each program should have a "command tag" function which can associate a script procedure with each command. These callback procedures can then be defined within the GUI script to update the GUI in response to commands. Finally, each application should redefine "printf" output statements to call the corresponding output method for the intperpreter (e.g., "Tcl_Eval" for compatibility with the "tkcon" console). This allows error and standard output to be handled independently. Within "tkcon", stdout and stderr are printed in blue and red, respectively, making the program output easier to read. The "toolscript" concept is ideally interpreter-independent. However, due mostly to ease of implementation and syntactical issues, TCL has ended up as the only supported interpreter. TCL calls are heavily embedded in the source code, making it somewhat difficult to simply add another interpreter. While XCircuit can be compiled with the Python interpreter, it is embedded, not extended, and so does not follow the principles of "toolscript". Rationale: This program was written with a number of things in mind. The major point in writing it was that I found all of the drawing programs freely distributed at the usual X11 ftp sources (ftp.uu.net, export.lcs.mit.edu, etc.), which includes xpic and xfig, and even some other programs like idraw and commercial programs like framemaker, were lacking in some manner. Some of them, like xpic, are missing fundamental parts, while others, like xfig and framemaker, have a cumbersome user interface and require inordinately large amounts of time to create simple pictures. The really powerful programs like Adobe Illustrator are, naturally, expensive. There has been a long-standing tradition of making MacDraw lookalikes which I find particularly disturbing, since a number of features of that GUI are fundamentally screwed up, including the dependence on a black-and-white color scheme for things such as grid lines and edit points which can make the screen cluttered and difficult to work with. I have chosen to freely ignore all such standards in cases where they seem to hinder rather than help the user. Disclaimers: The above comments refer to versions of the abovementioned programs available as of 1993 and do not necessarily reflect the programs' current status. Particularly the latest (from 1995 or so) version of xfig is quite good, though it continues to have a "MacDraw" feel to it. XCircuit's schematic capture has always been secondary to its use for drawing, and users may prefer programs such as "gschem" (by Ales Hvezda, part of gEDA) that are more in keeping with "normal" standards for EDA software. Because such programs exist, XCircuit's schematic capture, like its basic drawing functions, often deviate from the norm to explore radical ideas. Among XCircuit's "radical ideas" are automatic port finding, its parameterization method, embedded output formatting directives, and (a recent addition) automatic schematic (re)generation. The principles of XCircuit are as follows: A) Structural backbone 1) There are six drawing elements which are considered "primary". These are as follows: a) polygon (multiple lines which may or may not be closed and filled) b) arc (ellipse segment which may be closed and/or filled as above) c) label (any text) d) curve (based on the PostScript "curveto" algorithm) e) graphic (graphic image, e.g., from a PPM file) f) object instance (see below) 2) There are two drawing elements which are considered "secondary", which is to say, contain instances of primary elements. These are: a) path (a connected series of polygons, arcs, and/or curves) b) object (something containing polygons, arcs, labels, curves, paths, and instances of other objects) Each object is instanced by a primary element called the "object instance", a self-contained unit which allows an object to be scaled, rotated, and translated within another object. Since objects contain object instances and object instances point to objects, there is a two-step recursion which is central to the concept of xcircuit. 3) There is one primary object instance called the TopObject, which is the program window, and its associated object, which is whatever appears on the screen. TopObject is a pointer, so that any object in memory may be the top object, allowing a push/pop edit stack. All other objects are organized in an array of pointers called the Library. The Library is filled on startup with the contents of a Library file, and is expanded whenever a new object is created. Actually, there are many different TopObjects, called "pages", which can be switched between at will by typing the number of the page, 1 through 9 and 0 for page 10, or through the "Page" menu command, which allows access to as many pages as are defined. The "load" and "save" commands act only on the present page (unless multiple pages are loaded at a time), as do all the drawing commands. 4) All elements allocate memory as they are created and release the memory as they are destroyed, so the only limit on the number of elements in a drawing is the memory of the workstation. B) Input/Output 1) All input and output is in PostScript, albeit a version of PostScript with extremely restricted syntax: xcircuit is in no sense a PS interpreter! The primary element types are defined as procedures in the PostScript prologue; all secondary elements are defined as "def" structures in PostScript, the only restriction being that no definition can be called before it is defined. 2) Output can be encapsulated or non-encapsulated ("full page"), and can have multiple pages. All pages which declare the same "filename" on the "output properties" window will be saved to the same file. 3) The current state of the program is captured from time to time (default 10 minutes or 20 "significant" changes to the drawing) in a temporary file. If XCircuit crashes, work can be recovered by running "xcircuit" without arguments (i.e., without a specific filename on the command line). This method makes the filename transparent to the user, but the file can be found (on most systems) as /tmp/XC??? where ??? is a randomly-generated number that uniquely identifies the file. 4) Text is vector-drawn, in order to best match the flexibility of PostScript, which unlike X11 allows text to be scaled to any size and rotated to any orientation (modern font renderers can do this, but are not good at fast on-the-fly rendering needed for a drawing The quality of the vector-drawn text on the screen is relatively poor; however, the end product of xcircuit is the PostScript file, which does not suffer from those limitations. Text vectors are xcircuit elements read from an xcircuit library file, with encoding information read from a separate file. 5) X11 does not have any capability for generalized curves (splines). Therefore, splines are constructed by an N-segment approximation which internally looks like a polygon. The PostScript output is a smooth curve instead of the approximation. 6) X11 does not have any capability for generalized ellipses (ellipses under any rotation). Similarly to the splines, arcs are constructed by an N-segment approximation. 7) Implementing all arcs and curves as N-segment approximation allows the possibility of general paths, or sequences of polygons, arc sections, and curves which form a path that can be bordered, closed and/or filled like an individual arc, curve, or polygon. 8) Other than the qualitative appearance of the text, the screen output of xcircuit is meant to be the closest possible match to the rendering of the PostScript output. A PostScript hack allows stipple pattern fills to be effectively "transparent" (something that PostScript does not do naturally). However, the effect is *extremely* device-dependent because it overrides the printer's halftoning operators. One effect of this is that halftoning will look abnormally large when viewed at screen resolutions, e.g., with GhostScript. C) User Interface 1) The mouse button system and the object library are based on the Caltech circuit-simulation program "log" (either "analog" or "diglog"). As is usual for most applications, mouse button 1 is used to select things or cycle between selections, button 2 usually terminates a command, and button 3 will abort a command. In addition, button 1 has a function called "hold", which occurs after the button has been continually pressed for a short length of time (about 1/5 second). As the name implies, "hold" grabs hold of an element which can then be moved around the screen. Because this program is tailored to circuit drawing, the most common functions are drawing lines and moving object instances. Therefore, these two functions are made directly available from the mouse button 1 (after a "tap" or a "hold", respectively). The next most common function is selection of elements singly or in groups. Button 2 can be used to select an item if tapped, and if pressed and held down, a box will be drawn and everything inside that box selected when the button is released. All other commands are available from the pulldown menus and/or from the keyboard as single-key macros. Keyboard macros are quicker, since they act on the present cursor position, whereas menu commands require an extra step. From version 3.4, buttons and keys are handled identically by the interface, with the "hold" function becoming a modifier like "shift" or "control". All XCircuit functions can be arbitrarily bound to any button or key. The button 1 binding corresponds to the drawing mode. If button 1 is bound to function "Wire", then it works as described above. If it is bound to "Arc", then button 1 can be used to draw arcs, while the other functions remain the same. 2) The libraries are intended to provide a convenient way to store and retrieve elements of a picture which will be used more than once. For the application of circuit drawing, a built-in library provides basic objects such as transistors, amplifiers, resistors, capacitors, arrows, circles, power and ground symbols, and the like. This file ("builtins.lps") is loaded on startup; the program first looks in the current directory, and then searches in a given global directory (something like ~cad/lib/xcircuit/) if it could not find it initially. Thus each user can add to or modify the file of builtins to reflect personal taste. Since the PostScript output contains all object definitions, these changes to the built-in functions are inherently transferrable. The program checks objects with the same name for equivalence of their contents, and changes names as necessary to avoid conflicts. An additional library, the user library, contains all of the objects which are created (using the "make object" command) during a session or objects which are loaded from a file but do not belong to the built-in library. The user library can be saved by itself and reloaded later either into the user library or into the built-in library. This is the way to create a personalized built-in library set. 3) In the non-TCL-based version of XCircuit, the special file "startup.script" can be edited to include lines such as the following: filename loadlibrary The loadlibrary command will automatically include another library file. This method makes it convenient to divide up libraries into separate files according to (for instance) function (digital, analog, clip art, etc.), and use the loadlibrary commands to choose which ones will be loaded on startup. Caveat: If the order of loading is such that an object contains an instance of another object which has not yet been loaded, xcircuit will complain. In the TCL-based version of XCircuit, the equivalent file is "xcstartup.tcl" and the syntax is: library n load filename where "filename" is the name of the library file (e.g., "digital.lps"), and "n" is the library page number. By specifying the same page as an existing library, a set of objects can be appended to that library. "n" may also refer to a library by name. By default, libraries have the extension ".lps". As they contain only macros, they cannot be displayed with any PostScript interpreter. 4) Xcircuit has a strict sense of zooming and snap-to grid. Objects scale absolutely; line widths and text sizes will increase/decrease proportionally with the zoom, as well as dot/dash spacing and all other features. Xcircuit does have a minimum integer grid in coordinate space, which translates to 0.005 inches at an output scale of 1. The maximum zoom scale gives a screen size translating to about 100 by 100 inches at an output scale of 1. The effective scale can be varied by changing the output scale (reached from the "File/Write" menu selection) in order to fit a drawing to a page or to get a grid matched to a specific dimension. A separate scale parameter changes the scale of the reported position relative to the output scale (as it will appear on a printed page). 5) The snap-to grid is an all-important feature for circuit drawing, wherein it is critical that wires line up properly with one another. In xcircuit, there is no way to get off the snap-to grid except by turning the snap function off and physically pushing elements off the grid. In any case, objects can always be returned to the snap grid with the "snap" function (key 'S'). D) Schematic Capture XCircuit implements a sophisticated schematic capture. Unlike virtually all schematic capture software currently available, xcircuit allows the designer to draw the circuit in a "natural" way, making use both of schematic hierarchies and simple hierarchies created simply by grouping elements together. If the chosen netlist format is hierarchical (like SPICE), both hierarchical forms will be retained in the output. For element grouping, input/output ports connecting into to the group will be determined automatically, from context. Individual networks can be queried (key 'Alt-W') to highlight the entire visible part of the network, with the network name printed in the message window. Any schematic can cover multiple pages. One page is marked as "primary" and the others marked as "secondary". Netlists are generated in the primary page object only, but incorporate information from all the schematic pages. All pages which have the same "page label" are considered to be part of the same schematic. ----------------------------------------------------------------------------- Xcircuit reference: Local: See the xcircuit manpage ("man xcircuit") Online: http://opencircuitdesign.com/xcircuit/features.html ----------------------------------------------------------------------------- Online tutorials: See Standard: http://opencircuitdesign.com/xcircuit/tutorial/tutorial.html Schematic capture: http://opencircuitdesign.com/xcircuit/tutorial/tutorial2.html ----------------------------------------------------------------------------- Things to do: See the file "TODO" -----------------------------------------------------------------------------