• a set of actions,
• a set of variables, and
• a set of objects that can be understood by the user.

GUI: the set of objects are of a graphical nature. Also called "user friendly".

• o₁ reflects the values of v₁ and v₂;
• a₁ modifies the values of v₂ and v₄ based on the values of v₁, v₂ and v₃;
• o₂ is linked to the action a₁.
• a₂ may invoke the object o₃ if needed.

Objects:

Variables: the raw image, the file name, the image mode, etc.

Actions: save the image to a file.
 

Skill levels.

• For the beginner level:
a few easy to understand operations;
simplified set of menus;
point - and - click.
• For experienced users:
they want speed;
keyboard actions;
combine several actions - macros;
multiple mouse button clicks;
eliminate "do you really want to do this" messages.

• A particular object shape should always have the same meaning : X = close.
• Use the general conventions for the menu order (File, Edit, ..., Help).
• Use the same color for the same action.
• Makes it easier to learn.

• Select clear names for the actions.
• Avoid overloading windows and dialogs.
• Easy to recognize icons help remembering.

• Allow abort, cancel, undo, redo, for operations.
• It implies saving the application state at one or several moments (requires a stack).
• Ask for confirmation/give a warning for operations that cannot be undone.
• Good diagnostics and error messages.

• A continuous interactive dialog with the user.
• As input is received, some response should be seen.
• Invert color, blink, highlight, any other color change.
• If a process takes time, let the user know the program is still working.
• Display partial results when possible.
• Audio messages can spare screen space.

When the program is running, all of them are executing the following

while (1)
{
  while (!event)
    event = get_event();
  process(event);
}

Outline of application code

struct Widget {
  int nr_events;
  event_type *events;
  (void *())*callbacks;
  ...
};

void Widget::signal_connect(widget w, event_type event, void *() function)
{
  w.events[nr_events] = event;
  w.callbacks[nr_events] = function;
  w.nr_events++;
}

void check_event(Widget w, event_type event)
{
  for (int i=0; i

Event:


Mouse click, keyboard entry, focus, update, kill, etc.

They can come from the user, the system, the application itself, or 
other applications.

All the applications should inherit the basic system events:

Linux: kill, Ctrl-C

Windows: Ctrl-Alt-Del

Process Event


The communication with the outside world is the responsibility 
of each widget.


An event or a set of events are translated into a signal to be processed 
by the widget.


You must tell each widget which signal to receive and what to do in that 
case.


The function to be called when the widget receives a signal is called a 
callback function.



Objects and Inheritance

A class defines some general callback functions that are then 
automatic for the objects of that class.


A derivate class inherits this behavior and can redefine its own.


The callback function should in general be virtual.


GUI are based on windows and menus.
A window can contain:
one or more drawable areas containing text or graphics

several attached menus

several other interface objects

any combination of the above



A menu

can be:

 

displayed on a window









attached to some event





is defined by:



an identifier (File),









several items (New, Open, Save, etc.)









item separators (---------)



A menu item can invoke submenus.

Examples of Widgets (interface objects):


Toggle button



on or off



Action button



executes something (X)



Radio button



choose between several values



Label



displays text or an image



Entry



allows the user to enter a value



List box



displays a list of alternatives



Scale



choose a numerical value with a slider



Frame



can contain other widgets, used for organizing the window