* macosx/tkMacOSXCarbonEvents.c: add window event target carbon event

	* macosx/tkMacOSXEvent.c:	 handler for all kEventClassWindow and
	* macosx/tkMacOSXEvent.h:	 kEventClassMouse events; move all
	* macosx/tkMacOSXNotify.c:	 remaining events except for
	* macosx/tkMacOSXWindowEvent.c:	 kEventClassKeyboard from dispatcher to
	application event handler; pass event handler callRef downstream; fix
	debug event tracing; process all tcl event types in carbon event timer;
	delay carbon event timer first fire; add TkMacOSXTrackingLoop() to mark
	enter/exit of event tracking loop during which all tcl events but only
	carbon update events should be processed by the timer (replaces various
	calls to Tcl_SetServiceMode()); rename TkMacOSXReceiveAndProcessEvent()
	to TkMacOSXReceiveAndDispatchEvent(), move it from tkMacOSXEvent.c to
	tkMacOSXCarbonEvents.c and modify it to dequeue only update events
	during a tracking loop; add TkMacOSXRunTclEventLoop() to standardize
	the various ways in use to run the tcl event loop; add handling of
	kEventClassAppearance events (for ScrollBarVariantChanged event).

	* macosx/tkMacOSXDialog.c:	use new TkMacOSXTrackingLoop() around
	* macosx/tkMacOSXEvent.c:	blocking API that puts up modal dialogs
	* macosx/tkMacOSXMenu.c:	or when entering/exiting menu/control
	* macosx/tkMacOSXMouseEvent.c:	tracking, window dragging and other
	* macosx/tkMacOSXScale.c:	mouse tracking loops.
	* macosx/tkMacOSXScrlbr.c:
	* macosx/tkMacOSXWindowEvent.c:
	* macosx/tkMacOSXWm.c:

	* macosx/tkMacOSXDialog.c:	use new TkMacOSXRunTclEventLoop()
	* macosx/tkMacOSXScale.c:	instead of Tcl_DoOneEvent(),
	* macosx/tkMacOSXScrlbr.c:	Tcl_ServiceAll(), TclServiceIdle()
	* macosx/tkMacOSXWindowEvent.c:	and Tcl_GlobalEval("update idletasks").

	* macosx/tkMacOSXColor.c: make available as Tk system colors all
	* macosx/tkMacOSXPort.h:  appearance manager brushes, text colors and
	backgrounds with new and legacy names, as well as the fully transparent
	color "systemTransparent"; add TkMacOSXSetColorIn{Port,Context}() to
	directly set an X pixel color value in the current QD port resp. the
	given CG context without requiring passage through rgb representation
	(lossy for most system colors); modernize/remove Classic-era code;
	replace crufty strcmp() elseifs by Tcl_GetIndexFromObjStruct().

	* macosx/tkMacOSXButton.c:	use new TkMacOSXSetColorInPort()
	* macosx/tkMacOSXDraw.c:	instead of setting rgb color directly
	* macosx/tkMacOSXMenubutton.c:	to allow for non-rgb system colors.

	* macosx/tkMacOSXCursor.c: implement "none" cursor as on other
	platforms [Patch 1615427]; add all missing appearance manager cursors.

	* macosx/tkMacOSXDefault.h: set SELECT_FG_COLORs to None to match aqua
	L&F; use standard system color names; use new 'menu' system font;
	correct default scrollbar width.

	* macosx/tkMacOSXDraw.c:	standardize initialization, use and
	* macosx/tkMacOSXInt.h:		emptying of various static temp rgns
	* macosx/tkMacOSXRegion.c:	onto two global RgnHandles; in debug
	* macosx/tkMacOSXSubwindows.c:	builds, verify emptiness of these temp
	* macosx/tkMacOSXWindowEvent.c:	rgns before use.

	* macosx/tkMacOSXDraw.c: add TkMacOSX{Setup,Restore}DrawingContext() to
	* macosx/tkMacOSXInt.h:  abstract common setup & teardown of drawing
	environment (for both CG and QD); save/restore QD theme drawing state;
	handle GC clip region; add TkpClipDrawableToRect() to allow clipped
	drawing into drawable regardless of GC used; use new system color
	"systemWindowHeaderBackground" to setup background in themed toplevels;
	correct implementation of TkMacOSXMakeStippleMap().

	* macosx/tkMacOSXEntry.c: use new TkMacOSXSetupDrawingContext() and
	* macosx/tkMacOSXFont.c:  TkMacOSXRestoreDrawingContext() instead of
	various setup/teardown procs like TkMacOSX{SetUp,Release}CGContext(),
	TkMacOSXQuarz{Start,End}Draw(), TkMacOSXSetUpGraphicsPort() etc.

	* macosx/tkMacOSXEmbed.c: add CG context and drawable clip rgn fields
	* macosx/tkMacOSXInt.h:   to MacDrawable struct.
	* macosx/tkMacOSXSubwindows.c:

	* macosx/tkMacOSXDialog.c: make -parent option of tk_getOpenFile et al.
	use the sheet version of NavServices dialogs; ensure native parent win
	exists before using StandardSheet API for tk_messageBox [Bug 1677611];
	force sheets to behave like app-modal dialogs via WindowModality() API;
	use more modern ColorPicker API.

	* macosx/tkAboutDlg.r: use themed movable modal dialog, fix (c) year.

	* macosx/tkMacOSXEntry.c:  take xOff/yOff of MacDrawable into account
	when computing locations/bounds to ensure correct posititioning when
	not drawing into intermediate pixmap.

	* macosx/tkMacOSXFont.c: use appearance manager API to map system font
	* macosx/tkMacOSXFont.h: names to TkFonts; add "menu" system font for
	menu item text drawing from MDEF; disable broken QD stippling.

	* macosx/tkMacOSXMenu.c:		large-scale rewrite of custom
	* macosx/tkMacOSXMenu.r (removed):	MDEF and related code that
	* unix/Makefile.in:			restores many longtime-MIA
	features to working order (e.g. images, custom colors & fonts in menus
	etc); implement compound menu items; use Appearance Mgr and ThemeText
	APIs to mimic native MDEF as closely as possible when default "menu"
	system font is used; remove now obsolete SICN drawing code and
	resources.

	* macosx/tkMacOSXCarbonEvents.c: handle additional menu carbon events
	* macosx/tkMacOSXEvent.c:	 in order to support <<MenuSelect>> in
	* macosx/tkMacOSXMenu.c:	 the menubar and in menus that are not
	* macosx/tkMacOSXMenus.c:	 using the custom MDEF [Bug 1620826];
	fix early and missing clearing of current Tk active menu entry; fix
	extraneous sending of <<MenuSelect>> during active menu entry clearing.

	* macosx/tkMacOSXMouseEvent.c: add support for async window dragging by
	the window server; set the corresponding window attribute by default.

	* macosx/tkMacOSXMouseEvent.c: rationalized handling order of
	non-mousedown events; add TkMacOSXModifierState() to retrieve the
	current key modifiers in carbon format.

	* macosx/tkMacOSXScrlbr.c: use appearance manager API to retrieve
	scrollbar component metrics; add awareness of multiple possibilites for
	scrollbar arrow position in aqua and handle user changes to arrow
	position pref; handle difference in metrics of small & large scrollbar
	variants; handle aqua "jump to here" scrollbar behaviour; correct
	computation of scroll view size and position; enforce min scrollbar
	height to avoid scrollbar component overlap; erase scrollbar area
	outside of standard width; remove broken auto-adjust code; account for
	window class when leaving space for grow box; remove code to manually
	draw grow box; use modern API for thumb scroll proc; replace
	HiliteControl() by modern API; replace control mgr constants with
	appearance mgr equivalents.

	* macosx/tkMacOSXSubwindows.c: use SetWindowBounds() API instead of
	SizeWindow(); invalidate clip regions after X{Map,Unmap}Window as fix
	for [Bug 940117] made them dependent on mapping state; remove unneeded
	calls to TkMacOSXInvalClipRgns() and unnecessary setting of QD port;
	use native-endian pixmap on intel; remove obsolete pixmap pix locking.

	* macosx/tkMacOSXWindowEvent.c: handle only the first of a batch of
	kEventAppAvailableWindowBoundsChanged events sent per transaction;
	handle kEventWindowBoundsChanged event to support live window resizing
	and centralized sending of location/size changed ConfigureNotify
	events; ensure HIGrowBox is redrawn after bounds change; constrain
	window after dragging to ensure titlebar is not inacessible
	offscreen or under dock/menubar; handle kEventWindowGetRegion and
	kEventWindowDrawContent for transparent windows to mark resp. paint
	content region as transparent; handle kEventWindowConstrain for
	fullscreen windows to ensure bounds match new screen size; enter/exit
	fullscreen UIMode upon activation/deactivation of fullscreen window.

	* macosx/tkMacOSXWm.c: use live-resize and async-drag carbon window
	* macosx/tkMacOSXWm.h: attributes for toplevels by default; implement
	new [wm attributes] -topmost, -transparent and -fullscreen; refactor
	WmAttributesCmd() parallelling the tkUnixWm.c implementation, use thus
	factored proc to set proxy icon from [wm iconbitmap]; dynamically
	determine default values for toplevel min and max sizes (similar to
	tkWinWm.c impl): min sizes depend on window class & attributes to
	ensure visibility of all titlebar widgets and grow box, max sizes
	depend on maximal window bounds for all active displays; factor out
	code that puts into effect changes to master or override_redirect; use
	RepositionWindow() API to determine staggered initial window bounds;
	correct resize limit calculations, handle gridding and use modern
	resize API in TkMacOSXGrowToplevel(); remove sending of ConfigureNotify
	after resize or zoom (now handled by BoundsChanged handler); correct
	composite carbon window attribute handling, remove currently unusable
	attributes and add new attributes in [tk::unsupported::MacWindowStyle];
	ensure validity of window class and attributes before use; apply
	changes to window class when handling carbon window attribute changes
	(if HIWindowChangeClass() API available); add debug build warning
	message when deprecated window style is used instead of window class;
	use transparent HIGrowBox for resizable windows; avoid unnecessary
	calls to window structure width API; use tcl time API in TkpGetMS();
	add TkMacOSXEnterExitFullscreen() to enter/exit UIMode with dock and
	menubar hidden; restrict wmTracing output to debug builds; remove
	unneeded calls to TkMacOSXInvalClipRgns() and unnecessary setting of QD
	port; workaround GetWindowStructureWidths() Carbon bug (bogus results
	for never-mapped floating windows).

	* macosx/tkMacOSXXStubs.c (TkMacOSXDisplayChanged): add maximal window
	bounds field to Screen record (in ext_data), computed as the union of
	available window positioning bounds of all graphics devices (displays).

	* macosx/tkMacOSXBitmap.c: fix macRoman encoding leak.
	* macosx/tkMacOSXCursor.c:

	* macosx/tkMacOSXDebug.c (TkMacOSXCarbonEventToAscii): use static
	* macosx/tkMacOSXDebug.h: buffer to simplify callers; const fixes.

	* macosx/tkMacOSXBitmap.c: use more efficient QDSwapPort() instead of
	* macosx/tkMacOSXButton.c: GetPort()/SetPort()/GetGWorld()/SetGWorld().
	* macosx/tkMacOSXDraw.c:
	* macosx/tkMacOSXFont.c:
	* macosx/tkMacOSXMenubutton.c:
	* macosx/tkMacOSXScale.c:
	* macosx/tkMacOSXScrlbr.c:
	* macosx/tkMacOSXXStubs.c:

	* macosx/tkMacOSXColor.c: use kHIToolboxVersionNumber for runtime OS
	* macosx/tkMacOSXEntry.c: version check rather than Gestalt() etc.
	* macosx/tkMacOSXInt.h:
	* macosx/tkMacOSXWm.c:

	* macosx/tkMacOSXDraw.c: remove obsolete and now incorrect
	* macosx/tkMacOSXInt.h:  tkMenuCascadeRgn clipping code.
	* macosx/tkMacOSXMenu.c:

	* macosx/tkMacOSXHLEvents.c: replace Tcl_GlobalEval() resp. Tcl_Eval()
	* macosx/tkMacOSXScrlbr.c:   by Tcl_EvalEx().
	* macosx/tkMacOSXInit.c:

	* macosx/tkMacOSXInit.c (TkpInit): reorder initialization steps.

	* macosx/tkMacOSXKeyEvent.c: remove pre-10.2 support.

	* macosx/tkMacOSXMenus.c: remove now useless call to
	TkMacOSXHandleTearoffMenu(); use \x.. quoting for non-latin1 macroman
	literar chars to allow file to be edited as utf-8.

	* macosx/tkMacOSXScale.c: replace TrackControl() by modern
	* macosx/tkMacOSXScrlbr.c: HandleControlClick() API (using new
	TkMacOSXModifierState()).

	* macosx/tkMacOSXInt.h:		move all constant #defines needed to
	* macosx/tkMacOSXColor.c:	support building on older OS X releases
	* macosx/tkMacOSXEvent.h:	to a central location in tkMacOSXInt.h.
	* macosx/tkMacOSXFont.c:
	* macosx/tkMacOSXMenu.c:
	* macosx/tkMacOSXMenubutton.c:
	* macosx/tkMacOSXMenus.c:
	* macosx/tkMacOSXMouseEvent.c:
	* macosx/tkMacOSXWm.c:

	* macosx/tkMacOSXInt.h:		 add ChkErr() macro to factor out
	* macosx/tkMacOSXButton.c:	 Carbon OSStatus return value checking
	* macosx/tkMacOSXCarbonEvents.c: and TkMacOSXDbgMsg() macro to factour
	* macosx/tkMacOSXClipboard.c:	 out debug message output; use these
	* macosx/tkMacOSXColor.c:	 macros to replace #ifdef TK_MAC_DEBUG
	* macosx/tkMacOSXCursor.c:	 blocks & direct printing to stderr,
	* macosx/tkMacOSXDebug.c:	 and to do additional OSStatus return
	* macosx/tkMacOSXDialog.c:	 checking, and to standardize OSStatus
	* macosx/tkMacOSXDraw.c:	 usage.
	* macosx/tkMacOSXEntry.c:
	* macosx/tkMacOSXEvent.c:
	* macosx/tkMacOSXFont.c:
	* macosx/tkMacOSXHLEvents.c:
	* macosx/tkMacOSXInit.c:
	* macosx/tkMacOSXKeyEvent.c:
	* macosx/tkMacOSXMenu.c:
	* macosx/tkMacOSXMenubutton.c:
	* macosx/tkMacOSXMenus.c:
	* macosx/tkMacOSXMouseEvent.c:
	* macosx/tkMacOSXScrlbr.c:
	* macosx/tkMacOSXSubwindows.c:
	* macosx/tkMacOSXWindowEvent.c:
	* macosx/tkMacOSXWm.c:
	* macosx/tkMacOSXXStubs.c:

	* macosx/tkMacOSXSend.c:	remove duplicate/unused declarations.
	* macosx/tkMacOSXXStubs.c:

	* macosx/tkMacOSXDebug.c:	const fixes.
	* macosx/tkMacOSXInit.c:
	* macosx/tkMacOSXTest.c:
	* macosx/tkMacOSXWm.c:
	* macosx/tkMacOSXXStubs.c:

	* macosx/Wish-Info.plist.in: add tcl document extensions/mime types and
	LSMinimumSystemVersion, LSRequiresCarbon & NSAppleScriptEnabled keys.

	* macosx/tkMacOSXAETE.r:	fix whitespace.
	* macosx/tkMacOSXConfig.c:
	* macosx/tkMacOSXCursors.r:
	* macosx/tkMacOSXKeyboard.c:
	* macosx/tkMacOSXSend.c:
	* macosx/tkMacOSXXCursors.r:
	* macosx/README:

	* macosx/Makefile:		fix/add copyright and license refs.
	* macosx/Tk-Info.plist.in:
	* macosx/Wish-Info.plist.in:
	* macosx/tkMacOSX.h:

