In my experience, in a traditional desktop mvc gui program, the controller ends up spaghettied into the view. Most people do not take the time to factor out a controller class.
Design Patterns in Smalltalk MVC
The Model/View/Controller (MVC) triad of classes [KP88] is used to
build user interfaces in Smalltalk-80. Looking at the design patterns
inside MVC should help you see what we mean by the term "pattern."
MVC consists of three kinds of objects. The Model is the application
object, the View is its screen presentation, and the Controller
defines the way the user interface reacts to user input. Before MVC,
user interface designs tended to lump these objects together. MVC
decouples them to increase flexibility and reuse.
MVC decouples views and models by establishing a subscribe/notify
protocol between them. A view must ensure that its appearance reflects
the state of the model. Whenever the model's data changes, the model
notifies views that depend on it. In response, each view gets an
opportunity to update itself. This approach lets you attach multiple
views to a model to provide different presentations. You can also
create new views for a model without rewriting it.
The following diagram shows a model and three views. (We've left out
the controllers for simplicity.) The model contains some data values,
and the views defining a spreadsheet, histogram, and pie chart display
these data in various ways. The model communicates with its views when
its values change, and the views communicate with the model to access
Taken at face value, this example reflects a design that decouples
views from models. But the design is applicable to a more general
problem: decoupling objects so that changes to one can affect any
number of others without requiring the changed object to know details
of the others. This more general design is described by the Observer
(page 293) design pattern.
Another feature of MVC is that views can be nested. For example, a
control panel of buttons might be implemented as a complex view
containing nested button views. The user interface for an object
inspector can consist of nested views that may be reused in a
debugger. MVC supports nested views with the CompositeView class, a
subclass of View. CompositeView objects act just like View objects; a
composite view can be used wherever a view can be used, but it also
contains and manages nested views.
Again, we could think of this as a design that lets us treat a
composite view just like we treat one of its components. But the
design is applicable to a more general problem, which occurs whenever
we want to group objects and treat the group like an individual
object. This more general design is described by the Composite (163)
design pattern. It lets you create a class hierarchy in which some
subclasses define primitive objects (e.g., Button) and other classes
define composite objects (CompositeView) that assemble the primitives
into more complex objects.
MVC also lets you change the way a view responds to user input without
changing its visual presentation. You might want to change the way it
responds to the keyboard, for example, or have it use a pop-up menu
instead of command keys. MVC encapsulates the response mechanism in a
Controller object. There is a class hierarchy of controllers, making
it easy to create a new controller as a variation on an existing one.
A view uses an instance of a Controller subclass to implement a
particular response strategy; to implement a different strategy,
simply replace the instance with a different kind of controller. It's
even possible to change a view's controller at run-time to let the
view change the way it responds to user input. For example, a view can
be disabled so that it doesn't accept input simply by giving it a
controller that ignores input events.
The View-Controller relationship is an example of the Strategy (315)
design pattern. A Strategy is an object that represents an algorithm.
It's useful when you want to replace the algorithm either statically
or dynamically, when you have a lot of variants of the algorithm, or
when the algorithm has complex data structures that you want to
MVC uses other design patterns, such as Factory Method (107) to
specify the default controller class for a view and Decorator (175) to
add scrolling to a view. But the main relationships in MVC are given
by the Observer, Composite, and Strategy design patterns.