• The coordinate plane.

• The point.

• The rectangle.

• The region.

In addition to the global coordinate system, QuickDraw maintains a local coordinate system for every window. The relationship between global and local coordinates is shown at Fig 1.

Points

The data type for points is Point:

     struct Point
     {
       short v;  // Vertical coordinate.
       short h;  // Horizontal coordinate.
     };
     typedef struct Point Point;
     typedef Point *PointPtr;

The data type for rectangles is Rect:

     struct Rect 
     {
       short top;
       short left;
       short bottom;
       short right;
     };
     typedef struct Rect Rect;
     typedef Rect *RectPtr;

The data type for regions is Region:

     struct Region
     {
       unsigned short rgnSize;  // Size in bytes.
       Rect           rgnBBox;  // Enclosing rectangle.
       ...                      // More data if region is not rectangular.
     };
     typedef struct Region Region;
     typedef Region *RgnPtr;
     typedef RgnPtr *RgnHandle;

The rgnBBox field is a rectangle which completely encloses the region. The simplest region is a rectangle. In this case, the rgnBBox field defines the entire region, and there is no optional region data. For rectangular regions (or empty regions), the rgnSize field contains 10. The data for more complex regions is stored in a proprietary format.

The Graphics Pen, Foreground and Background Colours, Pixel Patterns and Bit Patterns, and Transfer Modes

• Pen location, which is specified in local coordinates stored in the pnLoc field of the colour graphics port. The functions Move and MoveTo are used to move the pen to a specified location, and the function GetPen gets the pen's current location.

• Pen size, which is specified by the width and height (in pixels) stored in the pnSize field of the colour graphics port. The pen's default size is one-by-one pixel; however, PenSize can be used to change the size and shape up to a 32,767-by-32767 pixel square. Note that, if either the width or height is set to 0, the pen does not draw.

• Pen colour, that is, the colour graphics port's foreground colour.

• Pen pattern, which defines the pattern that the pen draws with.

• Pen transfer mode, a Boolean or arithmetic operation which determines how QuickDraw transfers the pen pattern to the pixel map during drawing operations.

• Pen visibility, which is specified by an integer stored in the pnVis field of the graphics port, indicating whether drawing operations will actually appear. For example, for 0 or negative values, the pen draws with "invisible ink". The functions ShowPen and HidePen are used to change pen visibility.

Foreground and Background Colour

If your application uses the Palette Manager, you may also use the Palette Manager function PmForeColor to set the foreground colour.

The foreground colour is used by the graphics pen for drawing lines, framed shapes, and text. The foreground colour is also used by QuickDraw shape painting functions.

Background Colour

If your application uses the Palette Manager, you may also use the Palette Manager function PmBackColor to set the background colour.

The background colour is used by QuickDraw erasing functions, and is also used by the ScrollRect function to replace the scrolled pixels.

Pixel Patterns and Bit Patterns

You define a pixel pattern in a 'ppat' resource. To retrieve the pixel pattern stored in the 'ppat' resource, you use the GetPixPat function. The handle to a pixPat data structure returned by GetPixPat may then be used in a call to PenPixPat to assign the pattern to the pnPixPat field.

Similarly, if you wish to erase with a pixel pattern rather than the background colour, or replace the pixels scrolled by ScrollRect with a pixel pattern rather than the background colour, you can assign a pixel pattern to the colour graphics port's bkPixPat field using the function BackPixPat. (Initially, the pixel pattern in the colour graphics port's bkPixPat field is all-"white". When you assign a non-all-"white" pattern, the pattern in the bkPixPat field overrides the background colour)

In addition to drawing, painting and erasing functions, QuickDraw includes shape filling functions, which may be used to fill a specified shape using a specified pixel pattern. A handle to a pixPat data structure is passed in the thePPat parameter of these functions.

Bit Patterns

     PenPat(&qd.black);

     BackPat(&qd.white);

The PenPat and BackPat functions may also be used to assign other bit patterns to the pnPixPat and bkPixPat fields of the colour graphics port.

Transfer Modes

• Boolean Pattern Mode. Boolean pattern modes apply to line drawing, framing, painting, erasing, and filling operations.

• Boolean Source Mode. Boolean source modes apply to text drawing and copying operations.

• Arithmetic Source Mode. Arithmetic source modes apply to drawing (including text drawing), painting, and copying operations.

