Reduce the #ifdef count a lot by adding debug-print macros

1 files changed, 411 insertions, 389 deletions

diff --git a/macosx/tkMacOSXDraw.c b/macosx/tkMacOSXDraw.c
index 06a52a2..f4b8600 100644
--- a/macosx/tkMacOSXDraw.c
+++ b/macosx/tkMacOSXDraw.c
@@ -1,18 +1,17 @@
-/* 
+/*
  * tkMacOSXDraw.c --
  *
- *        This file contains functions that perform drawing to
- *        Xlib windows.  Most of the functions simple emulate
- *        Xlib functions.
+ *	This file contains functions that perform drawing to Xlib windows.
+ *	Most of the functions simple emulate Xlib functions.
  *
  * Copyright (c) 1995-1997 Sun Microsystems, Inc.
  * Copyright 2001, Apple Computer, Inc.
  * Copyright (c) 2006 Daniel A. Steffen <das@users.sourceforge.net>
  *
- * See the file "license.terms" for information on usage and redistribution
- * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ * See the file "license.terms" for information on usage and redistribution of
+ * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkMacOSXDraw.c,v 1.18 2006/10/16 16:25:38 das Exp $
+ * RCS: @(#) $Id: tkMacOSXDraw.c,v 1.19 2007/04/13 14:51:18 dkf Exp $
  */
 
 #include "tkMacOSXInt.h"
@@ -24,15 +23,17 @@
 #endif
 */
 
-#define RGBFLOATRED(c)   ((c).red   / 65535.0)
+#define RGBFLOATRED(c)	 ((c).red / 65535.0)
 #define RGBFLOATGREEN(c) ((c).green / 65535.0)
-#define RGBFLOATBLUE(c)  ((c).blue  / 65535.0)
-#define radians(d)       ((d) * (M_PI/180.0))
+#define RGBFLOATBLUE(c)	 ((c).blue / 65535.0)
+#define radians(d)	 ((d) * (M_PI/180.0))
 
 /*
- * Non-antialiased CG drawing looks better and more like X11 drawing when using
- * very fine lines, so decrease all linewidths by the following constant.
+ * Non-antialiased CG drawing looks better and more like X11 drawing when
+ * using very fine lines, so decrease all linewidths by the following
+ * constant.
  */
+
 #define NON_AA_CG_OFFSET .999
 
 /*
@@ -53,33 +54,35 @@ static int useThemedFrame = 0;
 /*
  * Prototypes for functions used only in this file.
  */
-static unsigned char InvertByte(unsigned char data);
-static void TkMacOSXSetUpCGContext(MacDrawable *macWin, CGrafPtr destPort,
-	GC gc, CGContextRef *contextPtr);
-static void TkMacOSXReleaseCGContext(MacDrawable *macWin, CGrafPtr destPort,
-	CGContextRef *context);
+
+static unsigned char	InvertByte(unsigned char data);
+static void		TkMacOSXSetUpCGContext(MacDrawable *macWin,
+			    CGrafPtr destPort, GC gc,
+			    CGContextRef *contextPtr);
+static void		TkMacOSXReleaseCGContext(MacDrawable *macWin,
+			    CGrafPtr destPort, CGContextRef *context);
 
 /*
  *----------------------------------------------------------------------
  *
  * TkMacOSXInitCGDrawing --
  *
- *        Initializes link vars that control CG drawing.
+ *	Initializes link vars that control CG drawing.
  *
  * Results:
- *        None.
+ *	None.
  *
  * Side effects:
- *        None.
+ *	None.
  *
  *----------------------------------------------------------------------
  */
 
 MODULE_SCOPE int
-TkMacOSXInitCGDrawing(interp, enable, limit)
-	Tcl_Interp *interp;
-	int enable;
-	int limit;
+TkMacOSXInitCGDrawing(
+    Tcl_Interp *interp,
+    int enable,
+    int limit)
 {
     static Boolean initialized = FALSE;
 
@@ -104,12 +107,13 @@ TkMacOSXInitCGDrawing(interp, enable, limit)
 	/*
 	 * Piggy-back the themed drawing var init here.
 	 */
+
 	if (Tcl_LinkVar(interp, "::tk::mac::useThemedToplevel",
-		    (char *) &useThemedToplevel, TCL_LINK_BOOLEAN) != TCL_OK) {
+		(char *) &useThemedToplevel, TCL_LINK_BOOLEAN) != TCL_OK) {
 	    Tcl_ResetResult(interp);
 	}
 	if (Tcl_LinkVar(interp, "::tk::mac::useThemedFrame",
-		    (char *) &useThemedFrame, TCL_LINK_BOOLEAN) != TCL_OK) {
+		(char *) &useThemedFrame, TCL_LINK_BOOLEAN) != TCL_OK) {
 	    Tcl_ResetResult(interp);
 	}
     }
@@ -121,36 +125,35 @@ TkMacOSXInitCGDrawing(interp, enable, limit)
  *
  * XCopyArea --
  *
- *        Copies data from one drawable to another using block transfer
- *        routines.
+ *	Copies data from one drawable to another using block transfer
+ *	routines.
  *
  * Results:
- *        None.
+ *	None.
  *
  * Side effects:
- *        Data is moved from a window or bitmap to a second window or
- *        bitmap.
+ *	Data is moved from a window or bitmap to a second window or bitmap.
  *
  *----------------------------------------------------------------------
  */
 
 void
 XCopyArea(
-    Display* display,                /* Display. */
-    Drawable src,                /* Source drawable. */
-    Drawable dst,                /* Destination drawable. */
-    GC gc,                        /* GC to use. */
-    int src_x,                        /* X & Y, width & height */
-    int src_y,                        /* define the source rectangle */
-    unsigned int width,                /* the will be copied. */
+    Display *display,		/* Display. */
+    Drawable src,		/* Source drawable. */
+    Drawable dst,		/* Destination drawable. */
+    GC gc,			/* GC to use. */
+    int src_x,			/* X & Y, width & height */
+    int src_y,			/* define the source rectangle */
+    unsigned int width,		/* the will be copied. */
     unsigned int height,
-    int dest_x,                        /* Dest X & Y on dest rect. */
+    int dest_x,			/* Dest X & Y on dest rect. */
     int dest_y)
 {
     Rect srcRect, dstRect;
-    Rect * srcPtr, * dstPtr;
-    const BitMap * srcBit;
-    const BitMap * dstBit;
+    Rect *srcPtr, *dstPtr;
+    const BitMap *srcBit;
+    const BitMap *dstBit;
     MacDrawable *srcDraw = (MacDrawable *) src;
     MacDrawable *dstDraw = (MacDrawable *) dst;
     CGrafPtr srcPort, dstPort;
@@ -195,20 +198,20 @@ XCopyArea(
 	    (short) (dstDraw->yOff + dest_y + height));
     }
     TkMacOSXSetUpClippingRgn(dst);
+
     /*
-     *  We will change the clip rgn in this routine, so we need to
-     *  be able to restore it when we exit.
+     * We will change the clip rgn in this routine, so we need to be able to
+     * restore it when we exit.
      */
 
     GetClip(tmpRgn2);
     if (tkPictureIsOpen) {
 	/*
-	 * When rendering into a picture, after a call to "OpenCPicture"
-	 * the clipping is seriously WRONG and also INCONSISTENT with the
-	 * clipping for single plane bitmaps.
-	 * To circumvent this problem,  we clip to the whole window
-	 * In this case, would have also clipped to the srcRect
-	 * ClipRect(&srcRect);
+	 * When rendering into a picture, after a call to "OpenCPicture" the
+	 * clipping is seriously WRONG and also INCONSISTENT with the clipping
+	 * for single plane bitmaps. To circumvent this problem, we clip to
+	 * the whole window In this case, would have also clipped to the
+	 * srcRect ClipRect(&srcRect);
 	 */
 
 	GetPortBounds(dstPort,&clpRect);
@@ -216,11 +219,12 @@ XCopyArea(
 	ClipRect(&clpRect);
     }
     if (!gc->clip_mask) {
+	/* do nothing */
     } else if (((TkpClipMask*)gc->clip_mask)->type == TKP_CLIP_REGION) {
 	RgnHandle clipRgn = (RgnHandle)
 		((TkpClipMask*)gc->clip_mask)->value.region;
-
 	int xOffset = 0, yOffset = 0;
+
 	if (tmpRgn == NULL) {
 	    tmpRgn = NewRgn();
 	}
@@ -252,39 +256,33 @@ XCopyArea(
  *
  * XCopyPlane --
  *
- *        Copies a bitmap from a source drawable to a destination
- *        drawable.  The plane argument specifies which bit plane of
- *        the source contains the bitmap.  Note that this implementation
- *        ignores the gc->function.
+ *	Copies a bitmap from a source drawable to a destination drawable. The
+ *	plane argument specifies which bit plane of the source contains the
+ *	bitmap. Note that this implementation ignores the gc->function.
  *
  * Results:
- *        None.
+ *	None.
  *
  * Side effects:
- *        Changes the destination drawable.
+ *	Changes the destination drawable.
  *
  *----------------------------------------------------------------------
  */
 
 void
 XCopyPlane(
-    Display* display,                /* Display. */
-    Drawable src,                /* Source drawable. */
-    Drawable dst,                /* Destination drawable. */
-    GC gc,                        /* The GC to use. */
-    int src_x,                        /* X, Y, width & height */
-    int src_y,                        /* define the source rect. */
-    unsigned int width,
-    unsigned int height,
-    int dest_x,                        /* X & Y on dest where we will copy. */
-    int dest_y,
-    unsigned long plane)        /* Which plane to copy. */
+    Display *display,		/* Display. */
+    Drawable src,		/* Source drawable. */
+    Drawable dst,		/* Destination drawable. */
+    GC gc,			/* The GC to use. */
+    int src_x, int src_y,	/* X, Y, width & height define the source
+				 * rect. */
+    unsigned int width, unsigned int height,
+    int dest_x, int dest_y,	/* X & Y on dest where we will copy. */
+    unsigned long plane)	/* Which plane to copy. */
 {
-    Rect srcRect, dstRect;
-    Rect * srcPtr, * dstPtr;
-    const BitMap * srcBit;
-    const BitMap * dstBit;
-    const BitMap * mskBit;
+    Rect srcRect, dstRect, *srcPtr, *dstPtr;
+    const BitMap *srcBit, *dstBit, *mskBit;
     MacDrawable *srcDraw = (MacDrawable *) src;
     MacDrawable *dstDraw = (MacDrawable *) dst;
     GWorldPtr srcPort, dstPort, mskPort;
@@ -311,10 +309,10 @@ XCopyPlane(
     srcPtr = &srcRect;
     if (tkPictureIsOpen) {
 	/*
-	 * When rendering into a picture, after a call to "OpenCPicture"
-	 * the clipping is seriously WRONG and also INCONSISTENT with the
-	 * clipping for color bitmaps.
-	 * To circumvent this problem,  we clip to the whole window
+	 * When rendering into a picture, after a call to "OpenCPicture" the
+	 * clipping is seriously WRONG and also INCONSISTENT with the clipping
+	 * for color bitmaps. To circumvent this problem, we clip to the whole
+	 * window.
 	 */
 
 	Rect clpRect;
@@ -348,8 +346,8 @@ XCopyPlane(
 	if (clipPtr->value.pixmap == src) {
 	    PixMapHandle pm;
 	    /*
-	     * Case 2: transparent bitmaps.  If it's color we ignore
-	     * the forecolor.
+	     * Case 2: transparent bitmaps. If it's color we ignore the
+	     * forecolor.
 	     */
 
 	    pm = GetPortPixMap(srcPort);
@@ -367,8 +365,8 @@ XCopyPlane(
 	    tmode = srcCopy;
 	    mskPort = TkMacOSXGetDrawablePort(clipPtr->value.pixmap);
 	    mskBit = GetPortBitMapForCopyBits(mskPort);
-	    CopyDeepMask(srcBit, mskBit, dstBit,
-		srcPtr, srcPtr, dstPtr, tmode, NULL);
+	    CopyDeepMask(srcBit, mskBit, dstBit, srcPtr, srcPtr, dstPtr,
+		    tmode, NULL);
 	}
     }
 
@@ -380,14 +378,14 @@ XCopyPlane(
  *
  * TkPutImage --
  *
- *        Copies a subimage from an in-memory image to a rectangle of
- *        of the specified drawable.
+ *	Copies a subimage from an in-memory image to a rectangle of the
+ *	specified drawable.
  *
  * Results:
- *        None.
+ *	None.
  *
  * Side effects:
- *        Draws the image on the specified drawable.
+ *	Draws the image on the specified drawable.
  *
  *----------------------------------------------------------------------
  */
@@ -430,13 +428,14 @@ TkPutImage(
     SetRect(srcPtr, src_x, src_y, src_x + width, src_y + height);
     if (tkPictureIsOpen) {
 	/*
-	 * When rendering into a picture, after a call to "OpenCPicture"
-	 * the clipping is seriously WRONG and also INCONSISTENT with the
-	 * clipping for single plane bitmaps.
-	 * To circumvent this problem,	we clip to the whole window
+	 * When rendering into a picture, after a call to "OpenCPicture" the
+	 * clipping is seriously WRONG and also INCONSISTENT with the clipping
+	 * for single plane bitmaps. To circumvent this problem, we clip to
+	 * the whole window.
 	 */
 
 	Rect clpRect;
+
 	GetPortBounds(destPort,&clpRect);
 	ClipRect(&clpRect);
 	destPtr = srcPtr;
@@ -447,14 +446,19 @@ TkPutImage(
     }
 
     if (image->obdata) {
-	/* Image from XGetImage, copy from containing GWorld directly */
+	/*
+	 * Image from XGetImage, copy from containing GWorld directly.
+	 */
+
 	GWorldPtr srcPort = TkMacOSXGetDrawablePort((Drawable)image->obdata);
+
 	CopyBits(GetPortBitMapForCopyBits(srcPort),
 		destBits, srcPtr, destPtr, srcCopy, NULL);
     } else if (image->depth == 1) {
 	/*
 	 * BW image
 	 */
+
 	const int maxRowBytes = 0x3ffe;
 	BitMap bitmap;
 	int odd;
@@ -487,7 +491,7 @@ TkPutImage(
 	    oldPtr = dataPtr;
 	    odd = sliceRowBytes % 2;
 	    if (!newData) {
-		newData = (char *) ckalloc(image->height * (sliceRowBytes+odd));
+		newData = ckalloc(image->height * (sliceRowBytes+odd));
 	    }
 	    newPtr = newData;
 	    for (i = 0; i < image->height; i++) {
@@ -512,6 +516,7 @@ TkPutImage(
 	/*
 	 * Color image
 	 */
+
 	const int maxRowBytes = 0x3ffc;
 	PixMap pixmap;
 
@@ -519,7 +524,7 @@ TkPutImage(
 	pixmap.bounds.top = 0;
 	pixmap.bounds.bottom = (short) image->height;
 	pixmap.pixelType = RGBDirect;
-	pixmap.pmVersion = baseAddr32;	      /* 32bit clean */
+	pixmap.pmVersion = baseAddr32;	/* 32bit clean */
 	pixmap.packType = 0;
 	pixmap.packSize = 0;
 	pixmap.hRes = 0x00480000;
@@ -589,23 +594,23 @@ TkPutImage(
  *
  * XDrawLines --
  *
- *        Draw connected lines.
+ *	Draw connected lines.
  *
  * Results:
- *        None.
+ *	None.
  *
  * Side effects:
- *        Renders a series of connected lines.
+ *	Renders a series of connected lines.
  *
  *----------------------------------------------------------------------
  */
 
 void
 XDrawLines(
-    Display* display,		/* Display. */
+    Display *display,		/* Display. */
     Drawable d,			/* Draw on this. */
     GC gc,			/* Use this GC. */
-    XPoint* points,		/* Array of points. */
+    XPoint *points,		/* Array of points. */
     int npoints,		/* Number of points. */
     int mode)			/* Line drawing mode. */
 {
@@ -654,15 +659,19 @@ XDrawLines(
 	TkMacOSXSetUpGraphicsPort(gc, destPort);
 	ShowPen();
 	PenPixPat(gPenPat);
-	/* This is broken for fat lines, it is not possible to correctly
-	 * imitate X11 drawing of oblique fat lines with QD line drawing,
-	 * we should draw a filled polygon instead. */
+
+	/*
+	 * This is broken for fat lines, it is not possible to correctly
+	 * imitate X11 drawing of oblique fat lines with QD line drawing, we
+	 * should draw a filled polygon instead.
+	 */
+
 	MoveTo((short) (macWin->xOff + points[0].x + o),
-	       (short) (macWin->yOff + points[0].y + o));
+		(short) (macWin->yOff + points[0].y + o));
 	for (i = 1; i < npoints; i++) {
 	    if (mode == CoordModeOrigin) {
 		LineTo((short) (macWin->xOff + points[i].x + o),
-		       (short) (macWin->yOff + points[i].y + o));
+			(short) (macWin->yOff + points[i].y + o));
 	    } else {
 		Line((short) points[i].x, (short) points[i].y);
 	    }
@@ -678,23 +687,24 @@ XDrawLines(
  *
  * XDrawSegments --
  *
- *        Draw unconnected lines.
+ *	Draw unconnected lines.
  *
  * Results:
- *        None.
+ *	None.
  *
  * Side effects:
- *        Renders a series of unconnected lines.
+ *	Renders a series of unconnected lines.
  *
  *----------------------------------------------------------------------
  */
 
-void XDrawSegments(
+void
+XDrawSegments(
     Display *display,
-    Drawable  d,
+    Drawable d,
     GC gc,
     XSegment *segments,
-    int  nsegments)
+    int nsegments)
 {
     MacDrawable *macWin = (MacDrawable *) d;
     CGrafPtr saveWorld;
@@ -730,14 +740,18 @@ void XDrawSegments(
 	TkMacOSXSetUpGraphicsPort(gc, destPort);
 	ShowPen();
 	PenPixPat(gPenPat);
-	/* This is broken for fat lines, it is not possible to correctly
-	 * imitate X11 drawing of oblique fat lines with QD line drawing,
-	 * we should draw a filled polygon instead. */
+
+	/*
+	 * This is broken for fat lines, it is not possible to correctly
+	 * imitate X11 drawing of oblique fat lines with QD line drawing, we
+	 * should draw a filled polygon instead.
+	 */
+
 	for (i = 0; i < nsegments; i++) {
 	    MoveTo((short) (macWin->xOff + segments[i].x1 + o),
-		   (short) (macWin->yOff + segments[i].y1 + o));
+		    (short) (macWin->yOff + segments[i].y1 + o));
 	    LineTo((short) (macWin->xOff + segments[i].x2 + o),
-		   (short) (macWin->yOff + segments[i].y2 + o));
+		    (short) (macWin->yOff + segments[i].y2 + o));
 	}
 	HidePen();
     }
@@ -750,13 +764,13 @@ void XDrawSegments(
  *
  * XFillPolygon --
  *
- *        Draws a filled polygon.
+ *	Draws a filled polygon.
  *
  * Results:
- *        None.
+ *	None.
  *
  * Side effects:
- *        Draws a filled polygon on the specified drawable.
+ *	Draws a filled polygon on the specified drawable.
  *
  *----------------------------------------------------------------------
  */
@@ -813,11 +827,11 @@ XFillPolygon(
 	PenNormal();
 	polygon = OpenPoly();
 	MoveTo((short) (macWin->xOff + points[0].x),
-	       (short) (macWin->yOff + points[0].y));
+		(short) (macWin->yOff + points[0].y));
 	for (i = 1; i < npoints; i++) {
 	    if (mode == CoordModeOrigin) {
 		LineTo((short) (macWin->xOff + points[i].x),
-		       (short) (macWin->yOff + points[i].y));
+			(short) (macWin->yOff + points[i].y));
 	    } else {
 		Line((short) points[i].x, (short) points[i].y);
 	    }
@@ -835,25 +849,24 @@ XFillPolygon(
  *
  * XDrawRectangle --
  *
- *        Draws a rectangle.
+ *	Draws a rectangle.
  *
  * Results:
- *        None.
+ *	None.
  *
  * Side effects:
- *        Draws a rectangle on the specified drawable.
+ *	Draws a rectangle on the specified drawable.
  *
  *----------------------------------------------------------------------
  */
 
 void
 XDrawRectangle(
-    Display* display,                /* Display. */
-    Drawable d,                        /* Draw on this. */
-    GC gc,                        /* Use this GC. */
-    int x,                        /* Upper left corner. */
-    int y,
-    unsigned int width,                /* Width & height of rect. */
+    Display *display,		/* Display. */
+    Drawable d,			/* Draw on this. */
+    GC gc,			/* Use this GC. */
+    int x, int y,		/* Upper left corner. */
+    unsigned int width,		/* Width & height of rect. */
     unsigned int height)
 {
     MacDrawable *macWin = (MacDrawable *) d;
@@ -891,10 +904,10 @@ XDrawRectangle(
 	TkMacOSXSetUpGraphicsPort(gc, destPort);
 	ShowPen();
 	PenPixPat(gPenPat);
-	theRect.left =   (short) (macWin->xOff + x + o);
-	theRect.top =    (short) (macWin->yOff + y + o);
-	theRect.right =  (short) (theRect.left + width  + lw);
-	theRect.bottom = (short) (theRect.top  + height + lw);
+	theRect.left = (short) (macWin->xOff + x + o);
+	theRect.top = (short) (macWin->yOff + y + o);
+	theRect.right = (short) (theRect.left + width + lw);
+	theRect.bottom = (short) (theRect.top + height + lw);
 	FrameRect(&theRect);
 	HidePen();
     }
@@ -908,27 +921,26 @@ XDrawRectangle(
  *
  * XDrawRectangles --
  *
- *       Draws the outlines of the specified rectangles as if a
- *       five-point PolyLine protocol request were specified for each
- *       rectangle:
+ *	Draws the outlines of the specified rectangles as if a five-point
+ *	PolyLine protocol request were specified for each rectangle:
  *
- *             [x,y] [x+width,y] [x+width,y+height] [x,y+height]
- *             [x,y]
+ *		[x,y] [x+width,y] [x+width,y+height] [x,y+height]
+ *		[x,y]
  *
- *      For the specified rectangles, these functions do not draw a
- *      pixel more than once.  XDrawRectangles draws the rectangles in
- *      the order listed in the array.  If rectangles intersect, the
- *      intersecting pixels are drawn multiple times.  Draws a
- *      rectangle.
+ *	For the specified rectangles, these functions do not draw a pixel more
+ *	than once. XDrawRectangles draws the rectangles in the order listed in
+ *	the array. If rectangles intersect, the intersecting pixels are drawn
+ *	multiple times. Draws a rectangle.
  *
  * Results:
- *        None.
+ *	None.
  *
  * Side effects:
- *        Draws rectangles on the specified drawable.
+ *	Draws rectangles on the specified drawable.
  *
  *----------------------------------------------------------------------
  */
+
 void
 XDrawRectangles(
     Display *display,
@@ -975,10 +987,10 @@ XDrawRectangles(
 	ShowPen();
 	PenPixPat(gPenPat);
 	for (i = 0, rectPtr = rectArr; i < nRects;i++, rectPtr++) {
-	    theRect.left =   (short) (macWin->xOff + rectPtr->x + o);
-	    theRect.top =    (short) (macWin->yOff + rectPtr->y + o);
-	    theRect.right =  (short) (theRect.left + rectPtr->width  + lw);
-	    theRect.bottom = (short) (theRect.top  + rectPtr->height + lw);
+	    theRect.left = (short) (macWin->xOff + rectPtr->x + o);
+	    theRect.top = (short) (macWin->yOff + rectPtr->y + o);
+	    theRect.right = (short) (theRect.left + rectPtr->width + lw);
+	    theRect.bottom = (short) (theRect.top + rectPtr->height + lw);
 	    FrameRect(&theRect);
 	}
 	HidePen();
@@ -993,23 +1005,24 @@ XDrawRectangles(
  *
  * XFillRectangles --
  *
- *        Fill multiple rectangular areas in the given drawable.
+ *	Fill multiple rectangular areas in the given drawable.
  *
  * Results:
- *        None.
+ *	None.
  *
  * Side effects:
- *        Draws onto the specified drawable.
+ *	Draws onto the specified drawable.
  *
  *----------------------------------------------------------------------
  */
+
 void
 XFillRectangles(
-    Display* display,                /* Display. */
-    Drawable d,                        /* Draw on this. */
-    GC gc,                        /* Use this GC. */
-    XRectangle *rectangles,        /* Rectangle array. */
-    int n_rectangles)                /* Number of rectangles. */
+    Display* display,		/* Display. */
+    Drawable d,			/* Draw on this. */
+    GC gc,			/* Use this GC. */
+    XRectangle *rectangles,	/* Rectangle array. */
+    int n_rectangles)		/* Number of rectangles. */
 {
     MacDrawable *macWin = (MacDrawable *) d;
     CGrafPtr saveWorld;
@@ -1033,8 +1046,7 @@ XFillRectangles(
 	    if (rectPtr->width == 0 || rectPtr->height == 0) {
 		continue;
 	    }
-	    rect = CGRectMake(
-		    macWin->xOff + rectPtr->x,
+	    rect = CGRectMake(macWin->xOff + rectPtr->x,
 		    macWin->yOff + rectPtr->y,
 		    rectPtr->width, rectPtr->height);
 	    CGContextFillRect(outContext, rect);
@@ -1045,10 +1057,10 @@ XFillRectangles(
 
 	TkMacOSXSetUpGraphicsPort(gc, destPort);
 	for (i = 0, rectPtr = rectangles; i < n_rectangles; i++, rectPtr++) {
-	    theRect.left =   (short) (macWin->xOff + rectPtr->x);
-	    theRect.top =    (short) (macWin->yOff + rectPtr->y);
-	    theRect.right =  (short) (theRect.left + rectPtr->width);
-	    theRect.bottom = (short) (theRect.top  + rectPtr->height);
+	    theRect.left = (short) (macWin->xOff + rectPtr->x);
+	    theRect.top = (short) (macWin->yOff + rectPtr->y);
+	    theRect.right = (short) (theRect.left + rectPtr->width);
+	    theRect.bottom = (short) (theRect.top + rectPtr->height);
 	    FillCRect(&theRect, gPenPat);
 	}
     }
@@ -1061,28 +1073,27 @@ XFillRectangles(
  *
  * XDrawArc --
  *
- *        Draw an arc.
+ *	Draw an arc.
  *
  * Results:
- *        None.
+ *	None.
  *
  * Side effects:
- *        Draws an arc on the specified drawable.
+ *	Draws an arc on the specified drawable.
  *
  *----------------------------------------------------------------------
  */
 
 void
 XDrawArc(
-    Display* display,                /* Display. */
-    Drawable d,                        /* Draw on this. */
-    GC gc,                        /* Use this GC. */
-    int x,                        /* Upper left of */
-    int y,                        /* bounding rect. */
-    unsigned int width,                /* Width & height. */
+    Display* display,		/* Display. */
+    Drawable d,			/* Draw on this. */
+    GC gc,			/* Use this GC. */
+    int x, int y,		/* Upper left of bounding rect. */
+    unsigned int width,		/* Width & height. */
     unsigned int height,
-    int angle1,                        /* Staring angle of arc. */
-    int angle2)                        /* Extent of arc. */
+    int angle1,			/* Staring angle of arc. */
+    int angle2)			/* Extent of arc. */
 {
     MacDrawable *macWin = (MacDrawable *) d;
     CGrafPtr saveWorld;
@@ -1142,11 +1153,11 @@ XDrawArc(
 	TkMacOSXSetUpGraphicsPort(gc, destPort);
 	ShowPen();
 	PenPixPat(gPenPat);
-	theRect.left =   (short) (macWin->xOff + x + o);
-	theRect.top =    (short) (macWin->yOff + y + o);
-	theRect.right =  (short) (theRect.left + width + lw);
+	theRect.left = (short) (macWin->xOff + x + o);
+	theRect.top = (short) (macWin->yOff + y + o);
+	theRect.right = (short) (theRect.left + width + lw);
 	theRect.bottom = (short) (theRect.top + height + lw);
-	start =  (short) (90 - (angle1/64));
+	start = (short) (90 - (angle1/64));
 	extent = (short) (-(angle2/64));
 	FrameArc(&theRect, start, extent);
 	HidePen();
@@ -1161,23 +1172,23 @@ XDrawArc(
  *
  * XDrawArcs --
  *
- *      Draws multiple circular or elliptical arcs.  Each arc is
- *      specified by a rectangle and two angles.  The center of the
- *      circle or ellipse is the center of the rect- angle, and the
- *      major and minor axes are specified by the width and height.
- *      Positive angles indicate counterclock- wise motion, and
- *      negative angles indicate clockwise motion.  If the magnitude
- *      of angle2 is greater than 360 degrees, XDrawArcs truncates it
- *      to 360 degrees.
+ *	Draws multiple circular or elliptical arcs. Each arc is specified by a
+ *	rectangle and two angles. The center of the circle or ellipse is the
+ *	center of the rectangle, and the major and minor axes are specified by
+ *	the width and height. Positive angles indicate counterclock- wise
+ *	motion, and negative angles indicate clockwise motion. If the
+ *	magnitude of angle2 is greater than 360 degrees, XDrawArcs truncates
+ *	it to 360 degrees.
  *
  * Results:
- *      None.
+ *	None.
  *
  * Side effects:
- *      Draws an arc for each array element on the specified drawable.
+ *	Draws an arc for each array element on the specified drawable.
  *
  *----------------------------------------------------------------------
  */
+
 void
 XDrawArcs(
     Display *display,
@@ -1186,12 +1197,11 @@ XDrawArcs(
     XArc *arcArr,
     int nArcs)
 {
-
     MacDrawable *macWin = (MacDrawable *) d;
     CGrafPtr saveWorld;
     GDHandle saveDevice;
     GWorldPtr destPort;
-    XArc * arcPtr;
+    XArc *arcPtr;
     int i, lw = gc->line_width;
 
     destPort = TkMacOSXGetDrawablePort(d);
@@ -1211,8 +1221,7 @@ XDrawArcs(
 		    || arcPtr->angle2 == 0) {
 		continue;
 	    }
-	    rect = CGRectMake(
-		    macWin->xOff + arcPtr->x + o,
+	    rect = CGRectMake(macWin->xOff + arcPtr->x + o,
 		    macWin->yOff + arcPtr->y + o,
 		    arcPtr->width, arcPtr->height);
 
@@ -1226,13 +1235,13 @@ XDrawArcs(
 		CGMutablePathRef p = CGPathCreateMutable();
 		CGAffineTransform t = CGAffineTransformIdentity;
 		CGPoint c = CGPointMake(CGRectGetMidX(rect),
-					CGRectGetMidY(rect));
+			CGRectGetMidY(rect));
 		float w = CGRectGetWidth(rect);
 
 		if (arcPtr->width != arcPtr->height) {
 		    t = CGAffineTransformMakeScale(1, CGRectGetHeight(rect)/w);
 		    c = CGPointApplyAffineTransform(c,
-						    CGAffineTransformInvert(t));
+			    CGAffineTransformInvert(t));
 		}
 		CGPathAddArc(p, &t, c.x, c.y, w/2,
 			radians(-arcPtr->angle1/64.0),
@@ -1253,11 +1262,11 @@ XDrawArcs(
 	ShowPen();
 	PenPixPat(gPenPat);
 	for (i = 0, arcPtr = arcArr;i < nArcs;i++, arcPtr++) {
-	    theRect.left =   (short) (macWin->xOff + arcPtr->x + o);
-	    theRect.top =    (short) (macWin->yOff + arcPtr->y + o);
-	    theRect.right =  (short) (theRect.left + arcPtr->width + lw);
+	    theRect.left = (short) (macWin->xOff + arcPtr->x + o);
+	    theRect.top = (short) (macWin->yOff + arcPtr->y + o);
+	    theRect.right = (short) (theRect.left + arcPtr->width + lw);
 	    theRect.bottom = (short) (theRect.top + arcPtr->height + lw);
-	    start =  (short) (90 - (arcPtr->angle1/64));
+	    start = (short) (90 - (arcPtr->angle1/64));
 	    extent = (short) (-(arcPtr->angle2/64));
 	    FrameArc(&theRect, start, extent);
 	}
@@ -1273,28 +1282,27 @@ XDrawArcs(
  *
  * XFillArc --
  *
- *        Draw a filled arc.
+ *	Draw a filled arc.
  *
  * Results:
- *        None.
+ *	None.
  *
  * Side effects:
- *        Draws a filled arc on the specified drawable.
+ *	Draws a filled arc on the specified drawable.
  *
  *----------------------------------------------------------------------
  */
 
 void
 XFillArc(
-    Display* display,                /* Display. */
-    Drawable d,                        /* Draw on this. */
-    GC gc,                        /* Use this GC. */
-    int x,                        /* Upper left of */
-    int y,                        /* bounding rect. */
-    unsigned int width,                /* Width & height. */
+    Display* display,		/* Display. */
+    Drawable d,			/* Draw on this. */
+    GC gc,			/* Use this GC. */
+    int x, int y,		/* Upper left of bounding rect. */
+    unsigned int width,		/* Width & height. */
     unsigned int height,
-    int angle1,                        /* Staring angle of arc. */
-    int angle2)                        /* Extent of arc. */
+    int angle1,			/* Staring angle of arc. */
+    int angle2)			/* Extent of arc. */
 {
     MacDrawable *macWin = (MacDrawable *) d;
     CGrafPtr saveWorld;
@@ -1322,9 +1330,7 @@ XFillArc(
 	    u += NON_AA_CG_OFFSET;
 	}
 	TkMacOSXSetUpCGContext(macWin, destPort, gc, &outContext);
-	rect = CGRectMake(
-		macWin->xOff + x + o,
-		macWin->yOff + y + o,
+	rect = CGRectMake(macWin->xOff + x + o, macWin->yOff + y + o,
 		width - u, height - u);
 
 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1040
@@ -1364,9 +1370,9 @@ XFillArc(
 	double vertex[2], center1[2], center2[2];
 
 	TkMacOSXSetUpGraphicsPort(gc, destPort);
-	theRect.left =   (short) (macWin->xOff + x + o);
-	theRect.top =    (short) (macWin->yOff + y + o);
-	theRect.right =  (short) (theRect.left + width + lw);
+	theRect.left = (short) (macWin->xOff + x + o);
+	theRect.top = (short) (macWin->yOff + y + o);
+	theRect.right = (short) (theRect.left + width + lw);
 	theRect.bottom = (short) (theRect.top + height + lw);
 	start = (short) (90 - (angle1/64));
 	extent = (short) (-(angle2/64));
@@ -1388,7 +1394,7 @@ XFillArc(
 
 	    polygon = OpenPoly();
 	    MoveTo((short) ((theRect.left + theRect.right)/2),
-		   (short) ((theRect.top + theRect.bottom)/2));
+		    (short) ((theRect.top + theRect.bottom)/2));
 	    LineTo((short) (center1[0] + .5), (short) (center1[1] + .5));
 	    LineTo((short) (center2[0] + .5), (short) (center2[1] + .5));
 	    ClosePoly();
@@ -1413,16 +1419,17 @@ XFillArc(
  *
  * XFillArcs --
  *
- *      Draw a filled arc.
+ *	Draw a filled arc.
  *
  * Results:
- *      None.
+ *	None.
  *
  * Side effects:
- *      Draws a filled arc for each array element on the specified drawable.
+ *	Draws a filled arc for each array element on the specified drawable.
  *
  *----------------------------------------------------------------------
  */
+
 void
 XFillArcs(
     Display *display,
@@ -1435,7 +1442,7 @@ XFillArcs(
     CGrafPtr saveWorld;
     GDHandle saveDevice;
     GWorldPtr destPort;
-    XArc * arcPtr;
+    XArc *arcPtr;
     int i, lw = gc->line_width;
 
     destPort = TkMacOSXGetDrawablePort(d);
@@ -1459,8 +1466,7 @@ XFillArcs(
 		    || arcPtr->angle2 == 0) {
 		continue;
 	    }
-	    rect = CGRectMake(
-		    macWin->xOff + arcPtr->x + o,
+	    rect = CGRectMake(macWin->xOff + arcPtr->x + o,
 		    macWin->yOff + arcPtr->y + o,
 		    arcPtr->width - u, arcPtr->height - u);
 
@@ -1474,13 +1480,13 @@ XFillArcs(
 		CGMutablePathRef p = CGPathCreateMutable();
 		CGAffineTransform t = CGAffineTransformIdentity;
 		CGPoint c = CGPointMake(CGRectGetMidX(rect),
-					CGRectGetMidY(rect));
+			CGRectGetMidY(rect));
 		float w = CGRectGetWidth(rect);
 
 		if (arcPtr->width != arcPtr->height) {
 		    t = CGAffineTransformMakeScale(1, CGRectGetHeight(rect)/w);
 		    c = CGPointApplyAffineTransform(c,
-						    CGAffineTransformInvert(t));
+			    CGAffineTransformInvert(t));
 		}
 		if (gc->arc_mode == ArcPieSlice) {
 		    CGPathMoveToPoint(p, &t, c.x, c.y);
@@ -1507,9 +1513,9 @@ XFillArcs(
 
 	TkMacOSXSetUpGraphicsPort(gc, destPort);
 	for (i = 0, arcPtr = arcArr;i<nArcs;i++, arcPtr++) {
-	    theRect.left =   (short) (macWin->xOff + arcPtr->x + o);
-	    theRect.top =    (short) (macWin->yOff + arcPtr->y + o);
-	    theRect.right =  (short) (theRect.left + arcPtr->width + lw);
+	    theRect.left = (short) (macWin->xOff + arcPtr->x + o);
+	    theRect.top = (short) (macWin->yOff + arcPtr->y + o);
+	    theRect.right = (short) (theRect.left + arcPtr->width + lw);
 	    theRect.bottom = (short) (theRect.top + arcPtr->height + lw);
 	    start = (short) (90 - (arcPtr->angle1/64));
 	    extent = (short) (- (arcPtr->angle2/64));
@@ -1532,7 +1538,7 @@ XFillArcs(
 
 		polygon = OpenPoly();
 		MoveTo((short) ((theRect.left + theRect.right)/2),
-		       (short) ((theRect.top + theRect.bottom)/2));
+			(short) ((theRect.top + theRect.bottom)/2));
 		LineTo((short) (center1[0] + .5), (short) (center1[1] + .5));
 		LineTo((short) (center2[0] + .5), (short) (center2[1] + .5));
 		ClosePoly();
@@ -1561,8 +1567,10 @@ XFillArcs(
  *
  *----------------------------------------------------------------------
  */
+
 long
-XMaxRequestSize(Display *display)
+XMaxRequestSize(
+    Display *display)
 {
     return (SHRT_MAX / 4);
 }
@@ -1573,31 +1581,28 @@ XMaxRequestSize(Display *display)
  *
  * TkScrollWindow --
  *
- *        Scroll a rectangle of the specified window and accumulate
- *        a damage region.
+ *	Scroll a rectangle of the specified window and accumulate a damage
+ *	region.
  *
  * Results:
- *        Returns 0 if the scroll genereated no additional damage.
- *        Otherwise, sets the region that needs to be repainted after
- *        scrolling and returns 1.
+ *	Returns 0 if the scroll genereated no additional damage. Otherwise,
+ *	sets the region that needs to be repainted after scrolling and returns
+ *	1.
  *
  * Side effects:
- *        Scrolls the bits in the window.
+ *	Scrolls the bits in the window.
  *
  *----------------------------------------------------------------------
  */
 
 int
 TkScrollWindow(
-    Tk_Window tkwin,                /* The window to be scrolled. */
-    GC gc,                        /* GC for window to be scrolled. */
-    int x,                        /* Position rectangle to be scrolled. */
-    int y,
-    int width,
-    int height,
-    int dx,                        /* Distance rectangle should be moved. */
-    int dy,
-    TkRegion damageRgn)                /* Region to accumulate damage in. */
+    Tk_Window tkwin,		/* The window to be scrolled. */
+    GC gc,			/* GC for window to be scrolled. */
+    int x, int y,		/* Position rectangle to be scrolled. */
+    int width, int height,
+    int dx, int dy,		/* Distance rectangle should be moved. */
+    TkRegion damageRgn)		/* Region to accumulate damage in. */
 {
     MacDrawable *destDraw = (MacDrawable *) Tk_WindowId(tkwin);
     RgnHandle rgn = (RgnHandle) damageRgn;
@@ -1613,13 +1618,12 @@ TkScrollWindow(
     TkMacOSXSetUpClippingRgn(Tk_WindowId(tkwin));
 
     /*
-     * Due to the implementation below the behavior may be differnt
-     * than X in certain cases that should never occur in Tk.  The
-     * scrollRect is the source rect extended by the offset (the union
-     * of the source rect and the offset rect).  Everything
-     * in the extended scrollRect is scrolled.  On X, it's possible
-     * to "skip" over an area if the offset makes the source and
-     * destination rects disjoint and non-aligned.
+     * Due to the implementation below the behavior may be differnt than X in
+     * certain cases that should never occur in Tk. The scrollRect is the
+     * source rect extended by the offset (the union of the source rect and
+     * the offset rect). Everything in the extended scrollRect is scrolled. On
+     * X, it's possible to "skip" over an area if the offset makes the source
+     * and destination rects disjoint and non-aligned.
      */
 
     SetRect(&srcRect, (short) (destDraw->xOff + x),
@@ -1639,9 +1643,10 @@ TkScrollWindow(
     }
 
     /*
-     * Adjust clip region so that we don't copy any windows
-     * that may overlap us.
+     * Adjust clip region so that we don't copy any windows that may overlap
+     * us.
      */
+
     visRgn = NewRgn();
     clipRgn = NewRgn();
     RectRgn(rgn, &srcRect);
@@ -1654,14 +1659,14 @@ TkScrollWindow(
     SetEmptyRgn(rgn);
 
     /*
-     * When a menu is up, the Mac does not expect drawing to occur and
-     * does not clip out the menu. We have to do it ourselves. This
-     * is pretty gross.
+     * When a menu is up, the Mac does not expect drawing to occur and does
+     * not clip out the menu. We have to do it ourselves. This is pretty
+     * gross.
      */
 
     if (tkUseMenuCascadeRgn == 1) {
-	    Point scratch = {0, 0};
-	    MacDrawable *macDraw = (MacDrawable *) Tk_WindowId(tkwin);
+	Point scratch = {0, 0};
+	MacDrawable *macDraw = (MacDrawable *) Tk_WindowId(tkwin);
 
 	LocalToGlobal(&scratch);
 	CopyRgn(tkMenuCascadeRgn, rgn);
@@ -1678,17 +1683,14 @@ TkScrollWindow(
 
     DisposeRgn(clipRgn);
     DisposeRgn(visRgn);
+
     /*
-     * Fortunantly, the region returned by ScrollRect is symanticlly
-     * the same as what we need to return in this function.  If the
-     * region is empty we return zero to denote that no damage was
-     * created.
+     * Fortunantly, the region returned by ScrollRect is symanticlly the same
+     * as what we need to return in this function. If the region is empty we
+     * return zero to denote that no damage was created.
      */
-    if (EmptyRgn(rgn)) {
-	return 0;
-    } else {
-	return 1;
-    }
+
+    return !EmptyRgn(rgn);
 }
 
 /*
@@ -1696,13 +1698,13 @@ TkScrollWindow(
  *
  * TkMacOSXSetUpGraphicsPort --
  *
- *        Set up the graphics port from the given GC.
+ *	Set up the graphics port from the given GC.
  *
  * Results:
- *        None.
+ *	None.
  *
  * Side effects:
- *        The current port is adjusted.
+ *	The current port is adjusted.
  *
  *----------------------------------------------------------------------
  */
@@ -1710,7 +1712,7 @@ TkScrollWindow(
 void
 TkMacOSXSetUpGraphicsPort(
     GC gc,
-    GWorldPtr destPort)                /* GC to apply to current port. */
+    GWorldPtr destPort)		/* GC to apply to current port. */
 {
     RGBColor macColor;
 
@@ -1719,12 +1721,15 @@ TkMacOSXSetUpGraphicsPort(
     }
 
     if (TkSetMacColor(gc->foreground, &macColor) == true) {
-	/* TODO: cache RGBPats for preformace - measure gains...  */
+	/*
+	 * TODO: cache RGBPats for preformace - measure gains...
+	 */
+
 	MakeRGBPat(gPenPat, &macColor);
     }
 
     PenNormal();
-    if(gc->function == GXxor) {
+    if (gc->function == GXxor) {
 	PenMode(patXor);
     }
     if (gc->line_width > 1) {
@@ -1732,26 +1737,26 @@ TkMacOSXSetUpGraphicsPort(
     }
     if (gc->line_style != LineSolid) {
 	/*
-	 * Here the dash pattern should be set in the drawing,
-	 * environment, but I don't know how to do that for the Mac.
+	 * Here the dash pattern should be set in the drawing environment, but
+	 * I don't know how to do that for the Mac.
 	 *
-	 * p[] is an array of unsigned chars containing the dash list.
-	 * A '\0' indicates the end of this list.
+	 * p[] is an array of unsigned chars containing the dash list. A '\0'
+	 * indicates the end of this list.
 	 *
-	 * Someone knows how to implement this? If you have a more
-	 * complete implementation of SetUpGraphicsPort() for
-	 * the Mac (or for Windows), please let me know.
+	 * Someone knows how to implement this? If you have a more complete
+	 * implementation of SetUpGraphicsPort() for the Mac (or for Windows),
+	 * please let me know.
 	 *
-	 *        Jan Nijtmans
-	 *        CMG Arnhem, B.V.
-	 *        email: j.nijtmans@chello.nl (private)
-	 *               jan.nijtmans@cmg.nl (work)
-	 *        url:   http://purl.oclc.org/net/nijtmans/
+	 *	Jan Nijtmans
+	 *	CMG Arnhem, B.V.
+	 *	email: j.nijtmans@chello.nl (private)
+	 *	       jan.nijtmans@cmg.nl (work)
+	 *	url:   http://purl.oclc.org/net/nijtmans/
 	 *
 	 * FIXME:
-	 * This is not possible with QuickDraw line drawing.  As of
-	 * Tk 8.4.7 we have a complete set of drawing routines using
-	 * CG, so there is no reason to support this here.
+	 * This is not possible with QuickDraw line drawing. As of Tk 8.4.7 we
+	 * have a complete set of drawing routines using CG, so there is no
+	 * reason to support this here.
 	 */
     }
 }
@@ -1761,13 +1766,13 @@ TkMacOSXSetUpGraphicsPort(
  *
  * TkMacOSXSetUpCGContext --
  *
- *        Set up a CGContext for the given graphics port.
+ *	Set up a CGContext for the given graphics port.
  *
  * Results:
- *        None.
+ *	None.
  *
  * Side effects:
- *        None.
+ *	None.
  *
  *----------------------------------------------------------------------
  */
@@ -1791,13 +1796,13 @@ TkMacOSXSetUpCGContext(
     outContext = *contextPtr;
 
     /*
-     * Now clip the CG Context to the port.  Note, we have already
-     * set up the port with our clip region, so we can just get
-     * the clip back out of there.  If we use the macWin->clipRgn
-     * directly at this point, we get some odd drawing effects.
+     * Now clip the CG Context to the port. Note, we have already set up the
+     * port with our clip region, so we can just get the clip back out of
+     * there. If we use the macWin->clipRgn directly at this point, we get
+     * some odd drawing effects.
      *
-     * We also have to intersect our clip region with the port
-     * visible region so we don't overwrite the window decoration.
+     * We also have to intersect our clip region with the port visible region
+     * so we don't overwrite the window decoration.
      */
 
     if (!clipRgn) {
@@ -1813,8 +1818,8 @@ TkMacOSXSetUpCGContext(
     SetEmptyRgn(clipRgn);
 
     /*
-     * Note: You have to call SyncCGContextOriginWithPort
-     * AFTER all the clip region manipulations.
+     * Note: You have to call SyncCGContextOriginWithPort AFTER all the clip
+     * region manipulations.
      */
 
     SyncCGContextOriginWithPort(outContext, destPort);
@@ -1823,28 +1828,32 @@ TkMacOSXSetUpCGContext(
 	    boundsRect.bottom - boundsRect.top);
     CGContextConcatCTM(outContext, coordsTransform);
 
-    /* Now offset the CTM to the subwindow offset */
+    /*
+     * Now offset the CTM to the subwindow offset.
+     */
 
     if (TkSetMacColor(gc->foreground, &macColor) == true) {
-	CGContextSetRGBFillColor(outContext,
-		RGBFLOATRED(macColor),
-		RGBFLOATGREEN(macColor),
-		RGBFLOATBLUE(macColor),
-		1);
-	CGContextSetRGBStrokeColor(outContext,
-		RGBFLOATRED(macColor),
-		RGBFLOATGREEN(macColor),
-		RGBFLOATBLUE(macColor),
-		1);
+	CGContextSetRGBFillColor(outContext, RGBFLOATRED(macColor),
+		RGBFLOATGREEN(macColor), RGBFLOATBLUE(macColor), 1);
+	CGContextSetRGBStrokeColor(outContext, RGBFLOATRED(macColor),
+		RGBFLOATGREEN(macColor), RGBFLOATBLUE(macColor), 1);
     }
 
-    if(gc->function == GXxor) {
+    if (gc->function == GXxor) {
+	/* empty */
     }
 
     w = gc->line_width;
-    /* When should we antialias? */
+
+    /*
+     * When should we antialias?
+     */
+
     if (notAA(gc->line_width)) {
-	/* Make non-antialiased CG drawing look more like X11 */
+	/*
+	 * Make non-antialiased CG drawing look more like X11.
+	 */
+
 	w -= (gc->line_width ? NON_AA_CG_OFFSET : 0);
 	CGContextSetShouldAntialias(outContext, 0);
     } else {
@@ -1867,7 +1876,7 @@ TkMacOSXSetUpCGContext(
 
     if (gc->cap_style == CapButt) {
 	/*
-	 *  What about CapNotLast, CapProjecting?
+	 * What about CapNotLast, CapProjecting?
 	 */
 
 	CGContextSetLineCap(outContext, kCGLineCapButt);
@@ -1891,22 +1900,22 @@ TkMacOSXSetUpCGContext(
  *
  * TkMacOSXReleaseCGContext --
  *
- *        Release the CGContext for the given graphics port.
+ *	Release the CGContext for the given graphics port.
  *
  * Results:
- *        None.
+ *	None.
  *
  * Side effects:
- *        None.
+ *	None.
  *
  *----------------------------------------------------------------------
  */
 
 static void
 TkMacOSXReleaseCGContext(
-	MacDrawable *macWin,
-	CGrafPtr destPort,
-	CGContextRef *outContext)
+    MacDrawable *macWin,
+    CGrafPtr destPort,
+    CGContextRef *outContext)
 {
     CGContextSynchronize(*outContext);
     QDEndCGContext(destPort, outContext);
@@ -1917,21 +1926,21 @@ TkMacOSXReleaseCGContext(
  *
  * TkMacOSXSetUpClippingRgn --
  *
- *        Set up the clipping region so that drawing only occurs on the
- *        specified X subwindow.
+ *	Set up the clipping region so that drawing only occurs on the
+ *	specified X subwindow.
  *
  * Results:
- *        None.
+ *	None.
  *
  * Side effects:
- *        The clipping region in the current port is changed.
+ *	The clipping region in the current port is changed.
  *
  *----------------------------------------------------------------------
  */
 
 void
 TkMacOSXSetUpClippingRgn(
-    Drawable drawable)                /* Drawable to update. */
+    Drawable drawable)		/* Drawable to update. */
 {
     MacDrawable *macDraw = (MacDrawable *) drawable;
 
@@ -1942,40 +1951,44 @@ TkMacOSXSetUpClippingRgn(
 
 #if defined(TK_MAC_DEBUG) && defined(TK_MAC_DEBUG_DRAWING)
 	TkMacOSXInitNamedDebugSymbol(HIToolbox, int, QDDebugFlashRegion,
-				     CGrafPtr port, RgnHandle region);
+		CGrafPtr port, RgnHandle region);
 	if (QDDebugFlashRegion) {
 	    CGrafPtr grafPtr = TkMacOSXGetDrawablePort(drawable);
-	    /* Carbon-internal region flashing SPI (c.f. Technote 2124) */
+
+	    /*
+	     * Carbon-internal region flashing SPI (c.f. Technote 2124)
+	     */
+
 	    QDDebugFlashRegion(grafPtr, macDraw->clipRgn);
 	}
 #endif /* TK_MAC_DEBUG_DRAWING */
 
 	/*
 	 * When a menu is up, the Mac does not expect drawing to occur and
-	 * does not clip out the menu. We have to do it ourselves. This
-	 * is pretty gross.
+	 * does not clip out the menu. We have to do it ourselves. This is
+	 * pretty gross.
 	 */
 
 	if (macDraw->clipRgn != NULL) {
 	    if (tkUseMenuCascadeRgn == 1) {
-		    Point scratch = {0, 0};
-		    GDHandle saveDevice;
-		    GWorldPtr saveWorld;
-
-		    GetGWorld(&saveWorld, &saveDevice);
-		    SetGWorld(TkMacOSXGetDrawablePort(drawable), NULL);
-		    LocalToGlobal(&scratch);
-		    SetGWorld(saveWorld, saveDevice);
-		    if (tmpRgn == NULL) {
-			tmpRgn = NewRgn();
-		    }
-		    CopyRgn(tkMenuCascadeRgn, tmpRgn);
-		    OffsetRgn(tmpRgn, -scratch.h, -scratch.v);
-		    DiffRgn(macDraw->clipRgn, tmpRgn, tmpRgn);
-		    SetClip(tmpRgn);
-		    macDraw->toplevel->flags |= TK_DRAWN_UNDER_MENU;
+		Point scratch = {0, 0};
+		GDHandle saveDevice;
+		GWorldPtr saveWorld;
+
+		GetGWorld(&saveWorld, &saveDevice);
+		SetGWorld(TkMacOSXGetDrawablePort(drawable), NULL);
+		LocalToGlobal(&scratch);
+		SetGWorld(saveWorld, saveDevice);
+		if (tmpRgn == NULL) {
+		    tmpRgn = NewRgn();
+		}
+		CopyRgn(tkMenuCascadeRgn, tmpRgn);
+		OffsetRgn(tmpRgn, -scratch.h, -scratch.v);
+		DiffRgn(macDraw->clipRgn, tmpRgn, tmpRgn);
+		SetClip(tmpRgn);
+		macDraw->toplevel->flags |= TK_DRAWN_UNDER_MENU;
 	    } else {
-		    SetClip(macDraw->clipRgn);
+		SetClip(macDraw->clipRgn);
 	    }
 	}
     }
@@ -1986,31 +1999,29 @@ TkMacOSXSetUpClippingRgn(
  *
  * TkMacOSXMakeStippleMap --
  *
- *        Given a drawable and a stipple pattern this function draws the
- *        pattern repeatedly over the drawable.  The drawable can then
- *        be used as a mask for bit-bliting a stipple pattern over an
- *        object.
+ *	Given a drawable and a stipple pattern this function draws the pattern
+ *	repeatedly over the drawable. The drawable can then be used as a mask
+ *	for bit-bliting a stipple pattern over an object.
  *
  * Results:
- *        A BitMap data structure.
+ *	A BitMap data structure.
  *
  * Side effects:
- *        None.
+ *	None.
  *
  *----------------------------------------------------------------------
  */
 
 BitMapPtr
 TkMacOSXMakeStippleMap(
-    Drawable drawable,                /* Window to apply stipple. */
-    Drawable stipple)                /* The stipple pattern. */
+    Drawable drawable,		/* Window to apply stipple. */
+    Drawable stipple)		/* The stipple pattern. */
 {
     GWorldPtr destPort;
     BitMapPtr bitmapPtr;
-    Rect      portRect;
-    int width, height, stippleHeight, stippleWidth;
-    int i, j;
-    char * data;
+    Rect portRect;
+    int width, height, stippleHeight, stippleWidth, i, j;
+    char *data;
     Rect bounds;
 
     destPort = TkMacOSXGetDrawablePort(drawable);
@@ -2039,7 +2050,7 @@ TkMacOSXMakeStippleMap(
 	    bounds.bottom = i + stippleHeight;
 
 	    CopyBits(GetPortBitMapForCopyBits(destPort), bitmapPtr,
-		&portRect, &bounds, srcCopy, NULL);
+		    &portRect, &bounds, srcCopy, NULL);
 	}
     }
     return bitmapPtr;
@@ -2050,20 +2061,20 @@ TkMacOSXMakeStippleMap(
  *
  * InvertByte --
  *
- *      This function reverses the bits in the passed in Byte of data.
+ *	This function reverses the bits in the passed in Byte of data.
  *
  * Results:
- *      The incoming byte in reverse bit order.
+ *	The incoming byte in reverse bit order.
  *
  * Side effects:
- *      None.
+ *	None.
  *
  *----------------------------------------------------------------------
  */
 
 static unsigned char
 InvertByte(
-    unsigned char data)                /* Byte of data. */
+    unsigned char data)		/* Byte of data. */
 {
     unsigned char i;
     unsigned char mask = 1, result = 0;
@@ -2082,32 +2093,32 @@ InvertByte(
  *
  * TkpDrawHighlightBorder --
  *
- *        This procedure draws a rectangular ring around the outside of
- *        a widget to indicate that it has received the input focus.
+ *	This procedure draws a rectangular ring around the outside of a widget
+ *	to indicate that it has received the input focus.
  *
- *      On the Macintosh, this puts a 1 pixel border in the bgGC color
- *      between the widget and the focus ring, except in the case where
- *      highlightWidth is 1, in which case the border is left out.
+ *	On the Macintosh, this puts a 1 pixel border in the bgGC color between
+ *	the widget and the focus ring, except in the case where highlightWidth
+ *	is 1, in which case the border is left out.
  *
- *      For proper Mac L&F, use highlightWidth of 3.
+ *	For proper Mac L&F, use highlightWidth of 3.
  *
  * Results:
- *        None.
+ *	None.
  *
  * Side effects:
- *        A rectangle "width" pixels wide is drawn in "drawable",
- *        corresponding to the outer area of "tkwin".
+ *	A rectangle "width" pixels wide is drawn in "drawable", corresponding
+ *	to the outer area of "tkwin".
  *
  *----------------------------------------------------------------------
  */
 
 void
 TkpDrawHighlightBorder (
-	Tk_Window tkwin,
-	GC fgGC,
-	GC bgGC,
-	int highlightWidth,
-	Drawable drawable)
+    Tk_Window tkwin,
+    GC fgGC,
+    GC bgGC,
+    int highlightWidth,
+    Drawable drawable)
 {
     if (highlightWidth == 1) {
 	TkDrawInsetFocusHighlight (tkwin, fgGC, highlightWidth, drawable, 0);
@@ -2125,8 +2136,8 @@ TkpDrawHighlightBorder (
  *
  * TkpDrawFrame --
  *
- *	This procedure draws the rectangular frame area.  If the user
- *	has request themeing, it draws with a the background theme.
+ *	This procedure draws the rectangular frame area. If the user has
+ *	request themeing, it draws with a the background theme.
  *
  * Results:
  *	None.
@@ -2138,15 +2149,20 @@ TkpDrawHighlightBorder (
  */
 
 void
-TkpDrawFrame (Tk_Window tkwin, Tk_3DBorder border,
-	int highlightWidth, int borderWidth, int relief)
+TkpDrawFrame(
+    Tk_Window tkwin,
+    Tk_3DBorder border,
+    int highlightWidth,
+    int borderWidth,
+    int relief)
 {
     if (useThemedToplevel && Tk_IsTopLevel(tkwin)) {
 	/*
-	 * Currently only support themed toplevels, until we can better
-	 * factor this to handle individual windows (blanket theming of
-	 * frames will work for very few UIs).
+	 * Currently only support themed toplevels, until we can better factor
+	 * this to handle individual windows (blanket theming of frames will
+	 * work for very few UIs).
 	 */
+
 	Rect bounds;
 	Point origin;
 	CGrafPtr saveWorld;
@@ -2175,15 +2191,21 @@ TkpDrawFrame (Tk_Window tkwin, Tk_3DBorder border,
 	EraseRect(&bounds);
 	SetGWorld(saveWorld, saveDevice);
 
-	XCopyArea(display, pixmap, Tk_WindowId(tkwin),
-		gc, 0, 0, bounds.right, bounds.bottom, 0, 0);
+	XCopyArea(display, pixmap, Tk_WindowId(tkwin), gc, 0, 0, bounds.right,
+		bounds.bottom, 0, 0);
 	Tk_FreePixmap(display, pixmap);
 	Tk_FreeGC(display, gc);
     } else {
-	Tk_Fill3DRectangle(tkwin, Tk_WindowId(tkwin),
-		border, highlightWidth, highlightWidth,
-		Tk_Width(tkwin) - 2 * highlightWidth,
-		Tk_Height(tkwin) - 2 * highlightWidth,
-		borderWidth, relief);
+	Tk_Fill3DRectangle(tkwin, Tk_WindowId(tkwin), border, highlightWidth,
+		highlightWidth, Tk_Width(tkwin) - 2 * highlightWidth,
+		Tk_Height(tkwin) - 2 * highlightWidth, borderWidth, relief);
     }
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */