Chapter 1

Calculate board size in twips, and hence scale factor
TInt boardSizeInTwips =
iCoeEnv->ScreenDevice()->HorizontalPixelsToTwips(boardSize);
boardSizeInTwips = (boardSizeInTwips * iZoomFactor) / 1000; // Zoom
TInt scaleFactor = (boardSizeInTwips * 1000) /
KIdealBoardSizeInTwips;
boardSize =
iCoeEnv->ScreenDevice()-
>HorizontalTwipsToPixels(boardSizeInTwips);
The HorizontalPixelsToTwips() function converts a given number of twips into pixels.
This is a device-specific thing: I use the screen device to give me the right answer. Then, I
scale the board size (in twips) by the zoom factor to get the board size I will really be using.
Next, I calculate a scale factor: the ratio of the board size I will be using (in twips) to the ideal
board size (in twips). I will be applying the same scale factor to the tiles and border,
individually.
For both the scale factor and the zoom factor, I use the number 1000 to indicate one-to-one.
This means I can do a scaling calculation using code such as
scaled_number = (old_number * scale) / 1000;
with integer values. This is preferable to doing the calculations in floating- point numbers.
This kind of 1000-based scaling is used elsewhere in Symbian OS graphics programming,
as we'll see when we look at the TZoomFactor class, in Chapter 15. Watch out, though, for
two possible sources of error:
� Always multiply by the scale first, and then divide by 1000 – otherwise, you will lose
precision.
� Ensure that the number to be scaled, combined with the scale factor, is less than the
maximum possible integer – otherwise, you'll get an overflow.
The number 1000 was chosen to be sufficiently large to enable reasonable precision, but
sufficiently small to reduce the risk of overflow. With a zoom factor of ten to one, and a twips
value the size of a Letter paper, scaling calculations will reach 15 840 (twips high) × 10
000(ten-to-one scale) = 158 400 000, which still leaves a good deal of room before you hit
the 2.1 billion maximum signed integer value.
Finally, I calculate a board size in pixels by calling the opposite function to the one I had
before – HorizontalTwipsToPixels().
Note
I am assuming that pixels on the screen are square. This assumption is
pretty safe.
Next, I calculate the real tile and border sizes, in twips, by applying the same scale factor as
was used for the board (I'll be using these values later, to calculate the point sizes of fonts):
// Tile and border sizes also
TInt tileSizeInTwips = (KTileSizeInTwips*scaleFactor) / 1000;
TInt borderSizeInTwips = (KBorderSizeInTwips*scaleFactor) / 1000;
Then, I have to calculate the sizes, in pixels, of the tiles and border.