The effects of these modes are best explained assuming a 1-bit (black-and-white) environment in which the foreground colour is black and the background colour is white. The following lists the pattern modes and describes the effect of source pixels on destination pixels in such an environment.

These effects are illustrated at Fig 4. Note particularly that patCopy causes the destination pixels to be completely over-written. patCopy is the transfer mode initially assigned to the pnMode field of the colour graphics port.

Boolean Source Modes

The relevant constants are srcCopy, srcOr, srcXor, srcBic, notSrcCopy, notSrcOr, notSrcXor, and notSrcBic. In general, for pixel images, you will probably want to use the srcCopy mode (which causes the destination pixels to be overwritten completely) or one of the arithmetic source modes.

Arithmetic Source Modes

Arithmetic source modes perform arithmetic operations on the values of the red, green and blue components of the source and destination pixels. Although rarely used by applications, arithmetic transfer modes produce predictable results on indexed devices because they work with RGB colours rather than with colour table indexes. The arithmetic source modes and their effects in a colour environment are as follows:

Drawing Lines and Framed Shapes

Functions for moving the graphics pen and drawing lines are as follows:

Fig 5 shows a line drawn using one of the system-supplied bit patterns, and with a pen of size 20-by-40 pixels. Note that the pen "hangs" below and to the right of the defining points,

Functions for Drawing Framed Shapes

Functions for drawing framed shapes are as follows:

Fig 6 shows various framed shapes drawn with various graphics pen sizes and bit patterns. Note that the bounding rectangles completely enclose the shapes they bound, that is, no pixels extend outside the infinitely thin lines of the bounding rectangle. Note also that the arc is a portion of the circumference of an oval bounded by a pair or radii joining at the oval's centre.

Framed Polygons and Regions

Note that, in the framed polygon at Fig 5, the final defining line from the last vertex back to the first vertex was not drawn during the definition process. Note also that, as in all line drawing, FramePoly hangs the pen down and to the right of the infinitely thin lines that define the polygon.

Framed Regions

Transfer Mode. Painting operations utilise the current graphics pen pattern mode. In filling operations, the transfer mode is invariably the pattern mode patCopy, meaning that the destination pixels are always completely overwritten.

Functions for Painting and Filling Shapes

Wedges

Fig 7 shows the polygon as defined for the framed polygon at Fig 6, but this time drawn with one of the polygon painting or filling functions. Note that, although the final defining line from the last vertex back to the first vertex was not drawn, the painting and filling functions complete the polygon (whereas FramePoly did not).

Fig 7 also shows a region comprising two rectangles and an overlapping oval, drawn using PaintRgn. Note that, where two regions overlap, the additional area is added to the region and the overlap is removed from the region.

Erasing and Inverting Shapes

Transfer Mode. In erasing operations, the transfer mode is invariably the pattern mode patCopy, meaning that the destination pixels are always completely overwritten.

Functions for Erasing and Inverting Shapes

Drawing Pictures

The subject of pictures is addressed in more detail at Chapter 13 - Offscreen Graphics Worlds, Pictures, Cursors, and Icons.

Drawing Text

Fonts are resources, and the font family ID is a resource ID. You can get the font family ID using GetFNum. For example, the following sets the current font to Palatino:

     short fontNum;

     GetFNum("\pPalatino",&fontNum);
     TextFont(fontNum);

If you know the font family ID, you can get its name by calling the Font Manager's GetFontName function. If you do not know either the font family ID or the font name, you can use the Resource Manager's GetIndResource function followed by the GetResInfo function to determine the names and IDs of all available fonts.

Setting and Modifying the Text Style

     TextFace(bold);                     // Set to bold.
     TextFace(bold | italic);            // Set to bold and italic.)
     TextFace(thePort->txFace | bold);   // Add bold to existing.
     TextFace(thePort->txFace &~ bold);  // Remove bold.
     TextFace(normal);                   // Set to plain.

A glyph is the visual representation of a character.

You should generally use either srcOr or srcBic when drawing text, because all other transfer modes draw the character's background as well as the glyph itself. This can result in the clipping of characters by adjacent characters.

Copying Pixel Images Between Graphics Ports

• CopyBits, which copies a pixel image to another graphics port, with facilities for:

  • Resizing the image.

  • Modifying the image with transfer modes.

  • Clipping the image to a region.

• CopyMask, which copies a pixel image to another graphics port, with facilities for:

  • Resizing the image.

  • Modifying the image by passing it through a mask.

