![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tkpack.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 tkpack.c CVS log | Up to [Micropolis - Activity] / micropolis / src / tk |
1.1 root 1: /*
2: * tkPack.c --
3: *
4: * This file contains code to implement the "packer"
5: * geometry manager for Tk.
6: *
7: * Copyright 1990 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 the above copyright
11: * notice appear 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/tkPack.c,v 1.27 92/01/04 15:16:41 ouster Exp $ SPRITE (Berkeley)";
19: #endif
20:
21: #include "tkconfig.h"
22: #include "tkint.h"
23:
24: typedef enum {TOP, BOTTOM, LEFT, RIGHT} Side;
25:
26: /* For each window that the packer cares about (either because
27: * the window is managed by the packer or because the window
28: * has children that are managed by the packer), there is a
29: * structure of the following type:
30: */
31:
32: typedef struct Packer {
33: Tk_Window tkwin; /* Tk token for window. NULL means that
34: * the window has been deleted, but the
35: * packet hasn't had a chance to clean up
36: * yet because the structure is still in
37: * use. */
38: struct Packer *parentPtr; /* Parent within which this window
39: * is packed (NULL means this window
40: * isn't managed by the packer). */
41: struct Packer *nextPtr; /* Next window packed within same
42: * parent. List is priority-ordered:
43: * first on list gets packed first. */
44: struct Packer *childPtr; /* First in list of children packed
45: * inside this window (NULL means
46: * no packed children). */
47: Side side; /* Side of parent against which
48: * this window is packed. */
49: Tk_Anchor anchorPoint; /* If frame allocated for window is larger
50: * than window needs, this indicates how
51: * where to position window in frame. */
52: int padX, padY; /* Additional amounts of space to give window
53: * besides what it asked for. */
54: int doubleBw; /* Twice the window's last known border
55: * width. If this changes, the window
56: * must be repacked within its parent. */
57: int *abortPtr; /* If non-NULL, it means that there is a nested
58: * call to ArrangePacking already working on
59: * this window. *abortPtr may be set to 1 to
60: * abort that nested call. This happens, for
61: * example, if tkwin or any of its children
62: * is deleted. */
63: int flags; /* Miscellaneous flags; see below
64: * for definitions. */
65: } Packer;
66:
67: /*
68: * Flag values for Packer structures:
69: *
70: * REQUESTED_REPACK: 1 means a Tk_DoWhenIdle request
71: * has already been made to repack
72: * all the children of this window.
73: * FILLX: 1 means if frame allocated for window
74: * is wider than window needs, expand window
75: * to fill frame. 0 means don't make window
76: * any larger than needed.
77: * FILLY: Same as FILLX, except for height.
78: * EXPAND: 1 means this window's frame will absorb any
79: * extra space in the parent window.
80: */
81:
82: #define REQUESTED_REPACK 1
83: #define FILLX 2
84: #define FILLY 4
85: #define EXPAND 8
86:
87: /*
88: * Hash table used to map from Tk_Window tokens to corresponding
89: * Packer structures:
90: */
91:
92: static Tcl_HashTable packerHashTable;
93:
94: /*
95: * Have statics in this module been initialized?
96: */
97:
98: static initialized = 0;
99:
100: /*
101: * Forward declarations for procedures defined later in this file:
102: */
103:
104: static void ArrangePacking _ANSI_ARGS_((ClientData clientData));
105: static Packer * GetPacker _ANSI_ARGS_((Tk_Window tkwin));
106: static int PackAfter _ANSI_ARGS_((Tcl_Interp *interp,
107: Packer *prevPtr, Packer *parentPtr, int argc,
108: char **argv));
109: static void PackReqProc _ANSI_ARGS_((ClientData clientData,
110: Tk_Window tkwin));
111: static void PackStructureProc _ANSI_ARGS_((ClientData clientData,
112: XEvent *eventPtr));
113: static void Unlink _ANSI_ARGS_((Packer *packPtr));
114:
115: /*
116: *--------------------------------------------------------------
117: *
118: * Tk_PackCmd --
119: *
120: * This procedure is invoked to process the "pack" Tcl command.
121: * See the user documentation for details on what it does.
122: *
123: * Results:
124: * A standard Tcl result.
125: *
126: * Side effects:
127: * See the user documentation.
128: *
129: *--------------------------------------------------------------
130: */
131:
132: int
133: Tk_PackCmd(clientData, interp, argc, argv)
134: ClientData clientData; /* Main window associated with
135: * interpreter. */
136: Tcl_Interp *interp; /* Current interpreter. */
137: int argc; /* Number of arguments. */
138: char **argv; /* Argument strings. */
139: {
140: Tk_Window tkwin = (Tk_Window) clientData;
141: int length;
142: char c;
143:
144: if (argc < 3) {
145: Tcl_AppendResult(interp, "wrong # args: should be \"",
146: argv[0], " option arg ?arg ...?\"", (char *) NULL);
147: return TCL_ERROR;
148: }
149: c = argv[1][0];
150: length = strlen(argv[1]);
151: if ((c == 'a') && (length >= 2)
152: && (strncmp(argv[1], "after", length) == 0)) {
153: Packer *prevPtr;
154: Tk_Window tkwin2;
155:
156: tkwin2 = Tk_NameToWindow(interp, argv[2], tkwin);
157: if (tkwin2 == NULL) {
158: return TCL_ERROR;
159: }
160: prevPtr = GetPacker(tkwin2);
161: if (prevPtr->parentPtr == NULL) {
162: Tcl_AppendResult(interp, "window \"", argv[2],
163: "\" isn't packed", (char *) NULL);
164: return TCL_ERROR;
165: }
166: return PackAfter(interp, prevPtr, prevPtr->parentPtr, argc-3, argv+3);
167: } else if ((c == 'a') && (length >= 2)
168: && (strncmp(argv[1], "append", length) == 0)) {
169: Packer *parentPtr;
170: register Packer *prevPtr;
171: Tk_Window tkwin2;
172:
173: tkwin2 = Tk_NameToWindow(interp, argv[2], tkwin);
174: if (tkwin2 == NULL) {
175: return TCL_ERROR;
176: }
177: parentPtr = GetPacker(tkwin2);
178: prevPtr = parentPtr->childPtr;
179: if (prevPtr != NULL) {
180: while (prevPtr->nextPtr != NULL) {
181: prevPtr = prevPtr->nextPtr;
182: }
183: }
184: return PackAfter(interp, prevPtr, parentPtr, argc-3, argv+3);
185: } else if ((c == 'b') && (strncmp(argv[1], "before", length) == 0)) {
186: Packer *packPtr, *parentPtr;
187: register Packer *prevPtr;
188: Tk_Window tkwin2;
189:
190: tkwin2 = Tk_NameToWindow(interp, argv[2], tkwin);
191: if (tkwin2 == NULL) {
192: return TCL_ERROR;
193: }
194: packPtr = GetPacker(tkwin2);
195: if (packPtr->parentPtr == NULL) {
196: Tcl_AppendResult(interp, "window \"", argv[2],
197: "\" isn't packed", (char *) NULL);
198: return TCL_ERROR;
199: }
200: parentPtr = packPtr->parentPtr;
201: prevPtr = parentPtr->childPtr;
202: if (prevPtr == packPtr) {
203: prevPtr = NULL;
204: } else {
205: for ( ; ; prevPtr = prevPtr->nextPtr) {
206: if (prevPtr == NULL) {
207: panic("\"pack before\" couldn't find predecessor");
208: }
209: if (prevPtr->nextPtr == packPtr) {
210: break;
211: }
212: }
213: }
214: return PackAfter(interp, prevPtr, parentPtr, argc-3, argv+3);
215: } else if ((c == 'i') && (strncmp(argv[1], "info", length) == 0)) {
216: char *prefix;
217: register Packer *packPtr;
218: Tk_Window tkwin2;
219: char tmp[20];
220: static char *sideNames[] = {"top", "bottom", "left", "right"};
221:
222: if (argc != 3) {
223: Tcl_AppendResult(interp, "wrong # args: should be \"",
224: argv[0], " info window\"", (char *) NULL);
225: return TCL_ERROR;
226: }
227: tkwin2 = Tk_NameToWindow(interp, argv[2], tkwin);
228: if (tkwin2 == NULL) {
229: return TCL_ERROR;
230: }
231: packPtr = GetPacker(tkwin2);
232: prefix = "";
233: for (packPtr = packPtr->childPtr; packPtr != NULL;
234: packPtr = packPtr->nextPtr) {
235: Tcl_AppendResult(interp, prefix, Tk_PathName(packPtr->tkwin),
236: " {", sideNames[(int) packPtr->side],
237: " frame ", Tk_NameOfAnchor(packPtr->anchorPoint),
238: (char *) NULL);
239: if (packPtr->padX != 0) {
240: sprintf(tmp, "%d", packPtr->padX);
241: Tcl_AppendResult(interp, " padx ", tmp, (char *) NULL);
242: }
243: if (packPtr->padY != 0) {
244: sprintf(tmp, "%d", packPtr->padY);
245: Tcl_AppendResult(interp, " pady ", tmp, (char *) NULL);
246: }
247: if (packPtr->flags & EXPAND) {
248: Tcl_AppendResult(interp, " expand", (char *) NULL);
249: }
250: if ((packPtr->flags & (FILLX|FILLY)) == (FILLX|FILLY)) {
251: Tcl_AppendResult(interp, " fill", (char *) NULL);
252: } else if (packPtr->flags & FILLX) {
253: Tcl_AppendResult(interp, " fillx", (char *) NULL);
254: } else if (packPtr->flags & FILLY) {
255: Tcl_AppendResult(interp, " filly", (char *) NULL);
256: }
257: Tcl_AppendResult(interp, "}", (char *) NULL);
258: prefix = " ";
259: }
260: return TCL_OK;
261: } else if ((c == 'u') && (strncmp(argv[1], "unpack", length) == 0)) {
262: Tk_Window tkwin2;
263: Packer *packPtr;
264:
265: if (argc != 3) {
266: Tcl_AppendResult(interp, "wrong # args: should be \"",
267: argv[0], " unpack window\"", (char *) NULL);
268: return TCL_ERROR;
269: }
270: tkwin2 = Tk_NameToWindow(interp, argv[2], tkwin);
271: if (tkwin2 == NULL) {
272: return TCL_ERROR;
273: }
274: packPtr = GetPacker(tkwin2);
275: if ((packPtr != NULL) && (packPtr->parentPtr != NULL)) {
276: Tk_ManageGeometry(tkwin2, (Tk_GeometryProc *) NULL,
277: (ClientData) NULL);
278: Unlink(packPtr);
279: Tk_UnmapWindow(packPtr->tkwin);
280: }
281: } else {
282: Tcl_AppendResult(interp, "bad option \"", argv[1],
283: "\": must be after, append, before, or info", (char *) NULL);
284: return TCL_ERROR;
285: }
286: return TCL_OK;
287: }
288:
289: /*
290: *--------------------------------------------------------------
291: *
292: * PackReqProc --
293: *
294: * This procedure is invoked by Tk_GeometryRequest for
295: * windows managed by the packer.
296: *
297: * Results:
298: * None.
299: *
300: * Side effects:
301: * Arranges for tkwin, and all its managed siblings, to
302: * be re-packed at the next idle point.
303: *
304: *--------------------------------------------------------------
305: */
306:
307: /* ARGSUSED */
308: static void
309: PackReqProc(clientData, tkwin)
310: ClientData clientData; /* Packer's information about
311: * window that got new preferred
312: * geometry. */
313: Tk_Window tkwin; /* Other Tk-related information
314: * about the window. */
315: {
316: register Packer *packPtr = (Packer *) clientData;
317:
318: packPtr = packPtr->parentPtr;
319: if (!(packPtr->flags & REQUESTED_REPACK)) {
320: packPtr->flags |= REQUESTED_REPACK;
321: Tk_DoWhenIdle(ArrangePacking, (ClientData) packPtr);
322: }
323: }
324:
325: /*
326: *--------------------------------------------------------------
327: *
328: * ArrangePacking --
329: *
330: * This procedure is invoked (using the Tk_DoWhenIdle
331: * mechanism) to re-layout a set of windows managed by
332: * the packer. It is invoked at idle time so that a
333: * series of packer requests can be merged into a single
334: * layout operation.
335: *
336: * Results:
337: * None.
338: *
339: * Side effects:
340: * The packed children of parentPtr may get resized or
341: * moved.
342: *
343: *--------------------------------------------------------------
344: */
345:
346: static void
347: ArrangePacking(clientData)
348: ClientData clientData; /* Structure describing parent
349: * whose children are to be
350: * re-layed out. */
351: {
352: register Packer *parentPtr = (Packer *) clientData;
353: register Packer *childPtr;
354: int numExpX, numExpY; /* # of windows that are expandable in
355: * each direction. */
356: int spareX, spareY; /* Amount of extra space to give to each
357: * expandable window. */
358: int leftOverX, leftOverY; /* Extra chunk of space to give to last
359: * expandable window. */
360: int cavityX, cavityY, cavityWidth, cavityHeight;
361: /* These variables keep track of the
362: * as-yet-unallocated space remaining in
363: * the middle of the parent window. */
364: int frameX, frameY, frameWidth, frameHeight;
365: /* These variables keep track of the frame
366: * allocated to the current window. */
367: int x, y, width, height; /* These variables are used to hold the
368: * actual geometry of the current window. */
369: int intBWidth; /* Width of internal border in parent window,
370: * if any. */
371: int abort; /* May get set to non-zero to abort this
372: * repacking operation. */
373: int maxWidth, maxHeight, tmp;
374:
375: parentPtr->flags &= ~REQUESTED_REPACK;
376:
377: /*
378: * If the parent has no children anymore, then don't do anything
379: * at all: just leave the parent's size as-is.
380: */
381:
382: if (parentPtr->childPtr == NULL) {
383: return;
384: }
385:
386: /*
387: * Abort any nested call to ArrangePacking for this window, since
388: * we'll do everything necessary here, and set up so this call
389: * can be aborted if necessary.
390: */
391:
392: if (parentPtr->abortPtr != NULL) {
393: *parentPtr->abortPtr = 1;
394: }
395: parentPtr->abortPtr = &abort;
396: abort = 0;
397: Tk_Preserve((ClientData) parentPtr);
398:
399: /*
400: * Pass #1: scan all the children to figure out the total amount
401: * of space needed. Two separate widths and heights are computed.
402: *
403: * "Width" and "height" compute the minimum parent size to meet
404: * the needs of each window in the direction "where there is
405: * flexibility". For example, if a child is packed TOP, then
406: * y is the flexible direction: the child's requested height
407: * will determine its size. For this window x is the inflexible
408: * direction: the window's width will be determined by the amount
409: * of space left in the parent's cavity, not by the window's
410: * requested width. "Width" and "height" are needed in order to
411: * compute how much extra space there is, so that it can be divided
412: * among the windows that have the EXPAND flag.
413: *
414: * "MaxWidth" and "maxHeight" compute the minimum parent size to
415: * meet all the needs of every window in both directions, flexible
416: * or inflexible. These values are needed to make geometry requests
417: * of the parent's parent.
418: */
419:
420: intBWidth = Tk_InternalBorderWidth(parentPtr->tkwin);
421: width = height = maxWidth = maxHeight = 2*intBWidth;
422: numExpX = numExpY = 0;
423: for (childPtr = parentPtr->childPtr; childPtr != NULL;
424: childPtr = childPtr->nextPtr) {
425: if ((childPtr->side == TOP) || (childPtr->side == BOTTOM)) {
426: tmp = Tk_ReqWidth(childPtr->tkwin) + childPtr->doubleBw
427: + childPtr->padX + width;
428: if (tmp > maxWidth) {
429: maxWidth = tmp;
430: }
431: height += Tk_ReqHeight(childPtr->tkwin) + childPtr->doubleBw
432: + childPtr->padY;
433: if (childPtr->flags & EXPAND) {
434: numExpY++;
435: }
436: } else {
437: tmp = Tk_ReqHeight(childPtr->tkwin) + childPtr->doubleBw
438: + childPtr->padY + height;
439: if (tmp > maxHeight) {
440: maxHeight = tmp;
441: }
442: width += Tk_ReqWidth(childPtr->tkwin) + childPtr->doubleBw
443: + childPtr->padX;
444: if (childPtr->flags & EXPAND) {
445: numExpX++;
446: }
447: }
448: }
449: if (width > maxWidth) {
450: maxWidth = width;
451: }
452: if (height > maxHeight) {
453: maxHeight = height;
454: }
455:
456: /*
457: * If the total amount of space needed in the parent window has
458: * changed, then notify the next geometry manager up and requeue
459: * ourselves to start again after the parent has had a chance to
460: * resize us.
461: */
462:
463: if ((maxWidth != Tk_ReqWidth(parentPtr->tkwin))
464: || (maxHeight != Tk_ReqHeight(parentPtr->tkwin))) {
465: Tk_GeometryRequest(parentPtr->tkwin, maxWidth, maxHeight);
466: parentPtr->flags |= REQUESTED_REPACK;
467: Tk_DoWhenIdle(ArrangePacking, (ClientData) parentPtr);
468: goto done;
469: }
470:
471: /*
472: * If there is spare space, figure out how much of it goes to
473: * each of the windows that is expandable.
474: */
475:
476: spareX = Tk_Width(parentPtr->tkwin) - width;
477: spareY = Tk_Height(parentPtr->tkwin) - height;
478: if ((spareX <= 0) || (numExpX == 0)) {
479: leftOverX = 0;
480: spareX = 0;
481: } else {
482: leftOverX = spareX % numExpX;
483: spareX /= numExpX;
484: }
485: if ((spareY <= 0) || (numExpY == 0)) {
486: leftOverY = spareY;
487: spareY = 0;
488: } else {
489: leftOverY = spareY % numExpY;
490: spareY /= numExpY;
491: }
492:
493: /*
494: * Pass #2: scan the children a second time assigning
495: * new sizes. The "cavity" variables keep track of the
496: * unclaimed space in the cavity of the window; this
497: * shrinks inward as we allocate windows around the
498: * edges. The "frame" variables keep track of the space
499: * allocated to the current window and its frame. The
500: * current window is then placed somewhere inside the
501: * frame, depending on anchorPoint.
502: */
503:
504: cavityX = cavityY = x = y = intBWidth;
505: cavityWidth = Tk_Width(parentPtr->tkwin) - 2*intBWidth;
506: cavityHeight = Tk_Height(parentPtr->tkwin) - 2*intBWidth;
507: for (childPtr = parentPtr->childPtr; childPtr != NULL;
508: childPtr = childPtr->nextPtr) {
509: if ((childPtr->side == TOP) || (childPtr->side == BOTTOM)) {
510: frameWidth = cavityWidth;
511: frameHeight = Tk_ReqHeight(childPtr->tkwin) + childPtr->padY
512: + childPtr->doubleBw;
513: if (childPtr->flags & EXPAND) {
514: frameHeight += spareY;
515: numExpY--;
516: if (numExpY == 0) {
517: frameHeight += leftOverY;
518: }
519: }
520: cavityHeight -= frameHeight;
521: if (cavityHeight < 0) {
522: frameHeight += cavityHeight;
523: cavityHeight = 0;
524: }
525: frameX = cavityX;
526: if (childPtr->side == TOP) {
527: frameY = cavityY;
528: cavityY += frameHeight;
529: } else {
530: frameY = cavityY + cavityHeight;
531: }
532: } else {
533: frameHeight = cavityHeight;
534: frameWidth = Tk_ReqWidth(childPtr->tkwin) + childPtr->padX
535: + childPtr->doubleBw;
536: if (childPtr->flags & EXPAND) {
537: frameWidth += spareX;
538: numExpX--;
539: if (numExpX == 0) {
540: frameWidth += leftOverX;
541: }
542: }
543: cavityWidth -= frameWidth;
544: if (cavityWidth < 0) {
545: frameWidth += cavityWidth;
546: cavityWidth = 0;
547: }
548: frameY = cavityY;
549: if (childPtr->side == LEFT) {
550: frameX = cavityX;
551: cavityX += frameWidth;
552: } else {
553: frameX = cavityX + cavityWidth;
554: }
555: }
556:
557: /*
558: * Now that we've got the size of the frame for the window,
559: * compute the window's actual size and location using the
560: * fill and frame factors.
561: */
562:
563: width = Tk_ReqWidth(childPtr->tkwin) + childPtr->doubleBw;
564: if ((childPtr->flags & FILLX) || (width > frameWidth)) {
565: width = frameWidth;
566: }
567: height = Tk_ReqHeight(childPtr->tkwin) + childPtr->doubleBw;
568: if ((childPtr->flags & FILLY) || (height > frameHeight)) {
569: height = frameHeight;
570: }
571: switch (childPtr->anchorPoint) {
572: case TK_ANCHOR_N:
573: x = frameX + (frameWidth - width)/2;
574: y = frameY;
575: break;
576: case TK_ANCHOR_NE:
577: x = frameX + frameWidth - width;
578: y = frameY;
579: break;
580: case TK_ANCHOR_E:
581: x = frameX + frameWidth - width;
582: y = frameY + (frameHeight - height)/2;
583: break;
584: case TK_ANCHOR_SE:
585: x = frameX + frameWidth - width;
586: y = frameY + frameHeight - height;
587: break;
588: case TK_ANCHOR_S:
589: x = frameX + (frameWidth - width)/2;
590: y = frameY + frameHeight - height;
591: break;
592: case TK_ANCHOR_SW:
593: x = frameX;
594: y = frameY + frameHeight - height;
595: break;
596: case TK_ANCHOR_W:
597: x = frameX;
598: y = frameY + (frameHeight - height)/2;
599: break;
600: case TK_ANCHOR_NW:
601: x = frameX;
602: y = frameY;
603: break;
604: case TK_ANCHOR_CENTER:
605: x = frameX + (frameWidth - width)/2;
606: y = frameY + (frameHeight - height)/2;
607: break;
608: default:
609: panic("bad frame factor in ArrangePacking");
610: }
611: width -= childPtr->doubleBw;
612: height -= childPtr->doubleBw;
613:
614: /*
615: * If the window is too small to be interesting then
616: * unmap it. Otherwise configure it and then make sure
617: * it's mapped.
618: */
619:
620: if ((width <= 0) || (height <= 0)) {
621: Tk_UnmapWindow(childPtr->tkwin);
622: } else {
623: if ((x != Tk_X(childPtr->tkwin))
624: || (y != Tk_Y(childPtr->tkwin))
625: || (width != Tk_Width(childPtr->tkwin))
626: || (height != Tk_Height(childPtr->tkwin))) {
627: Tk_MoveResizeWindow(childPtr->tkwin, x, y,
628: (unsigned int) width, (unsigned int) height);
629: }
630: if (abort) {
631: goto done;
632: }
633: Tk_MapWindow(childPtr->tkwin);
634: }
635:
636: /*
637: * Changes to the window's structure could cause almost anything
638: * to happen, including deleting the parent or child. If this
639: * happens, we'll be told to abort.
640: */
641:
642: if (abort) {
643: goto done;
644: }
645: }
646:
647: done:
648: parentPtr->abortPtr = NULL;
649: Tk_Release((ClientData) parentPtr);
650: }
651:
652: /*
653: *--------------------------------------------------------------
654: *
655: * GetPacker --
656: *
657: * This internal procedure is used to locate a Packer
658: * structure for a given window, creating one if one
659: * doesn't exist already.
660: *
661: * Results:
662: * The return value is a pointer to the Packer structure
663: * corresponding to tkwin.
664: *
665: * Side effects:
666: * A new packer structure may be created. If so, then
667: * a callback is set up to clean things up when the
668: * window is deleted.
669: *
670: *--------------------------------------------------------------
671: */
672:
673: static Packer *
674: GetPacker(tkwin)
675: Tk_Window tkwin; /* Token for window for which
676: * packer structure is desired. */
677: {
678: register Packer *packPtr;
679: Tcl_HashEntry *hPtr;
680: int new;
681:
682: if (!initialized) {
683: initialized = 1;
684: Tcl_InitHashTable(&packerHashTable, TCL_ONE_WORD_KEYS);
685: }
686:
687: /*
688: * See if there's already packer for this window. If not,
689: * then create a new one.
690: */
691:
692: hPtr = Tcl_CreateHashEntry(&packerHashTable, (char *) tkwin, &new);
693: if (!new) {
694: return (Packer *) Tcl_GetHashValue(hPtr);
695: }
696: packPtr = (Packer *) ckalloc(sizeof(Packer));
697: packPtr->tkwin = tkwin;
698: packPtr->parentPtr = NULL;
699: packPtr->nextPtr = NULL;
700: packPtr->childPtr = NULL;
701: packPtr->side = TOP;
702: packPtr->anchorPoint = TK_ANCHOR_CENTER;
703: packPtr->padX = packPtr->padY = 0;
704: packPtr->doubleBw = 2*Tk_Changes(tkwin)->border_width;
705: packPtr->abortPtr = NULL;
706: packPtr->flags = 0;
707: Tcl_SetHashValue(hPtr, packPtr);
708: Tk_CreateEventHandler(tkwin, StructureNotifyMask,
709: PackStructureProc, (ClientData) packPtr);
710: return packPtr;
711: }
712:
713: /*
714: *--------------------------------------------------------------
715: *
716: * PackAfter --
717: *
718: * This procedure does most of the real work of adding
719: * one or more windows into the packing order for its parent.
720: *
721: * Results:
722: * A standard Tcl return value.
723: *
724: * Side effects:
725: * The geometry of the specified windows may change, both now and
726: * again in the future.
727: *
728: *--------------------------------------------------------------
729: */
730:
731: static int
732: PackAfter(interp, prevPtr, parentPtr, argc, argv)
733: Tcl_Interp *interp; /* Interpreter for error reporting. */
734: Packer *prevPtr; /* Pack windows in argv just after this
735: * window; NULL means pack as first
736: * child of parentPtr. */
737: Packer *parentPtr; /* Parent in which to pack windows. */
738: int argc; /* Number of elements in argv. */
739: char **argv; /* Array of lists, each containing 2
740: * elements: window name and side
741: * against which to pack. */
742: {
743: register Packer *packPtr;
744: Tk_Window tkwin;
745: int length, optionCount;
746: char **options;
747: int index;
748: char c;
749:
750: /*
751: * Iterate over all of the window specifiers, each consisting of
752: * two arguments. The first argument contains the window name and
753: * the additional arguments contain options such as "top" or
754: * "padx 20".
755: */
756:
757: for ( ; argc > 0; argc -= 2, argv += 2, prevPtr = packPtr) {
758: if (argc < 2) {
759: Tcl_AppendResult(interp, "wrong # args: window \"",
760: argv[0], "\" should be followed by options",
761: (char *) NULL);
762: return TCL_ERROR;
763: }
764:
765: /*
766: * Find the packer for the window to be packed, and make sure
767: * that the window in which it will be packed is its parent.
768: */
769:
770: tkwin = Tk_NameToWindow(interp, argv[0], parentPtr->tkwin);
771: if (tkwin == NULL) {
772: return TCL_ERROR;
773: }
774: if (Tk_Parent(tkwin) != parentPtr->tkwin) {
775: Tcl_AppendResult(interp, "tried to pack \"",
776: argv[0], "\" in window that isn't its parent",
777: (char *) NULL);
778: return TCL_ERROR;
779: }
780: packPtr = GetPacker(tkwin);
781:
782: /*
783: * Process options for this window.
784: */
785:
786: if (Tcl_SplitList(interp, argv[1], &optionCount, &options) != TCL_OK) {
787: return TCL_ERROR;
788: }
789: packPtr->side = TOP;
790: packPtr->anchorPoint = TK_ANCHOR_CENTER;
791: packPtr->padX = packPtr->padY = 0;
792: packPtr->flags &= ~(FILLX|FILLY|EXPAND);
793: for (index = 0 ; index < optionCount; index++) {
794: char *curOpt = options[index];
795:
796: c = curOpt[0];
797: length = strlen(curOpt);
798:
799: if ((c == 't')
800: && (strncmp(curOpt, "top", length)) == 0) {
801: packPtr->side = TOP;
802: } else if ((c == 'b')
803: && (strncmp(curOpt, "bottom", length)) == 0) {
804: packPtr->side = BOTTOM;
805: } else if ((c == 'l')
806: && (strncmp(curOpt, "left", length)) == 0) {
807: packPtr->side = LEFT;
808: } else if ((c == 'r')
809: && (strncmp(curOpt, "right", length)) == 0) {
810: packPtr->side = RIGHT;
811: } else if ((c == 'e')
812: && (strncmp(curOpt, "expand", length)) == 0) {
813: packPtr->flags |= EXPAND;
814: } else if ((c == 'f')
815: && (strcmp(curOpt, "fill")) == 0) {
816: packPtr->flags |= FILLX|FILLY;
817: } else if ((length == 5) && (strcmp(curOpt, "fillx")) == 0) {
818: packPtr->flags |= FILLX;
819: } else if ((length == 5) && (strcmp(curOpt, "filly")) == 0) {
820: packPtr->flags |= FILLY;
821: } else if ((c == 'p') && (strcmp(curOpt, "padx")) == 0) {
822: if (optionCount < (index+2)) {
823: missingPad:
824: Tcl_AppendResult(interp, "wrong # args: \"", curOpt,
825: "\" option must be followed by count",
826: (char *) NULL);
827: goto error;
828: }
829: if ((Tcl_GetInt(interp, options[index+1], &packPtr->padX)
830: != TCL_OK) || (packPtr->padX < 0)) {
831: badPad:
832: Tcl_AppendResult(interp, "bad pad value \"",
833: options[index+1], "\": must be positive integer",
834: (char *) NULL);
835: goto error;
836: }
837: index++;
838: } else if ((c == 'p') && (strcmp(curOpt, "pady")) == 0) {
839: if (optionCount < (index+2)) {
840: goto missingPad;
841: }
842: if ((Tcl_GetInt(interp, options[index+1], &packPtr->padY)
843: != TCL_OK) || (packPtr->padY < 0)) {
844: goto badPad;
845: }
846: index++;
847: } else if ((c == 'f') && (length > 1)
848: && (strncmp(curOpt, "frame", length) == 0)) {
849: if (optionCount < (index+2)) {
850: Tcl_AppendResult(interp, "wrong # args: \"frame\" ",
851: "option must be followed by anchor point",
852: (char *) NULL);
853: goto error;
854: }
855: if (Tk_GetAnchor(interp, options[index+1],
856: &packPtr->anchorPoint) != TCL_OK) {
857: goto error;
858: }
859: index++;
860: } else {
861: Tcl_AppendResult(interp, "bad option \"", curOpt,
862: "\": should be top, bottom, left, right, ",
863: "expand, fill, fillx, filly, padx, pady, or frame",
864: (char *) NULL);
865: goto error;
866: }
867: }
868:
869: if (packPtr != prevPtr) {
870:
871: /*
872: * Unpack this window if it's currently packed.
873: */
874:
875: if (packPtr->parentPtr != NULL) {
876: Unlink(packPtr);
877: }
878:
879: /*
880: * Add the window in the correct place in its parent's
881: * packing order, then make sure that the window is
882: * managed by us.
883: */
884:
885: packPtr->parentPtr = parentPtr;
886: if (prevPtr == NULL) {
887: packPtr->nextPtr = parentPtr->childPtr;
888: parentPtr->childPtr = packPtr;
889: } else {
890: packPtr->nextPtr = prevPtr->nextPtr;
891: prevPtr->nextPtr = packPtr;
892: }
893: Tk_ManageGeometry(tkwin, PackReqProc, (ClientData) packPtr);
894: }
895: ckfree((char *) options);
896: }
897:
898: /*
899: * Arrange for the parent to be re-packed at the first
900: * idle moment.
901: */
902:
903: if (parentPtr->abortPtr != NULL) {
904: *parentPtr->abortPtr = 1;
905: }
906: if (!(parentPtr->flags & REQUESTED_REPACK)) {
907: parentPtr->flags |= REQUESTED_REPACK;
908: Tk_DoWhenIdle(ArrangePacking, (ClientData) parentPtr);
909: }
910: return TCL_OK;
911:
912: error:
913: ckfree((char *) options);
914: return TCL_ERROR;
915: }
916:
917: /*
918: *----------------------------------------------------------------------
919: *
920: * Unlink --
921: *
922: * Remove a packer from its parent's list of children.
923: *
924: * Results:
925: * None.
926: *
927: * Side effects:
928: * The parent will be scheduled for repacking.
929: *
930: *----------------------------------------------------------------------
931: */
932:
933: static void
934: Unlink(packPtr)
935: register Packer *packPtr; /* Window to unlink. */
936: {
937: register Packer *parentPtr, *packPtr2;
938:
939: parentPtr = packPtr->parentPtr;
940: if (parentPtr == NULL) {
941: return;
942: }
943: if (parentPtr->childPtr == packPtr) {
944: parentPtr->childPtr = packPtr->nextPtr;
945: } else {
946: for (packPtr2 = parentPtr->childPtr; ; packPtr2 = packPtr2->nextPtr) {
947: if (packPtr2 == NULL) {
948: panic("Unlink couldn't find previous window");
949: }
950: if (packPtr2->nextPtr == packPtr) {
951: packPtr2->nextPtr = packPtr->nextPtr;
952: break;
953: }
954: }
955: }
956: if (!(parentPtr->flags & REQUESTED_REPACK)) {
957: parentPtr->flags |= REQUESTED_REPACK;
958: Tk_DoWhenIdle(ArrangePacking, (ClientData) parentPtr);
959: }
960: if (parentPtr->abortPtr != NULL) {
961: *parentPtr->abortPtr = 1;
962: }
963:
964: packPtr->parentPtr = NULL;
965: }
966:
967: /*
968: *----------------------------------------------------------------------
969: *
970: * DestroyPacker --
971: *
972: * This procedure is invoked by Tk_EventuallyFree or Tk_Release
973: * to clean up the internal structure of a packer at a safe time
974: * (when no-one is using it anymore).
975: *
976: * Results:
977: * None.
978: *
979: * Side effects:
980: * Everything associated with the packer is freed up.
981: *
982: *----------------------------------------------------------------------
983: */
984:
985: static void
986: DestroyPacker(clientData)
987: ClientData clientData; /* Info about packed window that
988: * is now dead. */
989: {
990: register Packer *packPtr = (Packer *) clientData;
991: ckfree((char *) packPtr);
992: }
993:
994: /*
995: *----------------------------------------------------------------------
996: *
997: * PackStructureProc --
998: *
999: * This procedure is invoked by the Tk event dispatcher in response
1000: * to StructureNotify events.
1001: *
1002: * Results:
1003: * None.
1004: *
1005: * Side effects:
1006: * If a window was just deleted, clean up all its packer-related
1007: * information. If it was just resized, repack its children, if
1008: * any.
1009: *
1010: *----------------------------------------------------------------------
1011: */
1012:
1013: static void
1014: PackStructureProc(clientData, eventPtr)
1015: ClientData clientData; /* Our information about window
1016: * referred to by eventPtr. */
1017: XEvent *eventPtr; /* Describes what just happened. */
1018: {
1019: register Packer *packPtr = (Packer *) clientData;
1020: if (eventPtr->type == ConfigureNotify) {
1021: if ((packPtr->childPtr != NULL)
1022: && !(packPtr->flags & REQUESTED_REPACK)) {
1023: packPtr->flags |= REQUESTED_REPACK;
1024: Tk_DoWhenIdle(ArrangePacking, (ClientData) packPtr);
1025: }
1026: if (packPtr->doubleBw != 2*Tk_Changes(packPtr->tkwin)->border_width) {
1027: if ((packPtr->parentPtr != NULL)
1028: && !(packPtr->parentPtr->flags & REQUESTED_REPACK)) {
1029: packPtr->doubleBw = 2*Tk_Changes(packPtr->tkwin)->border_width;
1030: packPtr->parentPtr->flags |= REQUESTED_REPACK;
1031: Tk_DoWhenIdle(ArrangePacking, (ClientData) packPtr->parentPtr);
1032: }
1033: }
1034: } else if (eventPtr->type == DestroyNotify) {
1035: register Packer *packPtr2;
1036:
1037: if (packPtr->parentPtr != NULL) {
1038: Unlink(packPtr);
1039: }
1040: for (packPtr2 = packPtr->childPtr; packPtr2 != NULL;
1041: packPtr2 = packPtr2->nextPtr) {
1042: packPtr2->parentPtr = NULL;
1043: packPtr2->nextPtr = NULL;
1044: }
1045: Tcl_DeleteHashEntry(Tcl_FindHashEntry(&packerHashTable,
1046: (char *) packPtr->tkwin));
1047: if (packPtr->flags & REQUESTED_REPACK) {
1048: Tk_CancelIdleCall(ArrangePacking, (ClientData) packPtr);
1049: }
1050: packPtr->tkwin = NULL;
1051: Tk_EventuallyFree((ClientData) packPtr, DestroyPacker);
1052: }
1053: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.