* changes: updates for 8.4.14 release.

	* macosx/tkMacOSXDraw.c: fix numerous issues in CG and QD drawing procs
	so that they now match X11 drawing much more closely [Bug 1558051];
	use Tiger ellipse drawing API when available; fix comments & whitespace.

	* macosx/tkMacOSXInit.c: set default linewidth limit for CG
	antialiasing to 0 as thin horizontal/vertical lines look good now.

	* generic/tkCanvLine.c (ConfigureLine):     on TkAqua, pass outline
	* generic/tkCanvPoly.c (ConfigurePolygon):  linewidth in gc even for
	* generic/tkRectOval.c (ConfigureRectOval): fills (as it controls AA).

7 files changed, 581 insertions, 561 deletions

diff --git a/ChangeLog b/ChangeLog
index 618e923..2f152b4 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,7 +1,22 @@
-2006-10-10  Don Porter  <dgp@users.sourceforge.net>
+2006-10-16  Daniel Steffen  <das@users.sourceforge.net>
 
 	*** 8.4.14 TAGGED FOR RELEASE ***
 
+	* changes: updates for 8.4.14 release.
+
+	* macosx/tkMacOSXDraw.c: fix numerous issues in CG and QD drawing procs
+	so that they now match X11 drawing much more closely [Bug 1558051];
+	use Tiger ellipse drawing API when available; fix comments & whitespace.
+
+	* macosx/tkMacOSXInit.c: set default linewidth limit for CG
+	antialiasing to 0 as thin horizontal/vertical lines look good now.
+
+	* generic/tkCanvLine.c (ConfigureLine):     on TkAqua, pass outline
+	* generic/tkCanvPoly.c (ConfigurePolygon):  linewidth in gc even for
+	* generic/tkRectOval.c (ConfigureRectOval): fills (as it controls AA).
+
+2006-10-10  Don Porter  <dgp@users.sourceforge.net>
+
 	* changes:		changes updated for 8.4.14 release.
 
 2006-10-05  Jeff Hobbs  <jeffh@ActiveState.com>
diff --git a/changes b/changes
index 137371e..d946c4c 100644
--- a/changes
+++ b/changes
@@ -2,7 +2,7 @@ This file summarizes all changes made to Tk since version 1.0 was
 released on March 13, 1991.  Changes that aren't backward compatible
 are marked specially.
 
