![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tkplace.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Micropolis - Activity] / micropolis / src / tk|
Return to tkplace.c CVS log | Up to [Micropolis - Activity] / micropolis / src / tk |
1.1 ! root 1: /* ! 2: * tkPlace.c -- ! 3: * ! 4: * This file contains code to implement a simple geometry manager ! 5: * for Tk based on absolute placement or "rubber-sheet" placement. ! 6: * ! 7: * Copyright 1992 Regents of the University of California ! 8: * Permission to use, copy, modify, and distribute this ! 9: * software and its documentation for any purpose and without ! 10: * fee is hereby granted, provided that this copyright ! 11: * notice appears in all copies. The University of California ! 12: * makes no representations about the suitability of this ! 13: * software for any purpose. It is provided "as is" without ! 14: * express or implied warranty. ! 15: */ ! 16: ! 17: #ifndef lint ! 18: static char rcsid[] = "$Header: /user6/ouster/wish/RCS/tkPlace.c,v 1.6 92/06/10 08:59:28 ouster Exp $ SPRITE (Berkeley)"; ! 19: #endif /* not lint */ ! 20: ! 21: #include "tkconfig.h" ! 22: #include "tkint.h" ! 23: ! 24: /* ! 25: * Border modes for relative placement: ! 26: * ! 27: * BM_INSIDE: relative distances computed using area inside ! 28: * all borders of master window. ! 29: * BM_OUTSIDE: relative distances computed using outside area ! 30: * that includes all borders of master. ! 31: * BM_IGNORE: border issues are ignored: place relative to ! 32: * master's actual window size. ! 33: */ ! 34: ! 35: typedef enum {BM_INSIDE, BM_OUTSIDE, BM_IGNORE} BorderMode; ! 36: ! 37: /* ! 38: * For each window whose geometry is managed by the placer there is ! 39: * a structure of the following type: ! 40: */ ! 41: ! 42: typedef struct Slave { ! 43: Tk_Window tkwin; /* Tk's token for window. */ ! 44: struct Master *masterPtr; /* Pointer to information for window ! 45: * relative to which tkwin is placed. ! 46: * This isn't necessarily the logical ! 47: * parent of tkwin. NULL means the ! 48: * master was deleted or never assigned. */ ! 49: struct Slave *nextPtr; /* Next in list of windows placed relative ! 50: * to same master (NULL for end of list). */ ! 51: ! 52: /* ! 53: * Geometry information for window; where there are both relative ! 54: * and absolute values for the same attribute (e.g. x and relX) only ! 55: * one of them is actually used, depending on flags. ! 56: */ ! 57: ! 58: int x, y; /* X and Y pixel coordinates for tkwin. */ ! 59: float relX, relY; /* X and Y coordinates relative to size of ! 60: * master. */ ! 61: int width, height; /* Absolute dimensions for tkwin. */ ! 62: float relWidth, relHeight; /* Dimensions for tkwin relative to size of ! 63: * master. */ ! 64: Tk_Anchor anchor; /* Which point on tkwin is placed at the ! 65: * given position. */ ! 66: BorderMode borderMode; /* How to treat borders of master window. */ ! 67: int flags; /* Various flags; see below for bit ! 68: * definitions. */ ! 69: } Slave; ! 70: ! 71: /* ! 72: * Flag definitions for Slave structures: ! 73: * ! 74: * CHILD_REL_X - 1 means use relX field; 0 means use x. ! 75: * CHILD_REL_Y - 1 means use relY field; 0 means use y; ! 76: * CHILD_WIDTH - 1 means use width field; ! 77: * CHILD_REL_WIDTH - 1 means use relWidth; if neither this nor ! 78: * CHILD_WIDTH is 1, use window's requested ! 79: * width. ! 80: * CHILD_HEIGHT - 1 means use height field; ! 81: * CHILD_REL_HEIGHT - 1 means use relHeight; if neither this nor ! 82: * CHILD_HEIGHT is 1, use window's requested ! 83: * height. ! 84: */ ! 85: ! 86: #define CHILD_REL_X 1 ! 87: #define CHILD_REL_Y 2 ! 88: #define CHILD_WIDTH 4 ! 89: #define CHILD_REL_WIDTH 8 ! 90: #define CHILD_HEIGHT 0x10 ! 91: #define CHILD_REL_HEIGHT 0x20 ! 92: ! 93: /* ! 94: * For each master window that has a slave managed by the placer there ! 95: * is a structure of the following form: ! 96: */ ! 97: ! 98: typedef struct Master { ! 99: Tk_Window tkwin; /* Tk's token for master window. */ ! 100: struct Slave *slavePtr; /* First in linked list of slaves ! 101: * placed relative to this master. */ ! 102: int flags; /* See below for bit definitions. */ ! 103: } Master; ! 104: ! 105: /* ! 106: * Flag definitions for masters: ! 107: * ! 108: * PARENT_RECONFIG_PENDING - 1 means that a call to RecomputePlacement ! 109: * is already pending via a Do_When_Idle handler. ! 110: */ ! 111: ! 112: #define PARENT_RECONFIG_PENDING 1 ! 113: ! 114: /* ! 115: * The hash tables below both use Tk_Window tokens as keys. They map ! 116: * from Tk_Windows to Slave and Master structures for windows, if they ! 117: * exist. ! 118: */ ! 119: ! 120: static int initialized = 0; ! 121: static Tcl_HashTable masterTable; ! 122: static Tcl_HashTable slaveTable; ! 123: ! 124: /* ! 125: * Forward declarations for procedures defined later in this file: ! 126: */ ! 127: ! 128: static void SlaveStructureProc _ANSI_ARGS_((ClientData clientData, ! 129: XEvent *eventPtr)); ! 130: static int ConfigureSlave _ANSI_ARGS_((Tcl_Interp *interp, ! 131: Slave *slavePtr, int argc, char **argv)); ! 132: static Slave * FindSlave _ANSI_ARGS_((Tk_Window tkwin)); ! 133: static Master * FindMaster _ANSI_ARGS_((Tk_Window tkwin)); ! 134: static void MasterStructureProc _ANSI_ARGS_((ClientData clientData, ! 135: XEvent *eventPtr)); ! 136: static void PlaceRequestProc _ANSI_ARGS_((ClientData clientData, ! 137: Tk_Window tkwin)); ! 138: static void RecomputePlacement _ANSI_ARGS_((ClientData clientData)); ! 139: static void UnlinkSlave _ANSI_ARGS_((Slave *slavePtr)); ! 140: ! 141: /* ! 142: *-------------------------------------------------------------- ! 143: * ! 144: * Tk_PlaceCmd -- ! 145: * ! 146: * This procedure is invoked to process the "place" Tcl ! 147: * commands. See the user documentation for details on ! 148: * what it does. ! 149: * ! 150: * Results: ! 151: * A standard Tcl result. ! 152: * ! 153: * Side effects: ! 154: * See the user documentation. ! 155: * ! 156: *-------------------------------------------------------------- ! 157: */ ! 158: ! 159: int ! 160: Tk_PlaceCmd(clientData, interp, argc, argv) ! 161: ClientData clientData; /* Main window associated with interpreter. */ ! 162: Tcl_Interp *interp; /* Current interpreter. */ ! 163: int argc; /* Number of arguments. */ ! 164: char **argv; /* Argument strings. */ ! 165: { ! 166: Tk_Window tkwin; ! 167: Slave *slavePtr; ! 168: Tcl_HashEntry *hPtr; ! 169: int length; ! 170: char c; ! 171: ! 172: /* ! 173: * Initialize, if that hasn't been done yet. ! 174: */ ! 175: ! 176: if (!initialized) { ! 177: Tcl_InitHashTable(&masterTable, TCL_ONE_WORD_KEYS); ! 178: Tcl_InitHashTable(&slaveTable, TCL_ONE_WORD_KEYS); ! 179: initialized = 1; ! 180: } ! 181: ! 182: if (argc < 3) { ! 183: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 184: argv[0], " option|pathName args", (char *) NULL); ! 185: return TCL_ERROR; ! 186: } ! 187: c = argv[1][0]; ! 188: length = strlen(argv[1]); ! 189: ! 190: /* ! 191: * Handle special shortcut where window name is first argument. ! 192: */ ! 193: ! 194: if (c == '.') { ! 195: tkwin = Tk_NameToWindow(interp, argv[1], (Tk_Window) clientData); ! 196: if (tkwin == NULL) { ! 197: return TCL_ERROR; ! 198: } ! 199: slavePtr = FindSlave(tkwin); ! 200: return ConfigureSlave(interp, slavePtr, argc-2, argv+2); ! 201: } ! 202: ! 203: /* ! 204: * Handle more general case of option followed by window name followed ! 205: * by possible additional arguments. ! 206: */ ! 207: ! 208: tkwin = Tk_NameToWindow(interp, argv[2], (Tk_Window) clientData); ! 209: if (tkwin == NULL) { ! 210: return TCL_ERROR; ! 211: } ! 212: if ((c == 'c') && (strncmp(argv[1], "configure", length) == 0)) { ! 213: if (argc < 5) { ! 214: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 215: argv[0], ! 216: " configure pathName option value ?option value ...?\"", ! 217: (char *) NULL); ! 218: return TCL_ERROR; ! 219: } ! 220: slavePtr = FindSlave(tkwin); ! 221: return ConfigureSlave(interp, slavePtr, argc-3, argv+3); ! 222: } else if ((c == 'd') && (strncmp(argv[1], "dependents", length) == 0)) { ! 223: if (argc != 3) { ! 224: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 225: argv[0], " dependents pathName\"", (char *) NULL); ! 226: return TCL_ERROR; ! 227: } ! 228: hPtr = Tcl_FindHashEntry(&masterTable, (char *) tkwin); ! 229: if (hPtr != NULL) { ! 230: Master *masterPtr; ! 231: masterPtr = (Master *) Tcl_GetHashValue(hPtr); ! 232: for (slavePtr = masterPtr->slavePtr; slavePtr != NULL; ! 233: slavePtr = slavePtr->nextPtr) { ! 234: Tcl_AppendElement(interp, Tk_PathName(slavePtr->tkwin), 0); ! 235: } ! 236: } ! 237: } else if ((c == 'f') && (strncmp(argv[1], "forget", length) == 0)) { ! 238: if (argc != 3) { ! 239: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 240: argv[0], " forget pathName\"", (char *) NULL); ! 241: return TCL_ERROR; ! 242: } ! 243: hPtr = Tcl_FindHashEntry(&slaveTable, (char *) tkwin); ! 244: if (hPtr == NULL) { ! 245: return TCL_OK; ! 246: } ! 247: slavePtr = (Slave *) Tcl_GetHashValue(hPtr); ! 248: UnlinkSlave(slavePtr); ! 249: Tcl_DeleteHashEntry(hPtr); ! 250: Tk_DeleteEventHandler(tkwin, StructureNotifyMask, SlaveStructureProc, ! 251: (ClientData) slavePtr); ! 252: Tk_ManageGeometry(tkwin, (Tk_GeometryProc *) NULL, (ClientData) NULL); ! 253: Tk_UnmapWindow(tkwin); ! 254: ckfree((char *) slavePtr); ! 255: } else if ((c == 'i') && (strncmp(argv[1], "info", length) == 0)) { ! 256: char buffer[50]; ! 257: ! 258: if (argc != 3) { ! 259: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 260: argv[0], " info pathName\"", (char *) NULL); ! 261: return TCL_ERROR; ! 262: } ! 263: hPtr = Tcl_FindHashEntry(&slaveTable, (char *) tkwin); ! 264: if (hPtr == NULL) { ! 265: return TCL_OK; ! 266: } ! 267: slavePtr = (Slave *) Tcl_GetHashValue(hPtr); ! 268: if (slavePtr->flags & CHILD_REL_X) { ! 269: sprintf(buffer, "-relx %.4g", slavePtr->relX); ! 270: } else { ! 271: sprintf(buffer, "-x %d", slavePtr->x); ! 272: } ! 273: Tcl_AppendResult(interp, buffer, (char *) NULL); ! 274: if (slavePtr->flags & CHILD_REL_Y) { ! 275: sprintf(buffer, " -rely %.4g", slavePtr->relY); ! 276: } else { ! 277: sprintf(buffer, " -y %d", slavePtr->y); ! 278: } ! 279: Tcl_AppendResult(interp, buffer, (char *) NULL); ! 280: if (slavePtr->flags & CHILD_REL_WIDTH) { ! 281: sprintf(buffer, " -relwidth %.4g", slavePtr->relWidth); ! 282: Tcl_AppendResult(interp, buffer, (char *) NULL); ! 283: } else if (slavePtr->flags & CHILD_WIDTH) { ! 284: sprintf(buffer, " -width %d", slavePtr->width); ! 285: Tcl_AppendResult(interp, buffer, (char *) NULL); ! 286: } ! 287: if (slavePtr->flags & CHILD_REL_HEIGHT) { ! 288: sprintf(buffer, " -relheight %.4g", slavePtr->relHeight); ! 289: Tcl_AppendResult(interp, buffer, (char *) NULL); ! 290: } else if (slavePtr->flags & CHILD_HEIGHT) { ! 291: sprintf(buffer, " -height %d", slavePtr->height); ! 292: Tcl_AppendResult(interp, buffer, (char *) NULL); ! 293: } ! 294: Tcl_AppendResult(interp, " -anchor ", Tk_NameOfAnchor(slavePtr->anchor), ! 295: (char *) NULL); ! 296: if (slavePtr->borderMode == BM_OUTSIDE) { ! 297: Tcl_AppendResult(interp, " -bordermode outside", (char *) NULL); ! 298: } else if (slavePtr->borderMode == BM_IGNORE) { ! 299: Tcl_AppendResult(interp, " -bordermode ignore", (char *) NULL); ! 300: } ! 301: if ((slavePtr->masterPtr != NULL) ! 302: && (slavePtr->masterPtr->tkwin != Tk_Parent(slavePtr->tkwin))) { ! 303: Tcl_AppendResult(interp, " -in ", ! 304: Tk_PathName(slavePtr->masterPtr->tkwin), (char *) NULL); ! 305: } ! 306: } else { ! 307: Tcl_AppendResult(interp, "unknown or ambiguous option \"", argv[1], ! 308: "\": must be configure, dependents, forget, or info", ! 309: (char *) NULL); ! 310: return TCL_ERROR; ! 311: } ! 312: return TCL_OK; ! 313: } ! 314: ! 315: /* ! 316: *---------------------------------------------------------------------- ! 317: * ! 318: * FindSlave -- ! 319: * ! 320: * Given a Tk_Window token, find the Slave structure corresponding ! 321: * to that token (making a new one if necessary). ! 322: * ! 323: * Results: ! 324: * None. ! 325: * ! 326: * Side effects: ! 327: * A new Slave structure may be created. ! 328: * ! 329: *---------------------------------------------------------------------- ! 330: */ ! 331: ! 332: static Slave * ! 333: FindSlave(tkwin) ! 334: Tk_Window tkwin; /* Token for desired slave. */ ! 335: { ! 336: Tcl_HashEntry *hPtr; ! 337: register Slave *slavePtr; ! 338: int new; ! 339: ! 340: hPtr = Tcl_CreateHashEntry(&slaveTable, (char *) tkwin, &new); ! 341: if (new) { ! 342: slavePtr = (Slave *) ckalloc(sizeof(Slave)); ! 343: slavePtr->tkwin = tkwin; ! 344: slavePtr->masterPtr = NULL; ! 345: slavePtr->nextPtr = NULL; ! 346: slavePtr->x = slavePtr->y = 0; ! 347: slavePtr->relX = slavePtr->relY = 0.0; ! 348: slavePtr->width = slavePtr->height = 0; ! 349: slavePtr->relWidth = slavePtr->relHeight = 0.0; ! 350: slavePtr->anchor = TK_ANCHOR_NW; ! 351: slavePtr->borderMode = BM_INSIDE; ! 352: slavePtr->flags = 0; ! 353: Tcl_SetHashValue(hPtr, slavePtr); ! 354: Tk_CreateEventHandler(tkwin, StructureNotifyMask, SlaveStructureProc, ! 355: (ClientData) slavePtr); ! 356: Tk_ManageGeometry(tkwin, PlaceRequestProc, (ClientData) slavePtr); ! 357: } else { ! 358: slavePtr = (Slave *) Tcl_GetHashValue(hPtr); ! 359: } ! 360: return slavePtr; ! 361: } ! 362: ! 363: /* ! 364: *---------------------------------------------------------------------- ! 365: * ! 366: * UnlinkSlave -- ! 367: * ! 368: * This procedure removes a slave window from the chain of slaves ! 369: * in its master. ! 370: * ! 371: * Results: ! 372: * None. ! 373: * ! 374: * Side effects: ! 375: * The slave list of slavePtr's master changes. ! 376: * ! 377: *---------------------------------------------------------------------- ! 378: */ ! 379: ! 380: static void ! 381: UnlinkSlave(slavePtr) ! 382: Slave *slavePtr; /* Slave structure to be unlinked. */ ! 383: { ! 384: register Master *masterPtr; ! 385: register Slave *prevPtr; ! 386: ! 387: masterPtr = slavePtr->masterPtr; ! 388: if (masterPtr == NULL) { ! 389: return; ! 390: } ! 391: if (masterPtr->slavePtr == slavePtr) { ! 392: masterPtr->slavePtr = slavePtr->nextPtr; ! 393: } else { ! 394: for (prevPtr = masterPtr->slavePtr; ; ! 395: prevPtr = prevPtr->nextPtr) { ! 396: if (prevPtr == NULL) { ! 397: panic("UnlinkSlave couldn't find slave to unlink"); ! 398: } ! 399: if (prevPtr->nextPtr == slavePtr) { ! 400: prevPtr->nextPtr = slavePtr->nextPtr; ! 401: break; ! 402: } ! 403: } ! 404: } ! 405: slavePtr->masterPtr = NULL; ! 406: } ! 407: ! 408: /* ! 409: *---------------------------------------------------------------------- ! 410: * ! 411: * FindMaster -- ! 412: * ! 413: * Given a Tk_Window token, find the Master structure corresponding ! 414: * to that token (making a new one if necessary). ! 415: * ! 416: * Results: ! 417: * None. ! 418: * ! 419: * Side effects: ! 420: * A new Master structure may be created. ! 421: * ! 422: *---------------------------------------------------------------------- ! 423: */ ! 424: ! 425: static Master * ! 426: FindMaster(tkwin) ! 427: Tk_Window tkwin; /* Token for desired master. */ ! 428: { ! 429: Tcl_HashEntry *hPtr; ! 430: register Master *masterPtr; ! 431: int new; ! 432: ! 433: hPtr = Tcl_CreateHashEntry(&masterTable, (char *) tkwin, &new); ! 434: if (new) { ! 435: masterPtr = (Master *) ckalloc(sizeof(Master)); ! 436: masterPtr->tkwin = tkwin; ! 437: masterPtr->slavePtr = NULL; ! 438: masterPtr->flags = 0; ! 439: Tcl_SetHashValue(hPtr, masterPtr); ! 440: Tk_CreateEventHandler(masterPtr->tkwin, StructureNotifyMask, ! 441: MasterStructureProc, (ClientData) masterPtr); ! 442: } else { ! 443: masterPtr = (Master *) Tcl_GetHashValue(hPtr); ! 444: } ! 445: return masterPtr; ! 446: } ! 447: ! 448: /* ! 449: *---------------------------------------------------------------------- ! 450: * ! 451: * ConfigureSlave -- ! 452: * ! 453: * This procedure is called to process an argv/argc list to ! 454: * reconfigure the placement of a window. ! 455: * ! 456: * Results: ! 457: * A standard Tcl result. If an error occurs then a message is ! 458: * left in interp->result. ! 459: * ! 460: * Side effects: ! 461: * Information in slavePtr may change, and slavePtr's master is ! 462: * scheduled for reconfiguration. ! 463: * ! 464: *---------------------------------------------------------------------- ! 465: */ ! 466: ! 467: static int ! 468: ConfigureSlave(interp, slavePtr, argc, argv) ! 469: Tcl_Interp *interp; /* Used for error reporting. */ ! 470: Slave *slavePtr; /* Pointer to current information ! 471: * about slave. */ ! 472: int argc; /* Number of config arguments. */ ! 473: char **argv; /* String values for arguments. */ ! 474: { ! 475: register Master *masterPtr; ! 476: int c, length, result; ! 477: double d; ! 478: ! 479: result = TCL_OK; ! 480: for ( ; argc > 0; argc -= 2, argv += 2) { ! 481: if (argc < 2) { ! 482: Tcl_AppendResult(interp, "extra option \"", argv[0], ! 483: "\" (option with no value?)", (char *) NULL); ! 484: result = TCL_ERROR; ! 485: goto done; ! 486: } ! 487: length = strlen(argv[0]); ! 488: c = argv[0][1]; ! 489: if ((c == 'a') && (strncmp(argv[0], "-anchor", length) == 0)) { ! 490: if (Tk_GetAnchor(interp, argv[1], &slavePtr->anchor) != TCL_OK) { ! 491: result = TCL_ERROR; ! 492: goto done; ! 493: } ! 494: } else if ((c == 'b') ! 495: && (strncmp(argv[0], "-bordermode", length) == 0)) { ! 496: c = argv[1][0]; ! 497: length = strlen(argv[1]); ! 498: if ((c == 'i') && (strncmp(argv[1], "ignore", length) == 0) ! 499: && (length >= 2)) { ! 500: slavePtr->borderMode = BM_IGNORE; ! 501: } else if ((c == 'i') && (strncmp(argv[1], "inside", length) == 0) ! 502: && (length >= 2)) { ! 503: slavePtr->borderMode = BM_INSIDE; ! 504: } else if ((c == 'o') ! 505: && (strncmp(argv[1], "outside", length) == 0)) { ! 506: slavePtr->borderMode = BM_OUTSIDE; ! 507: } else { ! 508: Tcl_AppendResult(interp, "bad border mode \"", argv[1], ! 509: "\": must be ignore, inside, or outside", ! 510: (char *) NULL); ! 511: result = TCL_ERROR; ! 512: goto done; ! 513: } ! 514: } else if ((c == 'h') && (strncmp(argv[0], "-height", length) == 0)) { ! 515: if (argv[1][0] == 0) { ! 516: slavePtr->flags &= ~(CHILD_REL_HEIGHT|CHILD_HEIGHT); ! 517: } else { ! 518: if (Tk_GetPixels(interp, slavePtr->tkwin, argv[1], ! 519: &slavePtr->height) != TCL_OK) { ! 520: result = TCL_ERROR; ! 521: goto done; ! 522: } ! 523: slavePtr->flags &= ~CHILD_REL_HEIGHT; ! 524: slavePtr->flags |= CHILD_HEIGHT; ! 525: } ! 526: } else if ((c == 'i') && (strncmp(argv[0], "-in", length) == 0)) { ! 527: Tk_Window tkwin; ! 528: Tk_Window ancestor; ! 529: ! 530: tkwin = Tk_NameToWindow(interp, argv[1], slavePtr->tkwin); ! 531: if (tkwin == NULL) { ! 532: result = TCL_ERROR; ! 533: goto done; ! 534: } ! 535: ! 536: /* ! 537: * Make sure that the new master is either the logical parent ! 538: * of the slave or a descendant of that window. ! 539: */ ! 540: ! 541: for (ancestor = tkwin; ; ancestor = Tk_Parent(ancestor)) { ! 542: if (ancestor == Tk_Parent(slavePtr->tkwin)) { ! 543: break; ! 544: } ! 545: if (((Tk_FakeWin *) (ancestor))->flags & TK_TOP_LEVEL) { ! 546: Tcl_AppendResult(interp, "can't place ", ! 547: Tk_PathName(slavePtr->tkwin), " relative to ", ! 548: Tk_PathName(tkwin), (char *) NULL); ! 549: result = TCL_ERROR; ! 550: goto done; ! 551: } ! 552: } ! 553: UnlinkSlave(slavePtr); ! 554: slavePtr->masterPtr = FindMaster(tkwin); ! 555: slavePtr->nextPtr = slavePtr->masterPtr->slavePtr; ! 556: slavePtr->masterPtr->slavePtr = slavePtr; ! 557: } else if ((c == 'r') && (strncmp(argv[0], "-relheight", length) == 0) ! 558: && (length >= 5)) { ! 559: if (Tcl_GetDouble(interp, argv[1], &d) != TCL_OK) { ! 560: result = TCL_ERROR; ! 561: goto done; ! 562: } ! 563: slavePtr->relHeight = d; ! 564: slavePtr->flags |= CHILD_REL_HEIGHT; ! 565: slavePtr->flags &= ~CHILD_HEIGHT; ! 566: } else if ((c == 'r') && (strncmp(argv[0], "-relwidth", length) == 0) ! 567: && (length >= 5)) { ! 568: if (Tcl_GetDouble(interp, argv[1], &d) != TCL_OK) { ! 569: result = TCL_ERROR; ! 570: goto done; ! 571: } ! 572: slavePtr->relWidth = d; ! 573: slavePtr->flags |= CHILD_REL_WIDTH; ! 574: slavePtr->flags &= ~CHILD_WIDTH; ! 575: } else if ((c == 'r') && (strncmp(argv[0], "-relx", length) == 0) ! 576: && (length >= 5)) { ! 577: if (Tcl_GetDouble(interp, argv[1], &d) != TCL_OK) { ! 578: result = TCL_ERROR; ! 579: goto done; ! 580: } ! 581: slavePtr->relX = d; ! 582: slavePtr->flags |= CHILD_REL_X; ! 583: } else if ((c == 'r') && (strncmp(argv[0], "-rely", length) == 0) ! 584: && (length >= 5)) { ! 585: if (Tcl_GetDouble(interp, argv[1], &d) != TCL_OK) { ! 586: result = TCL_ERROR; ! 587: goto done; ! 588: } ! 589: slavePtr->relY = d; ! 590: slavePtr->flags |= CHILD_REL_Y; ! 591: } else if ((c == 'w') && (strncmp(argv[0], "-width", length) == 0)) { ! 592: if (argv[1][0] == 0) { ! 593: slavePtr->flags &= ~(CHILD_REL_WIDTH|CHILD_WIDTH); ! 594: } else { ! 595: if (Tk_GetPixels(interp, slavePtr->tkwin, argv[1], ! 596: &slavePtr->width) != TCL_OK) { ! 597: result = TCL_ERROR; ! 598: goto done; ! 599: } ! 600: slavePtr->flags &= ~CHILD_REL_WIDTH; ! 601: slavePtr->flags |= CHILD_WIDTH; ! 602: } ! 603: } else if ((c == 'x') && (strncmp(argv[0], "-x", length) == 0)) { ! 604: if (Tk_GetPixels(interp, slavePtr->tkwin, argv[1], ! 605: &slavePtr->x) != TCL_OK) { ! 606: result = TCL_ERROR; ! 607: goto done; ! 608: } ! 609: slavePtr->flags &= ~CHILD_REL_X; ! 610: } else if ((c == 'y') && (strncmp(argv[0], "-y", length) == 0)) { ! 611: if (Tk_GetPixels(interp, slavePtr->tkwin, argv[1], ! 612: &slavePtr->y) != TCL_OK) { ! 613: result = TCL_ERROR; ! 614: goto done; ! 615: } ! 616: slavePtr->flags &= ~CHILD_REL_Y; ! 617: } else { ! 618: Tcl_AppendResult(interp, "unknown or ambiguous option \"", ! 619: argv[0], "\": must be -anchor, -bordermode, -height, ", ! 620: "-in, -relheight, -relwidth, -relx, -rely, -width, ", ! 621: "-x, or -y", (char *) NULL); ! 622: result = TCL_ERROR; ! 623: goto done; ! 624: } ! 625: } ! 626: ! 627: /* ! 628: * If there's no master specified for this slave, use its Tk_Parent. ! 629: * Then arrange for a placement recalculation in the master. ! 630: */ ! 631: ! 632: done: ! 633: masterPtr = slavePtr->masterPtr; ! 634: if (masterPtr == NULL) { ! 635: masterPtr = FindMaster(Tk_Parent(slavePtr->tkwin)); ! 636: slavePtr->masterPtr = masterPtr; ! 637: slavePtr->nextPtr = masterPtr->slavePtr; ! 638: masterPtr->slavePtr = slavePtr; ! 639: } ! 640: if (!(masterPtr->flags & PARENT_RECONFIG_PENDING)) { ! 641: masterPtr->flags |= PARENT_RECONFIG_PENDING; ! 642: Tk_DoWhenIdle(RecomputePlacement, (ClientData) masterPtr); ! 643: } ! 644: return result; ! 645: } ! 646: ! 647: /* ! 648: *---------------------------------------------------------------------- ! 649: * ! 650: * RecomputePlacement -- ! 651: * ! 652: * This procedure is called as a when-idle handler. It recomputes ! 653: * the geometries of all the slaves of a given master. ! 654: * ! 655: * Results: ! 656: * None. ! 657: * ! 658: * Side effects: ! 659: * Windows may change size or shape. ! 660: * ! 661: *---------------------------------------------------------------------- ! 662: */ ! 663: ! 664: static void ! 665: RecomputePlacement(clientData) ! 666: ClientData clientData; /* Pointer to Master record. */ ! 667: { ! 668: register Master *masterPtr = (Master *) clientData; ! 669: register Slave *slavePtr; ! 670: Tk_Window ancestor, realMaster; ! 671: int x, y, width, height; ! 672: int masterWidth, masterHeight, masterBW; ! 673: ! 674: masterPtr->flags &= ~PARENT_RECONFIG_PENDING; ! 675: ! 676: /* ! 677: * Iterate over all the slaves for the master. Each slave's ! 678: * geometry can be computed independently of the other slaves. ! 679: */ ! 680: ! 681: for (slavePtr = masterPtr->slavePtr; slavePtr != NULL; ! 682: slavePtr = slavePtr->nextPtr) { ! 683: /* ! 684: * Step 1: compute size and borderwidth of master, taking into ! 685: * account desired border mode. ! 686: */ ! 687: ! 688: masterBW = 0; ! 689: masterWidth = Tk_Width(masterPtr->tkwin); ! 690: masterHeight = Tk_Height(masterPtr->tkwin); ! 691: if (slavePtr->borderMode == BM_INSIDE) { ! 692: masterBW = Tk_InternalBorderWidth(masterPtr->tkwin); ! 693: } else if (slavePtr->borderMode == BM_OUTSIDE) { ! 694: masterBW = -Tk_Changes(masterPtr->tkwin)->border_width; ! 695: } ! 696: masterWidth -= 2*masterBW; ! 697: masterHeight -= 2*masterBW; ! 698: ! 699: /* ! 700: * Step 2: compute size of slave (outside dimensions including ! 701: * border) and location of anchor point within master. ! 702: */ ! 703: ! 704: x = slavePtr->x; ! 705: if (slavePtr->flags & CHILD_REL_X) { ! 706: x = (slavePtr->relX*masterWidth) + ! 707: ((slavePtr->relX > 0) ? 0.5 : -0.5); ! 708: } ! 709: x += masterBW; ! 710: y = slavePtr->y; ! 711: if (slavePtr->flags & CHILD_REL_Y) { ! 712: y = (slavePtr->relY*masterHeight) + ! 713: ((slavePtr->relY > 0) ? 0.5 : -0.5); ! 714: } ! 715: y += masterBW; ! 716: if (slavePtr->flags & CHILD_REL_WIDTH) { ! 717: width = (slavePtr->relWidth*masterWidth) + 0.5; ! 718: } else if (slavePtr->flags & CHILD_WIDTH) { ! 719: width = slavePtr->width; ! 720: } else { ! 721: width = Tk_ReqWidth(slavePtr->tkwin) ! 722: + 2*Tk_Changes(slavePtr->tkwin)->border_width; ! 723: } ! 724: if (slavePtr->flags & CHILD_REL_HEIGHT) { ! 725: height = (slavePtr->relHeight*masterHeight) + 0.5; ! 726: } else if (slavePtr->flags & CHILD_HEIGHT) { ! 727: height = slavePtr->height; ! 728: } else { ! 729: height = Tk_ReqHeight(slavePtr->tkwin) ! 730: + 2*Tk_Changes(slavePtr->tkwin)->border_width; ! 731: } ! 732: ! 733: /* ! 734: * Step 3: adjust the x and y positions so that the desired ! 735: * anchor point on the slave appears at that position. Also ! 736: * adjust for the border mode and master's border. ! 737: */ ! 738: ! 739: switch (slavePtr->anchor) { ! 740: case TK_ANCHOR_N: ! 741: x -= width/2; ! 742: break; ! 743: case TK_ANCHOR_NE: ! 744: x -= width; ! 745: break; ! 746: case TK_ANCHOR_E: ! 747: x -= width; ! 748: y -= height/2; ! 749: break; ! 750: case TK_ANCHOR_SE: ! 751: x -= width; ! 752: y -= height; ! 753: break; ! 754: case TK_ANCHOR_S: ! 755: x -= width/2; ! 756: y -= height; ! 757: break; ! 758: case TK_ANCHOR_SW: ! 759: y -= height; ! 760: break; ! 761: case TK_ANCHOR_W: ! 762: y -= height/2; ! 763: break; ! 764: case TK_ANCHOR_NW: ! 765: break; ! 766: case TK_ANCHOR_CENTER: ! 767: x -= width/2; ! 768: y -= height/2; ! 769: break; ! 770: } ! 771: ! 772: /* ! 773: * Step 4: if masterPtr isn't actually the X master of slavePtr, ! 774: * then translate the x and y coordinates back into the coordinate ! 775: * system of masterPtr. ! 776: */ ! 777: ! 778: for (ancestor = masterPtr->tkwin, ! 779: realMaster = Tk_Parent(slavePtr->tkwin); ! 780: ancestor != realMaster; ancestor = Tk_Parent(ancestor)) { ! 781: x += Tk_X(ancestor) + Tk_Changes(ancestor)->border_width; ! 782: y += Tk_Y(ancestor) + Tk_Changes(ancestor)->border_width; ! 783: } ! 784: ! 785: /* ! 786: * Step 5: adjust width and height again to reflect inside dimensions ! 787: * of window rather than outside. Also make sure that the width and ! 788: * height aren't zero. ! 789: */ ! 790: ! 791: width -= 2*Tk_Changes(slavePtr->tkwin)->border_width; ! 792: height -= 2*Tk_Changes(slavePtr->tkwin)->border_width; ! 793: if (width <= 0) { ! 794: width = 1; ! 795: } ! 796: if (height <= 0) { ! 797: height = 1; ! 798: } ! 799: ! 800: /* ! 801: * Step 6: see if the window's size or location has changed; if ! 802: * so then tell X to reconfigure it. ! 803: */ ! 804: ! 805: if ((x != Tk_X(slavePtr->tkwin)) ! 806: || (y != Tk_Y(slavePtr->tkwin)) ! 807: || (width != Tk_Width(slavePtr->tkwin)) ! 808: || (height != Tk_Height(slavePtr->tkwin))) { ! 809: Tk_MoveResizeWindow(slavePtr->tkwin, x, y, ! 810: (unsigned int) width, (unsigned int) height); ! 811: } ! 812: Tk_MapWindow(slavePtr->tkwin); ! 813: } ! 814: } ! 815: ! 816: /* ! 817: *---------------------------------------------------------------------- ! 818: * ! 819: * MasterStructureProc -- ! 820: * ! 821: * This procedure is invoked by the Tk event handler when ! 822: * StructureNotify events occur for a master window. ! 823: * ! 824: * Results: ! 825: * None. ! 826: * ! 827: * Side effects: ! 828: * Structures get cleaned up if the window was deleted. If the ! 829: * window was resized then slave geometries get recomputed. ! 830: * ! 831: *---------------------------------------------------------------------- ! 832: */ ! 833: ! 834: static void ! 835: MasterStructureProc(clientData, eventPtr) ! 836: ClientData clientData; /* Pointer to Master structure for window ! 837: * referred to by eventPtr. */ ! 838: XEvent *eventPtr; /* Describes what just happened. */ ! 839: { ! 840: register Master *masterPtr = (Master *) clientData; ! 841: register Slave *slavePtr, *nextPtr; ! 842: ! 843: if (eventPtr->type == ConfigureNotify) { ! 844: if ((masterPtr->slavePtr != NULL) ! 845: && !(masterPtr->flags & PARENT_RECONFIG_PENDING)) { ! 846: masterPtr->flags |= PARENT_RECONFIG_PENDING; ! 847: Tk_DoWhenIdle(RecomputePlacement, (ClientData) masterPtr); ! 848: } ! 849: } else if (eventPtr->type == DestroyNotify) { ! 850: for (slavePtr = masterPtr->slavePtr; slavePtr != NULL; ! 851: slavePtr = nextPtr) { ! 852: slavePtr->masterPtr = NULL; ! 853: nextPtr = slavePtr->nextPtr; ! 854: slavePtr->nextPtr = NULL; ! 855: } ! 856: Tcl_DeleteHashEntry(Tcl_FindHashEntry(&masterTable, ! 857: (char *) masterPtr->tkwin)); ! 858: if (masterPtr->flags & PARENT_RECONFIG_PENDING) { ! 859: Tk_CancelIdleCall(RecomputePlacement, (ClientData) masterPtr); ! 860: } ! 861: masterPtr->tkwin = NULL; ! 862: ckfree((char *) masterPtr); ! 863: } ! 864: } ! 865: ! 866: /* ! 867: *---------------------------------------------------------------------- ! 868: * ! 869: * SlaveStructureProc -- ! 870: * ! 871: * This procedure is invoked by the Tk event handler when ! 872: * StructureNotify events occur for a slave window. ! 873: * ! 874: * Results: ! 875: * None. ! 876: * ! 877: * Side effects: ! 878: * Structures get cleaned up if the window was deleted. ! 879: * ! 880: *---------------------------------------------------------------------- ! 881: */ ! 882: ! 883: static void ! 884: SlaveStructureProc(clientData, eventPtr) ! 885: ClientData clientData; /* Pointer to Slave structure for window ! 886: * referred to by eventPtr. */ ! 887: XEvent *eventPtr; /* Describes what just happened. */ ! 888: { ! 889: register Slave *slavePtr = (Slave *) clientData; ! 890: ! 891: if (eventPtr->type == DestroyNotify) { ! 892: UnlinkSlave(slavePtr); ! 893: Tcl_DeleteHashEntry(Tcl_FindHashEntry(&slaveTable, ! 894: (char *) slavePtr->tkwin)); ! 895: ckfree((char *) slavePtr); ! 896: } ! 897: } ! 898: ! 899: /* ! 900: *---------------------------------------------------------------------- ! 901: * ! 902: * PlaceRequestProc -- ! 903: * ! 904: * This procedure is invoked by Tk whenever a slave managed by us ! 905: * changes its requested geometry. ! 906: * ! 907: * Results: ! 908: * None. ! 909: * ! 910: * Side effects: ! 911: * The window will get relayed out, if its requested size has ! 912: * anything to do with its actual size. ! 913: * ! 914: *---------------------------------------------------------------------- ! 915: */ ! 916: ! 917: /* ARGSUSED */ ! 918: static void ! 919: PlaceRequestProc(clientData, tkwin) ! 920: ClientData clientData; /* Pointer to our record for slave. */ ! 921: Tk_Window tkwin; /* Window that changed its desired ! 922: * size. */ ! 923: { ! 924: Slave *slavePtr = (Slave *) clientData; ! 925: Master *masterPtr; ! 926: ! 927: if (((slavePtr->flags & (CHILD_WIDTH|CHILD_REL_WIDTH)) != 0) ! 928: && ((slavePtr->flags & (CHILD_HEIGHT|CHILD_REL_HEIGHT)) != 0)) { ! 929: return; ! 930: } ! 931: masterPtr = slavePtr->masterPtr; ! 932: if (masterPtr == NULL) { ! 933: return; ! 934: } ! 935: if (!(masterPtr->flags & PARENT_RECONFIG_PENDING)) { ! 936: masterPtr->flags |= PARENT_RECONFIG_PENDING; ! 937: Tk_DoWhenIdle(RecomputePlacement, (ClientData) masterPtr); ! 938: } ! 939: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.