Chapter 1

}
The cursor is simply a black line around the outside of the tile and a white line around the
inside of that. The cursor had to look good whatever the color of the square underneath and
around, whatever the contrast capabilities of the display and at whatever zoom level. And yet
the cursor should not altogether hide the square underneath.
It took me quite a few iterations to get a scheme that was acceptable. Unusually, the scheme
I finally chose – for good aesthetic and functional reasons – was also very simple to execute
in C++ code.
Redrawing the view
Draw() is called by the control framework when the windowing system (the Window server)
determines that the control needs redrawing, for example, when a window on-top moves
away and exposes the control. The other circumstance in which a program draws to a view
is to update it to reflect a change in the program's data: for example, in the case of Solo
Ships, to show that a square has been hit. This is called application-initiated redrawing.
Sometimes the data will have changed so much that an application will need to redraw the
entire view. Often, however, only a small amount of data will have changed, and only part of
the view needs changing. This approach, called incremental redrawing, is a good idea, as,
for views of any complexity, redrawing the entire view is likely to be slow enough to be
noticeable to the user. The downside of incremental redrawing is that it can be complex to
program. For each view that you write, you will need to determine the appropriate trade off
between performance/appearance (requiring more incremental redrawing), and program
complexity (requiring less incremental redrawing).
For Solo Ships, some experimentation found that redrawing the whole view produced
noticeable display flicker and so was not satisfactory.
Using incremental redrawing to update just the tiles, however, produced an acceptable
effect. This meant I didn't have to go to the next level of complexity of incrementally
redrawing individual tiles.
The function to update all tiles on the board is DrawTilesNow(). It's called whenever a
fleet gets a hit, or the cursor moves from one square to another.
void CFleetView::DrawTilesNow() const
{
Window().Invalidate(iBoardRect);
ActivateGc();
Window().BeginRedraw(iBoardRect);
DrawTiles();
Window().EndRedraw();
DeactivateGc();
}
DrawTiles() actually draws the tiles, as we've already seen. But now it's sandwiched
between some unfamiliar functions. These are discussed in detail in Chapter 11, but for now
I'll just say a little about this standard pattern used for incremental redraws. The calls
through Window() are required because the Window server needs to know when and
where applications are drawing in order to coordinate all their display activities. Similarly, the