cs349 - s10 - Lecture 7

CS349 - Implementing User Interfaces - Spring 2010

Public Service Annoucements

Assignment 1

Clean-up

display = XOpenDisplay( "" )  // Argument is the display (e.g. citrine:0.0)
screen = DefaultScreen( display )
    bg = WhitePixel( display, screen )
    fg = BlackPixel( display, screen )
//
initSizeHints ( ..., &sizeHints )
window = XCreateSimpleWindow( display,
         DefaultRootWindow( display ),
         hint.s, hint.y, hint.width, hint.height,
         borderwidth, bordercolour, bg )
XSetStandardProperties( display, window, name, iconName, iconPixmap, argv, argc, &sizeHints )
gc = XCreateGC( diplay, window, valuemask, values )
    XSetBackground( display, gc, bg )
    XSetForeground( display, gc, fg )
XSelectInput( display, window, ButtonPressMask | KeyPressMask | ExposureMask )
XMapRaised( display, window )
// Now ready to start the event loop
while( true ) {
    start = gettimeofday( );
    if ( XEventsQueued( display, QueuedAlready ) > 0 ) {
        XNextEvent( display, &evt )
        switch ( evt.type ) {
        case ExposureEvent:
            while ( evt.count > ) XNextEvent( display, &evt );
            break;
        ...
        }
    step-animation-forward( )
    repaint( )
    now = gettimeofday( );
    working = now - start
    if ( working > LoopTime ) {
        // Report overtime
    } else {
         utime( LoopTime - working )
    }
}

Lecture 7 - Events in Transition

Better than X

The Event Loop is

a way of associating a block of code with each event
basic implementation could be a set of call-backs
1. Define a set of recognized events
2. Define a block of code that runs in response to each event, plus
  - a special block of code that repaints the display
3. What is the best model for allowing the blocks of code to interact?

For full-featured interfaces X has

one advantage
- You can do anything
and several drawbacks
- You have to do everything yourself, which is a lot of work
  - UI toolkits, like Motif, are supposed to ease this problem
- There is no abstraction for interaction of the blocks of code
  - Ordinary program decomposition methods are available
  - E.g., subroutines, data and data-type abstraction, objects and classes
- It runs too much on the client which
  - maximizes network usage
  - minimizes graphics hardware usage

There are two important steps in the evolution of interface architectures since X

Allow the server to execute code provided by the client
1. E.g., NeWS Network Extensible Window System
2. A James Gosling production
3. NeWS provides a PostScript engine in the server
4. Client downloads Object-Oriented PostScript code to the server
  - repaint is conceptually simple
  - input can be defined
5. Only obsessives liked it = Not a success.
Put the entire interface on the server
1. Special language for programming interfaces: Java
2. The server is now `thick', running a general-purpose programming language.
  - brings Unix into line with MacOS and Windows
  - which assume that the server & client are monolithic
3. The JFC have a rich library of interface components

This is called the `wheel of reincarnation'.

Return to: