Chapter 1

finished. When the BeginRedraw()function is executed by the window server, it has two
effects:
� The window server sets a clipping region to the intersection of the invalid region, the
region specified by BeginRedraw(), and the region of the window that is visible on the
screen.
� The window server then marks the region specified by BeginRe-draw() as valid (or,
more accurately, it subtracts the begin-redraw region from its current invalid region).
The application's draw code must then cover every pixel of the region specified by
BeginRedraw(). If the application's draw code includes an explicit call to
SetClippingRegion(), the region so specified is intersected with the clipping region
calculated at BeginRedraw() time.
When the application has finished redrawing, it calls EndRedraw(). This enables the
window server to delete the region object that it allocated during BeginRedraw()
processing.
Concurrency
You're probably wondering why the window server marks the region as valid at begin redraw
time rather than end redraw. The reason is that Symbian OS is a multitasking operating
system. The following theoretical sequence of events shows why this protocol is needed:
� Application A issues begin-redraw. The affected region is marked valid on A's window.
� A starts drawing.
� Application B comes to the foreground, and its window overwrites A's.
� B is terminated, so that A's window is again exposed.
� Clearly, A's window is now invalid. The window server marks it as such.
� A continues redrawing, and issues end-redraw.
At the end of this sequence, the region of the screen covered by the reexposed region of A's
window is in an arbitrary state. If the window server had marked A's window as valid at endredraw
time, the window server would not know that it still needs to be redrawn. Instead, the
window server marks A's window as valid at begin-redraw time so that, by the end of a
sequence like this, the window is correctly marked invalid and can be redrawn.
You might think this sequence of events would be rare, but it is possible, so the system has
to address it properly.
Redrawing
You should now find it pretty easy to understand how redrawing works. When the window
server knows that a region of a window is invalid, it sends a redraw message to the window's
owning application, specifying the bounding rectangle of the invalid region. This is picked up
by CONE and handled using the following code:
EXPORT_C void CCoeControl::HandleRedrawEvent(const TRect& aRect)
const
{
ActivateGc();
Window().BeginRedraw(aRect);
Draw(aRect);
DrawComponents(aRect);
Window().EndRedraw();