graph
sys
tool
lib
analyze
format
symb
GUI
|
|
Note: This should be considered a historical document that summarizes
what was available in 1996. I have no plans for updating this as I have
the other graph-related sections (Mar. 24, 2004).
Packages that assist one in developing interfaces, graphical
and otherwise, to programs and other beasties.
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 the packages
described below. They can turn a command-line driven program
into a magnificent point-and-click experience faster than you
can say "Jack Robinson".
As you might expect by now, this is oriented towards those
packages that will run on generic UNIX platforms, especially
Linux.
This web page and the contents therein can be freely
reproduced for educational purposes as long as the author
is credited and information about how to access the original
is offered. A version of this page appears in the
April 1996 issue of SysAdmin. The current
online version contains several more listings as well as
some description revisions or expansions.
A longer and less-detailed list of such things (including
commercial offerings) is the
User Interface Software Tools list of Brad Myers. Another
good resource is the WWW Virtual Library section on
Visual Languages and Visual Programming.
All of these programs are freely available
for non-commercial uses, but you'll have
to find and read the usage conditions for each package to see
if other uses are possible. Enjoy.
All links checked and live as of May 22, 1996.
Peruse the following list to jump to a specific package or
browse the lot from the start.
- 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. At present
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 which 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, a high-level
object-oriented output graphics model that handles automatic refresh
of objects when they change, a high-level input model that makes it
easy to add behaviors to objects and supports undo and help for
operations, 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]
- C++ Visual
Objects is a
toolkit for the building of 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
or features include an object oriented design, executables
typically 2 to 4 times smaller than those compiled
using other tookits, less code to write per application,
a smaller and more consistent set of interfaces,
and applications that are (due to the above reasons)
inherently more maintainable. Another major feature of Cvo
is that it takes advantage of the internationalization features
inherent in X11R5 and later releases.
A rich set of visual objects is
provided, including the standard things 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 may be easily constructed
using existing objects as bulding blocks due to the object oriented
nature of the toolkit. Cvo also attempts to consolidate similar
concepts within a single method, e.g. "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, due to various reasons unrelated to its
utility, 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 will build
using GCC/G++, making it amenable for compilation and use on Linux
platforms.
[ftp://ftp.x.org/contrib/libraries/]
[ftp.krystal.com/pub/]
- 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, i.e. 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, and 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 (Xaw), the standard set for the
Xt Toolkit, and the UKC
Widget Set, a smaller set of widgets that were mainly
created 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 additoin of new widget classes is
a straightforward procedure.
This should compile
on generic UNIX/X Windows 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/]
- A tool to generate and evaluate windows in shell scripts.
This allows the easy conversion of the dialog portions of
existing scripts 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 that are 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/]
- An object-oriented application programming interface (API)
system for the development
of window-based applications that 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 where
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 distributed object model and provides a standardized,
high-level notation called IDL for object definition. There is
also support for
Tcl/Tk-based
scripting, multi-threading, resolution independence, and
internationalization.
It is currently undergoing a standardization
process via the
X Consortium.
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]
- 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, e.g. Allegro, AKCL, CLISP, etc. The source code
can be obtained at the
Garnet FTP site. A successor to Garnet called
Amulet is currently being developed.
[http://www.cs.cmu.edu/afs/cs.cmu.edu/project/garnet/www/garnet-home.html]
- 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
plus 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, e.g. those that use
template classes.
[ftp://ftp.gmd.de/gmd/ginaplus/]
- 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
groupwave 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 hyper node
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]
- A graphical user interface library for scientific and
engineering applications. It provides for multiple views in
a single window with independent world and pixel coordinate
systems via more than 500 callable functions. Hv performs all
needed coordinate transformations and window maintenance as
well as providing applications with the ability to save their
views as PostScript of Encapsulated PostScript files.
Hv is
not an interface builder but rather a library whose use results
in applications with a unique appearance and feature set.
It is also not primarily intended to be a data visualization package
since it is mostly used to display and interact with representations
of physical objects (experimental rigs, geographic locations, etc.)
rather than complex data sets, although it can create simple
scientific graphs such as of the results of a simulation.
Important features include the maintenance of a floating point
world coordinate system to accomodate the real dimensions of
what is being represented (e.g. a detector array in a nuclear
physics laboratory), the capability of getting instant feedback
about the attributes of an item by moving the pointer over that
item, and a mechanism for registering multiple simulations, i.e.
one application can have many simulations running simultaneously
with each being updated at a different, controllable rate.
Hv requires a UNIX/X Windows platform with the Motif
library (version 1.1 or greater) and a color monitor that
supports 256 colors or gray scales. The source code is available
and is written in ANSI C. It has been tested on several
platforms including DEC (Ultrix and OSF), Sun, SGI, IBM,
HP and Linux. A brief overview of Hv and a 138 page programming
manual are available in PostScript format. The distribution
comes with several example applications, including a scientific
graphics application called
hvplot.
[http://www.cebaf.gov/~heddle/Hv]
- An X/Motif interactive graphical user interface builder.
With it you can build a GUI made of GUI widgets instantiated
by clicking on icions, move and resize them with the mouse,
edit their resources, and move about in the widget hierarchy
via the arrow keys. Once the GUI is built the C source files,
an X resource file, and a Makefile are automatically produced.
This is available only for Linux systems.
[http://www.umn.edu/nlhome/g257/parki005/lxb/lxb.html]
- An object-oriented application framework that supports the
development of multimedia applications by providing reusable objects
for 2D graphics, user interface components, 3D 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, scroll-bars
and more included as predefined classes. All of the rich and varied
functionality of ET++ is inherited by MET++ applications.
The MET++ extensions to ET++ include 3D graphics routines realized
with PEX, GL and OpenGL adapters. This framework provides objects
for camera, light sources, material definitions, primitive 3D objects,
polygons, and more, with 2D and 3D 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 amongst 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]
- The Morello Graphic
User Interface
is a cross-platform graphical user interface written in ANSI C.
It consists of a library and a code generation tool. The
library contains the usual collection of GUI objects, e.g.
menus, push buttons, editable fields, list, etc., and the
MGUI Designer tool allows the user to create and maintain
window layouts using the mouse. It can be used to develop
multi-platform applications that do not require GUI porting
across Windows 3.1, Windows 95, X Windows, and DOS BGI and
DJGPP, thus decoupling the application code and the host system
API.
The features include
total source level compatibility among all supported platforms,
the same look and feel in all environments, compact source
code, a manager object that automatically positions and
resizes its children, a designing tool that generates C source
code files that can be compiled in all supported environments,
support for 16, 256, 32K and 64K colors under DOS BGI and up
to 16 million in the other environments, text cut and paste
capabilities, various drawing primitives (e.g. rectangles,
circles, polylines, etc.), image drawing in up to 24 planes,
and a log facility with a run-time user modifiable tracing
level.
MGUI is available for several programming environments, including
Linux with X11. The freely available package includes the MGUI
library, the MGUI designer, documentation, examples and MEdit
source code.
[http://www.volftp.vol.it/IT/IT/ITALIANI/MORELLO/index_e.htm]
- A GUI development engine that incorporates the portable GUI
class library of
wxWindows as well as an extended
Scheme implementation called
MzScheme. It also
includes extensions to the wxWindows C++ classes called
wxMedia that support high-level editor and pasteboard objects.
This package is appropriate for developing any scheme-based
application which needs a graphical interface, especially
one that needs to be portable or needs sophisticated
text or graphics manipulation.
This differs from the similar STk
Scheme/GUI package in that it is more suitable for large-scale
application development, the Scheme implementation is directly
connected to the GUI toolbox, it is more portable, its object
scheme is minimalist, the Scheme interpreter provides
pre-emptive threads, it doesn't have the large set process
and socket facilities of STK (although it does provide the
interprocess communication tools from wxWindows), and it
provides a powerful editor class.
MrEd runs under the X Windows, Windows and Mac windowing systems
(due to the portability of the wxWindows package), and applications
developed are completely portable among these platforms.
The source code is available along with binaries for
Sun, SGI, IBM RS6000, Linux, FreeBSD, Windows 32, NT, and 95, and
Mac PowerPC and 68K platforms. The documentation includes a user
manual for MrEd as well as manuals for the various components
thereof in several different printable formats.
[http://www.cs.rice.edu/CS/PLT/packages/mred/index.html]
- A Perl module that weds the
Tk widget set to Perl 5, i.e. an interpreted
scripting language for making widgets and programs with
graphical user interfaces. The perl/Tk code is a rewrite of
the Tk code that allows easier external linking and calling,
especially by Perl. It is planned to eventually be a "portable Tk"
package which will be a library usable from Tcl, LISP, C++, python,
and other languages besides Perl.
[http://w4.lns.cornell.edu/~pvhp/ptk/ptkFAQ.html]
- An object-oriented framework for developing GUI applications.
It 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
advanced features such as drawing transformed graphics, including
drawing rotated text and pixmaps. A freely available version of
the source code is available as well as a binary for Linux
systems at the
Qt ftp site
Documentation is available in both hypertext and PostScript
format.
[http://www.troll.no/qt.html]
- A set of tools designed for the creation of interactive
applications under Unix, X and Motif. It consists of an editor,
an interpreter/compiler, a driver and an object oriented language.
The editor makes it easy to define the visual appearance of an
application, with all the tasks associated with specifying an
interface (e.g. designing input forms and dialog boxes, selecting
fonts, etc.) quick and simple. The driver is supplied with over
20 pre-defined classes including some high-level classes like
menus, and it can also handle user-defined classes. The language
is complete, typed, structured, event driven and object oriented.
Additional features include the possibility of modular application
design, manual code generation with a standard editor or automatic
code generation using an interactive editor, version management
under SCCS, code maintainability and rapid modification,
pre-compilation for fast run times and source protection,
use of C-like syntax, and integration of user defined C functions
using standard calls. A Linux version is freely available and
comes with 110+ page manual in PostScript format.
[ftp://ftp.cc.gatech.edu/pub/linux/X11/devel/]
- A Scheme interpreter which 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 command language, 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.
[http://kaolin.unice.fr/]
- A tool for scientists and programmers to use to integrate
common interface languages such as
Tcl/Tk,
Perl,
Python and
Guile with programs
containing collections of functions written in C or C++.
SWIG automates the process of writing highly specialized
wrapper codes for each language and makes it easy to extend
an interface language without having to worry about the
nasty details. SWIG was developed to provide a system
that would make it easy to put together interesting applications
involving numerical simulation, data analysis, and visualization
without having to worry about tedious systems programming or
making substantial modifications to existing code.
Applications of SWIG include simplified user interface
programming, extremely rapid prototyping, improving debugging
and testing, better performance (i.e. functions can be
written in C instead of Tcl, Perl, etc.), and development
of language independent applications. SWIG is used by
first creating an interface file containing C style
declarations of functions, variables and constants that
you want to build into a user interface. Next a parser
takes this file and converts it into an internal representation,
which is passed to a code generation module which produces C
code and a documentation module supporting ACII,
LaTeX, and HTML. Each
module is implemented as a collection of C++ classes which simplifies
the process of supporting new languages and allows the user
to expand the system.
The SWIG source code is available and can be compiled and
installed on generic UNIX boxes with an ANSI C compiler,
e.g. GCC. The documentation is contained within a 50+ page
users guide available in PostScript and ASCII formats.
[http://www.cs.utah.edu/~beazley/SWIG/]
- A data propagation formula manager for
Tcl/Tk. This software allows Tcl programmers
to define formulas among variables using a declarative style of
programming wherein the formulas are maintained by the system
so the variables are always consistent. This style is particularly
useful for building user interfaces, i.e. applications can be
defined around a small set of state variables and information
on the display (e.g. when a button should be active or what
text a label or button should display) can be maintained
locally in formulas. This comes with an example program in
the form of a video poker application called TkVP.
[http://www.cs.umn.edu/Research/GIMME/]
- 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 standard types like 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 controls 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 and an extended set of useful
widgets called Tix.
The latter provides some very nice new widgets including
file folders.
There are quite a few who like the Tk portion of this package
but not the Tcl part, and as such have developed other interfaces
to the Tk widget set. These packages include
perl/Tk and
STk as well as the built-in capability
of using Tk widgets in the
Python language.
[http://www.sunlabs.com:80/research/tcl/]
- A portable C++ GUI framework intended for the development
of a wide variety of applications on different platforms.
Applications developed using V will have the look and feel
of the native platform yet still be portable across platforms.
At the time of writing (2/96) V supports X Windows using the
Athena (Xaw) widgets and Windows 3.1, although versions for Motif,
Windows 95 and OX/2 are being developed.
Most of the standard GUI objects are supported by V, including
windows with menus, status bars, tool bars, a drawing canvas,
modal and modeless dialogs with th emost common controls (e.g.
buttons, lists, labels, text entry, check and radio buttons, etc.),
and portable printing support.
The X version was developed using the GCC/G++ compiler and
has been tested on Linux, SunOS, and SGI machines, while the
Windows version has been tested on both Windows 3.1 and 95.
A 150 page indexed manual is included in both LaTeX and
PostScript formats.
[http://www.cs.unm.edu/~wampler/vgui/vgui.html]
- The Visual X Windows
Programming Programming interface is an environment
in which to develop X Windows 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, e.g. OSF/Motif, OpenLook, MIT Athena (Xaw),
etc., although the present version only supports 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/]
- The Widget [Athena]
Front End is
a Tck/Tk interface to the X Toolkit
or a graphical front-end for applications in various programming
languages. It can be used as a standalone prototyping
environment for X Toolkit applications (interactive or
via scripts) or as a front-end to applications programs
in various programming languages to provide a graphical user
interface without having the write X Window and X Toolkit
bindings for those languages.
Wafe is based on the standard X11
Xt Intrinsics and can
be used with any Xt-based widget set, e.g. Athena (Xaw), Xpm,
Motif, Plotter, XmGraph, etc. It uses the Tcl embeddable
command language as a host language and extends Tcl's basic
capabilities with additional X Toolkit and widget specific
commands. Wafe has been used as a front-end for programs
written in Perl, gawk, Prolog, Tcl, C and Ada and several
demo programs are distributed with the sources. These
include xwafedesign, an interactive design program for
Wafe applications; xwafeftp, an FTP front-end; xbm, a
bitmap and pixmap viewer; etc.
The source code to Wafe is
available along with binaries for AIX, ULTRIX, HP, Alpha, and
Linux systems. These can be obtained at the
Wafe FTP site. The documentation is found in a
70+ page manual in PostScript format. The source for
some of the widget sets that Wafe can use is also
available in the same directory.
[http://www.wu-wien.ac.at/wafe/wafe.html]
- 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 ve 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/]
- An interactive object-oriented user interface language for
rapid prototyping, development and delivery of extensible
applications with Motif GUIs and
Xtango graphics/animation.
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, and a combination of high-level
object and functional interfaces to
Xt,
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 and
should compile and install on generic UNIX/X11 systems with
the OSF/Motif library. Various kinds of documentation are
available at the Web site.
[http://www.eit.com/software/winterp/]
- 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, i.e.
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 fast, 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.
It will install on generic UNIX platforms with
Xview 3.x or Motif 1.2.x and 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]
- An integrated programming environment that supports the development
of graphical user interfaces with the
Tcl/Tk toolkit, 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.neosoft.com/pub/tcl/alcatel/code/]
- A library and program that allow you to build interaction forms
with buttons, sliders and many other widgets in a simple way.
The library consists of a large number of C routines that are used
to build forms with the available widgets. These routines can be
used in both C and C++ programs.
The design goals for XForms were to create a package that is
intuitive, easy to use, powerful, aesthetically pleasing, and
easily extensible.
The basic idea behind XForms is that of a form, i.e. a window on
which different objects or widgets are placed.
A form can be defined with relatively few lines of code, and
several commonly used forms (e.g. choosing a file) have special
routines that allow them to be defined in a single line of code.
User interaction with the application forms created is fully
handled by the library routines, and that interaction can take
place in a number of different ways. The widget classes available
include buttons, sliders, input fields, menus, browsers, etc., and
adding new classes is a straightforward task detailed in the manual.
To make things even easier a Forms Designer is included with the
package. This program lets you interactively design forms and
generate the corresponding C code. Objects can be chosen and
placed and attributes changed using just a mouse.
The distribution includes the library, the GUI builder, and source code
for over 50 demonstration programs.
It is available only in
binary form 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
in PostScript format is avaiable separately.
[http://bragg.phys.uwm.edu/xforms]
- 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, and 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. A partly 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/]
- A tool which allows the quick construction of user
interfaces (GUIs) in an X Windows environment. It takes the
form of a series of user-definable widgets, e.g. buttons, sliders,
dials, etc., 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 which 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 which are read at run-time. Widget types
include base, plate, button, slider, dial, arrow, scrollbar,
label, data, view, slipper, and list types, the characteristics
of which can all 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.
[http://lightlink.com/lesher/xpip.html]
- A tool to build an visual program interface using a simple
scripting language or from the command line. Xtpanel 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/]
- A system for creating X applications, i.e. graphical
user interfaces, in a visual development environment. It
supports the Athena 3D and standard widget sets (as well as
the Xt and
Xlib libraries) and allows
the visual positioning and planning of an application. It
also allows the incorporation of separately written C++
code segments which can be compiled with the visual components
as a single application. Xvisual is a combination of a
a support library (libxv) and the Xvisual Interface
Builder (XIB).
The widgets or objects currently available in XIB include labels,
buttons, menu bars, pulldown menus, bitmaps, file and directory
list boxes, general purpose list boxes, background timers,
scrollbars, panners, and toggle switches. Libxv includes
many other features not directly supported by the interface
builder but can be incorporated within an application.
Xvisual was designed and built on a Linux system with
X Windows and the Athena Xaw3D widget set and as such
should readily compile on other Linux boxes. Given the
generic nature of the components, I'd assume that it wouldn't
be a Herculean task to port it to other platforms. Documentation
is available in either HTML or PostScript format. This is still
in beta stage as of 5/96.
[ftp://ftp.cc.gatech.edu/pub/linux/X11/devel/builders/]
- Yet Another
Class Library is a C++
class library that offers high-level abstractions for common
programming problems. Its class protocols are designed to
be application centered and making programming with them
easier, make good use of inherent C++ features, and provide
adequate hooks for easy extensibility. The class protocols
are platform independent so porting them is only a matter of
recompiling on a new platform.
YACL includes two kinds of core classes (data types and container
classes) as well as data storage and graphical user interface
classes. The GUI library features portable abstractions for
building GUIs based on the MVC (model view controller) paradigm,
use of the native API for the given platform's look and feel,
GUI objects well integrated with the base libraries, standard
objects or widgets (e.g. menus, dialogs, buttons, etc.), graphic
resource objects (e.g. cursors, fonts, pens, colors, etc.),
graphic objects (e.g. bitmaps, ellipses, 3-D graphics, etc.),
easy composition of basic objects, high reusability, and
many demo programs.
YACL will compile and run on Windows 3.1 and NT, IBM OS/2,
SGI IRIX, Sun Solaris, and several other UNIX platforms with
X Windows and Motif using GNU C++ 2.6.1 or later. The latter
platforms include Linux boxes. The documentation is the
expensive part of this freely available class library. It is
contained in the book Building Portable C++ Applications
with YACL by M. A. Sridhar, the author of the package.
[http://www.cs.sc.edu/~sridhar/yacl.html]
|
|
|