shared_source/c_tk_base_7_5_w_mods/tkpack.c

/* $Header$ */

/* 
 * 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.
 *
 * RCS: @(#) $Id: tkpack.c,v 1.1.1.1 2001/06/13 05:06:57 dtashley Exp $
 */

#include "tkPort.h"
#include "tkInt.h"

typedef enum {TOP, BOTTOM, LEFT, RIGHT} Side;

/* 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 /* Green Bay */ 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
                                 * parent.  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 parent 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 (half of this space is left on each
                                 * side).  This is space *outside* the window:
                                 * we'll allocate extra space in frame but
                                 * won't enlarge window). */
    int iPadX, iPadY;           /* Total extra pixels to allocate inside the
                                 * window (half 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 parent. */
    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 parent 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.
 */

#define REQUESTED_REPACK        1
#define FILLX                   2
#define FILLY                   4
#define EXPAND                  8
#define OLD_STYLE               16
#define DONT_PROPAGATE          32

/*
 * The following structure is the official type record for the
 * packer:
 */

static void             PackReqProc _ANSI_ARGS_((ClientData clientData,
                            Tk_Window tkwin));
static void             PackLostSlaveProc _ANSI_ARGS_((ClientData clientData,
                            Tk_Window tkwin));

static Tk_GeomMgr packerType = {
    "pack",                     /* name */
    PackReqProc,                /* requestProc */
    PackLostSlaveProc,          /* lostSlaveProc */
};

/*
 * Forward declarations for procedures defined later in this file:
 */

static void             ArrangePacking _ANSI_ARGS_((ClientData clientData));
static int              ConfigureSlaves _ANSI_ARGS_((Tcl_Interp *interp,
                            Tk_Window tkwin, int argc, char *argv[]));
static void             DestroyPacker _ANSI_ARGS_((char *memPtr));
static Packer *         GetPacker _ANSI_ARGS_((Tk_Window tkwin));
static int              PackAfter _ANSI_ARGS_((Tcl_Interp *interp,
                            Packer *prevPtr, Packer *masterPtr, int argc,
                            char **argv));
static void             PackReqProc _ANSI_ARGS_((ClientData clientData,
                            Tk_Window tkwin));
static void             PackStructureProc _ANSI_ARGS_((ClientData clientData,
                            XEvent *eventPtr));
static void             Unlink _ANSI_ARGS_((Packer *packPtr));
static int              XExpansion _ANSI_ARGS_((Packer *slavePtr,
                            int cavityWidth));
static int              YExpansion _ANSI_ARGS_((Packer *slavePtr,
                            int cavityHeight));

