Chapter 1

Default settings are assured here: the original call to ActivateGc()set default settings for
the window-owning control that was drawn first; later calls to ResetGc() ensure that
components are drawn with default settings also.
The loop above doesn't need to draw window-owning components of the window-owning
control that received the original redraw request. This is because the window server will
send a redraw message to such controls in any case, in due time.
You can see again here how lodger components promote system efficiency. For each
component that is a lodger (instead of a window- owning control), you avoid the client-server
message and the 'activate' and 'begin-redraw' brackets. All you need is a single
ResetGc(),which occupies a single byte in the window server's client-side buffer.
Support for flicker-free drawing
As an application programmer, you should be aware of two aspects of the window server
that promote flicker-free drawing.
Firstly, the window server clips drawing down to the intersection of the invalid region and the
begin-redraw region, so if your drawing code tends to flicker, the effect will be confined to the
area being necessarily redrawn.
You can exploit this in some draw-now situations. Imagine that I wanted to implement a
cursor-movement function, but didn't want to alter my DrawTiles() function. I could write a
DrawTwoTilesNow()function that accepted the (x, y) coordinates of two tiles to be drawn,
enabling me to calculate and invalidate only those two rectangles. I could then activate a GC
and begin-redraw the whole tiled area, calling DrawTiles() to do so. The window server
would clip drawing activity to the two tiles affected, eliminating flicker anywhere else. It's a
poor man's flicker-free solution, but in some cases, it might just make the difference.
Secondly, the window server's client-side buffer provides useful flicker- free support. For a
start, it improves overall system efficiency so that everything works faster and flickers are
therefore shorter. Also, it causes drawing commands to be batched up and executed rapidly
by the window server using the BITGDI and a constant clipping region. In practice, this
means that some sequences of draw commands are executed so fast that, even if your
coding flickers by nature, no one will ever see the problem, especially on high-persistence
LCD displays. The key here is to confine sequences that cause flicker to only a few
consecutive draw commands so that they all get executed as part of a single window server
buffer.
Finally, and most obviously, the use of lodger controls helps here too because it means the
window server buffer contains only a single ResetGc() command between controls, rather
than a whole end bracket for redraw and GC deactivation, followed by a begin bracket for
GC activation and redraw.
11.5.5 Backed-up Windows
In the window server, a standard window is represented by information about its position,
size, visible region, and invalid region – and that's about all. In particular, no memory is set
aside for the drawn content of the window, which is why the window server has to ask the
application to redraw when a region is invalid.
But in some cases, it's impractical for the application to redraw the window, for instance, if
it's:
� an old-style program that's not structured for event handling, and so can't redraw;