This Chapter introduces the basic concepts and principles that are of concern
to the Motif programmer. We define basic system concepts, describe the three
basic levels of the X programming model and describe basic Motif components.

X is network oriented and applications need not be running on the same
system as the one supporting the display. This can sometimes be quite
complicated for a system such as X to manage and so the concept of clients
and servers was introduced.

You need not worry too much about the practicality of this, as
normally X makes this transparent to the user -- especially if we run
programs on a single workstation. However, in order to fully understand the
workings of X, some notion of these concepts is required.

The program that controls each display is known as the
server. This terminology may seem a little odd as we may be used
to the server as something across the network such as a file server. Here,
the server is a local program that controls our
display. Also our display may be
available to other systems across the network. In this case our system does act
as a true display server.

The server acts as a go-between between user programs, called
clients or applications and the resources of the local system. These
run on either local or remote systems.

Tasks the server performs include:

allowing access by multiple clients,

interpreting network messages from clients,

two-dimensional graphics display,

maintain local resources such as windows, cursors, fonts and graphics.

The client and server are connected by a communication path called (
surprise, surprise) the connector. This is performed by a low-level C language interface known
as Xlib. Xlib is the lowest level of the X system
software hierarchy or architecture (Fig 3.1). Many applications can be
written using Xlib alone. However, in general, it will be difficult and time
consuming to write complex GUI programs only in Xlib. Many higher level
subroutine libraries, called toolkits, have been developed to remedy this problem.

Note: X is not restricted to a single language, operating system or user
interface. It is relatively straightforward to link calls to X from most
programming languages. An X application must only be able to generate and receive
messages in a special form, called X protocol messages. However, the
protocol messages are easily accessible as C libraries in Xlib (and others).

There are usually two levels of toolkits above Xlib

X Toolkit (Xt) Intrinsics are parts of the
toolkit that allow programmers to build new widgets.

Third Party Toolkits -- such a Motif.

An application program in X will usually consist of two parts.
The graphical user interface written in one or more of Xlib, Xt
or Motif and the algorithmic or functional part of
the application where the input from the interface and other
processing tasks are defined. Fig. 3.1 illustrates the relationships
between the application program and the various parts of the X System.

Fig. 3.1 The X Programming Model
The main concern of this text is to introduce concepts in building the
graphical user interface in X and Motif in particular. We now briefly describe
the main tasks of the three levels of the X programming model before embarking on
writing Motif programs.

The main task of Xlib is to translate C data structures and procedures into the
special form of X protocol messages which are then sent off. Obviously
the converse of receiving messages and converting them to C structures is
performed as well. Xlib handles the interface between client (application) and
the network.

Toolkits implement a set of user interface features
or application environments such as menus, buttons or scroll bars (referred to as
widgets).

They allow applications to manipulate these features using object-oriented
techniques.

X Toolkit Intrinsics or Xt Intrinsics are a
toolkit that allow programmers to create and use new widgets.

If we use widgets properly, it will simplify the X programming process and also
help preserve the look and feel of the
application which should make it easier to use.

We will have to call some Xt functions when writing Motif programs
since Motif is built upon Xt and thus needs to use Xt. However, we do notneed to
fully understand the workings of Xt as Motif takes care of most things for us.

X allows extensions to the Xt Intrinsics
toolkit. Many software houses have developed custom features that make the GUI's
appearance attractive, easy to use and easy to develop. Motif is one such
toolkit.

The third party toolkits usually supply a special client called the window
manager

The basic unit of currency of Motif is the
widget. The widget is the basic building block for the GUI. It is
common and beneficial for most GUIs assembled in Motif to look and behave in a
similar fashion. Motif enforces many of these features by providing default
actions for each widget. Motif also prescribes certain other actions that
should, whenever possible, be adhered to. Information regarding Motif GUI design
is provided in the Motif Style Guide. We now briefly address general issues relating to
Motif widgets and style.

A widget, in Motif, may be regarded as a general abstraction for
user-interface components. Motif provides widgets for almost every common GUI
component, including buttons, menus and scroll bars. Motif also provides widgets
whose only function is to control the layout of other widgets -- thus enabling
fairly advanced GUIs to be easily designed and assembled.

A widget is designed to operate independently of the application except
through well defined interactions, called callback
functions. This takes
a lot of mundane GUI control and maintenance away from the application
programmer. Widgets know how to redraw and highlight themselves, how to respond
to certain events such as a mouse click etc. Some widgets go further than
this, for example the Text widget is a fully functional text editor that has
built in cut and paste as well as other common text editing facilities.

The general behaviour of each widget is defined as part of the Motif (Xm)
library. In fact Xt defines certain base classes of widgets
which form a common foundation for nearly all Xt based widget sets. Motif
provides a widget set, the Xm library, which defines a complete set of
widget classes for most GUI requirements on top of Xt (Fig 3.1).

The Motif Reference Manual provides definitions on all aspects
of widget behaviour and interaction. Basically, each widget is defined as a C
data structure whose elements define a widget's data attributes, or
resources and pointers to functions, such as callbacks.

Each widget is defined to be of a certain class. All
widgets of that class inherit the same set of resources and callback functions.
Motif also defines a whole hierarchy of widget classes. There are two broad Motif
widget classes that concern us. The Primitive widget class contains actual GUI components, such as
buttons and text widgets. The Manager widget class defines widgets that
hold other widgets.

Chapter 4 introduces basic Motif
widget programming concepts and introduces how
resources and callback functions are set up. Chapter 5
then goes on to fully define each widget class and the Motif widget class
hierarchy. Following Chapters then address each widget class in detail.

The Motif Style Guide should be read by every Motif Application
developer. The Style Guide is not intended to be a Motif programming manual.
This book is not intended to be a complete guide to Motif style. The books
should be regarded as essential companions along with a good Motif reference
source.

The Motif Style Guide provides a set of guidelines that specify a
framework for the behaviour of Motif application developers, GUI developers,
widget developers and window managers. Many standard GUI design and behaviour
issues are integrated into a Motif widget's default settings. Therefore these
defaults should only be modified with great care and consideration.
Other aspects of style are left to the developer. The Motif Style Guide
only suggests certain standard operations, but where appropriate these
should be adopted.

The Motif Style Guide prescribes many common forms of interaction and
interface design. For example, it defines how menus should be constructed, used
and
organised. Chapter 18 summarises all the common style
concerns for the Motif programmer. Where appropriate specific reference is made
in individual Sections to Motif style for a particular widget.