/*
 *--------------------------------------------------------------
 *
 * Tk_PackCmd --
 *
 *      This procedure 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_PackCmd(clientData, interp, argc, argv)
    ClientData clientData;      /* Main window associated with
                                 * interpreter. */
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings. */
{
    Tk_Window tkwin = (Tk_Window) clientData;
    size_t length;
    int c;

    if ((argc >= 2) && (argv[1][0] == '.')) {
        return ConfigureSlaves(interp, tkwin, argc-1, argv+1);
    }
    if (argc < 3) {
        Tcl_AppendResult(interp, "wrong # args: should be \"",
                argv[0], " option arg ?arg ...?\"", (char *) NULL);
        return TCL_ERROR;
    }
    c = argv[1][0];
    length = strlen(argv[1]);
    if ((c == 'a') && (length >= 2)
            && (strncmp(argv[1], "after", length) == 0)) {
        Packer *prevPtr;
        Tk_Window tkwin2;

        tkwin2 = Tk_NameToWindow(interp, argv[2], tkwin);
        if (tkwin2 == NULL) {
            return TCL_ERROR;
        }
        prevPtr = GetPacker(tkwin2);
        if (prevPtr->masterPtr == NULL) {
            Tcl_AppendResult(interp, "window \"", argv[2],
                    "\" isn't packed", (char *) NULL);
            return TCL_ERROR;
        }
        return PackAfter(interp, prevPtr, prevPtr->masterPtr, argc-3, argv+3);
    } else if ((c == 'a') && (length >= 2)
            && (strncmp(argv[1], "append", length) == 0)) {
        Packer *masterPtr;
        register Packer *prevPtr;
        Tk_Window tkwin2;

        tkwin2 = Tk_NameToWindow(interp, argv[2], tkwin);
        if (tkwin2 == NULL) {
            return TCL_ERROR;
        }
        masterPtr = GetPacker(tkwin2);
        prevPtr = masterPtr->slavePtr;
        if (prevPtr != NULL) {
            while (prevPtr->nextPtr != NULL) {
                prevPtr = prevPtr->nextPtr;
            }
        }
        return PackAfter(interp, prevPtr, masterPtr, argc-3, argv+3);
    } else if ((c == 'b') && (strncmp(argv[1], "before", length) == 0)) {
        Packer *packPtr, *masterPtr;
        register Packer *prevPtr;
        Tk_Window tkwin2;

        tkwin2 = Tk_NameToWindow(interp, argv[2], tkwin);
        if (tkwin2 == NULL) {
            return TCL_ERROR;
        }
        packPtr = GetPacker(tkwin2);
        if (packPtr->masterPtr == NULL) {
            Tcl_AppendResult(interp, "window \"", argv[2],
                    "\" isn't packed", (char *) NULL);
            return TCL_ERROR;
        }
        masterPtr = packPtr->masterPtr;
        prevPtr = masterPtr->slavePtr;
        if (prevPtr == packPtr) {
            prevPtr = NULL;
        } else {
            for ( ; ; prevPtr = prevPtr->nextPtr) {
                if (prevPtr == NULL) {
                    panic("\"pack before\" couldn't find predecessor");
                }
                if (prevPtr->nextPtr == packPtr) {
                    break;
                }
            }
        }
        return PackAfter(interp, prevPtr, masterPtr, argc-3, argv+3);
    } else if ((c == 'c') && (strncmp(argv[1], "configure", length) == 0)) {
        if (argv[2][0] != '.') {
            Tcl_AppendResult(interp, "bad argument \"", argv[2],
                    "\": must be name of window", (char *) NULL);
            return TCL_ERROR;
        }
        return ConfigureSlaves(interp, tkwin, argc-2, argv+2);
    } else if ((c == 'f') && (strncmp(argv[1], "forget", length) == 0)) {
        Tk_Window slave;
        Packer *slavePtr;
        int i;

        for (i = 2; i < argc; i++) {
            slave = Tk_NameToWindow(interp, argv[i], tkwin);
            if (slave == NULL) {
                continue;
            }
            slavePtr = GetPacker(slave);
            if ((slavePtr != NULL) && (slavePtr->masterPtr != NULL)) {
                Tk_ManageGeometry(slave, (Tk_GeomMgr *) NULL,
                        (ClientData) NULL);
                if (slavePtr->masterPtr->tkwin != Tk_Parent(slavePtr->tkwin)) {
                    Tk_UnmaintainGeometry(slavePtr->tkwin,
                            slavePtr->masterPtr->tkwin);
                }
                Unlink(slavePtr);
                Tk_UnmapWindow(slavePtr->tkwin);
            }
        }
    } else if ((c == 'i') && (strncmp(argv[1], "info", length) == 0)) {
        register Packer *slavePtr;
        Tk_Window slave;
        char buffer[64 + TCL_INTEGER_SPACE * 4];
        static char *sideNames[] = {"top", "bottom", "left", "right"};

        if (argc != 3) {
            Tcl_AppendResult(interp, "wrong # args: should be \"",
                    argv[0], " info window\"", (char *) NULL);
            return TCL_ERROR;
        }
        slave = Tk_NameToWindow(interp, argv[2], tkwin);
        if (slave == NULL) {
            return TCL_ERROR;
        }
        slavePtr = GetPacker(slave);
        if (slavePtr->masterPtr == NULL) {
            Tcl_AppendResult(interp, "window \"", argv[2],
                    "\" isn't packed", (char *) NULL);
            return TCL_ERROR;
        }
        Tcl_AppendElement(interp, "-in");
        Tcl_AppendElement(interp, Tk_PathName(slavePtr->masterPtr->tkwin));
        Tcl_AppendElement(interp, "-anchor");
        Tcl_AppendElement(interp, Tk_NameOfAnchor(slavePtr->anchor));
        Tcl_AppendResult(interp, " -expand ",
                (slavePtr->flags & EXPAND) ? "1" : "0", " -fill ",
                (char *) NULL);
        switch (slavePtr->flags & (FILLX|FILLY)) {
            case 0:
                Tcl_AppendResult(interp, "none", (char *) NULL);
                break;
            case FILLX:
                Tcl_AppendResult(interp, "x", (char *) NULL);
                break;
            case FILLY:
                Tcl_AppendResult(interp, "y", (char *) NULL);
                break;
            case FILLX|FILLY:
                Tcl_AppendResult(interp, "both", (char *) NULL);
                break;
        }
        sprintf(buffer, " -ipadx %d -ipady %d -padx %d -pady %d",
                slavePtr->iPadX/2, slavePtr->iPadY/2, slavePtr->padX/2,
                slavePtr->padY/2);
        Tcl_AppendResult(interp, buffer, " -side ", sideNames[slavePtr->side],
                (char *) NULL);
    } else if ((c == 'p') && (strncmp(argv[1], "propagate", length) == 0)) {
        Tk_Window master;
        Packer *masterPtr;
        int propagate;

        if (argc > 4) {
            Tcl_AppendResult(interp, "wrong # args: should be \"",
                    argv[0], " propagate window ?boolean?\"", (char *) NULL);
            return TCL_ERROR;
        }
        master = Tk_NameToWindow(interp, argv[2], tkwin);
        if (master == NULL) {
            return TCL_ERROR;
        }
        masterPtr = GetPacker(master);
        if (argc == 3) {
            if (masterPtr->flags & DONT_PROPAGATE) {
                Tcl_SetResult(interp, "0", TCL_STATIC);
            } else {
                Tcl_SetResult(interp, "1", TCL_STATIC);
            }
            return TCL_OK;
        }
        if (Tcl_GetBoolean(interp, argv[3], &propagate) != TCL_OK) {
            return TCL_ERROR;
        }
        if (propagate) {
            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, (ClientData) masterPtr);
            }
        } else {
            masterPtr->flags |= DONT_PROPAGATE;
        }
    } else if ((c == 's') && (strncmp(argv[1], "slaves", length) == 0)) {
        Tk_Window master;
        Packer *masterPtr, *slavePtr;

        if (argc != 3) {
            Tcl_AppendResult(interp, "wrong # args: should be \"",
                    argv[0], " slaves window\"", (char *) NULL);
            return TCL_ERROR;
        }
        master = Tk_NameToWindow(interp, argv[2], tkwin);
        if (master == NULL) {
            return TCL_ERROR;
        }
        masterPtr = GetPacker(master);
        for (slavePtr = masterPtr->slavePtr; slavePtr != NULL;
                slavePtr = slavePtr->nextPtr) {
            Tcl_AppendElement(interp, Tk_PathName(slavePtr->tkwin));
        }
    } else if ((c == 'u') && (strncmp(argv[1], "unpack", length) == 0)) {
        Tk_Window tkwin2;
        Packer *packPtr;

        if (argc != 3) {
            Tcl_AppendResult(interp, "wrong # args: should be \"",
                    argv[0], " unpack window\"", (char *) NULL);
            return TCL_ERROR;
        }
        tkwin2 = Tk_NameToWindow(interp, argv[2], tkwin);
        if (tkwin2 == NULL) {
            return TCL_ERROR;
        }
        packPtr = GetPacker(tkwin2);
        if ((packPtr != NULL) && (packPtr->masterPtr != NULL)) {
            Tk_ManageGeometry(tkwin2, (Tk_GeomMgr *) NULL,
                    (ClientData) NULL);
            if (packPtr->masterPtr->tkwin != Tk_Parent(packPtr->tkwin)) {
                Tk_UnmaintainGeometry(packPtr->tkwin,
                        packPtr->masterPtr->tkwin);
            }
            Unlink(packPtr);
            Tk_UnmapWindow(packPtr->tkwin);
        }
    } else {
        Tcl_AppendResult(interp, "bad option \"", argv[1],
                "\": must be configure, forget, info, ",
                "propagate, or slaves", (char *) NULL);
        return TCL_ERROR;
    }
    return TCL_OK;
}

