Smalltalk and Object Orientation: an Introduction - Free

27. Graphical User Interface Construction Tools
27.1 Introduction
This chapter provides a brief introduction to the VisualWorks window building facilities. The
VisualWorks user interface builder is a tool which allows the developer to interactively construct a
window using an object oriented drawing tool (à la MacDraw, xfig or AutoSketch). This drawi ng tool
can then generate the Smalltalk source code required to actually create an instance of the window
designed by the user. This Smalltalk window definition can then be easily and simply linked to a user’s
application. Thus making it particularly easy to construct graphical interfaces to Smalltalk applications.
This chapter is intended to provide a description of some of the features of the User Interface
Painting tools. It is not intended to be a complete introduction to either the User Interface Buil der or to
the instance structure of VisualWorks windows.
In the remainder of this chapter we first consider what a window building tool is and then what
window construction tools are available in VisualWorks (which are very similar to those tools in other
Smalltalk development environments). We then consider the use of associated classes such as
ApplicationModel and ValueHolder as well as how to construct windows using the availab le
tools.
27.2 What is a user interface builder?
A user interface builder is a tool which allows a developer to construct a window by drawing it rather
than by defining it programatically. This is a very great advantage as the construction of windows in
many windowing systems is unnecessarily complex and difficult to understand. It often takes a great
deal of source code just to create a window, give it a label, place an input field, an output field and a
button on that window. In many situations the resulting “program” is difficult to maintain and may be
error prone. The result is that it is difficult to build and modify windows, whereas windowing systems
by their very nature are intended to be easy to use.
One approach to this problem was the construction of w indow construction toolkit. TCL/TK is an
example of such a toolkit [Ousterhout 1994]. It allows the user to specify the structure of a window in a
simple scripting language. The resulting window can then be integrated with a program written in
another language such as C. The problem with this approach is that firstly the developer must learn the
TCL scripting language, secondly they must integrate the windowing system with their C programs (not
always a straight forward task) and thirdly when a bug is encou ntered they must search through two
separate systems to identify where the fault occurred. In addition this approach still relies on the
developer laying out the window programatically.
Another approach is to use a window drawing tool. The motivation for s uch tools was to allow users
to construct their windows graphically, enabling them to easily and quickly modify the window layout
and then to compile the graphic window into source code. The source code could then be compiled to
construct the window. In th e early days of these systems it was necessary to integrate your application
code with the source code generated by the window construction tool. Having done this, if you ever
modified the window, you would overwrite any application code. Obviously this wa s not acceptable,
and was caused because the window construction tools were not closely integrated with a development
environment.
The age of the visual tool overcame this hurdle. Languages such as VisualBasic, Visual C++,
Symantec’s Visual Cafe and of course VisualWorks, allow a developer to draw a window on the screen,
compile it, add their own application code and modify the window without any loss of information.
These tools have greatly simplified the construction of graphical interfaces and enabled a far wider
range of applications to benefit from sophisticated windowing environments.
223