1 files changed, 305 insertions, 337 deletions

diff --git a/macosx/tkMacOSXSubwindows.c b/macosx/tkMacOSXSubwindows.c
index d536a1b..18dc2ec 100644
--- a/macosx/tkMacOSXSubwindows.c
+++ b/macosx/tkMacOSXSubwindows.c
@@ -1,16 +1,16 @@
-/* 
+/*
  * tkMacOSXSubwindows.c --
  *
  *	Implements subwindows for the macintosh version of Tk.
  *
  * Copyright (c) 1995-1997 Sun Microsystems, Inc.
  * Copyright 2001, Apple Computer, Inc.
- * Copyright (c) 2006 Daniel A. Steffen <das@users.sourceforge.net>
+ * Copyright (c) 2006-2007 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.
  *
- * RCS: @(#) $Id: tkMacOSXSubwindows.c,v 1.2.2.13 2006/10/31 22:33:38 das Exp $
+ * RCS: @(#) $Id: tkMacOSXSubwindows.c,v 1.2.2.14 2007/04/29 02:26:50 das Exp $
  */
 
 #include "tkMacOSXInt.h"
@@ -18,23 +18,19 @@
 #include "tkMacOSXWm.h"
 
 /*
-#ifdef	TK_MAC_DEBUG
+#ifdef TK_MAC_DEBUG
 #define TK_MAC_DEBUG_CLIP_REGIONS
 #endif
 */
 
 /*
- * Temporary region that can be reused.
- */
-static RgnHandle tmpRgn = NULL;
-
-/*
  * Prototypes for functions used only in this file.
  */
 
 static void GenerateConfigureNotify (TkWindow *winPtr, int includeWin);
 static void UpdateOffsets (TkWindow *winPtr, int deltaX, int deltaY);
 
