A Cookbook for Using the ModelView-Controller User Interface

Paradigm in Smalltalk-80
Glenn E. Krasner
Stephen T. Pope

Introduction
The user interface of the Smalltalk-80'" programming environment (see references. [Goldberg 831) was developed using a
particular strategy of representing information. display. and
control. This strategy was chosen to satisfy two goals: ( 1 ) to
create the special set of system components needed to support a
highly interactive software development process: and (2) to
provide a general set of system components that make it possible for programmers to create portable interactive graphical
applications easily.
In this anicle we assume that the reader has a basic
knowledge of the Smalltalk-80 language and programming environment. Interested readers nor familiar with these are
referred to [Goldberg and Robson 831 and [Goldberg 831 for introductory and tutorial material.

MVC and the Issues of Reusability and Pluggability

When building interactive applications. as with other programs.
modularity of components has enormous benefits. Isolating
functional units from each other as much as possible makes it
easier for the application designer to understand and modify
each particular unit. without having to know everything about
the other units. Our experiences with the Smalltalk-76
programming system showed that one particular form of
modularity-a
three-way separation of application components-has payoff beyond merely making the designer's life
easier. This three-way division of an application entails separating ( 1 ) the pans that represent the model of the underlying application domain from. ( 2 ) the way the model is presented to
the user and from. and (3) the way the user interacts with it.

Model-View-Controller (MVC) programming I S the application of this three-way factoring. whereby objects of different
classes take over the operations related to the application
domain (the modell. the display of the application's state (the
view). and the user interaction with the model and the view (the
controller). In earlier Smalltalk system user interfaces. the tools
that were put into the interface tended to consist of arrangements of four basic viewing idioms: paragraphs of text. lists of
text (menus). choice "buttons." and .graphical forms (bit- or
pixel-maps). These tools also tended to use three basic user interaction paradigms: browsing. inspecting. and editing. A goal
of the current Smalltalk-80 system was to be able to define user
interface :omponents for handling these idioms and paradigms
once. and share them among all the programming environment
tools and user-written applications using the methodology of
MVC programming.
We also envisioned that the MVC methodology would allow
programmers to wri~ean application model by first defining neu,
classes that would embody the special application domainspecific information. They would then design a user interface to
it by laying out a composite view (window) for it by "plugging
in" instances taken from the pre-defined user interface classes.
This "pluggability" was desirable not only for viewing idioms.
but also for implementing the controlling (editing) paradigms. AIthough certainly related in an interactive application. there is an
advantage to being able to separate the functionality between
how the model is displayed. and the methods for interacting with
it. The use of pop-up versus fixed menus. the meaning attached to
keyboard and mouse/function key. and scheduling of multiple
views should be choices that can be made independently of the
model or its view(s). They are choices that may be left up to the
end user where appropriate.

The Model-View-Controller Metaphor

ParcPlace Systems. 1100 Genf Road Palo Alto. CA 94303.
[email protected].

Aurhors Address.

Smalltalk-80 is a trademark of ParcPlace Systems.

26 JOOP August1September 1988

TO address the issues outlined above. the Model-View-Contro]ler metaphor and its application structuring paradigm for thinking about (and implementing) interactive application corn-

.,..

ponents was developed. ,Wodt,ls are t n u s iuiiipuirc~i..\,

system application that actually do the work (simulation of the
application domain). They are kept quite distinct from views.
which display aspects of the models. Conrrallrrs are used to
send messages to the model, and provide the interface between
the model with its associated views and the interactive user interface devices (e.g., keyboard. mouse). Each view may be
thought of as being closely associated with a controller, each
having exactly one model. but a model may have many
view/controller pairs.
uk

Controllers contain the interface between their associated

models and views and the input devices (e.g.. keyboard. pointing device. time). Controllers also deal with scheduling interactions with other view-controller pairs: they track mouse mobement between application views. and implement messages for
mouse button activity and input from the input sensor. Although menus can be thought of as view-controller pairs. they
are more typically considered input devices. and therefore are
in the realm of controllers.

Models
Broadcasting Change
The model of an application is the domain-specific software
simulation or implementation of the application's central structure. This can be as simple as an integer (as the model of a
counter) or string (as the model of a text editor). or it can be a
complex object that is an instance of a subclass of some
Smalltalk-80 collection or other composite class. Several examples of models will be discussed in the following sections of
this article.

Views
In this metaphor, views deal with everything graphical: they
request data from their model, and display the data. They contain not only the components needed for displaying but can
also contain subviews and be contained within superviews. The
superview provides ability to perform graphical transformations. windowing. and clipping between the levels of this subview/superview hierarchy. Display messages are often passed
from the top-level view (the standard system view of the application window) through to the subviews (the view objects
used in the subviews of the top-level view).

In the scheme described above. views and controllers have

exactly one model. but a model can have one or several views
and controllers associated with it. To maximize data encapsulation and thus code reusability. views and controllers need to
know about their model explicitly. but models should not know
about their views and controllers.
A change in a model is often triggered by a controller connecting a user action to a message sent to the model. Thls
change should be reflected in all of its views. not just the view
associated with the controller that initiated the change.

Dependents
To manage change notification. the notion of objects as dependetlts was developed. Views and controllers of a model are
registered in a list as dependents of the model, to be informed
whenever some aspect of the model is changed. When a model
has changed, a message is broadcast to notify all of its dependents about the change. This message can be parameterized
(with arguments). so that there can be many types of model

Figure 1. Model-View-Controller State and Message Sending

V i w messages

change messages. Each \.ie\\ or controller responds to the appropriate model changes in the appropriate manner.

Figure 2. FinancialHisroryVieu wlth 11s Barchart sub\

z . ~ h rCon
troller's menu. and an interaction prompter (note t h ; i ~~ h mcnu
r
and
prompter are never \.isible at the same time)

A Standard for the Interaction Cycle

The standard interaction cycle in the h4odel-View-Controller
metaphor. then. is that the user takes some input action and the active controller notifies the model to change itself accordingly. The
model carries out the prescribed operations. possibly changing its
state. and broadcasts to its dependents (views and conrrollers) that
it has changed. possibly telling them the nature of the change.
Views can then inquire of the model about its new state. and update
their display if necessaq'. Controllers may change their method of
interaction depending on the new stare of the model. This messagesending is shown diagrammaticall\- in Figure 1.

An Implementation of Model-View-Controller
The Smalltalk-80 implementation of the Model-View-Controller metaphor consists of three abstract superclasses named
Model, Wen,, and Conridlel: plus numerous concrete subclasses. The abstract classes hold the generic behavior and state of
the three parts of MVC. The concrete classes hold the specific
state and behavior of the application facilities and user interface components used in the Smalltalk-80 system. Since our
primary set of user interface components were those needed for
the system's software development tools. the most basic concrete subclasses of Model. View. and Controller are those that
deal with scheduled views. text. lists of text. menus. and
graphical forms and icons.

Class Model
The behavior required of models is the ability to have dependents and the ability to broadcast change messages to their

rent food utils

28 JOOP August'September 1988

pay

interest

dependents. Models hold onto a collection of heir dependent