/*
 *--------------------------------------------------------------
 *
 * PackReqProc --
 *
 *      This procedure 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, tkwin)
    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 = (Packer *) clientData;

    packPtr = packPtr->masterPtr;
    if (!(packPtr->flags & REQUESTED_REPACK)) {
        packPtr->flags |= REQUESTED_REPACK;
        Tcl_DoWhenIdle(ArrangePacking, (ClientData) packPtr);
    }
}

/*
 *--------------------------------------------------------------
 *
 * PackLostSlaveProc --
 *
 *      This procedure 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, tkwin)
    ClientData clientData;      /* Packer structure for slave window that
                                 * was stolen away. */
    Tk_Window tkwin;            /* Tk's handle for the slave window. */
{
    register Packer *slavePtr = (Packer *) clientData;

    if (slavePtr->masterPtr->tkwin != Tk_Parent(slavePtr->tkwin)) {
        Tk_UnmaintainGeometry(slavePtr->tkwin, slavePtr->masterPtr->tkwin);
    }
    Unlink(slavePtr);
    Tk_UnmapWindow(slavePtr->tkwin);
}

/*
 *--------------------------------------------------------------
 *
 * ArrangePacking --
 *
 *      This procedure 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 clientData;      /* Structure describing parent whose slaves
                                 * are to be re-layed out. */
{
    register Packer *masterPtr = (Packer *) 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 parent 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 intBWidth;              /* Width of internal border in parent window,
                                 * if any. */
    int abort;                  /* May get set to non-zero to abort this
                                 * repacking operation. */
    int borderX, borderY;
    int maxWidth, maxHeight, tmp;

    masterPtr->flags &= ~REQUESTED_REPACK;

    /*
     * If the parent has no slaves anymore, then don't do anything
     * at all:  just leave the parent'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((ClientData) 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.
     */

    intBWidth = Tk_InternalBorderWidth(masterPtr->tkwin);
    width = height = maxWidth = maxHeight = 2*intBWidth;
    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 the total amount of space needed in the parent 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 parent 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, (ClientData) 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 = cavityY = x = y = intBWidth;
    cavityWidth = Tk_Width(masterPtr->tkwin) - 2*intBWidth;
    cavityHeight = Tk_Height(masterPtr->tkwin) - 2*intBWidth;
    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;
        } else {
            borderX = slavePtr->padX;
            borderY = slavePtr->padY;
        }
        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;
        }
        borderX /= 2;
        borderY /= 2;
        switch (slavePtr->anchor) {
            case TK_ANCHOR_N:
                x = frameX + (frameWidth - width)/2;
                y = frameY + borderY;
                break;
            case TK_ANCHOR_NE:
                x = frameX + frameWidth - width - borderX;
                y = frameY + borderY;
                break;
            case TK_ANCHOR_E:
                x = frameX + frameWidth - width - borderX;
                y = frameY + (frameHeight - height)/2;
                break;
            case TK_ANCHOR_SE:
                x = frameX + frameWidth - width - borderX;
                y = frameY + frameHeight - height - borderY;
                break;
            case TK_ANCHOR_S:
                x = frameX + (frameWidth - width)/2;
                y = frameY + frameHeight - height - borderY;
                break;
            case TK_ANCHOR_SW:
                x = frameX + borderX;
                y = frameY + frameHeight - height - borderY;
                break;
            case TK_ANCHOR_W:
                x = frameX + borderX;
                y = frameY + (frameHeight - height)/2;
                break;
            case TK_ANCHOR_NW:
                x = frameX + borderX;
                y = frameY + borderY;
                break;
            case TK_ANCHOR_CENTER:
                x = frameX + (frameWidth - width)/2;
                y = frameY + (frameHeight - height)/2;
                break;
            default:
                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((ClientData) 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(slavePtr, cavityWidth)
    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 procedure 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)) {
            curExpand = (cavityWidth - childWidth)/numExpand;
            if (curExpand < minExpand) {
                minExpand = curExpand;
            }
        } else {
            cavityWidth -= childWidth;
            if (slavePtr->flags & EXPAND) {
                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(slavePtr, cavityHeight)
    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)) {
            curExpand = (cavityHeight - childHeight)/numExpand;
            if (curExpand < minExpand) {
                minExpand = curExpand;
            }
        } else {
            cavityHeight -= childHeight;
            if (slavePtr->flags & EXPAND) {
                numExpand++;
            }
        }
    }
    curExpand = cavityHeight/numExpand;
    if (curExpand < minExpand) {
        minExpand = curExpand;
    }
    return (minExpand < 0) ? 0 : minExpand;
}

