1 Architectural Overview

Conceptual Overview

Data Interaction GUIs

Multiuser Collaboration

Desktop Management

Session Management

Application Management

Object Management

Window Management

Style Management

Motif GUI Engine

Common Desktop Environment Motif Toolkit

Common Desktop Environment Motif Widgets

GUI Shell

GUI Construction

Integration Technologies

Process Execution

Application Messaging

Data Typing

Method Invocation

Conceptual Overview

architecture has many cross-process relationships. The three-process relationship of an X client, a window manager, and the X Window System server seems simple by comparison. The area covered by the Common Desktop Environment is broad, but the layering in the system is not as rigorous as that of

Figure 1-1 Conceptual overview of Common Desktop Environment

• Data interaction graphical user interfaces (GUIs)--Application-level components that are available for user interaction, invocable by other applications. Think of these as programming components at a larger granularity than widgets.

• Multiuser collaboration--Defines and uses application program interfaces (APIs) that enable collaboration between users on the network, particularly in the areas of calendar management, network resource naming, and network file sharing.

• Desktop management--Provides components that negotiate the visual relationships between entities on the desktop. These include the following: Window Manager, Workspace Manager, Session Manager, Application Manager, File Manager, Style Manager, and the Front Panel.

• Motif GUI engine--Includes those components that implement the controls available to the user and includes the Common Desktop Environment Motif toolkit, additional widgets, a GUI shell (Desktop Korn shell), and a GUI construction tool (Application Builder).

• Integration technologies--Represent technologies that do not generate GUIs, but are used as infrastructure by the rest of the desktop. These technologies include process execution control, application messaging (mechanism and protocols), data typing, and method invocation.

Data Interaction GUIs

UNIX command_line interface to applications and the Common Desktop Environment_recommended ToolTalk interface to applications. Actions, as semantic entities, are exposed to the end user through higher levels of software. Both actions and ToolTalk are discussed in more detail in

The desktop contains components that are available through action and ToolTalk APIs. Examples include GUIs to show a view of a directory, submit a print job, view the contents of the Trash Can, edit some text, show help information, compose a calendar appointment, and compose a mail message.

You can also incorporate actions and ToolTalk message support into your application so that the application-specific services they supply are available to the desktop and other applications. Particularly, applications should provide the composition, viewing, editing, and printing services for both proprietary and standard format data. This way, applications that are coded to accept an extensible set of data types automatically gain more capabilities as more media handlers are added to the system. The Common Desktop Environment File Manager, Front Panel, and Mailer attachment GUI are examples of such applications.

Media is used as a generic term for anything that can be presented to the user to convey information. The desktop provides media handlers for appointments, mail messages, mail folders, text, icons, and help data. Vendors have extended the desktop with additional media handlers, including PostScript, many kinds of image file formats, and audio data.

Multiuser Collaboration

An example of building on an existing mechanism is the remote procedure call (RPC) client/service implementation of calendar management. The desktop provides a client-side library and API, RPC protocol, and daemon/service that enables users to share appointment information. (The API is being standardized through X.400 Application Programming Interface Association (XAPIA) to enable a cross-UNIX, PC, and palmtop calendar standard.) The RPC protocol enables a user to browse and directly edit another user's calendar. Access is controlled by a user-specific access control mechanism. Calendars are tied to hosts, and a calendar's data is maintained by a host-specific daemon. The desktop names calendars through a user@host format.

The Common Desktop Environment uses conventional distributed file systems to name files that are sharable on the network. To provide an interface that is independent of the distributed file system, the desktop provides an API to translate host-relative file names into locally expressible file names. Although the desktop is based on the NFS system, it can be ported to run on top of other distributed file systems. Using the desktop file-name mapping API, an opaque file name object can be constructed and passed between desktop clients across the network and resolved in a host-specific way. Also, to simplify the programming task and end user metaphor, Common Desktop Environment applications should present remote file references as local file paths.

One of the fundamentals of building multiuser collaboration applications is the ability to share files. The conventions for naming network files, in conjunction with a ToolTalk file-sharing mechanism called file scoping , enable multiuser collaboration through file sharing. File scoping is more than a mechanism for simple, exclusive access control. Cooperating clients can use file-scope access to negotiate for access to files. For example, an application that has exclusive access to a file could ask whether the user was done with the file when another application wanted to gain exclusive access to the file.

Desktop Management

• A collection of drawers (File Manager views) in which folders (directories) and reports (files) are organized.