-RCS: @(#) $Id: changes,v 1.64.2.43 2006/10/10 19:19:32 dgp Exp $
+RCS: @(#) $Id: changes,v 1.64.2.44 2006/10/16 15:35:50 das Exp $
 
 3/16/91 (bug fix) Modified tkWindow.c to remove Tk's Tcl commands from
 the interpreter when the main window is deleted (otherwise there will
@@ -5979,10 +5979,18 @@ registered applevents (steffen)
 
 2006-08-21 (bug fix) Aqua: recursively called event loop (steffen)
 
+2006-08-24 (bug fix) Aqua: window grow icon obscuring scrollbar (steffen)
+
 2006-08-30 (new feature)[1518677] WM_UNICHAR window message (hobbs,petasis)
 
 2006-09-06 (bug fix)[1456342] speedier [text] delete (hobbs)
 
+2006-09-10 (bug fix) Aqua: active/inactive text selection color&relief (steffen)
+
+2006-09-10 (bug fix)[1472624] Aqua: mouse events in overrideredir wins (steffen)
+
+2006-09-11 (bug fix) Aqua: app menu shortcuts with custom .apple menu (steffen)
+
 2006-09-22 (bug fix)[1562528] NULL terminates variadic calls (fellows,ryazanov)
 
 2006-09-26 (platform support) MSVC8 AMD64 support (thoyts)
@@ -5990,4 +5998,6 @@ registered applevents (steffen)
 2006-10-05 (bug fix)[1122671] alignment fixes in ucs-2be encoding routines
 (hobbs,staplin)
 
+2006-10-16 (bug fix)[1558051] Aqua: CG drawing matches X11 (steffen)
+
 --- Released 8.4.14, October XX, 2006 --- See ChangeLog for details ---
diff --git a/generic/tkCanvLine.c b/generic/tkCanvLine.c
index e868ae6..dfa25c5 100644
--- a/generic/tkCanvLine.c
+++ b/generic/tkCanvLine.c
@@ -10,7 +10,7 @@
  * See the file "license.terms" for information on usage and redistribution
  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkCanvLine.c,v 1.13.2.1 2005/08/11 12:17:09 dkf Exp $
+ * RCS: @(#) $Id: tkCanvLine.c,v 1.13.2.2 2006/10/16 15:35:50 das Exp $
  */
 
 #include <stdio.h>
@@ -535,7 +535,15 @@ ConfigureLine(interp, canvas, itemPtr, objc, objv, flags)
 	gcValues.join_style = linePtr->joinStyle;
 	mask |= GCJoinStyle;
 	newGC = Tk_GetGC(tkwin, mask, &gcValues);
+#ifdef MAC_OSX_TK
+	/*
+	 * Mac OS X CG drawing needs access to linewidth even for 
+	 * arrow fills (as linewidth controls antialiasing).
+	 */
+	mask |= GCLineWidth;
+#else
 	gcValues.line_width = 0;
+#endif
 	arrowGC = Tk_GetGC(tkwin, mask, &gcValues);
     } else {
 	newGC = arrowGC = None;
diff --git a/generic/tkCanvPoly.c b/generic/tkCanvPoly.c
index 6831a5d..798576b 100644
--- a/generic/tkCanvPoly.c
+++ b/generic/tkCanvPoly.c
@@ -10,7 +10,7 @@
  * See the file "license.terms" for information on usage and redistribution
  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkCanvPoly.c,v 1.10.2.2 2005/08/11 12:17:09 dkf Exp $
+ * RCS: @(#) $Id: tkCanvPoly.c,v 1.10.2.3 2006/10/16 15:35:50 das Exp $
  */
 
 #include <stdio.h>
@@ -529,6 +529,15 @@ ConfigurePolygon(interp, canvas, itemPtr, objc, objv, flags)
 	    gcValues.fill_style = FillStippled;
 	    mask |= GCStipple|GCFillStyle;
 	}
+#ifdef MAC_OSX_TK
+	/*
+	 * Mac OS X CG drawing needs access to the outline linewidth
+	 * even for fills (as linewidth controls antialiasing).
+	 */
+	gcValues.line_width = polyPtr->outline.gc != None ? 
+		polyPtr->outline.gc->line_width : 0;
+	mask |= GCLineWidth;
+#endif
 	newGC = Tk_GetGC(tkwin, mask, &gcValues);
     }
     if (polyPtr->fillGC != None) {
diff --git a/generic/tkRectOval.c b/generic/tkRectOval.c
index 636b4ba..3a173a9 100644
--- a/generic/tkRectOval.c
+++ b/generic/tkRectOval.c
@@ -10,7 +10,7 @@
  * See the file "license.terms" for information on usage and redistribution
  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkRectOval.c,v 1.10.2.1 2004/07/27 18:58:33 das Exp $
+ * RCS: @(#) $Id: tkRectOval.c,v 1.10.2.2 2006/10/16 15:35:50 das Exp $
  */
 
 #include <stdio.h>
@@ -514,6 +514,15 @@ ConfigureRectOval(interp, canvas, itemPtr, objc, objv, flags)
 	} else {
 	    mask = GCForeground;
 	}
+#ifdef MAC_OSX_TK
+	/*
+	 * Mac OS X CG drawing needs access to the outline linewidth
+	 * even for fills (as linewidth controls antialiasing).
+	 */
+	gcValues.line_width = rectOvalPtr->outline.gc != None ?
+		rectOvalPtr->outline.gc->line_width : 0;
+	mask |= GCLineWidth;
+#endif
 	newGC = Tk_GetGC(tkwin, mask, &gcValues);
     }
     if (rectOvalPtr->fillGC != None) {
diff --git a/macosx/tkMacOSXDraw.c b/macosx/tkMacOSXDraw.c
index befcd5e..0094f84 100644
--- a/macosx/tkMacOSXDraw.c
+++ b/macosx/tkMacOSXDraw.c
@@ -12,7 +12,7 @@
  * 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.2.2.17 2006/06/14 21:20:12 das Exp $
+ * RCS: @(#) $Id: tkMacOSXDraw.c,v 1.2.2.18 2006/10/16 15:35:50 das Exp $
  */
 
 #include "tkMacOSXInt.h"
@@ -26,12 +26,16 @@
 #endif
 */
 
-#ifndef PI
-#    define PI 3.14159265358979323846
-#endif
-#define RGBFLOATRED(c)   (float)((float)(c.red)   / 65535.0f)
-#define RGBFLOATGREEN(c) (float)((float)(c.green) / 65535.0f)
-#define RGBFLOATBLUE(c)  (float)((float)(c.blue)  / 65535.0f)
+#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))
+
+/*
+ * 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
 
 /*
  * Temporary regions that can be reused.
@@ -39,11 +43,11 @@
 
 static RgnHandle tmpRgn = NULL;
 static RgnHandle tmpRgn2 = NULL;
-
 static PixPatHandle gPenPat = NULL;
 
 static int useCGDrawing = 1;
-static int tkMacOSXCGAntiAliasLimit = 1;
+static int tkMacOSXCGAntiAliasLimit = 0;
+#define notAA(w) ((w) < tkMacOSXCGAntiAliasLimit)
 
 static int useThemedToplevel = 0;
 static int useThemedFrame = 0;
@@ -51,13 +55,27 @@ static int useThemedFrame = 0;
 /*
  * Prototypes for functions used only in this file.
  */
-static unsigned char    InvertByte _ANSI_ARGS_((unsigned char data));
-
-static void TkMacOSXSetUpCGContext(MacDrawable *macWin,
-	CGrafPtr destPort, GC gc,  CGContextRef *contextPtr);
+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 inline double radians(double degrees) { return degrees * PI / 180.0f; }
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkMacOSXInitCGDrawing --
+ *
+ *        Initializes link vars that control CG drawing.
+ *
+ * Results:
+ *        None.
+ *
+ * Side effects:
+ *        None.
+ *
+ *----------------------------------------------------------------------
+ */
 
 MODULE_SCOPE int 
 TkMacOSXInitCGDrawing(interp, enable, limit)
@@ -284,7 +302,6 @@ XCopyPlane(
     display->request++;
     GetGWorld(&saveWorld, &saveDevice);
     SetGWorld(dstPort, NULL);
-
     TkMacOSXSetUpClippingRgn(dst);
 
     srcBit = GetPortBitMapForCopyBits(srcPort);
@@ -472,7 +489,7 @@ TkPutImage(
 	    oldPtr = dataPtr;
 	    odd = sliceRowBytes % 2;
 	    if (!newData) {
-		newData = (char *) ckalloc(image->height * (sliceRowBytes + odd));
+		newData = (char *) ckalloc(image->height * (sliceRowBytes+odd));
 	    }
 	    newPtr = newData;
 	    for (i = 0; i < image->height; i++) {
@@ -547,7 +564,8 @@ TkPutImage(
 		}
 		pixmap.baseAddr = newData;
 		pixmap.rowBytes = sliceRowBytes | 0x8000;
-		CopyBits((BitMap *) &pixmap, destBits, srcPtr, destPtr, srcCopy, NULL);
+		CopyBits((BitMap *) &pixmap, destBits, srcPtr, destPtr,
+			srcCopy, NULL);
 		if (slices) {
 		    pixmap.bounds.left = pixmap.bounds.right;
 		    dataPtr += sliceRowBytes;
@@ -557,78 +575,13 @@ TkPutImage(
 	    pixmap.bounds.right = (short) image->width;
 	    pixmap.baseAddr = image->data;
 	    pixmap.rowBytes = rowBytes | 0x8000;
-	    CopyBits((BitMap *) &pixmap, destBits, srcPtr, destPtr, srcCopy, NULL);
+	    CopyBits((BitMap *) &pixmap, destBits, srcPtr, destPtr,
+		    srcCopy, NULL);
 	}
     }
     if (newData != NULL) {
 	ckfree(newData);
     }
-    SetGWorld(saveWorld, saveDevice);
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * XFillRectangles --
- *
- *        Fill multiple rectangular areas in the given drawable.
- *
- * Results:
- *        None.
- *
- * Side effects:
- *        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. */
-{
-    MacDrawable *macWin = (MacDrawable *) d;
-    CGrafPtr saveWorld;
-    GDHandle saveDevice;
-    GWorldPtr destPort;
-    Rect theRect;
-    int i;
-
-    destPort = TkMacOSXGetDrawablePort(d);
-
-    display->request++;
-    GetGWorld(&saveWorld, &saveDevice);
-    SetGWorld(destPort, NULL);
-
-    TkMacOSXSetUpClippingRgn(d);
-    if (useCGDrawing) {
-        CGContextRef outContext;
-	CGRect	rect;
-        
-        TkMacOSXSetUpCGContext(macWin, destPort, gc, &outContext);
-
-	for (i = 0; i < n_rectangles; i++) {
-	    rect = CGRectMake((float)(macWin->xOff + rectangles[i].x),
-				(float)(macWin->yOff + rectangles[i].y),
-				(float)rectangles[i].width,
-				(float)rectangles[i].height);
-	    
-	    CGContextFillRect(outContext, rect);
-	}
-        TkMacOSXReleaseCGContext(macWin, destPort, &outContext);
-    } else {
-        TkMacOSXSetUpGraphicsPort(gc, destPort);
-
-	for (i = 0; i < n_rectangles; i++) {
-            theRect.left = (short) (macWin->xOff + rectangles[i].x);
-            theRect.top = (short) (macWin->yOff + rectangles[i].y);
-            theRect.right = (short) (theRect.left + rectangles[i].width);
-            theRect.bottom = (short) (theRect.top + rectangles[i].height);
-            FillCRect(&theRect, gPenPat);
-        }
-    }
 
     SetGWorld(saveWorld, saveDevice);
 }
@@ -662,64 +615,63 @@ XDrawLines(
     CGrafPtr saveWorld;
     GWorldPtr destPort;
     GDHandle saveDevice;
-    int i;
-
-    destPort = TkMacOSXGetDrawablePort(d);
+    int i, lw = gc->line_width;
 
-    display->request++;
     if (npoints < 2) {
 	return;	 /* TODO: generate BadValue error. */
     }
+
+    destPort = TkMacOSXGetDrawablePort(d);
+    display->request++;
     GetGWorld(&saveWorld, &saveDevice);
     SetGWorld(destPort, NULL);
-
     TkMacOSXSetUpClippingRgn(d);
 
     if (useCGDrawing) {
 	CGContextRef outContext;
 	float prevx, prevy;
+	float o = (lw % 2) ? .5 : 0;
 
 	TkMacOSXSetUpCGContext(macWin, destPort, gc, &outContext);
-
 	CGContextBeginPath(outContext);
-	prevx = (float) (macWin->xOff + points[0].x);
-	prevy = (float) (macWin->yOff + points[0].y);
+	prevx = macWin->xOff + points[0].x + o;
+	prevy = macWin->yOff + points[0].y + o;
 	CGContextMoveToPoint(outContext, prevx, prevy);
-
 	for (i = 1; i < npoints; i++) {
 	    if (mode == CoordModeOrigin) {
 		CGContextAddLineToPoint(outContext,
-			(float) (macWin->xOff + points[i].x),
-			(float) (macWin->yOff + points[i].y));
+			macWin->xOff + points[i].x + o,
+			macWin->yOff + points[i].y + o);
 	    } else {
-		prevx += (float) points[i].x;
-		prevy += (float) points[i].y;
+		prevx += points[i].x;
+		prevy += points[i].y;
 		CGContextAddLineToPoint(outContext, prevx, prevy);
 	    }
 	}
-
 	CGContextStrokePath(outContext);
 	TkMacOSXReleaseCGContext(macWin, destPort, &outContext);
     } else {
-	TkMacOSXSetUpGraphicsPort(gc, destPort);
+	int o = - (lw / 2);
 
+	TkMacOSXSetUpGraphicsPort(gc, destPort);
 	ShowPen();
-
 	PenPixPat(gPenPat);
-	MoveTo((short) (macWin->xOff + points[0].x),
-		(short) (macWin->yOff + points[0].y));
+	/* 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));
 	for (i = 1; i < npoints; i++) {
 	    if (mode == CoordModeOrigin) {
-		LineTo((short) (macWin->xOff + points[i].x),
-			(short) (macWin->yOff + points[i].y));
+		LineTo((short) (macWin->xOff + points[i].x + o),
+		       (short) (macWin->yOff + points[i].y + o));
 	    } else {
-		Line((short) (macWin->xOff + points[i].x),
-			(short) (macWin->yOff + points[i].y));
+		Line((short) points[i].x, (short) points[i].y);
 	    }
 	}
 	HidePen();
-
     }
+
     SetGWorld(saveWorld, saveDevice);
 }
 
@@ -750,45 +702,44 @@ void XDrawSegments(
     CGrafPtr saveWorld;
     GWorldPtr destPort;
     GDHandle saveDevice;
-    int i;
+    int i, lw = gc->line_width;
 
     destPort = TkMacOSXGetDrawablePort(d);
-
     display->request++;
-
     GetGWorld(&saveWorld, &saveDevice);
     SetGWorld(destPort, NULL);
-    
     TkMacOSXSetUpClippingRgn(d);
 
     if (useCGDrawing) {
-        CGContextRef outContext;
-
-        TkMacOSXSetUpCGContext(macWin, destPort, gc, &outContext);
+	CGContextRef outContext;
+	float o = (lw % 2) ? .5 : 0;
 
+	TkMacOSXSetUpCGContext(macWin, destPort, gc, &outContext);
         for (i = 0; i < nsegments; i++) {
 	    CGContextBeginPath(outContext);
             CGContextMoveToPoint(outContext,
-                    (float)(macWin->xOff + segments[i].x1),
-                    (float)(macWin->yOff + segments[i].y1));
-            CGContextAddLineToPoint (outContext,
-                    (float)(macWin->xOff + segments[i].x2),
-                    (float)(macWin->yOff + segments[i].y2));
-            CGContextStrokePath(outContext);
-
-        }
-        TkMacOSXReleaseCGContext(macWin, destPort, &outContext);
+		    macWin->xOff + segments[i].x1 + o,
+		    macWin->yOff + segments[i].y1 + o);
+	    CGContextAddLineToPoint(outContext,
+		    macWin->xOff + segments[i].x2 + o,
+		    macWin->yOff + segments[i].y2 + o);
+	    CGContextStrokePath(outContext);
+	}
+	TkMacOSXReleaseCGContext(macWin, destPort, &outContext);
     } else {
-        TkMacOSXSetUpGraphicsPort(gc, destPort);
+	int o = - (lw / 2);
 
-        ShowPen();
-
-        PenPixPat(gPenPat);
-        for (i = 0; i < nsegments; i++) {
-            MoveTo((short) (macWin->xOff + segments[i].x1),
-                   (short) (macWin->yOff + segments[i].y1));
-            LineTo((short) (macWin->xOff + segments[i].x2),
-                   (short) (macWin->yOff + segments[i].y2));
+	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. */
+	for (i = 0; i < nsegments; i++) {
+	    MoveTo((short) (macWin->xOff + segments[i].x1 + o),
+		   (short) (macWin->yOff + segments[i].y1 + o));
+	    LineTo((short) (macWin->xOff + segments[i].x2 + o),
+		   (short) (macWin->yOff + segments[i].y2 + o));
         }
         HidePen();
     }
@@ -823,49 +774,46 @@ XFillPolygon(
     int mode)			/* Drawing mode. */
 {
     MacDrawable *macWin = (MacDrawable *) d;
-    PolyHandle polygon;
     CGrafPtr saveWorld;
     GDHandle saveDevice;
     GWorldPtr destPort;
     int i;
 
     destPort = TkMacOSXGetDrawablePort(d);
-
     display->request++;
     GetGWorld(&saveWorld, &saveDevice);
     SetGWorld(destPort, NULL);
-
     TkMacOSXSetUpClippingRgn(d);
 
     if (useCGDrawing) {
 	CGContextRef outContext;
 	float prevx, prevy;
+	float o = (gc->line_width % 2) ? .5 : 0;
 
 	TkMacOSXSetUpCGContext(macWin, destPort, gc, &outContext);
-
 	CGContextBeginPath(outContext);
-	prevx = (float) (macWin->xOff + points[0].x);
-	prevy = (float) (macWin->yOff + points[0].y);
+	prevx = macWin->xOff + points[0].x + o;
+	prevy = macWin->yOff + points[0].y + o;
 	CGContextMoveToPoint(outContext, prevx, prevy);
 	for (i = 1; i < npoints; i++) {
 	    if (mode == CoordModeOrigin) {
-		CGContextAddLineToPoint(outContext, 
-			(float)(macWin->xOff + points[i].x),
-			(float)(macWin->yOff + points[i].y));
+		CGContextAddLineToPoint(outContext,
+			macWin->xOff + points[i].x + o,
+			macWin->yOff + points[i].y + o);
 	    } else {
-		prevx += (float) points[i].x;
-		prevy += (float) points[i].y;
+		prevx += points[i].x;
+		prevy += points[i].y;
 		CGContextAddLineToPoint(outContext, prevx, prevy);
 	    }
 	}
 	CGContextEOFillPath(outContext);
 	TkMacOSXReleaseCGContext(macWin, destPort, &outContext);
     } else {
-	TkMacOSXSetUpGraphicsPort(gc, destPort);
+	PolyHandle polygon;
 
+	TkMacOSXSetUpGraphicsPort(gc, destPort);
 	PenNormal();
 	polygon = OpenPoly();
-
 	MoveTo((short) (macWin->xOff + points[0].x),
 		(short) (macWin->yOff + points[0].y));
 	for (i = 1; i < npoints; i++) {
@@ -873,15 +821,14 @@ XFillPolygon(
 		LineTo((short) (macWin->xOff + points[i].x),
 			(short) (macWin->yOff + points[i].y));
 	    } else {
-		Line((short) (macWin->xOff + points[i].x),
-			(short) (macWin->yOff + points[i].y));
+		Line((short) points[i].x, (short) points[i].y);
 	    }
 	}
-
 	ClosePoly();
 	FillCPoly(polygon, gPenPat);
 	KillPoly(polygon);
     }
+
     SetGWorld(saveWorld, saveDevice);
 }
 
@@ -912,47 +859,52 @@ XDrawRectangle(
     unsigned int height)
 {
     MacDrawable *macWin = (MacDrawable *) d;
-    Rect theRect;
     CGrafPtr saveWorld;
     GDHandle saveDevice;
     GWorldPtr destPort;
+    int lw = gc->line_width;
 
-    destPort = TkMacOSXGetDrawablePort(d);
+    if (width == 0 || height == 0) {
+	return;
+    }
 
+    destPort = TkMacOSXGetDrawablePort(d);
     display->request++;
     GetGWorld(&saveWorld, &saveDevice);
     SetGWorld(destPort, NULL);
-
     TkMacOSXSetUpClippingRgn(d);
+
     if (useCGDrawing) {
-        CGContextRef outContext;
+	CGContextRef outContext;
 	CGRect	rect;
-        
-        TkMacOSXSetUpCGContext(macWin, destPort, gc, &outContext);
+	float o = (lw % 2) ? .5 : 0;
 
-	rect = CGRectMake((float) ((float) macWin->xOff + (float) x),
-	        (float) ((float) macWin->yOff + (float) y),
-	        (float) width,
-		(float) height);
+	TkMacOSXSetUpCGContext(macWin, destPort, gc, &outContext);
+	rect = CGRectMake(
+		macWin->xOff + x + o,
+		macWin->yOff + y + o,
+		width, height);
 	CGContextStrokeRect(outContext, rect);
-        TkMacOSXReleaseCGContext(macWin, destPort, &outContext);
+	TkMacOSXReleaseCGContext(macWin, destPort, &outContext);
     } else {
-        TkMacOSXSetUpGraphicsPort(gc, destPort);
+	Rect theRect;
+	int o = -lw/2;
 
-        theRect.left = (short) (macWin->xOff + x);
-        theRect.top = (short) (macWin->yOff + y);
-        theRect.right = (short) (theRect.left + width);
-        theRect.bottom = (short) (theRect.top + height);
-        
-        ShowPen();
-        PenPixPat(gPenPat);
-        FrameRect(&theRect);
-        HidePen();
+	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);
+	FrameRect(&theRect);
+	HidePen();
     }
+
     SetGWorld(saveWorld, saveDevice);
 }
 
-#if 0
+#ifdef TK_MACOSXDRAW_UNUSED
 /*
  *----------------------------------------------------------------------
  *
@@ -988,54 +940,123 @@ XDrawRectangles(
     int nRects)
 {
     MacDrawable *macWin = (MacDrawable *) drawable;
-    Rect     theRect;
     CGrafPtr saveWorld;
     GDHandle saveDevice;
     GWorldPtr destPort;
     XRectangle * rectPtr;
-    int       i;
+    int i, lw = gc->line_width;
 
     destPort = TkMacOSXGetDrawablePort(drawable);
-
     display->request++;
     GetGWorld(&saveWorld, &saveDevice);
     SetGWorld(destPort, NULL);
-
     TkMacOSXSetUpClippingRgn(drawable);
 
     if (useCGDrawing) {
         CGContextRef outContext;
 	CGRect	rect;
+	float o = (lw % 2) ? .5 : 0;
 
-        TkMacOSXSetUpCGContext(macWin, destPort, gc, &outContext);
-
+	TkMacOSXSetUpCGContext(macWin, destPort, gc, &outContext);
         for (i = 0, rectPtr = rectArr; i < nRects; i++, rectPtr++) {
-	    rect = CGRectMake((float) ((float) macWin->xOff 
-                    + (float) rectPtr->x),
-		    (float) ((float) macWin->yOff + (float) rectPtr->y),
-		    (float) rectPtr->width,
-		    (float) rectPtr->height);
+	    if (rectPtr->width == 0 || rectPtr->height == 0) {
+		continue;
+	    }
+	    rect = CGRectMake(
+		    macWin->xOff + rectPtr->x + o,
+		    macWin->yOff + rectPtr->y + o,
+		    rectPtr->width, rectPtr->height);
 	    CGContextStrokeRect(outContext, rect);
 	}
-        TkMacOSXReleaseCGContext(macWin, destPort, &outContext);
+	TkMacOSXReleaseCGContext(macWin, destPort, &outContext);
     } else {
+	Rect theRect;
+	int o = -lw/2;
+
 	TkMacOSXSetUpGraphicsPort(gc, destPort);
+	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);
+	    FrameRect(&theRect);
+	}
+	HidePen();
+    }
 
-        ShowPen();
-        PenPixPat(gPenPat);
+    SetGWorld(saveWorld, saveDevice);
+}
+#endif
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * XFillRectangles --
+ *
+ *        Fill multiple rectangular areas in the given drawable.
+ *
+ * Results:
+ *        None.
+ *
+ * Side effects:
+ *        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. */
+{
+    MacDrawable *macWin = (MacDrawable *) d;
+    CGrafPtr saveWorld;
+    GDHandle saveDevice;
+    GWorldPtr destPort;
+    XRectangle * rectPtr;
+    int i;
 
-        for (i = 0, rectPtr = rectArr; i < nRects;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);
-            FrameRect(&theRect);
+    destPort = TkMacOSXGetDrawablePort(d);
+    display->request++;
+    GetGWorld(&saveWorld, &saveDevice);
+    SetGWorld(destPort, NULL);
+    TkMacOSXSetUpClippingRgn(d);
+
+    if (useCGDrawing) {
+	CGContextRef outContext;
+	CGRect rect;
+
+	TkMacOSXSetUpCGContext(macWin, destPort, gc, &outContext);
+	for (i = 0, rectPtr = rectangles; i < n_rectangles; i++, rectPtr++) {
+	    if (rectPtr->width == 0 || rectPtr->height == 0) {
+		continue;
+	    }
+	    rect = CGRectMake(
+		    macWin->xOff + rectPtr->x,
+		    macWin->yOff + rectPtr->y,
+		    rectPtr->width, rectPtr->height);
+	    CGContextFillRect(outContext, rect);
+	}
+        TkMacOSXReleaseCGContext(macWin, destPort, &outContext);
+    } else {
+	Rect theRect;
+
+	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);
+            FillCRect(&theRect, gPenPat);
         }
-        HidePen();
     }
+
     SetGWorld(saveWorld, saveDevice);
 }
-#endif
 
 /*
  *----------------------------------------------------------------------
@@ -1063,91 +1084,80 @@ XDrawArc(
     unsigned int width,                /* Width & height. */
     unsigned int height,
     int angle1,                        /* Staring angle of arc. */
-    int angle2)                        /* Ending angle of arc. */
+    int angle2)                        /* Extent of arc. */
 {
     MacDrawable *macWin = (MacDrawable *) d;
-    Rect theRect;
-    short start, extent;
     CGrafPtr saveWorld;
     GDHandle saveDevice;
     GWorldPtr destPort;
+    int lw = gc->line_width;
 
-    if (width == 0 || height == 0) {
-        return;
+    if (width == 0 || height == 0 || angle2 == 0) {
+	return;
     }
-    
-    destPort = TkMacOSXGetDrawablePort(d);
 
+    destPort = TkMacOSXGetDrawablePort(d);
     display->request++;
     GetGWorld(&saveWorld, &saveDevice);
     SetGWorld(destPort, NULL);
-
     TkMacOSXSetUpClippingRgn(d);
 
     if (useCGDrawing) {
-        CGContextRef outContext;
-	CGRect	boundingRect;
-        int clockwise;
-	float a,b;
-	CGPoint	center;
-	float arc1, arc2;
-
-	if (angle2 > 0) {
-	    clockwise = 1;
-	} else {
-	    clockwise = 0;
-        }
-
-        TkMacOSXSetUpCGContext(macWin, destPort, gc, &outContext);
-
-        /*
-         * If we are drawing an oval, we have to squash the coordinate
-         * system before drawing, since CGContextAddArcToPoint only draws
-         * circles.
-         */
-
-        CGContextSaveGState(outContext);
-	boundingRect = CGRectMake(	(float)(macWin->xOff + x),
-					(float)(macWin->yOff + y),
-					(float)(width),
-					(float)(height));
-
-	center = CGPointMake(CGRectGetMidX(boundingRect), 
-                CGRectGetMidY(boundingRect));
-	a = CGRectGetWidth(boundingRect)/2;
-	b = CGRectGetHeight(boundingRect)/2;
-
-	CGContextTranslateCTM(outContext, center.x, center.y);
-	CGContextBeginPath(outContext);
-	CGContextScaleCTM(outContext, a, b);
-	arc1 = radians(-(angle1/64));
-	arc2 = radians(-(angle2/64)) + arc1;
-	CGContextAddArc(outContext, 0.0, 0.0, 1, arc1, arc2, clockwise);
+	CGContextRef outContext;
+	CGRect rect;
+	float o = (lw % 2) ? .5 : 0;
 
-	CGContextRestoreGState(outContext);
-        CGContextStrokePath(outContext);
-        TkMacOSXReleaseCGContext(macWin, destPort, &outContext);
+	TkMacOSXSetUpCGContext(macWin, destPort, gc, &outContext);
+	rect = CGRectMake(
+		macWin->xOff + x + o,
+		macWin->yOff + y + o,
+		width, height);
+
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1040
+	if (angle1 == 0 && angle2 == 23040 &&
+		CGContextStrokeEllipseInRect != NULL) {
+	    CGContextStrokeEllipseInRect(outContext, rect);
+	} else
+#endif
+	{
+	    CGMutablePathRef p = CGPathCreateMutable();
+	    CGAffineTransform t = CGAffineTransformIdentity;
+	    CGPoint c = CGPointMake(CGRectGetMidX(rect), CGRectGetMidY(rect));
+	    float w = CGRectGetWidth(rect);
+
+	    if (width != height) {
+		t = CGAffineTransformMakeScale(1, CGRectGetHeight(rect)/w);
+		c = CGPointApplyAffineTransform(c, CGAffineTransformInvert(t));
+	    }
+	    CGPathAddArc(p, &t, c.x, c.y, w/2, radians(-angle1/64.0),
+		    radians(-(angle1 + angle2)/64.0), angle2 > 0);
+	    CGContextAddPath(outContext, p);
+	    CGPathRelease(p);
+	    CGContextStrokePath(outContext);
+	}
+	TkMacOSXReleaseCGContext(macWin, destPort, &outContext);
     } else {
-        TkMacOSXSetUpGraphicsPort(gc, destPort);
-
-
-        theRect.left = (short) (macWin->xOff + x);
-        theRect.top = (short) (macWin->yOff + y);
-        theRect.right = (short) (theRect.left + width);
-        theRect.bottom = (short) (theRect.top + height);
-        start = (short) (90 - (angle1 / 64));
-        extent = (short) (-(angle2 / 64));
+	Rect theRect;
+	short start, extent;
+	int o = -lw/2;
 
-        ShowPen();
-        PenPixPat(gPenPat);
-        FrameArc(&theRect, start, extent);
-        HidePen();
+	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);
+	start =  (short) (90 - (angle1/64));
+	extent = (short) (-(angle2/64));
+	FrameArc(&theRect, start, extent);
+	HidePen();
     }
-    
+
     SetGWorld(saveWorld, saveDevice);
 }
 
-#if 0
+#ifdef TK_MACOSXDRAW_UNUSED
 /* 
  *----------------------------------------------------------------------
  * 
@@ -1180,81 +1190,82 @@ XDrawArcs(
 {
 
     MacDrawable *macWin = (MacDrawable *) d;
-    Rect rect;
-    short start, extent;
     CGrafPtr saveWorld;
     GDHandle saveDevice;
     GWorldPtr destPort;
-    XArc *    arcPtr;
-    int       i;
+    XArc * arcPtr;
+    int i, lw = gc->line_width;
 
     destPort = TkMacOSXGetDrawablePort(d);
-
     display->request++;
     GetGWorld(&saveWorld, &saveDevice);
     SetGWorld(destPort, NULL);
-
     TkMacOSXSetUpClippingRgn(d);
-    if (useCGDrawing) {
-        CGContextRef outContext;
 
-        TkMacOSXSetUpCGContext(macWin, destPort, gc, &outContext);
+    if (useCGDrawing) {
+	CGContextRef outContext;
+	CGRect rect;
+	float o = (lw % 2) ? .5 : 0;
 
+	TkMacOSXSetUpCGContext(macWin, destPort, gc, &outContext);
 	for (i=0, arcPtr = arcArr; i < nArcs; i++, arcPtr++) {
-	    CGRect	boundingRect;
-	    int clockwise;
-	    float a,b, arc1, arc2;
-	    CGPoint center;
-	   
-	    if (arcPtr[i].angle2 > 0) {
-		clockwise = 1;
-	    } else {
-		clockwise = 0;
+	    if (arcPtr->width == 0 || arcPtr->height == 0
+		    || arcPtr->angle2 == 0) {
+		continue;
+	    }
+	    rect = CGRectMake(
+		    macWin->xOff + arcPtr->x + o,
+		    macWin->yOff + arcPtr->y + o,
+		    arcPtr->width, arcPtr->height);
+
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1040
+	    if (arcPtr->angle1 == 0 && arcPtr->angle2 == 23040 &&
+		    CGContextStrokeEllipseInRect != NULL) {
+		CGContextStrokeEllipseInRect(outContext, rect);
+	    } else
+#endif
+	    {
+		CGMutablePathRef p = CGPathCreateMutable();
+		CGAffineTransform t = CGAffineTransformIdentity;
+		CGPoint c = CGPointMake(CGRectGetMidX(rect),
+					CGRectGetMidY(rect));
+		float w = CGRectGetWidth(rect);
+
+		if (arcPtr->width != arcPtr->height) {
+		    t = CGAffineTransformMakeScale(1, CGRectGetHeight(rect)/w);
+		    c = CGPointApplyAffineTransform(c,
+						    CGAffineTransformInvert(t));
+		}
+		CGPathAddArc(p, &t, c.x, c.y, w/2,
+			radians(-arcPtr->angle1/64.0),
+			radians(-(arcPtr->angle1 + arcPtr->angle2)/64.0),
+			arcPtr->angle2 > 0);
+		CGContextAddPath(outContext, p);
+		CGPathRelease(p);
+		CGContextStrokePath(outContext);
 	    }
-
-        /*
-         * If we are drawing an oval, we have to squash the coordinate
-         * system before drawing, since CGContextAddArcToPoint only draws
-         * circles.
-         */
-
-	    CGContextSaveGState(outContext);
-	    CGContextBeginPath(outContext);
-	    boundingRect = CGRectMake(	(float)(macWin->xOff + arcPtr[i].x),
-					(float)(macWin->yOff + arcPtr[i].y),
-					(float)arcPtr[i].width,
-					(float)arcPtr[i].height);
-	    
-	    center = CGPointMake(CGRectGetMidX(boundingRect), 
-                    CGRectGetMidY(boundingRect));
-	    a = CGRectGetWidth(boundingRect)/2;
-	    b = CGRectGetHeight(boundingRect)/2;
-	    
-	    CGContextTranslateCTM(outContext, center.x, center.y);
-	    CGContextScaleCTM(outContext, a, b);
-	    arc1 = radians(-(arcPtr[i].angle1/64));
-	    arc2 = radians(-(arcPtr[i].angle2/64)) + arc1;
-	    CGContextAddArc(outContext, 0.0, 0.0, 1, arc1, arc2, clockwise);
-	    CGContextRestoreGState(outContext);
-	    CGContextStrokePath(outContext);
 	}
-        TkMacOSXReleaseCGContext(macWin, destPort, &outContext);
+	TkMacOSXReleaseCGContext(macWin, destPort, &outContext);
     } else {
-	TkMacOSXSetUpGraphicsPort(gc, destPort);
+	Rect theRect;
+	short start, extent;
+	int o = -lw/2;
 
+	TkMacOSXSetUpGraphicsPort(gc, destPort);
         ShowPen();
         PenPixPat(gPenPat);
         for (i = 0, arcPtr = arcArr;i < nArcs;i++, arcPtr++) {
-            rect.left = (short) (macWin->xOff + arcPtr->x);
-            rect.top = (short) (macWin->yOff + arcPtr->y);
-            rect.right = (short) (rect.left + arcPtr->width);
-            rect.bottom = (short) (rect.top + arcPtr->height);
-            start = (short) (90 - (arcPtr->angle1 / 64));
-            extent = (short) (-(arcPtr->angle2 / 64));
-            FrameArc(&rect, start, extent);
-        }
-        HidePen();
+	    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));
+	    FrameArc(&theRect, start, extent);
+	}
+	HidePen();
     }
