Chapter 1

How to draw
Naturally, you can draw using the system GC and its member functions.
Important
You can assume that the GC was reset before Draw() was called.
Don't reset it yourself and don't set colors and options that you don't
need.
Avoiding wasteful redraws
Drawing outside the invalid region is technically harmless (because such drawing will be
clipped away by the window server whether it's inside your control's boundaries or not), but
it's potentially wasteful. You may be able to save time by confining your drawing activity to
the invalid region; the trade-off is that you will have to do some testing to find out what you
must draw and what you do not need to draw.
That's the purpose of the TRect passed to your Draw() function; it is the bounding
rectangle of the invalid region. If you wish, you can use this to draw (or redraw) only the part
of the control within the passed TRect. It will be worth doing this if the cost of testing is
outweighed by the savings from avoiding irrelevant drawing.
In practice, very few controls gain much by confining their redraw activity entirely to the
bounding rectangle – it's simpler and not much slower to redraw the whole control. As a
result, the majority of controls are coded to ignore the bounding rectangle that's passed. If
you're writing a control that does use the TRect, remember that you still have to obey the
contract to cover the entire invalid region within the boundary of your control, and nothing
outside your control. You may still have to set a clipping region to ensure this – the system
doesn't set one for you.
Note
Early in Symbian OS development, we passed the invalid region (rather than
its bounding rectangle) to Draw(). This turned out to be more trouble than it
was worth. Regions are data structures of arbitrary size, which are much
harder to pass around than TRects, but we had to pass them whether they
were needed or not – and they usually weren't. As a compromise, we passed
the bounding rectangle of the invalid region.
Breaking the const and leave rules
In quite rare circumstances, you may need to do some nondraw processing in Draw(). This
could happen, for instance, if your view is very complicated and you're doing lazy
initialization of some of the associated data structures in order to minimize memory usage.
In this case, you may need to allocate memory during Draw() to hold the results of your
intermediate draw-related calculations, and this allocation could cause a leave. In addition,
you'll want to use a pointer to refer to your newly allocated memory, perhaps in the control.
This requires you to change the pointer value, which would violate the const-ness of
Draw().
The solution, in this case, is to use casting to get rid of const-ness and to put your resourceallocating
code into a leaving function that gets called from a TRAP() within Draw(). You
also have to decide what to draw if your resource allocation fails
11.4 Flicker-free Redraw