(cherry-pick: Slave ->Pane, Master->Container in tkPanedwindow.c

More Master->Container-related changes

8 files changed, 1069 insertions, 1069 deletions

diff --git a/generic/tkGrid.c b/generic/tkGrid.c
index 835971d..41f5213 100644
--- a/generic/tkGrid.c
+++ b/generic/tkGrid.c
@@ -66,7 +66,7 @@
 #define GRID_DEFAULT_ANCHOR TK_ANCHOR_NW
 
 /*
- * Structure to hold information for grid masters. A slot is either a row or
+ * Structure to hold information for grid containers. A slot is either a row or
  * column.
  */
 
@@ -124,7 +124,7 @@ typedef struct GridLayout {
 } GridLayout;
 
 /*
- * Keep one of these for each geometry master.
+ * Keep one of these for each geometry container.
  */
 
 typedef struct {
@@ -139,9 +139,9 @@ typedef struct {
     int rowSpace;		/* The number of slots currently allocated for
     				 * row constraints. */
     int startX;			/* Pixel offset of this layout within its
-    				 * master. */
+    				 * container. */
     int startY;			/* Pixel offset of this layout within its
-    				 * master. */
+    				 * container. */
     Tk_Anchor anchor;		/* Value of anchor option: specifies where a
 				 * grid without weight should be placed. */
 } GridMaster;
@@ -157,15 +157,15 @@ typedef struct Gridder {
 				 * window has been deleted, but the gridder
 				 * hasn't had a chance to clean up yet because
 				 * the structure is still in use. */
-    struct Gridder *masterPtr;	/* Master window within which this window is
+    struct Gridder *containerPtr;	/* Master window within which this window is
 				 * managed (NULL means this window isn't
 				 * managed by the gridder). */
-    struct Gridder *nextPtr;	/* Next window managed within same master.
+    struct Gridder *nextPtr;	/* Next window managed within same container.
 				 * List order doesn't matter. */
     struct Gridder *slavePtr;	/* First in list of slaves managed inside this
 				 * window (NULL means no grid slaves). */
-    GridMaster *masterDataPtr;	/* Additional data for geometry master. */
-    Tcl_Obj *in;                /* Store master name when removed. */
+    GridMaster *containerDataPtr;	/* Additional data for geometry container. */
+    Tcl_Obj *in;                /* Store container name when removed. */
     int column, row;		/* Location in the grid (starting from
 				 * zero). */
     int numCols, numRows;	/* Number of columns or rows this slave spans.
@@ -185,7 +185,7 @@ typedef struct Gridder {
 				 * sticks to. See below for definitions */
     int doubleBw;		/* Twice the window's last known border width.
 				 * If this changes, the window must be
-				 * re-arranged within its master. */
+				 * re-arranged within its container. */
     int *abortPtr;		/* If non-NULL, it means that there is a
 				 * nested call to ArrangeGrid already working
 				 * on this window. *abortPtr may be set to 1
@@ -238,16 +238,16 @@ typedef struct UniformGroup {
  *				been made to re-arrange all the slaves of this
  *				window.
  * DONT_PROPAGATE		1 means don't set this window's requested
- *				size. 0 means if this window is a master then
+ *				size. 0 means if this window is a container then
  *				Tk will set its requested size to fit the
  *				needs of its slaves.
- * ALLOCED_MASTER               1 means that Grid has allocated itself as
- *                              geometry master for this window.
+ * ALLOCED_CONTAINER		1 means that Grid has allocated itself as
+ *				geometry container for this window.
  */
 
 #define REQUESTED_RELAYOUT	1
 #define DONT_PROPAGATE		2
-#define ALLOCED_MASTER		4
+#define ALLOCED_CONTAINER	4
 
 /*
  * Prototypes for procedures used only in this file:
@@ -258,7 +258,7 @@ static void		AdjustForSticky(Gridder *slavePtr, int *xPtr,
 static int		AdjustOffsets(int width, int elements,
 			    SlotInfo *slotPtr);
 static void		ArrangeGrid(ClientData clientData);
-static int		CheckSlotData(Gridder *masterPtr, int slot,
+static int		CheckSlotData(Gridder *containerPtr, int slot,
 			    int slotType, int checkOnly);
 static int		ConfigureSlaves(Tcl_Interp *interp, Tk_Window tkwin,
 			    int objc, Tcl_Obj *const objv[]);
@@ -291,7 +291,7 @@ static void		GridStructureProc(ClientData clientData,
 static void		GridLostSlaveProc(ClientData clientData,
 			    Tk_Window tkwin);
 static void		GridReqProc(ClientData clientData, Tk_Window tkwin);
-static void		InitMasterData(Gridder *masterPtr);
+static void		InitMasterData(Gridder *containerPtr);
 static Tcl_Obj *	NewPairObj(int, int);
 static Tcl_Obj *	NewQuadObj(int, int, int, int);
 static int		ResolveConstraints(Gridder *gridPtr, int rowOrColumn,
@@ -390,11 +390,11 @@ Tk_GridObjCmd(
 
     /*
      * Sample argument combinations:
-     *  grid columnconfigure <master> <index> -option
-     *  grid columnconfigure <master> <index> -option value -option value
-     *  grid rowconfigure <master> <index>
-     *  grid rowconfigure <master> <index> -option
-     *  grid rowconfigure <master> <index> -option value -option value.
+     *  grid columnconfigure <container> <index> -option
+     *  grid columnconfigure <container> <index> -option value -option value
+     *  grid rowconfigure <container> <index>
+     *  grid rowconfigure <container> <index> -option
+     *  grid rowconfigure <container> <index> -option value -option value.
      */
 
     case GRID_COLUMNCONFIGURE:
@@ -432,8 +432,8 @@ GridAnchorCommand(
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    Tk_Window master;
-    Gridder *masterPtr;
+    Tk_Window container;
+    Gridder *containerPtr;
     GridMaster *gridPtr;
     Tk_Anchor old;
 
@@ -442,21 +442,21 @@ GridAnchorCommand(
 	return TCL_ERROR;
     }
 
-    if (TkGetWindowFromObj(interp, tkwin, objv[2], &master) != TCL_OK) {
+    if (TkGetWindowFromObj(interp, tkwin, objv[2], &container) != TCL_OK) {
 	return TCL_ERROR;
     }
-    masterPtr = GetGrid(master);
+    containerPtr = GetGrid(container);
 
     if (objc == 3) {
-	gridPtr = masterPtr->masterDataPtr;
+	gridPtr = containerPtr->containerDataPtr;
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
 		Tk_NameOfAnchor(gridPtr?gridPtr->anchor:GRID_DEFAULT_ANCHOR),
 		-1));
 	return TCL_OK;
     }
 
-    InitMasterData(masterPtr);
-    gridPtr = masterPtr->masterDataPtr;
+    InitMasterData(containerPtr);
+    gridPtr = containerPtr->containerDataPtr;
     old = gridPtr->anchor;
     if (Tk_GetAnchorFromObj(interp, objv[3], &gridPtr->anchor) != TCL_OK) {
 	return TCL_ERROR;
@@ -467,12 +467,12 @@ GridAnchorCommand(
      */
 
     if (old != gridPtr->anchor) {
-	if (masterPtr->abortPtr != NULL) {
-	    *masterPtr->abortPtr = 1;
+	if (containerPtr->abortPtr != NULL) {
+	    *containerPtr->abortPtr = 1;
 	}
-	if (!(masterPtr->flags & REQUESTED_RELAYOUT)) {
-	    masterPtr->flags |= REQUESTED_RELAYOUT;
-	    Tcl_DoWhenIdle(ArrangeGrid, masterPtr);
+	if (!(containerPtr->flags & REQUESTED_RELAYOUT)) {
+	    containerPtr->flags |= REQUESTED_RELAYOUT;
+	    Tcl_DoWhenIdle(ArrangeGrid, containerPtr);
 	}
     }
     return TCL_OK;
@@ -501,8 +501,8 @@ GridBboxCommand(
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    Tk_Window master;
-    Gridder *masterPtr;		/* master grid record */
+    Tk_Window container;
+    Gridder *containerPtr;		/* container grid record */
     GridMaster *gridPtr;	/* pointer to grid data */
     int row, column;		/* origin for bounding box */
     int row2, column2;		/* end of bounding box */
@@ -515,10 +515,10 @@ GridBboxCommand(
 	return TCL_ERROR;
     }
 
-    if (TkGetWindowFromObj(interp, tkwin, objv[2], &master) != TCL_OK) {
+    if (TkGetWindowFromObj(interp, tkwin, objv[2], &container) != TCL_OK) {
 	return TCL_ERROR;
     }
-    masterPtr = GetGrid(master);
+    containerPtr = GetGrid(container);
 
     if (objc >= 5) {
 	if (Tcl_GetIntFromObj(interp, objv[3], &column) != TCL_OK) {
@@ -540,13 +540,13 @@ GridBboxCommand(
 	}
     }
 
-    gridPtr = masterPtr->masterDataPtr;
+    gridPtr = containerPtr->containerDataPtr;
     if (gridPtr == NULL) {
 	Tcl_SetObjResult(interp, NewQuadObj(0, 0, 0, 0));
 	return TCL_OK;
     }
 
-    SetGridSize(masterPtr);
+    SetGridSize(containerPtr);
     endX = MAX(gridPtr->columnEnd, gridPtr->columnMax);
     endY = MAX(gridPtr->rowEnd, gridPtr->rowMax);
 
@@ -643,7 +643,7 @@ GridForgetRemoveCommand(
 	}
 
 	slavePtr = GetGrid(slave);
-	if (slavePtr->masterPtr != NULL) {
+	if (slavePtr->containerPtr != NULL) {
 	    /*
 	     * For "forget", reset all the settings to their defaults
 	     */
@@ -671,24 +671,24 @@ GridForgetRemoveCommand(
 		slavePtr->sticky = 0;
 	    } else {
 		/*
-		 * When removing, store name of master to be able to
-		 * restore it later, even if the master is recreated.
+		 * When removing, store name of container to be able to
+		 * restore it later, even if the container is recreated.
 		 */
 
 		if (slavePtr->in != NULL) {
 		    Tcl_DecrRefCount(slavePtr->in);
 		    slavePtr->in = NULL;
 		}
-		if (slavePtr->masterPtr != NULL) {
+		if (slavePtr->containerPtr != NULL) {
 		    slavePtr->in = Tcl_NewStringObj(
-			    Tk_PathName(slavePtr->masterPtr->tkwin), -1);
+			    Tk_PathName(slavePtr->containerPtr->tkwin), -1);
 		    Tcl_IncrRefCount(slavePtr->in);
 		}
 	    }
 	    Tk_ManageGeometry(slave, NULL, NULL);
-	    if (slavePtr->masterPtr->tkwin != Tk_Parent(slavePtr->tkwin)) {
+	    if (slavePtr->containerPtr->tkwin != Tk_Parent(slavePtr->tkwin)) {
 		Tk_UnmaintainGeometry(slavePtr->tkwin,
-			slavePtr->masterPtr->tkwin);
+			slavePtr->containerPtr->tkwin);
 	    }
 	    Unlink(slavePtr);
 	    Tk_UnmapWindow(slavePtr->tkwin);
@@ -733,14 +733,14 @@ GridInfoCommand(
 	return TCL_ERROR;
     }
     slavePtr = GetGrid(slave);
-    if (slavePtr->masterPtr == NULL) {
+    if (slavePtr->containerPtr == NULL) {
 	Tcl_ResetResult(interp);
 	return TCL_OK;
     }
 
     infoObj = Tcl_NewObj();
     Tcl_DictObjPut(NULL, infoObj, Tcl_NewStringObj("-in", -1),
-	    TkNewWindowObj(slavePtr->masterPtr->tkwin));
+	    TkNewWindowObj(slavePtr->containerPtr->tkwin));
     Tcl_DictObjPut(NULL, infoObj, Tcl_NewStringObj("-column", -1),
 	    Tcl_NewIntObj(slavePtr->column));
     Tcl_DictObjPut(NULL, infoObj, Tcl_NewStringObj("-row", -1),
@@ -783,11 +783,11 @@ GridLocationCommand(
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    Tk_Window master;
-    Gridder *masterPtr;		/* Master grid record. */
+    Tk_Window container;
+    Gridder *containerPtr;		/* Master grid record. */
     GridMaster *gridPtr;	/* Pointer to grid data. */
     register SlotInfo *slotPtr;
-    int x, y;			/* Offset in pixels, from edge of master. */
+    int x, y;			/* Offset in pixels, from edge of container. */
     int i, j;			/* Corresponding column and row indeces. */
     int endX, endY;		/* End of grid. */
 
@@ -796,23 +796,23 @@ GridLocationCommand(
 	return TCL_ERROR;
     }
 
-    if (TkGetWindowFromObj(interp, tkwin, objv[2], &master) != TCL_OK) {
+    if (TkGetWindowFromObj(interp, tkwin, objv[2], &container) != TCL_OK) {
 	return TCL_ERROR;
     }
 
-    if (Tk_GetPixelsFromObj(interp, master, objv[3], &x) != TCL_OK) {
+    if (Tk_GetPixelsFromObj(interp, container, objv[3], &x) != TCL_OK) {
 	return TCL_ERROR;
     }
-    if (Tk_GetPixelsFromObj(interp, master, objv[4], &y) != TCL_OK) {
+    if (Tk_GetPixelsFromObj(interp, container, objv[4], &y) != TCL_OK) {
 	return TCL_ERROR;
     }
 
-    masterPtr = GetGrid(master);
-    if (masterPtr->masterDataPtr == NULL) {
+    containerPtr = GetGrid(container);
+    if (containerPtr->containerDataPtr == NULL) {
 	Tcl_SetObjResult(interp, NewPairObj(-1, -1));
 	return TCL_OK;
     }
-    gridPtr = masterPtr->masterDataPtr;
+    gridPtr = containerPtr->containerDataPtr;
 
     /*
      * Update any pending requests. This is not always the steady state value,
@@ -820,29 +820,29 @@ GridLocationCommand(
      * its easy to get.
      */
 
-    while (masterPtr->flags & REQUESTED_RELAYOUT) {
-	Tcl_CancelIdleCall(ArrangeGrid, masterPtr);
-	ArrangeGrid(masterPtr);
+    while (containerPtr->flags & REQUESTED_RELAYOUT) {
+	Tcl_CancelIdleCall(ArrangeGrid, containerPtr);
+	ArrangeGrid(containerPtr);
     }
-    SetGridSize(masterPtr);
+    SetGridSize(containerPtr);
     endX = MAX(gridPtr->columnEnd, gridPtr->columnMax);
     endY = MAX(gridPtr->rowEnd, gridPtr->rowMax);
 
-    slotPtr = masterPtr->masterDataPtr->columnPtr;
-    if (x < masterPtr->masterDataPtr->startX) {
+    slotPtr = containerPtr->containerDataPtr->columnPtr;
+    if (x < containerPtr->containerDataPtr->startX) {
 	i = -1;
     } else {
-	x -= masterPtr->masterDataPtr->startX;
+	x -= containerPtr->containerDataPtr->startX;
 	for (i = 0; slotPtr[i].offset < x && i < endX; i++) {
 	    /* null body */
 	}
     }
 
-    slotPtr = masterPtr->masterDataPtr->rowPtr;
-    if (y < masterPtr->masterDataPtr->startY) {
+    slotPtr = containerPtr->containerDataPtr->rowPtr;
+    if (y < containerPtr->containerDataPtr->startY) {
 	j = -1;
     } else {
-	y -= masterPtr->masterDataPtr->startY;
+	y -= containerPtr->containerDataPtr->startY;
 	for (j = 0; slotPtr[j].offset < y && j < endY; j++) {
 	    /* null body */
 	}
@@ -876,8 +876,8 @@ GridPropagateCommand(
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    Tk_Window master;
-    Gridder *masterPtr;
+    Tk_Window container;
+    Gridder *containerPtr;
     int propagate, old;
 
     if (objc > 4) {
@@ -885,13 +885,13 @@ GridPropagateCommand(
 	return TCL_ERROR;
     }
 
-    if (TkGetWindowFromObj(interp, tkwin, objv[2], &master) != TCL_OK) {
+    if (TkGetWindowFromObj(interp, tkwin, objv[2], &container) != TCL_OK) {
 	return TCL_ERROR;
     }
-    masterPtr = GetGrid(master);
+    containerPtr = GetGrid(container);
     if (objc == 3) {
 	Tcl_SetObjResult(interp,
-		Tcl_NewBooleanObj(!(masterPtr->flags & DONT_PROPAGATE)));
+		Tcl_NewBooleanObj(!(containerPtr->flags & DONT_PROPAGATE)));
 	return TCL_OK;
     }
     if (Tcl_GetBooleanFromObj(interp, objv[3], &propagate) != TCL_OK) {
@@ -902,39 +902,39 @@ GridPropagateCommand(
      * Only request a relayout if the propagation bit changes.
      */
 
-    old = !(masterPtr->flags & DONT_PROPAGATE);
+    old = !(containerPtr->flags & DONT_PROPAGATE);
     if (propagate != old) {
 	if (propagate) {
 	    /*
-	     * If we have slaves, we need to register as geometry master.
+	     * If we have slaves, we need to register as geometry container.
 	     */
 
-	    if (masterPtr->slavePtr != NULL) {
-		if (TkSetGeometryMaster(interp, master, "grid")	!= TCL_OK) {
+	    if (containerPtr->slavePtr != NULL) {
+		if (TkSetGeometryMaster(interp, container, "grid")	!= TCL_OK) {
 		    return TCL_ERROR;
 		}
-		masterPtr->flags |= ALLOCED_MASTER;
+		containerPtr->flags |= ALLOCED_CONTAINER;
 	    }
-	    masterPtr->flags &= ~DONT_PROPAGATE;
+	    containerPtr->flags &= ~DONT_PROPAGATE;
 	} else {
-	    if (masterPtr->flags & ALLOCED_MASTER) {
-		TkFreeGeometryMaster(master, "grid");
-		masterPtr->flags &= ~ALLOCED_MASTER;
+	    if (containerPtr->flags & ALLOCED_CONTAINER) {
+		TkFreeGeometryMaster(container, "grid");
+		containerPtr->flags &= ~ALLOCED_CONTAINER;
 	    }
-	    masterPtr->flags |= DONT_PROPAGATE;
+	    containerPtr->flags |= DONT_PROPAGATE;
 	}
 
 	/*
-	 * Re-arrange the master to allow new geometry information to
-	 * propagate upwards to the master's master.
+	 * Re-arrange the container to allow new geometry information to
+	 * propagate upwards to the container's container.
 	 */
 
-	if (masterPtr->abortPtr != NULL) {
-	    *masterPtr->abortPtr = 1;
+	if (containerPtr->abortPtr != NULL) {
+	    *containerPtr->abortPtr = 1;
 	}
-	if (!(masterPtr->flags & REQUESTED_RELAYOUT)) {
-	    masterPtr->flags |= REQUESTED_RELAYOUT;
-	    Tcl_DoWhenIdle(ArrangeGrid, masterPtr);
+	if (!(containerPtr->flags & REQUESTED_RELAYOUT)) {
+	    containerPtr->flags |= REQUESTED_RELAYOUT;
+	    Tcl_DoWhenIdle(ArrangeGrid, containerPtr);
 	}
     }
     return TCL_OK;
@@ -964,8 +964,8 @@ GridRowColumnConfigureCommand(
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    Tk_Window master, slave;
-    Gridder *masterPtr, *slavePtr;
+    Tk_Window container, slave;
+    Gridder *containerPtr, *slavePtr;
     SlotInfo *slotPtr = NULL;
     int slot;			/* the column or row number */
     int slotType;		/* COLUMN or ROW */
@@ -989,7 +989,7 @@ GridRowColumnConfigureCommand(
 	return TCL_ERROR;
     }
 
-    if (TkGetWindowFromObj(interp, tkwin, objv[2], &master) != TCL_OK) {
+    if (TkGetWindowFromObj(interp, tkwin, objv[2], &container) != TCL_OK) {
 	return TCL_ERROR;
     }
 
@@ -1010,7 +1010,7 @@ GridRowColumnConfigureCommand(
 	return TCL_ERROR;
     }
 
-    masterPtr = GetGrid(master);
+    containerPtr = GetGrid(container);
     first = 0; /* lint */
     last = 0; /* lint */
 
@@ -1030,11 +1030,11 @@ GridRowColumnConfigureCommand(
 	    Tcl_DecrRefCount(listCopy);
 	    return TCL_ERROR;
 	}
-	ok = CheckSlotData(masterPtr, slot, slotType, /* checkOnly */ 1);
+	ok = CheckSlotData(containerPtr, slot, slotType, /* checkOnly */ 1);
 	if (ok == TCL_OK) {
 	    slotPtr = (slotType == COLUMN) ?
-		    masterPtr->masterDataPtr->columnPtr :
-		    masterPtr->masterDataPtr->rowPtr;
+		    containerPtr->containerDataPtr->columnPtr :
+		    containerPtr->containerDataPtr->rowPtr;
 	}
 
 	/*
@@ -1110,12 +1110,12 @@ GridRowColumnConfigureCommand(
 	    slavePtr = NULL;
 	} else if (strcmp(Tcl_GetString(lObjv[j]), "all") == 0) {
 	    /*
-	     * Make sure master is initialised.
+	     * Make sure container is initialised.
 	     */
 
-	    InitMasterData(masterPtr);
+	    InitMasterData(containerPtr);
 
-	    slavePtr = masterPtr->slavePtr;
+	    slavePtr = containerPtr->slavePtr;
 	    if (slavePtr == NULL) {
 		continue;
 	    }
@@ -1123,11 +1123,11 @@ GridRowColumnConfigureCommand(
 	} else if (TkGetWindowFromObj(NULL, tkwin, lObjv[j], &slave)
 		== TCL_OK) {
 	    /*
-	     * Is it gridded in this master?
+	     * Is it gridded in this container?
 	     */
 
 	    slavePtr = GetGrid(slave);
-	    if (slavePtr->masterPtr != masterPtr) {
+	    if (slavePtr->containerPtr != containerPtr) {
 		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 			"the window \"%s\" is not managed by \"%s\"",
 			Tcl_GetString(lObjv[j]), Tcl_GetString(objv[2])));
@@ -1156,7 +1156,7 @@ GridRowColumnConfigureCommand(
 	    }
 
 	    for (slot = first; slot <= last; slot++) {
-		ok = CheckSlotData(masterPtr, slot, slotType, /*checkOnly*/ 0);
+		ok = CheckSlotData(containerPtr, slot, slotType, /*checkOnly*/ 0);
 		if (ok != TCL_OK) {
 		    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 			    "\"%s\" is out of range",
@@ -1167,8 +1167,8 @@ GridRowColumnConfigureCommand(
 		    return TCL_ERROR;
 		}
 		slotPtr = (slotType == COLUMN) ?
-			masterPtr->masterDataPtr->columnPtr :
-			masterPtr->masterDataPtr->rowPtr;
+			containerPtr->containerDataPtr->columnPtr :
+			containerPtr->containerDataPtr->rowPtr;
 
 		/*
 		 * Loop through each option value pair, setting the values as
@@ -1182,7 +1182,7 @@ GridRowColumnConfigureCommand(
 			return TCL_ERROR;
 		    }
 		    if (index == ROWCOL_MINSIZE) {
-			if (Tk_GetPixelsFromObj(interp, master, objv[i+1],
+			if (Tk_GetPixelsFromObj(interp, container, objv[i+1],
 				&size) != TCL_OK) {
 			    Tcl_DecrRefCount(listCopy);
 			    return TCL_ERROR;
@@ -1209,7 +1209,7 @@ GridRowColumnConfigureCommand(
 			    slotPtr[slot].uniform = NULL;
 			}
 		    } else if (index == ROWCOL_PAD) {
-			if (Tk_GetPixelsFromObj(interp, master, objv[i+1],
+			if (Tk_GetPixelsFromObj(interp, container, objv[i+1],
 				&size) != TCL_OK) {
 			    Tcl_DecrRefCount(listCopy);
 			    return TCL_ERROR;
@@ -1236,32 +1236,32 @@ GridRowColumnConfigureCommand(
 
     if (slotPtr != NULL) {
 	if (slotType == ROW) {
-	    int last = masterPtr->masterDataPtr->rowMax - 1;
+	    int last = containerPtr->containerDataPtr->rowMax - 1;
 
 	    while ((last >= 0) && (slotPtr[last].weight == 0)
 		    && (slotPtr[last].pad == 0) && (slotPtr[last].minSize == 0)
 		    && (slotPtr[last].uniform == NULL)) {
 		last--;
 	    }
-	    masterPtr->masterDataPtr->rowMax = last+1;
+	    containerPtr->containerDataPtr->rowMax = last+1;
 	} else {
-	    int last = masterPtr->masterDataPtr->columnMax - 1;
+	    int last = containerPtr->containerDataPtr->columnMax - 1;
 
 	    while ((last >= 0) && (slotPtr[last].weight == 0)
 		    && (slotPtr[last].pad == 0) && (slotPtr[last].minSize == 0)
 		    && (slotPtr[last].uniform == NULL)) {
 		last--;
 	    }
-	    masterPtr->masterDataPtr->columnMax = last + 1;
+	    containerPtr->containerDataPtr->columnMax = last + 1;
 	}
     }
 
-    if (masterPtr->abortPtr != NULL) {
-	*masterPtr->abortPtr = 1;
+    if (containerPtr->abortPtr != NULL) {
+	*containerPtr->abortPtr = 1;
     }
-    if (!(masterPtr->flags & REQUESTED_RELAYOUT)) {
-	masterPtr->flags |= REQUESTED_RELAYOUT;
-	Tcl_DoWhenIdle(ArrangeGrid, masterPtr);
+    if (!(containerPtr->flags & REQUESTED_RELAYOUT)) {
+	containerPtr->flags |= REQUESTED_RELAYOUT;
+	Tcl_DoWhenIdle(ArrangeGrid, containerPtr);
     }
     return TCL_OK;
 
@@ -1297,8 +1297,8 @@ GridSizeCommand(
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    Tk_Window master;
-    Gridder *masterPtr;
+    Tk_Window container;
+    Gridder *containerPtr;
     GridMaster *gridPtr;	/* pointer to grid data */
 
     if (objc != 3) {
@@ -1306,14 +1306,14 @@ GridSizeCommand(
 	return TCL_ERROR;
     }
 
-    if (TkGetWindowFromObj(interp, tkwin, objv[2], &master) != TCL_OK) {
+    if (TkGetWindowFromObj(interp, tkwin, objv[2], &container) != TCL_OK) {
 	return TCL_ERROR;
     }
-    masterPtr = GetGrid(master);
+    containerPtr = GetGrid(container);
 
-    if (masterPtr->masterDataPtr != NULL) {
-	SetGridSize(masterPtr);
-	gridPtr = masterPtr->masterDataPtr;
+    if (containerPtr->containerDataPtr != NULL) {
+	SetGridSize(containerPtr);
+	gridPtr = containerPtr->containerDataPtr;
 	Tcl_SetObjResult(interp, NewPairObj(
 		MAX(gridPtr->columnEnd, gridPtr->columnMax),
 		MAX(gridPtr->rowEnd, gridPtr->rowMax)));
@@ -1348,8 +1348,8 @@ GridSlavesCommand(
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    Tk_Window master;
-    Gridder *masterPtr;		/* master grid record */
+    Tk_Window container;
+    Gridder *containerPtr;		/* container grid record */
     Gridder *slavePtr;
     int i, value, index;
     int row = -1, column = -1;
@@ -1385,13 +1385,13 @@ GridSlavesCommand(
 	}
     }
 
-    if (TkGetWindowFromObj(interp, tkwin, objv[2], &master) != TCL_OK) {
+    if (TkGetWindowFromObj(interp, tkwin, objv[2], &container) != TCL_OK) {
 	return TCL_ERROR;
     }
-    masterPtr = GetGrid(master);
+    containerPtr = GetGrid(container);
 
     res = Tcl_NewListObj(0, NULL);
-    for (slavePtr = masterPtr->slavePtr; slavePtr != NULL;
+    for (slavePtr = containerPtr->slavePtr; slavePtr != NULL;
 	    slavePtr = slavePtr->nextPtr) {
 	if ((column >= 0) && (slavePtr->column > column
 		|| slavePtr->column+slavePtr->numCols-1 < column)) {
@@ -1434,7 +1434,7 @@ GridReqProc(
 {
     register Gridder *gridPtr = clientData;
 
-    gridPtr = gridPtr->masterPtr;
+    gridPtr = gridPtr->containerPtr;
     if (gridPtr && !(gridPtr->flags & REQUESTED_RELAYOUT)) {
 	gridPtr->flags |= REQUESTED_RELAYOUT;
 	Tcl_DoWhenIdle(ArrangeGrid, gridPtr);
@@ -1466,8 +1466,8 @@ GridLostSlaveProc(
 {
     register Gridder *slavePtr = clientData;
 
-    if (slavePtr->masterPtr->tkwin != Tk_Parent(slavePtr->tkwin)) {
-	Tk_UnmaintainGeometry(slavePtr->tkwin, slavePtr->masterPtr->tkwin);
+    if (slavePtr->containerPtr->tkwin != Tk_Parent(slavePtr->tkwin)) {
+	Tk_UnmaintainGeometry(slavePtr->tkwin, slavePtr->containerPtr->tkwin);
     }
     Unlink(slavePtr);
     Tk_UnmapWindow(slavePtr->tkwin);
@@ -1712,38 +1712,38 @@ AdjustForSticky(
  *	None.
  *
  * Side effects:
- *	The slaves of masterPtr may get resized or moved.
+ *	The slaves of containerPtr may get resized or moved.
  *
  *----------------------------------------------------------------------
  */
 
 static void
 ArrangeGrid(
-    ClientData clientData)	/* Structure describing master whose slaves
+    ClientData clientData)	/* Structure describing container whose slaves
 				 * are to be re-layed out. */
 {
-    register Gridder *masterPtr = clientData;
+    register Gridder *containerPtr = clientData;
     register Gridder *slavePtr;
-    GridMaster *slotPtr = masterPtr->masterDataPtr;
+    GridMaster *slotPtr = containerPtr->containerDataPtr;
     int abort;
     int width, height;		/* Requested size of layout, in pixels. */
     int realWidth, realHeight;	/* Actual size layout should take-up. */
     int usedX, usedY;
 
-    masterPtr->flags &= ~REQUESTED_RELAYOUT;
+    containerPtr->flags &= ~REQUESTED_RELAYOUT;
 
     /*
-     * If the master has no slaves anymore, then don't do anything at all:
-     * just leave the master's size as-is. Otherwise there is no way to
-     * "relinquish" control over the master so another geometry manager can
+     * If the container has no slaves anymore, then don't do anything at all:
+     * just leave the container's size as-is. Otherwise there is no way to
+     * "relinquish" control over the container so another geometry manager can
      * take over.
      */
 
-    if (masterPtr->slavePtr == NULL) {
+    if (containerPtr->slavePtr == NULL) {
 	return;
     }
 
-    if (masterPtr->masterDataPtr == NULL) {
+    if (containerPtr->containerDataPtr == NULL) {
 	return;
     }
 
@@ -1753,63 +1753,63 @@ ArrangeGrid(
      * necessary.
      */
 
-    if (masterPtr->abortPtr != NULL) {
-	*masterPtr->abortPtr = 1;
+    if (containerPtr->abortPtr != NULL) {
+	*containerPtr->abortPtr = 1;
     }
-    masterPtr->abortPtr = &abort;
+    containerPtr->abortPtr = &abort;
     abort = 0;
-    Tcl_Preserve(masterPtr);
+    Tcl_Preserve(containerPtr);
 
     /*
      * Call the constraint engine to fill in the row and column offsets.
      */
 
-    SetGridSize(masterPtr);
-    width = ResolveConstraints(masterPtr, COLUMN, 0);
-    height = ResolveConstraints(masterPtr, ROW, 0);
-    width += Tk_InternalBorderLeft(masterPtr->tkwin) +
-	    Tk_InternalBorderRight(masterPtr->tkwin);
-    height += Tk_InternalBorderTop(masterPtr->tkwin) +
-	    Tk_InternalBorderBottom(masterPtr->tkwin);
+    SetGridSize(containerPtr);
+    width = ResolveConstraints(containerPtr, COLUMN, 0);
+    height = ResolveConstraints(containerPtr, ROW, 0);
+    width += Tk_InternalBorderLeft(containerPtr->tkwin) +
+	    Tk_InternalBorderRight(containerPtr->tkwin);
+    height += Tk_InternalBorderTop(containerPtr->tkwin) +
+	    Tk_InternalBorderBottom(containerPtr->tkwin);
 
-    if (width < Tk_MinReqWidth(masterPtr->tkwin)) {
-	width = Tk_MinReqWidth(masterPtr->tkwin);
+    if (width < Tk_MinReqWidth(containerPtr->tkwin)) {
+	width = Tk_MinReqWidth(containerPtr->tkwin);
     }
-    if (height < Tk_MinReqHeight(masterPtr->tkwin)) {
-	height = Tk_MinReqHeight(masterPtr->tkwin);
+    if (height < Tk_MinReqHeight(containerPtr->tkwin)) {
+	height = Tk_MinReqHeight(containerPtr->tkwin);
     }
 
-    if (((width != Tk_ReqWidth(masterPtr->tkwin))
-	    || (height != Tk_ReqHeight(masterPtr->tkwin)))
-	    && !(masterPtr->flags & DONT_PROPAGATE)) {
-	Tk_GeometryRequest(masterPtr->tkwin, width, height);
+    if (((width != Tk_ReqWidth(containerPtr->tkwin))
+	    || (height != Tk_ReqHeight(containerPtr->tkwin)))
+	    && !(containerPtr->flags & DONT_PROPAGATE)) {
+	Tk_GeometryRequest(containerPtr->tkwin, width, height);
 	if (width>1 && height>1) {
-	    masterPtr->flags |= REQUESTED_RELAYOUT;
-	    Tcl_DoWhenIdle(ArrangeGrid, masterPtr);
+	    containerPtr->flags |= REQUESTED_RELAYOUT;
+	    Tcl_DoWhenIdle(ArrangeGrid, containerPtr);
 	}
-	masterPtr->abortPtr = NULL;
-	Tcl_Release(masterPtr);
+	containerPtr->abortPtr = NULL;
+	Tcl_Release(containerPtr);
 	return;
     }
 
     /*
-     * If the currently requested layout size doesn't match the master's
+     * If the currently requested layout size doesn't match the container's
      * window size, then adjust the slot offsets according to the weights. If
      * all of the weights are zero, place the layout according to the anchor
      * value.
      */
 
-    realWidth = Tk_Width(masterPtr->tkwin) -
-	    Tk_InternalBorderLeft(masterPtr->tkwin) -
-	    Tk_InternalBorderRight(masterPtr->tkwin);
-    realHeight = Tk_Height(masterPtr->tkwin) -
-	    Tk_InternalBorderTop(masterPtr->tkwin) -
-	    Tk_InternalBorderBottom(masterPtr->tkwin);
+    realWidth = Tk_Width(containerPtr->tkwin) -
+	    Tk_InternalBorderLeft(containerPtr->tkwin) -
+	    Tk_InternalBorderRight(containerPtr->tkwin);
+    realHeight = Tk_Height(containerPtr->tkwin) -
+	    Tk_InternalBorderTop(containerPtr->tkwin) -
+	    Tk_InternalBorderBottom(containerPtr->tkwin);
     usedX = AdjustOffsets(realWidth,
 	    MAX(slotPtr->columnEnd, slotPtr->columnMax), slotPtr->columnPtr);
     usedY = AdjustOffsets(realHeight, MAX(slotPtr->rowEnd, slotPtr->rowMax),
 	    slotPtr->rowPtr);
-    TkComputeAnchor(masterPtr->masterDataPtr->anchor, masterPtr->tkwin,
+    TkComputeAnchor(containerPtr->containerDataPtr->anchor, containerPtr->tkwin,
 	    0, 0, usedX, usedY, &slotPtr->startX, &slotPtr->startY);
 
     /*
@@ -1817,7 +1817,7 @@ ArrangeGrid(
      * cavity size, and adjusting the widget according to its stickyness.
      */
 
-    for (slavePtr = masterPtr->slavePtr; slavePtr != NULL && !abort;
+    for (slavePtr = containerPtr->slavePtr; slavePtr != NULL && !abort;
 	    slavePtr = slavePtr->nextPtr) {
 	int x, y;			/* Top left coordinate */
 	int width, height;		/* Slot or slave size */
@@ -1837,11 +1837,11 @@ ArrangeGrid(
 
 	/*
 	 * Now put the window in the proper spot. (This was taken directly
-	 * from tkPack.c.) If the slave is a child of the master, then do this
+	 * from tkPack.c.) If the slave is a child of the container, then do this
 	 * here. Otherwise let Tk_MaintainGeometry do the work.
 	 */
 
-	if (masterPtr->tkwin == Tk_Parent(slavePtr->tkwin)) {
+	if (containerPtr->tkwin == Tk_Parent(slavePtr->tkwin)) {
 	    if ((width <= 0) || (height <= 0)) {
 		Tk_UnmapWindow(slavePtr->tkwin);
 	    } else {
@@ -1856,25 +1856,25 @@ ArrangeGrid(
 		}
 
 		/*
-		 * Don't map the slave if the master isn't mapped: wait until
-		 * the master gets mapped later.
+		 * Don't map the slave if the container isn't mapped: wait until
+		 * the container gets mapped later.
 		 */
 
-		if (Tk_IsMapped(masterPtr->tkwin)) {
+		if (Tk_IsMapped(containerPtr->tkwin)) {
 		    Tk_MapWindow(slavePtr->tkwin);
 		}
 	    }
 	} else if ((width <= 0) || (height <= 0)) {
-	    Tk_UnmaintainGeometry(slavePtr->tkwin, masterPtr->tkwin);
+	    Tk_UnmaintainGeometry(slavePtr->tkwin, containerPtr->tkwin);
 	    Tk_UnmapWindow(slavePtr->tkwin);
 	} else {
-	    Tk_MaintainGeometry(slavePtr->tkwin, masterPtr->tkwin, x, y,
+	    Tk_MaintainGeometry(slavePtr->tkwin, containerPtr->tkwin, x, y,
 		    width, height);
 	}
     }
 
-    masterPtr->abortPtr = NULL;
-    Tcl_Release(masterPtr);
+    containerPtr->abortPtr = NULL;
+    Tcl_Release(containerPtr);
 }
 
 /*
@@ -1892,14 +1892,14 @@ ArrangeGrid(
  *
  * Side effects:
  *	The slot offsets are copied into the SlotInfo structure for the
- *	geometry master.
+ *	geometry container.
  *
  *----------------------------------------------------------------------
  */
 
 static int
 ResolveConstraints(
-    Gridder *masterPtr,		/* The geometry master for this grid. */
+    Gridder *containerPtr,		/* The geometry container for this grid. */
     int slotType,		/* Either ROW or COLUMN. */
     int maxOffset)		/* The actual maximum size of this layout in
 				 * pixels, or 0 (not currently used). */
@@ -1942,13 +1942,13 @@ ResolveConstraints(
     GridLayout layoutData[TYPICAL_SIZE + 1];
 
     if (slotType == COLUMN) {
-	constraintCount = masterPtr->masterDataPtr->columnMax;
-	slotCount = masterPtr->masterDataPtr->columnEnd;
-	slotPtr = masterPtr->masterDataPtr->columnPtr;
+	constraintCount = containerPtr->containerDataPtr->columnMax;
+	slotCount = containerPtr->containerDataPtr->columnEnd;
+	slotPtr = containerPtr->containerDataPtr->columnPtr;
     } else {
-	constraintCount = masterPtr->masterDataPtr->rowMax;
-	slotCount = masterPtr->masterDataPtr->rowEnd;
-	slotPtr = masterPtr->masterDataPtr->rowPtr;
+	constraintCount = containerPtr->containerDataPtr->rowMax;
+	slotCount = containerPtr->containerDataPtr->rowEnd;
+	slotPtr = containerPtr->containerDataPtr->rowPtr;
     }
 
     /*
@@ -2010,7 +2010,7 @@ ResolveConstraints(
 
     switch (slotType) {
     case COLUMN:
-	for (slavePtr = masterPtr->slavePtr; slavePtr != NULL;
+	for (slavePtr = containerPtr->slavePtr; slavePtr != NULL;
 		slavePtr = slavePtr->nextPtr) {
 	    int rightEdge = slavePtr->column + slavePtr->numCols - 1;
 
@@ -2029,7 +2029,7 @@ ResolveConstraints(
 	}
 	break;
     case ROW:
-	for (slavePtr = masterPtr->slavePtr; slavePtr != NULL;
+	for (slavePtr = containerPtr->slavePtr; slavePtr != NULL;
 		slavePtr = slavePtr->nextPtr) {
 	    int rightEdge = slavePtr->row + slavePtr->numRows - 1;
 
@@ -2150,7 +2150,7 @@ ResolveConstraints(
 
     /*
      * At this point, we know the minimum required size of the entire layout.
-     * It might be prudent to stop here if our "master" will resize itself to
+     * It might be prudent to stop here if our "container" will resize itself to
      * this size.
      */
 
@@ -2385,7 +2385,7 @@ ResolveConstraints(
     /*
      * Step 6.
      * All of the space has been apportioned; copy the layout information back
-     * into the master.
+     * into the container.
      */
 
     for (slot=0; slot < gridCount; slot++) {
@@ -2444,8 +2444,8 @@ GetGrid(
     }
     gridPtr = ckalloc(sizeof(Gridder));
     gridPtr->tkwin = tkwin;
-    gridPtr->masterPtr = NULL;
-    gridPtr->masterDataPtr = NULL;
+    gridPtr->containerPtr = NULL;
+    gridPtr->containerDataPtr = NULL;
     gridPtr->nextPtr = NULL;
     gridPtr->slavePtr = NULL;
     gridPtr->binNextPtr = NULL;
@@ -2467,7 +2467,7 @@ GetGrid(
     gridPtr->sticky = 0;
     gridPtr->size = 0;
     gridPtr->in = NULL;
-    gridPtr->masterDataPtr = NULL;
+    gridPtr->containerDataPtr = NULL;
     Tcl_SetHashValue(hPtr, gridPtr);
     Tk_CreateEventHandler(tkwin, StructureNotifyMask,
 	    GridStructureProc, gridPtr);
@@ -2485,7 +2485,7 @@ GetGrid(
  *	None
  *
  * Side effects:
- *	The width and height arguments are filled in the master data
+ *	The width and height arguments are filled in the container data
  *	structure. Additional space is allocated for the constraints to
  *	accommodate the offsets.
  *
@@ -2494,20 +2494,20 @@ GetGrid(
 
 static void
 SetGridSize(
-    Gridder *masterPtr)		/* The geometry master for this grid. */
+    Gridder *containerPtr)		/* The geometry container for this grid. */
 {
     register Gridder *slavePtr;	/* Current slave window. */
     int maxX = 0, maxY = 0;
 
-    for (slavePtr = masterPtr->slavePtr; slavePtr != NULL;
+    for (slavePtr = containerPtr->slavePtr; slavePtr != NULL;
 	    slavePtr = slavePtr->nextPtr) {
 	maxX = MAX(maxX, slavePtr->numCols + slavePtr->column);
 	maxY = MAX(maxY, slavePtr->numRows + slavePtr->row);
     }
-    masterPtr->masterDataPtr->columnEnd = maxX;
-    masterPtr->masterDataPtr->rowEnd = maxY;
-    CheckSlotData(masterPtr, maxX, COLUMN, CHECK_SPACE);
-    CheckSlotData(masterPtr, maxY, ROW, CHECK_SPACE);
+    containerPtr->containerDataPtr->columnEnd = maxX;
+    containerPtr->containerDataPtr->rowEnd = maxY;
+    CheckSlotData(containerPtr, maxX, COLUMN, CHECK_SPACE);
+    CheckSlotData(containerPtr, maxY, ROW, CHECK_SPACE);
 }
 
 /*
@@ -2604,7 +2604,7 @@ SetSlaveRow(
  *	TRUE if the index is OK, False otherwise.
  *
  * Side effects:
- *	A new master grid structure may be created. If so, then it is
+ *	A new container grid structure may be created. If so, then it is
  *	initialized. In addition, additional storage for a row or column
  *	constraints may be allocated, and the constraint maximums are
  *	adjusted.
@@ -2614,7 +2614,7 @@ SetSlaveRow(
 
 static int
 CheckSlotData(
-    Gridder *masterPtr,		/* The geometry master for this grid. */
+    Gridder *containerPtr,		/* The geometry container for this grid. */
     int slot,			/* Which slot to look at. */
     int slotType,		/* ROW or COLUMN. */
     int checkOnly)		/* Don't allocate new space if true. */
@@ -2630,7 +2630,7 @@ CheckSlotData(
 	return TCL_ERROR;
     }
 
-    if ((checkOnly == CHECK_ONLY) && (masterPtr->masterDataPtr == NULL)) {
+    if ((checkOnly == CHECK_ONLY) && (containerPtr->containerDataPtr == NULL)) {
 	return TCL_ERROR;
     }
 
@@ -2640,39 +2640,39 @@ CheckSlotData(
      * of the offsets as well.
      */
 
-    InitMasterData(masterPtr);
-    end = (slotType == ROW) ? masterPtr->masterDataPtr->rowMax :
-	    masterPtr->masterDataPtr->columnMax;
+    InitMasterData(containerPtr);
+    end = (slotType == ROW) ? containerPtr->containerDataPtr->rowMax :
+	    containerPtr->containerDataPtr->columnMax;
     if (checkOnly == CHECK_ONLY) {
     	return ((end < slot) ? TCL_ERROR : TCL_OK);
     } else {
-    	numSlot = (slotType == ROW) ? masterPtr->masterDataPtr->rowSpace
-		: masterPtr->masterDataPtr->columnSpace;
+    	numSlot = (slotType == ROW) ? containerPtr->containerDataPtr->rowSpace
+		: containerPtr->containerDataPtr->columnSpace;
     	if (slot >= numSlot) {
 	    int newNumSlot = slot + PREALLOC;
 	    size_t oldSize = numSlot * sizeof(SlotInfo);
 	    size_t newSize = newNumSlot * sizeof(SlotInfo);
 	    SlotInfo *newSI = ckalloc(newSize);
 	    SlotInfo *oldSI = (slotType == ROW)
-		    ? masterPtr->masterDataPtr->rowPtr
-		    : masterPtr->masterDataPtr->columnPtr;
+		    ? containerPtr->containerDataPtr->rowPtr
+		    : containerPtr->containerDataPtr->columnPtr;
 
 	    memcpy(newSI, oldSI, oldSize);
 	    memset(newSI+numSlot, 0, newSize - oldSize);
 	    ckfree(oldSI);
 	    if (slotType == ROW) {
-	 	masterPtr->masterDataPtr->rowPtr = newSI;
-	    	masterPtr->masterDataPtr->rowSpace = newNumSlot;
+	 	containerPtr->containerDataPtr->rowPtr = newSI;
+	    	containerPtr->containerDataPtr->rowSpace = newNumSlot;
 	    } else {
-	    	masterPtr->masterDataPtr->columnPtr = newSI;
-	    	masterPtr->masterDataPtr->columnSpace = newNumSlot;
+	    	containerPtr->containerDataPtr->columnPtr = newSI;
+	    	containerPtr->containerDataPtr->columnSpace = newNumSlot;
 	    }
 	}
 	if (slot >= end && checkOnly != CHECK_SPACE) {
 	    if (slotType == ROW) {
-		masterPtr->masterDataPtr->rowMax = slot+1;
+		containerPtr->containerDataPtr->rowMax = slot+1;
 	    } else {
-		masterPtr->masterDataPtr->columnMax = slot+1;
+		containerPtr->containerDataPtr->columnMax = slot+1;
 	    }
 	}
     	return TCL_OK;
@@ -2685,13 +2685,13 @@ CheckSlotData(
  * InitMasterData --
  *
  *	This internal procedure is used to allocate and initialize the data
- *	for a geometry master, if the data doesn't exist already.
+ *	for a geometry container, if the data doesn't exist already.
  *
  * Results:
  *	none
  *
  * Side effects:
- *	A new master grid structure may be created. If so, then it is
+ *	A new container grid structure may be created. If so, then it is
  *	initialized.
  *
  *----------------------------------------------------------------------
@@ -2699,10 +2699,10 @@ CheckSlotData(
 
 static void
 InitMasterData(
-    Gridder *masterPtr)
+    Gridder *containerPtr)
 {
-    if (masterPtr->masterDataPtr == NULL) {
-	GridMaster *gridPtr = masterPtr->masterDataPtr =
+    if (containerPtr->containerDataPtr == NULL) {
+	GridMaster *gridPtr = containerPtr->containerDataPtr =
 		ckalloc(sizeof(GridMaster));
 	size_t size = sizeof(SlotInfo) * TYPICAL_SIZE;
 
@@ -2728,13 +2728,13 @@ InitMasterData(
  *
  * Unlink --
  *
- *	Remove a grid from its master's list of slaves.
+ *	Remove a grid from its container's list of slaves.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The master will be scheduled for re-arranging, and the size of the
+ *	The container will be scheduled for re-arranging, and the size of the
  *	grid will be adjusted accordingly
  *
  *----------------------------------------------------------------------
@@ -2744,17 +2744,17 @@ static void
 Unlink(
     register Gridder *slavePtr)	/* Window to unlink. */
 {
-    register Gridder *masterPtr, *slavePtr2;
+    register Gridder *containerPtr, *slavePtr2;
 
-    masterPtr = slavePtr->masterPtr;
-    if (masterPtr == NULL) {
+    containerPtr = slavePtr->containerPtr;
+    if (containerPtr == NULL) {
 	return;
     }
 
-    if (masterPtr->slavePtr == slavePtr) {
-	masterPtr->slavePtr = slavePtr->nextPtr;
+    if (containerPtr->slavePtr == slavePtr) {
+	containerPtr->slavePtr = slavePtr->nextPtr;
     } else {
-	for (slavePtr2=masterPtr->slavePtr ; ; slavePtr2=slavePtr2->nextPtr) {
+	for (slavePtr2=containerPtr->slavePtr ; ; slavePtr2=slavePtr2->nextPtr) {
 	    if (slavePtr2 == NULL) {
 		Tcl_Panic("Unlink couldn't find previous window");
 	    }
@@ -2764,25 +2764,25 @@ Unlink(
 	    }
 	}
     }
-    if (!(masterPtr->flags & REQUESTED_RELAYOUT)) {
-	masterPtr->flags |= REQUESTED_RELAYOUT;
-	Tcl_DoWhenIdle(ArrangeGrid, masterPtr);
+    if (!(containerPtr->flags & REQUESTED_RELAYOUT)) {
+	containerPtr->flags |= REQUESTED_RELAYOUT;
+	Tcl_DoWhenIdle(ArrangeGrid, containerPtr);
     }
-    if (masterPtr->abortPtr != NULL) {
-	*masterPtr->abortPtr = 1;
+    if (containerPtr->abortPtr != NULL) {
+	*containerPtr->abortPtr = 1;
     }
 
-    SetGridSize(slavePtr->masterPtr);
-    slavePtr->masterPtr = NULL;
+    SetGridSize(slavePtr->containerPtr);
+    slavePtr->containerPtr = NULL;
 
     /*
-     * If we have emptied this master from slaves it means we are no longer
+     * If we have emptied this container from slaves it means we are no longer
      * handling it and should mark it as free.
      */
 
-    if ((masterPtr->slavePtr == NULL) && (masterPtr->flags & ALLOCED_MASTER)) {
-	TkFreeGeometryMaster(masterPtr->tkwin, "grid");
-	masterPtr->flags &= ~ALLOCED_MASTER;
+    if ((containerPtr->slavePtr == NULL) && (containerPtr->flags & ALLOCED_CONTAINER)) {
+	TkFreeGeometryMaster(containerPtr->tkwin, "grid");
+	containerPtr->flags &= ~ALLOCED_CONTAINER;
     }
 }
 
@@ -2794,7 +2794,7 @@ Unlink(
  *	This procedure is invoked by Tcl_EventuallyFree or Tcl_Release to
  *	clean up the internal structure of a grid at a safe time (when no-one
  *	is using it anymore). Cleaning up the grid involves freeing the main
- *	structure for all windows and the master structure for geometry
+ *	structure for all windows and the container structure for geometry
  *	managers.
  *
  * Results:
@@ -2812,14 +2812,14 @@ DestroyGrid(
 {
     register Gridder *gridPtr = memPtr;
 
-    if (gridPtr->masterDataPtr != NULL) {
-	if (gridPtr->masterDataPtr->rowPtr != NULL) {
-	    ckfree(gridPtr->masterDataPtr -> rowPtr);
+    if (gridPtr->containerDataPtr != NULL) {
+	if (gridPtr->containerDataPtr->rowPtr != NULL) {
+	    ckfree(gridPtr->containerDataPtr -> rowPtr);
 	}
-	if (gridPtr->masterDataPtr->columnPtr != NULL) {
-	    ckfree(gridPtr->masterDataPtr -> columnPtr);
+	if (gridPtr->containerDataPtr->columnPtr != NULL) {
+	    ckfree(gridPtr->containerDataPtr -> columnPtr);
 	}
-	ckfree(gridPtr->masterDataPtr);
+	ckfree(gridPtr->containerDataPtr);
     }
     if (gridPtr->in != NULL) {
 	Tcl_DecrRefCount(gridPtr->in);
@@ -2860,25 +2860,25 @@ GridStructureProc(
 	    gridPtr->flags |= REQUESTED_RELAYOUT;
 	    Tcl_DoWhenIdle(ArrangeGrid, gridPtr);
 	}
-	if ((gridPtr->masterPtr != NULL) &&
+	if ((gridPtr->containerPtr != NULL) &&
 		(gridPtr->doubleBw != 2*Tk_Changes(gridPtr->tkwin)->border_width)) {
-	    if (!(gridPtr->masterPtr->flags & REQUESTED_RELAYOUT)) {
+	    if (!(gridPtr->containerPtr->flags & REQUESTED_RELAYOUT)) {
 		gridPtr->doubleBw = 2*Tk_Changes(gridPtr->tkwin)->border_width;
-		gridPtr->masterPtr->flags |= REQUESTED_RELAYOUT;
-		Tcl_DoWhenIdle(ArrangeGrid, gridPtr->masterPtr);
+		gridPtr->containerPtr->flags |= REQUESTED_RELAYOUT;
+		Tcl_DoWhenIdle(ArrangeGrid, gridPtr->containerPtr);
 	    }
 	}
     } else if (eventPtr->type == DestroyNotify) {
 	register Gridder *slavePtr, *nextPtr;
 
-	if (gridPtr->masterPtr != NULL) {
+	if (gridPtr->containerPtr != NULL) {
 	    Unlink(gridPtr);
 	}
 	for (slavePtr = gridPtr->slavePtr; slavePtr != NULL;
 		slavePtr = nextPtr) {
 	    Tk_ManageGeometry(slavePtr->tkwin, NULL, NULL);
 	    Tk_UnmapWindow(slavePtr->tkwin);
-	    slavePtr->masterPtr = NULL;
+	    slavePtr->containerPtr = NULL;
 	    nextPtr = slavePtr->nextPtr;
 	    slavePtr->nextPtr = NULL;
 	}
@@ -2936,10 +2936,10 @@ ConfigureSlaves(
 				 * "option value" pairs. Caller must make sure
 				 * that there is at least one window name. */
 {
-    Gridder *masterPtr = NULL;
+    Gridder *containerPtr = NULL;
     Gridder *slavePtr;
     Tk_Window other, slave, parent, ancestor;
-    TkWindow *master;
+    TkWindow *container;
     int i, j, tmp;
     int numWindows;
     int width;
@@ -2982,27 +2982,27 @@ ConfigureSlaves(
 	    if (TkGetWindowFromObj(interp, tkwin, objv[i], &slave) != TCL_OK) {
 		return TCL_ERROR;
 	    }
-	    if (masterPtr == NULL) {
+	    if (containerPtr == NULL) {
 		/*
 		 * Is there any saved -in from a removed slave?
 		 * If there is, it becomes default for -in.
-		 * If the stored master does not exist, just ignore it.
+		 * If the stored container does not exist, just ignore it.
 		 */
 
 		struct Gridder *slavePtr = GetGrid(slave);
 		if (slavePtr->in != NULL) {
 		    if (TkGetWindowFromObj(interp, slave, slavePtr->in, &parent)
 			    == TCL_OK) {
-			masterPtr = GetGrid(parent);
-			InitMasterData(masterPtr);
+			containerPtr = GetGrid(parent);
+			InitMasterData(containerPtr);
 		    }
 		}
 	    }
-	    if (masterPtr == NULL) {
+	    if (containerPtr == NULL) {
 		parent = Tk_Parent(slave);
 		if (parent != NULL) {
-		    masterPtr = GetGrid(parent);
-		    InitMasterData(masterPtr);
+		    containerPtr = GetGrid(parent);
+		    InitMasterData(containerPtr);
 		}
 	    }
 	    numWindows++;
@@ -3070,8 +3070,8 @@ ConfigureSlaves(
 		    TCL_OK) {
 		return TCL_ERROR;
 	    }
-	    masterPtr = GetGrid(other);
-	    InitMasterData(masterPtr);
+	    containerPtr = GetGrid(other);
+	    InitMasterData(containerPtr);
 	} else if (index == CONF_ROW) {
 	    if (Tcl_GetIntFromObj(interp, objv[i+1], &tmp) != TCL_OK
 		    || tmp < 0) {
@@ -3087,13 +3087,13 @@ ConfigureSlaves(
 
     /*
      * If no -row is given, use the next row after the highest occupied row
-     * of the master.
+     * of the container.
      */
 
     if (defaultRow < 0) {
-	if (masterPtr != NULL && masterPtr->masterDataPtr != NULL) {
-	    SetGridSize(masterPtr);
-	    defaultRow = masterPtr->masterDataPtr->rowEnd;
+	if (containerPtr != NULL && containerPtr->containerDataPtr != NULL) {
+	    SetGridSize(containerPtr);
+	    defaultRow = containerPtr->containerDataPtr->rowEnd;
 	} else {
 	    defaultRow = 0;
 	}
@@ -3206,8 +3206,8 @@ ConfigureSlaves(
 		    return TCL_ERROR;
 		}
 		positionGiven = 1;
-		masterPtr = GetGrid(other);
-		InitMasterData(masterPtr);
+		containerPtr = GetGrid(other);
+		InitMasterData(containerPtr);
 		break;
 	    case CONF_STICKY: {
 		int sticky = StringToSticky(Tcl_GetString(objv[i+1]));
@@ -3291,8 +3291,8 @@ ConfigureSlaves(
 	 * packed, then leave it in its current location.
 	 */
 
-    	if (!positionGiven && (slavePtr->masterPtr != NULL)) {
-	    masterPtr = slavePtr->masterPtr;
+    	if (!positionGiven && (slavePtr->containerPtr != NULL)) {
+	    containerPtr = slavePtr->containerPtr;
 	    goto scheduleLayout;
     	}
 
@@ -3301,52 +3301,52 @@ ConfigureSlaves(
 	 * its current location.
 	 */
 
-	if (positionGiven && (masterPtr == slavePtr->masterPtr)) {
+	if (positionGiven && (containerPtr == slavePtr->containerPtr)) {
 	    goto scheduleLayout;
 	}
 
 	/*
-	 * Make sure we have a geometry master. We look at:
+	 * Make sure we have a geometry container. We look at:
 	 *  1)   the -in flag
 	 *  2)   the parent of the first slave.
 	 */
 
 	parent = Tk_Parent(slave);
-    	if (masterPtr == NULL) {
-	    masterPtr = GetGrid(parent);
-	    InitMasterData(masterPtr);
+    	if (containerPtr == NULL) {
+	    containerPtr = GetGrid(parent);
+	    InitMasterData(containerPtr);
     	}
 
-	if (slavePtr->masterPtr != NULL && slavePtr->masterPtr != masterPtr) {
-            if (slavePtr->masterPtr->tkwin != Tk_Parent(slavePtr->tkwin)) {
-                Tk_UnmaintainGeometry(slavePtr->tkwin, slavePtr->masterPtr->tkwin);
+	if (slavePtr->containerPtr != NULL && slavePtr->containerPtr != containerPtr) {
+            if (slavePtr->containerPtr->tkwin != Tk_Parent(slavePtr->tkwin)) {
+                Tk_UnmaintainGeometry(slavePtr->tkwin, slavePtr->containerPtr->tkwin);
             }
 	    Unlink(slavePtr);
-	    slavePtr->masterPtr = NULL;
+	    slavePtr->containerPtr = NULL;
 	}
 
-	if (slavePtr->masterPtr == NULL) {
-	    Gridder *tempPtr = masterPtr->slavePtr;
+	if (slavePtr->containerPtr == NULL) {
+	    Gridder *tempPtr = containerPtr->slavePtr;
 
-	    slavePtr->masterPtr = masterPtr;
-	    masterPtr->slavePtr = slavePtr;
+	    slavePtr->containerPtr = containerPtr;
+	    containerPtr->slavePtr = slavePtr;
 	    slavePtr->nextPtr = tempPtr;
 	}
 
 	/*
-	 * Make sure that the slave's parent is either the master or an
-	 * ancestor of the master, and that the master and slave aren't the
+	 * Make sure that the slave's parent is either the container or an
+	 * ancestor of the container, and that the container and slave aren't the
 	 * same.
 	 */
 
-	for (ancestor = masterPtr->tkwin; ; ancestor = Tk_Parent(ancestor)) {
+	for (ancestor = containerPtr->tkwin; ; ancestor = Tk_Parent(ancestor)) {
 	    if (ancestor == parent) {
 		break;
 	    }
 	    if (Tk_TopWinHierarchy(ancestor)) {
 		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 			"can't put %s inside %s", Tcl_GetString(objv[j]),
-			Tk_PathName(masterPtr->tkwin)));
+			Tk_PathName(containerPtr->tkwin)));
 		Tcl_SetErrorCode(interp, "TK", "GEOMETRY", "HIERARCHY", NULL);
 		Unlink(slavePtr);
 		return TCL_ERROR;
@@ -3357,31 +3357,31 @@ ConfigureSlaves(
 	 * Check for management loops.
 	 */
 
-	for (master = (TkWindow *)masterPtr->tkwin; master != NULL;
-	     master = (TkWindow *)TkGetGeomMaster(master)) {
-	    if (master == (TkWindow *)slave) {
+	for (container = (TkWindow *)containerPtr->tkwin; container != NULL;
+	     container = (TkWindow *)TkGetGeomMaster(container)) {
+	    if (container == (TkWindow *)slave) {
 		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		    "can't put %s inside %s, would cause management loop",
-	            Tcl_GetString(objv[j]), Tk_PathName(masterPtr->tkwin)));
+	            Tcl_GetString(objv[j]), Tk_PathName(containerPtr->tkwin)));
 		Tcl_SetErrorCode(interp, "TK", "GEOMETRY", "LOOP", NULL);
 		Unlink(slavePtr);
 		return TCL_ERROR;
 	    }
 	}
-	if (masterPtr->tkwin != Tk_Parent(slave)) {
-	    ((TkWindow *)slave)->maintainerPtr = (TkWindow *)masterPtr->tkwin;
+	if (containerPtr->tkwin != Tk_Parent(slave)) {
+	    ((TkWindow *)slave)->maintainerPtr = (TkWindow *)containerPtr->tkwin;
 	}
 
 	Tk_ManageGeometry(slave, &gridMgrType, slavePtr);
 
-	if (!(masterPtr->flags & DONT_PROPAGATE)) {
-	    if (TkSetGeometryMaster(interp, masterPtr->tkwin, "grid")
+	if (!(containerPtr->flags & DONT_PROPAGATE)) {
+	    if (TkSetGeometryMaster(interp, containerPtr->tkwin, "grid")
 		    != TCL_OK) {
 		Tk_ManageGeometry(slave, NULL, NULL);
 		Unlink(slavePtr);
 		return TCL_ERROR;
 	    }
-	    masterPtr->flags |= ALLOCED_MASTER;
+	    containerPtr->flags |= ALLOCED_CONTAINER;
 	}
 
 	/*
@@ -3406,16 +3406,16 @@ ConfigureSlaves(
 	defaultColumnSpan = 1;
 
 	/*
-	 * Arrange for the master to be re-arranged at the first idle moment.
+	 * Arrange for the container to be re-arranged at the first idle moment.
 	 */
 
     scheduleLayout:
-	if (masterPtr->abortPtr != NULL) {
-	    *masterPtr->abortPtr = 1;
+	if (containerPtr->abortPtr != NULL) {
+	    *containerPtr->abortPtr = 1;
 	}
-	if (!(masterPtr->flags & REQUESTED_RELAYOUT)) {
-	    masterPtr->flags |= REQUESTED_RELAYOUT;
-	    Tcl_DoWhenIdle(ArrangeGrid, masterPtr);
+	if (!(containerPtr->flags & REQUESTED_RELAYOUT)) {
+	    containerPtr->flags |= REQUESTED_RELAYOUT;
+	    Tcl_DoWhenIdle(ArrangeGrid, containerPtr);
 	}
     }
 
@@ -3444,7 +3444,7 @@ ConfigureSlaves(
 	    continue;
 	}
 
-	if (masterPtr == NULL) {
+	if (containerPtr == NULL) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
 		    "can't use '^', cant find master", -1));
 	    Tcl_SetErrorCode(interp, "TK", "GRID", "SHORTCUT_USAGE", NULL);
@@ -3480,7 +3480,7 @@ ConfigureSlaves(
 	lastColumn += numSkip;
 
 	match = 0;
-	for (slavePtr = masterPtr->slavePtr; slavePtr != NULL;
+	for (slavePtr = containerPtr->slavePtr; slavePtr != NULL;
 		slavePtr = slavePtr->nextPtr) {
 
 	    if (slavePtr->column == lastColumn
@@ -3506,22 +3506,22 @@ ConfigureSlaves(
 	}
     }
 
-    if (masterPtr == NULL) {
+    if (containerPtr == NULL) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
 		"can't determine master window", -1));
 	Tcl_SetErrorCode(interp, "TK", "GRID", "SHORTCUT_USAGE", NULL);
 	return TCL_ERROR;
     }
-    SetGridSize(masterPtr);
+    SetGridSize(containerPtr);
 
     /*
-     * If we have emptied this master from slaves it means we are no longer
+     * If we have emptied this container from slaves it means we are no longer
      * handling it and should mark it as free.
      */
 
-    if (masterPtr->slavePtr == NULL && masterPtr->flags & ALLOCED_MASTER) {
-	TkFreeGeometryMaster(masterPtr->tkwin, "grid");
-	masterPtr->flags &= ~ALLOCED_MASTER;
+    if (containerPtr->slavePtr == NULL && containerPtr->flags & ALLOCED_CONTAINER) {
+	TkFreeGeometryMaster(containerPtr->tkwin, "grid");
+	containerPtr->flags &= ~ALLOCED_CONTAINER;
     }
 
     return TCL_OK;
diff --git a/generic/tkPack.c b/generic/tkPack.c
index 245c6a4..50cd3b8 100644
--- a/generic/tkPack.c
+++ b/generic/tkPack.c
@@ -29,7 +29,7 @@ typedef struct Packer {
 				 * window has been deleted, but the packet
 				 * hasn't had a chance to clean up yet because
 				 * the structure is still in use. */
-    struct Packer *masterPtr;	/* Master window within which this window is
+    struct Packer *containerPtr;	/* Master window within which this window is
 				 * packed (NULL means this window isn't
 				 * managed by the packer). */
     struct Packer *nextPtr;	/* Next window packed within same master. List
@@ -87,8 +87,8 @@ typedef struct Packer {
  *				size. 0 means if this window is a master then
  *				Tk will set its requested size to fit the
  *				needs of its slaves.
- * ALLOCED_MASTER               1 means that Pack has allocated itself as
- *                              geometry master for this window.
+ * ALLOCED_CONTAINER	1 means that Pack has allocated itself as
+ *				geometry master for this window.
  */
 
 #define REQUESTED_REPACK	1
@@ -97,7 +97,7 @@ typedef struct Packer {
 #define EXPAND			8
 #define OLD_STYLE		16
 #define DONT_PROPAGATE		32
-#define ALLOCED_MASTER		64
+#define ALLOCED_CONTAINER	64
 
 /*
  * The following structure is the official type record for the packer:
@@ -123,7 +123,7 @@ static int		ConfigureSlaves(Tcl_Interp *interp, Tk_Window tkwin,
 static void		DestroyPacker(void *memPtr);
 static Packer *		GetPacker(Tk_Window tkwin);
 static int		PackAfter(Tcl_Interp *interp, Packer *prevPtr,
-			    Packer *masterPtr, int objc,Tcl_Obj *const objv[]);
+			    Packer *containerPtr, int objc,Tcl_Obj *const objv[]);
 static void		PackStructureProc(ClientData clientData,
 			    XEvent *eventPtr);
 static void		Unlink(Packer *packPtr);
@@ -241,33 +241,33 @@ Tk_PackObjCmd(
 	    return TCL_ERROR;
 	}
 	prevPtr = GetPacker(tkwin2);
-	if (prevPtr->masterPtr == NULL) {
+	if (prevPtr->containerPtr == NULL) {
 	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		    "window \"%s\" isn't packed", argv2));
 	    Tcl_SetErrorCode(interp, "TK", "PACK", "NOT_PACKED", NULL);
 	    return TCL_ERROR;
 	}
-	return PackAfter(interp, prevPtr, prevPtr->masterPtr, objc-3, objv+3);
+	return PackAfter(interp, prevPtr, prevPtr->containerPtr, objc-3, objv+3);
     }
     case PACK_APPEND: {
-	Packer *masterPtr;
+	Packer *containerPtr;
 	register Packer *prevPtr;
 	Tk_Window tkwin2;
 
 	if (TkGetWindowFromObj(interp, tkwin, objv[2], &tkwin2) != TCL_OK) {
 	    return TCL_ERROR;
 	}
-	masterPtr = GetPacker(tkwin2);
-	prevPtr = masterPtr->slavePtr;
+	containerPtr = GetPacker(tkwin2);
+	prevPtr = containerPtr->slavePtr;
 	if (prevPtr != NULL) {
 	    while (prevPtr->nextPtr != NULL) {
 		prevPtr = prevPtr->nextPtr;
 	    }
 	}
-	return PackAfter(interp, prevPtr, masterPtr, objc-3, objv+3);
+	return PackAfter(interp, prevPtr, containerPtr, objc-3, objv+3);
     }
     case PACK_BEFORE: {
-	Packer *packPtr, *masterPtr;
+	Packer *packPtr, *containerPtr;
 	register Packer *prevPtr;
 	Tk_Window tkwin2;
 
@@ -275,14 +275,14 @@ Tk_PackObjCmd(
 	    return TCL_ERROR;
 	}
 	packPtr = GetPacker(tkwin2);
-	if (packPtr->masterPtr == NULL) {
+	if (packPtr->containerPtr == NULL) {
 	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		    "window \"%s\" isn't packed", argv2));
 	    Tcl_SetErrorCode(interp, "TK", "PACK", "NOT_PACKED", NULL);
 	    return TCL_ERROR;
 	}
-	masterPtr = packPtr->masterPtr;
-	prevPtr = masterPtr->slavePtr;
+	containerPtr = packPtr->containerPtr;
+	prevPtr = containerPtr->slavePtr;
 	if (prevPtr == packPtr) {
 	    prevPtr = NULL;
 	} else {
@@ -295,7 +295,7 @@ Tk_PackObjCmd(
 		}
 	    }
 	}
-	return PackAfter(interp, prevPtr, masterPtr, objc-3, objv+3);
+	return PackAfter(interp, prevPtr, containerPtr, objc-3, objv+3);
     }
     case PACK_CONFIGURE:
 	if (argv2[0] != '.') {
@@ -315,11 +315,11 @@ Tk_PackObjCmd(
 		continue;
 	    }
 	    slavePtr = GetPacker(slave);
-	    if ((slavePtr != NULL) && (slavePtr->masterPtr != NULL)) {
+	    if ((slavePtr != NULL) && (slavePtr->containerPtr != NULL)) {
 		Tk_ManageGeometry(slave, NULL, NULL);
-		if (slavePtr->masterPtr->tkwin != Tk_Parent(slavePtr->tkwin)) {
+		if (slavePtr->containerPtr->tkwin != Tk_Parent(slavePtr->tkwin)) {
 		    Tk_UnmaintainGeometry(slavePtr->tkwin,
-			    slavePtr->masterPtr->tkwin);
+			    slavePtr->containerPtr->tkwin);
 		}
 		Unlink(slavePtr);
 		Tk_UnmapWindow(slavePtr->tkwin);
@@ -340,7 +340,7 @@ Tk_PackObjCmd(
 	    return TCL_ERROR;
 	}
 	slavePtr = GetPacker(slave);
-	if (slavePtr->masterPtr == NULL) {
+	if (slavePtr->containerPtr == NULL) {
 	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		    "window \"%s\" isn't packed", argv2));
 	    Tcl_SetErrorCode(interp, "TK", "PACK", "NOT_PACKED", NULL);
@@ -349,7 +349,7 @@ Tk_PackObjCmd(
 
 	infoObj = Tcl_NewObj();
 	Tcl_DictObjPut(NULL, infoObj, Tcl_NewStringObj("-in", -1),
-		TkNewWindowObj(slavePtr->masterPtr->tkwin));
+		TkNewWindowObj(slavePtr->containerPtr->tkwin));
 	Tcl_DictObjPut(NULL, infoObj, Tcl_NewStringObj("-anchor", -1),
 		Tcl_NewStringObj(Tk_NameOfAnchor(slavePtr->anchor), -1));
 	Tcl_DictObjPut(NULL, infoObj, Tcl_NewStringObj("-expand", -1),
@@ -383,7 +383,7 @@ Tk_PackObjCmd(
     }
     case PACK_PROPAGATE: {
 	Tk_Window master;
-	Packer *masterPtr;
+	Packer *containerPtr;
 	int propagate;
 
 	if (objc > 4) {
@@ -393,10 +393,10 @@ Tk_PackObjCmd(
 	if (TkGetWindowFromObj(interp, tkwin, objv[2], &master) != TCL_OK) {
 	    return TCL_ERROR;
 	}
-	masterPtr = GetPacker(master);
+	containerPtr = GetPacker(master);
 	if (objc == 3) {
 	    Tcl_SetObjResult(interp,
-		    Tcl_NewBooleanObj(!(masterPtr->flags & DONT_PROPAGATE)));
+		    Tcl_NewBooleanObj(!(containerPtr->flags & DONT_PROPAGATE)));
 	    return TCL_OK;
 	}
 	if (Tcl_GetBooleanFromObj(interp, objv[3], &propagate) != TCL_OK) {
@@ -407,39 +407,39 @@ Tk_PackObjCmd(
 	     * If we have slaves, we need to register as geometry master.
 	     */
 
-	    if (masterPtr->slavePtr != NULL) {
+	    if (containerPtr->slavePtr != NULL) {
 		if (TkSetGeometryMaster(interp, master, "pack") != TCL_OK) {
 		    return TCL_ERROR;
 		}
-		masterPtr->flags |= ALLOCED_MASTER;
+		containerPtr->flags |= ALLOCED_CONTAINER;
 	    }
-	    masterPtr->flags &= ~DONT_PROPAGATE;
+	    containerPtr->flags &= ~DONT_PROPAGATE;
 
 	    /*
 	     * Repack the master to allow new geometry information to
 	     * propagate upwards to the master's master.
 	     */
 
-	    if (masterPtr->abortPtr != NULL) {
-		*masterPtr->abortPtr = 1;
+	    if (containerPtr->abortPtr != NULL) {
+		*containerPtr->abortPtr = 1;
 	    }
-	    if (!(masterPtr->flags & REQUESTED_REPACK)) {
-		masterPtr->flags |= REQUESTED_REPACK;
-		Tcl_DoWhenIdle(ArrangePacking, masterPtr);
+	    if (!(containerPtr->flags & REQUESTED_REPACK)) {
+		containerPtr->flags |= REQUESTED_REPACK;
+		Tcl_DoWhenIdle(ArrangePacking, containerPtr);
 	    }
 	} else {
-	    if (masterPtr->flags & ALLOCED_MASTER) {
+	    if (containerPtr->flags & ALLOCED_CONTAINER) {
 		TkFreeGeometryMaster(master, "pack");
-		masterPtr->flags &= ~ALLOCED_MASTER;
+		containerPtr->flags &= ~ALLOCED_CONTAINER;
 	    }
-	    masterPtr->flags |= DONT_PROPAGATE;
+	    containerPtr->flags |= DONT_PROPAGATE;
 	}
 	break;
     }
     case PACK_CONTENT:
     case PACK_SLAVES: {
 	Tk_Window master;
-	Packer *masterPtr, *slavePtr;
+	Packer *containerPtr, *slavePtr;
 	Tcl_Obj *resultObj;
 
 	if (objc != 3) {
@@ -450,8 +450,8 @@ Tk_PackObjCmd(
 	    return TCL_ERROR;
 	}
 	resultObj = Tcl_NewObj();
-	masterPtr = GetPacker(master);
-	for (slavePtr = masterPtr->slavePtr; slavePtr != NULL;
+	containerPtr = GetPacker(master);
+	for (slavePtr = containerPtr->slavePtr; slavePtr != NULL;
 		slavePtr = slavePtr->nextPtr) {
 	    Tcl_ListObjAppendElement(NULL, resultObj,
 		    TkNewWindowObj(slavePtr->tkwin));
@@ -471,11 +471,11 @@ Tk_PackObjCmd(
 	    return TCL_ERROR;
 	}
 	packPtr = GetPacker(tkwin2);
-	if ((packPtr != NULL) && (packPtr->masterPtr != NULL)) {
+	if ((packPtr != NULL) && (packPtr->containerPtr != NULL)) {
 	    Tk_ManageGeometry(tkwin2, NULL, NULL);
-	    if (packPtr->masterPtr->tkwin != Tk_Parent(packPtr->tkwin)) {
+	    if (packPtr->containerPtr->tkwin != Tk_Parent(packPtr->tkwin)) {
 		Tk_UnmaintainGeometry(packPtr->tkwin,
-			packPtr->masterPtr->tkwin);
+			packPtr->containerPtr->tkwin);
 	    }
 	    Unlink(packPtr);
 	    Tk_UnmapWindow(packPtr->tkwin);
@@ -515,7 +515,7 @@ PackReqProc(
 {
     register Packer *packPtr = clientData;
 
-    packPtr = packPtr->masterPtr;
+    packPtr = packPtr->containerPtr;
     if (!(packPtr->flags & REQUESTED_REPACK)) {
 	packPtr->flags |= REQUESTED_REPACK;
 	Tcl_DoWhenIdle(ArrangePacking, packPtr);
@@ -548,8 +548,8 @@ PackLostSlaveProc(
 {
     register Packer *slavePtr = clientData;
 
-    if (slavePtr->masterPtr->tkwin != Tk_Parent(slavePtr->tkwin)) {
-	Tk_UnmaintainGeometry(slavePtr->tkwin, slavePtr->masterPtr->tkwin);
+    if (slavePtr->containerPtr->tkwin != Tk_Parent(slavePtr->tkwin)) {
+	Tk_UnmaintainGeometry(slavePtr->tkwin, slavePtr->containerPtr->tkwin);
     }
     Unlink(slavePtr);
     Tk_UnmapWindow(slavePtr->tkwin);
@@ -569,7 +569,7 @@ PackLostSlaveProc(
  *	None.
  *
  * Side effects:
- *	The packed slaves of masterPtr may get resized or moved.
+ *	The packed slaves of containerPtr may get resized or moved.
  *
  *------------------------------------------------------------------------
  */
@@ -579,7 +579,7 @@ ArrangePacking(
     ClientData clientData)	/* Structure describing master whose slaves
 				 * are to be re-layed out. */
 {
-    register Packer *masterPtr = clientData;
+    register Packer *containerPtr = clientData;
     register Packer *slavePtr;
     int cavityX, cavityY, cavityWidth, cavityHeight;
 				/* These variables keep track of the
@@ -597,14 +597,14 @@ ArrangePacking(
     int borderLeft, borderRight;
     int maxWidth, maxHeight, tmp;
 
-    masterPtr->flags &= ~REQUESTED_REPACK;
+    containerPtr->flags &= ~REQUESTED_REPACK;
 
     /*
      * If the master has no slaves anymore, then don't do anything at all:
      * just leave the master's size as-is.
      */
 
-    if (masterPtr->slavePtr == NULL) {
+    if (containerPtr->slavePtr == NULL) {
 	return;
     }
 
@@ -614,12 +614,12 @@ ArrangePacking(
      * necessary.
      */
 
-    if (masterPtr->abortPtr != NULL) {
-	*masterPtr->abortPtr = 1;
+    if (containerPtr->abortPtr != NULL) {
+	*containerPtr->abortPtr = 1;
     }
-    masterPtr->abortPtr = &abort;
+    containerPtr->abortPtr = &abort;
     abort = 0;
-    Tcl_Preserve(masterPtr);
+    Tcl_Preserve(containerPtr);
 
     /*
      * Pass #1: scan all the slaves to figure out the total amount of space
@@ -638,11 +638,11 @@ ArrangePacking(
      * maxHeight -	Same as maxWidth, except keeps height info.
      */
 
-    width = maxWidth = Tk_InternalBorderLeft(masterPtr->tkwin) +
-	    Tk_InternalBorderRight(masterPtr->tkwin);
-    height = maxHeight = Tk_InternalBorderTop(masterPtr->tkwin) +
-	    Tk_InternalBorderBottom(masterPtr->tkwin);
-    for (slavePtr = masterPtr->slavePtr; slavePtr != NULL;
+    width = maxWidth = Tk_InternalBorderLeft(containerPtr->tkwin) +
+	    Tk_InternalBorderRight(containerPtr->tkwin);
+    height = maxHeight = Tk_InternalBorderTop(containerPtr->tkwin) +
+	    Tk_InternalBorderBottom(containerPtr->tkwin);
+    for (slavePtr = containerPtr->slavePtr; slavePtr != NULL;
 	    slavePtr = slavePtr->nextPtr) {
 	if ((slavePtr->side == TOP) || (slavePtr->side == BOTTOM)) {
 	    tmp = Tk_ReqWidth(slavePtr->tkwin) + slavePtr->doubleBw
@@ -669,11 +669,11 @@ ArrangePacking(
 	maxHeight = height;
     }
 
-    if (maxWidth < Tk_MinReqWidth(masterPtr->tkwin)) {
-	maxWidth = Tk_MinReqWidth(masterPtr->tkwin);
+    if (maxWidth < Tk_MinReqWidth(containerPtr->tkwin)) {
+	maxWidth = Tk_MinReqWidth(containerPtr->tkwin);
     }
-    if (maxHeight < Tk_MinReqHeight(masterPtr->tkwin)) {
-	maxHeight = Tk_MinReqHeight(masterPtr->tkwin);
+    if (maxHeight < Tk_MinReqHeight(containerPtr->tkwin)) {
+	maxHeight = Tk_MinReqHeight(containerPtr->tkwin);
     }
 
     /*
@@ -683,12 +683,12 @@ ArrangePacking(
      * master has had a chance to resize us.
      */
 
-    if (((maxWidth != Tk_ReqWidth(masterPtr->tkwin))
-	    || (maxHeight != Tk_ReqHeight(masterPtr->tkwin)))
-	    && !(masterPtr->flags & DONT_PROPAGATE)) {
-	Tk_GeometryRequest(masterPtr->tkwin, maxWidth, maxHeight);
-	masterPtr->flags |= REQUESTED_REPACK;
-	Tcl_DoWhenIdle(ArrangePacking, masterPtr);
+    if (((maxWidth != Tk_ReqWidth(containerPtr->tkwin))
+	    || (maxHeight != Tk_ReqHeight(containerPtr->tkwin)))
+	    && !(containerPtr->flags & DONT_PROPAGATE)) {
+	Tk_GeometryRequest(containerPtr->tkwin, maxWidth, maxHeight);
+	containerPtr->flags |= REQUESTED_REPACK;
+	Tcl_DoWhenIdle(ArrangePacking, containerPtr);
 	goto done;
     }
 
@@ -701,15 +701,15 @@ ArrangePacking(
      * somewhere inside the frame, depending on anchor.
      */
 
-    cavityX = x = Tk_InternalBorderLeft(masterPtr->tkwin);
-    cavityY = y = Tk_InternalBorderTop(masterPtr->tkwin);
-    cavityWidth = Tk_Width(masterPtr->tkwin) -
-	    Tk_InternalBorderLeft(masterPtr->tkwin) -
-	    Tk_InternalBorderRight(masterPtr->tkwin);
-    cavityHeight = Tk_Height(masterPtr->tkwin) -
-	    Tk_InternalBorderTop(masterPtr->tkwin) -
-	    Tk_InternalBorderBottom(masterPtr->tkwin);
-    for (slavePtr = masterPtr->slavePtr; slavePtr != NULL;
+    cavityX = x = Tk_InternalBorderLeft(containerPtr->tkwin);
+    cavityY = y = Tk_InternalBorderTop(containerPtr->tkwin);
+    cavityWidth = Tk_Width(containerPtr->tkwin) -
+	    Tk_InternalBorderLeft(containerPtr->tkwin) -
+	    Tk_InternalBorderRight(containerPtr->tkwin);
+    cavityHeight = Tk_Height(containerPtr->tkwin) -
+	    Tk_InternalBorderTop(containerPtr->tkwin) -
+	    Tk_InternalBorderBottom(containerPtr->tkwin);
+    for (slavePtr = containerPtr->slavePtr; slavePtr != NULL;
 	    slavePtr = slavePtr->nextPtr) {
 	if ((slavePtr->side == TOP) || (slavePtr->side == BOTTOM)) {
 	    frameWidth = cavityWidth;
@@ -833,7 +833,7 @@ ArrangePacking(
 	 * this here. Otherwise let Tk_MaintainGeometry do the work.
 	 */
 
-	if (masterPtr->tkwin == Tk_Parent(slavePtr->tkwin)) {
+	if (containerPtr->tkwin == Tk_Parent(slavePtr->tkwin)) {
 	    if ((width <= 0) || (height <= 0)) {
 		Tk_UnmapWindow(slavePtr->tkwin);
 	    } else {
@@ -852,16 +852,16 @@ ArrangePacking(
 		 * the master gets mapped later.
 		 */
 
-		if (Tk_IsMapped(masterPtr->tkwin)) {
+		if (Tk_IsMapped(containerPtr->tkwin)) {
 		    Tk_MapWindow(slavePtr->tkwin);
 		}
 	    }
 	} else {
 	    if ((width <= 0) || (height <= 0)) {
-		Tk_UnmaintainGeometry(slavePtr->tkwin, masterPtr->tkwin);
+		Tk_UnmaintainGeometry(slavePtr->tkwin, containerPtr->tkwin);
 		Tk_UnmapWindow(slavePtr->tkwin);
 	    } else {
-		Tk_MaintainGeometry(slavePtr->tkwin, masterPtr->tkwin,
+		Tk_MaintainGeometry(slavePtr->tkwin, containerPtr->tkwin,
 			x, y, width, height);
 	    }
 	}
@@ -878,8 +878,8 @@ ArrangePacking(
     }
 
   done:
-    masterPtr->abortPtr = NULL;
-    Tcl_Release(masterPtr);
+    containerPtr->abortPtr = NULL;
+    Tcl_Release(containerPtr);
 }
 
 /*
@@ -1053,7 +1053,7 @@ GetPacker(
     }
     packPtr = ckalloc(sizeof(Packer));
     packPtr->tkwin = tkwin;
-    packPtr->masterPtr = NULL;
+    packPtr->containerPtr = NULL;
     packPtr->nextPtr = NULL;
     packPtr->slavePtr = NULL;
     packPtr->side = TOP;
@@ -1093,8 +1093,8 @@ PackAfter(
     Tcl_Interp *interp,		/* Interpreter for error reporting. */
     Packer *prevPtr,		/* Pack windows in argv just after this
 				 * window; NULL means pack as first child of
-				 * masterPtr. */
-    Packer *masterPtr,		/* Master in which to pack windows. */
+				 * containerPtr. */
+    Packer *containerPtr,		/* Master in which to pack windows. */
     int objc,			/* Number of elements in objv. */
     Tcl_Obj *const objv[])	/* Array of lists, each containing 2 elements:
 				 * window name and side against which to
@@ -1126,13 +1126,13 @@ PackAfter(
 	 * its parent.
 	 */
 
-	if (TkGetWindowFromObj(interp, masterPtr->tkwin, objv[0], &tkwin)
+	if (TkGetWindowFromObj(interp, containerPtr->tkwin, objv[0], &tkwin)
 		!= TCL_OK) {
 	    return TCL_ERROR;
 	}
 
 	parent = Tk_Parent(tkwin);
-	for (ancestor = masterPtr->tkwin; ; ancestor = Tk_Parent(ancestor)) {
+	for (ancestor = containerPtr->tkwin; ; ancestor = Tk_Parent(ancestor)) {
 	    if (ancestor == parent) {
 		break;
 	    }
@@ -1140,7 +1140,7 @@ PackAfter(
 	    badWindow:
 		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 			"can't pack %s inside %s", Tcl_GetString(objv[0]),
-			Tk_PathName(masterPtr->tkwin)));
+			Tk_PathName(containerPtr->tkwin)));
 		Tcl_SetErrorCode(interp, "TK", "GEOMETRY", "HIERARCHY", NULL);
 		return TCL_ERROR;
 	    }
@@ -1148,7 +1148,7 @@ PackAfter(
 	if (((Tk_FakeWin *) (tkwin))->flags & TK_TOP_HIERARCHY) {
 	    goto badWindow;
 	}
-	if (tkwin == masterPtr->tkwin) {
+	if (tkwin == containerPtr->tkwin) {
 	    goto badWindow;
 	}
 	packPtr = GetPacker(tkwin);
@@ -1258,12 +1258,12 @@ PackAfter(
 	     * Unpack this window if it's currently packed.
 	     */
 
-	    if (packPtr->masterPtr != NULL) {
-		if ((packPtr->masterPtr != masterPtr) &&
-			(packPtr->masterPtr->tkwin
+	    if (packPtr->containerPtr != NULL) {
+		if ((packPtr->containerPtr != containerPtr) &&
+			(packPtr->containerPtr->tkwin
 			!= Tk_Parent(packPtr->tkwin))) {
 		    Tk_UnmaintainGeometry(packPtr->tkwin,
-			    packPtr->masterPtr->tkwin);
+			    packPtr->containerPtr->tkwin);
 		}
 		Unlink(packPtr);
 	    }
@@ -1273,24 +1273,24 @@ PackAfter(
 	     * order, then make sure that the window is managed by us.
 	     */
 
-	    packPtr->masterPtr = masterPtr;
+	    packPtr->containerPtr = containerPtr;
 	    if (prevPtr == NULL) {
-		packPtr->nextPtr = masterPtr->slavePtr;
-		masterPtr->slavePtr = packPtr;
+		packPtr->nextPtr = containerPtr->slavePtr;
+		containerPtr->slavePtr = packPtr;
 	    } else {
 		packPtr->nextPtr = prevPtr->nextPtr;
 		prevPtr->nextPtr = packPtr;
 	    }
 	    Tk_ManageGeometry(tkwin, &packerType, packPtr);
 
-	    if (!(masterPtr->flags & DONT_PROPAGATE)) {
-		if (TkSetGeometryMaster(interp, masterPtr->tkwin, "pack")
+	    if (!(containerPtr->flags & DONT_PROPAGATE)) {
+		if (TkSetGeometryMaster(interp, containerPtr->tkwin, "pack")
 			!= TCL_OK) {
 		    Tk_ManageGeometry(tkwin, NULL, NULL);
 		    Unlink(packPtr);
 		    return TCL_ERROR;
 		}
-		masterPtr->flags |= ALLOCED_MASTER;
+		containerPtr->flags |= ALLOCED_CONTAINER;
 	    }
 	}
     }
@@ -1299,12 +1299,12 @@ PackAfter(
      * Arrange for the master to be re-packed at the first idle moment.
      */
 
-    if (masterPtr->abortPtr != NULL) {
-	*masterPtr->abortPtr = 1;
+    if (containerPtr->abortPtr != NULL) {
+	*containerPtr->abortPtr = 1;
     }
-    if (!(masterPtr->flags & REQUESTED_REPACK)) {
-	masterPtr->flags |= REQUESTED_REPACK;
-	Tcl_DoWhenIdle(ArrangePacking, masterPtr);
+    if (!(containerPtr->flags & REQUESTED_REPACK)) {
+	containerPtr->flags |= REQUESTED_REPACK;
+	Tcl_DoWhenIdle(ArrangePacking, containerPtr);
     }
     return TCL_OK;
 }
@@ -1329,16 +1329,16 @@ static void
 Unlink(
     register Packer *packPtr)	/* Window to unlink. */
 {
-    register Packer *masterPtr, *packPtr2;
+    register Packer *containerPtr, *packPtr2;
 
-    masterPtr = packPtr->masterPtr;
-    if (masterPtr == NULL) {
+    containerPtr = packPtr->containerPtr;
+    if (containerPtr == NULL) {
 	return;
     }
-    if (masterPtr->slavePtr == packPtr) {
-	masterPtr->slavePtr = packPtr->nextPtr;
+    if (containerPtr->slavePtr == packPtr) {
+	containerPtr->slavePtr = packPtr->nextPtr;
     } else {
-	for (packPtr2 = masterPtr->slavePtr; ; packPtr2 = packPtr2->nextPtr) {
+	for (packPtr2 = containerPtr->slavePtr; ; packPtr2 = packPtr2->nextPtr) {
 	    if (packPtr2 == NULL) {
 		Tcl_Panic("Unlink couldn't find previous window");
 	    }
@@ -1348,24 +1348,24 @@ Unlink(
 	    }
 	}
     }
-    if (!(masterPtr->flags & REQUESTED_REPACK)) {
-	masterPtr->flags |= REQUESTED_REPACK;
-	Tcl_DoWhenIdle(ArrangePacking, masterPtr);
+    if (!(containerPtr->flags & REQUESTED_REPACK)) {
+	containerPtr->flags |= REQUESTED_REPACK;
+	Tcl_DoWhenIdle(ArrangePacking, containerPtr);
     }
-    if (masterPtr->abortPtr != NULL) {
-	*masterPtr->abortPtr = 1;
+    if (containerPtr->abortPtr != NULL) {
+	*containerPtr->abortPtr = 1;
     }
 
-    packPtr->masterPtr = NULL;
+    packPtr->containerPtr = NULL;
 
     /*
      * If we have emptied this master from slaves it means we are no longer
      * handling it and should mark it as free.
      */
 
-    if ((masterPtr->slavePtr == NULL) && (masterPtr->flags & ALLOCED_MASTER)) {
-	TkFreeGeometryMaster(masterPtr->tkwin, "pack");
-	masterPtr->flags &= ~ALLOCED_MASTER;
+    if ((containerPtr->slavePtr == NULL) && (containerPtr->flags & ALLOCED_CONTAINER)) {
+	TkFreeGeometryMaster(containerPtr->tkwin, "pack");
+	containerPtr->flags &= ~ALLOCED_CONTAINER;
     }
 
 }
@@ -1430,18 +1430,18 @@ PackStructureProc(
 	    packPtr->flags |= REQUESTED_REPACK;
 	    Tcl_DoWhenIdle(ArrangePacking, packPtr);
 	}
-	if ((packPtr->masterPtr != NULL)
+	if ((packPtr->containerPtr != NULL)
 	        && (packPtr->doubleBw != 2*Tk_Changes(packPtr->tkwin)->border_width)) {
-	    if (!(packPtr->masterPtr->flags & REQUESTED_REPACK)) {
+	    if (!(packPtr->containerPtr->flags & REQUESTED_REPACK)) {
 		packPtr->doubleBw = 2*Tk_Changes(packPtr->tkwin)->border_width;
-		packPtr->masterPtr->flags |= REQUESTED_REPACK;
-		Tcl_DoWhenIdle(ArrangePacking, packPtr->masterPtr);
+		packPtr->containerPtr->flags |= REQUESTED_REPACK;
+		Tcl_DoWhenIdle(ArrangePacking, packPtr->containerPtr);
 	    }
 	}
     } else if (eventPtr->type == DestroyNotify) {
 	register Packer *slavePtr, *nextPtr;
 
-	if (packPtr->masterPtr != NULL) {
+	if (packPtr->containerPtr != NULL) {
 	    Unlink(packPtr);
 	}
 
@@ -1449,7 +1449,7 @@ PackStructureProc(
 		slavePtr = nextPtr) {
 	    Tk_ManageGeometry(slavePtr->tkwin, NULL, NULL);
 	    Tk_UnmapWindow(slavePtr->tkwin);
-	    slavePtr->masterPtr = NULL;
+	    slavePtr->containerPtr = NULL;
 	    nextPtr = slavePtr->nextPtr;
 	    slavePtr->nextPtr = NULL;
 	}
@@ -1521,7 +1521,7 @@ ConfigureSlaves(
 				 * "option value" pairs. Caller must make sure
 				 * that there is at least one window name. */
 {
-    Packer *masterPtr, *slavePtr, *prevPtr, *otherPtr;
+    Packer *containerPtr, *slavePtr, *prevPtr, *otherPtr;
     Tk_Window other, slave, parent, ancestor;
     TkWindow *master;
     int i, j, numWindows, tmp, positionGiven;
@@ -1555,7 +1555,7 @@ ConfigureSlaves(
      * options only get processed for the first window.
      */
 
-    masterPtr = NULL;
+    containerPtr = NULL;
     prevPtr = NULL;
     positionGiven = 0;
     for (j = 0; j < numWindows; j++) {
@@ -1578,7 +1578,7 @@ ConfigureSlaves(
 	 * a previous packing).
 	 */
 
-	if (slavePtr->masterPtr == NULL) {
+	if (slavePtr->containerPtr == NULL) {
 	    slavePtr->side = TOP;
 	    slavePtr->anchor = TK_ANCHOR_CENTER;
 	    slavePtr->padX = slavePtr->padY = 0;
@@ -1608,7 +1608,7 @@ ConfigureSlaves(
 			return TCL_ERROR;
 		    }
 		    prevPtr = GetPacker(other);
-		    if (prevPtr->masterPtr == NULL) {
+		    if (prevPtr->containerPtr == NULL) {
 		    notPacked:
 			Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 				"window \"%s\" isn't packed",
@@ -1617,7 +1617,7 @@ ConfigureSlaves(
 				NULL);
 			return TCL_ERROR;
 		    }
-		    masterPtr = prevPtr->masterPtr;
+		    containerPtr = prevPtr->containerPtr;
 		    positionGiven = 1;
 		}
 		break;
@@ -1634,11 +1634,11 @@ ConfigureSlaves(
 			return TCL_ERROR;
 		    }
 		    otherPtr = GetPacker(other);
-		    if (otherPtr->masterPtr == NULL) {
+		    if (otherPtr->containerPtr == NULL) {
 			goto notPacked;
 		    }
-		    masterPtr = otherPtr->masterPtr;
-		    prevPtr = masterPtr->slavePtr;
+		    containerPtr = otherPtr->containerPtr;
+		    prevPtr = containerPtr->slavePtr;
 		    if (prevPtr == otherPtr) {
 			prevPtr = NULL;
 		    } else {
@@ -1682,8 +1682,8 @@ ConfigureSlaves(
 			    != TCL_OK) {
 			return TCL_ERROR;
 		    }
-		    masterPtr = GetPacker(other);
-		    prevPtr = masterPtr->slavePtr;
+		    containerPtr = GetPacker(other);
+		    prevPtr = containerPtr->slavePtr;
 		    if (prevPtr != NULL) {
 			while (prevPtr->nextPtr != NULL) {
 			    prevPtr = prevPtr->nextPtr;
@@ -1742,8 +1742,8 @@ ConfigureSlaves(
 	 * current packing list.
 	 */
 
-	if (!positionGiven && (slavePtr->masterPtr != NULL)) {
-	    masterPtr = slavePtr->masterPtr;
+	if (!positionGiven && (slavePtr->containerPtr != NULL)) {
+	    containerPtr = slavePtr->containerPtr;
 	    goto scheduleLayout;
 	}
 
@@ -1754,7 +1754,7 @@ ConfigureSlaves(
 	 */
 
 	if (prevPtr == slavePtr) {
-	    masterPtr = slavePtr->masterPtr;
+	    containerPtr = slavePtr->containerPtr;
 	    goto scheduleLayout;
 	}
 
@@ -1765,8 +1765,8 @@ ConfigureSlaves(
 	 */
 
 	if (!positionGiven) {
-	    masterPtr = GetPacker(Tk_Parent(slave));
-	    prevPtr = masterPtr->slavePtr;
+	    containerPtr = GetPacker(Tk_Parent(slave));
+	    prevPtr = containerPtr->slavePtr;
 	    if (prevPtr != NULL) {
 		while (prevPtr->nextPtr != NULL) {
 		    prevPtr = prevPtr->nextPtr;
@@ -1781,19 +1781,19 @@ ConfigureSlaves(
 	 */
 
 	parent = Tk_Parent(slave);
-	for (ancestor = masterPtr->tkwin; ; ancestor = Tk_Parent(ancestor)) {
+	for (ancestor = containerPtr->tkwin; ; ancestor = Tk_Parent(ancestor)) {
 	    if (ancestor == parent) {
 		break;
 	    }
 	    if (Tk_TopWinHierarchy(ancestor)) {
 		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 			"can't pack %s inside %s", Tcl_GetString(objv[j]),
-			Tk_PathName(masterPtr->tkwin)));
+			Tk_PathName(containerPtr->tkwin)));
 		Tcl_SetErrorCode(interp, "TK", "GEOMETRY", "HIERARCHY", NULL);
 		return TCL_ERROR;
 	    }
 	}
-	if (slave == masterPtr->tkwin) {
+	if (slave == containerPtr->tkwin) {
 	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		    "can't pack %s inside itself", Tcl_GetString(objv[j])));
 	    Tcl_SetErrorCode(interp, "TK", "GEOMETRY", "SELF", NULL);
@@ -1804,18 +1804,18 @@ ConfigureSlaves(
 	 * Check for management loops.
 	 */
 
-	for (master = (TkWindow *)masterPtr->tkwin; master != NULL;
+	for (master = (TkWindow *)containerPtr->tkwin; master != NULL;
 	     master = (TkWindow *)TkGetGeomMaster(master)) {
 	    if (master == (TkWindow *)slave) {
 		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		    "can't put %s inside %s, would cause management loop",
-	            Tcl_GetString(objv[j]), Tk_PathName(masterPtr->tkwin)));
+	            Tcl_GetString(objv[j]), Tk_PathName(containerPtr->tkwin)));
 		Tcl_SetErrorCode(interp, "TK", "GEOMETRY", "LOOP", NULL);
 		return TCL_ERROR;
 	    }
 	}
-	if (masterPtr->tkwin != Tk_Parent(slave)) {
-	    ((TkWindow *)slave)->maintainerPtr = (TkWindow *)masterPtr->tkwin;
+	if (containerPtr->tkwin != Tk_Parent(slave)) {
+	    ((TkWindow *)slave)->maintainerPtr = (TkWindow *)containerPtr->tkwin;
 	}
 
 	/*
@@ -1823,20 +1823,20 @@ ConfigureSlaves(
 	 * prevPtr.
 	 */
 
-	if (slavePtr->masterPtr != NULL) {
-	    if ((slavePtr->masterPtr != masterPtr) &&
-		    (slavePtr->masterPtr->tkwin
+	if (slavePtr->containerPtr != NULL) {
+	    if ((slavePtr->containerPtr != containerPtr) &&
+		    (slavePtr->containerPtr->tkwin
 		    != Tk_Parent(slavePtr->tkwin))) {
 		Tk_UnmaintainGeometry(slavePtr->tkwin,
-			slavePtr->masterPtr->tkwin);
+			slavePtr->containerPtr->tkwin);
 	    }
 	    Unlink(slavePtr);
 	}
 
-	slavePtr->masterPtr = masterPtr;
+	slavePtr->containerPtr = containerPtr;
 	if (prevPtr == NULL) {
-	    slavePtr->nextPtr = masterPtr->slavePtr;
-	    masterPtr->slavePtr = slavePtr;
+	    slavePtr->nextPtr = containerPtr->slavePtr;
+	    containerPtr->slavePtr = slavePtr;
 	} else {
 	    slavePtr->nextPtr = prevPtr->nextPtr;
 	    prevPtr->nextPtr = slavePtr;
@@ -1844,14 +1844,14 @@ ConfigureSlaves(
 	Tk_ManageGeometry(slave, &packerType, slavePtr);
 	prevPtr = slavePtr;
 
-	if (!(masterPtr->flags & DONT_PROPAGATE)) {
-	    if (TkSetGeometryMaster(interp, masterPtr->tkwin, "pack")
+	if (!(containerPtr->flags & DONT_PROPAGATE)) {
+	    if (TkSetGeometryMaster(interp, containerPtr->tkwin, "pack")
 		    != TCL_OK) {
 		Tk_ManageGeometry(slave, NULL, NULL);
 		Unlink(slavePtr);
 		return TCL_ERROR;
 	    }
-	    masterPtr->flags |= ALLOCED_MASTER;
+	    containerPtr->flags |= ALLOCED_CONTAINER;
 	}
 
 	/*
@@ -1859,12 +1859,12 @@ ConfigureSlaves(
 	 */
 
     scheduleLayout:
-	if (masterPtr->abortPtr != NULL) {
-	    *masterPtr->abortPtr = 1;
+	if (containerPtr->abortPtr != NULL) {
+	    *containerPtr->abortPtr = 1;
 	}
-	if (!(masterPtr->flags & REQUESTED_REPACK)) {
-	    masterPtr->flags |= REQUESTED_REPACK;
-	    Tcl_DoWhenIdle(ArrangePacking, masterPtr);
+	if (!(containerPtr->flags & REQUESTED_REPACK)) {
+	    containerPtr->flags |= REQUESTED_REPACK;
+	    Tcl_DoWhenIdle(ArrangePacking, containerPtr);
 	}
     }
     return TCL_OK;
diff --git a/generic/tkPanedWindow.c b/generic/tkPanedWindow.c
index ac61ba8..fec9448 100644
--- a/generic/tkPanedWindow.c
+++ b/generic/tkPanedWindow.c
@@ -70,7 +70,7 @@ enum stretch {
 
 typedef struct {
     Tk_OptionTable pwOptions;	/* Token for paned window option table. */
-    Tk_OptionTable slaveOpts;	/* Token for slave cget option table. */
+    Tk_OptionTable paneOpts;	/* Token for pane cget option table. */
 } OptionTables;
 
 /*
@@ -78,35 +78,35 @@ typedef struct {
  * managed by a paned window widget.
  */
 
-typedef struct Slave {
+typedef struct Pane {
     Tk_Window tkwin;		/* Window being managed. */
     int minSize;		/* Minimum size of this pane, on the relevant
 				 * axis, in pixels. */
-    int padx;			/* Additional padding requested for slave, in
+    int padx;			/* Additional padding requested for pane, in
 				 * the x dimension. */
-    int pady;			/* Additional padding requested for slave, in
+    int pady;			/* Additional padding requested for pane, in
 				 * the y dimension. */
     Tcl_Obj *widthPtr, *heightPtr;
-				/* Tcl_Obj rep's of slave width/height, to
+				/* Tcl_Obj rep's of pane width/height, to
 				 * allow for null values. */
-    int width;			/* Slave width. */
-    int height;			/* Slave height. */
+    int width;			/* Pane width. */
+    int height;			/* Pane height. */
     int sticky;			/* Sticky string. */
     int x, y;			/* Coordinates of the widget. */
     int paneWidth, paneHeight;	/* Pane dimensions (may be different from
-				 * slave width/height). */
+				 * pane width/height). */
     int sashx, sashy;		/* Coordinates of the sash of the right or
 				 * bottom of this pane. */
     int markx, marky;		/* Coordinates of the last mark set for the
 				 * sash. */
     int handlex, handley;	/* Coordinates of the sash handle. */
-    enum stretch stretch;	/* Controls how slave grows/shrinks */
+    enum stretch stretch;	/* Controls how pane grows/shrinks */
     int hide;			/* Controls visibility of pane */
-    struct PanedWindow *masterPtr;
+    struct PanedWindow *containerPtr;
 				/* Paned window managing the window. */
     Tk_Window after;		/* Placeholder for parsing options. */
     Tk_Window before;		/* Placeholder for parsing options. */
-} Slave;
+} Pane;
 
 /*
  * A data structure of the following type is kept for each paned window widget
@@ -121,7 +121,7 @@ typedef struct PanedWindow {
     Tcl_Command widgetCmd;	/* Token for square's widget command. */
     Tk_OptionTable optionTable;	/* Token representing the configuration
 				 * specifications. */
-    Tk_OptionTable slaveOpts;	/* Token for slave cget table. */
+    Tk_OptionTable paneOpts;	/* Token for pane cget table. */
     Tk_3DBorder background;	/* Background color. */
     int borderWidth;		/* Value of -borderwidth option. */
     int relief;			/* 3D border effect (TK_RELIEF_RAISED, etc) */
@@ -151,9 +151,9 @@ typedef struct PanedWindow {
     Tcl_Obj *proxyBorderWidthPtr; /* Tcl_Obj rep for proxyBorderWidth */
     int proxyBorderWidth;	/* Borderwidth used to draw proxy. */
     int proxyRelief;		/* Relief used to draw proxy, if TK_RELIEF_NULL then use relief. */
-    Slave **slaves;		/* Pointer to array of Slaves. */
-    int numSlaves;		/* Number of slaves. */
-    int sizeofSlaves;		/* Number of elements in the slaves array. */
+    Pane **panes;		/* Pointer to array of Panes. */
+    int numPanes;		/* Number of panes. */
+    int sizeofPanes;		/* Number of elements in the panes array. */
     int flags;			/* Flags for widget; see below. */
 } PanedWindow;
 
@@ -200,16 +200,16 @@ static void		DisplayProxyWindow(ClientData clientData);
 static void		PanedWindowWorldChanged(ClientData instanceData);
 static int		PanedWindowWidgetObjCmd(ClientData clientData,
 			    Tcl_Interp *, int objc, Tcl_Obj * const objv[]);
-static void		PanedWindowLostSlaveProc(ClientData clientData,
+static void		PanedWindowLostPaneProc(ClientData clientData,
 			    Tk_Window tkwin);
 static void		PanedWindowReqProc(ClientData clientData,
 			    Tk_Window tkwin);
 static void		ArrangePanes(ClientData clientData);
-static void		Unlink(Slave *slavePtr);
-static Slave *		GetPane(PanedWindow *pwPtr, Tk_Window tkwin);
+static void		Unlink(Pane *panePtr);
+static Pane *		GetPane(PanedWindow *pwPtr, Tk_Window tkwin);
 static void		GetFirstLastVisiblePane(PanedWindow *pwPtr,
 			    int *firstPtr, int *lastPtr);
-static void		SlaveStructureProc(ClientData clientData,
+static void		PaneStructureProc(ClientData clientData,
 			    XEvent *eventPtr);
 static int		PanedWindowSashCommand(PanedWindow *pwPtr,
 			    Tcl_Interp *interp, int objc,
@@ -218,7 +218,7 @@ static int		PanedWindowProxyCommand(PanedWindow *pwPtr,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj * const objv[]);
 static void		ComputeGeometry(PanedWindow *pwPtr);
-static int		ConfigureSlaves(PanedWindow *pwPtr,
+static int		ConfigurePanes(PanedWindow *pwPtr,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj * const objv[]);
 static void		DestroyOptionTables(ClientData clientData,
@@ -233,7 +233,7 @@ static void		RestoreSticky(ClientData clientData, Tk_Window tkwin,
 			    char *internalPtr, char *oldInternalPtr);
 static void		AdjustForSticky(int sticky, int cavityWidth,
 			    int cavityHeight, int *xPtr, int *yPtr,
-			    int *slaveWidthPtr, int *slaveHeightPtr);
+			    int *paneWidthPtr, int *paneHeightPtr);
 static void		MoveSash(PanedWindow *pwPtr, int sash, int diff);
 static int		ObjectIsEmpty(Tcl_Obj *objPtr);
 static char *		ComputeSlotAddress(char *recordPtr, int offset);
@@ -241,16 +241,16 @@ static int		PanedWindowIdentifyCoords(PanedWindow *pwPtr,
 			    Tcl_Interp *interp, int x, int y);
 
 /*
- * Sashes are between panes only, so there is one less sash than slaves
+ * Sashes are between panes only, so there is one less sash than panes
  */
 
 #define ValidSashIndex(pwPtr, sash) \
-	(((sash) >= 0) && ((sash) < ((pwPtr)->numSlaves-1)))
+	(((sash) >= 0) && ((sash) < ((pwPtr)->numPanes-1)))
 
 static const Tk_GeomMgr panedWindowMgrType = {
     "panedwindow",		/* name */
     PanedWindowReqProc,		/* requestProc */
-    PanedWindowLostSlaveProc,	/* lostSlaveProc */
+    PanedWindowLostPaneProc,	/* lostPaneProc */
 };
 
 /*
@@ -261,7 +261,7 @@ static const Tk_GeomMgr panedWindowMgrType = {
 
 /*
  * The following structure contains pointers to functions used for processing
- * the custom "-sticky" option for slave windows.
+ * the custom "-sticky" option for panes.
  */
 
 static const Tk_ObjCustomOption stickyOption = {
@@ -334,33 +334,33 @@ static const Tk_OptionSpec optionSpecs[] = {
     {TK_OPTION_END, NULL, NULL, NULL, NULL, 0, 0, 0, 0, 0}
 };
 
-static const Tk_OptionSpec slaveOptionSpecs[] = {
+static const Tk_OptionSpec paneOptionSpecs[] = {
     {TK_OPTION_WINDOW, "-after", NULL, NULL,
-	 DEF_PANEDWINDOW_PANE_AFTER, -1, Tk_Offset(Slave, after),
+	 DEF_PANEDWINDOW_PANE_AFTER, -1, Tk_Offset(Pane, after),
 	 TK_OPTION_NULL_OK, 0, 0},
     {TK_OPTION_WINDOW, "-before", NULL, NULL,
-	 DEF_PANEDWINDOW_PANE_BEFORE, -1, Tk_Offset(Slave, before),
+	 DEF_PANEDWINDOW_PANE_BEFORE, -1, Tk_Offset(Pane, before),
 	 TK_OPTION_NULL_OK, 0, 0},
     {TK_OPTION_PIXELS, "-height", NULL, NULL,
-	 DEF_PANEDWINDOW_PANE_HEIGHT, Tk_Offset(Slave, heightPtr),
-	 Tk_Offset(Slave, height), TK_OPTION_NULL_OK, 0, 0},
+	 DEF_PANEDWINDOW_PANE_HEIGHT, Tk_Offset(Pane, heightPtr),
+	 Tk_Offset(Pane, height), TK_OPTION_NULL_OK, 0, 0},
     {TK_OPTION_BOOLEAN, "-hide", "hide", "Hide",
-	 DEF_PANEDWINDOW_PANE_HIDE, -1, Tk_Offset(Slave, hide), 0,0,GEOMETRY},
+	 DEF_PANEDWINDOW_PANE_HIDE, -1, Tk_Offset(Pane, hide), 0,0,GEOMETRY},
     {TK_OPTION_PIXELS, "-minsize", NULL, NULL,
-	 DEF_PANEDWINDOW_PANE_MINSIZE, -1, Tk_Offset(Slave, minSize), 0, 0, 0},
+	 DEF_PANEDWINDOW_PANE_MINSIZE, -1, Tk_Offset(Pane, minSize), 0, 0, 0},
     {TK_OPTION_PIXELS, "-padx", NULL, NULL,
-	 DEF_PANEDWINDOW_PANE_PADX, -1, Tk_Offset(Slave, padx), 0, 0, 0},
+	 DEF_PANEDWINDOW_PANE_PADX, -1, Tk_Offset(Pane, padx), 0, 0, 0},
     {TK_OPTION_PIXELS, "-pady", NULL, NULL,
-	 DEF_PANEDWINDOW_PANE_PADY, -1, Tk_Offset(Slave, pady), 0, 0, 0},
+	 DEF_PANEDWINDOW_PANE_PADY, -1, Tk_Offset(Pane, pady), 0, 0, 0},
     {TK_OPTION_CUSTOM, "-sticky", NULL, NULL,
-	 DEF_PANEDWINDOW_PANE_STICKY, -1, Tk_Offset(Slave, sticky), 0,
+	 DEF_PANEDWINDOW_PANE_STICKY, -1, Tk_Offset(Pane, sticky), 0,
 	 &stickyOption, 0},
     {TK_OPTION_STRING_TABLE, "-stretch", "stretch", "Stretch",
-	DEF_PANEDWINDOW_PANE_STRETCH, -1, Tk_Offset(Slave, stretch), 0,
+	DEF_PANEDWINDOW_PANE_STRETCH, -1, Tk_Offset(Pane, stretch), 0,
 	(ClientData) stretchStrings, 0},
     {TK_OPTION_PIXELS, "-width", NULL, NULL,
-	 DEF_PANEDWINDOW_PANE_WIDTH, Tk_Offset(Slave, widthPtr),
-	 Tk_Offset(Slave, width), TK_OPTION_NULL_OK, 0, 0},
+	 DEF_PANEDWINDOW_PANE_WIDTH, Tk_Offset(Pane, widthPtr),
+	 Tk_Offset(Pane, width), TK_OPTION_NULL_OK, 0, 0},
     {TK_OPTION_END, NULL, NULL, NULL, NULL, 0, 0, 0, 0, 0}
 };
 
@@ -428,7 +428,7 @@ Tk_PanedWindowObjCmd(
 	 */
 
 	pwOpts->pwOptions = Tk_CreateOptionTable(interp, optionSpecs);
-	pwOpts->slaveOpts = Tk_CreateOptionTable(interp, slaveOptionSpecs);
+	pwOpts->paneOpts = Tk_CreateOptionTable(interp, paneOptionSpecs);
     }
 
     Tk_SetClass(tkwin, "Panedwindow");
@@ -446,7 +446,7 @@ Tk_PanedWindowObjCmd(
 	    Tk_PathName(pwPtr->tkwin), PanedWindowWidgetObjCmd, pwPtr,
 	    PanedWindowCmdDeletedProc);
     pwPtr->optionTable = pwOpts->pwOptions;
-    pwPtr->slaveOpts = pwOpts->slaveOpts;
+    pwPtr->paneOpts = pwOpts->paneOpts;
     pwPtr->relief = TK_RELIEF_RAISED;
     pwPtr->gc = NULL;
     pwPtr->cursor = NULL;
@@ -471,7 +471,7 @@ Tk_PanedWindowObjCmd(
     /*
      * Find the toplevel ancestor of the panedwindow, and make a proxy win as
      * a child of that window; this way the proxy can always float above
-     * slaves in the panedwindow.
+     * panes in the panedwindow.
      */
 
     parent = Tk_Parent(pwPtr->tkwin);
@@ -548,7 +548,7 @@ PanedWindowWidgetObjCmd(
     Tcl_Obj *resultObj;
     int index, count, i, x, y;
     Tk_Window tkwin;
-    Slave *slavePtr;
+    Pane *panePtr;
 
     if (objc < 2) {
 	Tcl_WrongNumArgs(interp, 1, objv, "option ?arg arg...?");
@@ -569,7 +569,7 @@ PanedWindowWidgetObjCmd(
 	    result = TCL_ERROR;
 	    break;
 	}
-	result = ConfigureSlaves(pwPtr, interp, objc, objv);
+	result = ConfigurePanes(pwPtr, interp, objc, objv);
 	break;
 
     case PW_CGET:
@@ -616,21 +616,21 @@ PanedWindowWidgetObjCmd(
 	 * Clean up each window named in the arg list.
 	 */
 	for (count = 0, i = 2; i < objc; i++) {
-	    Tk_Window slave = Tk_NameToWindow(interp, Tcl_GetString(objv[i]),
+	    Tk_Window pane = Tk_NameToWindow(interp, Tcl_GetString(objv[i]),
 		    pwPtr->tkwin);
 
-	    if (slave == NULL) {
+	    if (pane == NULL) {
 		continue;
 	    }
-	    slavePtr = GetPane(pwPtr, slave);
-	    if ((slavePtr != NULL) && (slavePtr->masterPtr != NULL)) {
+	    panePtr = GetPane(pwPtr, pane);
+	    if ((panePtr != NULL) && (panePtr->containerPtr != NULL)) {
 		count++;
-		Tk_ManageGeometry(slave, NULL, NULL);
-		Tk_UnmaintainGeometry(slavePtr->tkwin, pwPtr->tkwin);
-		Tk_DeleteEventHandler(slavePtr->tkwin, StructureNotifyMask,
-			SlaveStructureProc, slavePtr);
-		Tk_UnmapWindow(slavePtr->tkwin);
-		Unlink(slavePtr);
+		Tk_ManageGeometry(pane, NULL, NULL);
+		Tk_UnmaintainGeometry(panePtr->tkwin, pwPtr->tkwin);
+		Tk_DeleteEventHandler(panePtr->tkwin, StructureNotifyMask,
+			PaneStructureProc, panePtr);
+		Tk_UnmapWindow(panePtr->tkwin);
+		Unlink(panePtr);
 	    }
 	    if (count != 0) {
 		ComputeGeometry(pwPtr);
@@ -666,15 +666,15 @@ PanedWindowWidgetObjCmd(
 	    break;
 	}
 	resultObj = NULL;
-	for (i = 0; i < pwPtr->numSlaves; i++) {
-	    if (pwPtr->slaves[i]->tkwin == tkwin) {
+	for (i = 0; i < pwPtr->numPanes; i++) {
+	    if (pwPtr->panes[i]->tkwin == tkwin) {
 		resultObj = Tk_GetOptionValue(interp,
-			(char *) pwPtr->slaves[i], pwPtr->slaveOpts,
+			(char *) pwPtr->panes[i], pwPtr->paneOpts,
 			objv[3], tkwin);
 	    }
 	}
 	if (resultObj == NULL) {
-	    if (i == pwPtr->numSlaves) {
+	    if (i == pwPtr->numPanes) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			"not managed by this window", -1));
 		Tcl_SetErrorCode(interp, "TK", "PANEDWINDOW", "UNMANAGED",
@@ -706,10 +706,10 @@ PanedWindowWidgetObjCmd(
                 result = TCL_ERROR;
                 break;
             }
-	    for (i = 0; i < pwPtr->numSlaves; i++) {
-		if (pwPtr->slaves[i]->tkwin == tkwin) {
+	    for (i = 0; i < pwPtr->numPanes; i++) {
+		if (pwPtr->panes[i]->tkwin == tkwin) {
 		    resultObj = Tk_GetOptionInfo(interp,
-			    (char *) pwPtr->slaves[i], pwPtr->slaveOpts,
+			    (char *) pwPtr->panes[i], pwPtr->paneOpts,
 			    (objc == 4) ? objv[3] : NULL,
 			    pwPtr->tkwin);
 		    if (resultObj == NULL) {
@@ -721,15 +721,15 @@ PanedWindowWidgetObjCmd(
 		}
 	    }
 	} else {
-	    result = ConfigureSlaves(pwPtr, interp, objc, objv);
+	    result = ConfigurePanes(pwPtr, interp, objc, objv);
 	}
 	break;
 
     case PW_PANES:
 	resultObj = Tcl_NewObj();
-	for (i = 0; i < pwPtr->numSlaves; i++) {
+	for (i = 0; i < pwPtr->numPanes; i++) {
 	    Tcl_ListObjAppendElement(NULL, resultObj,
-		    TkNewWindowObj(pwPtr->slaves[i]->tkwin));
+		    TkNewWindowObj(pwPtr->panes[i]->tkwin));
 	}
 	Tcl_SetObjResult(interp, resultObj);
 	break;
@@ -749,37 +749,37 @@ PanedWindowWidgetObjCmd(
 /*
  *----------------------------------------------------------------------
  *
- * ConfigureSlaves --
+ * ConfigurePanes --
  *
- *	Add or alter the configuration options of a slave in a paned window.
+ *	Add or alter the configuration options of a pane in a paned window.
  *
  * Results:
  *	Standard Tcl result.
  *
  * Side effects:
- *	Depends on options; may add a slave to the paned window, may alter the
- *	geometry management options of a slave.
+ *	Depends on options; may add a pane to the paned window, may alter the
+ *	geometry management options of a pane.
  *
  *----------------------------------------------------------------------
  */
 
 static int
-ConfigureSlaves(
+ConfigurePanes(
     PanedWindow *pwPtr,		/* Information about paned window. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    int i, firstOptionArg, j, found, doubleBw, index, numNewSlaves, haveLoc;
+    int i, firstOptionArg, j, found, doubleBw, index, numNewPanes, haveLoc;
     int insertIndex;
     Tk_Window tkwin = NULL, ancestor, parent;
-    Slave *slavePtr, **inserts, **newSlaves;
-    Slave options;
+    Pane *panePtr, **inserts, **newPanes;
+    Pane options;
     const char *arg;
 
     /*
      * Find the non-window name arguments; these are the configure options for
-     * the slaves. Also validate that the window names given are legitimate
+     * the panes. Also validate that the window names given are legitimate
      * (ie, they are real windows, they are not the panedwindow itself, etc.).
      */
 
@@ -817,8 +817,8 @@ ConfigureSlaves(
 		return TCL_ERROR;
 	    } else {
 		/*
-		 * Make sure the panedwindow is the parent of the slave,
-		 * or a descendant of the slave's parent.
+		 * Make sure the panedwindow is the parent of the pane,
+		 * or a descendant of the pane's parent.
 		 */
 
 		parent = Tk_Parent(tkwin);
@@ -847,8 +847,8 @@ ConfigureSlaves(
      * extra testing in the for loop below.
      */
 
-    memset((void *)&options, 0, sizeof(Slave));
-    if (Tk_SetOptions(interp, (char *) &options, pwPtr->slaveOpts,
+    memset((void *)&options, 0, sizeof(Pane));
+    if (Tk_SetOptions(interp, (char *) &options, pwPtr->paneOpts,
 	    objc - firstOptionArg, objv + firstOptionArg,
 	    pwPtr->tkwin, NULL, NULL) != TCL_OK) {
 	return TCL_ERROR;
@@ -865,8 +865,8 @@ ConfigureSlaves(
     if (options.after != NULL) {
 	tkwin = options.after;
 	haveLoc = 1;
-	for (i = 0; i < pwPtr->numSlaves; i++) {
-	    if (options.after == pwPtr->slaves[i]->tkwin) {
+	for (i = 0; i < pwPtr->numPanes; i++) {
+	    if (options.after == pwPtr->panes[i]->tkwin) {
 		index = i + 1;
 		break;
 	    }
@@ -874,8 +874,8 @@ ConfigureSlaves(
     } else if (options.before != NULL) {
 	tkwin = options.before;
 	haveLoc = 1;
-	for (i = 0; i < pwPtr->numSlaves; i++) {
-	    if (options.before == pwPtr->slaves[i]->tkwin) {
+	for (i = 0; i < pwPtr->numPanes; i++) {
+	    if (options.before == pwPtr->panes[i]->tkwin) {
 		index = i;
 		break;
 	    }
@@ -892,28 +892,28 @@ ConfigureSlaves(
 		"window \"%s\" is not managed by %s",
 		Tk_PathName(tkwin), Tk_PathName(pwPtr->tkwin)));
 	Tcl_SetErrorCode(interp, "TK", "PANEDWINDOW", "UNMANAGED", NULL);
-	Tk_FreeConfigOptions((char *) &options, pwPtr->slaveOpts,
+	Tk_FreeConfigOptions((char *) &options, pwPtr->paneOpts,
 		pwPtr->tkwin);
 	return TCL_ERROR;
     }
 
     /*
-     * Allocate an array to hold, in order, the pointers to the slave
+     * Allocate an array to hold, in order, the pointers to the pane
      * structures corresponding to the windows specified. Some of those
      * structures may already have existed, some may be new.
      */
 
-    inserts = ckalloc(sizeof(Slave *) * (firstOptionArg - 2));
+    inserts = ckalloc(sizeof(Pane *) * (firstOptionArg - 2));
     insertIndex = 0;
 
     /*
-     * Populate the inserts array, creating new slave structures as necessary,
+     * Populate the inserts array, creating new pane structures as necessary,
      * applying the options to each structure as we go, and, if necessary,
-     * marking the spot in the original slaves array as empty (for
-     * pre-existing slave structures).
+     * marking the spot in the original panes array as empty (for
+     * pre-existing pane structures).
      */
 
-    for (i = 0, numNewSlaves = 0; i < firstOptionArg - 2; i++) {
+    for (i = 0, numNewPanes = 0; i < firstOptionArg - 2; i++) {
 	/*
 	 * We don't check that tkwin is NULL here, because the pre-pass above
 	 * guarantees that the input at this stage is good.
@@ -923,24 +923,24 @@ ConfigureSlaves(
 		pwPtr->tkwin);
 
 	found = 0;
-	for (j = 0; j < pwPtr->numSlaves; j++) {
-	    if (pwPtr->slaves[j] != NULL && pwPtr->slaves[j]->tkwin == tkwin) {
-		Tk_SetOptions(interp, (char *) pwPtr->slaves[j],
-			pwPtr->slaveOpts, objc - firstOptionArg,
+	for (j = 0; j < pwPtr->numPanes; j++) {
+	    if (pwPtr->panes[j] != NULL && pwPtr->panes[j]->tkwin == tkwin) {
+		Tk_SetOptions(interp, (char *) pwPtr->panes[j],
+			pwPtr->paneOpts, objc - firstOptionArg,
 			objv + firstOptionArg, pwPtr->tkwin, NULL, NULL);
-		if (pwPtr->slaves[j]->minSize < 0) {
-		    pwPtr->slaves[j]->minSize = 0;
+		if (pwPtr->panes[j]->minSize < 0) {
+		    pwPtr->panes[j]->minSize = 0;
 		}
 		found = 1;
 
 		/*
-		 * If the slave is supposed to move, add it to the inserts
+		 * If the pane is supposed to move, add it to the inserts
 		 * array now; otherwise, leave it where it is.
 		 */
 
 		if (index != -1) {
-		    inserts[insertIndex++] = pwPtr->slaves[j];
-		    pwPtr->slaves[j] = NULL;
+		    inserts[insertIndex++] = pwPtr->panes[j];
+		    pwPtr->panes[j] = NULL;
 		}
 		break;
 	    }
@@ -951,7 +951,7 @@ ConfigureSlaves(
 	}
 
 	/*
-	 * Make sure this slave wasn't already put into the inserts array,
+	 * Make sure this pane wasn't already put into the inserts array,
 	 * i.e., when the user specifies the same window multiple times in a
 	 * single add commaned.
 	 */
@@ -966,104 +966,104 @@ ConfigureSlaves(
 	}
 
 	/*
-	 * Create a new slave structure and initialize it. All slaves start
+	 * Create a new pane structure and initialize it. All panes start
 	 * out with their "natural" dimensions.
 	 */
 
-	slavePtr = ckalloc(sizeof(Slave));
-	memset(slavePtr, 0, sizeof(Slave));
-	Tk_InitOptions(interp, (char *)slavePtr, pwPtr->slaveOpts,
+	panePtr = ckalloc(sizeof(Pane));
+	memset(panePtr, 0, sizeof(Pane));
+	Tk_InitOptions(interp, (char *)panePtr, pwPtr->paneOpts,
 		pwPtr->tkwin);
-	Tk_SetOptions(interp, (char *)slavePtr, pwPtr->slaveOpts,
+	Tk_SetOptions(interp, (char *)panePtr, pwPtr->paneOpts,
 		objc - firstOptionArg, objv + firstOptionArg,
 		pwPtr->tkwin, NULL, NULL);
-	slavePtr->tkwin = tkwin;
-	slavePtr->masterPtr = pwPtr;
-	doubleBw = 2 * Tk_Changes(slavePtr->tkwin)->border_width;
-	if (slavePtr->width > 0) {
-	    slavePtr->paneWidth = slavePtr->width;
+	panePtr->tkwin = tkwin;
+	panePtr->containerPtr = pwPtr;
+	doubleBw = 2 * Tk_Changes(panePtr->tkwin)->border_width;
+	if (panePtr->width > 0) {
+	    panePtr->paneWidth = panePtr->width;
 	} else {
-	    slavePtr->paneWidth = Tk_ReqWidth(tkwin) + doubleBw;
+	    panePtr->paneWidth = Tk_ReqWidth(tkwin) + doubleBw;
 	}
-	if (slavePtr->height > 0) {
-	    slavePtr->paneHeight = slavePtr->height;
+	if (panePtr->height > 0) {
+	    panePtr->paneHeight = panePtr->height;
 	} else {
-	    slavePtr->paneHeight = Tk_ReqHeight(tkwin) + doubleBw;
+	    panePtr->paneHeight = Tk_ReqHeight(tkwin) + doubleBw;
 	}
-	if (slavePtr->minSize < 0) {
-	    slavePtr->minSize = 0;
+	if (panePtr->minSize < 0) {
+	    panePtr->minSize = 0;
 	}
 
 	/*
-	 * Set up the geometry management callbacks for this slave.
+	 * Set up the geometry management callbacks for this pane.
 	 */
 
-	Tk_CreateEventHandler(slavePtr->tkwin, StructureNotifyMask,
-		SlaveStructureProc, slavePtr);
-	Tk_ManageGeometry(slavePtr->tkwin, &panedWindowMgrType, slavePtr);
-	inserts[insertIndex++] = slavePtr;
-	numNewSlaves++;
+	Tk_CreateEventHandler(panePtr->tkwin, StructureNotifyMask,
+		PaneStructureProc, panePtr);
+	Tk_ManageGeometry(panePtr->tkwin, &panedWindowMgrType, panePtr);
+	inserts[insertIndex++] = panePtr;
+	numNewPanes++;
     }
 
     /*
-     * Allocate the new slaves array, then copy the slaves into it, in order.
+     * Allocate the new panes array, then copy the panes into it, in order.
      */
 
-    i = sizeof(Slave *) * (pwPtr->numSlaves + numNewSlaves);
-    newSlaves = ckalloc(i);
-    memset(newSlaves, 0, (size_t) i);
+    i = sizeof(Pane *) * (pwPtr->numPanes + numNewPanes);
+    newPanes = ckalloc(i);
+    memset(newPanes, 0, (size_t) i);
     if (index == -1) {
 	/*
-	 * If none of the existing slaves have to be moved, just copy the old
+	 * If none of the existing panes have to be moved, just copy the old
 	 * and append the new.
 	 */
-	memcpy((void *)&(newSlaves[0]), pwPtr->slaves,
-		sizeof(Slave *) * pwPtr->numSlaves);
-	memcpy((void *)&(newSlaves[pwPtr->numSlaves]), inserts,
-		sizeof(Slave *) * numNewSlaves);
+	memcpy((void *)&(newPanes[0]), pwPtr->panes,
+		sizeof(Pane *) * pwPtr->numPanes);
+	memcpy((void *)&(newPanes[pwPtr->numPanes]), inserts,
+		sizeof(Pane *) * numNewPanes);
     } else {
 	/*
-	 * If some of the existing slaves were moved, the old slaves array
+	 * If some of the existing panes were moved, the old panes array
 	 * will be partially populated, with some valid and some invalid
-	 * entries. Walk through it, copying valid entries to the new slaves
+	 * entries. Walk through it, copying valid entries to the new panes
 	 * array as we go; when we get to the insert location for the new
-	 * slaves, copy the inserts array over, then finish off the old slaves
+	 * panes, copy the inserts array over, then finish off the old panes
 	 * array.
 	 */
 
 	for (i = 0, j = 0; i < index; i++) {
-	    if (pwPtr->slaves[i] != NULL) {
-		newSlaves[j] = pwPtr->slaves[i];
+	    if (pwPtr->panes[i] != NULL) {
+		newPanes[j] = pwPtr->panes[i];
 		j++;
 	    }
 	}
 
-	memcpy((void *)&(newSlaves[j]), inserts, sizeof(Slave *)*insertIndex);
+	memcpy((void *)&(newPanes[j]), inserts, sizeof(Pane *)*insertIndex);
 	j += firstOptionArg - 2;
 
-	for (i = index; i < pwPtr->numSlaves; i++) {
-	    if (pwPtr->slaves[i] != NULL) {
-		newSlaves[j] = pwPtr->slaves[i];
+	for (i = index; i < pwPtr->numPanes; i++) {
+	    if (pwPtr->panes[i] != NULL) {
+		newPanes[j] = pwPtr->panes[i];
 		j++;
 	    }
 	}
     }
 
     /*
-     * Make the new slaves array the paned window's slave array, and clean up.
+     * Make the new panes array the paned window's pane array, and clean up.
      */
 
-    ckfree(pwPtr->slaves);
+    ckfree(pwPtr->panes);
     ckfree(inserts);
-    pwPtr->slaves = newSlaves;
+    pwPtr->panes = newPanes;
 
     /*
-     * Set the paned window's slave count to the new value.
+     * Set the paned window's pane count to the new value.
      */
 
-    pwPtr->numSlaves += numNewSlaves;
+    pwPtr->numPanes += numNewPanes;
 
-    Tk_FreeConfigOptions((char *) &options, pwPtr->slaveOpts, pwPtr->tkwin);
+    Tk_FreeConfigOptions((char *) &options, pwPtr->paneOpts, pwPtr->tkwin);
 
     ComputeGeometry(pwPtr);
     return TCL_OK;
@@ -1101,7 +1101,7 @@ PanedWindowSashCommand(
     };
     int index, sash, x, y, diff;
     Tcl_Obj *coords[2];
-    Slave *slavePtr;
+    Pane *panePtr;
 
     if (objc < 3) {
 	Tcl_WrongNumArgs(interp, 2, objv, "option ?arg ...?");
@@ -1130,10 +1130,10 @@ PanedWindowSashCommand(
 	    Tcl_SetErrorCode(interp, "TK", "VALUE", "SASH_INDEX", NULL);
 	    return TCL_ERROR;
 	}
-	slavePtr = pwPtr->slaves[sash];
+	panePtr = pwPtr->panes[sash];
 
-	coords[0] = Tcl_NewIntObj(slavePtr->sashx);
-	coords[1] = Tcl_NewIntObj(slavePtr->sashy);
+	coords[0] = Tcl_NewIntObj(panePtr->sashx);
+	coords[1] = Tcl_NewIntObj(panePtr->sashy);
 	Tcl_SetObjResult(interp, Tcl_NewListObj(2, coords));
 	break;
 
@@ -1163,11 +1163,11 @@ PanedWindowSashCommand(
 		return TCL_ERROR;
 	    }
 
-	    pwPtr->slaves[sash]->markx = x;
-	    pwPtr->slaves[sash]->marky = y;
+	    pwPtr->panes[sash]->markx = x;
+	    pwPtr->panes[sash]->marky = y;
 	} else {
-	    coords[0] = Tcl_NewIntObj(pwPtr->slaves[sash]->markx);
-	    coords[1] = Tcl_NewIntObj(pwPtr->slaves[sash]->marky);
+	    coords[0] = Tcl_NewIntObj(pwPtr->panes[sash]->markx);
+	    coords[1] = Tcl_NewIntObj(pwPtr->panes[sash]->marky);
 	    Tcl_SetObjResult(interp, Tcl_NewListObj(2, coords));
 	}
 	break;
@@ -1198,18 +1198,18 @@ PanedWindowSashCommand(
 	    return TCL_ERROR;
 	}
 
-	slavePtr = pwPtr->slaves[sash];
+	panePtr = pwPtr->panes[sash];
 	if (pwPtr->orient == ORIENT_HORIZONTAL) {
 	    if (index == SASH_PLACE) {
-		diff = x - pwPtr->slaves[sash]->sashx;
+		diff = x - pwPtr->panes[sash]->sashx;
 	    } else {
-		diff = x - pwPtr->slaves[sash]->markx;
+		diff = x - pwPtr->panes[sash]->markx;
 	    }
 	} else {
 	    if (index == SASH_PLACE) {
-		diff = y - pwPtr->slaves[sash]->sashy;
+		diff = y - pwPtr->panes[sash]->sashy;
 	    } else {
-		diff = y - pwPtr->slaves[sash]->marky;
+		diff = y - pwPtr->panes[sash]->marky;
 	    }
 	}
 
@@ -1369,15 +1369,15 @@ PanedWindowEventProc(
     } else if (eventPtr->type == DestroyNotify) {
 	DestroyPanedWindow(pwPtr);
     } else if (eventPtr->type == UnmapNotify) {
-        for (i = 0; i < pwPtr->numSlaves; i++) {
-            if (!pwPtr->slaves[i]->hide) {
-                Tk_UnmapWindow(pwPtr->slaves[i]->tkwin);
+        for (i = 0; i < pwPtr->numPanes; i++) {
+            if (!pwPtr->panes[i]->hide) {
+                Tk_UnmapWindow(pwPtr->panes[i]->tkwin);
             }
         }
     } else if (eventPtr->type == MapNotify) {
-        for (i = 0; i < pwPtr->numSlaves; i++) {
-            if (!pwPtr->slaves[i]->hide) {
-                Tk_MapWindow(pwPtr->slaves[i]->tkwin);
+        for (i = 0; i < pwPtr->numPanes; i++) {
+            if (!pwPtr->panes[i]->hide) {
+                Tk_MapWindow(pwPtr->panes[i]->tkwin);
             }
         }
     }
@@ -1443,7 +1443,7 @@ DisplayPanedWindow(
     ClientData clientData)	/* Information about window. */
 {
     PanedWindow *pwPtr = clientData;
-    Slave *slavePtr;
+    Pane *panePtr;
     Pixmap pixmap;
     Tk_Window tkwin = pwPtr->tkwin;
     int i, sashWidth, sashHeight;
@@ -1496,19 +1496,19 @@ DisplayPanedWindow(
      */
 
     GetFirstLastVisiblePane(pwPtr, &first, &last);
-    for (i = 0; i < pwPtr->numSlaves - 1; i++) {
-	slavePtr = pwPtr->slaves[i];
-	if (slavePtr->hide || i == last) {
+    for (i = 0; i < pwPtr->numPanes - 1; i++) {
+	panePtr = pwPtr->panes[i];
+	if (panePtr->hide || i == last) {
 	    continue;
 	}
 	if (sashWidth > 0 && sashHeight > 0) {
 	    Tk_Fill3DRectangle(tkwin, pixmap, pwPtr->background,
-		    slavePtr->sashx, slavePtr->sashy, sashWidth, sashHeight,
+		    panePtr->sashx, panePtr->sashy, sashWidth, sashHeight,
 		    1, pwPtr->sashRelief);
 	}
 	if (pwPtr->showHandle) {
 	    Tk_Fill3DRectangle(tkwin, pixmap, pwPtr->background,
-		    slavePtr->handlex, slavePtr->handley,
+		    panePtr->handlex, panePtr->handley,
 		    pwPtr->handleSize, pwPtr->handleSize, 1,
 		    TK_RELIEF_RAISED);
 	}
@@ -1569,23 +1569,23 @@ DestroyPanedWindow(
     }
 
     /*
-     * Clean up the slave list; foreach slave:
-     *  o  Cancel the slave's structure notification callback
-     *  o  Cancel geometry management for the slave.
-     *  o  Free memory for the slave
+     * Clean up the pane list; foreach pane:
+     *  o  Cancel the pane's structure notification callback
+     *  o  Cancel geometry management for the pane.
+     *  o  Free memory for the pane
      */
 
-    for (i = 0; i < pwPtr->numSlaves; i++) {
-	Tk_DeleteEventHandler(pwPtr->slaves[i]->tkwin, StructureNotifyMask,
-		SlaveStructureProc, pwPtr->slaves[i]);
-	Tk_ManageGeometry(pwPtr->slaves[i]->tkwin, NULL, NULL);
-	Tk_FreeConfigOptions((char *) pwPtr->slaves[i], pwPtr->slaveOpts,
+    for (i = 0; i < pwPtr->numPanes; i++) {
+	Tk_DeleteEventHandler(pwPtr->panes[i]->tkwin, StructureNotifyMask,
+		PaneStructureProc, pwPtr->panes[i]);
+	Tk_ManageGeometry(pwPtr->panes[i]->tkwin, NULL, NULL);
+	Tk_FreeConfigOptions((char *) pwPtr->panes[i], pwPtr->paneOpts,
 		pwPtr->tkwin);
-	ckfree(pwPtr->slaves[i]);
-	pwPtr->slaves[i] = NULL;
+	ckfree(pwPtr->panes[i]);
+	pwPtr->panes[i] = NULL;
     }
-    if (pwPtr->slaves) {
-	ckfree(pwPtr->slaves);
+    if (pwPtr->panes) {
+	ckfree(pwPtr->panes);
     }
 
     /*
@@ -1630,8 +1630,8 @@ PanedWindowReqProc(
     Tk_Window tkwin)		/* Other Tk-related information about the
 				 * window. */
 {
-    Slave *slavePtr = clientData;
-    PanedWindow *pwPtr = (PanedWindow *) slavePtr->masterPtr;
+    Pane *panePtr = clientData;
+    PanedWindow *pwPtr = (PanedWindow *) panePtr->containerPtr;
 
     if (Tk_IsMapped(pwPtr->tkwin)) {
 	if (!(pwPtr->flags & RESIZE_PENDING)) {
@@ -1639,13 +1639,13 @@ PanedWindowReqProc(
 	    Tcl_DoWhenIdle(ArrangePanes, pwPtr);
 	}
     } else {
-	int doubleBw = 2 * Tk_Changes(slavePtr->tkwin)->border_width;
+	int doubleBw = 2 * Tk_Changes(panePtr->tkwin)->border_width;
 
-	if (slavePtr->width <= 0) {
-	    slavePtr->paneWidth = Tk_ReqWidth(slavePtr->tkwin) + doubleBw;
+	if (panePtr->width <= 0) {
+	    panePtr->paneWidth = Tk_ReqWidth(panePtr->tkwin) + doubleBw;
 	}
-	if (slavePtr->height <= 0) {
-	    slavePtr->paneHeight = Tk_ReqHeight(slavePtr->tkwin) + doubleBw;
+	if (panePtr->height <= 0) {
+	    panePtr->paneHeight = Tk_ReqHeight(panePtr->tkwin) + doubleBw;
 	}
 	ComputeGeometry(pwPtr);
     }
@@ -1654,39 +1654,39 @@ PanedWindowReqProc(
 /*
  *--------------------------------------------------------------
  *
- * PanedWindowLostSlaveProc --
+ * PanedWindowLostPaneProc --
  *
  *	This function is invoked by Tk whenever some other geometry claims
- *	control over a slave that used to be managed by us.
+ *	control over a pane that used to be managed by us.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	Forgets all information about the slave. Causes geometry to be
+ *	Forgets all information about the pane. Causes geometry to be
  *	recomputed for the panedwindow.
  *
  *--------------------------------------------------------------
  */
 
 static void
-PanedWindowLostSlaveProc(
-    ClientData clientData,	/* Grid structure for slave window that was
+PanedWindowLostPaneProc(
+    ClientData clientData,	/* Grid structure for the pane that was
 				 * stolen away. */
-    Tk_Window tkwin)		/* Tk's handle for the slave window. */
+    Tk_Window tkwin)		/* Tk's handle for the pane. */
 {
-    register Slave *slavePtr = clientData;
-    PanedWindow *pwPtr = (PanedWindow *) slavePtr->masterPtr;
-
-    if (pwPtr->tkwin != Tk_Parent(slavePtr->tkwin)) {
-	Tk_UnmaintainGeometry(slavePtr->tkwin, pwPtr->tkwin);
-    }
-    Unlink(slavePtr);
-    Tk_DeleteEventHandler(slavePtr->tkwin, StructureNotifyMask,
-	    SlaveStructureProc, slavePtr);
-    Tk_UnmapWindow(slavePtr->tkwin);
-    slavePtr->tkwin = NULL;
-    ckfree(slavePtr);
+    register Pane *panePtr = clientData;
+    PanedWindow *pwPtr = (PanedWindow *) panePtr->containerPtr;
+
+    if (pwPtr->tkwin != Tk_Parent(panePtr->tkwin)) {
+	Tk_UnmaintainGeometry(panePtr->tkwin, pwPtr->tkwin);
+    }
+    Unlink(panePtr);
+    Tk_DeleteEventHandler(panePtr->tkwin, StructureNotifyMask,
+	    PaneStructureProc, panePtr);
+    Tk_UnmapWindow(panePtr->tkwin);
+    panePtr->tkwin = NULL;
+    ckfree(panePtr);
     ComputeGeometry(pwPtr);
 }
 
@@ -1704,19 +1704,19 @@ PanedWindowLostSlaveProc(
  *	None.
  *
  * Side effects:
- *	The slaves of masterPtr may get resized or moved.
+ *	The panes of containerPtr may get resized or moved.
  *
  *--------------------------------------------------------------
  */
 
 static void
 ArrangePanes(
-    ClientData clientData)	/* Structure describing parent whose slaves
+    ClientData clientData)	/* Structure describing parent whose panes
 				 * are to be re-layed out. */
 {
     register PanedWindow *pwPtr = clientData;
-    register Slave *slavePtr;
-    int i, slaveWidth, slaveHeight, slaveX, slaveY;
+    register Pane *panePtr;
+    int i, newPaneWidth, newPaneHeight, paneX, paneY;
     int paneWidth, paneHeight, paneSize, paneMinSize;
     int doubleBw;
     int x, y;
@@ -1731,13 +1731,13 @@ ArrangePanes(
     pwPtr->flags &= ~(REQUESTED_RELAYOUT|RESIZE_PENDING);
 
     /*
-     * If the parent has no slaves anymore, then don't do anything at all:
+     * If the parent has no panes anymore, then don't do anything at all:
      * just leave the parent's size as-is. Otherwise there is no way to
      * "relinquish" control over the parent so another geometry manager can
      * take over.
      */
 
-    if (pwPtr->numSlaves == 0) {
+    if (pwPtr->numPanes == 0) {
 	return;
     }
 
@@ -1776,37 +1776,37 @@ ArrangePanes(
 		+ pwPtr->sashPad;
     }
 
-    for (i = sashCount = 0; i < pwPtr->numSlaves; i++) {
-	slavePtr = pwPtr->slaves[i];
+    for (i = sashCount = 0; i < pwPtr->numPanes; i++) {
+	panePtr = pwPtr->panes[i];
 
-	if (slavePtr->hide) {
+	if (panePtr->hide) {
 	    continue;
 	}
 
 	/*
-	 * Compute the total size needed by all the slaves and the left-over,
+	 * Compute the total size needed by all the panes and the left-over,
 	 * or shortage of space available.
 	 */
 
 	if (horizontal) {
-            if (slavePtr->width > 0) {
-                paneSize = slavePtr->width;
+            if (panePtr->width > 0) {
+                paneSize = panePtr->width;
             } else {
-                paneSize = slavePtr->paneWidth;
+                paneSize = panePtr->paneWidth;
             }
-	    stretchReserve -= paneSize + (2 * slavePtr->padx);
+	    stretchReserve -= paneSize + (2 * panePtr->padx);
 	} else {
-            if (slavePtr->height > 0) {
-                paneSize = slavePtr->height;
+            if (panePtr->height > 0) {
+                paneSize = panePtr->height;
             } else {
-                paneSize = slavePtr->paneHeight;
+                paneSize = panePtr->paneHeight;
             }
-	    stretchReserve -= paneSize + (2 * slavePtr->pady);
+	    stretchReserve -= paneSize + (2 * panePtr->pady);
 	}
-	if (IsStretchable(slavePtr->stretch,i,first,last)
+	if (IsStretchable(panePtr->stretch,i,first,last)
 		&& Tk_IsMapped(pwPtr->tkwin)) {
 	    paneDynSize += paneSize;
-	    paneDynMinSize += slavePtr->minSize;
+	    paneDynMinSize += panePtr->minSize;
 	}
 	if (i != last) {
 	    stretchReserve -= sashWidth;
@@ -1818,53 +1818,53 @@ ArrangePanes(
      * Second pass; adjust/arrange panes.
      */
 
-    for (i = 0; i < pwPtr->numSlaves; i++) {
-	slavePtr = pwPtr->slaves[i];
+    for (i = 0; i < pwPtr->numPanes; i++) {
+	panePtr = pwPtr->panes[i];
 
-	if (slavePtr->hide) {
-	    Tk_UnmaintainGeometry(slavePtr->tkwin, pwPtr->tkwin);
-	    Tk_UnmapWindow(slavePtr->tkwin);
+	if (panePtr->hide) {
+	    Tk_UnmaintainGeometry(panePtr->tkwin, pwPtr->tkwin);
+	    Tk_UnmapWindow(panePtr->tkwin);
 	    continue;
 	}
 
 	/*
-	 * Compute the size of this slave. The algorithm (assuming a
+	 * Compute the size of this pane. The algorithm (assuming a
 	 * horizontal paned window) is:
 	 *
 	 * 1.  Get "base" dimensions. If a width or height is specified for
-	 *     this slave, use those values; else use the ReqWidth/ReqHeight.
+	 *     this pane, use those values; else use the ReqWidth/ReqHeight.
 	 * 2.  Using base dimensions, pane dimensions, and sticky values,
 	 *     determine the x and y, and actual width and height of the
 	 *     widget.
 	 */
 
-	doubleBw = 2 * Tk_Changes(slavePtr->tkwin)->border_width;
-	slaveWidth = (slavePtr->width > 0 ? slavePtr->width :
-		Tk_ReqWidth(slavePtr->tkwin) + doubleBw);
-	slaveHeight = (slavePtr->height > 0 ? slavePtr->height :
-		Tk_ReqHeight(slavePtr->tkwin) + doubleBw);
-	paneMinSize = slavePtr->minSize;
+	doubleBw = 2 * Tk_Changes(panePtr->tkwin)->border_width;
+	newPaneWidth = (panePtr->width > 0 ? panePtr->width :
+		Tk_ReqWidth(panePtr->tkwin) + doubleBw);
+	newPaneHeight = (panePtr->height > 0 ? panePtr->height :
+		Tk_ReqHeight(panePtr->tkwin) + doubleBw);
+	paneMinSize = panePtr->minSize;
 
 	/*
 	 * Calculate pane width and height.
 	 */
 
 	if (horizontal) {
-            if (slavePtr->width > 0) {
-                paneSize = slavePtr->width;
+            if (panePtr->width > 0) {
+                paneSize = panePtr->width;
             } else {
-                paneSize = slavePtr->paneWidth;
+                paneSize = panePtr->paneWidth;
             }
 	    pwSize = pwWidth;
 	} else {
-            if (slavePtr->height > 0) {
-                paneSize = slavePtr->height;
+            if (panePtr->height > 0) {
+                paneSize = panePtr->height;
             } else {
-                paneSize = slavePtr->paneHeight;
+                paneSize = panePtr->paneHeight;
             }
 	    pwSize = pwHeight;
 	}
-	if (IsStretchable(slavePtr->stretch, i, first, last)) {
+	if (IsStretchable(panePtr->stretch, i, first, last)) {
 	    double frac;
 
 	    if (paneDynSize > 0) {
@@ -1874,7 +1874,7 @@ ArrangePanes(
 	    }
 
 	    paneDynSize -= paneSize;
-	    paneDynMinSize -= slavePtr->minSize;
+	    paneDynMinSize -= panePtr->minSize;
 	    stretchAmount = (int) (frac * stretchReserve);
 	    if (paneSize + stretchAmount >= paneMinSize) {
 		stretchReserve -= stretchAmount;
@@ -1899,9 +1899,9 @@ ArrangePanes(
 	}
 	if (horizontal) {
 	    paneWidth = paneSize;
-	    paneHeight = pwHeight - (2 * slavePtr->pady);
+	    paneHeight = pwHeight - (2 * panePtr->pady);
 	} else {
-	    paneWidth = pwWidth - (2 * slavePtr->padx);
+	    paneWidth = pwWidth - (2 * panePtr->padx);
 	    paneHeight = paneSize;
 	}
 
@@ -1929,15 +1929,15 @@ ArrangePanes(
 	    paneHeight = pwHeight - syReserve - y + internalBW;
 	}
 
-	if (slaveWidth > paneWidth) {
-	    slaveWidth = paneWidth;
+	if (newPaneWidth > paneWidth) {
+	    newPaneWidth = paneWidth;
 	}
-	if (slaveHeight > paneHeight) {
-	    slaveHeight = paneHeight;
+	if (newPaneHeight > paneHeight) {
+	    newPaneHeight = paneHeight;
 	}
 
-	slavePtr->x = x;
-	slavePtr->y = y;
+	panePtr->x = x;
+	panePtr->y = y;
 
 	/*
 	 * Compute the location of the sash at the right or bottom of the
@@ -1945,51 +1945,51 @@ ArrangePanes(
 	 */
 
 	if (horizontal) {
-	    x += paneWidth + (2 * slavePtr->padx);
+	    x += paneWidth + (2 * panePtr->padx);
 	    if (x < internalBW) {
 		x = internalBW;
 	    }
-	    slavePtr->sashx = x + sashOffset;
-	    slavePtr->sashy = y;
-	    slavePtr->handlex = x + handleOffset;
-	    slavePtr->handley = y + pwPtr->handlePad;
+	    panePtr->sashx = x + sashOffset;
+	    panePtr->sashy = y;
+	    panePtr->handlex = x + handleOffset;
+	    panePtr->handley = y + pwPtr->handlePad;
 	    x += sashWidth;
 	} else {
-	    y += paneHeight + (2 * slavePtr->pady);
+	    y += paneHeight + (2 * panePtr->pady);
 	    if (y < internalBW) {
 		y = internalBW;
 	    }
-	    slavePtr->sashx = x;
-	    slavePtr->sashy = y + sashOffset;
-	    slavePtr->handlex = x + pwPtr->handlePad;
-	    slavePtr->handley = y + handleOffset;
+	    panePtr->sashx = x;
+	    panePtr->sashy = y + sashOffset;
+	    panePtr->handlex = x + pwPtr->handlePad;
+	    panePtr->handley = y + handleOffset;
 	    y += sashWidth;
 	}
 
 	/*
-	 * Compute the actual dimensions of the slave in the pane.
+	 * Compute the actual dimensions of the pane in the pane.
 	 */
 
-	slaveX = slavePtr->x;
-	slaveY = slavePtr->y;
-	AdjustForSticky(slavePtr->sticky, paneWidth, paneHeight,
-		&slaveX, &slaveY, &slaveWidth, &slaveHeight);
+	paneX = panePtr->x;
+	paneY = panePtr->y;
+	AdjustForSticky(panePtr->sticky, paneWidth, paneHeight,
+		&paneX, &paneY, &newPaneWidth, &newPaneHeight);
 
-	slaveX += slavePtr->padx;
-	slaveY += slavePtr->pady;
+	paneX += panePtr->padx;
+	paneY += panePtr->pady;
 
 	/*
 	 * Now put the window in the proper spot.
 	 */
 
-	if (slaveWidth <= 0 || slaveHeight <= 0 ||
-		(horizontal ? slaveX - internalBW > pwWidth :
-		slaveY - internalBW > pwHeight)) {
-	    Tk_UnmaintainGeometry(slavePtr->tkwin, pwPtr->tkwin);
-	    Tk_UnmapWindow(slavePtr->tkwin);
+	if (newPaneWidth <= 0 || newPaneHeight <= 0 ||
+		(horizontal ? paneX - internalBW > pwWidth :
+		paneY - internalBW > pwHeight)) {
+	    Tk_UnmaintainGeometry(panePtr->tkwin, pwPtr->tkwin);
+	    Tk_UnmapWindow(panePtr->tkwin);
 	} else {
-	    Tk_MaintainGeometry(slavePtr->tkwin, pwPtr->tkwin,
-		    slaveX, slaveY, slaveWidth, slaveHeight);
+	    Tk_MaintainGeometry(panePtr->tkwin, pwPtr->tkwin,
+		    paneX, paneY, newPaneWidth, newPaneHeight);
 	}
 	sashCount--;
     }
@@ -2001,7 +2001,7 @@ ArrangePanes(
  *
  * Unlink --
  *
- *	Remove a slave from a paned window.
+ *	Remove a pane from a paned window.
  *
  * Results:
  *	None.
@@ -2014,57 +2014,57 @@ ArrangePanes(
 
 static void
 Unlink(
-    register Slave *slavePtr)		/* Window to unlink. */
+    register Pane *panePtr)		/* Window to unlink. */
 {
-    register PanedWindow *masterPtr;
+    register PanedWindow *containerPtr;
     int i, j;
 
-    masterPtr = slavePtr->masterPtr;
-    if (masterPtr == NULL) {
+    containerPtr = panePtr->containerPtr;
+    if (containerPtr == NULL) {
 	return;
     }
 
     /*
-     * Find the specified slave in the panedwindow's list of slaves, then
+     * Find the specified pane in the panedwindow's list of panes, then
      * remove it from that list.
      */
 
-    for (i = 0; i < masterPtr->numSlaves; i++) {
-	if (masterPtr->slaves[i] == slavePtr) {
-	    for (j = i; j < masterPtr->numSlaves - 1; j++) {
-		masterPtr->slaves[j] = masterPtr->slaves[j + 1];
+    for (i = 0; i < containerPtr->numPanes; i++) {
+	if (containerPtr->panes[i] == panePtr) {
+	    for (j = i; j < containerPtr->numPanes - 1; j++) {
+		containerPtr->panes[j] = containerPtr->panes[j + 1];
 	    }
 	    break;
 	}
     }
 
     /*
-     * Clean out any -after or -before references to this slave
+     * Clean out any -after or -before references to this pane
      */
 
-    for (i = 0; i < masterPtr->numSlaves; i++) {
-	if (masterPtr->slaves[i]->before == slavePtr->tkwin) {
-	    masterPtr->slaves[i]->before = NULL;
+    for (i = 0; i < containerPtr->numPanes; i++) {
+	if (containerPtr->panes[i]->before == panePtr->tkwin) {
+	    containerPtr->panes[i]->before = NULL;
 	}
-	if (masterPtr->slaves[i]->after == slavePtr->tkwin) {
-	    masterPtr->slaves[i]->after = NULL;
+	if (containerPtr->panes[i]->after == panePtr->tkwin) {
+	    containerPtr->panes[i]->after = NULL;
 	}
     }
 
-    masterPtr->flags |= REQUESTED_RELAYOUT;
-    if (!(masterPtr->flags & REDRAW_PENDING)) {
-	masterPtr->flags |= REDRAW_PENDING;
-	Tcl_DoWhenIdle(DisplayPanedWindow, masterPtr);
+    containerPtr->flags |= REQUESTED_RELAYOUT;
+    if (!(containerPtr->flags & REDRAW_PENDING)) {
+	containerPtr->flags |= REDRAW_PENDING;
+	Tcl_DoWhenIdle(DisplayPanedWindow, containerPtr);
     }
 
     /*
-     * Set the slave's masterPtr to NULL, so that we can tell that the slave
+     * Set the pane's containerPtr to NULL, so that we can tell that the pane
      * is no longer attached to any panedwindow.
      */
 
-    slavePtr->masterPtr = NULL;
+    panePtr->containerPtr = NULL;
 
-    masterPtr->numSlaves--;
+    containerPtr->numPanes--;
 }
 
 /*
@@ -2076,7 +2076,7 @@ Unlink(
  *	token in a given paned window.
  *
  * Results:
- *	Pointer to the slave structure, or NULL if the window is not managed
+ *	Pointer to the pane structure, or NULL if the window is not managed
  *	by this paned window.
  *
  * Side effects:
@@ -2085,16 +2085,16 @@ Unlink(
  *----------------------------------------------------------------------
  */
 
-static Slave *
+static Pane *
 GetPane(
     PanedWindow *pwPtr,		/* Pointer to the paned window info. */
     Tk_Window tkwin)		/* Window to search for. */
 {
     int i;
 
-    for (i = 0; i < pwPtr->numSlaves; i++) {
-	if (pwPtr->slaves[i]->tkwin == tkwin) {
-	    return pwPtr->slaves[i];
+    for (i = 0; i < pwPtr->numPanes; i++) {
+	if (pwPtr->panes[i]->tkwin == tkwin) {
+	    return pwPtr->panes[i];
 	}
     }
     return NULL;
@@ -2125,8 +2125,8 @@ GetFirstLastVisiblePane(
 {
     int i;
 
-    for (i = 0, *lastPtr = 0, *firstPtr = -1; i < pwPtr->numSlaves; i++) {
-	if (pwPtr->slaves[i]->hide == 0) {
+    for (i = 0, *lastPtr = 0, *firstPtr = -1; i < pwPtr->numPanes; i++) {
+	if (pwPtr->panes[i]->hide == 0) {
 	    if (*firstPtr < 0) {
 		*firstPtr = i;
 	    }
@@ -2138,7 +2138,7 @@ GetFirstLastVisiblePane(
 /*
  *--------------------------------------------------------------
  *
- * SlaveStructureProc --
+ * PaneStructureProc --
  *
  *	This function is invoked whenever StructureNotify events occur for a
  *	window that's managed by a paned window. This function's only purpose
@@ -2148,25 +2148,25 @@ GetFirstLastVisiblePane(
  *	None.
  *
  * Side effects:
- *	The paned window slave structure associated with the window
- *	is freed, and the slave is disassociated from the paned
+ *	The paned window pane structure associated with the window
+ *	is freed, and the pane is disassociated from the paned
  *	window which managed it.
  *
  *--------------------------------------------------------------
  */
 
 static void
-SlaveStructureProc(
+PaneStructureProc(
     ClientData clientData,	/* Pointer to record describing window item. */
     XEvent *eventPtr)		/* Describes what just happened. */
 {
-    Slave *slavePtr = clientData;
-    PanedWindow *pwPtr = slavePtr->masterPtr;
+    Pane *panePtr = clientData;
+    PanedWindow *pwPtr = panePtr->containerPtr;
 
     if (eventPtr->type == DestroyNotify) {
-	Unlink(slavePtr);
-	slavePtr->tkwin = NULL;
-	ckfree(slavePtr);
+	Unlink(panePtr);
+	panePtr->tkwin = NULL;
+	ckfree(panePtr);
 	ComputeGeometry(pwPtr);
     }
 }
@@ -2177,7 +2177,7 @@ SlaveStructureProc(
  * ComputeGeometry --
  *
  *	Compute geometry for the paned window, including coordinates of all
- *	slave windows and each sash.
+ *	panes and each sash.
  *
  * Results:
  *	None.
@@ -2195,7 +2195,7 @@ ComputeGeometry(
     int i, x, y, doubleBw, internalBw;
     int sashWidth, sashOffset, handleOffset;
     int reqWidth, reqHeight, dim;
-    Slave *slavePtr;
+    Pane *panePtr;
     const int horizontal = (pwPtr->orient == ORIENT_HORIZONTAL);
 
     pwPtr->flags |= REQUESTED_RELAYOUT;
@@ -2221,20 +2221,20 @@ ComputeGeometry(
 		+ pwPtr->sashPad;
     }
 
-    for (i = 0; i < pwPtr->numSlaves; i++) {
-	slavePtr = pwPtr->slaves[i];
+    for (i = 0; i < pwPtr->numPanes; i++) {
+	panePtr = pwPtr->panes[i];
 
-	if (slavePtr->hide) {
+	if (panePtr->hide) {
 	    continue;
 	}
 
 	/*
-	 * First set the coordinates for the top left corner of the slave's
+	 * First set the coordinates for the top left corner of the pane's
 	 * parcel.
 	 */
 
-	slavePtr->x = x;
-	slavePtr->y = y;
+	panePtr->x = x;
+	panePtr->y = y;
 
 	/*
 	 * Make sure the pane's paned dimension is at least minsize. This
@@ -2243,12 +2243,12 @@ ComputeGeometry(
 	 */
 
 	if (horizontal) {
-	    if (slavePtr->paneWidth < slavePtr->minSize) {
-		slavePtr->paneWidth = slavePtr->minSize;
+	    if (panePtr->paneWidth < panePtr->minSize) {
+		panePtr->paneWidth = panePtr->minSize;
 	    }
 	} else {
-	    if (slavePtr->paneHeight < slavePtr->minSize) {
-		slavePtr->paneHeight = slavePtr->minSize;
+	    if (panePtr->paneHeight < panePtr->minSize) {
+		panePtr->paneHeight = panePtr->minSize;
 	    }
 	}
 
@@ -2258,55 +2258,55 @@ ComputeGeometry(
 	 */
 
 	if (horizontal) {
-	    x += slavePtr->paneWidth + (2 * slavePtr->padx);
-	    slavePtr->sashx = x + sashOffset;
-	    slavePtr->sashy = y;
-	    slavePtr->handlex = x + handleOffset;
-	    slavePtr->handley = y + pwPtr->handlePad;
+	    x += panePtr->paneWidth + (2 * panePtr->padx);
+	    panePtr->sashx = x + sashOffset;
+	    panePtr->sashy = y;
+	    panePtr->handlex = x + handleOffset;
+	    panePtr->handley = y + pwPtr->handlePad;
 	    x += sashWidth;
 	} else {
-	    y += slavePtr->paneHeight + (2 * slavePtr->pady);
-	    slavePtr->sashx = x;
-	    slavePtr->sashy = y + sashOffset;
-	    slavePtr->handlex = x + pwPtr->handlePad;
-	    slavePtr->handley = y + handleOffset;
+	    y += panePtr->paneHeight + (2 * panePtr->pady);
+	    panePtr->sashx = x;
+	    panePtr->sashy = y + sashOffset;
+	    panePtr->handlex = x + pwPtr->handlePad;
+	    panePtr->handley = y + handleOffset;
 	    y += sashWidth;
 	}
 
 	/*
-	 * Find the maximum height/width of the slaves, for computing the
+	 * Find the maximum height/width of the panes, for computing the
 	 * requested height/width of the paned window.
 	 */
 
 	if (horizontal) {
 	    /*
-	     * If the slave has an explicit height set, use that; otherwise,
-	     * use the slave's requested height.
+	     * If the pane has an explicit height set, use that; otherwise,
+	     * use the pane's requested height.
 	     */
 
-	    if (slavePtr->height > 0) {
-		dim = slavePtr->height;
+	    if (panePtr->height > 0) {
+		dim = panePtr->height;
 	    } else {
-		doubleBw = 2 * Tk_Changes(slavePtr->tkwin)->border_width;
-		dim = Tk_ReqHeight(slavePtr->tkwin) + doubleBw;
+		doubleBw = 2 * Tk_Changes(panePtr->tkwin)->border_width;
+		dim = Tk_ReqHeight(panePtr->tkwin) + doubleBw;
 	    }
-	    dim += 2 * slavePtr->pady;
+	    dim += 2 * panePtr->pady;
 	    if (dim > reqHeight) {
 		reqHeight = dim;
 	    }
 	} else {
 	    /*
-	     * If the slave has an explicit width set use that; otherwise, use
-	     * the slave's requested width.
+	     * If the pane has an explicit width set use that; otherwise, use
+	     * the pane's requested width.
 	     */
 
-	    if (slavePtr->width > 0) {
-		dim = slavePtr->width;
+	    if (panePtr->width > 0) {
+		dim = panePtr->width;
 	    } else {
-		doubleBw = 2 * Tk_Changes(slavePtr->tkwin)->border_width;
-		dim = Tk_ReqWidth(slavePtr->tkwin) + doubleBw;
+		doubleBw = 2 * Tk_Changes(panePtr->tkwin)->border_width;
+		dim = Tk_ReqWidth(panePtr->tkwin) + doubleBw;
 	    }
-	    dim += 2 * slavePtr->padx;
+	    dim += 2 * panePtr->padx;
 	    if (dim > reqWidth) {
 		reqWidth = dim;
 	    }
@@ -2324,7 +2324,7 @@ ComputeGeometry(
      * the paned window.
      *
      * The height (or width) is equal to the maximum height (or width) of the
-     * slaves, plus the width of the border of the top and bottom (or left and
+     * panes, plus the width of the border of the top and bottom (or left and
      * right) of the paned window.
      *
      * If the panedwindow has an explicit width/height set use that;
@@ -2535,11 +2535,11 @@ RestoreSticky(
  * AdjustForSticky --
  *
  *	Given the x,y coords of the top-left corner of a pane, the dimensions
- *	of that pane, and the dimensions of a slave, compute the x,y coords
- *	and actual dimensions of the slave based on the slave's sticky value.
+ *	of that pane, and the dimensions of a pane, compute the x,y coords
+ *	and actual dimensions of the pane based on the pane's sticky value.
  *
  * Results:
- *	No direct return; sets the x, y, slaveWidth and slaveHeight to correct
+ *	No direct return; sets the x, y, paneWidth and paneHeight to correct
  *	values.
  *
  * Side effects:
@@ -2556,26 +2556,26 @@ AdjustForSticky(
     int cavityHeight,		/* Height of the cavity. */
     int *xPtr, int *yPtr,	/* Initially, coordinates of the top-left
 				 * corner of cavity; also return values for
-				 * actual x, y coords of slave. */
-    int *slaveWidthPtr,		/* Slave width. */
-    int *slaveHeightPtr)	/* Slave height. */
+				 * actual x, y coords of pane. */
+    int *paneWidthPtr,		/* Pane width. */
+    int *paneHeightPtr)	/* Pane height. */
 {
-    int diffx = 0;		/* Cavity width - slave width. */
-    int diffy = 0;		/* Cavity hight - slave height. */
+    int diffx = 0;		/* Cavity width - pane width. */
+    int diffy = 0;		/* Cavity hight - pane height. */
 
-    if (cavityWidth > *slaveWidthPtr) {
-	diffx = cavityWidth - *slaveWidthPtr;
+    if (cavityWidth > *paneWidthPtr) {
+	diffx = cavityWidth - *paneWidthPtr;
     }
 
-    if (cavityHeight > *slaveHeightPtr) {
-	diffy = cavityHeight - *slaveHeightPtr;
+    if (cavityHeight > *paneHeightPtr) {
+	diffy = cavityHeight - *paneHeightPtr;
     }
 
     if ((sticky & STICK_EAST) && (sticky & STICK_WEST)) {
-	*slaveWidthPtr += diffx;
+	*paneWidthPtr += diffx;
     }
     if ((sticky & STICK_NORTH) && (sticky & STICK_SOUTH)) {
-	*slaveHeightPtr += diffy;
+	*paneHeightPtr += diffy;
     }
     if (!(sticky & STICK_WEST)) {
 	*xPtr += (sticky & STICK_EAST) ? diffx : diffx/2;
@@ -2608,8 +2608,8 @@ MoveSash(
     int diff)
 {
     int i;
-    int expandPane, reduceFirst, reduceLast, reduceIncr, slaveSize, sashOffset;
-    Slave *slavePtr;
+    int expandPane, reduceFirst, reduceLast, reduceIncr, paneSize, sashOffset;
+    Pane *panePtr;
     int stretchReserve = 0;
     int nextSash = sash + 1;
     const int horizontal = (pwPtr->orient == ORIENT_HORIZONTAL);
@@ -2618,7 +2618,7 @@ MoveSash(
 	return;
 
     /*
-     * Update the slave sizes with their real sizes.
+     * Update the pane sizes with their real sizes.
      */
 
     if (pwPtr->showHandle && pwPtr->handleSize > pwPtr->sashWidth) {
@@ -2627,17 +2627,17 @@ MoveSash(
     } else {
 	sashOffset = pwPtr->sashPad;
     }
-    for (i = 0; i < pwPtr->numSlaves; i++) {
-	slavePtr = pwPtr->slaves[i];
-	if (slavePtr->hide) {
+    for (i = 0; i < pwPtr->numPanes; i++) {
+	panePtr = pwPtr->panes[i];
+	if (panePtr->hide) {
 	    continue;
 	}
 	if (horizontal) {
-	    slavePtr->paneWidth = slavePtr->width = slavePtr->sashx
-		    - sashOffset - slavePtr->x - (2 * slavePtr->padx);
+	    panePtr->paneWidth = panePtr->width = panePtr->sashx
+		    - sashOffset - panePtr->x - (2 * panePtr->padx);
 	} else {
-	    slavePtr->paneHeight = slavePtr->height = slavePtr->sashy
-		    - sashOffset - slavePtr->y - (2 * slavePtr->pady);
+	    panePtr->paneHeight = panePtr->height = panePtr->sashy
+		    - sashOffset - panePtr->y - (2 * panePtr->pady);
 	}
     }
 
@@ -2647,7 +2647,7 @@ MoveSash(
      * pane to either side of the sash.
      */
 
-    while (nextSash < pwPtr->numSlaves-1 && pwPtr->slaves[nextSash]->hide) {
+    while (nextSash < pwPtr->numPanes-1 && pwPtr->panes[nextSash]->hide) {
 	nextSash++;
     }
 
@@ -2658,7 +2658,7 @@ MoveSash(
     if (diff > 0) {
 	expandPane = sash;
 	reduceFirst = nextSash;
-	reduceLast = pwPtr->numSlaves;
+	reduceLast = pwPtr->numPanes;
 	reduceIncr = 1;
     } else {
 	diff = abs(diff);
@@ -2674,14 +2674,14 @@ MoveSash(
      */
 
     for (i = reduceFirst; i != reduceLast; i += reduceIncr) {
-	slavePtr = pwPtr->slaves[i];
-	if (slavePtr->hide) {
+	panePtr = pwPtr->panes[i];
+	if (panePtr->hide) {
 	    continue;
 	}
 	if (horizontal) {
-	    stretchReserve += slavePtr->width - slavePtr->minSize;
+	    stretchReserve += panePtr->width - panePtr->minSize;
 	} else {
-	    stretchReserve += slavePtr->height - slavePtr->minSize;
+	    stretchReserve += panePtr->height - panePtr->minSize;
 	}
     }
     if (stretchReserve <= 0) {
@@ -2695,11 +2695,11 @@ MoveSash(
      * Expand pane by diff amount.
      */
 
-    slavePtr = pwPtr->slaves[expandPane];
+    panePtr = pwPtr->panes[expandPane];
     if (horizontal) {
-	slavePtr->paneWidth = slavePtr->width += diff;
+	panePtr->paneWidth = panePtr->width += diff;
     } else {
-	slavePtr->paneHeight = slavePtr->height += diff;
+	panePtr->paneHeight = panePtr->height += diff;
     }
 
     /*
@@ -2707,26 +2707,26 @@ MoveSash(
      */
 
     for (i = reduceFirst; i != reduceLast; i += reduceIncr) {
-	slavePtr = pwPtr->slaves[i];
-	if (slavePtr->hide) {
+	panePtr = pwPtr->panes[i];
+	if (panePtr->hide) {
 	    continue;
 	}
 	if (horizontal) {
-	    slaveSize = slavePtr->width;
+	    paneSize = panePtr->width;
 	} else {
-	    slaveSize = slavePtr->height;
+	    paneSize = panePtr->height;
 	}
-	if (diff > (slaveSize - slavePtr->minSize)) {
-	    diff -= slaveSize - slavePtr->minSize;
-	    slaveSize = slavePtr->minSize;
+	if (diff > (paneSize - panePtr->minSize)) {
+	    diff -= paneSize - panePtr->minSize;
+	    paneSize = panePtr->minSize;
 	} else {
-	    slaveSize -= diff;
+	    paneSize -= diff;
 	    i = reduceLast - reduceIncr;
 	}
 	if (horizontal) {
-	    slavePtr->paneWidth = slavePtr->width = slaveSize;
+	    panePtr->paneWidth = panePtr->width = paneSize;
 	} else {
-	    slavePtr->paneHeight = slavePtr->height = slaveSize;
+	    panePtr->paneHeight = panePtr->height = paneSize;
 	}
     }
 }
@@ -2949,9 +2949,9 @@ PanedWindowProxyCommand(
 
 	/*
 	 * Make sure the proxy window is higher in the stacking order than the
-	 * slaves, so that it will be visible when drawn. It would be more
+	 * panes, so that it will be visible when drawn. It would be more
 	 * correct to push the proxy window just high enough to appear above
-	 * the highest slave, but it's much easier to just force it all the
+	 * the highest pane, but it's much easier to just force it all the
 	 * way to the top of the stacking order.
 	 */
 
@@ -3101,12 +3101,12 @@ PanedWindowIdentifyCoords(
     GetFirstLastVisiblePane(pwPtr, &first, &last);
     isHandle = 0;
     found = -1;
-    for (i = 0; i < pwPtr->numSlaves - 1; i++) {
-	if (pwPtr->slaves[i]->hide || i == last) {
+    for (i = 0; i < pwPtr->numPanes - 1; i++) {
+	if (pwPtr->panes[i]->hide || i == last) {
 	    continue;
 	}
-	thisx = pwPtr->slaves[i]->sashx;
-	thisy = pwPtr->slaves[i]->sashy;
+	thisx = pwPtr->panes[i]->sashx;
+	thisy = pwPtr->panes[i]->sashy;
 
 	if (((thisx - lpad) <= x && x <= (thisx + rpad + sashWidth)) &&
 		((thisy - tpad) <= y && y <= (thisy + bpad + sashHeight))) {
@@ -3117,8 +3117,8 @@ PanedWindowIdentifyCoords(
 	     */
 
 	    if (pwPtr->showHandle) {
-		thisx = pwPtr->slaves[i]->handlex;
-		thisy = pwPtr->slaves[i]->handley;
+		thisx = pwPtr->panes[i]->handlex;
+		thisy = pwPtr->panes[i]->handley;
 		if (pwPtr->orient == ORIENT_HORIZONTAL) {
 		    if (thisy <= y && y <= (thisy + pwPtr->handleSize)) {
 			isHandle = 1;
diff --git a/generic/tkPlace.c b/generic/tkPlace.c
index f5afa38..271b92a 100644
--- a/generic/tkPlace.c
+++ b/generic/tkPlace.c
@@ -17,10 +17,10 @@
  * Border modes for relative placement:
  *
  * BM_INSIDE:		relative distances computed using area inside all
- *			borders of master window.
+ *			borders of container window.
  * BM_OUTSIDE:		relative distances computed using outside area that
- *			includes all borders of master.
- * BM_IGNORE:		border issues are ignored: place relative to master's
+ *			includes all borders of container.
+ * BM_IGNORE:		border issues are ignored: place relative to container's
  *			actual window size.
  */
 
@@ -38,13 +38,13 @@ typedef enum {BM_INSIDE, BM_OUTSIDE, BM_IGNORE} BorderMode;
 typedef struct Slave {
     Tk_Window tkwin;		/* Tk's token for window. */
     Tk_Window inTkwin;		/* Token for the -in window. */
-    struct Master *masterPtr;	/* Pointer to information for window relative
+    struct Master *containerPtr;	/* Pointer to information for window relative
 				 * to which tkwin is placed. This isn't
 				 * necessarily the logical parent of tkwin.
-				 * NULL means the master was deleted or never
+				 * NULL means the container was deleted or never
 				 * assigned. */
     struct Slave *nextPtr;	/* Next in list of windows placed relative to
-				 * same master (NULL for end of list). */
+				 * same container (NULL for end of list). */
     Tk_OptionTable optionTable;	/* Table that defines configuration options
 				 * available for this command. */
     /*
@@ -57,19 +57,19 @@ typedef struct Slave {
     Tcl_Obj *xPtr, *yPtr;	/* Tcl_Obj rep's of x, y coords, to keep pixel
 				 * spec. information. */
     double relX, relY;		/* X and Y coordinates relative to size of
-				 * master. */
+				 * container. */
     int width, height;		/* Absolute dimensions for tkwin. */
     Tcl_Obj *widthPtr;		/* Tcl_Obj rep of width, to keep pixel
 				 * spec. */
     Tcl_Obj *heightPtr;		/* Tcl_Obj rep of height, to keep pixel
 				 * spec. */
     double relWidth, relHeight;	/* Dimensions for tkwin relative to size of
-				 * master. */
+				 * container. */
     Tcl_Obj *relWidthPtr;
     Tcl_Obj *relHeightPtr;
     Tk_Anchor anchor;		/* Which point on tkwin is placed at the given
 				 * position. */
-    BorderMode borderMode;	/* How to treat borders of master window. */
+    BorderMode borderMode;	/* How to treat borders of container window. */
     int flags;			/* Various flags; see below for bit
 				 * definitions. */
 } Slave;
@@ -123,14 +123,14 @@ static const Tk_OptionSpec optionSpecs[] = {
 #define CHILD_REL_HEIGHT	8
 
 /*
- * For each master window that has a slave managed by the placer there is a
+ * For each container window that has a slave managed by the placer there is a
  * structure of the following form:
  */
 
 typedef struct Master {
-    Tk_Window tkwin;		/* Tk's token for master window. */
+    Tk_Window tkwin;		/* Tk's token for container window. */
     struct Slave *slavePtr;	/* First in linked list of slaves placed
-				 * relative to this master. */
+				 * relative to this container. */
     int *abortPtr;		/* If non-NULL, it means that there is a nested
 				 * call to RecomputePlacement already working on
 				 * this window.  *abortPtr may be set to 1 to
@@ -141,7 +141,7 @@ typedef struct Master {
 } Master;
 
 /*
- * Flag definitions for masters:
+ * Flag definitions for containers:
  *
  * PARENT_RECONFIG_PENDING -	1 means that a call to RecomputePlacement is
  *				already pending via a Do_When_Idle handler.
@@ -309,9 +309,9 @@ Tk_PlaceObjCmd(
 	if (slavePtr == NULL) {
 	    return TCL_OK;
 	}
-	if ((slavePtr->masterPtr != NULL) &&
-		(slavePtr->masterPtr->tkwin != Tk_Parent(slavePtr->tkwin))) {
-	    Tk_UnmaintainGeometry(slavePtr->tkwin, slavePtr->masterPtr->tkwin);
+	if ((slavePtr->containerPtr != NULL) &&
+		(slavePtr->containerPtr->tkwin != Tk_Parent(slavePtr->tkwin))) {
+	    Tk_UnmaintainGeometry(slavePtr->tkwin, slavePtr->containerPtr->tkwin);
 	}
 	UnlinkSlave(slavePtr);
 	Tcl_DeleteHashEntry(Tcl_FindHashEntry(&dispPtr->slaveTable,
@@ -332,17 +332,17 @@ Tk_PlaceObjCmd(
 
     case PLACE_CONTENT:
     case PLACE_SLAVES: {
-	Master *masterPtr;
+	Master *containerPtr;
 
 	if (objc != 3) {
 	    Tcl_WrongNumArgs(interp, 2, objv, "pathName");
 	    return TCL_ERROR;
 	}
-	masterPtr = FindMaster(tkwin);
-	if (masterPtr != NULL) {
+	containerPtr = FindMaster(tkwin);
+	if (containerPtr != NULL) {
 	    Tcl_Obj *listPtr = Tcl_NewObj();
 
-	    for (slavePtr = masterPtr->slavePtr; slavePtr != NULL;
+	    for (slavePtr = containerPtr->slavePtr; slavePtr != NULL;
 		    slavePtr = slavePtr->nextPtr) {
 		Tcl_ListObjAppendElement(NULL, listPtr,
 			TkNewWindowObj(slavePtr->tkwin));
@@ -469,13 +469,13 @@ FindSlave(
  * UnlinkSlave --
  *
  *	This function removes a slave window from the chain of slaves in its
- *	master.
+ *	container.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The slave list of slavePtr's master changes.
+ *	The slave list of slavePtr's container changes.
  *
  *----------------------------------------------------------------------
  */
@@ -484,17 +484,17 @@ static void
 UnlinkSlave(
     Slave *slavePtr)		/* Slave structure to be unlinked. */
 {
-    register Master *masterPtr;
+    register Master *containerPtr;
     register Slave *prevPtr;
 
-    masterPtr = slavePtr->masterPtr;
-    if (masterPtr == NULL) {
+    containerPtr = slavePtr->containerPtr;
+    if (containerPtr == NULL) {
 	return;
     }
-    if (masterPtr->slavePtr == slavePtr) {
-	masterPtr->slavePtr = slavePtr->nextPtr;
+    if (containerPtr->slavePtr == slavePtr) {
+	containerPtr->slavePtr = slavePtr->nextPtr;
     } else {
-	for (prevPtr = masterPtr->slavePtr; ; prevPtr = prevPtr->nextPtr) {
+	for (prevPtr = containerPtr->slavePtr; ; prevPtr = prevPtr->nextPtr) {
 	    if (prevPtr == NULL) {
 		Tcl_Panic("UnlinkSlave couldn't find slave to unlink");
 	    }
@@ -505,10 +505,10 @@ UnlinkSlave(
 	}
     }
 
-    if (masterPtr->abortPtr != NULL) {
-	*masterPtr->abortPtr = 1;
+    if (containerPtr->abortPtr != NULL) {
+	*containerPtr->abortPtr = 1;
     }
-    slavePtr->masterPtr = NULL;
+    slavePtr->containerPtr = NULL;
 }
 
 /*
@@ -530,27 +530,27 @@ UnlinkSlave(
 
 static Master *
 CreateMaster(
-    Tk_Window tkwin)		/* Token for desired master. */
+    Tk_Window tkwin)		/* Token for desired container. */
 {
     Tcl_HashEntry *hPtr;
-    register Master *masterPtr;
+    register Master *containerPtr;
     int isNew;
     TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr;
 
     hPtr = Tcl_CreateHashEntry(&dispPtr->masterTable, (char *) tkwin, &isNew);
     if (isNew) {
-	masterPtr = ckalloc(sizeof(Master));
-	masterPtr->tkwin = tkwin;
-	masterPtr->slavePtr = NULL;
-	masterPtr->abortPtr = NULL;
-	masterPtr->flags = 0;
-	Tcl_SetHashValue(hPtr, masterPtr);
-	Tk_CreateEventHandler(masterPtr->tkwin, StructureNotifyMask,
-		MasterStructureProc, masterPtr);
+	containerPtr = ckalloc(sizeof(Master));
+	containerPtr->tkwin = tkwin;
+	containerPtr->slavePtr = NULL;
+	containerPtr->abortPtr = NULL;
+	containerPtr->flags = 0;
+	Tcl_SetHashValue(hPtr, containerPtr);
+	Tk_CreateEventHandler(containerPtr->tkwin, StructureNotifyMask,
+		MasterStructureProc, containerPtr);
     } else {
-	masterPtr = Tcl_GetHashValue(hPtr);
+	containerPtr = Tcl_GetHashValue(hPtr);
     }
-    return masterPtr;
+    return containerPtr;
 }
 
 /*
@@ -574,7 +574,7 @@ CreateMaster(
 
 static Master *
 FindMaster(
-    Tk_Window tkwin)		/* Token for desired master. */
+    Tk_Window tkwin)		/* Token for desired container. */
 {
     register Tcl_HashEntry *hPtr;
     TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr;
@@ -599,7 +599,7 @@ FindMaster(
  *	the interp's result.
  *
  * Side effects:
- *	Information in slavePtr may change, and slavePtr's master is scheduled
+ *	Information in slavePtr may change, and slavePtr's container is scheduled
  *	for reconfiguration.
  *
  *----------------------------------------------------------------------
@@ -613,12 +613,12 @@ ConfigureSlave(
     int objc,			/* Number of config arguments. */
     Tcl_Obj *const objv[])	/* Object values for arguments. */
 {
-    register Master *masterPtr;
+    register Master *containerPtr;
     Tk_SavedOptions savedOptions;
     int mask;
     Slave *slavePtr;
-    Tk_Window masterWin = NULL;
-    TkWindow *master;
+    Tk_Window containerWin = NULL;
+    TkWindow *container;
 
     if (Tk_TopWinHierarchy(tkwin)) {
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
@@ -656,13 +656,13 @@ ConfigureSlave(
 	slavePtr->flags |= CHILD_WIDTH;
     }
 
-    if (!(mask & IN_MASK) && (slavePtr->masterPtr != NULL)) {
+    if (!(mask & IN_MASK) && (slavePtr->containerPtr != NULL)) {
 	/*
 	 * If no -in option was passed and the slave is already placed then
 	 * just recompute the placement.
 	 */
 
-	masterPtr = slavePtr->masterPtr;
+	containerPtr = slavePtr->containerPtr;
 	goto scheduleLayout;
     } else if (mask & IN_MASK) {
 	/* -in changed */
@@ -672,8 +672,8 @@ ConfigureSlave(
 	tkwin = slavePtr->inTkwin;
 
 	/*
-	 * Make sure that the new master is either the logical parent of the
-	 * slave or a descendant of that window, and that the master and slave
+	 * Make sure that the new container is either the logical parent of the
+	 * slave or a descendant of that window, and that the container and slave
 	 * aren't the same.
 	 */
 
@@ -701,9 +701,9 @@ ConfigureSlave(
 	 * Check for management loops.
 	 */
 
-	for (master = (TkWindow *)tkwin; master != NULL;
-	     master = (TkWindow *)TkGetGeomMaster(master)) {
-	    if (master == (TkWindow *)slavePtr->tkwin) {
+	for (container = (TkWindow *)tkwin; container != NULL;
+	     container = (TkWindow *)TkGetGeomMaster(container)) {
+	    if (container == (TkWindow *)slavePtr->tkwin) {
 		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		    "can't put %s inside %s, would cause management loop",
 	            Tk_PathName(slavePtr->tkwin), Tk_PathName(tkwin)));
@@ -715,52 +715,52 @@ ConfigureSlave(
 	    ((TkWindow *)slavePtr->tkwin)->maintainerPtr = (TkWindow *)tkwin;
 	}
 
-	if ((slavePtr->masterPtr != NULL)
-		&& (slavePtr->masterPtr->tkwin == tkwin)) {
+	if ((slavePtr->containerPtr != NULL)
+		&& (slavePtr->containerPtr->tkwin == tkwin)) {
 	    /*
-	     * Re-using same old master. Nothing to do.
+	     * Re-using same old container. Nothing to do.
 	     */
 
-	    masterPtr = slavePtr->masterPtr;
+	    containerPtr = slavePtr->containerPtr;
 	    goto scheduleLayout;
 	}
-	if ((slavePtr->masterPtr != NULL) &&
-		(slavePtr->masterPtr->tkwin != Tk_Parent(slavePtr->tkwin))) {
-	    Tk_UnmaintainGeometry(slavePtr->tkwin, slavePtr->masterPtr->tkwin);
+	if ((slavePtr->containerPtr != NULL) &&
+		(slavePtr->containerPtr->tkwin != Tk_Parent(slavePtr->tkwin))) {
+	    Tk_UnmaintainGeometry(slavePtr->tkwin, slavePtr->containerPtr->tkwin);
 	}
 	UnlinkSlave(slavePtr);
-	masterWin = tkwin;
+	containerWin = tkwin;
     }
 
     /*
-     * If there's no master specified for this slave, use its Tk_Parent.
+     * If there's no container specified for this slave, use its Tk_Parent.
      */
 
-    if (masterWin == NULL) {
-	masterWin = Tk_Parent(slavePtr->tkwin);
-	slavePtr->inTkwin = masterWin;
+    if (containerWin == NULL) {
+	containerWin = Tk_Parent(slavePtr->tkwin);
+	slavePtr->inTkwin = containerWin;
     }
 
     /*
-     * Manage the slave window in this master.
+     * Manage the slave window in this container.
      */
 
-    masterPtr = CreateMaster(masterWin);
-    slavePtr->masterPtr = masterPtr;
-    slavePtr->nextPtr = masterPtr->slavePtr;
-    masterPtr->slavePtr = slavePtr;
+    containerPtr = CreateMaster(containerWin);
+    slavePtr->containerPtr = containerPtr;
+    slavePtr->nextPtr = containerPtr->slavePtr;
+    containerPtr->slavePtr = slavePtr;
     Tk_ManageGeometry(slavePtr->tkwin, &placerType, slavePtr);
 
     /*
-     * Arrange for the master to be re-arranged at the first idle moment.
+     * Arrange for the container to be re-arranged at the first idle moment.
      */
 
   scheduleLayout:
     Tk_FreeSavedOptions(&savedOptions);
 
-    if (!(masterPtr->flags & PARENT_RECONFIG_PENDING)) {
-	masterPtr->flags |= PARENT_RECONFIG_PENDING;
-	Tcl_DoWhenIdle(RecomputePlacement, masterPtr);
+    if (!(containerPtr->flags & PARENT_RECONFIG_PENDING)) {
+	containerPtr->flags |= PARENT_RECONFIG_PENDING;
+	Tcl_DoWhenIdle(RecomputePlacement, containerPtr);
     }
     return TCL_OK;
 
@@ -804,10 +804,10 @@ PlaceInfoCommand(
 	return TCL_OK;
     }
     infoObj = Tcl_NewObj();
-    if (slavePtr->masterPtr != NULL) {
+    if (slavePtr->containerPtr != NULL) {
 	Tcl_AppendToObj(infoObj, "-in", -1);
 	Tcl_ListObjAppendElement(NULL, infoObj,
-		TkNewWindowObj(slavePtr->masterPtr->tkwin));
+		TkNewWindowObj(slavePtr->containerPtr->tkwin));
 	Tcl_AppendToObj(infoObj, " ", -1);
     }
     Tcl_AppendPrintfToObj(infoObj,
@@ -849,7 +849,7 @@ PlaceInfoCommand(
  * RecomputePlacement --
  *
  *	This function is called as a when-idle handler. It recomputes the
- *	geometries of all the slaves of a given master.
+ *	geometries of all the slaves of a given container.
  *
  * Results:
  *	None.
@@ -864,15 +864,15 @@ static void
 RecomputePlacement(
     ClientData clientData)	/* Pointer to Master record. */
 {
-    register Master *masterPtr = clientData;
+    register Master *containerPtr = clientData;
     register Slave *slavePtr;
     int x, y, width, height, tmp;
-    int masterWidth, masterHeight, masterX, masterY;
+    int containerWidth, containerHeight, containerX, containerY;
     double x1, y1, x2, y2;
     int abort;			/* May get set to non-zero to abort this
 				 * placement operation. */
 
-    masterPtr->flags &= ~PARENT_RECONFIG_PENDING;
+    containerPtr->flags &= ~PARENT_RECONFIG_PENDING;
 
     /*
      * Abort any nested call to RecomputePlacement for this window, since
@@ -880,50 +880,50 @@ RecomputePlacement(
      * aborted if necessary.
      */
 
-    if (masterPtr->abortPtr != NULL) {
-	*masterPtr->abortPtr = 1;
+    if (containerPtr->abortPtr != NULL) {
+	*containerPtr->abortPtr = 1;
     }
-    masterPtr->abortPtr = &abort;
+    containerPtr->abortPtr = &abort;
     abort = 0;
-    Tcl_Preserve(masterPtr);
+    Tcl_Preserve(containerPtr);
 
     /*
-     * Iterate over all the slaves for the master. Each slave's geometry can
+     * Iterate over all the slaves for the container. Each slave's geometry can
      * be computed independently of the other slaves. Changes to the window's
      * structure could cause almost anything to happen, including deleting the
      * parent or child. If this happens, we'll be told to abort.
      */
 
-    for (slavePtr = masterPtr->slavePtr; slavePtr != NULL && !abort;
+    for (slavePtr = containerPtr->slavePtr; slavePtr != NULL && !abort;
 	    slavePtr = slavePtr->nextPtr) {
 	/*
-	 * Step 1: compute size and borderwidth of master, taking into account
+	 * Step 1: compute size and borderwidth of container, taking into account
 	 * desired border mode.
 	 */
 
-	masterX = masterY = 0;
-	masterWidth = Tk_Width(masterPtr->tkwin);
-	masterHeight = Tk_Height(masterPtr->tkwin);
+	containerX = containerY = 0;
+	containerWidth = Tk_Width(containerPtr->tkwin);
+	containerHeight = Tk_Height(containerPtr->tkwin);
 	if (slavePtr->borderMode == BM_INSIDE) {
-	    masterX = Tk_InternalBorderLeft(masterPtr->tkwin);
-	    masterY = Tk_InternalBorderTop(masterPtr->tkwin);
-	    masterWidth -= masterX + Tk_InternalBorderRight(masterPtr->tkwin);
-	    masterHeight -= masterY +
-		    Tk_InternalBorderBottom(masterPtr->tkwin);
+	    containerX = Tk_InternalBorderLeft(containerPtr->tkwin);
+	    containerY = Tk_InternalBorderTop(containerPtr->tkwin);
+	    containerWidth -= containerX + Tk_InternalBorderRight(containerPtr->tkwin);
+	    containerHeight -= containerY +
+		    Tk_InternalBorderBottom(containerPtr->tkwin);
 	} else if (slavePtr->borderMode == BM_OUTSIDE) {
-	    masterX = masterY = -Tk_Changes(masterPtr->tkwin)->border_width;
-	    masterWidth -= 2 * masterX;
-	    masterHeight -= 2 * masterY;
+	    containerX = containerY = -Tk_Changes(containerPtr->tkwin)->border_width;
+	    containerWidth -= 2 * containerX;
+	    containerHeight -= 2 * containerY;
 	}
 
 	/*
 	 * Step 2: compute size of slave (outside dimensions including border)
-	 * and location of anchor point within master.
+	 * and location of anchor point within container.
 	 */
 
-	x1 = slavePtr->x + masterX + (slavePtr->relX*masterWidth);
+	x1 = slavePtr->x + containerX + (slavePtr->relX*containerWidth);
 	x = (int) (x1 + ((x1 > 0) ? 0.5 : -0.5));
-	y1 = slavePtr->y + masterY + (slavePtr->relY*masterHeight);
+	y1 = slavePtr->y + containerY + (slavePtr->relY*containerHeight);
 	y = (int) (y1 + ((y1 > 0) ? 0.5 : -0.5));
 	if (slavePtr->flags & (CHILD_WIDTH|CHILD_REL_WIDTH)) {
 	    width = 0;
@@ -939,7 +939,7 @@ RecomputePlacement(
 		 * errors in relX and relWidth accumulate.
 		 */
 
-		x2 = x1 + (slavePtr->relWidth*masterWidth);
+		x2 = x1 + (slavePtr->relWidth*containerWidth);
 		tmp = (int) (x2 + ((x2 > 0) ? 0.5 : -0.5));
 		width += tmp - x;
 	    }
@@ -957,7 +957,7 @@ RecomputePlacement(
 		 * See note above for rounding errors in width computation.
 		 */
 
-		y2 = y1 + (slavePtr->relHeight*masterHeight);
+		y2 = y1 + (slavePtr->relHeight*containerHeight);
 		tmp = (int) (y2 + ((y2 > 0) ? 0.5 : -0.5));
 		height += tmp - y;
 	    }
@@ -969,7 +969,7 @@ RecomputePlacement(
 	/*
 	 * Step 3: adjust the x and y positions so that the desired anchor
 	 * point on the slave appears at that position. Also adjust for the
-	 * border mode and master's border.
+	 * border mode and container's border.
 	 */
 
 	switch (slavePtr->anchor) {
@@ -1022,12 +1022,12 @@ RecomputePlacement(
 
 	/*
 	 * Step 5: reconfigure the window and map it if needed. If the slave
-	 * is a child of the master, we do this ourselves. If the slave isn't
-	 * a child of the master, let Tk_MaintainGeometry do the work (it will
+	 * is a child of the container, we do this ourselves. If the slave isn't
+	 * a child of the container, let Tk_MaintainGeometry do the work (it will
 	 * re-adjust things as relevant windows map, unmap, and move).
 	 */
 
-	if (masterPtr->tkwin == Tk_Parent(slavePtr->tkwin)) {
+	if (containerPtr->tkwin == Tk_Parent(slavePtr->tkwin)) {
 	    if ((x != Tk_X(slavePtr->tkwin))
 		    || (y != Tk_Y(slavePtr->tkwin))
 		    || (width != Tk_Width(slavePtr->tkwin))
@@ -1039,26 +1039,26 @@ RecomputePlacement(
             }
 
 	    /*
-	     * Don't map the slave unless the master is mapped: the slave will
-	     * get mapped later, when the master is mapped.
+	     * Don't map the slave unless the container is mapped: the slave will
+	     * get mapped later, when the container is mapped.
 	     */
 
-	    if (Tk_IsMapped(masterPtr->tkwin)) {
+	    if (Tk_IsMapped(containerPtr->tkwin)) {
 		Tk_MapWindow(slavePtr->tkwin);
 	    }
 	} else {
 	    if ((width <= 0) || (height <= 0)) {
-		Tk_UnmaintainGeometry(slavePtr->tkwin, masterPtr->tkwin);
+		Tk_UnmaintainGeometry(slavePtr->tkwin, containerPtr->tkwin);
 		Tk_UnmapWindow(slavePtr->tkwin);
 	    } else {
-		Tk_MaintainGeometry(slavePtr->tkwin, masterPtr->tkwin,
+		Tk_MaintainGeometry(slavePtr->tkwin, containerPtr->tkwin,
 			x, y, width, height);
 	    }
 	}
     }
 
-    masterPtr->abortPtr = NULL;
-    Tcl_Release(masterPtr);
+    containerPtr->abortPtr = NULL;
+    Tcl_Release(containerPtr);
 }
 
 /*
@@ -1067,7 +1067,7 @@ RecomputePlacement(
  * MasterStructureProc --
  *
  *	This function is invoked by the Tk event handler when StructureNotify
- *	events occur for a master window.
+ *	events occur for a container window.
  *
  * Results:
  *	None.
@@ -1085,55 +1085,55 @@ MasterStructureProc(
 				 * referred to by eventPtr. */
     XEvent *eventPtr)		/* Describes what just happened. */
 {
-    register Master *masterPtr = clientData;
+    register Master *containerPtr = clientData;
     register Slave *slavePtr, *nextPtr;
-    TkDisplay *dispPtr = ((TkWindow *) masterPtr->tkwin)->dispPtr;
+    TkDisplay *dispPtr = ((TkWindow *) containerPtr->tkwin)->dispPtr;
 
     switch (eventPtr->type) {
     case ConfigureNotify:
-	if ((masterPtr->slavePtr != NULL)
-		&& !(masterPtr->flags & PARENT_RECONFIG_PENDING)) {
-	    masterPtr->flags |= PARENT_RECONFIG_PENDING;
-	    Tcl_DoWhenIdle(RecomputePlacement, masterPtr);
+	if ((containerPtr->slavePtr != NULL)
+		&& !(containerPtr->flags & PARENT_RECONFIG_PENDING)) {
+	    containerPtr->flags |= PARENT_RECONFIG_PENDING;
+	    Tcl_DoWhenIdle(RecomputePlacement, containerPtr);
 	}
 	return;
     case DestroyNotify:
-	for (slavePtr = masterPtr->slavePtr; slavePtr != NULL;
+	for (slavePtr = containerPtr->slavePtr; slavePtr != NULL;
 		slavePtr = nextPtr) {
-	    slavePtr->masterPtr = NULL;
+	    slavePtr->containerPtr = NULL;
 	    nextPtr = slavePtr->nextPtr;
 	    slavePtr->nextPtr = NULL;
 	}
 	Tcl_DeleteHashEntry(Tcl_FindHashEntry(&dispPtr->masterTable,
-		(char *) masterPtr->tkwin));
-	if (masterPtr->flags & PARENT_RECONFIG_PENDING) {
-	    Tcl_CancelIdleCall(RecomputePlacement, masterPtr);
+		(char *) containerPtr->tkwin));
+	if (containerPtr->flags & PARENT_RECONFIG_PENDING) {
+	    Tcl_CancelIdleCall(RecomputePlacement, containerPtr);
 	}
-	masterPtr->tkwin = NULL;
-	if (masterPtr->abortPtr != NULL) {
-	    *masterPtr->abortPtr = 1;
+	containerPtr->tkwin = NULL;
+	if (containerPtr->abortPtr != NULL) {
+	    *containerPtr->abortPtr = 1;
 	}
-	Tcl_EventuallyFree(masterPtr, TCL_DYNAMIC);
+	Tcl_EventuallyFree(containerPtr, TCL_DYNAMIC);
 	return;
     case MapNotify:
 	/*
-	 * When a master gets mapped, must redo the geometry computation so
+	 * When a container gets mapped, must redo the geometry computation so
 	 * that all of its slaves get remapped.
 	 */
 
-	if ((masterPtr->slavePtr != NULL)
-		&& !(masterPtr->flags & PARENT_RECONFIG_PENDING)) {
-	    masterPtr->flags |= PARENT_RECONFIG_PENDING;
-	    Tcl_DoWhenIdle(RecomputePlacement, masterPtr);
+	if ((containerPtr->slavePtr != NULL)
+		&& !(containerPtr->flags & PARENT_RECONFIG_PENDING)) {
+	    containerPtr->flags |= PARENT_RECONFIG_PENDING;
+	    Tcl_DoWhenIdle(RecomputePlacement, containerPtr);
 	}
 	return;
     case UnmapNotify:
 	/*
-	 * Unmap all of the slaves when the master gets unmapped, so that they
+	 * Unmap all of the slaves when the container gets unmapped, so that they
 	 * don't keep redisplaying themselves.
 	 */
 
-	for (slavePtr = masterPtr->slavePtr; slavePtr != NULL;
+	for (slavePtr = containerPtr->slavePtr; slavePtr != NULL;
 		slavePtr = slavePtr->nextPtr) {
 	    Tk_UnmapWindow(slavePtr->tkwin);
 	}
@@ -1168,7 +1168,7 @@ SlaveStructureProc(
     TkDisplay *dispPtr = ((TkWindow *) slavePtr->tkwin)->dispPtr;
 
     if (eventPtr->type == DestroyNotify) {
-	if (slavePtr->masterPtr != NULL) {
+	if (slavePtr->containerPtr != NULL) {
 	    UnlinkSlave(slavePtr);
 	}
 	Tcl_DeleteHashEntry(Tcl_FindHashEntry(&dispPtr->slaveTable,
@@ -1202,7 +1202,7 @@ PlaceRequestProc(
     Tk_Window tkwin)		/* Window that changed its desired size. */
 {
     Slave *slavePtr = clientData;
-    Master *masterPtr;
+    Master *containerPtr;
 
     if ((slavePtr->flags & (CHILD_WIDTH|CHILD_REL_WIDTH))
 	    && (slavePtr->flags & (CHILD_HEIGHT|CHILD_REL_HEIGHT))) {
@@ -1214,13 +1214,13 @@ PlaceRequestProc(
         TkDoConfigureNotify((TkWindow *)(slavePtr->tkwin));
 	return;
     }
-    masterPtr = slavePtr->masterPtr;
-    if (masterPtr == NULL) {
+    containerPtr = slavePtr->containerPtr;
+    if (containerPtr == NULL) {
 	return;
     }
-    if (!(masterPtr->flags & PARENT_RECONFIG_PENDING)) {
-	masterPtr->flags |= PARENT_RECONFIG_PENDING;
-	Tcl_DoWhenIdle(RecomputePlacement, masterPtr);
+    if (!(containerPtr->flags & PARENT_RECONFIG_PENDING)) {
+	containerPtr->flags |= PARENT_RECONFIG_PENDING;
+	Tcl_DoWhenIdle(RecomputePlacement, containerPtr);
     }
 }
 
@@ -1251,8 +1251,8 @@ PlaceLostSlaveProc(
     register Slave *slavePtr = clientData;
     TkDisplay *dispPtr = ((TkWindow *) slavePtr->tkwin)->dispPtr;
 
-    if (slavePtr->masterPtr->tkwin != Tk_Parent(slavePtr->tkwin)) {
-	Tk_UnmaintainGeometry(slavePtr->tkwin, slavePtr->masterPtr->tkwin);
+    if (slavePtr->containerPtr->tkwin != Tk_Parent(slavePtr->tkwin)) {
+	Tk_UnmaintainGeometry(slavePtr->tkwin, slavePtr->containerPtr->tkwin);
     }
     Tk_UnmapWindow(tkwin);
     UnlinkSlave(slavePtr);
diff --git a/generic/tkTextWind.c b/generic/tkTextWind.c
index c9fc20f..dd9e0ea 100644
--- a/generic/tkTextWind.c
+++ b/generic/tkTextWind.c
@@ -443,7 +443,7 @@ EmbWinConfigure(
 		    break;
 		}
 		if (Tk_TopWinHierarchy(ancestor)) {
-		badMaster:
+		badContainer:
 		    Tcl_SetObjResult(textPtr->interp, Tcl_ObjPrintf(
 			    "can't embed %s in %s",
 			    Tk_PathName(ewPtr->body.ew.tkwin),
@@ -459,7 +459,7 @@ EmbWinConfigure(
 	    }
 	    if (Tk_TopWinHierarchy(ewPtr->body.ew.tkwin)
 		    || (ewPtr->body.ew.tkwin == textPtr->tkwin)) {
-		goto badMaster;
+		goto badContainer;
 	    }
 
 	    if (client == NULL) {
@@ -936,12 +936,12 @@ EmbWinLayoutProc(
 		break;
 	    }
 	    if (Tk_TopWinHierarchy(ancestor)) {
-		goto badMaster;
+		goto badContainer;
 	    }
 	}
 	if (Tk_TopWinHierarchy(ewPtr->body.ew.tkwin)
 		|| (textPtr->tkwin == ewPtr->body.ew.tkwin)) {
-	badMaster:
+	badContainer:
 	    Tcl_SetObjResult(textPtr->interp, Tcl_ObjPrintf(
 		    "can't embed %s relative to %s",
 		    Tk_PathName(ewPtr->body.ew.tkwin),
diff --git a/generic/ttk/ttkManager.c b/generic/ttk/ttkManager.c
index c396f63..3621186 100644
--- a/generic/ttk/ttkManager.c
+++ b/generic/ttk/ttkManager.c
@@ -12,16 +12,16 @@
  * +++ The Geometry Propagation Dance.
  *
  * When a slave window requests a new size or some other parameter changes,
- * the manager recomputes the required size for the master window and calls
+ * the manager recomputes the required size for the container window and calls
  * Tk_GeometryRequest().  This is scheduled as an idle handler so multiple
  * updates can be processed as a single batch.
  *
- * If all goes well, the master's manager will process the request
- * (and so on up the chain to the toplevel window), and the master
+ * If all goes well, the container's manager will process the request
+ * (and so on up the chain to the toplevel window), and the container
  * window will eventually receive a <Configure> event.  At this point
  * it recomputes the size and position of all slaves and places them.
  *
- * If all does not go well, however, the master's request may be ignored
+ * If all does not go well, however, the container's request may be ignored
  * (typically because the top-level window has a fixed, user-specified size).
  * Tk doesn't provide any notification when this happens; to account for this,
  * we also schedule an idle handler to call the layout procedure
@@ -54,13 +54,13 @@ typedef struct
 
 /* slave->flags bits:
  */
-#define SLAVE_MAPPED 		0x1	/* slave to be mapped when master is */
+#define SLAVE_MAPPED 		0x1	/* slave to be mapped when container is */
 
 struct TtkManager_
 {
     Ttk_ManagerSpec	*managerSpec;
     void 		*managerData;
-    Tk_Window   	masterWindow;
+    Tk_Window   	containerWindow;
     unsigned		flags;
     int 	 	nSlaves;
     Ttk_Slave 		**slaves;
@@ -88,7 +88,7 @@ static void ScheduleUpdate(Ttk_Manager *mgr, unsigned flags)
 }
 
 /* ++ RecomputeSize --
- * 	Recomputes the required size of the master window,
+ * 	Recomputes the required size of the container window,
  * 	makes geometry request.
  */
 static void RecomputeSize(Ttk_Manager *mgr)
@@ -96,7 +96,7 @@ static void RecomputeSize(Ttk_Manager *mgr)
     int width = 1, height = 1;
 
     if (mgr->managerSpec->RequestedSize(mgr->managerData, &width, &height)) {
-	Tk_GeometryRequest(mgr->masterWindow, width, height);
+	Tk_GeometryRequest(mgr->containerWindow, width, height);
 	ScheduleUpdate(mgr, MGR_RELAYOUT_REQUIRED);
     }
     mgr->flags &= ~MGR_RESIZE_REQUIRED;
@@ -136,8 +136,8 @@ static void ManagerIdleProc(ClientData clientData)
  */
 
 /* ++ ManagerEventHandler --
- * 	Recompute slave layout when master widget is resized.
- * 	Keep the slave's map state in sync with the master's.
+ * 	Recompute slave layout when container widget is resized.
+ * 	Keep the slave's map state in sync with the container's.
  */
 static const int ManagerEventMask = StructureNotifyMask;
 static void ManagerEventHandler(ClientData clientData, XEvent *eventPtr)
@@ -208,19 +208,19 @@ static void DeleteSlave(Ttk_Slave *slave)
  */
 
 Ttk_Manager *Ttk_CreateManager(
-    Ttk_ManagerSpec *managerSpec, void *managerData, Tk_Window masterWindow)
+    Ttk_ManagerSpec *managerSpec, void *managerData, Tk_Window containerWindow)
 {
     Ttk_Manager *mgr = (Ttk_Manager *)ckalloc(sizeof(*mgr));
 
     mgr->managerSpec 	= managerSpec;
     mgr->managerData	= managerData;
-    mgr->masterWindow	= masterWindow;
+    mgr->containerWindow	= containerWindow;
     mgr->nSlaves 	= 0;
     mgr->slaves 	= NULL;
     mgr->flags  	= 0;
 
     Tk_CreateEventHandler(
-	mgr->masterWindow, ManagerEventMask, ManagerEventHandler, mgr);
+	mgr->containerWindow, ManagerEventMask, ManagerEventHandler, mgr);
 
     return mgr;
 }
@@ -228,7 +228,7 @@ Ttk_Manager *Ttk_CreateManager(
 void Ttk_DeleteManager(Ttk_Manager *mgr)
 {
     Tk_DeleteEventHandler(
-	mgr->masterWindow, ManagerEventMask, ManagerEventHandler, mgr);
+	mgr->containerWindow, ManagerEventMask, ManagerEventHandler, mgr);
 
     while (mgr->nSlaves > 0) {
 	Ttk_ForgetSlave(mgr, mgr->nSlaves - 1);
@@ -300,7 +300,7 @@ static void RemoveSlave(Ttk_Manager *mgr, int index)
 	slave->slaveWindow, SlaveEventMask, SlaveEventHandler, slave);
 
     /* Note [1] */
-    Tk_UnmaintainGeometry(slave->slaveWindow, mgr->masterWindow);
+    Tk_UnmaintainGeometry(slave->slaveWindow, mgr->containerWindow);
     Tk_UnmapWindow(slave->slaveWindow);
 
     DeleteSlave(slave);
@@ -370,9 +370,9 @@ void Ttk_PlaceSlave(
     Ttk_Manager *mgr, int slaveIndex, int x, int y, int width, int height)
 {
     Ttk_Slave *slave = mgr->slaves[slaveIndex];
-    Tk_MaintainGeometry(slave->slaveWindow,mgr->masterWindow,x,y,width,height);
+    Tk_MaintainGeometry(slave->slaveWindow,mgr->containerWindow,x,y,width,height);
     slave->flags |= SLAVE_MAPPED;
-    if (Tk_IsMapped(mgr->masterWindow)) {
+    if (Tk_IsMapped(mgr->containerWindow)) {
 	Tk_MapWindow(slave->slaveWindow);
     }
 }
@@ -383,7 +383,7 @@ void Ttk_PlaceSlave(
 void Ttk_UnmapSlave(Ttk_Manager *mgr, int slaveIndex)
 {
     Ttk_Slave *slave = mgr->slaves[slaveIndex];
-    Tk_UnmaintainGeometry(slave->slaveWindow, mgr->masterWindow);
+    Tk_UnmaintainGeometry(slave->slaveWindow, mgr->containerWindow);
     slave->flags &= ~SLAVE_MAPPED;
     /* Contrary to documentation, Tk_UnmaintainGeometry doesn't always
      * unmap the slave:
@@ -467,12 +467,12 @@ int Ttk_GetSlaveIndexFromObj(
     /* Try interpreting as a slave window name;
      */
     if ((*string == '.') &&
-	    (tkwin = Tk_NameToWindow(interp, string, mgr->masterWindow))) {
+	    (tkwin = Tk_NameToWindow(interp, string, mgr->containerWindow))) {
 	slaveIndex = Ttk_SlaveIndex(mgr, tkwin);
 	if (slaveIndex < 0) {
 	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		    "%s is not managed by %s", string,
-		    Tk_PathName(mgr->masterWindow)));
+		    Tk_PathName(mgr->containerWindow)));
 	    Tcl_SetErrorCode(interp, "TTK", "SLAVE", "MANAGER", NULL);
 	    return TCL_ERROR;
 	}
@@ -512,22 +512,22 @@ void Ttk_ReorderSlave(Ttk_Manager *mgr, int fromIndex, int toIndex)
     ScheduleUpdate(mgr, MGR_RESIZE_REQUIRED);
 }
 
-/* ++ Ttk_Maintainable(interp, slave, master) --
- * 	Utility routine.  Verifies that 'master' may be used to maintain
+/* ++ Ttk_Maintainable(interp, slave, container) --
+ * 	Utility routine.  Verifies that 'container' may be used to maintain
  *	the geometry of 'slave' via Tk_MaintainGeometry:
  *
- * 	+ 'master' is either 'slave's parent -OR-
- * 	+ 'master is a descendant of 'slave's parent.
+ * 	+ 'container' is either 'slave's parent -OR-
+ * 	+ 'container is a descendant of 'slave's parent.
  * 	+ 'slave' is not a toplevel window
- * 	+ 'slave' belongs to the same toplevel as 'master'
+ * 	+ 'slave' belongs to the same toplevel as 'container'
  *
  * Returns: 1 if OK; otherwise 0, leaving an error message in 'interp'.
  */
-int Ttk_Maintainable(Tcl_Interp *interp, Tk_Window slave, Tk_Window master)
+int Ttk_Maintainable(Tcl_Interp *interp, Tk_Window slave, Tk_Window container)
 {
-    Tk_Window ancestor = master, parent = Tk_Parent(slave);
+    Tk_Window ancestor = container, parent = Tk_Parent(slave);
 
-    if (Tk_IsTopLevel(slave) || slave == master) {
+    if (Tk_IsTopLevel(slave) || slave == container) {
 	goto badWindow;
     }
 
@@ -542,7 +542,7 @@ int Ttk_Maintainable(Tcl_Interp *interp, Tk_Window slave, Tk_Window master)
 
 badWindow:
     Tcl_SetObjResult(interp, Tcl_ObjPrintf("can't add %s as slave of %s",
-	    Tk_PathName(slave), Tk_PathName(master)));
+	    Tk_PathName(slave), Tk_PathName(container)));
     Tcl_SetErrorCode(interp, "TTK", "GEOMETRY", "MAINTAINABLE", NULL);
     return 0;
 }
diff --git a/generic/ttk/ttkManager.h b/generic/ttk/ttkManager.h
index 07fcea1..0a66ada 100644
--- a/generic/ttk/ttkManager.h
+++ b/generic/ttk/ttkManager.h
@@ -14,7 +14,7 @@ typedef struct TtkManager_ Ttk_Manager;
 /*
  * Geometry manager specification record:
  *
- * RequestedSize computes the requested size of the master window.
+ * RequestedSize computes the requested size of the container window.
  *
  * PlaceSlaves sets the position and size of all managed slaves
  * by calling Ttk_PlaceSlave().
@@ -45,7 +45,7 @@ MODULE_SCOPE void Ttk_LostSlaveProc(ClientData, Tk_Window slave);
  * Public API:
  */
 MODULE_SCOPE Ttk_Manager *Ttk_CreateManager(
-	Ttk_ManagerSpec *, void *managerData, Tk_Window masterWindow);
+	Ttk_ManagerSpec *, void *managerData, Tk_Window window);
 MODULE_SCOPE void Ttk_DeleteManager(Ttk_Manager *);
 
 MODULE_SCOPE void Ttk_InsertSlave(
@@ -86,7 +86,7 @@ MODULE_SCOPE void *Ttk_SlaveData(Ttk_Manager *, int slaveIndex);
 MODULE_SCOPE Tk_Window Ttk_SlaveWindow(Ttk_Manager *, int slaveIndex);
     /* Returns: slave window */
 
-MODULE_SCOPE int Ttk_Maintainable(Tcl_Interp *, Tk_Window slave, Tk_Window master);
-    /* Returns: 1 if master can manage slave; 0 otherwise leaving error msg */
+MODULE_SCOPE int Ttk_Maintainable(Tcl_Interp *, Tk_Window content, Tk_Window container);
+    /* Returns: 1 if container can manage content; 0 otherwise leaving error msg */
 
 #endif /* _TTKMANAGER */
diff --git a/generic/ttk/ttkPanedwindow.c b/generic/ttk/ttkPanedwindow.c
index adc2aef..704e90c 100644
--- a/generic/ttk/ttkPanedwindow.c
+++ b/generic/ttk/ttkPanedwindow.c
@@ -213,7 +213,7 @@ static int ShoveDown(Paned *pw, int i, int pos)
     int sashThickness = pw->paned.sashThickness;
 
     if (i == Ttk_NumberSlaves(pw->paned.mgr) - 1) {
-	pos = pane->sashPos; /* Sentinel value == master window size */
+	pos = pane->sashPos; /* Sentinel value == container window size */
     } else {
 	Pane *nextPane = Ttk_SlaveData(pw->paned.mgr,i+1);
 	if (pos + sashThickness > nextPane->sashPos)