+
     SetGWorld(saveWorld, saveDevice);
 }
 #endif
@@ -1285,125 +1296,120 @@ XFillArc(
     unsigned int width,                /* Width & height. */
     unsigned int height,
     int angle1,                        /* Staring angle of arc. */
-    int angle2)                        /* Ending angle of arc. */
+    int angle2)                        /* Extent of arc. */
 {
     MacDrawable *macWin = (MacDrawable *) d;
-    Rect theRect;
-    short start, extent;
-    PolyHandle polygon;
-    double sin1, cos1, sin2, cos2, angle;
-    double boxWidth, boxHeight;
-    double vertex[2], center1[2], center2[2];
     CGrafPtr saveWorld;
     GDHandle saveDevice;
     GWorldPtr destPort;
+    int lw = gc->line_width;
 
-    destPort = TkMacOSXGetDrawablePort(d);
+    if (width == 0 || height == 0 || angle2 == 0) {
+	return;
+    }
 
+    destPort = TkMacOSXGetDrawablePort(d);
     display->request++;
     GetGWorld(&saveWorld, &saveDevice);
     SetGWorld(destPort, NULL);
-
     TkMacOSXSetUpClippingRgn(d);
 
     if (useCGDrawing) {
-        CGContextRef outContext;
-	CGRect	boundingRect;
-        int clockwise;
-	float a,b;
-	CGPoint	center;
-
-	if (angle2 > 0) {
-            clockwise = 1;
-	} else {
-            clockwise = 0;
-        }
-
-        TkMacOSXSetUpCGContext(macWin, destPort, gc, &outContext);
-	
-	boundingRect = CGRectMake((float) (macWin->xOff + x),
-	        (float) (macWin->yOff + y),
-		(float) width,
-		(float) height);
-	center = CGPointMake(CGRectGetMidX(boundingRect), 
-                CGRectGetMidY(boundingRect));
-	a = CGRectGetWidth(boundingRect)/2;
-	b = CGRectGetHeight(boundingRect)/2;
-
-	if (gc->arc_mode == ArcChord) {
-	  float arc1, arc2;
+	CGContextRef outContext;
+	CGRect rect;
+	float o = (lw % 2) ? .5 : 0, u = 0;
 
-	    CGContextBeginPath(outContext);
-	    CGContextTranslateCTM(outContext, center.x, center.y);
-	    CGContextScaleCTM(outContext, a, b);
-	    arc1 = radians(-(angle1/64));
-	    arc2 = radians(-(angle2/64)) + arc1;
-	    CGContextAddArc(outContext, 0.0, 0.0, 1, arc1, arc2, clockwise);
-	    CGContextFillPath(outContext);
-	} else if (gc->arc_mode == ArcPieSlice) {
-            float arc1, arc2;
-
-	    CGContextTranslateCTM(outContext, center.x, center.y);
-	    CGContextScaleCTM(outContext,a,b);
-	    arc1 = radians(-(angle1/64));
-	    arc2 = radians(-(angle2/64)) + arc1;
-	    CGContextAddArc(outContext, 0.0, 0.0, 1, arc1, arc2, clockwise);
-	    CGContextAddLineToPoint(outContext, 0.0f, 0.0f);
-	    CGContextClosePath(outContext);
+	if (notAA(lw)) {
+	    o += NON_AA_CG_OFFSET/2;
+	    u += NON_AA_CG_OFFSET;
+	}
+	TkMacOSXSetUpCGContext(macWin, destPort, gc, &outContext);
+	rect = CGRectMake(
+		macWin->xOff + x + o,
+		macWin->yOff + y + o,
+		width - u, height - u);
+
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1040
+	if (angle1 == 0 && angle2 == 23040 &&
+		CGContextFillEllipseInRect != NULL) {
+	    CGContextFillEllipseInRect(outContext, rect);
+	} else
+#endif
+	{
+	    CGMutablePathRef p = CGPathCreateMutable();
+	    CGAffineTransform t = CGAffineTransformIdentity;
+	    CGPoint c = CGPointMake(CGRectGetMidX(rect), CGRectGetMidY(rect));
+	    float w = CGRectGetWidth(rect);
+
+	    if (width != height) {
+		t = CGAffineTransformMakeScale(1, CGRectGetHeight(rect)/w);
+		c = CGPointApplyAffineTransform(c, CGAffineTransformInvert(t));
+	    }
+	    if (gc->arc_mode == ArcPieSlice) {
+		CGPathMoveToPoint(p, &t, c.x, c.y);
+	    }
+	    CGPathAddArc(p, &t, c.x, c.y, w/2, radians(-angle1/64.0),
+		    radians(-(angle1 + angle2)/64.0), angle2 > 0);
+	    CGPathCloseSubpath(p);
+	    CGContextAddPath(outContext, p);
+	    CGPathRelease(p);
 	    CGContextFillPath(outContext);
 	}
-	
-        TkMacOSXReleaseCGContext(macWin, destPort, &outContext);
+	TkMacOSXReleaseCGContext(macWin, destPort, &outContext);
     } else {
-        TkMacOSXSetUpGraphicsPort(gc, destPort);
-
-        theRect.left = (short) (macWin->xOff + x);
-        theRect.top = (short) (macWin->yOff + y);
-        theRect.right = (short) (theRect.left + width);
-        theRect.bottom = (short) (theRect.top + height);
-        start = (short) (90 - (angle1 / 64));
-        extent = (short) (- (angle2 / 64));
-
-        if (gc->arc_mode == ArcChord) {
-            boxWidth = theRect.right - theRect.left;
-            boxHeight = theRect.bottom - theRect.top;
-            angle = -(angle1/64.0)*PI/180.0;
-            sin1 = sin(angle);
-            cos1 = cos(angle);
-            angle -= (angle2/64.0)*PI/180.0;
-            sin2 = sin(angle);
-            cos2 = cos(angle);
-            vertex[0] = (theRect.left + theRect.right)/2.0;
-            vertex[1] = (theRect.top + theRect.bottom)/2.0;
-            center1[0] = vertex[0] + cos1*boxWidth/2.0;
-            center1[1] = vertex[1] + sin1*boxHeight/2.0;
-            center2[0] = vertex[0] + cos2*boxWidth/2.0;
-            center2[1] = vertex[1] + sin2*boxHeight/2.0;
-
-            polygon = OpenPoly();
-            MoveTo((short) ((theRect.left + theRect.right)/2),
-                    (short) ((theRect.top + theRect.bottom)/2));
-        
-            LineTo((short) (center1[0] + 0.5), (short) (center1[1] + 0.5));
-            LineTo((short) (center2[0] + 0.5), (short) (center2[1] + 0.5));
-            ClosePoly();
+	Rect theRect;
+	short start, extent;
+	int o = - (lw / 2);
+	PolyHandle polygon;
+	double sin1, cos1, sin2, cos2, angle;
+	double boxWidth, boxHeight;
+	double vertex[2], center1[2], center2[2];
 
-            ShowPen();
-            FillCArc(&theRect, start, extent, gPenPat);
-            FillCPoly(polygon, gPenPat);
-            HidePen();
-
-            KillPoly(polygon);
-        } else {
-            ShowPen();
-            FillCArc(&theRect, start, extent, gPenPat);
-            HidePen();
-        }
+	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.bottom = (short) (theRect.top + height + lw);
+	start = (short) (90 - (angle1/64));
+	extent = (short) (-(angle2/64));
+	if (gc->arc_mode == ArcChord) {
+	    boxWidth = theRect.right - theRect.left;
+	    boxHeight = theRect.bottom - theRect.top;
+	    angle = radians(-angle1/64.0);
+	    sin1 = sin(angle);
+	    cos1 = cos(angle);
+	    angle -= radians(angle2/64.0);
+	    sin2 = sin(angle);
+	    cos2 = cos(angle);
+	    vertex[0] = (theRect.left + theRect.right)/2.0;
+	    vertex[1] = (theRect.top + theRect.bottom)/2.0;
+	    center1[0] = vertex[0] + cos1*boxWidth/2.0;
+	    center1[1] = vertex[1] + sin1*boxHeight/2.0;
+	    center2[0] = vertex[0] + cos2*boxWidth/2.0;
+	    center2[1] = vertex[1] + sin2*boxHeight/2.0;
+
+	    polygon = OpenPoly();
+	    MoveTo((short) ((theRect.left + theRect.right)/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();
+	    ShowPen();
+	    FillCArc(&theRect, start, extent, gPenPat);
+	    FillCPoly(polygon, gPenPat);
+	    HidePen();
+	    KillPoly(polygon);
+	} else {
+	    ShowPen();
+	    FillCArc(&theRect, start, extent, gPenPat);
+	    HidePen();
+	}
     }
+
     SetGWorld(saveWorld, saveDevice);
 }
 
-#if 0
+#ifdef TK_MACOSXDRAW_UNUSED
 /*  
  *----------------------------------------------------------------------
  *  
@@ -1428,166 +1434,128 @@ XFillArcs(
     int nArcs)
 {
     MacDrawable *macWin = (MacDrawable *) d;
-    Rect rect;
-    short start, extent;
-    PolyHandle polygon;
-    double sin1, cos1, sin2, cos2, angle;
-    double boxWidth, boxHeight;
-    double vertex[2], center1[2], center2[2];
     CGrafPtr saveWorld;
     GDHandle saveDevice;
     GWorldPtr destPort;
-    int       i;
-    XArc      * arcPtr;
+    XArc * arcPtr;
+    int i, lw = gc->line_width;
 
     destPort = TkMacOSXGetDrawablePort(d);
-
     display->request++;
     GetGWorld(&saveWorld, &saveDevice);
     SetGWorld(destPort, NULL);
-
     TkMacOSXSetUpClippingRgn(d);
 
     if (useCGDrawing) {
-        CGContextRef outContext;
-        
+	CGContextRef outContext;
+	CGRect rect;
+	float o = (lw % 2) ? .5 : 0, u = 0;
+
+	if (notAA(lw)) {
+	    o += NON_AA_CG_OFFSET/2;
+	    u += NON_AA_CG_OFFSET;
+	}
         TkMacOSXSetUpCGContext(macWin, destPort, gc, &outContext);
 	for (i = 0, arcPtr = arcArr; i < nArcs; i++, arcPtr++) {
-	    CGRect	boundingRect;
-	    int clockwise = arcPtr[i].angle1;
-	    float a,b;
-	    CGPoint center;
-	    
-	    if (arcPtr[i].angle2 > 0) {
-		clockwise = 1;
-	    } else {
-		clockwise = 0;
-            }
+	    if (arcPtr->width == 0 || arcPtr->height == 0
+		    || arcPtr->angle2 == 0) {
+		continue;
+	    }
+	    rect = CGRectMake(
+		    macWin->xOff + arcPtr->x + o,
+		    macWin->yOff + arcPtr->y + o,
+		    arcPtr->width - u, arcPtr->height - u);
+
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1040
+	    if (arcPtr->angle1 == 0 && arcPtr->angle2 == 23040 &&
+		    CGContextFillEllipseInRect != NULL) {
+		CGContextFillEllipseInRect(outContext, rect);
+	    } else
+#endif
+	    {
+		CGMutablePathRef p = CGPathCreateMutable();
+		CGAffineTransform t = CGAffineTransformIdentity;
+		CGPoint c = CGPointMake(CGRectGetMidX(rect),
+					CGRectGetMidY(rect));
+		float w = CGRectGetWidth(rect);
+
+		if (arcPtr->width != arcPtr->height) {
+		    t = CGAffineTransformMakeScale(1, CGRectGetHeight(rect)/w);
+		    c = CGPointApplyAffineTransform(c,
+						    CGAffineTransformInvert(t));
+		}
+		if (gc->arc_mode == ArcPieSlice) {
+		    CGPathMoveToPoint(p, &t, c.x, c.y);
+		}
+		CGPathAddArc(p, &t, c.x, c.y, w/2,
+			radians(-arcPtr->angle1/64.0),
+			radians(-(arcPtr->angle1 + arcPtr->angle2)/64.0),
+			arcPtr->angle2 > 0);
+		CGPathCloseSubpath(p);
+		CGContextAddPath(outContext, p);
+		CGPathRelease(p);
+		CGContextFillPath(outContext);
+	    }
+	}
+	TkMacOSXReleaseCGContext(macWin, destPort, &outContext);
+    } else {
+	Rect theRect;
+	short start, extent;
+	int o = - (lw / 2);
+	PolyHandle polygon;
+	double sin1, cos1, sin2, cos2, angle;
+	double boxWidth, boxHeight;
+	double vertex[2], center1[2], center2[2];
 
-	    /*
-	     * If we are drawing an oval, we have to squash the coordinate
-	     * system before drawing, since CGContextAddArcToPoint only draws
-	     * circles.
-	     */
+	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.bottom = (short) (theRect.top + arcPtr->height + lw);
+	    start = (short) (90 - (arcPtr->angle1/64));
+	    extent = (short) (- (arcPtr->angle2/64));
 
 	    if (gc->arc_mode == ArcChord) {
-	    
-		CGContextBeginPath(outContext);
-		boundingRect = CGRectMake((float)(macWin->xOff + arcPtr[i].x),
-	                (float)(macWin->yOff + arcPtr[i].y),
-			(float)arcPtr[i].width,
-			(float)arcPtr[i].height);
-		center = CGPointMake(CGRectGetMidX(boundingRect), 
-                        CGRectGetMidY(boundingRect));
-		a = CGRectGetWidth(boundingRect)/2.0;
-		b = CGRectGetHeight(boundingRect)/2.0;
-		
-		angle = -(arcPtr->angle1/64.0)*PI/180.0;
+		boxWidth = theRect.right - theRect.left;
+		boxHeight = theRect.bottom - theRect.top;
+		angle = radians(-arcPtr->angle1/64.0);
 		sin1 = sin(angle);
 		cos1 = cos(angle);
-		angle -= (arcPtr->angle2/64.0)*PI/180.0;
+		angle -= radians(arcPtr->angle2/64.0);
 		sin2 = sin(angle);
 		cos2 = cos(angle);
-		vertex[0] = (CGRectGetMinX(boundingRect) 
-                        + CGRectGetMaxX(boundingRect))/2.0;
-		vertex[1] = (CGRectGetMaxY(boundingRect) 
-                        + CGRectGetMinY(boundingRect))/2.0;
-		center1[0] = vertex[0] + cos1*a;
-		center1[1] = vertex[1] + sin1*b;
-		center2[0] = vertex[0] + cos2*a;
-		center2[1] = vertex[1] + sin2*b;
-
-		CGContextScaleCTM(outContext, a, b);
-		
-		CGContextBeginPath(outContext);
-		CGContextMoveToPoint(outContext, (float) vertex[0],
-		        (float) vertex[1]);
-		CGContextAddLineToPoint(outContext,
-			(float) (center1[0] + 0.5),
-			(float) (center1[1] + 0.5));
-		CGContextAddLineToPoint(outContext,
-			(float) (center2[0] + 0.5),
-		        (float) (center2[1] + 0.5));
-		CGContextFillPath(outContext);
-	    } else if (gc->arc_mode == ArcPieSlice) {
-	        float arc1, arc2;
-		CGContextBeginPath(outContext);
-		boundingRect = CGRectMake((float)(macWin->xOff + arcPtr[i].x),
-		        (float)(macWin->yOff + arcPtr[i].y),
-			(float)arcPtr[i].width,
-			(float)arcPtr[i].height);
-		center = CGPointMake(CGRectGetMidX(boundingRect), 
-                        CGRectGetMidY(boundingRect));
-		a = CGRectGetWidth(boundingRect)/2;
-		b = CGRectGetHeight(boundingRect)/2;
-		
-		CGContextTranslateCTM(outContext, center.x, center.y);
-		CGContextScaleCTM(outContext, a, b);
-		arc1 = radians(-(arcPtr[i].angle1/64));
-		arc2 = radians(-(arcPtr[i].angle2/64)) + arc1;
-		CGContextAddArc(outContext, 0.0, 0.0, 1, 
-                        arc1, arc2, clockwise);
-		CGContextAddLineToPoint(outContext, 0.0f, 0.0f);
-		CGContextClosePath(outContext);
-		CGContextFillPath(outContext);
+		vertex[0] = (theRect.left + theRect.right)/2.0;
+		vertex[1] = (theRect.top + theRect.bottom)/2.0;
+		center1[0] = vertex[0] + cos1*boxWidth/2.0;
+		center1[1] = vertex[1] + sin1*boxHeight/2.0;
+		center2[0] = vertex[0] + cos2*boxWidth/2.0;
+		center2[1] = vertex[1] + sin2*boxHeight/2.0;
+
+		polygon = OpenPoly();
+		MoveTo((short) ((theRect.left + theRect.right)/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();
+		ShowPen();
+		FillCArc(&theRect, start, extent, gPenPat);
+		FillCPoly(polygon, gPenPat);
+		HidePen();
+		KillPoly(polygon);
+	    } else {
+		ShowPen();
+		FillCArc(&theRect, start, extent, gPenPat);
+		HidePen();
 	    }
 	}
-        
-        TkMacOSXReleaseCGContext(macWin, destPort, &outContext);
-    } else {
-    
-        TkMacOSXSetUpGraphicsPort(gc, destPort);
-
-        for (i = 0, arcPtr = arcArr;i<nArcs;i++, arcPtr++) {
-            rect.left = (short) (macWin->xOff + arcPtr->x);
-            rect.top = (short) (macWin->yOff + arcPtr->y);
-            rect.right = (short) (rect.left + arcPtr->width);
-            rect.bottom = (short) (rect.top + arcPtr->height);
-            start = (short) (90 - (arcPtr->angle1 / 64));
-            extent = (short) (- (arcPtr->angle2 / 64));
-
-            if (gc->arc_mode == ArcChord) {
-                boxWidth = rect.right - rect.left;
-                boxHeight = rect.bottom - rect.top;
-                angle = -(arcPtr->angle1/64.0)*PI/180.0;
-                sin1 = sin(angle);
-                cos1 = cos(angle);
-                angle -= (arcPtr->angle2/64.0)*PI/180.0;
-                sin2 = sin(angle);
-                cos2 = cos(angle);
-                vertex[0] = (rect.left + rect.right)/2.0;
-                vertex[1] = (rect.top + rect.bottom)/2.0;
-                center1[0] = vertex[0] + cos1*boxWidth/2.0;
-                center1[1] = vertex[1] + sin1*boxHeight/2.0;
-                center2[0] = vertex[0] + cos2*boxWidth/2.0;
-                center2[1] = vertex[1] + sin2*boxHeight/2.0;
-    
-                polygon = OpenPoly();
-                MoveTo((short) ((rect.left + rect.right)/2),
-                        (short) ((rect.top + rect.bottom)/2));
-    
-                LineTo((short) (center1[0] + 0.5), (short) (center1[1] + 0.5));
-                LineTo((short) (center2[0] + 0.5), (short) (center2[1] + 0.5));
-                ClosePoly();
-    
-                ShowPen();
-                FillCArc(&rect, start, extent, gPenPat);
-                FillCPoly(polygon, gPenPat);
-                HidePen();
-
-                KillPoly(polygon);
-            } else {
-                ShowPen();
-                FillCArc(&rect, start, extent, gPenPat);
-                HidePen();
-            }
-        }
     }
+
     SetGWorld(saveWorld, saveDevice);
 }
 #endif
 
-#if 0
+#ifdef TK_MACOSXDRAW_UNUSED
 /* 
  *----------------------------------------------------------------------
  * 
@@ -1642,10 +1610,8 @@ TkScrollWindow(
     RgnHandle visRgn, clipRgn;
     
     destPort = TkMacOSXGetDrawablePort(Tk_WindowId(tkwin));
-
     GetGWorld(&saveWorld, &saveDevice);
     SetGWorld(destPort, NULL);
-
     TkMacOSXSetUpClippingRgn(Tk_WindowId(tkwin));
 
     /*
@@ -1821,6 +1787,7 @@ TkMacOSXSetUpCGContext(
     Rect boundsRect;
     CGAffineTransform coordsTransform;
     static RgnHandle clipRgn = NULL;
+    float w;
 
     err = QDBeginCGContext(destPort, contextPtr);
     outContext = *contextPtr;
@@ -1854,8 +1821,8 @@ TkMacOSXSetUpCGContext(
 
     SyncCGContextOriginWithPort(outContext, destPort);
 
-    coordsTransform = CGAffineTransformMake(1.0f, 0.0f, 0.0f, -1.0f, 0.0f,
-	    (float) (boundsRect.bottom - boundsRect.top));
+    coordsTransform = CGAffineTransformMake(1, 0, 0, -1, 0,
+	    boundsRect.bottom - boundsRect.top);
     CGContextConcatCTM(outContext, coordsTransform);
     
     /* Now offset the CTM to the subwindow offset */
@@ -1865,34 +1832,36 @@ TkMacOSXSetUpCGContext(
 		RGBFLOATRED(macColor), 
 		RGBFLOATGREEN(macColor), 
 		RGBFLOATBLUE(macColor),
-		1.0f);
+		1);
 	CGContextSetRGBStrokeColor(outContext,
 		RGBFLOATRED(macColor),
 		RGBFLOATGREEN(macColor),
 		RGBFLOATBLUE(macColor),
-		1.0f);
+		1);
     }
