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

	* macosx/tkMacOSXEvent.c:	 handler for all kEventClassWindow and
	* macosx/tkMacOSXEvent.h:	 kEventClassMouse events;
	* macosx/tkMacOSXNotify.c:	 move all 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
	* macosx/ttkMacOSXTheme.c: 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
	* macosx/ttkMacOSXTheme.c: 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; always draw with CG; remove QD
	dependent stippling algorithm; move most header declarations into the
	source file (as they were not used anywhere else).

	* macosx/tkMacOSXMenu.c:		 large-scale rewrite of custom
	* macosx/tkMacOSXMenu.r (removed):	 MDEF and related code that
	* macosx/Wish.xcode/project.pbxproj:	 restores many longtime-MIA
	* macosx/Wish.xcodeproj/project.pbxproj: features to working order
	* unix/Makefile.in:			 (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/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/ttkMacOSXTheme.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/Wish-Common.xcconfig: add Wish's Info.plist as __info_plist
	section to tktest; enable more warnings.

	* macosx/Wish.xcodeproj/project.pbxproj: add 'DebugMemCompile' build
	configuration that calls configure with --enable-symbols=all; disable
	configure check for __attribute__((__visibility__("hidden"))) in Debug
	configuration to restore availability of ZeroLink.

	* macosx/Wish-Common.xcconfig:	fix whitespace.
	* macosx/Wish-Debug.xcconfig:
	* macosx/Wish-Release.xcconfig:
	* macosx/tkMacOSXAETE.r:
	* macosx/tkMacOSXConfig.c:
	* macosx/tkMacOSXCursors.r:
	* macosx/tkMacOSXKeyboard.c:
	* macosx/tkMacOSXSend.c:
	* macosx/ttkMacOSXTheme.c:
	* macosx/tkMacOSXXCursors.r:
	* macosx/README:

	* macosx/GNUmakefile:		fix/add copyright and license refs.
	* macosx/Tk-Info.plist.in:
	* macosx/Wish-Info.plist.in:
	* macosx/Wish.xcode/project.pbxproj:
	* macosx/Wish.xcodeproj/project.pbxproj:
	* macosx/tkMacOSX.h:

1 files changed, 531 insertions, 537 deletions

diff --git a/macosx/tkMacOSXEmbed.c b/macosx/tkMacOSXEmbed.c
index c82a649..bfd500c 100644
--- a/macosx/tkMacOSXEmbed.c
+++ b/macosx/tkMacOSXEmbed.c
@@ -1,51 +1,52 @@
-/* 
+/*
  * tkMacOSXEmbed.c --
  *
- *        This file contains platform-specific procedures for theMac to provide
- *        basic operations needed for application embedding (where one
- *        application can use as its main window an internal window from
- *        some other application).
- *        Currently only Toplevel embedding within the same Tk application is
- *      allowed on the Macintosh.
+ *	This file contains platform-specific procedures for theMac to provide
+ *	basic operations needed for application embedding (where one
+ *	application can use as its main window an internal window from
+ *	some other application).
+ *	Currently only Toplevel embedding within the same Tk application is
+ *	allowed on the Macintosh.
  *
  * Copyright (c) 1996-1997 Sun Microsystems, Inc.
  * Copyright 2001, Apple Computer, Inc.
+ * 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: tkMacOSXEmbed.c,v 1.8 2006/10/31 22:33:34 das Exp $
+ *  RCS: @(#) $Id: tkMacOSXEmbed.c,v 1.9 2007/04/23 21:24:33 das Exp $
  */
 
 #include "tkMacOSXInt.h"
 
 /*
  * One of the following structures exists for each container in this
- * application.  It keeps track of the container window and its
+ * application. It keeps track of the container window and its
  * associated embedded window.
  */
 
 typedef struct Container {
-    Window parent;                /* The Mac Drawable for the parent of
-                                 * the pair (the container). */
-    TkWindow *parentPtr;        /* Tk's information about the container,
-                                 * or NULL if the container isn't
-                                 * in this process. */
-    Window embedded;                /* The MacDrawable for the embedded
-                                 * window.  Starts off as None, but
-                                 * gets filled in when the window is
-                                 * eventually created. */
-    TkWindow *embeddedPtr;        /* Tk's information about the embedded
-                                 * window, or NULL if the
-                                 * embedded application isn't in
-                                 * this process. */
-    struct Container *nextPtr;        /* Next in list of all containers in
-                                 * this process. */
+    Window parent;		  /* The Mac Drawable for the parent of
+				 * the pair (the container). */
+    TkWindow *parentPtr;	/* Tk's information about the container,
+				 * or NULL if the container isn't
+				 * in this process. */
+    Window embedded;		    /* The MacDrawable for the embedded
+				 * window. Starts off as None, but
+				 * gets filled in when the window is
+				 * eventually created. */
+    TkWindow *embeddedPtr;	  /* Tk's information about the embedded
+				 * window, or NULL if the
+				 * embedded application isn't in
+				 * this process. */
+    struct Container *nextPtr;	      /* Next in list of all containers in
+				 * this process. */
 } Container;
 
 static Container *firstContainerPtr = NULL;
-                                        /* First in list of all containers
-                                         * managed by this process.  */
+					/* First in list of all containers
+					 * managed by this process. */
 /*
  * Globals defined in this file
  */
@@ -56,21 +57,15 @@ TkMacOSXEmbedHandler *tkMacOSXEmbedHandler = NULL;
  * Prototypes for static procedures defined in this file:
  */
 
-static void                ContainerEventProc _ANSI_ARGS_((
-                            ClientData clientData, XEvent *eventPtr));
-static void                EmbeddedEventProc _ANSI_ARGS_((
-                            ClientData clientData, XEvent *eventPtr));
-static void                EmbedActivateProc _ANSI_ARGS_((ClientData clientData, 
-                            XEvent *eventPtr));
-static void                EmbedFocusProc _ANSI_ARGS_((ClientData clientData,
-                            XEvent *eventPtr));
-static void                EmbedGeometryRequest _ANSI_ARGS_((
-                            Container * containerPtr, int width, int height));
-static void                EmbedSendConfigure _ANSI_ARGS_((
-                            Container *containerPtr));
-static void                EmbedStructureProc _ANSI_ARGS_((ClientData clientData,
-                            XEvent *eventPtr));
-static void                EmbedWindowDeleted _ANSI_ARGS_((TkWindow *winPtr));
+static void ContainerEventProc(ClientData clientData, XEvent *eventPtr);
+static void EmbeddedEventProc(ClientData clientData, XEvent *eventPtr);
+static void EmbedActivateProc(ClientData clientData, XEvent *eventPtr);
+static void EmbedFocusProc(ClientData clientData, XEvent *eventPtr);
+static void EmbedGeometryRequest(Container * containerPtr, int width,
+	int height);
+static void EmbedSendConfigure(Container *containerPtr);
+static void EmbedStructureProc(ClientData clientData, XEvent *eventPtr);
+static void EmbedWindowDeleted(TkWindow *winPtr);
 
 
 /*
@@ -78,15 +73,15 @@ static void                EmbedWindowDeleted _ANSI_ARGS_((TkWindow *winPtr));
  *
  * Tk_MacOSXSetEmbedHandler --
  *
- *        Registers a handler for an in process form of embedding, like 
- *        Netscape plugins, where Tk is loaded into the process, but does
- *        not control the main window
+ *	Registers a handler for an in process form of embedding, like
+ *	Netscape plugins, where Tk is loaded into the process, but does
+ *	not control the main window
  *
  * Results:
- *        None
+ *	None
  *
  * Side effects:
- *        The embed handler is set.
+ *	The embed handler is set.
  *
  *----------------------------------------------------------------------
  */
@@ -99,28 +94,27 @@ Tk_MacOSXSetEmbedHandler(
     Tk_MacOSXEmbedGetOffsetInParentProc *getOffsetProc)
 {
     if (tkMacOSXEmbedHandler == NULL) {
-            tkMacOSXEmbedHandler = (TkMacOSXEmbedHandler *) ckalloc(sizeof(TkMacOSXEmbedHandler));
+	    tkMacOSXEmbedHandler = (TkMacOSXEmbedHandler *) ckalloc(sizeof(TkMacOSXEmbedHandler));
     }
     tkMacOSXEmbedHandler->registerWinProc = registerWinProc;
     tkMacOSXEmbedHandler->getPortProc = getPortProc;
     tkMacOSXEmbedHandler->containerExistProc = containerExistProc;
     tkMacOSXEmbedHandler->getClipProc = getClipProc;
-    tkMacOSXEmbedHandler->getOffsetProc = getOffsetProc;    
+    tkMacOSXEmbedHandler->getOffsetProc = getOffsetProc;
 }
-
 
 /*
  *----------------------------------------------------------------------
  *
  * TkpMakeWindow --
  *
- *        Creates an X Window (Mac subwindow).
+ *	Creates an X Window (Mac subwindow).
  *
  * Results:
- *        The window id is returned.
+ *	The window id is returned.
  *
  * Side effects:
- *        None.
+ *	None.
  *
  *----------------------------------------------------------------------
  */
@@ -138,57 +132,55 @@ TkpMakeWindow(
      * the window structure should have already been
      * created in the TkpUseWindow function.
      */
-    
+
     if (Tk_IsEmbedded(winPtr)) {
-        return (Window) winPtr->privatePtr;
+	return (Window) winPtr->privatePtr;
     }
-    
+
     /*
      * Allocate sub window
      */
-    
+
     macWin = (MacDrawable *) ckalloc(sizeof(MacDrawable));
     if (macWin == NULL) {
-        winPtr->privatePtr = NULL;
-        return None;
+	winPtr->privatePtr = NULL;
+	return None;
     }
     macWin->winPtr = winPtr;
     winPtr->privatePtr = macWin;
     macWin->clipRgn = NewRgn();
     macWin->aboveClipRgn = NewRgn();
+    macWin->drawRgn = NewRgn();
     macWin->referenceCount = 0;
     macWin->flags = TK_CLIP_INVALID;
 
+    macWin->grafPtr = NULL;
+    macWin->context = NULL;
     if (Tk_IsTopLevel(macWin->winPtr)) {
-        
-        /*
-         *This will be set when we are mapped.
-         */
-        
-        macWin->grafPtr  = NULL;  
-        macWin->toplevel = macWin;
-        macWin->xOff = 0;
-        macWin->yOff = 0;
+	/*
+	 *This will be set when we are mapped.
+	 */
+	macWin->xOff = 0;
+	macWin->yOff = 0;
+	macWin->toplevel = macWin;
     } else {
-        macWin->grafPtr = NULL;
-        macWin->xOff = winPtr->parentPtr->privatePtr->xOff +
-            winPtr->parentPtr->changes.border_width +
-            winPtr->changes.x;
-        macWin->yOff = winPtr->parentPtr->privatePtr->yOff +
-            winPtr->parentPtr->changes.border_width +
-            winPtr->changes.y;
-        macWin->toplevel = winPtr->parentPtr->privatePtr->toplevel;
+	macWin->xOff = winPtr->parentPtr->privatePtr->xOff +
+	    winPtr->parentPtr->changes.border_width +
+	    winPtr->changes.x;
+	macWin->yOff = winPtr->parentPtr->privatePtr->yOff +
+	    winPtr->parentPtr->changes.border_width +
+	    winPtr->changes.y;
+	macWin->toplevel = winPtr->parentPtr->privatePtr->toplevel;
     }
-
     macWin->toplevel->referenceCount++;
-    
-    /* 
+
+    /*
      * TODO: need general solution for visibility events.
      */
     event.xany.serial = Tk_Display(winPtr)->request;
     event.xany.send_event = False;
     event.xany.display = Tk_Display(winPtr);
-        
+
     event.xvisibility.type = VisibilityNotify;
     event.xvisibility.window = (Window) macWin;
     event.xvisibility.state = VisibilityUnobscured;
@@ -202,31 +194,31 @@ TkpMakeWindow(
  *
  * TkpUseWindow --
  *
- *        This procedure causes a Tk window to use a given X window as
- *        its parent window, rather than the root window for the screen.
- *        It is invoked by an embedded application to specify the window
- *        in which it is embedded.
+ *	This procedure causes a Tk window to use a given X window as
+ *	its parent window, rather than the root window for the screen.
+ *	It is invoked by an embedded application to specify the window
+ *	in which it is embedded.
  *
  * Results:
- *        The return value is normally TCL_OK.  If an error occurs (such
- *        as string not being a valid window spec), then the return value
- *        is TCL_ERROR and an error message is left in the interp's result if
- *        interp is non-NULL.
+ *	The return value is normally TCL_OK. If an error occurs (such
+ *	as string not being a valid window spec), then the return value
+ *	is TCL_ERROR and an error message is left in the interp's result if
+ *	interp is non-NULL.
  *
  * Side effects:
- *        None.
+ *	None.
  *
  *----------------------------------------------------------------------
  */
 
 int
 TkpUseWindow(
-    Tcl_Interp *interp,                /* If not NULL, used for error reporting
-                                 * if string is bogus. */
-    Tk_Window tkwin,                /* Tk window that does not yet have an
-                                 * associated X window. */
-    CONST char *string)                /* String identifying an X window to use
-                                 * for tkwin;  must be an integer value. */
+    Tcl_Interp *interp,		       /* If not NULL, used for error reporting
+				 * if string is bogus. */
+    Tk_Window tkwin,		    /* Tk window that does not yet have an
+				 * associated X window. */
+    CONST char *string)		       /* String identifying an X window to use
+				 * for tkwin; must be an integer value. */
 {
     TkWindow *winPtr = (TkWindow *) tkwin;
     TkWindow *usePtr;
@@ -235,12 +227,13 @@ TkpUseWindow(
     XEvent event;
 
     if (winPtr->window != None) {
-	Tcl_AppendResult(interp, "can't modify container after widget is created", (char *) NULL);
+	Tcl_AppendResult(interp, "can't modify container after widget is "
+		"created", NULL);
 	return TCL_ERROR;
     }
-    
+
     /*
-     * Decode the container pointer, and look for it among the 
+     * Decode the container pointer, and look for it among the
      *list of available containers.
      *
      * N.B. For now, we are limiting the containers to be in the same Tk
@@ -248,9 +241,9 @@ TkpUseWindow(
      * of containers.
      *
      */
-     
+
     if (Tcl_GetInt(interp, string, (int*) &parent) != TCL_OK) {
-        return TCL_ERROR;
+	return TCL_ERROR;
     }
 
     usePtr = (TkWindow *) Tk_IdToWindow(winPtr->display, (Window) parent);
@@ -261,158 +254,159 @@ TkpUseWindow(
 	    return TCL_ERROR;
 	}
     }
-    
-    /* 
+
+    /*
      * The code below can probably be simplified given we have already
      * discovered 'usePtr' above.
      */
 
     /*
      * Save information about the container and the embedded window
-     * in a Container structure.  Currently, there must already be an existing
-     * Container structure, since we only allow the case where both container 
+     * in a Container structure. Currently, there must already be an existing
+     * Container structure, since we only allow the case where both container
      * and embedded app. are in the same process.
      */
 
     for (containerPtr = firstContainerPtr; containerPtr != NULL;
-            containerPtr = containerPtr->nextPtr) {
-        if (containerPtr->parent == (Window) parent) {
-            winPtr->flags |= TK_BOTH_HALVES;
-            containerPtr->parentPtr->flags |= TK_BOTH_HALVES;
-            break;
-        }
+	    containerPtr = containerPtr->nextPtr) {
+	if (containerPtr->parent == (Window) parent) {
+	    winPtr->flags |= TK_BOTH_HALVES;
+	    containerPtr->parentPtr->flags |= TK_BOTH_HALVES;
+	    break;
+	}
     }
-    
+
     /*
-     * Make the embedded window.  
+     * Make the embedded window.
      */
 
     macWin = (MacDrawable *) ckalloc(sizeof(MacDrawable));
     if (macWin == NULL) {
-        winPtr->privatePtr = NULL;
-        return TCL_ERROR;
+	winPtr->privatePtr = NULL;
+	return TCL_ERROR;
     }
-    
+
     macWin->winPtr = winPtr;
     winPtr->privatePtr = macWin;
 
     /*
      * The grafPtr will be NULL for a Tk in Tk embedded window.
      * It is none of our business what it is for a Tk not in Tk embedded window,
-     * but we will initialize it to NULL, and let the registerWinProc 
-     * set it.  In any case, you must always use TkMacOSXGetDrawablePort 
-     * to get the portPtr.  It will correctly find the container's port.
+     * but we will initialize it to NULL, and let the registerWinProc
+     * set it. In any case, you must always use TkMacOSXGetDrawablePort
+     * to get the portPtr. It will correctly find the container's port.
      */
 
     macWin->grafPtr = NULL;
+    macWin->context = NULL;
 
     macWin->clipRgn = NewRgn();
     macWin->aboveClipRgn = NewRgn();
+    macWin->drawRgn = NewRgn();
     macWin->referenceCount = 0;
     macWin->flags = TK_CLIP_INVALID;
     macWin->toplevel = macWin;
     macWin->toplevel->referenceCount++;
-   
+
     winPtr->flags |= TK_EMBEDDED;
-    
-    
+
+
     /*
      * Make a copy of the TK_EMBEDDED flag, since sometimes
      * we need this to get the port after the TkWindow structure
      * has been freed.
      */
-     
+
     macWin->flags |= TK_EMBEDDED;
-    
+
     /*
-     * Now check whether it is embedded in another Tk widget.  If not (the first
+     * Now check whether it is embedded in another Tk widget. If not (the first
      * case below) we see if there is an in-process embedding handler registered,
      * and if so, let that fill in the rest of the macWin.
      */
-    
+
     if (containerPtr == NULL) {
-        /*
-         * If someone has registered an in process embedding handler, then 
-         * see if it can handle this window...
-         */
-        
-        if (tkMacOSXEmbedHandler == NULL ||
-                tkMacOSXEmbedHandler->registerWinProc((int) parent,
-                (Tk_Window) winPtr) != TCL_OK) {
-            Tcl_AppendResult(interp, "The window ID ", string,
-                    " does not correspond to a valid Tk Window.",
-                     (char *) NULL);
-            return TCL_ERROR;        
-        } else {
-            containerPtr = (Container *) ckalloc(sizeof(Container));
-
-            containerPtr->parentPtr = NULL;
-            containerPtr->embedded = (Window) macWin;
-            containerPtr->embeddedPtr = macWin->winPtr;
-            containerPtr->nextPtr = firstContainerPtr;
-            firstContainerPtr = containerPtr;
-            
-        }    
+	/*
+	 * If someone has registered an in process embedding handler, then
+	 * see if it can handle this window...
+	 */
+
+	if (tkMacOSXEmbedHandler == NULL ||
+		tkMacOSXEmbedHandler->registerWinProc((int) parent,
+		(Tk_Window) winPtr) != TCL_OK) {
+	    Tcl_AppendResult(interp, "The window ID ", string,
+		    " does not correspond to a valid Tk Window.", NULL);
+	    return TCL_ERROR;
+	} else {
+	    containerPtr = (Container *) ckalloc(sizeof(Container));
+
+	    containerPtr->parentPtr = NULL;
+	    containerPtr->embedded = (Window) macWin;
+	    containerPtr->embeddedPtr = macWin->winPtr;
+	    containerPtr->nextPtr = firstContainerPtr;
+	    firstContainerPtr = containerPtr;
+
+	}
     } else {
-        
-        /* 
-         * The window is embedded in another Tk window.
-         */ 
-        
-        macWin->xOff = parent->winPtr->privatePtr->xOff +
-                parent->winPtr->changes.border_width +
-                winPtr->changes.x;
-        macWin->yOff = parent->winPtr->privatePtr->yOff +
-                parent->winPtr->changes.border_width +
-                winPtr->changes.y;
-    
-    
-        /*
-         * Finish filling up the container structure with the embedded window's 
-         * information.
-         */
-     
-        containerPtr->embedded = (Window) macWin;
-        containerPtr->embeddedPtr = macWin->winPtr;
-
-        /*
-         * Create an event handler to clean up the Container structure when
-         * tkwin is eventually deleted.
-         */
-
-        Tk_CreateEventHandler(tkwin, StructureNotifyMask, EmbeddedEventProc,
-                (ClientData) winPtr);
+
+	/*
+	 * The window is embedded in another Tk window.
+	 */
+
+	macWin->xOff = parent->winPtr->privatePtr->xOff +
+		parent->winPtr->changes.border_width +
+		winPtr->changes.x;
+	macWin->yOff = parent->winPtr->privatePtr->yOff +
+		parent->winPtr->changes.border_width +
+		winPtr->changes.y;
+
+
+	/*
+	 * Finish filling up the container structure with the embedded window's
+	 * information.
+	 */
+
+	containerPtr->embedded = (Window) macWin;
+	containerPtr->embeddedPtr = macWin->winPtr;
+
+	/*
+	 * Create an event handler to clean up the Container structure when
+	 * tkwin is eventually deleted.
+	 */
+
+	Tk_CreateEventHandler(tkwin, StructureNotifyMask, EmbeddedEventProc,
+		(ClientData) winPtr);
 
     }
 
-   /* 
+   /*
      * TODO: need general solution for visibility events.
      */
-     
+
 
     event.xany.serial = Tk_Display(winPtr)->request;
     event.xany.send_event = False;
     event.xany.display = Tk_Display(winPtr);
-        
+
     event.xvisibility.type = VisibilityNotify;
     event.xvisibility.window = (Window) macWin;;
     event.xvisibility.state = VisibilityUnobscured;
     Tk_QueueWindowEvent(&event, TCL_QUEUE_TAIL);
 
-    
-    /* 
+
+    /*
      * TODO: need general solution for visibility events.
      */
-     
+
     event.xany.serial = Tk_Display(winPtr)->request;
     event.xany.send_event = False;
     event.xany.display = Tk_Display(winPtr);
-        
+
     event.xvisibility.type = VisibilityNotify;
     event.xvisibility.window = (Window) macWin;;
     event.xvisibility.state = VisibilityUnobscured;
     Tk_QueueWindowEvent(&event, TCL_QUEUE_TAIL);
-     
+
     return TCL_OK;
 }
 
@@ -421,24 +415,24 @@ TkpUseWindow(
  *
  * TkpMakeContainer --
  *
- *        This procedure is called to indicate that a particular window
- *        will be a container for an embedded application.  This changes
- *        certain aspects of the window's behavior, such as whether it
- *        will receive events anymore.
+ *	This procedure is called to indicate that a particular window
+ *	will be a container for an embedded application. This changes
+ *	certain aspects of the window's behavior, such as whether it
+ *	will receive events anymore.
  *
  * Results:
- *        None.
+ *	None.
  *
  * Side effects:
- *        None.
+ *	None.
  *
  *----------------------------------------------------------------------
  */
 
 void
 TkpMakeContainer(
-    Tk_Window tkwin)                /* Token for a window that is about to
-                                 * become a container. */
+    Tk_Window tkwin)		    /* Token for a window that is about to
+				 * become a container. */
 {
     TkWindow *winPtr = (TkWindow *) tkwin;
     Container *containerPtr;
@@ -458,25 +452,25 @@ TkpMakeContainer(
     containerPtr->nextPtr = firstContainerPtr;
     firstContainerPtr = containerPtr;
     winPtr->flags |= TK_CONTAINER;
-    
+
     /*
      * Request SubstructureNotify events so that we can find out when
      * the embedded application creates its window or attempts to
-     * resize it.  Also watch Configure events on the container so that
-     * we can resize the child to match.  Also, pass activate events from
+     * resize it. Also watch Configure events on the container so that
+     * we can resize the child to match. Also, pass activate events from
      * the container down to the embedded toplevel.
      */
 
     Tk_CreateEventHandler(tkwin,
-            SubstructureNotifyMask|SubstructureRedirectMask,
-            ContainerEventProc, (ClientData) winPtr);
+	    SubstructureNotifyMask|SubstructureRedirectMask,
+	    ContainerEventProc, (ClientData) winPtr);
     Tk_CreateEventHandler(tkwin, StructureNotifyMask, EmbedStructureProc,
-            (ClientData) containerPtr);
+	    (ClientData) containerPtr);
     Tk_CreateEventHandler(tkwin, ActivateMask, EmbedActivateProc,
-            (ClientData) containerPtr);
+	    (ClientData) containerPtr);
     Tk_CreateEventHandler(tkwin, FocusChangeMask, EmbedFocusProc,
-            (ClientData) containerPtr);
-         
+	    (ClientData) containerPtr);
+
 }
 
 /*
@@ -484,30 +478,30 @@ TkpMakeContainer(
  *
  * TkMacOSXContainerId --
  *
- *        Given an embedded window, this procedure returns the MacDrawable
- *        identifier for the associated container window.
+ *	Given an embedded window, this procedure returns the MacDrawable
+ *	identifier for the associated container window.
  *
  * Results:
- *        The return value is the MacDrawable for winPtr's
- *        container window.
+ *	The return value is the MacDrawable for winPtr's
+ *	container window.
  *
  * Side effects:
- *        None.
+ *	None.
  *
  *----------------------------------------------------------------------
  */
 
 MacDrawable *
 TkMacOSXContainerId(winPtr)