objects. The class Model has message protocol to add and
remove dependents from this collection. In addition. class
Model contains the ability to broadcast change messages to dependents. Sending the message changed to a Model causes the
message update to be sent to each of its dependents. Sending
the message changed: aparameter will cause the corresponding message update: aparameter to be sent to each dependent.
A simple yet sophisticated MVC example is the FinancialHistoryview tutorial found in [Goldberg and Robson 831. A display of a FinancialHistory is shown in Figure 2 and its implementation is discussed in the MVC implementation
examples at the end of this article. In it. a vieu that displays a

Figure 3. Message-sending and dependency updating for an example from the FinancialHis~oryapplication

-23,

1 ,-I

= "Normal" message-passing
= Dependents changed/update messages

bar chart is created as a dependent of a dictionary of tagged

numerical values (for example. rent 2 $500). The composite
FinancialHistoryView has two subviews, with two bar charts.
whose models are two distinct dictionaries (incomes and expenditures). These are held as instance variables of the central
model. an instance of class FinancialHistory.
Figure 2 also shows the pop-up menu used by the FinancialHistorycontrolier with the two items labeled 'spend' and
'receive' as well as the input prompter (a FillInTheBlank)
querying for an amount of be spent on 'good times'.
User action for interacting with the FinancialHistory application might be to pick an item from a menu to add a new amount
for rent. The controller then sends a message to the model (the
dictionary), and the model sends self changed. As a result of this,
the bar chan is sent the message update. In response to that message, the bar chart gets the new values from the dictionary and
displays the new bars using the display messages. A flow diagram
for this MVC interaction might look like Figure 3.
The change messages with parameters (i.e., self changed:
sorneAspect).are used to pass information from the model to its
dependents about which aspect has changed, s o as to minimize
the amount of view updating needed. For example. the object
householdFinances (the model mentioned earlier that holds
onto the dictionaries of income and expenses), could have been
the model of two bar chan views. with separate protocols for
displaying expenses and income. In this case, the update message could contain a parameter saying,which of the aspects (expenses o r income) had changed.
Depending on the application. many of the basic Smalltalk80 system structure classes can serve as models of MVC systems. Views can be found in the system or user applications
that use very simple objects (numbers or strings). collection
class instances (orderedCollections, dictionaries. bitmaps or
displayTexts) or complex composite objects (networks,
databases, event lists. or financial histories) as their underlying
models.
Class View
The abstract superclass, class View. contains the generic behavior of views in the system. This includes model and controller interaction. subview and superview interaction. coordinate
transformation. and display rectangle actions. The many subclasses of View implement the various display interaction tools
used in the user interface.
Every instance of a view has exactly one model and exactly
one controller. The model is normally set explicitly. Because
vieu and controller classes are often designed in consort. a
view's controller is often simply initialized to an instance of the
corresponding controller class. To support this. the message
defaultControllerClass. that returns the class of the appropriate controller. is defined in many of the subclasses of
view.
Views have the ability to have zero or more subviews. with
flexible coordinate transformations between one view and its
super- and subviews. Instances of class View have instance
variables for their superviews and for a (possibly empty) collection of subviews. as well as for an instance ot' class

Window1n_eTranstorm;1t1011
un1c.n rcpiesciio
,......, ..
(translation and scaling) between that view's coordinate system
and that of its superview. In addition. there is a default protocol
in View for adding and removing subvieus. as well as a
protocol for changing the transformations. This allows views
consisting of many subviews to be pieced together flexibly and
simply.
The third type of behavior in class View is that which relates
to displaying. Because subclasses of Vieu are assumed to use
display objects to actually do their displaying (Forms. Pens.
Lines. or instances of other graphical classes). View only suppons generic displaying behavior. In particular. there is no instance variable for display objects. Class View assumes that the
top level of a subview structure displays on some medium
(typically the display screen).
Views therefore cache the transformation from their own internal coordinate system to the display's coordinate system (i.e., the
composition of the view's transformation and all of its
superviews' transformations). so that it is faster to get from a
view's internal space to display space. View also has instance
variables insetDisp1a~Bo.v.the clipping rectangle within which
the view may display without overlapping other views: borderWidrh and border-Color; to define the (nonscaled) borders between a view and its superview: insidecolor. to detine the color
(if any) with which a view colors its insetDisplayBox before actually displaying its contents: and bo~mdingBo-r.to describe the
extent of display objects within the view's coordinate system.
By default. the message model: anobject, when sent to a
view. initializes the view's controller to be a new instance of
the view's default controller class. It establishes artObjecr as
the model for both the view and the controller. and establishes
the view as a dependent of the model. This one message is typically sufficient for setting up the MVC structure.
The message release, used when closing a hierarchy of
views (i.e.. the subviews of one top-level window), gives the
programmer the opportunity to insert any finalization activity.
By default, release breaks the pointer links between the view
and controller. The message release also removes the view
from its model's dependents collection. breaking reference circularities between them.
LL,L

Class Controller
It is a controller's job to handle the control or manipulation
(editing) functions of a model and a particular view. In particular. controllers coordinate the models and views with the
input devices and handle scheduling tasks. The abstract superclass Controller contains three instance variables: nrodel. rie.lc..
and sensor. the last of which is usually an instance of class
Inputsensor representing the behavior of the input devices.
Because the interpretation of input device behavior is very
dependent on the particular application. class Controller implements almost none of this behavior. The one such behavior that
is implemented is the determination of whether or not the controller's view contains the cursor.
Class Controller does include default scheduling behavior. It
takes the point of view that only one controller is to bq active
at a time: that is. only one controller at a time mediates user

AugusLSeptember 1988 JOOP 29

input actions. Other \,leu.< could be displaying infomiallon in

parallel. but the user's actions are to be interpreted b! a aingle
controller. Thus. there is behavior in class Controller for determining ahether a controller needs to recei\,e or maintain control. In addinon. there is beha\,ior to signal initiation and rerminarion of control. since many controllers will need to have
special initiation and termination behavior.
The query messages isControl\Vanted and isControlActhe
are overridden in concrete subclasses of Controller if the! require a different beha\,ior for determining a.hether to receive or
maintain control. By default. these messages use the messages
controlToSe~tLeve1(pass i t on down) and vieaHasCursor (a
query) in such a wa!, that the controller of the lo\\est sub\ ieu
in the hierarch!. that contains the cursor in its displa! box \I i l l
take and retain control.
Once a controller obtains control. the default beha\.ior is to
send i t the messages controlInitialize. controlLoop. and
controlTerminate. This message sequence is found in the
method startlip. The messages controlInitialize and controlTerminate are overridden in subclasses thar want specific behavior for starting and ending their control sequences (for example. many of the list controllers have a scroll bar appear to
their left only a,hen the!. have control). ControlLoop is implemented as a loop thar sends the message controlActivit~as
long as the controller retains control. This message is overridden in many controller classes to d o the "real" work of the user
interface.

Graphics-Dtsclay Ob~ecr
Graohlcs-Paths
Graph~cs-V~ers
Graphtcs-Ea~tors
Graphtcs-Su~oor:
Kernel-Objects
Kernel-Classes

for the size (minimum. ma\lrnuni. changing1 of the \ ieu on the

displa!. Interactive applications r\.picall! e\iat inside c!,stem
vieas. that is. the \,ieus and controllera ior the applicar~onare
created as sub\,iews of a StandardS!srerii\~ieu (the applicatmn'h
top-level \,ieu ).
In addition to StandardS!~stemCo~itroIler. the 5)stern
pro\ides other abstract controller classes \I ith default behavior.
\I i l l ne\,er take control: the!
are
Instances o'f 12'oCo~lrr-ollcr~
often used in conjunction u ith "read-onl!"
views. Class
h4o~tseMr11lrCorirr.oll~~r.
includes beha\ ior for producing pop-up
menus \I hen any of the mouse buttons is pressed. Most controllers in the user interface are subclasses of MouseMenuController. including StandardSystemCo1itrol1er itself. because
of the extensive use of pop-up menus. Another example of
u.hich implethese abstract classes is class S(~1~o1lCo1111~olIer:
ments scroll bars.
Standardsystem View and StandardSystemController
Because views are often coniposed of parts (compos~te
views). with one application vlew containing multiple sub\.ieu.s
(as the FinancialHistor! \'ieu s h o w in Figure 2 has subviews
Subclasses of View and Controller are the various classes that
for the t a o bar chart viea 5 ) . the instance \ariables for views
implement more specific types of view and controller behavior.
have different meanings in an application's Standand Slarldur-dS~sren~Co~~rroller~
are
Classes Slar~dur.dS?sreni\i'e~~
ardSystemVien than in their s u b v i e u , ~Of
. the many subclasses
the implementation of "window S y t e m " behawor. Standof Viea. some are meant to behave as top-level \,iews (such as
ardSystemController contains the definition of the standard hliieStandardS!~steniViea ). and others are meant to be used as subblcfrorl nierlzr (normally assigned to the right-hand mouse button ).
views (single subviews u ithin a structured vies.) and "plugged
used for accessing operations of closing. collapsing. and resizinp
in" to other views as coniponents (such as the SelectionInListthe top-level view on the display. It also contains the behavior for
Views used in many types of applications).
scheduling the view as one of the active views. SrandFigure 1 is a schematic diagram of the state and interardSytemView contains the behavior for top-level view labels.
relationships of the rele\,anr MVC objects used in the Counterfor displaying when collapsed or not (possibly using icons). and
Figure 4. Instance variables of an M\'C Triad for runnin; Counter\:~e\t

value: 0
dependents:
OrderedCollection (a Counterview)

Counter

4'

model: a Counter'
view: a CounterViewD
yellowBunonMenu: a PopUpMenu
yellowBunonMessages (increment decrement)
sensor: an InputSensor'

CounterController

30

JOOP August Sepiemoer 1988

a Counter
controller: a CounterController
suoerview: a StandardSvstemView
b i e s : ~ r d e r e d ~ o l l e o) n
insetDis~layBox: 421@34 corner: 569@104
borderwidth: 2@2 corner: 2@2
bordercolor: a Form
insidecolor: a Form

