Motif/Lesstif Application Development

A Motif development license can be had from Red Hat software
(http://www.redhat.com/)
or the Open Group
(http://www.opengroup.org/desktop/motif/).
If you have to pay for the development license, I strongly
recommend you use Lesstif and find a commercial workstation with a
Motif run-time license already installed. Odds are, you can tweak
any errant code without needing to purchase Motif. If you have a
spare machine on which to install Solaris for the Intel platform,
Sun now makes Solaris available for non-commercial use for the cost
of the media (about $10 US); this includes a run-time license for
Motif and the headers needed for development. It is fairly easy to
do your development on Linux/Lesstif, then make a quick build under
Solaris/Motif to check compatibility.

Remember, though, Lesstif is an implementation of Motif
version 1.2 with limited support for Motif 2.0, while the
commercial implementation of Motif 2.1 has already been released.
The good news is the vast majority of systems are still using Motif
1.2.

Lesstif can be downloaded from a number of places, beginning
with
http://www.hungryprogrammers.org/.
Binaries are available for Linux (and some other UNIX flavors) as
RPMs or gzipped tar files from the site and its mirrors. Installing
Lesstif on my Red Hat-based workstation was as simple as
typing:

rpm -i lesstif.rpm

You don't need the development RPM unless you plan on
contributing to the Lesstif project.

For most commercial UNIX systems, the developer will not need
to do anything extra to start developing using Motif; for example,
Sun ships the Motif headers and libraries with Solaris. If you
choose a commercial Motif license for Linux, you will need to
follow the steps outlined in the package. Getting things rolling on
Slackware or some other non-RPM-based system is rather trivial. The
libXm files should end up in the /usr/X11R6/lib directory (or
/usr/dt/lib on Solaris), and the headers should be placed in their
own directory (named /Xm) off the /X11 include directory, e.g.,
/usr/X11R6/include/Xm or /usr/dt/include/Xm.

X Components

Figure 1. Accessing X with Motif

Access to the X Window System in a Motif application is
accomplished primarily through three libraries: the X library
(commonly referred to as Xlib) which provides the most primitive
interface, the X Toolkit (Xt) upon which Motif is built and Motif
(see Figure 1). A book covering Xt, or at least the Motif
Programming Manual, would be a good investment if you
become serious about GUI development. Many libraries choose to
build on Xt rather than X, so it is reasonable to expect X and Xt
to be consistent across UNIX flavors and available on any end-user
configuration.

The X library functions are typically prefixed with “X”,
and the X toolkit widgets and functions are prefixed with “Xt”.
Although the toolkit is used fairly heavily within a Motif
application, the need to access X library routines is rare. Symbols
provided by Motif (functions, constants and variables) are prefixed
with “Xm”.

The X server via the window manager is responsible for
interacting with the video hardware and dispatching messages and
events to the applications. It is important to note applications
running under X are implemented using an event-driven paradigm. The
programs generally spend their time waiting to receive messages
that indicate such events as mouse movement, key presses, or
exposed windows—more on this later.

Graphic Primitives

The graphic components used to build an X/Motif application
are called widgets. Some simple widgets are a push button, a radio
button and a text field; more-involved widgets might be a file
selection dialog or an HTML widget. Many graphic components are
composites of widgets coupled within a routine or C++ class. You
could spend your career developing GUIs without ever learning how
to create a custom widget. It is best to avoid writing custom
widgets until you are very comfortable with the X/Motif
environment; even then, you should have good reasons for not using
more conventional techniques. The Motif widget libraries have been
implemented in a very object-oriented fashion (especially for
something written entirely in C). If this sort of thing interests
you, I strongly encourage a study of the widget libraries (refer to
the Lesstif source). Many widgets are available that implement
functionality not addressed by the Motif library.

A number of generic routines can be used to create and alter
instances of widgets (e.g., XtCreateManagedWidget); in addition,
widgets typically make some specific routines available (e.g.,
XmCreateScrolledText). The run-time behavior of a widget is
controlled through resources; that is, variables specific to a
single instance of the widget which determine aspects of its
behavior such as position, color, button labels, etc.