summaryrefslogtreecommitdiffstats
path: root/tk8.6/generic/tkPack.c
diff options
context:
space:
mode:
Diffstat (limited to 'tk8.6/generic/tkPack.c')
-rw-r--r--tk8.6/generic/tkPack.c1859
1 files changed, 0 insertions, 1859 deletions
diff --git a/tk8.6/generic/tkPack.c b/tk8.6/generic/tkPack.c
deleted file mode 100644
index 88a4b2d..0000000
--- a/tk8.6/generic/tkPack.c
+++ /dev/null
@@ -1,1859 +0,0 @@
-/*
- * tkPack.c --
- *
- * This file contains code to implement the "packer" geometry manager for
- * Tk.
- *
- * Copyright (c) 1990-1994 The Regents of the University of California.
- * Copyright (c) 1994-1997 Sun Microsystems, Inc.
- *
- * See the file "license.terms" for information on usage and redistribution of
- * this file, and for a DISCLAIMER OF ALL WARRANTIES.
- */
-
-#include "tkInt.h"
-
-typedef enum {TOP, BOTTOM, LEFT, RIGHT} Side;
-static const char *const sideNames[] = {
- "top", "bottom", "left", "right", NULL
-};
-
-/*
- * For each window that the packer cares about (either because the window is
- * managed by the packer or because the window has slaves that are managed by
- * the packer), there is a structure of the following type:
- */
-
-typedef struct Packer {
- Tk_Window tkwin; /* Tk token for window. NULL means that the
- * 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
- * packed (NULL means this window isn't
- * managed by the packer). */
- struct Packer *nextPtr; /* Next window packed within same master. List
- * is priority-ordered: first on list gets
- * packed first. */
- struct Packer *slavePtr; /* First in list of slaves packed inside this
- * window (NULL means no packed slaves). */
- Side side; /* Side of master against which this window is
- * packed. */
- Tk_Anchor anchor; /* If frame allocated for window is larger
- * than window needs, this indicates how where
- * to position window in frame. */
- int padX, padY; /* Total additional pixels to leave around the
- * window. Some is of this space is on each
- * side. This is space *outside* the window:
- * we'll allocate extra space in frame but
- * won't enlarge window). */
- int padLeft, padTop; /* The part of padX or padY to use on the left
- * or top of the widget, respectively. By
- * default, this is half of padX or padY. */
- int iPadX, iPadY; /* Total extra pixels to allocate inside the
- * window (half of this amount will appear on
- * each side). */
- int doubleBw; /* Twice the window's last known border width.
- * If this changes, the window must be
- * repacked within its master. */
- int *abortPtr; /* If non-NULL, it means that there is a
- * nested call to ArrangePacking already
- * working on this window. *abortPtr may be
- * set to 1 to abort that nested call. This
- * happens, for example, if tkwin or any of
- * its slaves is deleted. */
- int flags; /* Miscellaneous flags; see below for
- * definitions. */
-} Packer;
-
-/*
- * Flag values for Packer structures:
- *
- * REQUESTED_REPACK: 1 means a Tcl_DoWhenIdle request has already
- * been made to repack all the slaves of this
- * window.
- * FILLX: 1 means if frame allocated for window is wider
- * than window needs, expand window to fill
- * frame. 0 means don't make window any larger
- * than needed.
- * FILLY: Same as FILLX, except for height.
- * EXPAND: 1 means this window's frame will absorb any
- * extra space in the master window.
- * OLD_STYLE: 1 means this window is being managed with the
- * old-style packer algorithms (before Tk version
- * 3.3). The main difference is that padding and
- * filling are done differently.
- * DONT_PROPAGATE: 1 means don't set this window's requested
- * 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.
- */
-
-#define REQUESTED_REPACK 1
-#define FILLX 2
-#define FILLY 4
-#define EXPAND 8
-#define OLD_STYLE 16
-#define DONT_PROPAGATE 32
-#define ALLOCED_MASTER 64
-
-/*
- * The following structure is the official type record for the packer:
- */
-
-static void PackReqProc(ClientData clientData, Tk_Window tkwin);
-static void PackLostSlaveProc(ClientData clientData,
- Tk_Window tkwin);
-
-static const Tk_GeomMgr packerType = {
- "pack", /* name */
- PackReqProc, /* requestProc */
- PackLostSlaveProc, /* lostSlaveProc */
-};
-
-/*
- * Forward declarations for functions defined later in this file:
- */
-
-static void ArrangePacking(ClientData clientData);
-static int ConfigureSlaves(Tcl_Interp *interp, Tk_Window tkwin,
- int objc, Tcl_Obj *const objv[]);
-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[]);
-static void PackStructureProc(ClientData clientData,
- XEvent *eventPtr);
-static void Unlink(Packer *packPtr);
-static int XExpansion(Packer *slavePtr, int cavityWidth);
-static int YExpansion(Packer *slavePtr, int cavityHeight);
-
-/*
- *------------------------------------------------------------------------
- *
- * TkAppendPadAmount --
- *
- * This function generates a text value that describes one of the -padx,
- * -pady, -ipadx, or -ipady configuration options. The text value
- * generated is appended to the given Tcl_Obj.
- *
- * Results:
- * None.
- *
- * Side effects:
- * None.
- *
- *------------------------------------------------------------------------
- */
-
-void
-TkAppendPadAmount(
- Tcl_Obj *bufferObj, /* The interpreter into which the result is
- * written. */
- const char *switchName, /* One of "padx", "pady", "ipadx" or
- * "ipady" */
- int halfSpace, /* The left or top padding amount */
- int allSpace) /* The total amount of padding */
-{
- Tcl_Obj *padding[2];
-
- if (halfSpace*2 == allSpace) {
- Tcl_DictObjPut(NULL, bufferObj, Tcl_NewStringObj(switchName, -1),
- Tcl_NewIntObj(halfSpace));
- } else {
- padding[0] = Tcl_NewIntObj(halfSpace);
- padding[1] = Tcl_NewIntObj(allSpace - halfSpace);
- Tcl_DictObjPut(NULL, bufferObj, Tcl_NewStringObj(switchName, -1),
- Tcl_NewListObj(2, padding));
- }
-}
-
-/*
- *------------------------------------------------------------------------
- *
- * Tk_PackCmd --
- *
- * This function is invoked to process the "pack" Tcl command. See the
- * user documentation for details on what it does.
- *
- * Results:
- * A standard Tcl result.
- *
- * Side effects:
- * See the user documentation.
- *
- *------------------------------------------------------------------------
- */
-
-int
-Tk_PackObjCmd(
- ClientData clientData, /* Main window associated with interpreter. */
- Tcl_Interp *interp, /* Current interpreter. */
- int objc, /* Number of arguments. */
- Tcl_Obj *const objv[]) /* Argument objects. */
-{
- Tk_Window tkwin = clientData;
- const char *argv2;
- static const char *const optionStrings[] = {
- /* after, append, before and unpack are deprecated */
- "after", "append", "before", "unpack",
- "configure", "forget", "info", "propagate", "slaves", NULL };
- enum options {
- PACK_AFTER, PACK_APPEND, PACK_BEFORE, PACK_UNPACK,
- PACK_CONFIGURE, PACK_FORGET, PACK_INFO, PACK_PROPAGATE, PACK_SLAVES };
- int index;
-
- if (objc >= 2) {
- const char *string = Tcl_GetString(objv[1]);
-
- if (string[0] == '.') {
- return ConfigureSlaves(interp, tkwin, objc-1, objv+1);
- }
- }
- if (objc < 3) {
- Tcl_WrongNumArgs(interp, 1, objv, "option arg ?arg ...?");
- return TCL_ERROR;
- }
-
- if (Tcl_GetIndexFromObjStruct(interp, objv[1], optionStrings,
- sizeof(char *), "option", 0, &index) != TCL_OK) {
- /*
- * Call it again without the deprecated ones to get a proper error
- * message. This works well since there can't be any ambiguity between
- * deprecated and new options.
- */
-
- Tcl_ResetResult(interp);
- Tcl_GetIndexFromObjStruct(interp, objv[1], &optionStrings[4],
- sizeof(char *), "option", 0, &index);
- return TCL_ERROR;
- }
-
- argv2 = Tcl_GetString(objv[2]);
- switch ((enum options) index) {
- case PACK_AFTER: {
- Packer *prevPtr;
- Tk_Window tkwin2;
-
- if (TkGetWindowFromObj(interp, tkwin, objv[2], &tkwin2) != TCL_OK) {
- return TCL_ERROR;
- }
- prevPtr = GetPacker(tkwin2);
- if (prevPtr->masterPtr == 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);
- }
- case PACK_APPEND: {
- Packer *masterPtr;
- register Packer *prevPtr;
- Tk_Window tkwin2;
-
- if (TkGetWindowFromObj(interp, tkwin, objv[2], &tkwin2) != TCL_OK) {
- return TCL_ERROR;
- }
- masterPtr = GetPacker(tkwin2);
- prevPtr = masterPtr->slavePtr;
- if (prevPtr != NULL) {
- while (prevPtr->nextPtr != NULL) {
- prevPtr = prevPtr->nextPtr;
- }
- }
- return PackAfter(interp, prevPtr, masterPtr, objc-3, objv+3);
- }
- case PACK_BEFORE: {
- Packer *packPtr, *masterPtr;
- register Packer *prevPtr;
- Tk_Window tkwin2;
-
- if (TkGetWindowFromObj(interp, tkwin, objv[2], &tkwin2) != TCL_OK) {
- return TCL_ERROR;
- }
- packPtr = GetPacker(tkwin2);
- if (packPtr->masterPtr == 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;
- if (prevPtr == packPtr) {
- prevPtr = NULL;
- } else {
- for ( ; ; prevPtr = prevPtr->nextPtr) {
- if (prevPtr == NULL) {
- Tcl_Panic("\"pack before\" couldn't find predecessor");
- }
- if (prevPtr->nextPtr == packPtr) {
- break;
- }
- }
- }
- return PackAfter(interp, prevPtr, masterPtr, objc-3, objv+3);
- }
- case PACK_CONFIGURE:
- if (argv2[0] != '.') {
- Tcl_SetObjResult(interp, Tcl_ObjPrintf(
- "bad argument \"%s\": must be name of window", argv2));
- Tcl_SetErrorCode(interp, "TK", "VALUE", "WINDOW_PATH", NULL);
- return TCL_ERROR;
- }
- return ConfigureSlaves(interp, tkwin, objc-2, objv+2);
- case PACK_FORGET: {
- Tk_Window slave;
- Packer *slavePtr;
- int i;
-
- for (i = 2; i < objc; i++) {
- if (TkGetWindowFromObj(interp, tkwin, objv[i], &slave) != TCL_OK) {
- continue;
- }
- slavePtr = GetPacker(slave);
- if ((slavePtr != NULL) && (slavePtr->masterPtr != NULL)) {
- Tk_ManageGeometry(slave, NULL, NULL);
- if (slavePtr->masterPtr->tkwin != Tk_Parent(slavePtr->tkwin)) {
- Tk_UnmaintainGeometry(slavePtr->tkwin,
- slavePtr->masterPtr->tkwin);
- }
- Unlink(slavePtr);
- Tk_UnmapWindow(slavePtr->tkwin);
- }
- }
- break;
- }
- case PACK_INFO: {
- register Packer *slavePtr;
- Tk_Window slave;
- Tcl_Obj *infoObj;
-
- if (objc != 3) {
- Tcl_WrongNumArgs(interp, 2, objv, "window");
- return TCL_ERROR;
- }
- if (TkGetWindowFromObj(interp, tkwin, objv[2], &slave) != TCL_OK) {
- return TCL_ERROR;
- }
- slavePtr = GetPacker(slave);
- if (slavePtr->masterPtr == NULL) {
- Tcl_SetObjResult(interp, Tcl_ObjPrintf(
- "window \"%s\" isn't packed", argv2));
- Tcl_SetErrorCode(interp, "TK", "PACK", "NOT_PACKED", NULL);
- return TCL_ERROR;
- }
-
- infoObj = Tcl_NewObj();
- Tcl_DictObjPut(NULL, infoObj, Tcl_NewStringObj("-in", -1),
- TkNewWindowObj(slavePtr->masterPtr->tkwin));
- Tcl_DictObjPut(NULL, infoObj, Tcl_NewStringObj("-anchor", -1),
- Tcl_NewStringObj(Tk_NameOfAnchor(slavePtr->anchor), -1));
- Tcl_DictObjPut(NULL, infoObj, Tcl_NewStringObj("-expand", -1),
- Tcl_NewBooleanObj(slavePtr->flags & EXPAND));
- switch (slavePtr->flags & (FILLX|FILLY)) {
- case 0:
- Tcl_DictObjPut(NULL, infoObj, Tcl_NewStringObj("-fill", -1),
- Tcl_NewStringObj("none", -1));
- break;
- case FILLX:
- Tcl_DictObjPut(NULL, infoObj, Tcl_NewStringObj("-fill", -1),
- Tcl_NewStringObj("x", -1));
- break;
- case FILLY:
- Tcl_DictObjPut(NULL, infoObj, Tcl_NewStringObj("-fill", -1),
- Tcl_NewStringObj("y", -1));
- break;
- case FILLX|FILLY:
- Tcl_DictObjPut(NULL, infoObj, Tcl_NewStringObj("-fill", -1),
- Tcl_NewStringObj("both", -1));
- break;
- }
- TkAppendPadAmount(infoObj, "-ipadx", slavePtr->iPadX/2, slavePtr->iPadX);
- TkAppendPadAmount(infoObj, "-ipady", slavePtr->iPadY/2, slavePtr->iPadY);
- TkAppendPadAmount(infoObj, "-padx", slavePtr->padLeft,slavePtr->padX);
- TkAppendPadAmount(infoObj, "-pady", slavePtr->padTop, slavePtr->padY);
- Tcl_DictObjPut(NULL, infoObj, Tcl_NewStringObj("-side", -1),
- Tcl_NewStringObj(sideNames[slavePtr->side], -1));
- Tcl_SetObjResult(interp, infoObj);
- break;
- }
- case PACK_PROPAGATE: {
- Tk_Window master;
- Packer *masterPtr;
- int propagate;
-
- if (objc > 4) {
- Tcl_WrongNumArgs(interp, 2, objv, "window ?boolean?");
- return TCL_ERROR;
- }
- if (TkGetWindowFromObj(interp, tkwin, objv[2], &master) != TCL_OK) {
- return TCL_ERROR;
- }
- masterPtr = GetPacker(master);
- if (objc == 3) {
- Tcl_SetObjResult(interp,
- Tcl_NewBooleanObj(!(masterPtr->flags & DONT_PROPAGATE)));
- return TCL_OK;
- }
- if (Tcl_GetBooleanFromObj(interp, objv[3], &propagate) != TCL_OK) {
- return TCL_ERROR;
- }
- if (propagate) {
- /*
- * If we have slaves, we need to register as geometry master.
- */
-
- if (masterPtr->slavePtr != NULL) {
- if (TkSetGeometryMaster(interp, master, "pack") != TCL_OK) {
- return TCL_ERROR;
- }
- masterPtr->flags |= ALLOCED_MASTER;
- }
- masterPtr->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 (!(masterPtr->flags & REQUESTED_REPACK)) {
- masterPtr->flags |= REQUESTED_REPACK;
- Tcl_DoWhenIdle(ArrangePacking, masterPtr);
- }
- } else {
- if (masterPtr->flags & ALLOCED_MASTER) {
- TkFreeGeometryMaster(master, "pack");
- masterPtr->flags &= ~ALLOCED_MASTER;
- }
- masterPtr->flags |= DONT_PROPAGATE;
- }
- break;
- }
- case PACK_SLAVES: {
- Tk_Window master;
- Packer *masterPtr, *slavePtr;
- Tcl_Obj *resultObj;
-
- if (objc != 3) {
- Tcl_WrongNumArgs(interp, 2, objv, "window");
- return TCL_ERROR;
- }
- if (TkGetWindowFromObj(interp, tkwin, objv[2], &master) != TCL_OK) {
- return TCL_ERROR;
- }
- resultObj = Tcl_NewObj();
- masterPtr = GetPacker(master);
- for (slavePtr = masterPtr->slavePtr; slavePtr != NULL;
- slavePtr = slavePtr->nextPtr) {
- Tcl_ListObjAppendElement(NULL, resultObj,
- TkNewWindowObj(slavePtr->tkwin));
- }
- Tcl_SetObjResult(interp, resultObj);
- break;
- }
- case PACK_UNPACK: {
- Tk_Window tkwin2;
- Packer *packPtr;
-
- if (objc != 3) {
- Tcl_WrongNumArgs(interp, 2, objv, "window");
- return TCL_ERROR;
- }
- if (TkGetWindowFromObj(interp, tkwin, objv[2], &tkwin2) != TCL_OK) {
- return TCL_ERROR;
- }
- packPtr = GetPacker(tkwin2);
- if ((packPtr != NULL) && (packPtr->masterPtr != NULL)) {
- Tk_ManageGeometry(tkwin2, NULL, NULL);
- if (packPtr->masterPtr->tkwin != Tk_Parent(packPtr->tkwin)) {
- Tk_UnmaintainGeometry(packPtr->tkwin,
- packPtr->masterPtr->tkwin);
- }
- Unlink(packPtr);
- Tk_UnmapWindow(packPtr->tkwin);
- }
- break;
- }
- }
-
- return TCL_OK;
-}
-
-/*
- *------------------------------------------------------------------------
- *
- * PackReqProc --
- *
- * This function is invoked by Tk_GeometryRequest for windows managed by
- * the packer.
- *
- * Results:
- * None.
- *
- * Side effects:
- * Arranges for tkwin, and all its managed siblings, to be re-packed at
- * the next idle point.
- *
- *------------------------------------------------------------------------
- */
-
- /* ARGSUSED */
-static void
-PackReqProc(
- ClientData clientData, /* Packer's information about window that got
- * new preferred geometry. */
- Tk_Window tkwin) /* Other Tk-related information about the
- * window. */
-{
- register Packer *packPtr = clientData;
-
- packPtr = packPtr->masterPtr;
- if (!(packPtr->flags & REQUESTED_REPACK)) {
- packPtr->flags |= REQUESTED_REPACK;
- Tcl_DoWhenIdle(ArrangePacking, packPtr);
- }
-}
-
-/*
- *------------------------------------------------------------------------
- *
- * PackLostSlaveProc --
- *
- * This function is invoked by Tk whenever some other geometry claims
- * control over a slave that used to be managed by us.
- *
- * Results:
- * None.
- *
- * Side effects:
- * Forgets all packer-related information about the slave.
- *
- *------------------------------------------------------------------------
- */
-
- /* ARGSUSED */
-static void
-PackLostSlaveProc(
- ClientData clientData, /* Packer structure for slave window that was
- * stolen away. */
- Tk_Window tkwin) /* Tk's handle for the slave window. */
-{
- register Packer *slavePtr = clientData;
-
- if (slavePtr->masterPtr->tkwin != Tk_Parent(slavePtr->tkwin)) {
- Tk_UnmaintainGeometry(slavePtr->tkwin, slavePtr->masterPtr->tkwin);
- }
- Unlink(slavePtr);
- Tk_UnmapWindow(slavePtr->tkwin);
-}
-
-/*
- *------------------------------------------------------------------------
- *
- * ArrangePacking --
- *
- * This function is invoked (using the Tcl_DoWhenIdle mechanism) to
- * re-layout a set of windows managed by the packer. It is invoked at
- * idle time so that a series of packer requests can be merged into a
- * single layout operation.
- *
- * Results:
- * None.
- *
- * Side effects:
- * The packed slaves of masterPtr may get resized or moved.
- *
- *------------------------------------------------------------------------
- */
-
-static void
-ArrangePacking(
- ClientData clientData) /* Structure describing master whose slaves
- * are to be re-layed out. */
-{
- register Packer *masterPtr = clientData;
- register Packer *slavePtr;
- int cavityX, cavityY, cavityWidth, cavityHeight;
- /* These variables keep track of the
- * as-yet-unallocated space remaining in the
- * middle of the master window. */
- int frameX, frameY, frameWidth, frameHeight;
- /* These variables keep track of the frame
- * allocated to the current window. */
- int x, y, width, height; /* These variables are used to hold the actual
- * geometry of the current window. */
- int abort; /* May get set to non-zero to abort this
- * repacking operation. */
- int borderX, borderY;
- int borderTop, borderBtm;
- int borderLeft, borderRight;
- int maxWidth, maxHeight, tmp;
-
- masterPtr->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) {
- return;
- }
-
- /*
- * Abort any nested call to ArrangePacking for this window, since we'll do
- * everything necessary here, and set up so this call can be aborted if
- * necessary.
- */
-
- if (masterPtr->abortPtr != NULL) {
- *masterPtr->abortPtr = 1;
- }
- masterPtr->abortPtr = &abort;
- abort = 0;
- Tcl_Preserve(masterPtr);
-
- /*
- * Pass #1: scan all the slaves to figure out the total amount of space
- * needed. Two separate width and height values are computed:
- *
- * width - Holds the sum of the widths (plus padding) of all the
- * slaves seen so far that were packed LEFT or RIGHT.
- * height - Holds the sum of the heights (plus padding) of all the
- * slaves seen so far that were packed TOP or BOTTOM.
- *
- * maxWidth - Gradually builds up the width needed by the master to
- * just barely satisfy all the slave's needs. For each
- * slave, the code computes the width needed for all the
- * slaves so far and updates maxWidth if the new value is
- * greater.
- * 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;
- slavePtr = slavePtr->nextPtr) {
- if ((slavePtr->side == TOP) || (slavePtr->side == BOTTOM)) {
- tmp = Tk_ReqWidth(slavePtr->tkwin) + slavePtr->doubleBw
- + slavePtr->padX + slavePtr->iPadX + width;
- if (tmp > maxWidth) {
- maxWidth = tmp;
- }
- height += Tk_ReqHeight(slavePtr->tkwin) + slavePtr->doubleBw
- + slavePtr->padY + slavePtr->iPadY;
- } else {
- tmp = Tk_ReqHeight(slavePtr->tkwin) + slavePtr->doubleBw
- + slavePtr->padY + slavePtr->iPadY + height;
- if (tmp > maxHeight) {
- maxHeight = tmp;
- }
- width += Tk_ReqWidth(slavePtr->tkwin) + slavePtr->doubleBw
- + slavePtr->padX + slavePtr->iPadX;
- }
- }
- if (width > maxWidth) {
- maxWidth = width;
- }
- if (height > maxHeight) {
- maxHeight = height;
- }
-
- if (maxWidth < Tk_MinReqWidth(masterPtr->tkwin)) {
- maxWidth = Tk_MinReqWidth(masterPtr->tkwin);
- }
- if (maxHeight < Tk_MinReqHeight(masterPtr->tkwin)) {
- maxHeight = Tk_MinReqHeight(masterPtr->tkwin);
- }
-
- /*
- * If the total amount of space needed in the master window has changed,
- * and if we're propagating geometry information, then notify the next
- * geometry manager up and requeue ourselves to start again after the
- * 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);
- goto done;
- }
-
- /*
- * Pass #2: scan the slaves a second time assigning new sizes. The
- * "cavity" variables keep track of the unclaimed space in the cavity of
- * the window; this shrinks inward as we allocate windows around the
- * edges. The "frame" variables keep track of the space allocated to the
- * current window and its frame. The current window is then placed
- * 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;
- slavePtr = slavePtr->nextPtr) {
- if ((slavePtr->side == TOP) || (slavePtr->side == BOTTOM)) {
- frameWidth = cavityWidth;
- frameHeight = Tk_ReqHeight(slavePtr->tkwin) + slavePtr->doubleBw
- + slavePtr->padY + slavePtr->iPadY;
- if (slavePtr->flags & EXPAND) {
- frameHeight += YExpansion(slavePtr, cavityHeight);
- }
- cavityHeight -= frameHeight;
- if (cavityHeight < 0) {
- frameHeight += cavityHeight;
- cavityHeight = 0;
- }
- frameX = cavityX;
- if (slavePtr->side == TOP) {
- frameY = cavityY;
- cavityY += frameHeight;
- } else {
- frameY = cavityY + cavityHeight;
- }
- } else {
- frameHeight = cavityHeight;
- frameWidth = Tk_ReqWidth(slavePtr->tkwin) + slavePtr->doubleBw
- + slavePtr->padX + slavePtr->iPadX;
- if (slavePtr->flags & EXPAND) {
- frameWidth += XExpansion(slavePtr, cavityWidth);
- }
- cavityWidth -= frameWidth;
- if (cavityWidth < 0) {
- frameWidth += cavityWidth;
- cavityWidth = 0;
- }
- frameY = cavityY;
- if (slavePtr->side == LEFT) {
- frameX = cavityX;
- cavityX += frameWidth;
- } else {
- frameX = cavityX + cavityWidth;
- }
- }
-
- /*
- * Now that we've got the size of the frame for the window, compute
- * the window's actual size and location using the fill, padding, and
- * frame factors. The variables "borderX" and "borderY" are used to
- * handle the differences between old-style packing and the new style
- * (in old-style, iPadX and iPadY are always zero and padding is
- * completely ignored except when computing frame size).
- */
-
- if (slavePtr->flags & OLD_STYLE) {
- borderX = borderY = 0;
- borderTop = borderBtm = 0;
- borderLeft = borderRight = 0;
- } else {
- borderX = slavePtr->padX;
- borderY = slavePtr->padY;
- borderLeft = slavePtr->padLeft;
- borderRight = borderX - borderLeft;
- borderTop = slavePtr->padTop;
- borderBtm = borderY - borderTop;
- }
- width = Tk_ReqWidth(slavePtr->tkwin) + slavePtr->doubleBw
- + slavePtr->iPadX;
- if ((slavePtr->flags & FILLX)
- || (width > (frameWidth - borderX))) {
- width = frameWidth - borderX;
- }
- height = Tk_ReqHeight(slavePtr->tkwin) + slavePtr->doubleBw
- + slavePtr->iPadY;
- if ((slavePtr->flags & FILLY)
- || (height > (frameHeight - borderY))) {
- height = frameHeight - borderY;
- }
- switch (slavePtr->anchor) {
- case TK_ANCHOR_N:
- x = frameX + (borderLeft + frameWidth - width - borderRight)/2;
- y = frameY + borderTop;
- break;
- case TK_ANCHOR_NE:
- x = frameX + frameWidth - width - borderRight;
- y = frameY + borderTop;
- break;
- case TK_ANCHOR_E:
- x = frameX + frameWidth - width - borderRight;
- y = frameY + (borderTop + frameHeight - height - borderBtm)/2;
- break;
- case TK_ANCHOR_SE:
- x = frameX + frameWidth - width - borderRight;
- y = frameY + frameHeight - height - borderBtm;
- break;
- case TK_ANCHOR_S:
- x = frameX + (borderLeft + frameWidth - width - borderRight)/2;
- y = frameY + frameHeight - height - borderBtm;
- break;
- case TK_ANCHOR_SW:
- x = frameX + borderLeft;
- y = frameY + frameHeight - height - borderBtm;
- break;
- case TK_ANCHOR_W:
- x = frameX + borderLeft;
- y = frameY + (borderTop + frameHeight - height - borderBtm)/2;
- break;
- case TK_ANCHOR_NW:
- x = frameX + borderLeft;
- y = frameY + borderTop;
- break;
- case TK_ANCHOR_CENTER:
- x = frameX + (borderLeft + frameWidth - width - borderRight)/2;
- y = frameY + (borderTop + frameHeight - height - borderBtm)/2;
- break;
- default:
- Tcl_Panic("bad frame factor in ArrangePacking");
- }
- width -= slavePtr->doubleBw;
- height -= slavePtr->doubleBw;
-
- /*
- * The final step is to set the position, size, and mapped/unmapped
- * state of the slave. If the slave is a child of the master, then do
- * this here. Otherwise let Tk_MaintainGeometry do the work.
- */
-
- if (masterPtr->tkwin == Tk_Parent(slavePtr->tkwin)) {
- if ((width <= 0) || (height <= 0)) {
- Tk_UnmapWindow(slavePtr->tkwin);
- } else {
- if ((x != Tk_X(slavePtr->tkwin))
- || (y != Tk_Y(slavePtr->tkwin))
- || (width != Tk_Width(slavePtr->tkwin))
- || (height != Tk_Height(slavePtr->tkwin))) {
- Tk_MoveResizeWindow(slavePtr->tkwin, x, y, width, height);
- }
- if (abort) {
- goto done;
- }
-
- /*
- * Don't map the slave if the master isn't mapped: wait until
- * the master gets mapped later.
- */
-
- if (Tk_IsMapped(masterPtr->tkwin)) {
- Tk_MapWindow(slavePtr->tkwin);
- }
- }
- } else {
- if ((width <= 0) || (height <= 0)) {
- Tk_UnmaintainGeometry(slavePtr->tkwin, masterPtr->tkwin);
- Tk_UnmapWindow(slavePtr->tkwin);
- } else {
- Tk_MaintainGeometry(slavePtr->tkwin, masterPtr->tkwin,
- x, y, width, height);
- }
- }
-
- /*
- * 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.
- */
-
- if (abort) {
- goto done;
- }
- }
-
- done:
- masterPtr->abortPtr = NULL;
- Tcl_Release(masterPtr);
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * XExpansion --
- *
- * Given a list of packed slaves, the first of which is packed on the
- * left or right and is expandable, compute how much to expand the child.
- *
- * Results:
- * The return value is the number of additional pixels to give to the
- * child.
- *
- * Side effects:
- * None.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-XExpansion(
- register Packer *slavePtr, /* First in list of remaining slaves. */
- int cavityWidth) /* Horizontal space left for all remaining
- * slaves. */
-{
- int numExpand, minExpand, curExpand;
- int childWidth;
-
- /*
- * This function is tricky because windows packed top or bottom can be
- * interspersed among expandable windows packed left or right. Scan
- * through the list, keeping a running sum of the widths of all left and
- * right windows (actually, count the cavity space not allocated) and a
- * running count of all expandable left and right windows. At each top or
- * bottom window, and at the end of the list, compute the expansion factor
- * that seems reasonable at that point. Return the smallest factor seen at
- * any of these points.
- */
-
- minExpand = cavityWidth;
- numExpand = 0;
- for ( ; slavePtr != NULL; slavePtr = slavePtr->nextPtr) {
- childWidth = Tk_ReqWidth(slavePtr->tkwin) + slavePtr->doubleBw
- + slavePtr->padX + slavePtr->iPadX;
- if ((slavePtr->side == TOP) || (slavePtr->side == BOTTOM)) {
- if (numExpand) {
- curExpand = (cavityWidth - childWidth)/numExpand;
- if (curExpand < minExpand) {
- minExpand = curExpand;
- }
- }
- } else {
- cavityWidth -= childWidth;
- if (slavePtr->flags & EXPAND) {
- numExpand++;
- }
- }
- }
- if (numExpand) {
- curExpand = cavityWidth/numExpand;
- if (curExpand < minExpand) {
- minExpand = curExpand;
- }
- }
- return (minExpand < 0) ? 0 : minExpand;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * YExpansion --
- *
- * Given a list of packed slaves, the first of which is packed on the top
- * or bottom and is expandable, compute how much to expand the child.
- *
- * Results:
- * The return value is the number of additional pixels to give to the
- * child.
- *
- * Side effects:
- * None.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-YExpansion(
- register Packer *slavePtr, /* First in list of remaining slaves. */
- int cavityHeight) /* Vertical space left for all remaining
- * slaves. */
-{
- int numExpand, minExpand, curExpand;
- int childHeight;
-
- /*
- * See comments for XExpansion.
- */
-
- minExpand = cavityHeight;
- numExpand = 0;
- for ( ; slavePtr != NULL; slavePtr = slavePtr->nextPtr) {
- childHeight = Tk_ReqHeight(slavePtr->tkwin) + slavePtr->doubleBw
- + slavePtr->padY + slavePtr->iPadY;
- if ((slavePtr->side == LEFT) || (slavePtr->side == RIGHT)) {
- if (numExpand) {
- curExpand = (cavityHeight - childHeight)/numExpand;
- if (curExpand < minExpand) {
- minExpand = curExpand;
- }
- }
- } else {
- cavityHeight -= childHeight;
- if (slavePtr->flags & EXPAND) {
- numExpand++;
- }
- }
- }
- if (numExpand) {
- curExpand = cavityHeight/numExpand;
- if (curExpand < minExpand) {
- minExpand = curExpand;
- }
- }
- return (minExpand < 0) ? 0 : minExpand;
-}
-
-/*
- *------------------------------------------------------------------------
- *
- * GetPacker --
- *
- * This internal function is used to locate a Packer structure for a
- * given window, creating one if one doesn't exist already.
- *
- * Results:
- * The return value is a pointer to the Packer structure corresponding to
- * tkwin.
- *
- * Side effects:
- * A new packer structure may be created. If so, then a callback is set
- * up to clean things up when the window is deleted.
- *
- *------------------------------------------------------------------------
- */
-
-static Packer *
-GetPacker(
- Tk_Window tkwin) /* Token for window for which packer structure
- * is desired. */
-{
- register Packer *packPtr;
- Tcl_HashEntry *hPtr;
- int isNew;
- TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr;
-
- if (!dispPtr->packInit) {
- dispPtr->packInit = 1;
- Tcl_InitHashTable(&dispPtr->packerHashTable, TCL_ONE_WORD_KEYS);
- }
-
- /*
- * See if there's already packer for this window. If not, then create a
- * new one.
- */
-
- hPtr = Tcl_CreateHashEntry(&dispPtr->packerHashTable, (char *) tkwin,
- &isNew);
- if (!isNew) {
- return Tcl_GetHashValue(hPtr);
- }
- packPtr = ckalloc(sizeof(Packer));
- packPtr->tkwin = tkwin;
- packPtr->masterPtr = NULL;
- packPtr->nextPtr = NULL;
- packPtr->slavePtr = NULL;
- packPtr->side = TOP;
- packPtr->anchor = TK_ANCHOR_CENTER;
- packPtr->padX = packPtr->padY = 0;
- packPtr->padLeft = packPtr->padTop = 0;
- packPtr->iPadX = packPtr->iPadY = 0;
- packPtr->doubleBw = 2*Tk_Changes(tkwin)->border_width;
- packPtr->abortPtr = NULL;
- packPtr->flags = 0;
- Tcl_SetHashValue(hPtr, packPtr);
- Tk_CreateEventHandler(tkwin, StructureNotifyMask,
- PackStructureProc, packPtr);
- return packPtr;
-}
-
-/*
- *------------------------------------------------------------------------
- *
- * PackAfter --
- *
- * This function does most of the real work of adding one or more windows
- * into the packing order for its master.
- *
- * Results:
- * A standard Tcl return value.
- *
- * Side effects:
- * The geometry of the specified windows may change, both now and again
- * in the future.
- *
- *------------------------------------------------------------------------
- */
-
-static int
-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. */
- 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
- * pack. */
-{
- register Packer *packPtr;
- Tk_Window tkwin, ancestor, parent;
- Tcl_Obj **options;
- int index, optionCount, c;
-
- /*
- * Iterate over all of the window specifiers, each consisting of two
- * arguments. The first argument contains the window name and the
- * additional arguments contain options such as "top" or "padx 20".
- */
-
- for ( ; objc > 0; objc -= 2, objv += 2, prevPtr = packPtr) {
- if (objc < 2) {
- Tcl_SetObjResult(interp, Tcl_ObjPrintf(
- "wrong # args: window \"%s\" should be followed by options",
- Tcl_GetString(objv[0])));
- Tcl_SetErrorCode(interp, "TCL", "WRONGARGS", NULL);
- return TCL_ERROR;
- }
-
- /*
- * Find the packer for the window to be packed, and make sure that the
- * window in which it will be packed is either its or a descendant of
- * its parent.
- */
-
- if (TkGetWindowFromObj(interp, masterPtr->tkwin, objv[0], &tkwin)
- != TCL_OK) {
- return TCL_ERROR;
- }
-
- parent = Tk_Parent(tkwin);
- for (ancestor = masterPtr->tkwin; ; ancestor = Tk_Parent(ancestor)) {
- if (ancestor == parent) {
- break;
- }
- if (((Tk_FakeWin *) (ancestor))->flags & TK_TOP_HIERARCHY) {
- badWindow:
- Tcl_SetObjResult(interp, Tcl_ObjPrintf(
- "can't pack %s inside %s", Tcl_GetString(objv[0]),
- Tk_PathName(masterPtr->tkwin)));
- Tcl_SetErrorCode(interp, "TK", "GEOMETRY", "HIERARCHY", NULL);
- return TCL_ERROR;
- }
- }
- if (((Tk_FakeWin *) (tkwin))->flags & TK_TOP_HIERARCHY) {
- goto badWindow;
- }
- if (tkwin == masterPtr->tkwin) {
- goto badWindow;
- }
- packPtr = GetPacker(tkwin);
-
- /*
- * Process options for this window.
- */
-
- if (Tcl_ListObjGetElements(interp, objv[1], &optionCount, &options)
- != TCL_OK) {
- return TCL_ERROR;
- }
- packPtr->side = TOP;
- packPtr->anchor = TK_ANCHOR_CENTER;
- packPtr->padX = packPtr->padY = 0;
- packPtr->padLeft = packPtr->padTop = 0;
- packPtr->iPadX = packPtr->iPadY = 0;
- packPtr->flags &= ~(FILLX|FILLY|EXPAND);
- packPtr->flags |= OLD_STYLE;
- for (index = 0 ; index < optionCount; index++) {
- Tcl_Obj *curOptPtr = options[index];
- const char *curOpt = Tcl_GetString(curOptPtr);
- size_t length = curOptPtr->length;
-
- c = curOpt[0];
-
- if ((c == 't')
- && (strncmp(curOpt, "top", length)) == 0) {
- packPtr->side = TOP;
- } else if ((c == 'b')
- && (strncmp(curOpt, "bottom", length)) == 0) {
- packPtr->side = BOTTOM;
- } else if ((c == 'l')
- && (strncmp(curOpt, "left", length)) == 0) {
- packPtr->side = LEFT;
- } else if ((c == 'r')
- && (strncmp(curOpt, "right", length)) == 0) {
- packPtr->side = RIGHT;
- } else if ((c == 'e')
- && (strncmp(curOpt, "expand", length)) == 0) {
- packPtr->flags |= EXPAND;
- } else if ((c == 'f')
- && (strcmp(curOpt, "fill")) == 0) {
- packPtr->flags |= FILLX|FILLY;
- } else if ((length == 5) && (strcmp(curOpt, "fillx")) == 0) {
- packPtr->flags |= FILLX;
- } else if ((length == 5) && (strcmp(curOpt, "filly")) == 0) {
- packPtr->flags |= FILLY;
- } else if ((c == 'p') && (strcmp(curOpt, "padx")) == 0) {
- if (optionCount < (index+2)) {
- missingPad:
- Tcl_SetObjResult(interp, Tcl_ObjPrintf(
- "wrong # args: \"%s\" option must be"
- " followed by screen distance", curOpt));
- Tcl_SetErrorCode(interp, "TK", "OLDPACK", "BAD_PARAMETER",
- NULL);
- return TCL_ERROR;
- }
- if (TkParsePadAmount(interp, tkwin, options[index+1],
- &packPtr->padLeft, &packPtr->padX) != TCL_OK) {
- return TCL_ERROR;
- }
- packPtr->padX /= 2;
- packPtr->padLeft /= 2;
- packPtr->iPadX = 0;
- index++;
- } else if ((c == 'p') && (strcmp(curOpt, "pady")) == 0) {
- if (optionCount < (index+2)) {
- goto missingPad;
- }
- if (TkParsePadAmount(interp, tkwin, options[index+1],
- &packPtr->padTop, &packPtr->padY) != TCL_OK) {
- return TCL_ERROR;
- }
- packPtr->padY /= 2;
- packPtr->padTop /= 2;
- packPtr->iPadY = 0;
- index++;
- } else if ((c == 'f') && (length > 1)
- && (strncmp(curOpt, "frame", (size_t) length) == 0)) {
- if (optionCount < (index+2)) {
- Tcl_SetObjResult(interp, Tcl_NewStringObj(
- "wrong # args: \"frame\""
- " option must be followed by anchor point", -1));
- Tcl_SetErrorCode(interp, "TK", "OLDPACK", "BAD_PARAMETER",
- NULL);
- return TCL_ERROR;
- }
- if (Tk_GetAnchorFromObj(interp, options[index+1],
- &packPtr->anchor) != TCL_OK) {
- return TCL_ERROR;
- }
- index++;
- } else {
- Tcl_SetObjResult(interp, Tcl_ObjPrintf(
- "bad option \"%s\": should be top, bottom, left,"
- " right, expand, fill, fillx, filly, padx, pady, or"
- " frame", curOpt));
- Tcl_SetErrorCode(interp, "TK", "OLDPACK", "BAD_PARAMETER",
- NULL);
- return TCL_ERROR;
- }
- }
-
- if (packPtr != prevPtr) {
- /*
- * Unpack this window if it's currently packed.
- */
-
- if (packPtr->masterPtr != NULL) {
- if ((packPtr->masterPtr != masterPtr) &&
- (packPtr->masterPtr->tkwin
- != Tk_Parent(packPtr->tkwin))) {
- Tk_UnmaintainGeometry(packPtr->tkwin,
- packPtr->masterPtr->tkwin);
- }
- Unlink(packPtr);
- }
-
- /*
- * Add the window in the correct place in its master's packing
- * order, then make sure that the window is managed by us.
- */
-
- packPtr->masterPtr = masterPtr;
- if (prevPtr == NULL) {
- packPtr->nextPtr = masterPtr->slavePtr;
- masterPtr->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")
- != TCL_OK) {
- Tk_ManageGeometry(tkwin, NULL, NULL);
- Unlink(packPtr);
- return TCL_ERROR;
- }
- masterPtr->flags |= ALLOCED_MASTER;
- }
- }
- }
-
- /*
- * Arrange for the master to be re-packed at the first idle moment.
- */
-
- if (masterPtr->abortPtr != NULL) {
- *masterPtr->abortPtr = 1;
- }
- if (!(masterPtr->flags & REQUESTED_REPACK)) {
- masterPtr->flags |= REQUESTED_REPACK;
- Tcl_DoWhenIdle(ArrangePacking, masterPtr);
- }
- return TCL_OK;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * Unlink --
- *
- * Remove a packer from its master's list of slaves.
- *
- * Results:
- * None.
- *
- * Side effects:
- * The master will be scheduled for repacking.
- *
- *----------------------------------------------------------------------
- */
-
-static void
-Unlink(
- register Packer *packPtr) /* Window to unlink. */
-{
- register Packer *masterPtr, *packPtr2;
-
- masterPtr = packPtr->masterPtr;
- if (masterPtr == NULL) {
- return;
- }
- if (masterPtr->slavePtr == packPtr) {
- masterPtr->slavePtr = packPtr->nextPtr;
- } else {
- for (packPtr2 = masterPtr->slavePtr; ; packPtr2 = packPtr2->nextPtr) {
- if (packPtr2 == NULL) {
- Tcl_Panic("Unlink couldn't find previous window");
- }
- if (packPtr2->nextPtr == packPtr) {
- packPtr2->nextPtr = packPtr->nextPtr;
- break;
- }
- }
- }
- if (!(masterPtr->flags & REQUESTED_REPACK)) {
- masterPtr->flags |= REQUESTED_REPACK;
- Tcl_DoWhenIdle(ArrangePacking, masterPtr);
- }
- if (masterPtr->abortPtr != NULL) {
- *masterPtr->abortPtr = 1;
- }
-
- packPtr->masterPtr = 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;
- }
-
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * DestroyPacker --
- *
- * This function is invoked by Tcl_EventuallyFree or Tcl_Release to clean
- * up the internal structure of a packer at a safe time (when no-one is
- * using it anymore).
- *
- * Results:
- * None.
- *
- * Side effects:
- * Everything associated with the packer is freed up.
- *
- *----------------------------------------------------------------------
- */
-
-static void
-DestroyPacker(
- void *memPtr) /* Info about packed window that is now
- * dead. */
-{
- register Packer *packPtr = memPtr;
-
- ckfree(packPtr);
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * PackStructureProc --
- *
- * This function is invoked by the Tk event dispatcher in response to
- * StructureNotify events.
- *
- * Results:
- * None.
- *
- * Side effects:
- * If a window was just deleted, clean up all its packer-related
- * information. If it was just resized, repack its slaves, if any.
- *
- *----------------------------------------------------------------------
- */
-
-static void
-PackStructureProc(
- ClientData clientData, /* Our information about window referred to by
- * eventPtr. */
- XEvent *eventPtr) /* Describes what just happened. */
-{
- register Packer *packPtr = clientData;
-
- if (eventPtr->type == ConfigureNotify) {
- if ((packPtr->slavePtr != NULL)
- && !(packPtr->flags & REQUESTED_REPACK)) {
- packPtr->flags |= REQUESTED_REPACK;
- Tcl_DoWhenIdle(ArrangePacking, packPtr);
- }
- if ((packPtr->masterPtr != NULL)
- && (packPtr->doubleBw != 2*Tk_Changes(packPtr->tkwin)->border_width)) {
- if (!(packPtr->masterPtr->flags & REQUESTED_REPACK)) {
- packPtr->doubleBw = 2*Tk_Changes(packPtr->tkwin)->border_width;
- packPtr->masterPtr->flags |= REQUESTED_REPACK;
- Tcl_DoWhenIdle(ArrangePacking, packPtr->masterPtr);
- }
- }
- } else if (eventPtr->type == DestroyNotify) {
- register Packer *slavePtr, *nextPtr;
-
- if (packPtr->masterPtr != NULL) {
- Unlink(packPtr);
- }
-
- for (slavePtr = packPtr->slavePtr; slavePtr != NULL;
- slavePtr = nextPtr) {
- Tk_ManageGeometry(slavePtr->tkwin, NULL, NULL);
- Tk_UnmapWindow(slavePtr->tkwin);
- slavePtr->masterPtr = NULL;
- nextPtr = slavePtr->nextPtr;
- slavePtr->nextPtr = NULL;
- }
-
- if (packPtr->tkwin != NULL) {
- TkDisplay *dispPtr = ((TkWindow *) packPtr->tkwin)->dispPtr;
- Tcl_DeleteHashEntry(Tcl_FindHashEntry(&dispPtr->packerHashTable,
- (char *) packPtr->tkwin));
- }
-
- if (packPtr->flags & REQUESTED_REPACK) {
- Tcl_CancelIdleCall(ArrangePacking, packPtr);
- }
- packPtr->tkwin = NULL;
- Tcl_EventuallyFree(packPtr, (Tcl_FreeProc *) DestroyPacker);
- } else if (eventPtr->type == MapNotify) {
- /*
- * When a master gets mapped, must redo the geometry computation so
- * that all of its slaves get remapped.
- */
-
- if ((packPtr->slavePtr != NULL)
- && !(packPtr->flags & REQUESTED_REPACK)) {
- packPtr->flags |= REQUESTED_REPACK;
- Tcl_DoWhenIdle(ArrangePacking, packPtr);
- }
- } else if (eventPtr->type == UnmapNotify) {
- register Packer *packPtr2;
-
- /*
- * Unmap all of the slaves when the master gets unmapped, so that they
- * don't bother to keep redisplaying themselves.
- */
-
- for (packPtr2 = packPtr->slavePtr; packPtr2 != NULL;
- packPtr2 = packPtr2->nextPtr) {
- Tk_UnmapWindow(packPtr2->tkwin);
- }
- }
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * ConfigureSlaves --
- *
- * This implements the guts of the "pack configure" command. Given a list
- * of slaves and configuration options, it arranges for the packer to
- * manage the slaves and sets the specified options.
- *
- * Results:
- * TCL_OK is returned if all went well. Otherwise, TCL_ERROR is returned
- * and the interp's result is set to contain an error message.
- *
- * Side effects:
- * Slave windows get taken over by the packer.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-ConfigureSlaves(
- Tcl_Interp *interp, /* Interpreter for error reporting. */
- Tk_Window tkwin, /* Any window in application containing
- * slaves. Used to look up slave names. */
- int objc, /* Number of elements in argv. */
- Tcl_Obj *const objv[]) /* Argument objects: contains one or more
- * window names followed by any number of
- * "option value" pairs. Caller must make sure
- * that there is at least one window name. */
-{
- Packer *masterPtr, *slavePtr, *prevPtr, *otherPtr;
- Tk_Window other, slave, parent, ancestor;
- int i, j, numWindows, tmp, positionGiven;
- const char *string;
- static const char *const optionStrings[] = {
- "-after", "-anchor", "-before", "-expand", "-fill",
- "-in", "-ipadx", "-ipady", "-padx", "-pady", "-side", NULL };
- enum options {
- CONF_AFTER, CONF_ANCHOR, CONF_BEFORE, CONF_EXPAND, CONF_FILL,
- CONF_IN, CONF_IPADX, CONF_IPADY, CONF_PADX, CONF_PADY, CONF_SIDE };
- int index, side;
-
- /*
- * Find out how many windows are specified.
- */
-
- for (numWindows = 0; numWindows < objc; numWindows++) {
- string = Tcl_GetString(objv[numWindows]);
- if (string[0] != '.') {
- break;
- }
- }
-
- /*
- * Iterate over all of the slave windows, parsing the configuration
- * options for each slave. It's a bit wasteful to re-parse the options for
- * each slave, but things get too messy if we try to parse the arguments
- * just once at the beginning. For example, if a slave already is packed
- * we want to just change a few existing values without resetting
- * everything. If there are multiple windows, the -after, -before, and -in
- * options only get processed for the first window.
- */
-
- masterPtr = NULL;
- prevPtr = NULL;
- positionGiven = 0;
- for (j = 0; j < numWindows; j++) {
- if (TkGetWindowFromObj(interp, tkwin, objv[j], &slave) != TCL_OK) {
- return TCL_ERROR;
- }
- if (Tk_TopWinHierarchy(slave)) {
- Tcl_SetObjResult(interp, Tcl_ObjPrintf(
- "can't pack \"%s\": it's a top-level window",
- Tcl_GetString(objv[j])));
- Tcl_SetErrorCode(interp, "TK", "GEOMETRY", "TOPLEVEL", NULL);
- return TCL_ERROR;
- }
- slavePtr = GetPacker(slave);
- slavePtr->flags &= ~OLD_STYLE;
-
- /*
- * If the slave isn't currently packed, reset all of its configuration
- * information to default values (there could be old values left from
- * a previous packing).
- */
-
- if (slavePtr->masterPtr == NULL) {
- slavePtr->side = TOP;
- slavePtr->anchor = TK_ANCHOR_CENTER;
- slavePtr->padX = slavePtr->padY = 0;
- slavePtr->padLeft = slavePtr->padTop = 0;
- slavePtr->iPadX = slavePtr->iPadY = 0;
- slavePtr->flags &= ~(FILLX|FILLY|EXPAND);
- }
-
- for (i = numWindows; i < objc; i+=2) {
- if ((i+2) > objc) {
- Tcl_SetObjResult(interp, Tcl_ObjPrintf(
- "extra option \"%s\" (option with no value?)",
- Tcl_GetString(objv[i])));
- Tcl_SetErrorCode(interp, "TK", "PACK", "BAD_PARAMETER", NULL);
- return TCL_ERROR;
- }
- if (Tcl_GetIndexFromObjStruct(interp, objv[i], optionStrings,
- sizeof(char *), "option", 0, &index) != TCL_OK) {
- return TCL_ERROR;
- }
-
- switch ((enum options) index) {
- case CONF_AFTER:
- if (j == 0) {
- if (TkGetWindowFromObj(interp, tkwin, objv[i+1], &other)
- != TCL_OK) {
- return TCL_ERROR;
- }
- prevPtr = GetPacker(other);
- if (prevPtr->masterPtr == NULL) {
- notPacked:
- Tcl_SetObjResult(interp, Tcl_ObjPrintf(
- "window \"%s\" isn't packed",
- Tcl_GetString(objv[i+1])));
- Tcl_SetErrorCode(interp, "TK", "PACK", "NOT_PACKED",
- NULL);
- return TCL_ERROR;
- }
- masterPtr = prevPtr->masterPtr;
- positionGiven = 1;
- }
- break;
- case CONF_ANCHOR:
- if (Tk_GetAnchorFromObj(interp, objv[i+1], &slavePtr->anchor)
- != TCL_OK) {
- return TCL_ERROR;
- }
- break;
- case CONF_BEFORE:
- if (j == 0) {
- if (TkGetWindowFromObj(interp, tkwin, objv[i+1], &other)
- != TCL_OK) {
- return TCL_ERROR;
- }
- otherPtr = GetPacker(other);
- if (otherPtr->masterPtr == NULL) {
- goto notPacked;
- }
- masterPtr = otherPtr->masterPtr;
- prevPtr = masterPtr->slavePtr;
- if (prevPtr == otherPtr) {
- prevPtr = NULL;
- } else {
- while (prevPtr->nextPtr != otherPtr) {
- prevPtr = prevPtr->nextPtr;
- }
- }
- positionGiven = 1;
- }
- break;
- case CONF_EXPAND:
- if (Tcl_GetBooleanFromObj(interp, objv[i+1], &tmp) != TCL_OK) {
- return TCL_ERROR;
- }
- slavePtr->flags &= ~EXPAND;
- if (tmp) {
- slavePtr->flags |= EXPAND;
- }
- break;
- case CONF_FILL:
- string = Tcl_GetString(objv[i+1]);
- if (strcmp(string, "none") == 0) {
- slavePtr->flags &= ~(FILLX|FILLY);
- } else if (strcmp(string, "x") == 0) {
- slavePtr->flags = (slavePtr->flags & ~FILLY) | FILLX;
- } else if (strcmp(string, "y") == 0) {
- slavePtr->flags = (slavePtr->flags & ~FILLX) | FILLY;
- } else if (strcmp(string, "both") == 0) {
- slavePtr->flags |= FILLX|FILLY;
- } else {
- Tcl_SetObjResult(interp, Tcl_ObjPrintf(
- "bad fill style \"%s\": must be "
- "none, x, y, or both", string));
- Tcl_SetErrorCode(interp, "TK", "VALUE", "FILL", NULL);
- return TCL_ERROR;
- }
- break;
- case CONF_IN:
- if (j == 0) {
- if (TkGetWindowFromObj(interp, tkwin, objv[i+1], &other)
- != TCL_OK) {
- return TCL_ERROR;
- }
- masterPtr = GetPacker(other);
- prevPtr = masterPtr->slavePtr;
- if (prevPtr != NULL) {
- while (prevPtr->nextPtr != NULL) {
- prevPtr = prevPtr->nextPtr;
- }
- }
- positionGiven = 1;
- }
- break;
- case CONF_IPADX:
- if ((Tk_GetPixelsFromObj(interp, slave, objv[i+1], &tmp)
- != TCL_OK) || (tmp < 0)) {
- Tcl_SetObjResult(interp, Tcl_ObjPrintf(
- "bad ipadx value \"%s\": must be positive screen"
- " distance", Tcl_GetString(objv[i+1])));
- Tcl_SetErrorCode(interp, "TK", "VALUE", "INT_PAD", NULL);
- return TCL_ERROR;
- }
- slavePtr->iPadX = tmp * 2;
- break;
- case CONF_IPADY:
- if ((Tk_GetPixelsFromObj(interp, slave, objv[i+1], &tmp)
- != TCL_OK) || (tmp < 0)) {
- Tcl_SetObjResult(interp, Tcl_ObjPrintf(
- "bad ipady value \"%s\": must be positive screen"
- " distance", Tcl_GetString(objv[i+1])));
- Tcl_SetErrorCode(interp, "TK", "VALUE", "INT_PAD", NULL);
- return TCL_ERROR;
- }
- slavePtr->iPadY = tmp * 2;
- break;
- case CONF_PADX:
- if (TkParsePadAmount(interp, slave, objv[i+1],
- &slavePtr->padLeft, &slavePtr->padX) != TCL_OK) {
- return TCL_ERROR;
- }
- break;
- case CONF_PADY:
- if (TkParsePadAmount(interp, slave, objv[i+1],
- &slavePtr->padTop, &slavePtr->padY) != TCL_OK) {
- return TCL_ERROR;
- }
- break;
- case CONF_SIDE:
- if (Tcl_GetIndexFromObjStruct(interp, objv[i+1], sideNames,
- sizeof(char *), "side", TCL_EXACT, &side) != TCL_OK) {
- return TCL_ERROR;
- }
- slavePtr->side = (Side) side;
- break;
- }
- }
-
- /*
- * If no position in a packing list was specified and the slave is
- * already packed, then leave it in its current location in its
- * current packing list.
- */
-
- if (!positionGiven && (slavePtr->masterPtr != NULL)) {
- masterPtr = slavePtr->masterPtr;
- goto scheduleLayout;
- }
-
- /*
- * If the slave is going to be put back after itself or the same -in
- * window is passed in again, then just skip the whole operation,
- * since it won't work anyway.
- */
-
- if (prevPtr == slavePtr) {
- masterPtr = slavePtr->masterPtr;
- goto scheduleLayout;
- }
-
- /*
- * If none of the "-in", "-before", or "-after" options has been
- * specified, arrange for the slave to go at the end of the order for
- * its parent.
- */
-
- if (!positionGiven) {
- masterPtr = GetPacker(Tk_Parent(slave));
- prevPtr = masterPtr->slavePtr;
- if (prevPtr != NULL) {
- while (prevPtr->nextPtr != NULL) {
- prevPtr = prevPtr->nextPtr;
- }
- }
- }
-
- /*
- * 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
- * same.
- */
-
- parent = Tk_Parent(slave);
- for (ancestor = masterPtr->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)));
- Tcl_SetErrorCode(interp, "TK", "GEOMETRY", "HIERARCHY", NULL);
- return TCL_ERROR;
- }
- }
- if (slave == masterPtr->tkwin) {
- Tcl_SetObjResult(interp, Tcl_ObjPrintf(
- "can't pack %s inside itself", Tcl_GetString(objv[j])));
- Tcl_SetErrorCode(interp, "TK", "GEOMETRY", "SELF", NULL);
- return TCL_ERROR;
- }
-
- /*
- * Unpack the slave if it's currently packed, then position it after
- * prevPtr.
- */
-
- if (slavePtr->masterPtr != NULL) {
- if ((slavePtr->masterPtr != masterPtr) &&
- (slavePtr->masterPtr->tkwin
- != Tk_Parent(slavePtr->tkwin))) {
- Tk_UnmaintainGeometry(slavePtr->tkwin,
- slavePtr->masterPtr->tkwin);
- }
- Unlink(slavePtr);
- }
-
- slavePtr->masterPtr = masterPtr;
- if (prevPtr == NULL) {
- slavePtr->nextPtr = masterPtr->slavePtr;
- masterPtr->slavePtr = slavePtr;
- } else {
- slavePtr->nextPtr = prevPtr->nextPtr;
- prevPtr->nextPtr = slavePtr;
- }
- Tk_ManageGeometry(slave, &packerType, slavePtr);
- prevPtr = slavePtr;
-
- if (!(masterPtr->flags & DONT_PROPAGATE)) {
- if (TkSetGeometryMaster(interp, masterPtr->tkwin, "pack")
- != TCL_OK) {
- Tk_ManageGeometry(slave, NULL, NULL);
- Unlink(slavePtr);
- return TCL_ERROR;
- }
- masterPtr->flags |= ALLOCED_MASTER;
- }
-
- /*
- * Arrange for the master to be re-packed at the first idle moment.
- */
-
- scheduleLayout:
- if (masterPtr->abortPtr != NULL) {
- *masterPtr->abortPtr = 1;
- }
- if (!(masterPtr->flags & REQUESTED_REPACK)) {
- masterPtr->flags |= REQUESTED_REPACK;
- Tcl_DoWhenIdle(ArrangePacking, masterPtr);
- }
- }
- return TCL_OK;
-}
-
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 4
- * fill-column: 78
- * End:
- */