/[dtapublic]/projs/ets/trunk/src/c_tk_base_7_5_w_mods/tkpack.c

Diff of /projs/ets/trunk/src/c_tk_base_7_5_w_mods/tkpack.c

Parent Directory | Revision Log | View Patch Patch

-revision 69 by dashley,
Sat Nov  5 10:54:17 2016 UTC
+revision 71 by dashley,
Sat Nov  5 11:07:06 2016 UTC
 Line 1
  /* $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 */

 Legend:



Removed from v.69
 


changed lines


 
Added in v.71
 Legend:



Removed from v.69
 


changed lines


 
Added in v.71
-Removed from v.69
+Added in v.71

dashley@gmail.com	ViewVC Help
Powered by ViewVC 1.1.25