• A collection of papers in use on the desktop (windows). Some papers are pushed out of the way (as icons), but are within easy reach.

• Continuous display (through Front Panel icons) of a clock, the date, an indication of new mail, and an indication of something in the trash can.

• Direct access (through Front Panel buttons) to an appointment book (Calendar), a pad of paper ( Text Editor), a terminal (emulator), a mail box ( Mailer), a printer ( Print Manager), office lighting controls ( Style Manager), a list of electronic agents ( Application Manager and Front Panel personal tool box), and a guide book ( Help).

Session Management

• Home session--A snapshot of the desktop state that reassembles in the same way each time it is started.

• Current session--The state of a desktop saved at logout time.

The desktop uses the X11R5 Interclient Communication Conventions style of session management. This consists mostly of conventions for setting properties on top-level windows. The desktop extends this by providing a facility that allocates specific files into which applications can store their state. A command-line flag then points to this file when the application is restarted. Applications that maintain multiple top-level windows must save the state of each of them.

A session is associated with a particular user. In the Common Desktop Environment, the Login Manager is responsible for initial user login. The Login Manager is an alternative GUI for the UNIX login program. Normally, it checks the entered password with the user's registered password. However, vendors can provide authentication schemes tuned to their platform.

The Login Manager is network-aware. When faced with an X display that is normally served by host A, the user can log into the user's desktop by running a session from host B that has full access to the user's normal set of files and services on host B. This is possible by Login Manager acting as the desktop's X11 Display Manager (XDM). The XDM Control Protocol (XDMCP) is used between X11 window servers and XDMs on the network. The Login Manager displays its login window or host chooser window on any X11 server requesting either XDM service. This makes the Common Desktop Environment a good match for use with XDMCP-aware X terminals.

For connections to the X server, the desktop uses the X magic cookie scheme to control access. If a user on some host machine can read a certain file within a session owner's home directory, then access to the X server is granted. An alternative to this per-user authorization is per-host authorization. This is useful for installations supporting pre-X11R4 clients, which will be unable to connect to X servers using the X magic cookie scheme.

X resource files are handled in the context of Common Desktop Environment sessions as follows: a set of Common Desktop Environment default resources is merged with a host version of this file, followed by the user's $HOME/.Xdefaults file, followed by a session-specific file of resources that have changed through user interaction with the Style Manager. The result is stored in the RESOURCE_MANAGER property of the root window. To enable fine-grain customization, the C preprocessor is run on resource file s.

Application Management

• Installation of applications so that they can be run remotely
• User navigation of available applications
• Execution of remote applications

This network transparency is accomplished by installing applications on network hosts designated as application servers . The parts of the installation relevant to the desktop require placing certain files in conventional places in the application's installation hierarchy. The application server maintains a list of applications that it is serving. Each host on the network maintains a list of the application servers on the network that it queries when a user logs into the desktop. This process is referred to as application gathering . It results in a dynamically-generated file hierarchy of actions arranged in folders. (Actions represent operations that end users can invoke, including starting applications.)

The Common Desktop Environment Application Manager provides a specialized view of the file system for the end user. Applications are arranged into groups and groups can be nested (such as in a directory hierarchy). Your application's installation script associates the application to a group. This association can be overridden by the system administrator as part of application server configuration. The set and arrangement of the actions shown through the Application Manager is a system resource that is typically shared between multiple users. Users cannot modify this view.

The user can drag an icon from the Application Manager onto the desktop, File Manager, Front Panel, and so on. The associated action remains valid as long as the gathered application that it refers to remains valid. Because actions represent a form of abstraction and indirection, the actual location of the application can change over time. This change remains transparent to the end user (this is explained further in "Method Invocation" ). The user double-clicks on an action icon to invoke it.

Object Management

Objects managed by desktop-based applications do not have to be file-based; in-memory buffers can represent desktop objects, too. The Common Desktop Environment Mailer handles Multipurpose Internet Mail Extensions (MIME) messages by displaying attachments to a message as icons in a scrollable panel. These are objects that behave just like file-based objects during activities such as drag and drop. The user can drag between the File Manager and the Mailer. Applications that use drag and drop should maintain this important user model by supporting both file-based and buffer-based objects. The desktop drag-and-drop API and protocol make this straightforward.

Window Management

