Smalltalk and Object Orientation: an Introduction - Free

27.11 Visual reuse
The aim of visual reuse is to avoid the necessity to rebuild applications from scratch. There are
essentially three ty pes of visual reuse in VisualWorks, these are: cut and paste between windows, the
use of subcanvases and the use of inheritance. Each of these will be discussed briefly below.
27.11.1 Cut and paste reuse
It is possible to cut and paste widgets from one window to another using the canvas and the copy edit
menu option. Essentially you open the user interface builder on a particular window, select the elements
of the window that you wish to copy, use the edit menu to copy them and then go to another canvas and
use the edit menu option paste, to place them on the new window. This copy operation also copies all
the preference information defined for the first window (although it does not copy any instance variable
definitions, initialization or accessor methods). All that is now required for these widgets to be available
on the new window is to define them and carry out any initialization operations required.
This approach saves time on building new windows as whole window layouts (such as buttons, input
fields, test labels, text boxes etc.) can be copied at once. It is also possible to mix widgets copied from a
number of different windows.
However, this approach suffers with problems of maintenance (for both window layout and source
code). For example, if the purpose of copying a set of widgets was to ensure that all windows had a
similar look (for example, with the same set of buttons across the bottom of the window for operations
such as next, last, quit and help). Then whenever a change was made to one window, the same change
would have to be performed for every window in the system. Similarly, if the windows were on
different classes it would be necessary to ensure that any source code changes were reflected in each
class.
Many early graphical user interface building t ools provided only this sort of reuse. Indeed there are
many systems still in use which provide only this level of support.
27.11.2 Subcanvas reuse
Each window is actually a canvas which has certain properties including the windowSpec. These
canvases are by defaul t used to construct the window. However, the layout of part of a window can be
defined by a different specification. The top level window handles this by treating the lower
specification as a subcanvas. That is a subcanvas takes its layout from a different window specification
from that of the result of the window.
There are in fact two ways in which a subcanvas can be used. These are specification based and
instance based. We will consider each of these separately.
window
subcanvas
window specification
window
subcanvas
reference
object providing
specification and
functionality
(a)
(b)
Figure 27.15: Subcanvas reuse
Specification based reuse. Specification based reuse uses another window specification (in addition
to the current window specification) to define what the area of the window controlled by the subcanvas
should look like. This subcanvas can be supplied by another application model (by referencing the other
class). This is indicated in Figure 27.15(a). In this situation, the window’s application model must
provide the necessary functionality required by the widgets in the subcanvas area.
Instance based reuse. Instance based reuse differs from specification based reuse in that in addition
to being able to obtain the window specification used to determine the win dow layout of the subcanvas
from another class, the functionality of the widgets is handled by an instance of that class. Thus the
subcanvas now relates to a completely separate object from the remainder of the window. This is
indicated in Figure 27.15(b).
233