CLIM on a UX displaying through Motif

[barmar@Think.COM (Barry Margolin)]

    Date: Wed, 18 Jul 90 09:09 CDT
    From: dmitchell@BACKUS.trc.amoco.com (Donald H. Mitchell)

    Now, as I understand, CLIM is a common language for coding an interface to run
    under any high-power windowing system.

Right.

    OK, I want an application running on my UX to call CLIM routines to display
    through Motif.  Will it do that?  OK, but will it do it as a Motif window
    rather than a Dynamic Window?  I want Motif widgets and use of selection
    mechanisms and use of handles, buttons, menus, etc.  Remember, I want it
    running on the UX; so, don't tell me to ask Lucid or Franz or whoever unless
    they'll provide libraries that work with the UX and don't require running
    their Lisps on the displaying node's processor.

You are confusing two parts of Motif.  First of all, there is a Motif
Window Manager, which implements everything outside the application
windows (e.g. mechanisms for raising and burying windows, setting
keyboard focus, iconification).  There is also a Motif widget library,
which is a library that the application must use.  Widgets are the
building blocks of user interfaces in X.  Thus, in order to present a
Motif user interface, the application running on the UX board would have
to have a Motif widget library, and such a thing hasn't been implemented
in Lisp as far as I know.

There are two reasons I can think of for the common confusion between
window managers and window systems.  First, X was the first window
system to separate the two pieces.  Second, if you use a Unix
workstation as your X server you probably run the window manager on the
same workstation.

In general, there's no relationship between the user interface within an
application and the window manager user interface.  I'm not even sure
that applications can find out what window manager is running, so I
don't think they can automatically adapt themselves.

    What architecturally will a system running CLIM require of the window server?
    Could someone draw me an architectural diagram showing what runs on the client
    and what runs on the server when executing an application that displays
    through CLIM?  Is there a CLIM server module that runs on top of the window
    system?

       Client(UX400S)                          Server(Sun)

    TCP<-------------------------------------->TCP
    CLIM client service                        CLIM server service
    Application                                Window manager

No, no piece of CLIM runs on the X server.  The architecture looks
like this:

Client(UX400S)                             Server(anything)

TCP<-------------------------------------->TCP
CLX library                                X server
Genera window system (optional)            Server operating system (if any)
CLIM library                               Hardware
Application

For Motif-based Unix applications, the architecture is similar, except
that CLIM library is replaced with Motif widget library, CLX library is
replaced with Xlib, and Genera window system is removed.  Notice that no
part of Motif runs on the server, either.

There is, however, a way to get what you want.  A few months ago I saw
an announcement of a Motif interface library for Common Lisp.  It works
by having a Motif server running on a Unix system.  I don't remember the
name of this product, so I'll refer to it as Lisp/Motif below.  The
architecture would look like:

Client(UX400S)                  Motif Server(Sun)    X Server(anything)

TCP                             TCP                  TCP
Lisp/Motif & CLX libraries      Xlib                 X server
CLIM library                    Motif library        Operating system
Application                     Lisp/Motif server    Hardware

The CLX library on the client and Xlib on the Motif server talk to the X
server using the X protocol.  The Lisp/Motif library on the client talks
to the Lisp/Motif server via a specialized protocol.  I don't know if
the CLIM interface to Lisp/Motif has been implemented

    A further opinion independent from the above query:
    Symbolics, if you recoded your development windows to use CLIM and behave like
    whatever native window system the developer is running the Symbolics through
    (maybe as an option), it would really help me get more people more productive
    on the Symbolics and would break down more of the "but it doesn't fit into the
    environment" complaints.  

Motif isn't a window system.  It's a user interface library, as CLIM is.

In addition to being a user interface library, Motif is also a "look and
feel" specification.  Thus, another way to get a Motif interface from
CLIM would be for CLIM to include a mode that follows this
specification.  In fact, I believe the CLIM developers are working on
this, but I don't think it will be in the first release.

However, remember my point above about there being no way for an
application or user interface library to determine what window manager
happens to be running.  While the CLIM library could be made to
implement a Motif (or any other) look and feel, it would have to rely on
the application or user to tell it which look and feel to use in an X
environment (perhaps this could be specified in the resource database).
In Macintosh or MS-Windows environments the native look and feel is
known a priori, so CLIM can adapt itself without needing hints from the
application or user.
                                                barmar