• CopyDeepMask, which combines the effects of CopyBits and CopyMask, allowing you to:

  • Resize the image.

  • Clip the image to a region.

  • Specify a transfer mode.

  • Modify the image by passing it through a mask.

Fig 8 shows the relative locations of the first four bytes of the portBits field in a graphics port and the portPixMap field in a colour graphics port. The portBits field is actually a structure of type BitMap, and the first four bytes of that structure (baseAddr) are a pointer to a bit image. portPixMap is a handle to a PixMap structure, the first four bytes of which are a pointer to the pixel map's image data.

When you use CopyBits, CopyMask, and CopyDeepMask to copy pixel images between colour graphics ports, you must coerce each port's CGrafPtr data type to a GrafPtr data type, dereference the portBits fields of each and then pass these "bitmaps" in the source and destination parameters. For example, if your application copies a pixel image from a colour graphics port called, say, myColourPort, you could specify (GrafPtr) myColourPort->portBits in the source parameter.

All this works because:

• In a CGrafPort structure, the two high bits of the portVersion field are always set. These bits in a GrafPort structure are the two high bits in the portBits.rowBytes field, which are always clear.

• By looking at these bits, CopyBits, CopyMask, and CopyDeepMask can establish that you have passed the functions a handle to a pixel map rather than the base address of a bitmap.

On indexed devices, pixel images are always copied using the colour table of the source PixMap structure for source colour information, and using the colour table of the current GDevice structure for destination colour information. The colour table attached to the destination PixMap is ignored.

When the PixMap structure for the mask is 1 bit deep, it has the same effect as a bitmap mask, that is, a black bit in the mask means that the destination pixel will take the colour of the source pixel and a white bit in the mask means that the destination pixel is to retain its current colour. When masks have PixMap structures with pixel depths greater than 1, Colour QuickDraw takes a weighted average between the colours in the source and destination PixMap structures. Within each pixel, the calculation is done in RGB colour, on a colour component basis. As an example, a red mask (that is, one with high values for the red components of all pixels) filters out red values coming from the source pixel image.

Transfer Modes

If you specify a destination rectangle that is smaller than the source rectangle when using CopyBits, CopyMask, CopyDeepMask on a direct device, Color QuickDraw automatically uses an averaging technique to produce the destination pixels, maintaining high-quality images when shrinking them. On indexed devices, Color QuickDraw averages these pixels only when you explicitly specify dithering.

You can add dithering to any transfer mode by adding the following constant to the transfer mode:

     ditherCopy = 64  // Add to source mode for dithering.

For example, you could define a rectangle to bound an oval and then frame the oval. You could then use OffsetRect to move the oval's bounding rectangle downwards. Using the offset bounding rectangle, you could frame a second, connected oval to form a figure eight with the first oval. You could then use that shape to help define a region. You could create a second region, and then use UnionRgn to create a region from the union of the two.

Manipulating Rectangles

Manipulating Regions

Manipulating Polygons

The system highlight colour, which can be changed by the user at the Highlight Color item in the Color pane of the Appearance control panel, is stored in a low memory global represented by the symbolic name HiliteRGB. It can be retrieved using LMGetHiliteRGB. You can override the default colour using the function HiliteColor. The current colour is copied to the rgbHiliteColor field of the GrafVars structure, a handle to which is stored in the grafVars field of the colour graphics port structure.

Color QuickDraw implements highlighting by replacing the background colour with the highlight colour. Another low memory global, represented by the symbolic name HiliteMode, contains a byte which represents the current highlight mode. One bit in that byte, represented by the constant pHiliteBit, is used to toggle the background and highlight colours.

Color QuickDraw resets the highlight bit after performing each drawing operation, so your application should always clear the highlight bit immediately before calling InvertRgn (or, indeed, any of the other drawing or image-copying function that uses the patXor or srcXor transfer modes.) The highlight mode can be retrieved and set using LMGetHiliteMode and LMSetHiliteMode, and BitClr may be used to clear the highlight bit:

     UInt8 hiliteMode;
     ...
     hiliteMode = LMGetHiliteMode();
     BitClr(&hiliteMode,pHiliteBit);
     LMSetHiliteMode(hiliteMode);

     hilite = 50  // Add to source or pattern mode for highlighting.

• Cursors, which are 16-by-16 pixel images which map the user's movements of the mouse to relative locations on the screen.

• Icons, which are images that an object, concept, or message. Icons are stored as resources.