/*
 *--------------------------------------------------------------
 *
 * GetPacker --
 *
 *      This internal procedure 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(tkwin)
    Tk_Window tkwin;            /* Token for window for which
                                 * packer structure is desired. */
{
    register Packer *packPtr;
    Tcl_HashEntry *hPtr;
    int new;
    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, 
            &new);
    if (!new) {
        return (Packer *) Tcl_GetHashValue(hPtr);
    }
    packPtr = (Packer *) 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->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, (ClientData) packPtr);
    return packPtr;
}

/*
 *--------------------------------------------------------------
 *
 * PackAfter --
 *
 *      This procedure does most of the real work of adding
 *      one or more windows into the packing order for its parent.
 *
 * 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(interp, prevPtr, masterPtr, argc, argv)
    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 argc;                   /* Number of elements in argv. */
    char **argv;                /* Array of lists, each containing 2
                                 * elements:  window name and side
                                 * against which to pack. */
{
    register Packer *packPtr;
    Tk_Window tkwin, ancestor, parent;
    size_t length;
    char **options;
    int index, tmp, 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 ( ; argc > 0; argc -= 2, argv += 2, prevPtr = packPtr) {
        if (argc < 2) {
            Tcl_AppendResult(interp, "wrong # args: window \"",
                    argv[0], "\" should be followed by options",
                    (char *) 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.
         */

        tkwin = Tk_NameToWindow(interp, argv[0], masterPtr->tkwin);
        if (tkwin == NULL) {
            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_LEVEL) {
                badWindow:
                Tcl_AppendResult(interp, "can't pack ", argv[0],
                        " inside ", Tk_PathName(masterPtr->tkwin),
                        (char *) NULL);
                return TCL_ERROR;
            }
        }
        if (((Tk_FakeWin *) (tkwin))->flags & TK_TOP_LEVEL) {
            goto badWindow;
        }
        if (tkwin == masterPtr->tkwin) {
            goto badWindow;
        }
        packPtr = GetPacker(tkwin);

        /*
         * Process options for this window.
         */

        if (Tcl_SplitList(interp, argv[1], &optionCount, &options) != TCL_OK) {
            return TCL_ERROR;
        }
        packPtr->side = TOP;
        packPtr->anchor = TK_ANCHOR_CENTER;
        packPtr->padX = packPtr->padY = 0;
        packPtr->iPadX = packPtr->iPadY = 0;
        packPtr->flags &= ~(FILLX|FILLY|EXPAND);
        packPtr->flags |= OLD_STYLE;
        for (index = 0 ; index < optionCount; index++) {
            char *curOpt = options[index];

            c = curOpt[0];
            length = strlen(curOpt);

            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_AppendResult(interp, "wrong # args: \"", curOpt,
                            "\" option must be followed by screen distance",
                            (char *) NULL);
                    goto error;
                }
                if ((Tk_GetPixels(interp, tkwin, options[index+1], &tmp)
                        != TCL_OK) || (tmp < 0)) {
                    badPad:
                    Tcl_AppendResult(interp, "bad pad value \"",
                            options[index+1],
                            "\": must be positive screen distance",
                            (char *) NULL);
                    goto error;
                }
                packPtr->padX = tmp;
                packPtr->iPadX = 0;
                index++;
            } else if ((c == 'p') && (strcmp(curOpt, "pady")) == 0) {
                if (optionCount < (index+2)) {
                    goto missingPad;
                }
                if ((Tk_GetPixels(interp, tkwin, options[index+1], &tmp)
                        != TCL_OK) || (tmp < 0)) {
                    goto badPad;
                }
                packPtr->padY = tmp;
                packPtr->iPadY = 0;
                index++;
            } else if ((c == 'f') && (length > 1)
                    && (strncmp(curOpt, "frame", length) == 0)) {
                if (optionCount < (index+2)) {
                    Tcl_AppendResult(interp, "wrong # args: \"frame\" ",
                            "option must be followed by anchor point",
                            (char *) NULL);
                    goto error;
                }
                if (Tk_GetAnchor(interp, options[index+1],
                        &packPtr->anchor) != TCL_OK) {
                    goto error;
                }
                index++;
            } else {
                Tcl_AppendResult(interp, "bad option \"", curOpt,
                        "\": should be top, bottom, left, right, ",
                        "expand, fill, fillx, filly, padx, pady, or frame",
                        (char *) NULL);
                goto 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 parent'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, (ClientData) packPtr);
        }
        ckfree((char *) options);
    }

    /*
     * Arrange for the parent 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, (ClientData) masterPtr);
    }
    return TCL_OK;

    error:
    ckfree((char *) options);
    return TCL_ERROR;
}

/*
 *----------------------------------------------------------------------
 *
 * Unlink --
 *
 *      Remove a packer from its parent's list of slaves.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      The parent will be scheduled for repacking.
 *
 *----------------------------------------------------------------------
 */

static void
Unlink(packPtr)
    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) {
                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, (ClientData) masterPtr);
    }
    if (masterPtr->abortPtr != NULL) {
        *masterPtr->abortPtr = 1;
    }

    packPtr->masterPtr = NULL;
}