The Front Panel can be thought of as a graphic version of the root window menu supported by many window managers. It can also be thought of as a tuned object manager in which common objects are readily available to the user. The Front Panel can show dynamic system information, and it enables the user to invoke actions and system functions. The user dynamically customizes the Front Panel by dragging and dropping action icons from the Application Manager and File Manager onto subpanels. Applications can come equipped with special configuration files that extend the Front Panel, possibly defining drop behavior, drop zone animation feedback, and so on. The user can optionally install these configuration files depending on customization preferences. Figure 1-2 displays a typical desktop Front Panel.

Figure 1-2 Typical Front Panel

Workspaces are abstractions supported by the Window Manager that can be thought of as virtual desktops. Application windows exist within one, some, or all available workspaces. The user usually determines which workspaces an application window exists in as part of the user's customization. You should rarely use the workspace API other than to explicitly designate in which workspace your application appears on session restart. In general, do not place your application within multiple workspaces, because this overrides the user's prerogative .

Style Management

You, as an application developer, are more directly influenced by font choices, color choices, and input device mappings. The Motif toolkit and the Common Desktop Environment handle many of these settings transparently for widgets. However, your application will appear more integrated with the rest of the desktop if it responds to user font and color preferences. Applications that directly interact with the mouse will feel more integrated with the rest of the desktop if they are consistent with other applications; for example, by using the same mouse button double-click minimum interval value (multiClickTime resource).

To accommodate differences between platform vendor's display technology and available font sets, the Common Desktop Environment defines font aliases that are indirect names to actual font names. Use these aliases in the same way as the rest of desktop uses them.

The Style Manager provides the user with color selection options to adjust the desktop color scheme. This color information is private to the Common Desktop Environment. Applications doing widget subclassing can indirectly access some of the color scheme by looking at inherited background pixel values. A call to XmGetColors() generates 3-D shadow colors.

The Common Desktop Environment does not dictate color usage for static colors, such as those used within icons. For these situations, however, your application should attempt to use the colors offered by the Common Desktop Environment Icon Editor, to enhance color sharing .

Motif GUI Engine

Common Desktop Environment Motif Toolkit

Common Desktop Environment Motif and Motif 2.0 are also highly compatible. Most functions put into Common Desktop Environment Motif have been introduced into Motif 2.0. As a result, developers have compiled their applications with Common Desktop Environment Motif, relinked to Motif 2.0, and ran the applications successfully. Widget subclassing that has not followed Motif 1.2 subclassing guidelines designed to shield programs from widget size changes are likely to fail.

A drag-and-drop convenience layer has been added on top of the Motif 1.2 drag-and-drop API. In addition, the Common Desktop Environment uses the Motif 1.2 preregister drag feedback protocol. A drop site drag manager process keeps track of visible drop zones on the desktop. This data is used by a drag source client process to manage drag feedback interaction. Limited drag time validation of drop zones is followed by full validation at drop time, with snap-back-to-source animation if the drop fails.

Common Desktop Environment Motif includes a GUI style guide and certification checklist that has substantially expanded on the Motif 1.2 style guide. Additions affect the input models, window management, and GUI design principles .

Common Desktop Environment Motif Widgets

• Low-level control widgets:
  • SpinBox--A text field and arrow button widget

  • ComboBox--A text field and list box widget

  • MenuButton--A menu that doesn't need to be in a row column widget

  These were added primarily to help you port applications from a Microsoft Windows or OPEN LOOK environment. The SpinBox and ComboBox widgets have equivalents in Motif 2.0.

• Rich and full-featured widgets:
  • Terminal Emulator widget--Useful for applications designed to mix the best of a command-line user interface with a GUI

  • Editor widget--Available for embedding a more full-featured plain text editor than that available from the Motif Text widget

  • Help widgets--Handle navigation and interaction with application help volumes

    Help is delivered with an application in the form of Semantic Description Language (SDL) files that have been compiled from HelpTag , a form of Standard Generalized Markup Language (SGML) files. The Help system features mixed text and graphics, hyper links, dynamic reformatting of text, and structured navigation capabilities.

GUI Shell

If you are comfortable with shell programming, you may prefer to use Desktop Korn shell for modest programming tasks because it is:

• Well suited to system-administration-type applications because the shell commands intermix easily with GUI control.

• Good for putting a GUI control program on top of character-based applications because the shell environment handles character-based interaction in a natural way.

• A good way to deliver instruction-set-independent programs to a heterogeneous collection of hosts. For example, use the Common Desktop Environment Mailer to attach a script to a message that the recipient simply double-clicks to invoke .

