Lecture 28

Wednesday, March 11, 1998

Read chapters 1 to 3 from Schildt's Windows 95 Programming in C and C++, by Herbert Schildt.

Problem: How do we design our application so that we can handle user input at any time?
Another problem: Normally the user can, at any time:
- close the application,
- minimize the application to an icon,
- maxmize or resize the window, which requires the window to be redrawn,
- press a key,
- open a menu,
- remove a window from in front of the application, which requires the application's window to be redrawn.
Who (the application or the GUI system) is responsible for handling these events and redrawing the window if necessary?

The GUI system may be part of the operating system (OS), or may be a separate system running on top of the OS.
- Part of the OS: MacOS, Windows 95, Windows NT, OS/2.
- Separate system: Windows 3.x, Unix X/Windows.
To the user, the GUI is the system that acts as a mediator between the user, the application, and the OS.
To the programmer, the GUI is a library of constants, variables, types, and functions that allow the application to interact with the user and with the OS.

Problem: How do we design our program so that we can handle user input at any time?
Solution: Use an event-driven paradigm.
In an event-driven paradigm, the program responds to actions initiated by the user. This is in contrast with the normal (command-line) programming paradigm where the user responds to actions (prompts) initiated by the program.
In such a program, there is an event loop which receives notification of actions (called events) initiated by the user and call appropriate subroutines.
- The operation of the loop is this:
  1. get the next event
  2. do appropriate processing
  3. go to 1
There are two ways that the application can "get the next event":
1. polling
2. callbacks

With polling, the application calls a subroutine in the GUI system which returns the next event.
- If there is no event yet, the subroutine waits for one before returning. This is called blocking.
A true multitasking OS (such as Unix or Windows NT) is required for polling. Otherwise other applications will not have a chance to run while the GUI is waiting for input.

With callbacks, the application "registers" some of its subroutines with the GUI system. Then when an event occurs, the GUI system call the appropriate application subroutine to handle the event.
- Note the important difference compared to "normal" programming style: the OS is calling your function.
Some GUI systems allow the application to register several subroutines (each of which could handle one event), and others allow the application to register only one subroutine.

Lectures

This page is maintained by simpson@cs.sfu.ca.

Last updated on 11 Mar 1998.