Counterview

Interaction devices
(mouse, keyboard)

The complete bource code tor th13 example 13 I ~ C I U U S ~O) S I W 11.

the section called "MVC Implementation Examples." The interdependencies are shown by the arrows linking the model. vieu
and controller together via instance variables and dependents.

PleasQ t y p e a file n a m e :

User Interface Component Hierarchy

Are y o u certain t h a t y o u
w a n t t o remove this method?

The classes View and Controller. along with the other abstract
classes. provide the framework for views and controllers in the
Smalltalk-80 implementation of the Model-View-Controller
metaphor. The system also contains various subclasses of View
and Controller that provide the pieces of user interface
functionality required by interactive applications. These. user
interface components include menus. text. and forms. These
components are pieced together to form the standard system
views of the Smalltalk-80 application development environment. and can be reused or subclassed for system applications.
They form the kernel of the component library of model-building tools and user interaction components that can be easily
'-pulled off the shelf' and "plugged" together to create interactive applications. We list some of them here. but in most cases
we only use the names of the subclasses of View: it is assumed
that each is used with one or more appropriate Controller subclasses.
SttYtchli'en. and Listl'ierc are two subclasses of View that
provide static or dynamic menu behavior. SwitchViews are
used. for example. in the instance/class switch of the system
browser or the iconic menu of the form editor. They behave as
a switch; they can either be on or off. and when the user clicks
the mouse button on them. they will notify their model. These
are typically used as menus of text or forms. or "buttons."
?, ListView is a scrolling menu of text items. such as those
used in the upper four subviews of the system browser (shown
in Figure 1 1 J. It will inform its model when the user has made
a new selection in the list. Figure 5 shows examples of the use
of subclasses of SwitchViews (in the iconic menu of [he FormEditor, the paint program) and Listviews (in the Browser's
catcgory list subview).
Ptmlprer-s and Cot1firmei.s are simple views that can be used
for eliciting user input. They are started up by giving them a
string for their query or prompt. and can return either a string
value (in the case of Prompters) or a Boolean value (in the case
of Confirmers).
Because they can be considered as belonging more to the

Figure 7. Example\ of simple and h~crarch~cal

menus

exit ~ r o i e c :

aste

mad reader

aracoo
move
hardcopy
ardcooy below
save

controller-sensor interface. pop-up menus are implemented as a

special kind of MVC class. Class Popb'p~Menuis a subclass of
Object and provides its own scheduling and displaying behavior. They are typically invoked by a h4ouseMenuController
when the user pushes a mouse button. When invoked, PopUpMenus by default return a numerical value that the invoking
controller uses to determine the action to perform. There are
several subclasses of PopUpMenu. some that implement hierarchical (multi-level) menus and others that return symbols instead of numerical values upon item selection. Examples of
typical menus are shown in Figure 7.
A number of view/controller subclasses provide text hanand class TestC'iew
dling components. Class StiirlgHolderbi'e~~

Figure 8. File-bared TextEditorVieu and Menu\

TopView =
StandardSystemVicw

,-

up*anaDlas '
box
self InserD age'"
top
box top.
bottom
box bO 'OPY
1.R
box Iaft.
asre
ngnt
box nght. ao ~t
pnnt I C

-+

count number ot ocr

(5

( pitcnscals

rowser
workspace
file 1st
file taltor

Subview =
TextEdi torview
Controller =
TextEdi tor (manages
the w o - u v menu)

August September 1988 JOOP

31

~ l l. ~
l o~ CCo ~
r i ~r rlo f/ /~f ~~ :
mentioned earlier: ~ f ~ l l . ~ ~ ~ . ~ ~ c and
and the class 111pitrSe1is01.
that is used for monitoring user inpui.
There is a global object called Scrisor- ihat ia the sole instance
of the class Inputsensor. I t is used to model the user's input
devices such as the mouse and the keyboard. One can send
query messages to Sensor such as anyButtonPressed. or one
can wait for a user action ~ . i i hmessages such as waitBlueButton. One need normally never refer to Sensor. since it is
used in the iniplementation of the more basic controller classes.
but many types of special user interface componenls. especially those that track the mouse directly (for rubber-band lines. for
example). use it.

Figure 9. S~mpleWorkspace View and Menu

provide views of text used in Workspaces. Editors. Transcripts.

and other instances where text is displayed. The Controller subclasses Parapr-aphEdiror and TcsrEdiror have the standard textediting functionality and are used in many text editor sub\riews.
The layout of a file-based text editor view is shown in Figure 8
along with the names of its components.
In addition to these view types. there are several other classes provided within the system that are used in building MVC
user interfaces. These include the special controller classes

Program Development Support Examples

Workspaces. inspectors. browsers. debugpers. and various
editors are among the system vieus provided in the Smalltalk80 software development suppon environment. They serve no\\
as examples of piecing together subviews from the view and
controller components collection with appropriate models to

Figure 10. Inspector Examples-Simple. .4rray and Dicrionary Inspectors

C&or
mroect
eferencer
remove
Dicr~onay
Dictionwylns
nnt Ir
DisviayMeoi~
OispiiyScan

Figure 11. System Browser view layout and browser menus

Category, Class, Protocol and Message Lists

~rapnio-views

I
boroenng

....r*ro.

C,

e x t m r : mxtmnt of fse$ rpoifits:

aBitnup
(wx~entx) en0 neognt
Tfaace a v
i
n
y p with width
(extent y )
with the bits aBitmap:

ext t x.
width
height * ax en1 y.
011set * a oint.
b l t l * aEi map

instance/class
switches
32 JOOP AugustSeptember 1988

n cut paste dolt printlt

inspecrlr accept cancel)].
t TextMenu

~ d d view
e

[zed inspecrorb tor i o i l i p ~ i . . \O L ~ , C . L > y u C , , ..., .,. . ..,-.. selves or application-specific classes such as event lists.

tions
Workspaces

Browsers
The workspaces in the system are StringHolderView/StringHolder controller combinations installed as the single subview
of a Standardsystemview. Their model is an instance of StringHolder. which merely holds onto an instance of Text, a String
with formatting information. The menu messages implemented
by StringHolderController correspond to the basic text editing
and Smalltalk-80 code evaluation commands as shown in the
menu in Figure 9.
Inspectors
The inspectors in the system are implemented as two views.
A ListView contains the instance variable list (left side), and a
TextView displays the value of the selected instance variable
(right side). An instance of Inspectorview serves as their common superview. and an instance of Standardsystemview serves
as its superview for scheduling purposes. The model for these
views is an instance of Inspector.
Inspectors can be used to view any object. A separate class,
Inspector: serves as the intermediary or filter for handling access to any aspects of any object. As a result, no extra protocol
is needed in class Object. Using intermediary objects between
views and -'actual" models is a common way to further isolate
the viewing behavior from the modeling application.
It is possible to build a more appropriate interactive interface
to composite objects by subclassing the inspector for use with

As with inspectors. intermediary objects are used to model

the system code browser behavior. An instance of class Bran.ser. is the intermediary model for each system browser. representing the query paths through the system class hierarchy to
the class organization and the classes. As dependents of the
Browser model. there are the four list views (for Class
Categories. Classes. Message Protocols and Messages). a code
(text) view (for the method code of the selected message or a
class definition template), and two switch views (for selective
browsing of class and instance messages as shown in Figure
I I ) . Class Browser has separate protocol for each of the various
subviews of the browsers.
Each of the subviews sends different messages to the model
to query the values of an aspect of the system code. Each of the
controllers sends different messages when the aspect should be
changed.
For example. when the user selects a new class in the class
list subview. the controller for that subview sends the message
className: newCiassName to the Browser. The Browser sets
up its new state accordingly. This involves sending the messages self changed: #protocol and self changed: #text. In
response to the corresponding update: messages. the category
subview, the class and instance switches, and the class subview
do nothing. The protocol subview asks the Browser for the new
list of protocols to display and displays it. The message list
subview clears itself. and the text subview asks the Browser for

Figure 11. Debugger view layout and debugger's menus

Message-Sending Stack List

I

Selected Method
Code View

origin: origin aelta

comer + a e l t r ]

awn
fauwz,

---------------

;a.ita

undo
COPY
cut

p
.
,
t
.
00 It
pnnt it

Receiver Object
Inspector

Method temporary
variable Inspector

August!Septernber 1988 JOOP

33

the current text to display. which is the new class template. In

this wag. the six view/controller pairs sharing the single model
work to produce the desired effect.
There are several other types of Browser found in the
Smalltalk-80 system. Note the middle group of menu items in
the upper-right subview (The MessageList) of the System
Browser shown above. The menu items senders, implementors, and messages can be used to open new browsers (called
MessageSer B r o ~ s c r s )on a small subset of the system messages-namely all the senders of the currently selected message. all other implementors of the same message. or all messages sent from within the method of the currently selected
message. Other Browsers exist, for example. to assist in change
or system recovery
management (Char7geSer BI.OH.SCI.S)
(ChartgeLisr B r o ~ c x w , .
Debuggers
Class Deh~~gger
is defined as a subclass of class Browser. so
that it can inherit the cross-referencing behavior (menu messages for querying senders. implementors. and messages used
in a method). It also inherits and augments the code view behavior. The upper subview. which is a context list (i.e.. a message-sending stack). is a list view that uses protocol defined in
class Debugger for displaying the system's message sending
context stack as a list view.
Unlike the system browser. the Debugger is not the only
model involved in the debugging application. There is a
separate Inspector model for each of the two inspector subviews that comprise the four lower subviews. The Debugger instance holds onto those two Inspector objects as two of its instance variables: it explicitly changes the objects they are
inspecting whenever a new context is selected. This is an example of using cooperating model objects with independent
coordinated views. It also shows an advantage to having the Inspector class as a filter on the object: the object used as the
"model" of the Inspector object can change. while the views
and controllers refer to a consistent model.
Object Editors in Smalltalk-80 Applications
Along with the user interaction paradigms of browsing and inspecting, editing is one of the most important aspects of applica-

tions and software development tools. Among the standard editor$

available in Smalltalk-80 systems are text and file editors. foml and
bitmap editors for graphics. and file system editors for source code
and resource management. Many Smalltalk-80-based application?.
implement neu, graphical editors for the structured objects that are
specific to their application domains. such as charts. graphs. maps.
networks. spreadsheets. animations. event lists. or database
contents.

View/Controller Factoring and Pluggable Views

Originally. the program environment tools \\ere implemented
so as to have the models knou nothing about their vieus and
controllers and to use subclassing as the style for differentiating
behavior. In this style. for example. all the know ledge for creating the appropriate pop-up menus is in the class. and there is a
different class for each type of vie\v. Each of these classes has
class variables to hold the menu and the correspondin,0 messages. and those class variables are bound to instance variables
at innance creation time. Associated with each of these different controller classes was a new view class. This is still how
some of the system views are implemented. and it has a number
of advantages. such as clean factoring of system components.
We noticed. however. that many of these different controller
and view classes shared a large number of properties. especially those that implemented list views. One similarity was that
the models were almost always some son of filter class that already knew about the lists and the selected item in the list.
The view classes tended to be identical except for the one
message. defaultControllerClass. which is used to create the
different controllers. The controllers were quite similar except
for the particular set of menu items and the messages they sent
themselves when an item was selected. Finall!.. the controller
messages were almost always passed directly on to the model:
that is. the method for message aMessage. which was sent to
the controller when the menu item aMessage was selecled. was
almost always implemented as Tmodel aMessage.
It would be easier for the application developer if these differences (e.g., the message sent to the model to genemte the
list) were not implemented by different view/controller classes.
but were made parameters (instance variables) of a single class.
This is the notion called p/uggah/e views. Rather than building
a new kind of view (e.g.. a new kind of list view) by creating
two new classes. the developer creates an instance of an exist-

Figure 13. Setup message for the class list view in the browser using a pluggable SelectionlnListView

classListView c SelectionlnListView
on: aBrowser
aspect: #className
change: #className:
list: #classList
menu: #classMenu
initialselection: #className.

"an instance of SelectionlnListView"

"model of the SelectionlnListViewn
'message to get the selected item'
'message sent on item selection'
"message sent to generate list"
"message sent to get menu'
"message sent to get initial selection'

self addsubview: classListView

"Add a subview to the TopView"

"relative area filled by SubView"
"border to adjacent SubViews"

in: myAreaRectangle
borderwidth: 1

34 JOOP AugustSeptember 1988

item select~ondefin~tions.
In some sense. this is an engineering trade-off. because i t has
iesb tlexibilit! than entirely new class definitions and can lead
to having controller information in the model,. It does.
however. reduce the number of different things the developer
needs to do to get an application together. as well as the number of different classes needed.
.An example of the use of pluggable views is the implementation of the system browser list subviews. The original implementation had a special subclass of Listcontroller for each of the list
subviews. Each of these classes had its own definition of the
menus and messages to send when the menu item was selected.
and its own message to send when a new list item was selected.
The current pluggable implementation has four instances of the
same class. SelectionInListController. with parameters that represent the messages to be sent to the model when the selection
changes. and to create an appropriate menu when the proper
mouse button is pressed. The Browser model knows about the
four local menus and receives the corresponding messages.
The use of the setup message for adding a pluggable
SelectionInListView to a composite.view is demonstrated in the
Figure 13. This code segment comes from the actual view initialization for the Browserview. It defines a SelectionInListView in the subview area described by the rectangle mpAreaRectangle. It uses the messages and the menu referred to in the
figure.
The pluggability of SelectionInListViews is afforded by the
class message shown here. namely on:aspect:change:list:rnenu:initialSelection:. The message addSubView:in:borderWidth: is defined in class View for the composition of complex viewlsubview layouts. Messages of this type are the
essence of subview pluggability and examples of their use and
utility are available through out the system's user interface
classes. Several other classes of plugpable subviews implement
similar instantiation lplri~gingimessages.
Another example of a pluggable view is the text view used in
many system views. In this case. one wants to plug a text editor
subview into a view and tell it the messages needed for it to access its new text contents. to set its model's text. and to display
its menu. The message that is implemented in the class CodeVew for this is on:aspect:change:menu:initialSelection:
(note the similarity between this and the message used above
for a pluggable SelectionInListView). The example message in
Figure 14 is the entire method used to define a FileEditor view
such as the one shown in Figure 8.
Several of the other views can be used with pluggable instantiation messages. These include the saitch views (which one
passes a label. the messages they send to determine their state
~ n drespond to being pressed). and confirmers and prompters
cone passes them a message or prompt and they return strings
or Boolean values).
Models a n d MVC Usage
Class Object contains behavior that supports Model's
t'unctionality. i.e.. the ability for any object to have dependents. and

d 0

,c

. ,..

.. ..,

%.

. .-

models and whose corresponding value.; are collection> 01' those

models' dependents. Class Object also implement\ the message
protocol to deal with adding and removing dependents. For e l ample. when some object (like ahlodel) receives the mesage addDependent: someVieu. then sorne\.ieu- is added to the collect~on
found in the DependetirFirltts dictionan at key ahlodel.
Since views and controllers hold direct pointer to their
models. the DependentFields dictionary creates a type of circularity that most stonge managers cannot reclaim. One byproduct of the release mechanism is to remove an object's dependents which will break these circularities. so thih is typicsll>
not a problem except when developing an ML'C application. The
corresponding circularities that result from using instances of
Model are the direct kind that most storage managers can reclaim.
Therefore. we encourage the use and subclassing of Model.
There are several more sophisticated aspects of advanced
MVC application that are not covered in this article. These include the use of windows and viewports, flexible scrolling
frameworks. text composition and fonts. and view composition
with nonscaling subviews. These issues can be studied via their
usage within the Smalltalk-80 system or through examples
found in Smalltalk-80 system applications. interested readers
are also referred to back issues of the Pnr-cPlace R;err.~Ie~re~.
(former/! the Snrallralk-80 iVen,s/errer-)from ParcPlace Systems
and the OOPSTAD HOOPLA Newsletter (see addresses in the
reference list).

MVC Implementation Examples

Presented next are three MVC implementation examples: one a
full application for a very simple view type la Counter view);
one a new application view using pluggable components (the
Organizer view): and one a condensed listing for the viewing
components of a more complex application (the FinancialHistory view discussed earl~erand shown in Figure 2 ) .

Counter View Example

The Counter demonstration and tutorial example is part of
the standard Smalltalk-80 Version VI 2.2 release package and
was originally written by Michael Hanus of the University of
Dortmund. It implements a model (an instance of class
Coi~nrer,that is a simple numerical value and view (a Coirnrevli'en., on i t which shotis the value of the Counter. The controlimplements a menu allowing one to inler /Coirr~rer-Contt.ollt~r~
crement or decrement the Counter's value. The complete code
for these three classes follows.
First one must define u class named Co~rntrr.as a subclass of
Model in the system class category named Dtlnlo-Coirnrev.
Counter has one instance variable for its value.
Model subclass: #Counter
instanceVariableNames: 'value'
classVariableNames: ' '

August.September 1988 JOOP

35

Figure 14. Open Message for a FileEdi~or\-leu using a Pluggable Code\:iew

FileModel class methodsfor: 'Instance creation'

open: aFileMode1 named: aString
'Scheduled a view whose model is aFileModel and whose label is astring."
'local variable for my top-level view and 1 subview'
I topview codeview I
"set up the top-level standard system view"
topview t Standardsystemview model: aFileModel
label: aString
minimumsize: 180@180.
"pluggable CodeView setup message"
codeview c CodeView
"it takes its model and the following:'
on: aFileModel
"message sent to the model to get the text'
aspect: #text
change: #acceptText:from:
'message sent to accept a new text'
menu: #textMenu
"message sent to get text view's menu"
initialselection: nil.
"initially-selectedtext"
topview addsubview: codeview
"add the code view as the sole subview"
in: (0@0 extent: 1@1)
"use the entire view's area*
borderwidth: 1.
W i h a 1-pixel border"

I topview controller open

"open the defauk controller to start up view"

poolDictionaries: ' '

category: 'Demo-Counter'

Next, one adds methods to Counter for initializing new counter

instances and for accessing their values. These messages will
then be understood by all Counter instances.
Counter methodsfor: 'initialize-release'
initialize
"Set the initial value to 0."
self value: 0
Counter methodsfor: 'accessing'
value
"Answer the current value of the receiver."
?value
value: aNurnber
"Initialize the counter to value aNumber."
value t aNumber.
self changedUtoupdate displayed value"
Counter methodsfor: 'operations'
decrement
"Subtract 1 from the value of the counter."
self value: value -1
increment
"Add 1 to the value of the counter."
self value: value + 1

Add the method to class Counter to be used for petting a new

counter instance. ,
Counter class methodsfor: 'instance creation'
new

36 JOOP AugustSeptember 1988

"Answer an initialized instance of the receiver."

Tsuper new initialize

Now define a class for the controller, along with the methods
to define the menu it uses and those that implement the menu
functions by passing them along to the model. The controller
inherits all its instance variables from its superclasses.
MouseMenuController subciass: #CounterController
instanceVariableNames: ' '
classVariableNames: ' '
poolDictionaries: ' '
category: 'Demo-Counter'
CounterController methodsfor: 'initialize-release'
initialize
"Initialize a menu of commands for changing the
value of the model."
super initialize.
self yellowButtonMenu: (PopUpMenu labels:
'Increment\Decrement' withCRs)
yellowButtonMessages: #(increment decrement)
CounterController methodsfor: 'menu messages'
decrement
"Subtract 1 from the value of the counter."
self model decrement
increment
"Add 1 to the value of the counter."
self model increment
CounterController methodsfor: 'control defaults'
isControlActive
"Take control when the blue button is not pressed."

Tsuper isControlActive &

sensor blueButtonPressed not
sext. define the class CounterView as a subclass of View with
no additional instance variables.
View subclass #Counterview
instanceVariableNames: ' '
classVariableNames: ' '
poolDictionaries: ' '
category: '~emo-Counter'
Add to it methods for displaying the state of its model (a
Counter) in the view shown in Listing 1.
Define a method for updating the view when the model changes. The model's sending a self changed message will cause
the view to be sent an update message.
CounterView methods for 'updating'
update: aparameter
"simply redisplay everything."
self display
Another method is needed to return the class of the default controller used within a counterview.
CounterView methodsfor: 'controller access'
defaultControllerClass
"Answer the class of a typically useful controller."
f CounterController
CounterController'initialize-release'
Finally. a method is needed to open up a new counterview and
set up the model and controller for it. The resulting view and its
menu are shown in Figure 15.

Discussion
The code pre3ented so far is the most trivial sort of complete
blVC implementation. Suppose now that we wish to add pushbuttons to the view instead of having menu items to increment
and decrement the value of the counter. Using pluggable button

views. this can easily be done by writing a new open method

for.the CounterView. as shown in Listing 2.
In the open method, one sees the setup of the view as a composition of its three subviews. The subvicw placement is done
via the definition of relative rectangles. These relative rectangles are displayed in the left-hand figure in Figure 16. The
definitions of the two SwitchViews and their Buttons sets their
actions so that they send the increment and decrement messages to the model of the view. This will then have the desired
effect of changing the value of the model (a Counter).

Hierarchical Text Organizer

The second example is the implementation of a simple browser view on a ?-level hierarchical text. It presents a view with
two subviews: a list of topics and a text view for the selected
topic's text. The model is an organizer. which holds onto its organization in a dictionary of text keys and text values. The keys
are used in the topic list view and the values are the contents of
the text view. The layout and menus of an organizer are shown
in Figure 17.
The Organizer is included here as an example of a more
sophisticated use of pluggable views and also as an example of
MVC class factoring. In this example, the single class (Organizer) implements the functionality of the model and the
view and also defined the menus used in the view's two subviews.
The organizer class has two instance variables; its organization dictionary and the currently selected category (topic, section).
Model subclass: #Organizer
instanceVariableNames:'organization'
currentcategory'
classVariableNames:"
poolDictionaries:"
category: 'Interface-Outlines'
The most basic messages to an organizer are for setting it up
and for accessing the organization by category.
Organizer methodsfor: 'initialize-release'
initialize

Listing 1.
CounterView MethodsFor: 'displaying'
displayview
"Display the value of the model in the receiver's view."
I box pos displayText I
box t self insetDisplayBox.
"get the view's rectangular area for displaying"
"Position the text at the left side of the area, 113 of the way down"
box origin + (4 @ (box extent y 13)).
"concatenate the components of the output string and display them"
displayText t ('value:, self model value printstring) asDisplayText.
pos

displayText displayAt: pos

August.Septernber 1988 JOOP 37

Listing 2.

CounterView class methodsFor: 'instance creation'

openWithGraphicalButtons
"Open a view for a new counter that has fixed graphical buttons (whose forms are
generated from the '+' and '-' characters and displayed on white backgrounds)
for incrementing and decrementing the value."
"CounterView openWithGraphicalButtons"

aCounterView topview incrButton decrButton incrSwitchView decrSwitchView 1

"top view = StandardSystemView"
topview t StandardSystemView new label: 'Counter'.
topview minimumsize: 120 @ 80.
topview maximumSize: 600 @ 300.
topview borderWidth:2

"set window border"

"main counter subview"

aCounterView t CounterView new model: Counter new.
aCounterView insidecolor: Form white.
"add main CounterView to topview in the right-hand 60%"
topview addsubview: aCounterView
in:(0.4 @ 0 extent: 0.6 @ 1)
"a view's area is defined to be"
borderWidth:O
"the rectangle O@O to 1@ I "
incrButton t Button newoff
"define increment button and give it its action Buttons are used in Switches
incrButton onAction: [aCounterView model increment].
"put it in a switchview"
incSwitchView t SwitchView new model: incrButton
"whose label is a form"
incrSwitchView label: ('+' as DisplayText magnifyBy: 2@2).
"surrounded by white"
incSwitchView insidecolor: Form white
"add the increment switch to topview"
topview addsubview: incrSwitchView
"put it in the top-left corner"
in: (0430 extent: 0.4 @ 0.5)
"Border is defined as left, top, right, bottom"
borderwidth: (0@0 extent: 2@1).
"define the decrement switch"
decrButton t Button newoff.
decrBunon onAction: [aCounterView model decrement].
decrSwitchView

SwitchView new model: decrButton.

"its form is also put in there"

asDisplayText magnifyBy: 2@2).
decrSwitchView label:
decrSwitchView insidecolor: Form white
"add it in the lower-left"
topview addsubview: decrSwitchView
"under the increment button"
in: (0 @ 0.5 extent: 0.4 @ 0.5)
borderwidth: (0431 extent: 2@0).
"start up topview's controller"
topview controller open
(I-'

38 JOOP AugustiSeptember 1988

Organizer class methodsfor: 'creation'

new
"make a default new Organizer"
I super new initialize
A

Organizer class methodsfor: 'loading'

load: aFileName
"Read a new Organization in from the given file using empty lines and double empty lines as the default
separators. Many other formats can be parsed"
"Organizer load: 'DT.ws'."
1 file org cr I
file t (Filestream oldFileNamed: aFileName).
cr t Character cr.
org t self new.
org parsefrom: file
entryseparatorstring: (String with: cr with: cr with: cr)
keyseparatorstring: (String with: cr with: cr).
I org
A

Organizer class methodsfor: 'view creation'

open File: aName
"read a new Organizer from the given file"
"Organizer openfile: 'DT.ws'."
?self openon: (self load: aName) label: aName
openon: anorganization label: aLabel
"open an Organizer view on the given organization"
"Organizer openon: Organizer new label: 'Maintenance"'

I topview listview textview I

topview t Standardsystemview
model: anorganization
label: aLabel
minimumsize: 250@250.
topview borderwidth: 1.

"top-level view"

listview t SelectionlnListView
on: anorganization
aspect: #organization
change: #organization:
list: #organizationList
menu: #organizationMenu
initialselection: #currentcategory
textview t CodeView
on: anorganlzation
aspect: #text
change: #acceptTex!:
menu: #textMenu.

"plug in topic list view"

"model of list"
"message sent to set new list"
"message sent to get list"
"message sent to get menu"

"plug in text editor view"

"with its model"
"and its aspect accessing message"
"and change message"
"and its menu accesdsing message"
"plug in a special controller for the text view"
troller
textview controller: ~ l w a ~ s ~ c c e ~ t ~ o d e ~ o nnew.
"plug the subviews into the top view"
topview addsubview: listview
~ n (0@0
:
extent: 1Q0.3)
"list view in the top 30%"
borderwidth: 1.
topview addsubview: textview
topview controller open
in: (0Q0.3 extent: 1Q0.7)
borderwidth: 1

"text view in the bottom 70%"

topview controller open

AugusVSeptember 1988 JOOP

39

Figure IS.

\'leu

la>out and menu of the s~nipleCounrerVieu

CounterView class methodsfor: 'instance creation '

open
"Open a view for a new counter."
"select and execute this comment to test this method"
"CounterView open.'
( aCounterView topview

aCounterView c Counterview new

model: Counter new.

"create the counter display view"

'a new Counterview instance"
k i t h a Counter as its model'
'give it a borderwidth"
'and white insides"

aCounterView borderwidth: 2.
aCounterView insideColor: Form white.

topview t Standardsystemview new

label: 'Counter '.
topview minimumsize: 80@40.

value: 0

"the top-level view"

'a new system window"
'labelled 'Counter' '
'at least this big"
"add the counterview as a subview"

topview addsubview: acounterview.

"start up the controller"
topview controller open
"set up a new empty Organizer. Its organization is
an empty dictionary."
organization c Dictionary new

"prompt the user and remove the current category

from the organization"
(BinaryChoice message: 'Are you certain that you
want to remove category', currentcategory,
ifTrue:
[organization removeKey: currentcategory.
currentcategory t nil.
self changed: #organization]
I?')

Organizer methodsfor: 'organization list'

currentcategory

organizationList
"return the list of organization keys (topics), the
keys of the dictionary"
?organization keys asSortedCollection
organization: acategory
"set the current category and signal that the organization text has changed"
currentcategory t acategory.
self changed: #text
addcategory
"Add a new category, prompting the user (with a FillInTheBlank) for its name"
1 newcategory I
Newcategory t FilllnTheBlank
request: 'New Category' initialAnswer: (").
newcategory =" iffrue: [?self].
organization at: newcategory put: Text new.
currentcategory c newcategory.
self changed: #organization

40 JOOP Avgvst!September 1988

renamecategory
"prompt the user for a new name and rename the
current categor "
l newcategory
newcategory t FilllnTheBlank
request: 'New Category'
initialAnswer: (currentcategory).
newcategory = " ifTrue: [?self].
organization at: newcategory put: (organization at:
currentcategory).
organization removeKey: currentcategory
currentcategory t newcategory.
self changed: #organization

i"

organizationbdenu
"return the menu to be used in the topic key list"
currentcategory == nil
ifTrue: [TActionMenu ActionMenulabels: 'add
category' selectors: #(addCategory)].
TActionMenu ActionMenulabels: 'add
category\rename\removel withCRs
selectors: #(addcategory renamecategory removeCategory)

rigule

View

IU.

filth

c u d , u ~ ~ , . ,t? .
\ L~
L,..

AL.U

,.,Y,L~..=

L L

.,

". .. LV..,..-.

L L L ~ V L . ~

graph~calbuttons

val: 0

Figure 17. Organizer view showing list and text views and menus

=nan

es

Smalltalk nochanges.

rename
remove
- --'empty the change set'

(Filestream filcNamed: 'fileNamc.stl)

(FiieStream fileNamed: 'fileNarnest')
ChangeLktView open.

*browse the current c h i

Organizer methodsfor: 'parsing'

parsefrom: aStream entryseparatorstring: entryStr
keyseparatorstring: aKeyStr
"read a n organization from the given stream using
the two given strings to
p a r s e t h e contents into entries and values"

1 tmp key body 1

[aStream atEnd] whilefalse:
[tmp t R e a d s t r e a m o n : (aStream upToAll: entryStr).
key t tmp upToAll: aKeyStr.
body t tmp upToEnd asText.
organization at: key put: body]

~ y ~ r eSupport
%
=: Terminal Support
S: Clocks

many common file formats (such as System Workspace>.

password files. or tables) to be parsed with organizers.

,,::ie
ao ~t

1 I

Smailtaik changes.
'access the change
'remove all changes to a class from the
Stream removeFromChanges.

The class messages for organizers provide for the creation of

new instances and the simple loading of standard files.
The organizer described above can be used, for example, for
creating a browser on the contents of the Smalltalk-80 system's
System Workspace, as shown in Figure 17.

FinancialHistory Example View Setup

The text-related messages allow the user to query and set the
text value for the currently selected category, as shown in
Listing 3.
Organizer methodsfor: 'text'
text
"answer the text for t h e current category"
currentcategory == nil ifTrue: [?Text new].
Torganization at: currentcategory copy

acceptText: aText
"this is s e n t to accept t h e changed text from the
text subview"
currentcategory == nil ifTrue: [Tfalse].
organization at: currentcategory put: aText copy.
Ttrue
textMenu
"answer the menu u s e d in the text subview"
TActionMenu
labels: 'again\undo\copy\cut\paste\do it\print it\inspect\accept\cancel'
withCRs
lines: #(2 5 8)
selectors: #(again undo copyselection cut p a s t e
dolt printlt
inspectlt a c c e p t cancel)
The methods used to parse streams assume that special strings
arc used for separating entries from their keys and for separat-

On the following pages is a condensed version of the source

code (Listings 4 and 5 ) for the classes FinancialHistory,
FinancialHistoryView. and FinancialHistoryController as
described in depth in [Goldberg and Robson 831 and the ParcPlace Systems Smalltalk-80 VI 2.3 release fileset. Figure 2
shows the view layout and standard menu for the FinancialHistory example. Included here is the method text for the
MVC-related setup and interaction messages.
The controller class implements the default menus for use
within FinancialHistoryView as shown below. It carries out
user queries and sends messages to the model to change the
state (such as after spending or receiving money).
Only the receive message for the controller is shown above;
the spend message is closely analogous to it.
The class FinancialHistoryView simply contains the view
setup message for plugging the two BarChartViews into a topView and starting the appropriate controller.
View subclass: #FinancialHistoryView
instanceVariableNames: ' '
classVariableNames: ' '
poolDictionaries: ' '
category: 'D.emo-FinancialTools'
FinancialHistoryView methodsfor: 'controller access'
defaultControllerClass
f Financial~istoryController
The setup message defines the topview and inserts the subviews into it. The BarChartViews are defined in the support

Listing 1.

MouseMenuController subclass: #FlnancialHistoryController

instancevariable Names: ' '
classVariableNames: 'FHYellowButtonMenu FHYellowButtonMessages'
poolDictionaries: ' '
category: 'Demo-FinancialTools'

FinancialHistoryController .methodsfor: 'initialize-release'

initialize
"initialize me and set up the appropriate menus"
super initialize.
self initializeYellowButtonMenu
FinancialHistoryController methodsfor: 'private'
initializeYellowButtonMenu
"plug in my menu and its messages from the class variables"
"The message yellowButtonMenu: yellowButtonMessages: is implemented for all mouse-menu-controllers"
self yellowButtonMenu: FHYellowButtonMenu
yellowButtonMessages: FHYellowButtonMessages

FinancialHistoryController Class methodsfor: 'class initialization'

initialize
"Specify the yellow button menu items and actions."
FHYellowButtonMenu t PopUpMenu labels: 'spend\receive' withCRs.
FHYellowButtonMessages t #(spend receive).
FinancialHistoryController methodsfor: 'menu messages'
receive
"Ask what amount is being received from what and send the appropriate message to the model."

I receiveFrom amount I
"prompt the user with a FilllnTheBlank prompter"
receiveFrom t FilllnTheBlank request: 'Receive from what?'.
receiveFrom =" ifTrue: [Tse~f].
"return if he/she answers blank"
amount t FilllnTheBlank request: 'How much from', receivefrom, '?'.
amount =" iffrue: [Tself].
"read a number out of this string"
amount t Number readFrom: (Readstream on: amount).
model receive: amount from: receivefrom.

"send it on to the model"

classes for the FinancialHistory example and are the bar chart
elements seen in Figure 2.
The three examples presented here show some of the sophistication possible using the Model-View-Controller paradigm
and methodology in the Smalltalk-80 system. Readers are encouraged to browse the Smalltalk-80 system interface classes
or read the other references to see many more examples of
MVC programming.

Summary
The Model-View-Controller metaphor is a way to design and
implement interactive application software that takes advantage
of modularity. both to help the conceptual development of the
applications, and to allow pieces already developed for one application to be reused in a new application.
The metaphor imposes a separation of behavior between the
48 JOOP August1Septernber 1988

actual model of the application domain. the views used for displaying the state of the model. and the editing or control of the
model and views.
We have implemented the metaphor in the Smalltalk-80 system and have used this implementation both to create the basic
programming development tools used in the system, and to
develop a diverse collection of applications.

Acknowledgements
The Smalltalk-80 Programming System and the MVC user interface paradigm were developed over several years by
numerous members of the Systems Concepts Laboratory at the
Xerox Palo Alto Research Center (PARC).
Several of our colleaques at Xerox PARC and ParcPlace Systems reviewed and contributed to this paper. We are indebted to
them for their assistance.

FinancialHistoryView class methodsFor: 'instance creation'

open: aFHModel
adpen and schedule the MVC application for the Financial History given as the argument to this message"

1 aFHView aBCView topview I

topview t Standardsystemview new.

"define the top view (application window)"

topview
topview
topview
topview

"plug in the model"

"make the background light gray"

model: aFHModel.
borderwidth: 2.
insidecolor: Form IightGray.
label: 'Financial History'.

"label the view"

"make it big"
"make the FHView for insertion into topview"
FinancialHistoryView new model: aFHModel.
"add the FHView as a subview of topview"
topview addsubview: aFHView.
"use the entire area of topview"
aFHView

aBCView

define the expenditures Barchart"

BarChartView new model: aFHModel expenditures.
"its model is the expenditures dictionary"
"its area is the given absolute region"

aBCView insidecolor: Form white.

aBCView borderwidth: 2.
"it has no controller"
aBCView controller: NoController new.
"add it as a subview"
aFHView addsubview: aBCView
in: (0.04Q0.05 extent: 0.44Q0.9)
borderwidth: 2
"define the incomes Barchart similarly"
"its model is the incomes dictionary"
aBCView t BarChartView new model: aFHModel incomes.
aBCView insidecolor: Form white.
aBCView borderwidth: 2.
aBCView controller: NoController new
"add it as a subview"
aFHView addsubview: aBCView
in: (0.52Q0.05 extent: 0.44Q0.9)
borderwidth: 2.
"open the new top-level controller for the application:
topview controller open
References
\dele Goldberg. Snruilt~rik-,YO Tire I r r ~ e r o ~ n w
Propronmrrri:. E~iwr~~rrnrrnr
,Add~\on-\\e\le! Pubiirhers. .llenlo Park. 1983.

Ralph E. Johnion. .Model'l i r t ~C O I I ~ I - d l eDepartment

r
o f C. S.. L-. o f Illino~a.L'r-

4dcle Goldberg and D a \ ~ dRobson. Sniullrolk-XI): Tlrv I~rn:~rrrqr

urrtl

11s

Inrpl~nre~r-

torro~r Add~~on-\\e>le)Publirher5. Menlo Park. 1983

bana-Champaign. Sovember 1987

Sam S Adams. "MetaMethods: The M V C Paradigm". in: HOOPLA! (Hooray for

P~rwPImc S~srrnrj \cuderrr.r Sumber\ 1-14 are now a v a ~ l ~ b from

le
ParcPlace

S) rtcm,. 2400 Gens Road. Palo Alto. C.4 91303.

HOOPLA ,Hoor<r?.jhr0hjrc.r-Orrrn~edPro,qromnrrn: Lu11:rro:cs'r. S e u h t e r o f
OOPST,AD

tobject-Oriented

Programmmg

for

Smalltalk.

hpplic;lt~on\

Dc\eloper\ b i o c ~ a t ~ o n. l%
. a ~ l a b lfrom
e
OOPST.4D. P O . Box 1565. Everett.
H'\ 98206.

Further Reading
Slsplwn T Pope. Sm.illtalL-$0 ;\ppl~car~onrBibliography. Sniollto/k-SO .Le*.slzrrrr
; I / . ParcPlacc S\steni~.September 1987.

To find out more about the uae o f the >IVC ci~,ses w ~ r h ~the
n Smallwlh-80 \ys[em. ~nterestedreaders are reierred to the r),tem ~rself.Lamp the !vlessageSet
brewers for b r o w m g all senders o f the pluggable v w r init~:diwtion messape\
can be very ~ n f o r m a t ~ v eExample\
.
o f these m ~ g h be
t found In the "plugg~np" message on:aspect:chanpe:menu:initialselection: uhich 15 ~mplemented in elas\
Codeview or the parallel mewape, In the other pluggable vleu clasbei such as
S e l e c t ~ o n l n L ~ s r V ~or
e wSwirchVie\r
u w r Interlace claaOne can also browse 311 references to the >lrnple ~nteract~ve
\e\ (auch as F~lllnTheBlanhor B ~ n a r ) C h o ~ c eor
~ . the open merrage\ for the
\ysrem'\ appllcatlon blew\. For example\ o f adv;lnced Interaction usage. looking
at ~mplemcntorro f the meshage controlActivit! L.;ln Ix ~ n \ r r u c r ~ o n ~ l .

August September 1988 JOOP

49