-    
+
     if(gc->function == GXxor) {
     }
-    
-    CGContextSetLineWidth(outContext, (float) gc->line_width);
 
+    w = gc->line_width;
     /* When should we antialias? */
-    if (gc->line_width < tkMacOSXCGAntiAliasLimit) {
+    if (notAA(gc->line_width)) {
+	/* Make non-antialiased CG drawing look more like X11 */
+	w -= (gc->line_width ? NON_AA_CG_OFFSET : 0);
 	CGContextSetShouldAntialias(outContext, 0);
     } else {
 	CGContextSetShouldAntialias(outContext, 1);
     }
+    CGContextSetLineWidth(outContext, w);
 
     if (gc->line_style != LineSolid) { 
 	int num = 0;
 	char *p = &(gc->dashes);
-	float dashOffset = (float) gc->dash_offset;
+	float dashOffset = gc->dash_offset;
 	float lengths[10];
 
 	while (p[num] != '\0') {
-	    lengths[num] = (float) (p[num]);
+	    lengths[num] = p[num];
 	    num++;
 	}
 	CGContextSetLineDash(outContext, dashOffset, lengths, num);
diff --git a/macosx/tkMacOSXInit.c b/macosx/tkMacOSXInit.c
index e5b6735..70ed06f 100644
--- a/macosx/tkMacOSXInit.c
+++ b/macosx/tkMacOSXInit.c
@@ -11,12 +11,12 @@
  * See the file "license.terms" for information on usage and redistribution
  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkMacOSXInit.c,v 1.3.2.18 2006/08/18 07:47:25 das Exp $
+ * RCS: @(#) $Id: tkMacOSXInit.c,v 1.3.2.19 2006/10/16 15:35:51 das Exp $
  */
 
 #include "tkMacOSXInt.h"
 
-#include "tclInt.h" /* for TclGetStartupScript() & TclSetStartupScript() */
+#include "tclInt.h" /* for Tcl{G,S}etStartupScriptFileName() */
 
 #include <sys/stat.h>
 #include <mach-o/dyld.h>
@@ -137,7 +137,7 @@ TkpInit(interp)
 	TkMacOSXInitCarbonEvents(interp);
 	TkMacOSXInitMenus(interp);
 	TkMacOSXUseAntialiasedText(interp, TRUE);
-	TkMacOSXInitCGDrawing(interp, TRUE, 3);
+	TkMacOSXInitCGDrawing(interp, TRUE, 0);
 	TkMacOSXInitKeyboard(interp);
 
 	encoding = CFStringGetSystemEncoding();