Typically, an application calls GetPenState at the beginning of a function that changes the pen's location, size, transfer mode, and/or pattern and restores the saved state to the pen on exit from that function. Depending on its requirements, an application might also save and restore the colour graphics port's foreground and background colours, and the text transfer mode, in the same way.

Since the introduction of the Appearance Manager, it has also become necessary to save and restore the pen pixel/bit pattern and background pixel/bit pattern in functions that call the Appearance Manager functions SetThemeBackground, SetThemePen, and/or SetThemeWindowBackground. Recall from Chapter 6 - The Appearance Manager that constants of type ThemeBrush are passed in the inBrush parameter of these Appearance Manager functions and that the value in the inBrush parameter can represent either a colour or a pattern depending on the current appearance. If it is a colour, that colour will be assigned to the relevant field of the graphics port structure, that is, the rgbFgColor or rgbBkColor field. If it is a pattern, that pattern will be assigned to the relevant field of the colour graphics port structure, that is, the pnPixPat or bkPixPat field.

Accordingly, in the era of the Appearance Manager, applications which call SetThemeBackground and/or SetThemePen will need to take measures to save and restore the complete graphics port drawing state and, if required, normalise that state.

Mac OS 8.5 (Appearance Manager Version 1.1) and Later

Information about the current state of the graphics port is stored in a structure of type ThemeDrawingState. This is a private data structure.

Mac OS 8.1 (Appearance Manager Version 1.0.3) and Earlier

     struct drawingEnvironment
     {
       PenState     penLocSizeModePat;   // Pen location, size, mode, pattern.
       RGBColor     requestedForeColour; // rgbFgColor field of colour graphics port.
       RGBColor     requestedBackColour; // rgbBkColor field of colour graphics port.
       SInt16       textTransferMode;    // txMode field of colour graphics port.
       PixPatHandle penPixelPattern;     // pnPixPat field of colour graphics port.
       PixPatHandle backPixelPattern;    // bkPixPat field of colour graphics port.
       Pattern      penBitPattern;       // If pen pixel pattern is a bit pattern.
       Pattern      backBitPattern;      // If background pixel pattern is a bit pattern.
     };
     typedef struct drawingEnvironment drawingEnvironment;

• Call PenNormal to initialise the pen location, size, mode, and pattern.

• Call RGBForeColor and RGBBackColor to set the foreground and background colours to, respectively, black and white.

• Call TextMode with the Boolean source mode srcOr.

• Call BakPat with the pattern in the QuickDraw global variable white.

Main QuickDraw Constants, Data Types and Functions

patCopy     = 8
patOr       = 9
patXor      = 10
patBic      = 11
notPatCopy  = 12
notPatOr    = 13
notPatXor   = 14
notPatBic   = 15

srcCopy     = 0
srcOr       = 1
srcXor      = 2
srcBic      = 3
notSrcCopy  = 4
notSrcOr    = 5
notSrcXor   = 6
notSrcBic   = 7
ditherCopy  = 64

blend        = 32
addPin       = 33
addOver      = 34
subPin       = 35
transparent  = 36
addMax       = 37
subOver      = 38
adMin        = 39
ditherCopy   = 64

hilite      = 50
hiliteBit   = 7
pHiliteBit  = 0

sysPatListID  = 0

typedef unsigned char PixelType;

struct Point
{
  short  v;
  short  h;
};
typedef struct Point Point;
typedef Point *PointPtr;

struct Rect 
{
  short  top;
  short  left;
  short  bottom;
  short  right;
};
typedef struct Rect Rect;
typedef Rect *RectPtr;

struct Region
{
  short  rgnSize;
  Rect   rgnBBox;
};
typedef struct Region Region;
typedef Region *RgnPtr, **RgnHandle;

struct Polygon
{
  short  polySize;
  Rect   polyBBox;
  Point  polyPoints[1];
};

typedef struct Polygon Polygon;
typedef Polygon *PolyPtr, **PolyHandle;

struct PenState
{
  Point    pnLoc;
  Point    pnSize;
  short    pnMode;
  Pattern  pnPat;
};
typedef struct PenState PenState;

void  InitGraf(void *globalPtr);

void  HidePen(void);
void  ShowPen(void);
void  GetPen(Point *pt);
void  GetPenState(PenState *pnState);
void  SetPenState(const PenState *pnState);
void  PenSize(short width,short height);
void  PenMode(short mode);
void  PenNormal(void);