/*
 *----------------------------------------------------------------------
 *
 * DestroyPacker --
 *
 *      This procedure 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(memPtr)
    char *memPtr;               /* Info about packed window that
                                 * is now dead. */
{
    register Packer *packPtr = (Packer *) memPtr;
    ckfree((char *) packPtr);
}

/*
 *----------------------------------------------------------------------
 *
 * PackStructureProc --
 *
 *      This procedure 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, eventPtr)
    ClientData clientData;              /* Our information about window
                                         * referred to by eventPtr. */
    XEvent *eventPtr;                   /* Describes what just happened. */
{
    register Packer *packPtr = (Packer *) clientData;

    if (eventPtr->type == ConfigureNotify) {
        if ((packPtr->slavePtr != NULL)
                && !(packPtr->flags & REQUESTED_REPACK)) {
            packPtr->flags |= REQUESTED_REPACK;
            Tcl_DoWhenIdle(ArrangePacking, (ClientData) packPtr);
        }
        if (packPtr->doubleBw != 2*Tk_Changes(packPtr->tkwin)->border_width) {
            if ((packPtr->masterPtr != NULL)
                    && !(packPtr->masterPtr->flags & REQUESTED_REPACK)) {
                packPtr->doubleBw = 2*Tk_Changes(packPtr->tkwin)->border_width;
                packPtr->masterPtr->flags |= REQUESTED_REPACK;
                Tcl_DoWhenIdle(ArrangePacking, (ClientData) 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, (Tk_GeomMgr *) NULL,
                    (ClientData) 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, (ClientData) packPtr);
        }
        packPtr->tkwin = NULL;
        Tcl_EventuallyFree((ClientData) packPtr, 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, (ClientData) 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(interp, tkwin, argc, argv)
    Tcl_Interp *interp;         /* Interpreter for error reporting. */
    Tk_Window tkwin;            /* Any window in application containing
                                 * slaves.  Used to look up slave names. */
    int argc;                   /* Number of elements in argv. */
    char *argv[];               /* Argument strings:  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, c, tmp, positionGiven;
    size_t length;

    /*
     * Find out how many windows are specified.
     */

    for (numWindows = 0; numWindows < argc; numWindows++) {
        if (argv[numWindows][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++) {
        slave = Tk_NameToWindow(interp, argv[j], tkwin);
        if (slave == NULL) {
            return TCL_ERROR;
        }
        if (Tk_IsTopLevel(slave)) {
            Tcl_AppendResult(interp, "can't pack \"", argv[j],
                    "\": it's a top-level window", (char *) 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->iPadX = slavePtr->iPadY = 0;
            slavePtr->flags &= ~(FILLX|FILLY|EXPAND);
        }

        for (i = numWindows; i < argc; i+=2) {
            if ((i+2) > argc) {
                Tcl_AppendResult(interp, "extra option \"", argv[i],
                        "\" (option with no value?)", (char *) NULL);
                return TCL_ERROR;
            }
            length = strlen(argv[i]);
            if (length < 2) {
                goto badOption;
            }
            c = argv[i][1];
            if ((c == 'a') && (strncmp(argv[i], "-after", length) == 0)
                    && (length >= 2)) {
                if (j == 0) {
                    other = Tk_NameToWindow(interp, argv[i+1], tkwin);
                    if (other == NULL) {
                        return TCL_ERROR;
                    }
                    prevPtr = GetPacker(other);
                    if (prevPtr->masterPtr == NULL) {
                        notPacked:
                        Tcl_AppendResult(interp, "window \"", argv[i+1],
                                "\" isn't packed", (char *) NULL);
                        return TCL_ERROR;
                    }
                    masterPtr = prevPtr->masterPtr;
                    positionGiven = 1;
                }
            } else if ((c == 'a') && (strncmp(argv[i], "-anchor", length) == 0)
                    && (length >= 2)) {
                if (Tk_GetAnchor(interp, argv[i+1], &slavePtr->anchor)
                        != TCL_OK) {
                    return TCL_ERROR;
                }
            } else if ((c == 'b')
                    && (strncmp(argv[i], "-before", length) == 0)) {
                if (j == 0) {
                    other = Tk_NameToWindow(interp, argv[i+1], tkwin);
                    if (other == NULL) {
                        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;
                }
            } else if ((c == 'e')
                    && (strncmp(argv[i], "-expand", length) == 0)) {
                if (Tcl_GetBoolean(interp, argv[i+1], &tmp) != TCL_OK) {
                    return TCL_ERROR;
                }
                slavePtr->flags &= ~EXPAND;
                if (tmp) {
                    slavePtr->flags |= EXPAND;
                }
            } else if ((c == 'f') && (strncmp(argv[i], "-fill", length) == 0)) {
                if (strcmp(argv[i+1], "none") == 0) {
                    slavePtr->flags &= ~(FILLX|FILLY);
                } else if (strcmp(argv[i+1], "x") == 0) {
                    slavePtr->flags = (slavePtr->flags & ~FILLY) | FILLX;
                } else if (strcmp(argv[i+1], "y") == 0) {
                    slavePtr->flags = (slavePtr->flags & ~FILLX) | FILLY;
                } else if (strcmp(argv[i+1], "both") == 0) {
                    slavePtr->flags |= FILLX|FILLY;
                } else {
                    Tcl_AppendResult(interp, "bad fill style \"", argv[i+1],
                            "\": must be none, x, y, or both", (char *) NULL);
                    return TCL_ERROR;
                }
            } else if ((c == 'i') && (strcmp(argv[i], "-in") == 0)) {
                if (j == 0) {
                    other = Tk_NameToWindow(interp, argv[i+1], tkwin);
                    if (other == NULL) {
                        return TCL_ERROR;
                    }
                    masterPtr = GetPacker(other);
                    prevPtr = masterPtr->slavePtr;
                    if (prevPtr != NULL) {
                        while (prevPtr->nextPtr != NULL) {
                            prevPtr = prevPtr->nextPtr;
                        }
                    }
                    positionGiven = 1;
                }
            } else if ((c == 'i') && (strcmp(argv[i], "-ipadx") == 0)) {
                if ((Tk_GetPixels(interp, slave, argv[i+1], &tmp) != TCL_OK)
                        || (tmp < 0)) {
                    badPad:
                    Tcl_ResetResult(interp);
                    Tcl_AppendResult(interp, "bad pad value \"", argv[i+1],
                            "\": must be positive screen distance",
                            (char *) NULL);
                    return TCL_ERROR;
                }
                slavePtr->iPadX = tmp*2;
            } else if ((c == 'i') && (strcmp(argv[i], "-ipady") == 0)) {
                if ((Tk_GetPixels(interp, slave, argv[i+1], &tmp) != TCL_OK)
                        || (tmp< 0)) {
                    goto badPad;
                }
                slavePtr->iPadY = tmp*2;
            } else if ((c == 'p') && (strcmp(argv[i], "-padx") == 0)) {
                if ((Tk_GetPixels(interp, slave, argv[i+1], &tmp) != TCL_OK)
                        || (tmp< 0)) {
                    goto badPad;
                }
                slavePtr->padX = tmp*2;
            } else if ((c == 'p') && (strcmp(argv[i], "-pady") == 0)) {
                if ((Tk_GetPixels(interp, slave, argv[i+1], &tmp) != TCL_OK)
                        || (tmp< 0)) {
                    goto badPad;
                }
                slavePtr->padY = tmp*2;
            } else if ((c == 's') && (strncmp(argv[i], "-side", length) == 0)) {
                c = argv[i+1][0];
                if ((c == 't') && (strcmp(argv[i+1], "top") == 0)) {
                    slavePtr->side = TOP;
                } else if ((c == 'b') && (strcmp(argv[i+1], "bottom") == 0)) {
                    slavePtr->side = BOTTOM;
                } else if ((c == 'l') && (strcmp(argv[i+1], "left") == 0)) {
                    slavePtr->side = LEFT;
                } else if ((c == 'r') && (strcmp(argv[i+1], "right") == 0)) {
                    slavePtr->side = RIGHT;
                } else {
                    Tcl_AppendResult(interp, "bad side \"", argv[i+1],
                            "\": must be top, bottom, left, or right",
                            (char *) NULL);
                    return TCL_ERROR;
                }
            } else {
                badOption:
                Tcl_AppendResult(interp, "unknown or ambiguous option \"",
                        argv[i], "\": must be -after, -anchor, -before, ",
                        "-expand, -fill, -in, -ipadx, -ipady, -padx, ",
                        "-pady, or -side", (char *) NULL);
                return TCL_ERROR;
            }
        }

        /*
         * 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 then
         * 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_IsTopLevel(ancestor)) {
                Tcl_AppendResult(interp, "can't pack ", argv[j],
                        " inside ", Tk_PathName(masterPtr->tkwin),
                        (char *) NULL);
                return TCL_ERROR;
            }
        }
        if (slave == masterPtr->tkwin) {
            Tcl_AppendResult(interp, "can't pack ", argv[j],
                    " inside itself", (char *) 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, (ClientData) slavePtr);
        prevPtr = slavePtr;

        /*
         * Arrange for the parent 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, (ClientData) masterPtr);
        }
    }
    return TCL_OK;
}

/* End of tkpack.c */