+
 /*
  *----------------------------------------------------------------------
  *
@@ -51,13 +47,13 @@ static void UpdateOffsets (TkWindow *winPtr, int deltaX, int deltaY);
  *----------------------------------------------------------------------
  */
 
-void 
+void
 XDestroyWindow(
     Display* display,		/* Display. */
     Window window)		/* Window. */
 {
     MacDrawable *macWin = (MacDrawable *) window;
-    CGrafPtr     destPort;
+    CGrafPtr destPort;
     /*
      * Remove any dangling pointers that may exist if
      * the window we are deleting is being tracked by
@@ -68,68 +64,69 @@ XDestroyWindow(
     macWin->toplevel->referenceCount--;
 
     if (Tk_IsTopLevel(macWin->winPtr)) {
-        WindowRef winRef;
-        /*
-         * We are relying on the Activate Mac OS event to pass the
-         * focus away from a window that is getting Destroyed to the
-         * Front non-floating window.  BUT we don't get activate events
-         * when a floating window is destroyed - since the front non-floating
-         * window doesn't in fact get activated...  So maybe we can check here
-         * and if we are destroying a floating window, we can pass the focus
-         * back to the front non-floating window...
-         */
-         
-        if (macWin->grafPtr != NULL) {
-            TkWindow *focusPtr = TkGetFocusWin(macWin->winPtr);
-            if (focusPtr == NULL || (focusPtr->mainPtr->winPtr == macWin->winPtr)) {
-                winRef = GetWindowFromPort(macWin->grafPtr);
-                if (TkpIsWindowFloating (winRef)) {
-                    Window window;
-                    
-                    window = TkMacOSXGetXWindow(ActiveNonFloatingWindow());
-                    if (window != None) {
-                        TkMacOSXGenerateFocusEvent(window, 1);
-                    }
-                }
-            }
-        }
+	WindowRef winRef;
+	/*
+	 * We are relying on the Activate Mac OS event to pass the
+	 * focus away from a window that is getting Destroyed to the
+	 * Front non-floating window. BUT we don't get activate events
+	 * when a floating window is destroyed - since the front non-floating
+	 * window doesn't in fact get activated... So maybe we can check here
+	 * and if we are destroying a floating window, we can pass the focus
+	 * back to the front non-floating window...
+	 */
+
+	if (macWin->grafPtr != NULL) {
+	    TkWindow *focusPtr = TkGetFocusWin(macWin->winPtr);
+	    if (focusPtr == NULL || (focusPtr->mainPtr->winPtr == macWin->winPtr)) {
+		winRef = GetWindowFromPort(macWin->grafPtr);
+		if (TkpIsWindowFloating (winRef)) {
+		    Window window;
+
+		    window = TkMacOSXGetXWindow(ActiveNonFloatingWindow());
+		    if (window != None) {
+			TkMacOSXGenerateFocusEvent(window, 1);
+		    }
+		}
+	    }
+	}
 	DisposeRgn(macWin->clipRgn);
 	DisposeRgn(macWin->aboveClipRgn);
-	
+	DisposeRgn(macWin->drawRgn);
+
 	/*
 	 * Delete the Mac window and remove it from the windowTable.
 	 * The window could be NULL if the window was never mapped.
 	 * However, we don't do this for embedded windows, they don't
 	 * go in the window list, and they do not own their portPtr's.
 	 */
-	 
+
 	if (!(Tk_IsEmbedded(macWin->winPtr))) {
-            destPort = TkMacOSXGetDrawablePort(window);
+	    destPort = TkMacOSXGetDrawablePort(window);
 	    if (destPort != NULL) {
-	        TkMacOSXWindowList *listPtr, *prevPtr;
-                WindowRef        winRef;
-                winRef = GetWindowFromPort(destPort);
-	        TkMacOSXUnregisterMacWindow(winRef);
-	        DisposeWindow(winRef);
-	    
-	        for (listPtr = tkMacOSXWindowListPtr, prevPtr = NULL;
-	    	        tkMacOSXWindowListPtr != NULL;
-	    	        prevPtr = listPtr, listPtr = listPtr->nextPtr) {
-	            if (listPtr->winPtr == macWin->winPtr) {
-	                if (prevPtr == NULL) {
-	            	    tkMacOSXWindowListPtr = listPtr->nextPtr;
-	                } else {
-	            	    prevPtr->nextPtr = listPtr->nextPtr;
-	                }
-	                ckfree((char *) listPtr);
-	                break;
-	            }
-	        }
+		TkMacOSXWindowList *listPtr, *prevPtr;
+		WindowRef winRef;
+		winRef = GetWindowFromPort(destPort);
+		TkMacOSXUnregisterMacWindow(winRef);
+		DisposeWindow(winRef);
+
+		for (listPtr = tkMacOSXWindowListPtr, prevPtr = NULL;
+			tkMacOSXWindowListPtr != NULL;
+			prevPtr = listPtr, listPtr = listPtr->nextPtr) {
+		    if (listPtr->winPtr == macWin->winPtr) {
+			if (prevPtr == NULL) {
+			    tkMacOSXWindowListPtr = listPtr->nextPtr;
+			} else {
+			    prevPtr->nextPtr = listPtr->nextPtr;
+			}
+			ckfree((char *) listPtr);
+			break;
+		    }
+		}
 	    }
 	}
-	
+
 	macWin->grafPtr = NULL;
-	
+
 	/*
 	 * Delay deletion of a toplevel data structure untill all
 	 * children have been deleted.
@@ -138,18 +135,14 @@ XDestroyWindow(
 	    ckfree((char *) macWin->toplevel);
 	}
     } else {
-        CGrafPtr destPort;
-        destPort = TkMacOSXGetDrawablePort(window);
-	if (destPort != NULL) {
-	    SetGWorld(destPort, NULL);
-	    TkMacOSXInvalidateWindow(macWin, TK_PARENT_WINDOW);
-	}
+	TkMacOSXInvalidateWindow(macWin, TK_PARENT_WINDOW);
 	if (macWin->winPtr->parentPtr != NULL) {
 	    TkMacOSXInvalClipRgns((Tk_Window) macWin->winPtr->parentPtr);
 	}
 	DisposeRgn(macWin->clipRgn);
 	DisposeRgn(macWin->aboveClipRgn);
-	
+	DisposeRgn(macWin->drawRgn);
+
 	if (macWin->toplevel->referenceCount == 0) {
 	    ckfree((char *) macWin->toplevel);
 	}
@@ -162,7 +155,7 @@ XDestroyWindow(
  *
  * XMapWindow --
  *
- *	Map the given X Window to the screen.  See X window documentation 
+ *	Map the given X Window to the screen. See X window documentation
  *  for more details.
  *
  * Results:
@@ -174,7 +167,7 @@ XDestroyWindow(
  *----------------------------------------------------------------------
  */
 
-void 
+void
 XMapWindow(
     Display* display,		/* Display. */
     Window window)		/* Window. */
@@ -186,7 +179,7 @@ XMapWindow(
     /*
      * Under certain situations it's possible for this function to be
      * called before the toplevel window it's associated with has actually
-     * been mapped.  In that case we need to create the real Macintosh
+     * been mapped. In that case we need to create the real Macintosh
      * window now as this function as well as other X functions assume that
      * the portPtr is valid.
      */
@@ -204,7 +197,7 @@ XMapWindow(
 	     * XXX windows that have a wmPtr->master parent set.
 	     */
 	    WindowRef wRef = GetWindowFromPort(destPort);
-	    if ((TkMacOSXWindowClass(macWin->winPtr) == kSheetWindowClass)
+	    if ((macWin->winPtr->wmInfoPtr->macClass == kSheetWindowClass)
 		    && (macWin->winPtr->wmInfoPtr->master != None)) {
 		ShowSheetWindow(wRef,
 			GetWindowFromPort(TkMacOSXGetDrawablePort(macWin->winPtr->wmInfoPtr->master)));
@@ -212,25 +205,25 @@ XMapWindow(
 		ShowWindow(wRef);
 	    }
 	}
+	TkMacOSXInvalClipRgns((Tk_Window) macWin->winPtr);
 
-	/* 
+	/*
 	 * We only need to send the MapNotify event
 	 * for toplevel windows.
 	 */
 	event.xany.serial = display->request;
 	event.xany.send_event = False;
 	event.xany.display = display;
-	
+
 	event.xmap.window = window;
 	event.xmap.type = MapNotify;
 	event.xmap.event = window;
 	event.xmap.override_redirect = macWin->winPtr->atts.override_redirect;
 	Tk_QueueWindowEvent(&event, TCL_QUEUE_TAIL);
     } else {
-	/* 
-	 * Generate damage for that area of the window 
+	/*
+	 * Generate damage for that area of the window
 	 */
-	SetGWorld(destPort, NULL);
 	TkMacOSXInvalClipRgns((Tk_Window) macWin->winPtr->parentPtr);
 	TkMacOSXInvalidateWindow(macWin, TK_PARENT_WINDOW);
     }
@@ -241,7 +234,7 @@ XMapWindow(
  *
  * XUnmapWindow --
  *
- *	Unmap the given X Window to the screen.  See X window
+ *	Unmap the given X Window to the screen. See X window
  *	documentation for more details.
  *
  * Results:
@@ -253,7 +246,7 @@ XMapWindow(
  *----------------------------------------------------------------------
  */
 
-void 
+void
 XUnmapWindow(
     Display* display,		/* Display. */
     Window window)		/* Window. */
@@ -273,15 +266,16 @@ XUnmapWindow(
 	     * XXX windows that have a wmPtr->master parent set.
 	     */
 	    WindowRef wref = GetWindowFromPort(destPort);
-	    if ((TkMacOSXWindowClass(macWin->winPtr) == kSheetWindowClass)
+	    if ((macWin->winPtr->wmInfoPtr->macClass == kSheetWindowClass)
 		    && (macWin->winPtr->wmInfoPtr->master != None)) {
 		HideSheetWindow(wref);
 	    } else {
 		HideWindow(wref);
 	    }
 	}
+	TkMacOSXInvalClipRgns((Tk_Window) macWin->winPtr);
 
-	/* 
+	/*
 	 * We only need to send the UnmapNotify event
 	 * for toplevel windows.
 	 */
@@ -295,10 +289,9 @@ XUnmapWindow(
 	event.xunmap.from_configure = false;
 	Tk_QueueWindowEvent(&event, TCL_QUEUE_TAIL);
     } else {
-	/* 
+	/*
 	 * Generate damage for that area of the window.
 	 */
-	SetGWorld(destPort, NULL);
 	TkMacOSXInvalidateWindow(macWin, TK_PARENT_WINDOW);
 	TkMacOSXInvalClipRgns((Tk_Window) macWin->winPtr->parentPtr);
     }
@@ -309,7 +302,7 @@ XUnmapWindow(
  *
  * XResizeWindow --
  *
- *	Resize a given X window.  See X windows documentation for
+ *	Resize a given X window. See X windows documentation for
  *	further details.
  *
  * Results:
@@ -321,104 +314,99 @@ XUnmapWindow(
  *----------------------------------------------------------------------
  */
 
-void 
+void
 XResizeWindow(
     Display* display,		/* Display. */
-    Window window, 		/* Window. */
+    Window window,		/* Window. */
     unsigned int width,
     unsigned int height)
 {
     MacDrawable *macWin = (MacDrawable *) window;
-    CGrafPtr     destPort;
-    int havePort = 1;
+    CGrafPtr	 destPort;
 
     destPort = TkMacOSXGetDrawablePort(window);
-    if (destPort == NULL) {
-	havePort = 0;
-    }
-
     display->request++;
     if (Tk_IsTopLevel(macWin->winPtr)) {
 	if (!Tk_IsEmbedded(macWin->winPtr)) {
-	    /* 
+	    /*
 	     * NOTE: we are not adding the new space to the update
-	     * region.  It is currently assumed that Tk will need
+	     * region. It is currently assumed that Tk will need
 	     * to completely redraw anway.
 	     */
-            if (havePort) {
-                SetPort(destPort);
-	        SizeWindow(GetWindowFromPort(destPort),
-		        (short) width, (short) height, false);
-	        TkMacOSXInvalidateWindow(macWin, TK_WINDOW_ONLY);
-	        TkMacOSXInvalClipRgns((Tk_Window) macWin->winPtr);
-            }
+	    if (destPort) {
+		WindowRef w = GetWindowFromPort(destPort);
+		Rect bounds;
+
+		ChkErr(GetWindowBounds, w, kWindowContentRgn, &bounds);
+		bounds.right = bounds.left + width;
+		bounds.bottom = bounds.top + height;
+		ChkErr(SetWindowBounds, w, kWindowContentRgn, &bounds);
+		TkMacOSXInvalidateWindow(macWin, TK_WINDOW_ONLY);
+	    }
 	} else {
 	    int deltaX, deltaY;
-	    
+
 	    /*
 	     * Find the Parent window -
-	     *    For an embedded window this will be its container.
+	     * For an embedded window this will be its container.
 	     */
 	    TkWindow *contWinPtr;
-	    
+
 	    contWinPtr = TkpGetOtherWindow(macWin->winPtr);
-	    
+
 	    if (contWinPtr != NULL) {
-	        MacDrawable *macParent = contWinPtr->privatePtr;
+		MacDrawable *macParent = contWinPtr->privatePtr;
 
-                if (havePort) {
-                    SetPort(destPort);
+		if (destPort) {
 		    TkMacOSXInvalidateWindow(macWin, TK_PARENT_WINDOW);
-		    TkMacOSXInvalClipRgns((Tk_Window) macParent->winPtr);	
+		    TkMacOSXInvalClipRgns((Tk_Window) macParent->winPtr);
 		}
 		deltaX = macParent->xOff +
 		    macWin->winPtr->changes.x - macWin->xOff;
 		deltaY = macParent->yOff +
 		    macWin->winPtr->changes.y - macWin->yOff;
-		
+
 		UpdateOffsets(macWin->winPtr, deltaX, deltaY);
 	    } else {
-	        /*
-	         * This is the case where we are embedded in
-	         * another app.  At this point, we are assuming that
-	         * the changes.x,y is not maintained, if you need
+		/*
+		 * This is the case where we are embedded in
+		 * another app. At this point, we are assuming that
+		 * the changes.x,y is not maintained, if you need
 		 * the info get it from Tk_GetRootCoords,
-	         * and that the toplevel sits at 0,0 when it is drawn.
-	         */
-		
+		 * and that the toplevel sits at 0,0 when it is drawn.
+		 */
+
 		TkMacOSXInvalidateWindow(macWin, TK_PARENT_WINDOW);
 		UpdateOffsets(macWin->winPtr, 0, 0);
 	    }
-	         
-	}   
+
+	}
     } else {
 	/* TODO: update all xOff & yOffs */
 	int deltaX, deltaY, parentBorderwidth;
 	MacDrawable *macParent = macWin->winPtr->parentPtr->privatePtr;
-	
+
 	if (macParent == NULL) {
 	    return; /* TODO: Probably should be a panic */
 	}
-	
-        if (havePort) {
-            SetPort(destPort);
+
+	if (destPort) {
 	    TkMacOSXInvalidateWindow(macWin, TK_PARENT_WINDOW);
-	    TkMacOSXInvalClipRgns((Tk_Window) macParent->winPtr);	
-        }
+	    TkMacOSXInvalClipRgns((Tk_Window) macParent->winPtr);
+	}
 	deltaX = - macWin->xOff;
 	deltaY = - macWin->yOff;
 
 	parentBorderwidth = macWin->winPtr->parentPtr->changes.border_width;
-	
+
 	deltaX += macParent->xOff + parentBorderwidth +
 	    macWin->winPtr->changes.x;
 	deltaY += macParent->yOff + parentBorderwidth +
 	    macWin->winPtr->changes.y;
-        
+
 	UpdateOffsets(macWin->winPtr, deltaX, deltaY);
     }
 }
-
 
 /*
  *----------------------------------------------------------------------
@@ -426,9 +414,9 @@ XResizeWindow(
  * GenerateConfigureNotify --
  *
  *	Generates ConfigureNotify events for all the child widgets
- *      of the widget passed in the winPtr parameter.  If includeWin
- *      is true, also generates ConfigureNotify event for the 
- *      widget itself.
+ *	of the widget passed in the winPtr parameter. If includeWin
+ *	is true, also generates ConfigureNotify event for the
+ *	widget itself.
  *
  * Results:
  *	None.
@@ -445,24 +433,23 @@ GenerateConfigureNotify (TkWindow *winPtr, int includeWin)
     TkWindow *childPtr;
 
     for (childPtr = winPtr->childList; childPtr != NULL;
-                               childPtr = childPtr->nextPtr) {
-        if (!Tk_IsMapped(childPtr) || Tk_IsTopLevel(childPtr)) {
-            continue;
-        }
-        GenerateConfigureNotify(childPtr, 1);
+			       childPtr = childPtr->nextPtr) {
+	if (!Tk_IsMapped(childPtr) || Tk_IsTopLevel(childPtr)) {
+	    continue;
+	}
+	GenerateConfigureNotify(childPtr, 1);
     }
     if (includeWin) {
-        TkDoConfigureNotify(winPtr);
+	TkDoConfigureNotify(winPtr);
     }
-}    
-
-
+}
+
 /*
  *----------------------------------------------------------------------
  *
  * XMoveResizeWindow --
  *
- *	Move or resize a given X window.  See X windows documentation
+ *	Move or resize a given X window. See X windows documentation
  *	for further details.
  *
  * Results:
@@ -474,83 +461,79 @@ GenerateConfigureNotify (TkWindow *winPtr, int includeWin)
  *----------------------------------------------------------------------
  */
 
-void 
+void
 XMoveResizeWindow(
     Display* display,		/* Display. */
-    Window window, 		/* Window. */
+    Window window,		/* Window. */
     int x, int y,
     unsigned int width,
     unsigned int height)
-{	
+{
     MacDrawable * macWin = (MacDrawable *) window;
-    CGrafPtr      destPort;
-    int havePort = 1;
+    CGrafPtr	  destPort;
 
     destPort   = TkMacOSXGetDrawablePort(window);
-    if (destPort == NULL) {
-	havePort = 0;
-    }
-
-    if (Tk_IsTopLevel(macWin->winPtr) && !Tk_IsEmbedded(macWin->winPtr)) {	
-	/* 
+    if (Tk_IsTopLevel(macWin->winPtr) && !Tk_IsEmbedded(macWin->winPtr)) {
+	/*
 	 * NOTE: we are not adding the new space to the update
-	 * region.  It is currently assumed that Tk will need
+	 * region. It is currently assumed that Tk will need
 	 * to completely redraw anway.
 	 */
-        if (havePort) {
-            SetPort( destPort);
-	    SizeWindow(GetWindowFromPort(destPort),
-		    (short) width, (short) height, false);
-	    MoveWindowStructure(GetWindowFromPort(destPort), x, y);
-	
+	if (destPort) {
+	    Rect bounds;
+
+	    bounds.left = x + macWin->winPtr->wmInfoPtr->xInParent;
+	    bounds.right = bounds.left + width;
+	    bounds.top = y + macWin->winPtr->wmInfoPtr->yInParent;
+	    bounds.bottom = bounds.top + height;
+	    ChkErr(SetWindowBounds, GetWindowFromPort(destPort),
+		    kWindowContentRgn, &bounds);
 	    TkMacOSXInvalidateWindow(macWin, TK_WINDOW_ONLY);
-	    TkMacOSXInvalClipRgns((Tk_Window) macWin->winPtr);
-        }
+	}
     } else {
 	int deltaX, deltaY, parentBorderwidth;
 	Rect bounds;
 	MacDrawable *macParent;
-	
-        /*
-         * Find the Parent window -
-         *    For an embedded window this will be its container.
-         */
-         
+
+	/*
+	 * Find the Parent window -
+	 *    For an embedded window this will be its container.
+	 */
+
 	if (Tk_IsEmbedded(macWin->winPtr)) {
 	    TkWindow *contWinPtr;
-	    
+
 	    contWinPtr = TkpGetOtherWindow(macWin->winPtr);
 	    if (contWinPtr == NULL) {
 		Tcl_Panic("XMoveResizeWindow could not find container");
 	    }
 	    macParent = contWinPtr->privatePtr;
-	    
+
 	    /*
 	     * NOTE: Here we should handle out of process embedding.
 	     */
-	
-	    
+
+
 	} else {
-	    macParent = macWin->winPtr->parentPtr->privatePtr;   
+	    macParent = macWin->winPtr->parentPtr->privatePtr;
 	    if (macParent == NULL) {
-	        return; /* TODO: Probably should be a panic */
+		return; /* TODO: Probably should be a panic */
 	    }
 	}
 
-	if (havePort) {
-	    SetPort( destPort);
+	if (destPort) {
 	    TkMacOSXInvalidateWindow(macWin, TK_PARENT_WINDOW);
 	    TkMacOSXInvalClipRgns((Tk_Window) macParent->winPtr);
 	}
 
 	deltaX = - macWin->xOff;
 	deltaY = - macWin->yOff;
-	
-        /*
+
+	/*
 	 * If macWin->winPtr is an embedded window, don't offset by its
 	 *  parent's borderwidth...
 	 */
-	 
+
 	if (!Tk_IsEmbedded(macWin->winPtr)) {
 	    parentBorderwidth = macWin->winPtr->parentPtr->changes.border_width;
 	} else {
@@ -560,13 +543,13 @@ XMoveResizeWindow(
 	    macWin->winPtr->changes.x;
 	deltaY += macParent->yOff + parentBorderwidth +
 	    macWin->winPtr->changes.y;
-		
+
 	UpdateOffsets(macWin->winPtr, deltaX, deltaY);
-        if (havePort) {
+	if (destPort) {
 	    TkMacOSXWinBounds(macWin->winPtr, &bounds);
 	    InvalWindowRect(GetWindowFromPort(destPort),&bounds);
-        }
-        GenerateConfigureNotify(macWin->winPtr, 0);
+	}
+	GenerateConfigureNotify(macWin->winPtr, 0);
     }
 }
 
@@ -575,7 +558,7 @@ XMoveResizeWindow(
  *
  * XMoveWindow --
  *
- *	Move a given X window.  See X windows documentation for further
+ *	Move a given X window. See X windows documentation for further
  *  details.
  *
  * Results:
@@ -587,7 +570,7 @@ XMoveResizeWindow(
  *----------------------------------------------------------------------
  */
 
-void 
+void
 XMoveWindow(
     Display* display,		/* Display. */
     Window window,		/* Window. */
@@ -596,70 +579,64 @@ XMoveWindow(
 {
     MacDrawable *macWin = (MacDrawable *) window;
     CGrafPtr  destPort;
-    int havePort = 1;
 
     destPort   = TkMacOSXGetDrawablePort(window);
-    if (destPort == NULL) {
-	havePort = 0;
-    }
 
     if (Tk_IsTopLevel(macWin->winPtr) && !Tk_IsEmbedded(macWin->winPtr)) {
-	/* 
+	/*
 	 * NOTE: we are not adding the new space to the update
-	 * region.  It is currently assumed that Tk will need
+	 * region. It is currently assumed that Tk will need
 	 * to completely redraw anway.
 	 */
-        if (havePort) { 
-            SetPort(destPort);
-	    MoveWindowStructure( GetWindowFromPort(destPort), x, y);
+	if (destPort) {
+	    WindowRef w = GetWindowFromPort(destPort);
 
+	    MoveWindowStructure(w, x, y);
 	    TkMacOSXInvalidateWindow(macWin, TK_WINDOW_ONLY);
-	    TkMacOSXInvalClipRgns((Tk_Window) macWin->winPtr);
-        }
+	}
     } else {
 	int deltaX, deltaY, parentBorderwidth;
 	Rect bounds;
 	MacDrawable *macParent;
-	
-        /*
-         * Find the Parent window -
-         * For an embedded window this will be its container.
-         */
-         
+
+	/*
+	 * Find the Parent window -
+	 * For an embedded window this will be its container.
+	 */
+
 	if (Tk_IsEmbedded(macWin->winPtr)) {
 	    TkWindow *contWinPtr;
-	    
+
 	    contWinPtr = TkpGetOtherWindow(macWin->winPtr);
 	    if (contWinPtr == NULL) {
 		Tcl_Panic("XMoveWindow could not find container");
 	    }
 	    macParent = contWinPtr->privatePtr;
-	    
+
 	    /*
 	     * NOTE: Here we should handle out of process embedding.
 	     */
-		    
+
 	} else {
-	    macParent = macWin->winPtr->parentPtr->privatePtr;   
+	    macParent = macWin->winPtr->parentPtr->privatePtr;
 	    if (macParent == NULL) {
-	        return; /* TODO: Probably should be a panic */
+		return; /* TODO: Probably should be a panic */
 	    }
 	}
 
-        if (havePort) {
-            SetPort(destPort);
+	if (destPort) {
 	    TkMacOSXInvalidateWindow(macWin, TK_PARENT_WINDOW);
 	    TkMacOSXInvalClipRgns((Tk_Window) macParent->winPtr);
-        }
-        
+	}
+
 	deltaX = - macWin->xOff;
 	deltaY = - macWin->yOff;
-	
-        /*
+
+	/*
 	 * If macWin->winPtr is an embedded window, don't offset by its
 	 *  parent's borderwidth...
 	 */
-	 
+
 	if (!Tk_IsEmbedded(macWin->winPtr)) {
 	    parentBorderwidth = macWin->winPtr->parentPtr->changes.border_width;
 	} else {
@@ -669,12 +646,12 @@ XMoveWindow(
 	    macWin->winPtr->changes.x;
 	deltaY += macParent->yOff + parentBorderwidth +
 	    macWin->winPtr->changes.y;
-		
+
 	UpdateOffsets(macWin->winPtr, deltaX, deltaY);
-	if (havePort) {
-            TkMacOSXWinBounds(macWin->winPtr, &bounds);
+	if (destPort) {
+	    TkMacOSXWinBounds(macWin->winPtr, &bounds);
 	    InvalWindowRect(GetWindowFromPort(destPort),&bounds);
-        }
+	}
 	GenerateConfigureNotify(macWin->winPtr, 0);
     }
 }
@@ -695,18 +672,18 @@ XMoveWindow(
  *----------------------------------------------------------------------
  */
 
-void 
+void
 XRaiseWindow(
     Display* display,		/* Display. */
     Window window)		/* Window. */
 {
     MacDrawable *macWin = (MacDrawable *) window;
-    
+
     display->request++;
     if (Tk_IsTopLevel(macWin->winPtr) && !Tk_IsEmbedded(macWin->winPtr)) {
 	TkWmRestackToplevel(macWin->winPtr, Above, NULL);
     } else {
-    	/* TODO: this should generate damage */
+	/* TODO: this should generate damage */
     }
 }
 
@@ -727,18 +704,18 @@ XRaiseWindow(
  *----------------------------------------------------------------------
  */
 
-void 
+void
 XLowerWindow(
     Display* display,		/* Display. */
     Window window)		/* Window. */
 {
     MacDrawable *macWin = (MacDrawable *) window;
-    
+
     display->request++;
     if (Tk_IsTopLevel(macWin->winPtr) && !Tk_IsEmbedded(macWin->winPtr)) {
 	TkWmRestackToplevel(macWin->winPtr, Below, NULL);
     } else {
-    	/* TODO: this should generate damage */
+	/* TODO: this should generate damage */
     }
 }
 #endif
@@ -755,7 +732,7 @@ XLowerWindow(
  *	None.
  *
  * Side effects:
- *	Changes the attributes of the specified window.  Note that we
+ *	Changes the attributes of the specified window. Note that we
  *	ignore the passed in values and use the values stored in the
  *	TkWindow data structure.
  *
@@ -784,8 +761,8 @@ XConfigureWindow(
     }
 
     /*
-     * Change the stacking order of the window.  Tk actuall keeps all
-     * the information we need for stacking order.  All we need to do
+     * Change the stacking order of the window. Tk actuall keeps all
+     * the information we need for stacking order. All we need to do
      * is make sure the clipping regions get updated and generate damage
      * that will ensure things get drawn correctly.
      */
@@ -793,28 +770,27 @@ XConfigureWindow(
     if (value_mask & CWStackMode) {
 	Rect bounds;
 	CGrafPtr destPort;
-	
+
 	destPort = TkMacOSXGetDrawablePort(w);
 	if (destPort != NULL) {
-	    SetPort( destPort);
 	    TkMacOSXInvalClipRgns((Tk_Window) winPtr->parentPtr);
 	    TkMacOSXWinBounds(winPtr, &bounds);
 	    InvalWindowRect(GetWindowFromPort(destPort),&bounds);
 	}
-    } 
+    }
 
-    /* TkGenWMMoveRequestEvent(macWin->winPtr, 
+    /* TkGenWMMoveRequestEvent(macWin->winPtr,
 	    macWin->winPtr->changes.x, macWin->winPtr->changes.y); */
 }
 
 /*
  *----------------------------------------------------------------------
  *
- *  TkMacOSXUpdateClipRgn --
+ * TkMacOSXUpdateClipRgn --
  *
  *	This function updates the cliping regions for a given window
- *	and all of its children.  Once updated the TK_CLIP_INVALID flag
- *	in the subwindow data structure is unset.  The TK_CLIP_INVALID 
+ *	and all of its children. Once updated the TK_CLIP_INVALID flag
+ *	in the subwindow data structure is unset. The TK_CLIP_INVALID
  *	flag should always be unset before any drawing is attempted.
  *
  * Results:
@@ -841,21 +817,18 @@ TkMacOSXUpdateClipRgn(
     if (winPtr->privatePtr && winPtr->privatePtr->flags & TK_CLIP_INVALID) {
 	if (Tk_IsMapped(winPtr)) {
 	    rgn = winPtr->privatePtr->aboveClipRgn;
-	    if (tmpRgn == NULL) {
-		tmpRgn = NewRgn();
-	    }
 
-	    /* 
+	    /*
 	     * Start with a region defined by the window bounds.
 	     */
 
 	    x = winPtr->privatePtr->xOff;
 	    y = winPtr->privatePtr->yOff;
 	    SetRectRgn(rgn, (short) x, (short) y,
-		(short) (winPtr->changes.width  + x), 
+		(short) (winPtr->changes.width	+ x),
 		(short) (winPtr->changes.height + y));
 
-	    /* 
+	    /*
 	     * Clip away the area of any windows that may obscure this
 	     * window.
 	     * For a non-toplevel window, first, clip to the parents visible
@@ -863,14 +836,15 @@ TkMacOSXUpdateClipRgn(
 	     * Second, clip away any siblings that are higher in the
 	     * stacking order.
 	     * For an embedded toplevel, just clip to the container's visible
-	     * clip region.  Remember, we only allow one contained window
+	     * clip region. Remember, we only allow one contained window
 	     * in a frame, and don't support any other widgets in the frame
 	     * either. This is not currently enforced, however.
 	     */
 
-	    if (!Tk_IsTopLevel(winPtr)) { 
+	    if (!Tk_IsTopLevel(winPtr)) {
 		TkMacOSXUpdateClipRgn(winPtr->parentPtr);
-		SectRgn(rgn, 
+		TkMacOSXCheckTmpRgnEmpty(1);
+		SectRgn(rgn,
 			winPtr->parentPtr->privatePtr->aboveClipRgn, rgn);
 
 		win2Ptr = winPtr->nextPtr;
@@ -881,10 +855,10 @@ TkMacOSXUpdateClipRgn(
 		    }
 		    x = win2Ptr->privatePtr->xOff;
 		    y = win2Ptr->privatePtr->yOff;
-		    SetRectRgn(tmpRgn, (short) x, (short) y,
-			    (short) (win2Ptr->changes.width  + x), 
+		    SetRectRgn(tkMacOSXtmpRgn1, (short) x, (short) y,
+			    (short) (win2Ptr->changes.width  + x),
 			    (short) (win2Ptr->changes.height + y));
-		    DiffRgn(rgn, tmpRgn, rgn);
+		    DiffRgn(rgn, tkMacOSXtmpRgn1, rgn);
 
 		    win2Ptr = win2Ptr->nextPtr;
 		}
@@ -893,11 +867,14 @@ TkMacOSXUpdateClipRgn(
 
 		if (contWinPtr != NULL) {
 		    TkMacOSXUpdateClipRgn(contWinPtr);
-		    SectRgn(rgn, 
+		    TkMacOSXCheckTmpRgnEmpty(1);
+		    SectRgn(rgn,
 			    contWinPtr->privatePtr->aboveClipRgn, rgn);
 		} else if (tkMacOSXEmbedHandler != NULL) {
-		    tkMacOSXEmbedHandler->getClipProc((Tk_Window) winPtr, tmpRgn);
-		    SectRgn(rgn, tmpRgn, rgn);
+		    TkMacOSXCheckTmpRgnEmpty(1);
+		    tkMacOSXEmbedHandler->getClipProc((Tk_Window) winPtr,
+			    tkMacOSXtmpRgn1);
+		    SectRgn(rgn, tkMacOSXtmpRgn1, rgn);
 		}
 
 		/*
@@ -906,10 +883,10 @@ TkMacOSXUpdateClipRgn(
 
 	    }
 
-	    /* 
+	    /*
 	     * The final clip region is the aboveClip region (or visible
 	     * region) minus all the children of this window.
-	     * Alternatively, if the window is a container, we must also 
+	     * Alternatively, if the window is a container, we must also
 	     * subtract the region of the embedded window.
 	     */
 
@@ -924,10 +901,10 @@ TkMacOSXUpdateClipRgn(
 		}
 		x = win2Ptr->privatePtr->xOff;
 		y = win2Ptr->privatePtr->yOff;
-		SetRectRgn(tmpRgn, (short) x, (short) y,
-			(short) (win2Ptr->changes.width  + x), 
+		SetRectRgn(tkMacOSXtmpRgn1, (short) x, (short) y,
+			(short) (win2Ptr->changes.width	 + x),
 			(short) (win2Ptr->changes.height + y));
-		DiffRgn(rgn, tmpRgn, rgn);
+		DiffRgn(rgn, tkMacOSXtmpRgn1, rgn);
 
 		win2Ptr = win2Ptr->nextPtr;
 	    }
@@ -938,18 +915,19 @@ TkMacOSXUpdateClipRgn(
 		    if (Tk_IsMapped(win2Ptr)) {
 			x = win2Ptr->privatePtr->xOff;
 			y = win2Ptr->privatePtr->yOff;
-			SetRectRgn(tmpRgn, (short) x, (short) y,
-				(short) (win2Ptr->changes.width  + x), 
+			SetRectRgn(tkMacOSXtmpRgn1, (short) x, (short) y,
+				(short) (win2Ptr->changes.width	 + x),
 				(short) (win2Ptr->changes.height + y));
-			DiffRgn(rgn, tmpRgn, rgn);
+			DiffRgn(rgn, tkMacOSXtmpRgn1, rgn);
 		    }
-		} 
+		}
 
 		/*
 		 * NOTE: Here we should handle out of process embedding.
 		 */
 
 	    }
+	    SetEmptyRgn(tkMacOSXtmpRgn1);
 	} else {
 	    /*
 	     * An unmapped window has empty clip regions to prevent any
@@ -957,7 +935,7 @@ TkMacOSXUpdateClipRgn(
 	     * visible. [Bug 940117]
 	     */
 
-	    if (!Tk_IsTopLevel(winPtr)) { 
+	    if (!Tk_IsTopLevel(winPtr)) {
 		TkMacOSXUpdateClipRgn(winPtr->parentPtr);
 	    } else if (Tk_IsEmbedded(winPtr)) {
 		TkWindow *contWinPtr = TkpGetOtherWindow(winPtr);
@@ -972,7 +950,7 @@ TkMacOSXUpdateClipRgn(
 
 	winPtr->privatePtr->flags &= ~TK_CLIP_INVALID;
 
-#if defined(TK_MAC_DEBUG) && defined(TK_MAC_DEBUG_CLIP_REGIONS)
+#ifdef TK_MAC_DEBUG_CLIP_REGIONS
 	TkMacOSXInitNamedDebugSymbol(HIToolbox, int, QDDebugFlashRegion,
 				     CGrafPtr port, RgnHandle region);
 	if (QDDebugFlashRegion) {
@@ -991,8 +969,8 @@ TkMacOSXUpdateClipRgn(
  *
  * TkMacOSXVisableClipRgn --
  *
- *	This function returnd the Macintosh cliping region for the 
- *	given window.  A NULL Rgn means the window is not visible.
+ *	This function returnd the Macintosh cliping region for the
+ *	given window. A NULL Rgn means the window is not visible.
  *
  * Results:
  *	The region.
@@ -1033,7 +1011,7 @@ TkMacOSXVisableClipRgn(
 
 void
 TkMacOSXInvalidateWindow(
-    MacDrawable *macWin,        /* Make window that's causing damage. */
+    MacDrawable *macWin,	/* Make window that's causing damage. */
     int flag)			/* Should be TK_WINDOW_ONLY or
 				 * TK_PARENT_WINDOW */
 {
@@ -1053,7 +1031,7 @@ TkMacOSXInvalidateWindow(
 	    InvalWindowRgn(windowRef, macWin->aboveClipRgn);
 	}
 
-#if defined(TK_MAC_DEBUG) && defined(TK_MAC_DEBUG_CLIP_REGIONS)
+#ifdef TK_MAC_DEBUG_CLIP_REGIONS
 	TkMacOSXInitNamedDebugSymbol(HIToolbox, int, QDDebugFlashRegion,
 				     CGrafPtr port, RgnHandle region);
 	if (QDDebugFlashRegion) {
@@ -1073,7 +1051,7 @@ TkMacOSXInvalidateWindow(
  *	This function returns the Graphics Port for a given X drawable.
  *
  * Results:
- *	A CGrafPort .  Either an off screen pixmap or a Window.
+ *	A CGrafPort . Either an off screen pixmap or a Window.
  *
  * Side effects:
  *	None.
@@ -1086,68 +1064,65 @@ TkMacOSXGetDrawablePort(
     Drawable drawable)
 {
     MacDrawable *macWin = (MacDrawable *) drawable;
-    GWorldPtr resultPort = NULL;
-    
+    CGrafPtr resultPort = NULL;
+
     if (macWin == NULL) {
-        return NULL;
+	return NULL;
     }
-    
+
     /*
-     * This is NULL for off-screen pixmaps.  Then the portPtr
+     * This is NULL for off-screen pixmaps. Then the portPtr
      * always points to the off-screen port, and we don't
      * have to worry about containment
      */
-     
+
     if (macWin->clipRgn == NULL) {
 	return macWin->grafPtr;
     }
-    
+
     /*
      * If the Drawable is in an embedded window, use the Port of its container.
-     *  
+     *
      * TRICKY POINT: we can have cases when a toplevel is being destroyed
-     * where the winPtr for the toplevel has been freed, but the children 
-     * are not all the way destroyed.  The children will call this function
+     * where the winPtr for the toplevel has been freed, but the children
+     * are not all the way destroyed. The children will call this function
      * as they are being destroyed, but Tk_IsEmbedded will return garbage.
-     * So we check the copy of the TK_EMBEDDED flag we put into the 
+     * So we check the copy of the TK_EMBEDDED flag we put into the
      * toplevel's macWin flags.
      */
-     
-     
-     
-    
+
     if (!(macWin->toplevel->flags & TK_EMBEDDED)) {
-        return macWin->toplevel->grafPtr;
+	return macWin->toplevel->grafPtr;
     } else {
-    	TkWindow *contWinPtr;
+	TkWindow *contWinPtr;
 
 	contWinPtr = TkpGetOtherWindow(macWin->toplevel->winPtr);
-	
-    	if (contWinPtr != NULL) {
-    	    resultPort = TkMacOSXGetDrawablePort(
+
+	if (contWinPtr != NULL) {
+	    resultPort = TkMacOSXGetDrawablePort(
 		(Drawable) contWinPtr->privatePtr);
-    	} else if (tkMacOSXEmbedHandler != NULL) {
+	} else if (tkMacOSXEmbedHandler != NULL) {
 	    resultPort = tkMacOSXEmbedHandler->getPortProc(
-                    (Tk_Window) macWin->winPtr);
-    	} 
-	
+		    (Tk_Window) macWin->winPtr);
+	}
+
 	if (resultPort == NULL) {
 	    /*
 	     * FIXME:
 	     *
 	     * So far as I can tell, the only time that this happens is when
 	     * we are tearing down an embedded child interpreter, and most
-	     * of the time, this is harmless...  However, we really need to
+	     * of the time, this is harmless... However, we really need to
 	     * find why the embedding loses.
 	     */
 	    DebugStr("\pTkMacOSXGetDrawablePort couldn't find container");
-    	    return NULL;
-    	}	
-	    
+	    return NULL;
+	}
+
 	/*
 	 * NOTE: Here we should handle out of process embedding.
 	 */
-		    
+
     }
     return resultPort;
 }
@@ -1177,23 +1152,23 @@ TkMacOSXGetRootControl(
      */
     MacDrawable *macWin = (MacDrawable *) drawable;
     ControlRef result = NULL;
-    
+
     if (macWin == NULL) {
-        return NULL;
+	return NULL;
     }
     if (!(macWin->toplevel->flags & TK_EMBEDDED)) {
-        return macWin->toplevel->rootControl;
+	return macWin->toplevel->rootControl;
     } else {
-        TkWindow *contWinPtr;
+	TkWindow *contWinPtr;
 
-        contWinPtr = TkpGetOtherWindow(macWin->toplevel->winPtr);
+	contWinPtr = TkpGetOtherWindow(macWin->toplevel->winPtr);
 
-        if (contWinPtr != NULL) {
-            result = TkMacOSXGetRootControl(
-                (Drawable) contWinPtr->privatePtr);
-        } else if (tkMacOSXEmbedHandler != NULL) {
-            result = NULL;
-        }
+	if (contWinPtr != NULL) {
+	    result = TkMacOSXGetRootControl(
+		(Drawable) contWinPtr->privatePtr);
+	} else if (tkMacOSXEmbedHandler != NULL) {
+	    result = NULL;
+	}
    }
     return result;
 }
@@ -1204,7 +1179,7 @@ TkMacOSXGetRootControl(
  * TkMacOSXInvalClipRgns --
  *
  *	This function invalidates the clipping regions for a given
- *	window and all of its children.  This function should be
+ *	window and all of its children. This function should be
  *	called whenever changes are made to subwindows that would
  *	affect the size or position of windows.
  *
@@ -1213,7 +1188,7 @@ TkMacOSXGetRootControl(
  *
  * Side effects:
  *	The cliping regions for the window and its children are
- *	mark invalid.  (Make sure they are valid before drawing.)
+ *	mark invalid. (Make sure they are valid before drawing.)
  *
  *----------------------------------------------------------------------
  */
@@ -1225,8 +1200,8 @@ TkMacOSXInvalClipRgns(
     TkWindow *winPtr = (TkWindow *) tkwin;
     TkWindow *childPtr;
 
-    /* 
-     * If already marked we can stop because all 
+    /*
+     * If already marked we can stop because all
      * decendants will also already be marked.
      */
     if (!winPtr->privatePtr || winPtr->privatePtr->flags & TK_CLIP_INVALID) {
@@ -1237,8 +1212,8 @@ TkMacOSXInvalClipRgns(
     SetEmptyRgn(winPtr->privatePtr->aboveClipRgn);
     SetEmptyRgn(winPtr->privatePtr->clipRgn);
 
-    /* 
-     * Invalidate clip regions for all children & 
+    /*
+     * Invalidate clip regions for all children &
      * their decendants - unless the child is a toplevel.
      */
     childPtr = winPtr->childList;
@@ -1274,7 +1249,7 @@ TkMacOSXInvalClipRgns(
  *
  *	Given a Tk window this function determines the windows
  *	bounds in relation to the Macintosh window's coordinate
- *	system.  This is also the same coordinate system as the
+ *	system. This is also the same coordinate system as the
  *	Tk toplevel window in which this window is contained.
  *
  * Results:
@@ -1327,14 +1302,14 @@ UpdateOffsets(
 
     if (winPtr->privatePtr == NULL) {
 	/*
-	 * We havn't called Tk_MakeWindowExist for this window yet.  The
-	 * offset information will be postponed and calulated at that 
-	 * time.  (This will usually only happen when a mapped parent is
+	 * We havn't called Tk_MakeWindowExist for this window yet. The
+	 * offset information will be postponed and calulated at that
+	 * time. (This will usually only happen when a mapped parent is
 	 * being moved but has child windows that have yet to be mapped.)
 	 */
 	return;
     }
-    
+
     winPtr->privatePtr->xOff += deltaX;
     winPtr->privatePtr->yOff += deltaY;
 
@@ -1345,17 +1320,17 @@ UpdateOffsets(
 	}
 	childPtr = childPtr->nextPtr;
     }
-    
+
     if (Tk_IsContainer(winPtr)) {
 	childPtr = TkpGetOtherWindow(winPtr);
 	if (childPtr != NULL) {
 	    UpdateOffsets(childPtr,deltaX,deltaY);
 	}
-	    
+
 	/*
 	 * NOTE: Here we should handle out of process embedding.
 	 */
-		    
+
     }
 }
 
@@ -1387,8 +1362,7 @@ Tk_GetPixmap(
     GWorldPtr gWorld;
     Rect bounds;
     MacDrawable *macPix;
-    PixMapHandle pixels;
-    
+
     if (display != NULL) {
 	display->request++;
     }
@@ -1398,6 +1372,7 @@ Tk_GetPixmap(
     macPix->yOff = 0;
     macPix->clipRgn = NULL;
     macPix->aboveClipRgn = NULL;
+    macPix->drawRgn = NULL;
     macPix->referenceCount = 0;
     macPix->toplevel = NULL;
     macPix->flags = 0;
@@ -1409,24 +1384,20 @@ Tk_GetPixmap(
 	depth = 0;
     }
     /*
-     * Allocate memory for the off screen pixmap.  If we fail
-     * try again from system memory.  Eventually, we may have
+     * Allocate memory for the off screen pixmap. If we fail
+     * try again from system memory. Eventually, we may have
      * to panic.
      */
-    err = NewGWorld(&gWorld, depth, &bounds, NULL, NULL, 0);
-    if (err != noErr) {
-	err = NewGWorld(&gWorld, depth, &bounds, NULL, NULL, useTempMem);
-    }
+    err = ChkErr(NewGWorld, &gWorld, depth, &bounds, NULL, NULL, 0
+#ifdef __LITTLE_ENDIAN__
+	    | kNativeEndianPixMap
+#endif
+	    );
     if (err != noErr) {
-        Tcl_Panic("Out of memory: NewGWorld failed in Tk_GetPixmap");
+	Tcl_Panic("Out of memory: NewGWorld failed in Tk_GetPixmap");
     }
-
-    /*
-     * Lock down the pixels so they don't move out from under us.
-     */
-    pixels = GetGWorldPixMap(gWorld);
-    LockPixels(pixels);
     macPix->grafPtr = gWorld;
+    macPix->context = NULL;
 
     return (Pixmap) macPix;
 }
@@ -1447,17 +1418,14 @@ Tk_GetPixmap(
  *----------------------------------------------------------------------
  */
 
-void 
+void
 Tk_FreePixmap(
     Display *display,		/* Display. */
-    Pixmap pixmap)     		/* Pixmap to destroy */
+    Pixmap pixmap)		/* Pixmap to destroy */
 {
     MacDrawable *macPix = (MacDrawable *) pixmap;
-    PixMapHandle pixels;
 
     display->request++;
-    pixels = GetGWorldPixMap(macPix->grafPtr);
-    UnlockPixels(pixels);
     DisposeGWorld(macPix->grafPtr);
     ckfree((char *) macPix);
 }