1 Introduction

The QTk module implements a description based abstraction to help programmers efficiently build graphical user interfaces. Windows are built in a declarative way, expressing the widgets that compose the window along with their geometry. Widgets can be dynamically controled using handlers. Miscellaneous facilities are also providden to fasten the GUI development of applications. The QTk module is dedicaded to Oz 3.

The documentation is separated in the following chapters :

1.1 Description-based User Interface Specification

The QTk module is based on using descriptions to define user interfaces. A description is a record value that defines completely the user interface.

In general, there are three main ways of defining user interfaces:

QTk uses the description approach, where the descriptions are record values. (The QTk Prototyper provides an interactive interface; this regains part of the advantage of using an Interface Builder.) (The Macintosh has popularized the notion of ``resources'', which are graphical descriptions of user interfaces that correspond to records. However, they are intended to be used graphically, through an Interface Builder. They are much more cumbersome to use than records, for example, they cannot be easily calculated in programs.)

The description approach is particularly useful in a symbolic language such as Oz that allows easy and concise creation of data structures. QTk uses record values, which are well-supported by Oz. For example, the following code defines a record and references it in D:

 
   declare 
   D=td(button(text:"Show" 
               action:proc{$} {Show 'Hello World'end)
        button(text:"Close" 
               action:toplevel#close))

The record with label td has two fields that themselves contain records and that define two buttons. It defines a window with two buttons, labeled Show and Close, which are linked to the actions of displaying Hello World and closing the window.

There are at least five advantages to using descriptions:

By mixing functions and records, descriptions can be made both concise and readable. Here's an example:

 
   declare 
   In Out
   fun {Txt T H S} lr(glue:nswe
                      label(text:T)
                      text(handle:H glue:nswe tdscrollbar:S)) end 
   fun {But T A} button(glue:we text:T action:A) end 
 
   D=td(tdrubberframe(glue:nswe
           {Txt "Expression" In  false}
           {Txt "Result"     Out true})
        lr(glue:we
           {But "Eval" proc {$} V={E {In get($)}} in {Out set(V)} end}
           {But "Quit" toplevel#close}))

The result in D is still a record value, but the source code is shorter. This defines a window with one rubber frame, two text labels, two text boxes (including one with scrollbar), two buttons (each with an action). One of the actions is a procedure that does a calculation (defined by the function E), the other simply closes the window. The text boxes have 'handles', which allow to do things with the text--here, one of the boxes is read (through the 'get' method) and the other is written (through the 'set' method).


Donatien Grolaux
Version 1.2.3 (20011129)