void  RGBForeColor(const RGBColor *color);
void  RGBBackColor(const RGBColor *color);
void  GetForeColor(RGBColor *color);
void  GetBackColor(RGBColor *color);
void  GetCPixel(short h,short v,RGBColor *cPix);
void  SetCPixel(short h,short v,const RGBColor *cPix);

PixPatHandle  GetPixPat(short patID);
PixPatHandle  NewPixPat(void);
void          CopyPixPat(PixPatHandle srcPP,PixPatHandle dstPP);
void          MakeRGBPat(PixPatHandle pp,const RGBColor *myColor);
void          DisposePixPat(PixPatHandle pp);

PatHandle  GetPattern(short patternID);
void       GetIndPattern(Pattern *thePat,short patternListID,short index);

void  BackPixPat(PixPatHandle pp);
void  PenPixPat(PixPatHandle pp);
void  BackPat(const Pattern *pat);
void  PenPat(const Pattern *pat);

void  MoveTo(short h,short v);
void  Move(short dh,short dv);
void  LineTo(short h,short v);
void  Line(short dh,short dv);

void  FrameRect(const Rect *r);
void  PaintRect(const Rect *r);
void  FillRect(const Rect *r,ConstPatternParam pat);
void  FillCRect(const Rect *r,PixPatHandle pp);
void  InvertRect(const Rect *r);
void  EraseRect(const Rect *r);

