TITLE: Objects should always draw themselves. NOT!


RESPONSE: Allan Clarke

In the rush towards object-oriented programming, many designers
picked up a simple maxim: objects should be responsible for taking
care of themselves. One manifestation of this in the GUI arena is the
statement that objects should know how to draw themselves. 

	shape->draw (currentView);

	TShape :: draw (TView* current) 
	{
		show icon ...
		show labels ...
		etc
	}

This is usually an erroneous assumption. The reason is simple. It
should be the view's responsibility for figuring out what the 
rendering of any given object should look like.

Consider two examples. First you might have more than one view onto
a given object. Each view has an independent scaling factor. Second,
two views might display the information in quite disparate ways. One
might show a graph of nodes and arcs, another might show a textual
heirarchy of the same information.

Both these simple and common requirements show the inflexibility of
the original design decision. A better design would have us code as

	TShape :: draw (TView* current) 
	{
		current->draw (this);
	}

	TView :: draw (TShape* shape)
	{
		show icon ...
		show labels ...
		etc
	}

and would use inheritance to provide for different shapes and/or
different views.

	virtual TMyView :: draw (TShape*    shape);
	virtual TMyView :: draw (TCircle*   circle);
	virtual TMyView :: draw (TTriAngle* triangle);

The use of overloading draw() instead of adding type-specific 
routines like drawCircle() etc is more a matter of style.