GUI Construction

App Builder maintains the user interface state in Builder Interface Language (BIL) files. A code generator takes the BIL files and produces Motif toolkit code. App Builder can also generate User Interface Language (UIL) files.

As you make changes to your application's user interface, App Builder merges your custom code with the code it generates. Generated code is a good source of example code, even if you do not using App Builder to maintain your application's GUI state.

In addition, nonprogrammers can use App Builder to produce an application GUI prototype. The prototype can roll forward to programmers for the production phase of development.

Integration Technologies

Process Execution

The SPC API and associated control programs are private to the Common Desktop Environment. Actions represent the public API for running applications remotely.

Application Messaging

The desktop provides two standard ToolTalk protocols known as messages sets . A message set contains a number of messages that can be exchanged between a sender and a handler process. These messages are grouped together because they describe related requests and notices. The sender and recipient may be within the same process or on different hosts. Message sets have associated utility functions that allow you to concentrate on the semantics of the protocol without getting involved in the low-level messaging details. Some of the message set functions enable you to defer to default behavior with almost no work on your part.

Desktop Message Set

Media Message Set

Data Typing

The Common Desktop Environment defines, and platform vendors supply, a set of desktop type definitions. Your application should augment the database with both proprietary and public data types at application installation time.

Information is extracted from the actions and data-types through a Common Desktop Environment library API. The data typing API matches an object's properties with the database type criteria to determine the object's desktop type. The matching algorithm uses a set of precedence rules to resolve conflicts.

The Common Desktop Environment type space is defined by the X/Open Common Desktop Environment standard and exists primarily to support desktop-oriented activities such as icon display and action association. The MIME type space is defined by the Internet Engineering Task Force and exists to deal with exchange of mail message parts. A ToolTalk media type space exists in order to match data with handlers, and is a subset of X selection target types defined by the X Consortium. Thus, to do a complete job of type definition, you have to define a Common Desktop Environment type, X selection target, and MIME type. For private Common Desktop Environment types, append the type name to an organization's name. This partitions the name space without need for centralized allocation of types. The Common Desktop Environment claims the Dt prefix, for Desktop .

Method Invocation

• A description of how to invoke the operation: for example, through ToolTalk, through an execution string passed to the SPC mechanism, from within a terminal emulator, and so on.

• A description of the type of arguments associated with the action. The type of the desktop objects (files and buffers) that it accepts is defined by the actions and data-types database. Actions are polymorphic with respect to data types. For example, the Open action invokes a text editor for arguments that are text files and a graphics editor for arguments that are graphics files.

• A description of the number of arguments, if any, associated with the action.

• An optional indication as to where to carry out the operation: the local machine, a particular remote machine, the machine on which the executable resides, and so on. In addition, these execution locations can be included in a list so that if a host is not available then the next host on the list is tried. This provides a measure of redundancy that can be used to increase the likelihood of application launch, even in the face of remote host unavailability. Thus, actions provide network distribution guidance, implemented either through built-in ToolTalk facilities or through the SPC mechanism directly.

• An optional label, help string, and icon that the user sees when interacting with the action's GUI. These are hints to an application about how to represent the action to the user. These hints may be ignored, as the Front Panel does by ignoring the icon if the Front Panel configuration file supplies an alternative icon.

The actions and data-types database and the File Manager use action files to instantiate actions as file system objects that can be viewed, invoked, moved, copied, and so on. The database contains references to an action's implementation (for example "run /usr/bin/app on machine net_app_svr "). However, a representation is needed of an action as an object that the user can directly manipulate. This is achieved by using an object's name, which identifies it as an action to any object manager that is looking for actions. Thus, if there is an executable file named Dtstyle and an action named Dtstyle, the File Manager will interpret that file, regardless of its content, as the Dtstyle action reference. In addition, the File Manager uses the action's label as the name that the user sees for this file. Action labels are localizable, whereas action names are programmatic entities that should not be localized.

The good feature about using files simply as pointers into the actions and data-types database is that the underlying implementation can evolve without the user having to do anything. However, one user's actions and data-types database may not match another user's actions and data-types database. Thus, a user cannot exchange an action reference, for example as a mail message attachment, and expect another person to have a comparable definition for that action. Exchanging a Desktop Korn shell script is the best solution to this problem.

Actions are useful because they integrate both legacy command-line applications and ToolTalk applications into the desktop as polymorphic, distributed operations on desktop objects.