-    TkWindow *winPtr;                /* Tk's structure for an embedded window. */
+    TkWindow *winPtr;		     /* Tk's structure for an embedded window. */
 {
     Container *containerPtr;
 
     for (containerPtr = firstContainerPtr; containerPtr != NULL;
-            containerPtr = containerPtr->nextPtr) {
-        if (containerPtr->embeddedPtr == winPtr) {
-            return (MacDrawable *) containerPtr->parent;
-        }
+	    containerPtr = containerPtr->nextPtr) {
+	if (containerPtr->embeddedPtr == winPtr) {
+	    return (MacDrawable *) containerPtr->parent;
+	}
     }
     Tcl_Panic("TkMacOSXContainerId couldn't find window");
     return None;
@@ -518,39 +512,39 @@ TkMacOSXContainerId(winPtr)
  *
  * TkMacOSXGetHostToplevel --
  *
- *        Given the TkWindow, return the MacDrawable for the outermost
- *      toplevel containing it.  This will be a real Macintosh window.
+ *	Given the TkWindow, return the MacDrawable for the outermost
+ *	toplevel containing it. This will be a real Macintosh window.
  *
  * Results:
- *        Returns a MacDrawable corresponding to a Macintosh Toplevel
+ *	Returns a MacDrawable corresponding to a Macintosh Toplevel
  *
  * Side effects:
- *        None.
+ *	None.
  *
  *----------------------------------------------------------------------
  */
 
 MacDrawable *
 TkMacOSXGetHostToplevel(
-    TkWindow *winPtr)                /* Tk's structure for a window. */
+    TkWindow *winPtr)		     /* Tk's structure for a window. */
 {
     TkWindow *contWinPtr, *topWinPtr;
 
     topWinPtr = winPtr->privatePtr->toplevel->winPtr;
     if (!Tk_IsEmbedded(topWinPtr)) {
-            return winPtr->privatePtr->toplevel;
+	    return winPtr->privatePtr->toplevel;
     } else {
-        contWinPtr = TkpGetOtherWindow(topWinPtr);
-
-        /*
-         * NOTE: Here we should handle out of process embedding.
-         */
-        
-        if (contWinPtr != NULL) {
-            return TkMacOSXGetHostToplevel(contWinPtr);
-        } else {
-            return None;
-        }
+	contWinPtr = TkpGetOtherWindow(topWinPtr);
+
+	/*
+	 * NOTE: Here we should handle out of process embedding.
+	 */
+
+	if (contWinPtr != NULL) {
+	    return TkMacOSXGetHostToplevel(contWinPtr);
+	} else {
+	    return None;
+	}
     }
 }
 