void  FrameRoundRect(const Rect *r,short ovalWidth,short ovalHeight);
void  PaintRoundRect(const Rect *r,short ovalWidth,short ovalHeight);
void  FillRoundRect(const Rect *r,short ovalWidth,short ovalHeight,const Pattern *pat;
void  FillCRoundRect(const Rect *r,short ovalWidth,short ovalHeight,PixPatHandle pp);
void  InvertRoundRect(const Rect *r,short ovalWidth,short ovalHeight);
void  EraseRoundRect(const Rect *r,short ovalWidth,short ovalHeight);

void  FrameOval(const Rect *r);
void  PaintOval(const Rect *r);
void  FillOval(const Rect *r,const Pattern *pat);
void  FillCOval(const Rect *r,PixPatHandle pp);
void  InvertOval(const Rect *r);
void  EraseOval(const Rect *r);

void  FrameArc(const Rect *r,short startAngle,short arcAngle);
void  PaintArc(const Rect *r,short startAngle,short arcAngle);
void  FillArc(const Rect *r,short startAngle,short arcAngle,const Pattern *pat);
void  FillCArc(const Rect *r,short startAngle,short arcAngle,PixPatHandle pp);
void  InvertArc(const Rect *r,short startAngle,short arcAngle);
void  EraseArc(const Rect *r,short startAngle,short arcAngle);

void  FramePoly(PolyHandle poly);
void  PaintPoly(PolyHandle poly);
void  FillPoly(PolyHandle poly,const Pattern *pat);
void  FillCPoly(PolyHandle poly,PixPatHandle pp);
void  InvertPoly(PolyHandle poly);
void  ErasePoly(PolyHandle poly);

void  FrameRgn(RgnHandle rgn);
void  PaintRgn(RgnHandle rgn);
void  FillCRgn(RgnHandle rgn,PixPatHandle pp);
void  EraseRgn(RgnHandle rgn);
void  InvertRgn(RgnHandle rgn);
void  FillRgn(RgnHandle rgn, const Pattern *pat);

void  TextFont(short font);
void  TextFace(short face);
void  TextMode(short mode);
void  TextSize(short size);
void  SpaceExtra(Fixed extra);
void  GetFontInfo(FontInfo *info);

void   DrawChar(short ch);
void   DrawString(ConstStr255Param s);
void   DrawText(const void *textBuf,short firstByte,short byteCount);
short  CharWidth(short ch);
short  StringWidth(ConstStr255Param s);

void  CopyBits(const BitMap *srcBits,const BitMap *dstBits,const Rect *srcRect,
      const Rect *dstRect,short mode,RgnHandle maskRgn);
void  CopyMask(const BitMap *srcBits,const BitMap *maskBits,const BitMap *dstBits,
      const Rect *srcRect,const Rect *maskRect,const Rect *dstRect);
void  CopyDeepMask(const BitMap *srcBits,const BitMap *maskBits,const BitMap *dstBits,
      const Rect *srcRect,const Rect *maskRect,const Rect *dstRect,short mode, 
      RgnHandle maskRgn)

void   HiliteColor(const RGBColor *color);
void   LMGetHiliteRGB(RGBColor *hiliteRGBValue);
void   LMSetHiliteRGB(const RGBColor *hiliteRGBValue);
UInt8  LMGetHiliteMode(void);
void   LMSetHiliteMode(UInt8 value);

CTabHandle  GetCTable(short ctID);
void        DisposeCTable(CTabHandle cTable);

PolyHandle  OpenPoly(void);
void        ClosePoly(void);
void        KillPoly(PolyHandle poly);
void        OffsetPoly(PolyHandle poly,short dh,short dv);

void     SetRect(Rect *r,short left,short top,short right,short bottom);
void     OffsetRect(Rect *r,short dh,short dv);
void     InsetRect(Rect *r,short dh,short dv);
Boolean  SectRect(const Rect *src1,const Rect *src2,Rect *dstRect);
void     UnionRect(const Rect *src1,const Rect *src2,Rect *dstRect);
Boolean  PtInRect(Point pt,const Rect *r);
void     Pt2Rect(Point pt1,Point pt2,Rect *dstRect);
void     PtToAngle(const Rect *r,Point pt,short *angle);
Boolean  EqualRect(const Rect *rect1,const Rect *rect2);
Boolean  EmptyRect(const Rect *r);

RgnHandle  NewRgn(void);
void       OpenRgn(void);
void       CloseRgn(RgnHandle dstRgn);
void       DisposeRgn(RgnHandle rgn);
void       CopyRgn(RgnHandle srcRgn,RgnHandle dstRgn);
void       SetEmptyRgn(RgnHandle rgn);
void       SetRectRgn(RgnHandle rgn,short left,short top,short right,short bottom);
void       RectRgn(RgnHandle rgn,const Rect *r);
void       OffsetRgn(RgnHandle rgn,short dh,short dv);
void       InsetRgn(RgnHandle rgn,short dh,short dv);
void       SectRgn(RgnHandle srcRgnA,RgnHandle srcRgnB,RgnHandle dstRgn);
void       UnionRgn(RgnHandle srcRgnA,RgnHandle srcRgnB,RgnHandle dstRgn);
void       DiffRgn(RgnHandle srcRgnA,RgnHandle srcRgnB,RgnHandle dstRgn);
void       XorRgn(RgnHandle srcRgnA,RgnHandle srcRgnB,RgnHandle dstRgn);
Boolean    PtInRgn(Point pt,RgnHandle rgn);
Boolean    RectInRgn(const Rect *r,RgnHandle rgn);
Boolean    EqualRgn(RgnHandle rgnA,RgnHandle rgnB);
Boolean    EmptyRgn(RgnHandle rgn);
OSErr      BitMapToRegion(RgnHandle region,const BitMap *bMap);

void  ScalePt(Point *pt,const Rect *srcRect,const Rect *dstRect);
void  MapPt(Point *pt,const Rect *srcRect,const Rect *dstRect);
void  MapRect(Rect *r,const Rect *srcRect,const Rect *dstRect);
void  MapRgn(RgnHandle rgn,const Rect *srcRect,const Rect *dstRect);
void  MapPoly(PolyHandle poly,const Rect *srcRect,const Rect *dstRect);

Boolean  QDDone(GrafPtr port);

short  QDError(void);

void  ScrollRect(const Rect *r,short dh,short dv,RgnHandle updateRgn);
void  SetOrigin(short h,short v);
void  PortSize(short width,short height);
void  MovePortTo(short leftGlobal,short topGlobal);
void  GetClip(RgnHandle rgn);
void  SetClip(RgnHandle rgn);
void  ClipRect(const Rect *r);

void     GlobalToLocal(Point *pt);
void     LocalToGlobal(Point *pt);
void     AddPt(Point src,Point *dst);
void     SubPt(Point *src,Point *dst);
void     SetPt(Point *pt,short h,short v);
Boolean  EqualPt(Point pt1,Point pt2);
Boolean  GetPixel(short h,short v);

typedef struct OpaqueThemeDrawingState *ThemeDrawingState;

OSStatus  NormalizeThemeDrawingState(void);
OSStatus  GetThemeDrawingState(ThemeDrawingState *outState);
OSStatus  SetThemeDrawingState(ThemeDrawingState inState,Boolean inDisposeNow);
OSStatus  DisposeThemeDrawingState(ThemeDrawingState inState);