Graphical User Interface Development Systems
Steve Baum This is a brief (not meant to be all encompassing) list of packages that assist in developing interfaces, graphical and otherwise, to programs and other beasties. The list can be found at:http://www-ocean.tamu.edu/~baum/graphics-GUI.html. If you've got an old program or three and want to build a quick and easy visual interface to them, then try one of these packages. They can turn a command-line driven program into a magnificent point-and-click experience faster than you can say "Jack Robinson." The list is oriented toward those packages that will run on generic UNIX platforms, especially Linux. A longer and less detailed list of such things (including commercial offerings) can be found in the User Interface Software Tools list of Brad Myers at:
http://www.cs.cmu.edu/afs/cs.cmu.edu/ \ user/bam/www/toolnames.html
Another good resource is the WWW Virtual Library section on Visual Languages and Visual Programming.
http://cuiwww.unige.ch/eao/www/Visual/ Visual.Programming.biblio.html
All of these packages are freely available for non-commercial use. Some can even be used for commercial purposes, although you should be sure to find and read the usage limitations (if any) for each package. Enjoy. Amulet Amulet is a user interface development environment containing a comprehensive set of tools that make it significantly easier to design and implement highly interactive, graphical, direct manipulation user interfaces. These applications will run without modification on both UNIX and PC platforms. Presently, Amulet provides a low-level toolkit layer, an object-oriented, constraint-based graphical system that allows properties of graphical objects to be specified in a simple, declarative manner, and then maintained automatically by the system. A higher-level tool is in the works that will allow interfaces to be developed without programming. Features of Amulet include a dynamic, prototype-instance object system that makes prototyping easier, constraints integrated with the object system, a machine-independent graphics system, and a high-level object-oriented output graphics model that handles automatic refresh of objects when they change. It also includes a high-level input model, which makes it easy to add behaviors to objects and supports undo and help for operations, and a set of flexible widgets including buttons, check boxes, radio buttons, menus, menu bars, scroll bars, scrolling windows, and text input fields. The source code for UNIX or PC platforms is available as is a 200+-page user manual and tutorial in PostScript format. Amulet should compile and install on generic UNIX platforms using the gcc 2.7.0 along with libg++, and there is a separate makefile script for Linux platforms. It requires Visual C++ for installation on PC platforms. This is the successor to the Garnet project.
[http://www.cs.cmu.edu/afs/cs/project/amulet \ /www/amulet-home.html]
Cvo C++ Visual Objects (Cvo) is a toolkit for building visual tools for the X Window system. It is written in C++ and visually resembles the Motif toolkit, but there are significant differences between Cvo and other toolkits. These differences include an object-oriented design, executables typically two to four times smaller than those compiled using other tookits, and less code to write per application. It also includes a smaller and more consistent set of interfaces and applications that are (due to the above reasons) inherently more maintainable. Cvo also takes advantage of the internationalization features inherent in X11R5 and later releases. A rich set of visual objects Cvo provides, including standard items like buttons, text displays, input boxes, pop-up and pull-down menus, scrolling lists, and radio boxes. More specialized objects, such as a chart object that expands to support 3-D and pie charts and a canvas on which an application may paint, are also included. New complex objects can easily be constructed using existing objects as building blocks, owing to the object-oriented nature of the toolkit. Cvo also attempts to consolidate similar concepts within a single method (for example, "callback" functions are treated like any other "event"), which reduces not only the complexity of the system but also the amount of information an application writer needs to remember to use it. Cvo was created as an internal Cray Research Inc. project but, for various reasons unrelated to its utility, was made freely available subject to a fairly permissive copyright notice. Extensive documention is included with the distribution, including a tutorial in PostScript and hypertext documentation of the visual objects in the toolkit. There are several makefiles for various architectures and Cvo can be built using GCC/G++, making it amenable to compilation and use on Linux platforms.
[ftp://ftp.x.org/contrib/libraries/] [ftp.krystal.com/pub/]
DIRT The Design In Real Time X user interface builder allows the interactive creation and rapid prototyping of X user interfaces using the X Toolkit and a number of other widget sets. User interfaces are created interactively via the direct manipulation of user interface objects, that is, widgets, such as push-buttons, menus, and scroll bars. The look and feel of each widget is controlled by attributes that can be modified interactively. Objects can be used as soon as they are created; Dirt generates the source code required for the designed user interface and separates the user interface definition from the application code. The object classes available in Dirt are the Athena Widget Set, the standard set for the Xt Toolkit, and the UKC Widget Set, a smaller set of widgets that were created mainly for Dirt but can be used across a wide selection of user interfaces. A lot of these are extensions of the Athena Widget Set. The addition of new widget classes is a straightforward procedure. This should compile on generic UNIX/X Window systems since the aforementioned widget sets are included in the standard X distribution. A 36-page PostScript user guide is available, as well as another, more technical, document describing the implementation of DIRT and how to add new objects to the system.
[ftp://ftp.ukc.ac.uk/pub/rlh/ \ src/X/dirt/]
Finesse Finesse is a tool designed to generate and evaluate windows in shell scripts. This allows the easy conversion of the dialog portions of an existing script to a mouse-oriented Motif user interface. No knowledge of programming X Windows is needed, since the windows are generated by several easy-to-use commands called in the script. A graphical shell script user interface can thus be developed quickly and easily. Binaries of Finesse are available for DEC Alpha, HP9000, SGI Iris, IBM RS6000, SUN4, and Linux platforms, and documentation is available in both German and English.
[ftp://ftp.science-computing.uni-tuebingen.de/pub/finesse/]
Fresco An object-oriented application programming interface (API) system for the development of window-based applications, Fresco is a design evolution of the Interviews toolkit. It covers the functionality of Xlib and Xt and adds structured graphics and application embedding, thus bringing together objects that have not traditionally been mixed. The most important advance in functionality is support for graphical embedding, wherein a single, simple model of graphical objects is provided that supports composition of both graphical objects as in a drawing editor) and application-level editors such as word processors or spreadsheets. It is also capable of interoperating with Xt/Motif widgets. Fresco uses the standard CORBA (http://www.acl.lanl.gov/sunrise/DistComp/Objects/corba.html) distributed object model and provides a standardized, high-level notation called IDL for object definition. There is also support for Tcl/Tk-based scripting (http://www.smli.com/research/tcl/), multi-threading, resolution independence, and internationalization. It is currently undergoing a standardization process via the X Consortium (http://www.x.org/). Fresco is under continual development and snapshots of the current full source distribution are available, as well as binaries for several platforms. The current snapshot (1/96) supports UNIX/X11 as well as Windows NT and Windows 95, with a Macintosh version in the works. Binaries are also available for several platforms and available at the home site, some created at the site (Sun SPARC and Windows NT and 95) and others contributed by third parties (DEC Alpha, HP, SGI, and Linux). Hypertext and PostScript versions of a tutorial are available.
[http://faslab.com/fresco/ \ HomePage.html]
Garnet Garnet is a user interface development environment for Common Lisp and X11 or Macintosh. It helps you create graphical, user interfaces for applications. It includes a custom object-oriented programming system, widgets for multi-font, multi-line, mouse-driven text editing, automatic generation of PostScript, support for large-scale applications and data visualization, two complete widget sets, interactive design tools for creating an interface without writing code, an interactive tool for creating new widgets, and more. It will run on generic UNIX boxes with X11 and an implementation of Common Lisp for example, Allegro, AKCL, CLISP, etc. The source code can be obtained at the Garnet ftp site:
ftp://a.gp.cs.cmu.edu/usr/ \ garnet/garnet/
A successor to Garnet called Amulet (described above) is currently being developed.
[http://www.cs.cmu.edu/afs/cs.cmu.edu/ \ project/garnet/www/garnet-home.html]
GINA++ The Generic Interactive Application for C++ is an object-oriented application framework that facilitates the development of applications having a GUI. It is written in C++ and uses OSF/Motif and the X Window system for the interface parts. GINA++ comes as a set of C++ classes with a set of demo applications. The classes constitute an executable program that possesses the basic functionality and user interface components identical to all interactive graphical applications, but lacks any application-specific behavior. This package should compile using GCC/G++ (2.5.8 or later). Some demo applications do not compile with GCC, in particular, those that use template classes.
[ftp://ftp.gmd.de/gmd/ginaplus/]
GroupKit GroupKit is a groupware toolkit for developing real-time conferencing applications. Applications such as drawing tools, editors, and meeting tools can be shared simultaneously among several users. The goal of this software is to make developing groupware applications only slightly more difficult than single-user applications. It has been used as a research tool for prototyping groupware systems and investigating multi-user architectures and interaction techniques, and also as a graduate level teaching tool. A number of conference applications are included in the distribution, including a brainstorming tool, a file viewer, a fisheye, a group sketchpad, a group draw, a hypernode editor, a postit note editor, a simple sketchpad, a text chat and editor, and several simple games. Session managers, the programs used to create, locate, and join conferences, can also be constructed using GroupKit. GroupKit should compile and install on generic UNIX/X11 workstations. It is based on the Tcl/Tk toolkit as well as an extension called Tcl-DP, a Tcl front-end to standard UNIX sockets. The source code is available and should install on the indicated platforms if these tools are first installed. The documentatation consists of a 50-page users' manual and several papers, all available in PostScript.
[http://www.cpsc.ucalgary.ca/projects/grouplab \ /projects/groupkit/groupkit.html]
MET++ MET++ is an object-oriented application framework that supports the development of multimedia applications by providing reusable objects for 2-D graphics, user interface components, 3-D graphics, audio, and music. It manages the standard behavior of a multimedia application, such as time synchronization and user interaction (e.g., file dialog, cut and paste, commands, etc.). MET++ is an extension to the ET++ Application Framework, an object-oriented class library that integrates interface building blocks, basic data structures, input/output, printing, and high-level application framework components. It supports user-interaction features such as direct manipulation, multi-undoable commands, and a flexible mechanism to compose visual objects with declarative layout specification and automatic object positioning via components like pop-up and pull-down menus, buttons, scrollbars, all of which are included as predefined classes. All of the rich and varied functionality of ET++ is inherited by MET++ applications. The MET++ extensions to ET++ include 3-D graphics routines realized with PEX, GL, and OpenGL adapters. This framework provides objects for camera, light sources, material definitions, primitive 3-D objects, polygons, and more, with 2-D and 3-D graphics integrated so they can be mixed in the same view. Building block classes for audio and music include intensity, pitch, tonalsystem, pitchscale, and more. Time synchronization is realized via temporal grouping elements such as loop, repeat, sequence, and synchronize. Import and exchange converters for many file formats are included, as is a hypertext/hypermedia link mechanism. Both ET++ and MET++ are C++ class libraries that can be compiled with almost any AT&T-based C++ compiler or with GCC/C++. Although the ET++ library is highly portable among UNIX/X11 platforms, some of the advanced multimedia features of MET++ limit its portability to a subset of the platforms amenable to ET++. Documentation includes man pages and related papers, although I don't think that anything in the way of a tutorial exists as yet.
[http://www.ifi.unizh.ch/groups/mml/ \ projects/met++/met++.html]
Qt An object-oriented framework for developing GUI applications, Qt consists of a rich C++ library (around 100 classes) and a meta- object system that extends C++ with new concepts called signals and slots, which define clean and natural object interfaces for creating independent objects. Qt is based on Xlib and supports such advanced features as drawing transformed graphics, including drawing rotated text and pixmaps. It is in beta form at present and a free version for Linux/X Windows platforms is available. Documentation thus far is all online at the Qt web site http://www.troll.no/.
[ftp://ftp.nvg.unit.no/pub/linux/qt/]
STk Stk is a Scheme interpreter that can access the Tk graphical user interface part of the Tcl/Tk toolkit, i.e., Tk with Tcl replaced by Scheme. STk also provides an efficient CLOS-like object-oriented system called STklos, which provides multiple inheritance, generic functions, and multi-methods. This implementation was developed due to perceived limitations in Tcl, the details of which can be found at the Tcl/Tk home site. STk runs on a variety of machines and systems, including Sun SPARC, DEC 5000 Ultrix and Alpha, SGI IRIX, IBM RS6000, HP 9000/735, Linux, and others. Porting it to other UNIX platforms is probably reasonably straightforward. Documentation consists of a users' manual and several papers.
[ftp://kaolin.unice.fr/html \ /STk.html]
Tcl/Tk Tcl, the tool command language, is an embeddable scripting language, and Tk is a graphical user interface toolkit based on Tcl. Tk was designed for use with the X Window system (although ports to other window systems are purportedly available or will be) and provides a set of Tcl commands to create and manipulate widgets. Widget types include the standards such as buttons, scrollbars, menus, and text windows, as well as a general purpose drawing widget called a canvas that lets you create lighter weight items like lines, boxes, and bitmaps. Tk supports the X Window system hierarchy of windows, and widgets are under the control of a geometry manager that specifies their size and location on the screen. Tcl/Tk has been ported to most (if not all) UNIX/X11 platforms and should readily install via the configure and make files included in the distribution. There are also a myriad of third-party Tcl/Tk extensions and applications available, (e.g., a programming environment for building graphical user interfaces with Tcl/Tk called XF).
[http://www.sunlabs.com:80/research/tcl/]
VXP The Visual X Windows Programming interface is an environment in which to develop X Window programs interactively. The visual programming process begins with the design of the application interface, where the components (e.g., widgets) are instantiated. Next, the properties of these components are set, and the code necessary to handle the actions for certain events is written by the developer (in C). Finally, the application is built by the system, which automatically generates the remainder of the C code for the application. The programmer can also compile, execute, and debug the application from within the system. The goal of the project is to eventually support all Xt-derived widget sets, including OSF/Motif, OpenLook, MIT Athena, etc., but the present version supports only the first-named set. Thus far, only binary distributions are available for HP, SGI, DEC OSF, SUN OS5/4, IBM RS600 and AIX, NetBSD, SCO, Linux, UnixWare, BSD, and FreeBSD systems. Online and hardcopy version of a user's manual and a tutorial are available.
[http://www.shsu.edu/~stdyxc05/VXP/]
Wafe The Widget [Athena] Front End is a package that implements a symbolic, string-based interface to the X toolkit, the Athena Widget set (or the 3-D version, Xaw3d), the OSF/Motif Widget set, and various complementary widget classes and extension packages. You can develop applications with high-level graphical user interfaces in Tcl using Wafe, or you can use it mostly as a graphical front-end that provides easy access to GUI programming for various programming languages. The components of Wafe are Tcl, Xt, widget sets, and extensions. The extensions include the Xpm library, a drag-and-drop library, additional converters, etc. As a graphical front-end, Wafe has been used with Perl, GAWK, Prolog, Tcl, C, and Ada, and there are implementations for embedding it (to create a bidirectional interface) in Perl and Python. The source code for Wafe is available along with binaries for AIX, ULTRIX, HP, Alpha, and Linux systems. These can be obtained along with some rudimentary documentation at the Wafe ftp site, ftp://ftp.wu- wien.ac.at/pub/src/X11/wafe/.
[http://www.wu-wien.ac.at/wafe/wafe.html]
WCL The Widget Creation Library (with Motif and Athena resource interpreters) is a system for developing applications using Motif and Athena widgets. It features rapid prototyping, a blending of the prototyping, development, and delivery environments, minimum specifications to describe an interface, extensibility, widget set independence, and more. This is intended to be a very small library for programmers developing applications using the various widget sets based on the Xt intrinsics. The distribution contains the source code (written in C), documentation, and demos.
[ftp://ftp.wu-wien.ac.at/pub/src/X11/]
WINTERP WINTERP is an interactive object-oriented user interface language for rapid prototyping, development, and delivery of extensible applications with Motif GUIs and Xtango graphics animation (http://www.cc.gatech.edu/gvu/softviz/algoanim/xtango.html). It uses a small, fast, object-oriented mini-Lisp interpreter based on XLISP-PLUS and has an object-oriented interface to the OSF/Motif widget class hierarchy. It also includes a combination of high-level object and functional interfaces to the Xtoolkit, Xlib, and underlying UNIX system libraries. The latest version features a 2.5D graphics and animation widget based on the Xtango graphics/animation package, which simplifies much of the drudgery involved in creating 2.5D graphics interfaces and enables simple game-style animation, employing multiple layers of arbitrarily shaped objects. The source code is available at the WINTERP ftp site, ftp://ftp.eit.com/pub/winterp/, and should compile and install on generic UNIX/X11 systems with the OSF/Motif library. Various types of documentation are available at the Web site.
[http://www.eit.com/software/winterp/]
wxWindows wxWindows is a toolkit for platform-independent GUI programming in C++. It consists of several class libraries and tools, and its uses include development of applications for delivery on several platforms and single-platform development, e.g., a high-level wrapper around XView, Motif, or Windows. It was designed with portability and simplicity of programming as the primary goals, with some trade-offs in the area of completeness (for example, the interfaces may not be as polished as some). It is currently an active project, and the developers encourage suggestions and extensions from the users. The features include wxBuilder, a Windows and Motif-hosted GUI builder for creating simple interfaces interactively and generating C++ code; a simple-to-use and object-oriented API; graphics calls including splines and polylines; toolbar classes; support for menu bars and status lines; a programmatic form facility for building form-like screens quickly; object-oriented interprocess communications (DDE subset) under UNIX and Windows 3.1; encapsulated PostScript generation under UNIX; a TeX2RTF utility for maintaining online and printed manuals, all source, and much more. wxWindows will install on generic UNIX platforms with Xview 3.x or Motif 1.2.x and any one of several C++ compilers, including GCC/G++, and has been installed on Linux platforms. It can also be installed on PC platforms using most of the C++ compilers available. Compilation and installation instructions and hints are available at the site for platforms for which binaries aren't supplied. A reference manual is available in several forms, including PostScript.
[http://www.aiai.ed.ac.uk/~jacs/wxwin.html]
XF An integrated programming environment that supports the development of graphical user interfaces with the Tcl/Tk toolkit (http://www.smli.com/research/tcl/), a shell-like interpreted command language (Tcl), and a Motif-like widget set (Tk). The design aims for XF are rapid construction of interactive user interfaces, immediate access to the resulting interface, high flexibility for later changes, support for group development, and support for standard interfaces. To implement a complete application, the user must have some reasonable facility with programing in Tcl. XF should readily install on any UNIX/X11 platform on which Tcl/Tk has already been installed, and since the latter has been ported to nearly every platform in existence, this shouldn't be too much of a problem. A 120+-page combination tutorial and users' manual is available in PostScript format.
[ftp://ftp.aud.alcatel.com/tcl/code/]
XForms A GUI toolkit based on Xlib for X Window systems, XForms features a rich set of objects (e.g., buttons, sliders, menus, etc.) integrated into an easy and efficient object/event callback execution model that allows fast and easy construction of X applications. The library is extensible and new objects can be easily created and added. It comes with fdesign, a GUI builder that allows a user to create XForms-based interfaces by directly manipulating and composing graphical objects supported by the system. Once the interface is created, XForms can generate C code that, when compiled and executed, implements exactly the same interface as was designed. It is available in binary format for Linux, Sun, SGI, DEC Alpha, HP, IBM RS6000, FreeBSD, NetBSD, BSDi, unixware, Solaris, SCO, DEC Ultrix, Cray, and Convex systems. A 200+-page tutorial and reference manual is also available.
[http://bragg.phys.uwm.edu/xforms]
XIT The X User Interface Toolkit is an object-oriented user interface development environment for the X Window system based on Common Lisp, CLOS, CLX, and CLUE. It is a framework for Common Lisp/CLOS applications with GUIs for the X Window system. It contains user interface toolkits, including general building blocks and mechanisms for building arbitrary user interface elements and a set of predefined common elements (widgets), as well as high-level interactive tools for constructing, inspecting, and modifying user interfaces by means of direct manipulation. The system is stable although still under active development. An incomplete XIT manual in PostScript is available, as is the source code. It is known to run on the freely available Common Lisp implementation CLISP as well as on Allegro CL, a commercial implementation.
[ftp://ftp.informatik.uni-stuttgart.de/pub/xit/]
XPIP XPIP is a tool that allows the quick construction of user interfaces (GUIs) in an X Window environment. It takes the form of a series of user-definable widgets that are employed for varying parameters, control flow, input/output, and other alterable processes. It is not as comprehensive as other packages, but provides a balance between ease of use and sophistication that makes it appealing to the more casual programmer. It consists of an unalterable library of routines combined with a single user-modified buffer file that provides the system with access to application-specific routines. Each XPIP application is divided into a series of panels, each of which contains a set of widgets. Any number of panels may appear on screen at a given time, and the widgets in each are defined in separate configuration files that are read at run-time. Widget types include base, plate, button, slider, dial, arrow, scrollbar, label, data, view, slipper, and lists, the characteristics of which can be customized or left at the default values. The source code is available and should install in environments with an ANSI C compiler and a color system running X Windows (R4 or higher). A 40+-page PostScript user's manual is also included in the package, which can be downloaded from the XPIP ftp site, ftp://cns-ftp.bu.edu/pub/xpip/.
[http://cns-web.bu.edu/pub/xpip/html/xpip.html]
xtpanel xtpanel is a tool to build a visual program interface using a simple scripting language or from the command line. It provides a quick and easy way of producing a panel containing interactive objects such as buttons, sliders, and text fields. Objects can print, run system commands, or modify other panel objects. The result is an interactive X Window program using a scripting language that is easier to learn and use than conventional X programming. Xtpanel uses the X toolkit and the MIT Athena widget set. Documentation is via a man page and an online interactive tutorial. The source code is available and should install on generic UNIX/X Windows platforms.
[ftp://sepftp.stanford.edu/pub/Xtpanel/]
About the Author
S. Baum is presently attending graduate school at Texas A&M University. He's been fooling around with computers for years, but realized the one true way only after he obtained a Linux box about a year ago. Now he sits transfixed for countless hours programming and cruising the web for nifty software. He can be reached at baum@astra.tamu.edu.
|