@@ -559,41 +553,41 @@ TkMacOSXGetHostToplevel(
  *
  * TkpClaimFocus --
  *
- *        This procedure is invoked when someone asks for the input focus
- *        to be put on a window in an embedded application, but the
- *        application doesn't currently have the focus.  It requests the
- *        input focus from the container application.
+ *	This procedure is invoked when someone asks for the input focus
+ *	to be put on a window in an embedded application, but the
+ *	application doesn't currently have the focus. It requests the
+ *	input focus from the container application.
  *
  * Results:
- *        None.
+ *	None.
  *
  * Side effects:
- *        The input focus may change.
+ *	The input focus may change.
  *
  *----------------------------------------------------------------------
  */
 
 void
 TkpClaimFocus(
-    TkWindow *topLevelPtr,                /* Top-level window containing desired
-                                         * focus window; should be embedded. */
-    int force)                                /* One means that the container should
-                                         * claim the focus if it doesn't
-                                         * currently have it. */
+    TkWindow *topLevelPtr,		  /* Top-level window containing desired
+					 * focus window; should be embedded. */
+    int force)				      /* One means that the container should
+					 * claim the focus if it doesn't
+					 * currently have it. */
 {
     XEvent event;
     Container *containerPtr;
 
     if (!(topLevelPtr->flags & TK_EMBEDDED)) {
-        return;
+	return;
     }
 
     for (containerPtr = firstContainerPtr;
-            containerPtr->embeddedPtr != topLevelPtr;
-            containerPtr = containerPtr->nextPtr) {
-        /* Empty loop body. */
+	    containerPtr->embeddedPtr != topLevelPtr;
+	    containerPtr = containerPtr->nextPtr) {
+	/* Empty loop body. */
     }
-    
+
 
     event.xfocus.type = FocusIn;
     event.xfocus.serial = LastKnownRequestProcessed(topLevelPtr->display);
@@ -610,25 +604,25 @@ TkpClaimFocus(
  *
  * TkpTestembedCmd --
  *
- *        This procedure implements the "testembed" command.  It returns
- *        some or all of the information in the list pointed to by
- *        firstContainerPtr.
+ *	This procedure implements the "testembed" command. It returns
+ *	some or all of the information in the list pointed to by
+ *	firstContainerPtr.
  *
  * Results:
- *        A standard Tcl result.
+ *	A standard Tcl result.
  *
  * Side effects:
- *        None.
+ *	None.
  *
  *----------------------------------------------------------------------
  */
 
 int
 TkpTestembedCmd(
-    ClientData clientData,                /* Main window for application. */
-    Tcl_Interp *interp,                        /* Current interpreter. */
-    int argc,                                /* Number of arguments. */
-    CONST char **argv)                        /* Argument strings. */
+    ClientData clientData,		  /* Main window for application. */
+    Tcl_Interp *interp,			       /* Current interpreter. */
+    int argc,				     /* Number of arguments. */
+    CONST char **argv)			      /* Argument strings. */
 {
     int all;
     Container *containerPtr;
@@ -636,47 +630,47 @@ TkpTestembedCmd(
     char buffer[50];
 
     if ((argc > 1) && (strcmp(argv[1], "all") == 0)) {
-        all = 1;
+	all = 1;
     } else {
-        all = 0;
+	all = 0;
     }
     Tcl_DStringInit(&dString);
     for (containerPtr = firstContainerPtr; containerPtr != NULL;
-            containerPtr = containerPtr->nextPtr) {
-        Tcl_DStringStartSublist(&dString);
-        if (containerPtr->parent == None) {
-            Tcl_DStringAppendElement(&dString, "");
-        } else {
-            if (all) {
-                sprintf(buffer, "0x%x", (int) containerPtr->parent);
-                Tcl_DStringAppendElement(&dString, buffer);
-            } else {
-                Tcl_DStringAppendElement(&dString, "XXX");
-            }
-        }
-        if (containerPtr->parentPtr == NULL) {
-            Tcl_DStringAppendElement(&dString, "");
-        } else {
-            Tcl_DStringAppendElement(&dString,
-                    containerPtr->parentPtr->pathName);
-        }
-        if (containerPtr->embedded == None) {
-            Tcl_DStringAppendElement(&dString, "");
-        } else {
-            if (all) {
-                sprintf(buffer, "0x%x", (int) containerPtr->embedded);
-                Tcl_DStringAppendElement(&dString, buffer);
-            } else {
-                Tcl_DStringAppendElement(&dString, "XXX");
-            }
-        }
-        if (containerPtr->embeddedPtr == NULL) {
-            Tcl_DStringAppendElement(&dString, "");
-        } else {
-            Tcl_DStringAppendElement(&dString,
-                    containerPtr->embeddedPtr->pathName);
-        }
-        Tcl_DStringEndSublist(&dString);
+	    containerPtr = containerPtr->nextPtr) {
+	Tcl_DStringStartSublist(&dString);
+	if (containerPtr->parent == None) {
+	    Tcl_DStringAppendElement(&dString, "");
+	} else {
+	    if (all) {
+		sprintf(buffer, "0x%x", (int) containerPtr->parent);
+		Tcl_DStringAppendElement(&dString, buffer);
+	    } else {
+		Tcl_DStringAppendElement(&dString, "XXX");
+	    }
+	}
+	if (containerPtr->parentPtr == NULL) {
+	    Tcl_DStringAppendElement(&dString, "");
+	} else {
+	    Tcl_DStringAppendElement(&dString,
+		    containerPtr->parentPtr->pathName);
+	}
+	if (containerPtr->embedded == None) {
+	    Tcl_DStringAppendElement(&dString, "");
+	} else {
+	    if (all) {
+		sprintf(buffer, "0x%x", (int) containerPtr->embedded);
+		Tcl_DStringAppendElement(&dString, buffer);
+	    } else {
+		Tcl_DStringAppendElement(&dString, "XXX");
+	    }
+	}
+	if (containerPtr->embeddedPtr == NULL) {
+	    Tcl_DStringAppendElement(&dString, "");
+	} else {
+	    Tcl_DStringAppendElement(&dString,
+		    containerPtr->embeddedPtr->pathName);
+	}
+	Tcl_DStringEndSublist(&dString);
     }
     Tcl_DStringResult(interp, &dString);
     return TCL_OK;
@@ -687,29 +681,29 @@ TkpTestembedCmd(
  *
  * TkpRedirectKeyEvent --
  *
- *        This procedure is invoked when a key press or release event
- *        arrives for an application that does not believe it owns the
- *        input focus.  This can happen because of embedding; for example,
- *        X can send an event to an embedded application when the real
- *        focus window is in the container application and is an ancestor
- *        of the container.  This procedure's job is to forward the event
- *        back to the application where it really belongs.
+ *	This procedure is invoked when a key press or release event
+ *	arrives for an application that does not believe it owns the
+ *	input focus. This can happen because of embedding; for example,
+ *	X can send an event to an embedded application when the real
+ *	focus window is in the container application and is an ancestor
+ *	of the container. This procedure's job is to forward the event
+ *	back to the application where it really belongs.
  *
  * Results:
- *        None.
+ *	None.
  *
  * Side effects:
- *        The event may get sent to a different application.
+ *	The event may get sent to a different application.
  *
  *----------------------------------------------------------------------
  */
 
 void
 TkpRedirectKeyEvent(
-    TkWindow *winPtr,                /* Window to which the event was originally
-                                 * reported. */
-    XEvent *eventPtr)                /* X event to redirect (should be KeyPress
-                                 * or KeyRelease). */
+    TkWindow *winPtr,		     /* Window to which the event was originally
+				 * reported. */
+    XEvent *eventPtr)		     /* X event to redirect (should be KeyPress
+				 * or KeyRelease). */
 {
 }
 
@@ -718,24 +712,24 @@ TkpRedirectKeyEvent(
  *
  * TkpGetOtherWindow --
  *
- *        If both the container and embedded window are in the same
- *        process, this procedure will return either one, given the other.
+ *	If both the container and embedded window are in the same
+ *	process, this procedure will return either one, given the other.
  *
  * Results:
- *        If winPtr is a container, the return value is the token for the
- *        embedded window, and vice versa.  If the "other" window isn't in
- *        this process, NULL is returned.
+ *	If winPtr is a container, the return value is the token for the
+ *	embedded window, and vice versa. If the "other" window isn't in
+ *	this process, NULL is returned.
  *
  * Side effects:
- *        None.
+ *	None.
  *
  *----------------------------------------------------------------------
  */
 
 TkWindow *
 TkpGetOtherWindow(
-    TkWindow *winPtr)                /* Tk's structure for a container or
-                                 * embedded window. */
+    TkWindow *winPtr)		     /* Tk's structure for a container or
+				 * embedded window. */
 {
     Container *containerPtr;
 
@@ -745,47 +739,48 @@ TkpGetOtherWindow(
      */
 
     if (!(winPtr->flags & TK_BOTH_HALVES)) {
-        return NULL;
+	return NULL;
     }
-    
+
     for (containerPtr = firstContainerPtr; containerPtr != NULL;
-            containerPtr = containerPtr->nextPtr) {
-        if (containerPtr->embeddedPtr == winPtr) {
-            return containerPtr->parentPtr;
-        } else if (containerPtr->parentPtr == winPtr) {
-            return containerPtr->embeddedPtr;
-        }
+	    containerPtr = containerPtr->nextPtr) {
+	if (containerPtr->embeddedPtr == winPtr) {
+	    return containerPtr->parentPtr;
+	} else if (containerPtr->parentPtr == winPtr) {
+	    return containerPtr->embeddedPtr;
+	}
     }
     return NULL;
 }
+
 /*
  *----------------------------------------------------------------------
  *
  * EmbeddedEventProc --
  *
- *        This procedure is invoked by the Tk event dispatcher when various
- *        useful events are received for a window that is embedded in
- *        another application.
+ *	This procedure is invoked by the Tk event dispatcher when various
+ *	useful events are received for a window that is embedded in
+ *	another application.
  *
  * Results:
- *        None.
+ *	None.
  *
  * Side effects:
- *        Our internal state gets cleaned up when an embedded window is
- *        destroyed.
+ *	Our internal state gets cleaned up when an embedded window is
+ *	destroyed.
  *
  *----------------------------------------------------------------------
  */
 
 static void
 EmbeddedEventProc(clientData, eventPtr)
-    ClientData clientData;                /* Token for container window. */
-    XEvent *eventPtr;                        /* ResizeRequest event. */
+    ClientData clientData;		  /* Token for container window. */
+    XEvent *eventPtr;			     /* ResizeRequest event. */
 {
     TkWindow *winPtr = (TkWindow *) clientData;
 
     if (eventPtr->type == DestroyNotify) {
-        EmbedWindowDeleted(winPtr);
+	EmbedWindowDeleted(winPtr);
     }
 }
 
@@ -794,28 +789,28 @@ EmbeddedEventProc(clientData, eventPtr)
  *
  * ContainerEventProc --
  *
- *        This procedure is invoked by the Tk event dispatcher when various
- *        useful events are received for the children of a container
- *        window.  It forwards relevant information, such as geometry
- *        requests, from the events into the container's application.
+ *	This procedure is invoked by the Tk event dispatcher when various
+ *	useful events are received for the children of a container
+ *	window. It forwards relevant information, such as geometry
+ *	requests, from the events into the container's application.
  *
- *        NOTE: on the Mac, only the DestroyNotify branch is ever taken.
- *      We don't synthesize the other events.
+ *	NOTE: on the Mac, only the DestroyNotify branch is ever taken.
+ *	We don't synthesize the other events.
  *
  * Results:
- *        None.
+ *	None.
  *
  * Side effects:
- *        Depends on the event.  For example, when ConfigureRequest events
- *        occur, geometry information gets set for the container window.
+ *	Depends on the event. For example, when ConfigureRequest events
+ *	occur, geometry information gets set for the container window.
  *
  *----------------------------------------------------------------------
  */
 
 static void
 ContainerEventProc(clientData, eventPtr)
-    ClientData clientData;                /* Token for container window. */
-    XEvent *eventPtr;                        /* ResizeRequest event. */
+    ClientData clientData;		  /* Token for container window. */
+    XEvent *eventPtr;			     /* ResizeRequest event. */
 {
     TkWindow *winPtr = (TkWindow *) clientData;
     Container *containerPtr;
@@ -828,67 +823,67 @@ ContainerEventProc(clientData, eventPtr)
      */
 
     errHandler = Tk_CreateErrorHandler(eventPtr->xfocus.display, -1,
-            -1, -1, (Tk_ErrorProc *) NULL, (ClientData) NULL);
+	    -1, -1, (Tk_ErrorProc *) NULL, (ClientData) NULL);
 
     /*
      * Find the Container structure associated with the parent window.
      */
 
     for (containerPtr = firstContainerPtr;
-            containerPtr->parent != eventPtr->xmaprequest.parent;
-            containerPtr = containerPtr->nextPtr) {
-        if (containerPtr == NULL) {
-            Tcl_Panic("ContainerEventProc couldn't find Container record");
-        }
+	    containerPtr->parent != eventPtr->xmaprequest.parent;
+	    containerPtr = containerPtr->nextPtr) {
+	if (containerPtr == NULL) {
+	    Tcl_Panic("ContainerEventProc couldn't find Container record");
+	}
     }
 
     if (eventPtr->type == CreateNotify) {
-        /*
-         * A new child window has been created in the container. Record
-         * its id in the Container structure (if more than one child is
-         * created, just remember the last one and ignore the earlier
-         * ones).
-         */
-
-        containerPtr->embedded = eventPtr->xcreatewindow.window;
+	/*
+	 * A new child window has been created in the container. Record
+	 * its id in the Container structure (if more than one child is
+	 * created, just remember the last one and ignore the earlier
+	 * ones).
+	 */
+
+	containerPtr->embedded = eventPtr->xcreatewindow.window;
     } else if (eventPtr->type == ConfigureRequest) {
-        if ((eventPtr->xconfigurerequest.x != 0)
-                || (eventPtr->xconfigurerequest.y != 0)) {
-            /*
-             * The embedded application is trying to move itself, which
-             * isn't legal.  At this point, the window hasn't actually
-             * moved, but we need to send it a ConfigureNotify event to
-             * let it know that its request has been denied.  If the
-             * embedded application was also trying to resize itself, a
-             * ConfigureNotify will be sent by the geometry management
-             * code below, so we don't need to do anything.  Otherwise,
-             * generate a synthetic event.
-             */
-
-            if ((eventPtr->xconfigurerequest.width == winPtr->changes.width)
-                    && (eventPtr->xconfigurerequest.height
-                    == winPtr->changes.height)) {
-                EmbedSendConfigure(containerPtr);
-            }
-        }
-        EmbedGeometryRequest(containerPtr,
-                eventPtr->xconfigurerequest.width,
-                eventPtr->xconfigurerequest.height);
+	if ((eventPtr->xconfigurerequest.x != 0)
+		|| (eventPtr->xconfigurerequest.y != 0)) {
+	    /*
+	     * The embedded application is trying to move itself, which
+	     * isn't legal. At this point, the window hasn't actually
+	     * moved, but we need to send it a ConfigureNotify event to
+	     * let it know that its request has been denied. If the
+	     * embedded application was also trying to resize itself, a
+	     * ConfigureNotify will be sent by the geometry management
+	     * code below, so we don't need to do anything. Otherwise,
+	     * generate a synthetic event.
+	     */
+
+	    if ((eventPtr->xconfigurerequest.width == winPtr->changes.width)
+		    && (eventPtr->xconfigurerequest.height
+		    == winPtr->changes.height)) {
+		EmbedSendConfigure(containerPtr);
+	    }
+	}
+	EmbedGeometryRequest(containerPtr,
+		eventPtr->xconfigurerequest.width,
+		eventPtr->xconfigurerequest.height);
     } else if (eventPtr->type == MapRequest) {
-        /*
-         * The embedded application's map request was ignored and simply
-         * passed on to us, so we have to map the window for it to appear
-         * on the screen.
-         */
-
-        XMapWindow(eventPtr->xmaprequest.display,
-                eventPtr->xmaprequest.window);
+	/*
+	 * The embedded application's map request was ignored and simply
+	 * passed on to us, so we have to map the window for it to appear
+	 * on the screen.
+	 */
+
+	XMapWindow(eventPtr->xmaprequest.display,
+		eventPtr->xmaprequest.window);
     } else if (eventPtr->type == DestroyNotify) {
-        /*
-         * The embedded application is gone.  Destroy the container window.
-         */
+	/*
+	 * The embedded application is gone. Destroy the container window.
+	 */
 
-        Tk_DestroyWindow((Tk_Window) winPtr);
+	Tk_DestroyWindow((Tk_Window) winPtr);
     }
     Tk_DeleteErrorHandler(errHandler);
 }
@@ -898,47 +893,47 @@ ContainerEventProc(clientData, eventPtr)
  *
  * EmbedStructureProc --
  *
- *        This procedure is invoked by the Tk event dispatcher when
- *        a container window owned by this application gets resized
- *        (and also at several other times that we don't care about).
- *        This procedure reflects the size change in the embedded
- *        window that corresponds to the container.
+ *	This procedure is invoked by the Tk event dispatcher when
+ *	a container window owned by this application gets resized
+ *	(and also at several other times that we don't care about).
+ *	This procedure reflects the size change in the embedded
+ *	window that corresponds to the container.
  *
  * Results:
- *        None.
+ *	None.
  *
  * Side effects:
- *        The embedded window gets resized to match the container.
+ *	The embedded window gets resized to match the container.
  *
  *----------------------------------------------------------------------
  */
 
 static void
 EmbedStructureProc(clientData, eventPtr)
-    ClientData clientData;                /* Token for container window. */
-    XEvent *eventPtr;                        /* ResizeRequest event. */
+    ClientData clientData;		  /* Token for container window. */
+    XEvent *eventPtr;			     /* ResizeRequest event. */
 {
     Container *containerPtr = (Container *) clientData;
     Tk_ErrorHandler errHandler;
 
     if (eventPtr->type == ConfigureNotify) {
-        if (containerPtr->embedded != None) {
-            /*
-             * Ignore errors, since the embedded application could have
-             * deleted its window.
-             */
-
-            errHandler = Tk_CreateErrorHandler(eventPtr->xfocus.display, -1,
-                    -1, -1, (Tk_ErrorProc *) NULL, (ClientData) NULL);
-            Tk_MoveResizeWindow((Tk_Window) containerPtr->embeddedPtr, 0, 0,
-                    (unsigned int) Tk_Width(
-                            (Tk_Window) containerPtr->parentPtr),
-                    (unsigned int) Tk_Height(
-                            (Tk_Window) containerPtr->parentPtr));
-            Tk_DeleteErrorHandler(errHandler);
-        }
+	if (containerPtr->embedded != None) {
+	    /*
+	     * Ignore errors, since the embedded application could have
+	     * deleted its window.
+	     */
+
+	    errHandler = Tk_CreateErrorHandler(eventPtr->xfocus.display, -1,
+		    -1, -1, (Tk_ErrorProc *) NULL, (ClientData) NULL);
+	    Tk_MoveResizeWindow((Tk_Window) containerPtr->embeddedPtr, 0, 0,
+		    (unsigned int) Tk_Width(
+			    (Tk_Window) containerPtr->parentPtr),
+		    (unsigned int) Tk_Height(
+			    (Tk_Window) containerPtr->parentPtr));
+	    Tk_DeleteErrorHandler(errHandler);
+	}
     } else if (eventPtr->type == DestroyNotify) {
-        EmbedWindowDeleted(containerPtr->parentPtr);
+	EmbedWindowDeleted(containerPtr->parentPtr);
     }
 }
 
@@ -947,33 +942,33 @@ EmbedStructureProc(clientData, eventPtr)
  *
  * EmbedActivateProc --
  *
- *        This procedure is invoked by the Tk event dispatcher when
- *        Activate and Deactivate events occur for a container window owned
- *        by this application.  It is responsible for forwarding an activate 
- *      event down into the embedded toplevel.
+ *	This procedure is invoked by the Tk event dispatcher when
+ *	Activate and Deactivate events occur for a container window owned
+ *	by this application. It is responsible for forwarding an activate
+ *	event down into the embedded toplevel.
  *
  * Results:
- *        None.
+ *	None.
  *
  * Side effects:
- *        The X focus may change.
+ *	The X focus may change.
  *
  *----------------------------------------------------------------------
  */
 
 static void
 EmbedActivateProc(clientData, eventPtr)
-    ClientData clientData;                /* Token for container window. */
-    XEvent *eventPtr;                        /* ResizeRequest event. */
+    ClientData clientData;		  /* Token for container window. */
+    XEvent *eventPtr;			     /* ResizeRequest event. */
 {
     Container *containerPtr = (Container *) clientData;
-    
+
     if (containerPtr->embeddedPtr != NULL) {
-        if (eventPtr->type == ActivateNotify) {
-            TkGenerateActivateEvents(containerPtr->embeddedPtr,1);
-        } else if (eventPtr->type == DeactivateNotify) {
-            TkGenerateActivateEvents(containerPtr->embeddedPtr,0);
-        }        
+	if (eventPtr->type == ActivateNotify) {
+	    TkGenerateActivateEvents(containerPtr->embeddedPtr,1);
+	} else if (eventPtr->type == DeactivateNotify) {
+	    TkGenerateActivateEvents(containerPtr->embeddedPtr,0);
+	}
     }
 }
 
@@ -982,25 +977,25 @@ EmbedActivateProc(clientData, eventPtr)
  *
  * EmbedFocusProc --
  *
- *        This procedure is invoked by the Tk event dispatcher when
- *        FocusIn and FocusOut events occur for a container window owned
- *        by this application.  It is responsible for moving the focus
- *        back and forth between a container application and an embedded
- *        application.
+ *	This procedure is invoked by the Tk event dispatcher when
+ *	FocusIn and FocusOut events occur for a container window owned
+ *	by this application. It is responsible for moving the focus
+ *	back and forth between a container application and an embedded
+ *	application.
  *
  * Results:
- *        None.
+ *	None.
  *
  * Side effects:
- *        The X focus may change.
+ *	The X focus may change.
  *
  *----------------------------------------------------------------------
  */
 
 static void
 EmbedFocusProc(clientData, eventPtr)
-    ClientData clientData;                /* Token for container window. */
-    XEvent *eventPtr;                        /* ResizeRequest event. */
+    ClientData clientData;		  /* Token for container window. */
+    XEvent *eventPtr;			     /* ResizeRequest event. */
 {
     Container *containerPtr = (Container *) clientData;
     Display *display;
@@ -1008,34 +1003,34 @@ EmbedFocusProc(clientData, eventPtr)
 
     if (containerPtr->embeddedPtr != NULL) {
     display = Tk_Display(containerPtr->parentPtr);
-        event.xfocus.serial = LastKnownRequestProcessed(display);
-        event.xfocus.send_event = false;
-        event.xfocus.display = display;
-        event.xfocus.mode = NotifyNormal;
-        event.xfocus.window = containerPtr->embedded; 
-        
+	event.xfocus.serial = LastKnownRequestProcessed(display);
+	event.xfocus.send_event = false;
+	event.xfocus.display = display;
+	event.xfocus.mode = NotifyNormal;
+	event.xfocus.window = containerPtr->embedded;
+
     if (eventPtr->type == FocusIn) {
-        /*
-         * The focus just arrived at the container.  Change the X focus
-         * to move it to the embedded application, if there is one. 
-         * Ignore X errors that occur during this operation (it's
-         * possible that the new focus window isn't mapped).
-         */
-    
-            event.xfocus.detail = NotifyNonlinear;
-            event.xfocus.type = FocusIn;
-
-        } else if (eventPtr->type == FocusOut) {
-        /* When the container gets a FocusOut event, it has to  tell the embedded app
-         * that it has lost the focus.
-         */
-         
-            event.xfocus.type = FocusOut;
-            event.xfocus.detail = NotifyNonlinear;
-         }
-         
-        Tk_QueueWindowEvent(&event, TCL_QUEUE_MARK);
-    } 
+	/*
+	 * The focus just arrived at the container. Change the X focus
+	 * to move it to the embedded application, if there is one.
+	 * Ignore X errors that occur during this operation (it's
+	 * possible that the new focus window isn't mapped).
+	 */
+
+	    event.xfocus.detail = NotifyNonlinear;
+	    event.xfocus.type = FocusIn;
+
+	} else if (eventPtr->type == FocusOut) {
+	/* When the container gets a FocusOut event, it has to	tell the embedded app
+	 * that it has lost the focus.
+	 */
+
+	    event.xfocus.type = FocusOut;
+	    event.xfocus.detail = NotifyNonlinear;
+	 }
+
+	Tk_QueueWindowEvent(&event, TCL_QUEUE_MARK);
+    }
 }
 
 /*
@@ -1043,36 +1038,36 @@ EmbedFocusProc(clientData, eventPtr)
  *
  * EmbedGeometryRequest --
  *
- *        This procedure is invoked when an embedded application requests
- *        a particular size.  It processes the request (which may or may
- *        not actually honor the request) and reflects the results back
- *        to the embedded application.
+ *	This procedure is invoked when an embedded application requests
+ *	a particular size. It processes the request (which may or may
+ *	not actually honor the request) and reflects the results back
+ *	to the embedded application.
  *
- *      NOTE: On the Mac, this is a stub, since we don't synthesize
- *      ConfigureRequest events.
+ *	NOTE: On the Mac, this is a stub, since we don't synthesize
+ *	ConfigureRequest events.
  *
  * Results:
- *        None.
+ *	None.
  *
  * Side effects:
- *        If we deny the child's size change request, a Configure event
- *        is synthesized to let the child know how big it ought to be.
- *        Events get processed while we're waiting for the geometry
- *        managers to do their thing.
+ *	If we deny the child's size change request, a Configure event
+ *	is synthesized to let the child know how big it ought to be.
+ *	Events get processed while we're waiting for the geometry
+ *	managers to do their thing.
  *
  *----------------------------------------------------------------------
  */
 
 static void
 EmbedGeometryRequest(containerPtr, width, height)
-    Container *containerPtr;        /* Information about the embedding. */
-    int width, height;                /* Size that the child has requested. */
+    Container *containerPtr;	    /* Information about the embedding. */
+    int width, height;		      /* Size that the child has requested. */
 {
     TkWindow *winPtr = containerPtr->parentPtr;
 
     /*
      * Forward the requested size into our geometry management hierarchy
-     * via the container window.  We need to send a Configure event back
+     * via the container window. We need to send a Configure event back
      * to the embedded application if we decide not to honor its
      * request; to make this happen, process all idle event handlers
      * synchronously here (so that the geometry managers have had a
@@ -1082,11 +1077,11 @@ EmbedGeometryRequest(containerPtr, width, height)
 
     Tk_GeometryRequest((Tk_Window) winPtr, width, height);
     while (Tcl_DoOneEvent(TCL_IDLE_EVENTS)) {
-        /* Empty loop body. */
+	/* Empty loop body. */
     }
     if ((winPtr->changes.width != width)
-            || (winPtr->changes.height != height)) {
-        EmbedSendConfigure(containerPtr);
+	    || (winPtr->changes.height != height)) {
+	EmbedSendConfigure(containerPtr);
     }
 }
 
@@ -1095,26 +1090,26 @@ EmbedGeometryRequest(containerPtr, width, height)
  *
  * EmbedSendConfigure --
  *
- *        This is currently a stub.  It is called to notify an
- *        embedded application of its current size and location.  This
- *        procedure is called when the embedded application made a
- *        geometry request that we did not grant, so that the embedded
- *        application knows that its geometry didn't change after all.
- *      It is a response to ConfigureRequest events, which we do not
- *      currently synthesize on the Mac
+ *	This is currently a stub. It is called to notify an
+ *	embedded application of its current size and location. This
+ *	procedure is called when the embedded application made a
+ *	geometry request that we did not grant, so that the embedded
+ *	application knows that its geometry didn't change after all.
+ *	It is a response to ConfigureRequest events, which we do not
+ *	currently synthesize on the Mac
  *
  * Results:
- *        None.
+ *	None.
  *
  * Side effects:
- *        None.
+ *	None.
  *
  *----------------------------------------------------------------------
  */
 
 static void
 EmbedSendConfigure(containerPtr)
-    Container *containerPtr;        /* Information about the embedding. */
+    Container *containerPtr;	    /* Information about the embedding. */
 {
 }
 
@@ -1123,28 +1118,28 @@ EmbedSendConfigure(containerPtr)
  *
  * EmbedWindowDeleted --
  *
- *        This procedure is invoked when a window involved in embedding
- *        (as either the container or the embedded application) is
- *        destroyed.  It cleans up the Container structure for the window.
+ *	This procedure is invoked when a window involved in embedding
+ *	(as either the container or the embedded application) is
+ *	destroyed. It cleans up the Container structure for the window.
  *
  * Results:
- *        None.
+ *	None.
  *
  * Side effects:
- *        A Container structure may be freed.
+ *	A Container structure may be freed.
  *
  *----------------------------------------------------------------------
  */
 
 static void
 EmbedWindowDeleted(winPtr)
-    TkWindow *winPtr;                /* Tk's information about window that
-                                 * was deleted. */
+    TkWindow *winPtr;		     /* Tk's information about window that
+				 * was deleted. */
 {
     Container *containerPtr, *prevPtr;
 
     /*
-     * Find the Container structure for this window.  Delete the
+     * Find the Container structure for this window. Delete the
      * information about the embedded application and free the container's
      * record.
      */
@@ -1152,49 +1147,48 @@ EmbedWindowDeleted(winPtr)
     prevPtr = NULL;
     containerPtr = firstContainerPtr;
     while (1) {
-        if (containerPtr->embeddedPtr == winPtr) {
-
-            /*
-             * We also have to destroy our parent, to clean up the container.
-             * Fabricate an event to do this.
-             */
-             
-            if (containerPtr->parentPtr != NULL &&
-                    containerPtr->parentPtr->flags & TK_BOTH_HALVES) {
-                XEvent event;
-                
-                event.xany.serial = 
-                    Tk_Display(containerPtr->parentPtr)->request;
-                    event.xany.send_event = False;
-                    event.xany.display = Tk_Display(containerPtr->parentPtr);
-        
-                    event.xany.type = DestroyNotify;
-                    event.xany.window = containerPtr->parent;
-                    event.xdestroywindow.event = containerPtr->parent;
-                    Tk_QueueWindowEvent(&event, TCL_QUEUE_HEAD);
-
-            }
-            
-            containerPtr->embedded = None;
-            containerPtr->embeddedPtr = NULL;
-            
-            break;
-        }
-        if (containerPtr->parentPtr == winPtr) {
-            containerPtr->parentPtr = NULL;
-            break;
-        }
-        prevPtr = containerPtr;
-        containerPtr = containerPtr->nextPtr;
+	if (containerPtr->embeddedPtr == winPtr) {
+
+	    /*
+	     * We also have to destroy our parent, to clean up the container.
+	     * Fabricate an event to do this.
+	     */
+
+	    if (containerPtr->parentPtr != NULL &&
+		    containerPtr->parentPtr->flags & TK_BOTH_HALVES) {
+		XEvent event;
+
+		event.xany.serial =
+		    Tk_Display(containerPtr->parentPtr)->request;
+		    event.xany.send_event = False;
+		    event.xany.display = Tk_Display(containerPtr->parentPtr);
+
+		    event.xany.type = DestroyNotify;
+		    event.xany.window = containerPtr->parent;
+		    event.xdestroywindow.event = containerPtr->parent;
+		    Tk_QueueWindowEvent(&event, TCL_QUEUE_HEAD);
+
+	    }
+
+	    containerPtr->embedded = None;
+	    containerPtr->embeddedPtr = NULL;
+
+	    break;
+	}
+	if (containerPtr->parentPtr == winPtr) {
+	    containerPtr->parentPtr = NULL;
+	    break;
+	}
+	prevPtr = containerPtr;
+	containerPtr = containerPtr->nextPtr;
     }
     if ((containerPtr->embeddedPtr == NULL)
-            && (containerPtr->parentPtr == NULL)) {
-        if (prevPtr == NULL) {
-            firstContainerPtr = containerPtr->nextPtr;
-        } else {
-            prevPtr->nextPtr = containerPtr->nextPtr;
-        }
-        ckfree((char *) containerPtr);
+	    && (containerPtr->parentPtr == NULL)) {
+	if (prevPtr == NULL) {
+	    firstContainerPtr = containerPtr->nextPtr;
+	} else {
+	    prevPtr->nextPtr = containerPtr->nextPtr;
+	}
+	ckfree((char *) containerPtr);
     }
 }
-