![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tkmsg.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 tkmsg.c CVS log | Up to [Micropolis - Activity] / micropolis / src / tk |
1.1 ! root 1: /* ! 2: * tkMessage.c -- ! 3: * ! 4: * This module implements a message widgets for the Tk ! 5: * toolkit. A message widget displays a multi-line string ! 6: * in a window according to a particular aspect ratio. ! 7: * ! 8: * Copyright 1990 Regents of the University of California. ! 9: * Permission to use, copy, modify, and distribute this ! 10: * software and its documentation for any purpose and without ! 11: * fee is hereby granted, provided that the above copyright ! 12: * notice appear in all copies. The University of California ! 13: * makes no representations about the suitability of this ! 14: * software for any purpose. It is provided "as is" without ! 15: * express or implied warranty. ! 16: */ ! 17: ! 18: #ifndef lint ! 19: static char rcsid[] = "$Header: /user6/ouster/wish/RCS/tkMessage.c,v 1.36 92/06/08 11:06:05 ouster Exp $ SPRITE (Berkeley)"; ! 20: #endif ! 21: ! 22: #include "tkconfig.h" ! 23: #include "default.h" ! 24: #include "tkint.h" ! 25: ! 26: /* ! 27: * A data structure of the following type is kept for each message ! 28: * widget managed by this file: ! 29: */ ! 30: ! 31: typedef struct { ! 32: Tk_Window tkwin; /* Window that embodies the message. NULL ! 33: * means that the window has been destroyed ! 34: * but the data structures haven't yet been ! 35: * cleaned up.*/ ! 36: Tcl_Interp *interp; /* Interpreter associated with message. */ ! 37: Tk_Uid string; /* String displayed in message. */ ! 38: int numChars; /* Number of characters in string, not ! 39: * including terminating NULL character. */ ! 40: char *textVarName; /* Name of variable (malloc'ed) or NULL. ! 41: * If non-NULL, message displays the contents ! 42: * of this variable. */ ! 43: ! 44: /* ! 45: * Information used when displaying widget: ! 46: */ ! 47: ! 48: Tk_3DBorder border; /* Structure used to draw 3-D border and ! 49: * background. NULL means a border hasn't ! 50: * been created yet. */ ! 51: int borderWidth; /* Width of border. */ ! 52: int relief; /* 3-D effect: TK_RELIEF_RAISED, etc. */ ! 53: XFontStruct *fontPtr; /* Information about text font, or NULL. */ ! 54: XColor *fgColorPtr; /* Foreground color in normal mode. */ ! 55: GC textGC; /* GC for drawing text in normal mode. */ ! 56: int padX, padY; /* User-requested extra space around text. */ ! 57: Tk_Anchor anchor; /* Where to position text within window region ! 58: * if window is larger or smaller than ! 59: * needed. */ ! 60: int width; /* User-requested width, in pixels. 0 means ! 61: * compute width using aspect ratio below. */ ! 62: int aspect; /* Desired aspect ratio for window ! 63: * (100*width/height). */ ! 64: int lineLength; /* Length of each line, in pixels. Computed ! 65: * from width and/or aspect. */ ! 66: int msgHeight; /* Total number of pixels in vertical direction ! 67: * needed to display message. */ ! 68: Tk_Justify justify; /* Justification for text. */ ! 69: ! 70: /* ! 71: * Miscellaneous information: ! 72: */ ! 73: ! 74: Cursor cursor; /* Current cursor for window, or None. */ ! 75: int flags; /* Various flags; see below for ! 76: * definitions. */ ! 77: } Message; ! 78: ! 79: /* ! 80: * Flag bits for messages: ! 81: * ! 82: * REDRAW_PENDING: Non-zero means a DoWhenIdle handler ! 83: * has already been queued to redraw ! 84: * this window. ! 85: * CLEAR_NEEDED; Need to clear the window when redrawing. ! 86: */ ! 87: ! 88: #define REDRAW_PENDING 1 ! 89: #define CLEAR_NEEDED 2 ! 90: ! 91: /* ! 92: * Information used for argv parsing. ! 93: */ ! 94: ! 95: ! 96: static Tk_ConfigSpec configSpecs[] = { ! 97: {TK_CONFIG_ANCHOR, "-anchor", "anchor", "Anchor", ! 98: DEF_MESSAGE_ANCHOR, Tk_Offset(Message, anchor), 0}, ! 99: {TK_CONFIG_INT, "-aspect", "aspect", "Aspect", ! 100: DEF_MESSAGE_ASPECT, Tk_Offset(Message, aspect), 0}, ! 101: {TK_CONFIG_BORDER, "-background", "background", "Background", ! 102: DEF_MESSAGE_BG_COLOR, Tk_Offset(Message, border), ! 103: TK_CONFIG_COLOR_ONLY}, ! 104: {TK_CONFIG_BORDER, "-background", "background", "Background", ! 105: DEF_MESSAGE_BG_MONO, Tk_Offset(Message, border), ! 106: TK_CONFIG_MONO_ONLY}, ! 107: {TK_CONFIG_SYNONYM, "-bd", "borderWidth", (char *) NULL, ! 108: (char *) NULL, 0, 0}, ! 109: {TK_CONFIG_SYNONYM, "-bg", "background", (char *) NULL, ! 110: (char *) NULL, 0, 0}, ! 111: {TK_CONFIG_PIXELS, "-borderwidth", "borderWidth", "BorderWidth", ! 112: DEF_MESSAGE_BORDER_WIDTH, Tk_Offset(Message, borderWidth), 0}, ! 113: {TK_CONFIG_ACTIVE_CURSOR, "-cursor", "cursor", "Cursor", ! 114: DEF_MESSAGE_CURSOR, Tk_Offset(Message, cursor), TK_CONFIG_NULL_OK}, ! 115: {TK_CONFIG_SYNONYM, "-fg", "foreground", (char *) NULL, ! 116: (char *) NULL, 0, 0}, ! 117: {TK_CONFIG_FONT, "-font", "font", "Font", ! 118: DEF_MESSAGE_FONT, Tk_Offset(Message, fontPtr), 0}, ! 119: {TK_CONFIG_COLOR, "-foreground", "foreground", "Foreground", ! 120: DEF_MESSAGE_FG, Tk_Offset(Message, fgColorPtr), 0}, ! 121: {TK_CONFIG_JUSTIFY, "-justify", "justify", "Justify", ! 122: DEF_MESSAGE_JUSTIFY, Tk_Offset(Message, justify), 0}, ! 123: {TK_CONFIG_PIXELS, "-padx", "padX", "Pad", ! 124: DEF_MESSAGE_PADX, Tk_Offset(Message, padX), 0}, ! 125: {TK_CONFIG_PIXELS, "-pady", "padY", "Pad", ! 126: DEF_MESSAGE_PADY, Tk_Offset(Message, padY), 0}, ! 127: {TK_CONFIG_RELIEF, "-relief", "relief", "Relief", ! 128: DEF_MESSAGE_RELIEF, Tk_Offset(Message, relief), 0}, ! 129: {TK_CONFIG_STRING, "-text", "text", "Text", ! 130: DEF_MESSAGE_TEXT, Tk_Offset(Message, string), 0}, ! 131: {TK_CONFIG_STRING, "-textvariable", "textVariable", "Variable", ! 132: DEF_MESSAGE_TEXT_VARIABLE, Tk_Offset(Message, textVarName), ! 133: TK_CONFIG_NULL_OK}, ! 134: {TK_CONFIG_PIXELS, "-width", "width", "Width", ! 135: DEF_MESSAGE_WIDTH, Tk_Offset(Message, width), 0}, ! 136: {TK_CONFIG_END, (char *) NULL, (char *) NULL, (char *) NULL, ! 137: (char *) NULL, 0, 0} ! 138: }; ! 139: ! 140: /* ! 141: * Forward declarations for procedures defined later in this file: ! 142: */ ! 143: ! 144: static void MessageEventProc _ANSI_ARGS_((ClientData clientData, ! 145: XEvent *eventPtr)); ! 146: static char * MessageTextVarProc _ANSI_ARGS_((ClientData clientData, ! 147: Tcl_Interp *interp, char *name1, char *name2, ! 148: int flags)); ! 149: static int MessageWidgetCmd _ANSI_ARGS_((ClientData clientData, ! 150: Tcl_Interp *interp, int argc, char **argv)); ! 151: static void ComputeMessageGeometry _ANSI_ARGS_((Message *msgPtr)); ! 152: static int ConfigureMessage _ANSI_ARGS_((Tcl_Interp *interp, ! 153: Message *msgPtr, int argc, char **argv, ! 154: int flags)); ! 155: static void DestroyMessage _ANSI_ARGS_((ClientData clientData)); ! 156: static void DisplayMessage _ANSI_ARGS_((ClientData clientData)); ! 157: ! 158: /* ! 159: *-------------------------------------------------------------- ! 160: * ! 161: * Tk_MessageCmd -- ! 162: * ! 163: * This procedure is invoked to process the "message" Tcl ! 164: * command. See the user documentation for details on what ! 165: * it does. ! 166: * ! 167: * Results: ! 168: * A standard Tcl result. ! 169: * ! 170: * Side effects: ! 171: * See the user documentation. ! 172: * ! 173: *-------------------------------------------------------------- ! 174: */ ! 175: ! 176: int ! 177: Tk_MessageCmd(clientData, interp, argc, argv) ! 178: ClientData clientData; /* Main window associated with ! 179: * interpreter. */ ! 180: Tcl_Interp *interp; /* Current interpreter. */ ! 181: int argc; /* Number of arguments. */ ! 182: char **argv; /* Argument strings. */ ! 183: { ! 184: register Message *msgPtr; ! 185: Tk_Window new; ! 186: Tk_Window tkwin = (Tk_Window) clientData; ! 187: ! 188: if (argc < 2) { ! 189: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 190: argv[0], " pathName ?options?\"", (char *) NULL); ! 191: return TCL_ERROR; ! 192: } ! 193: ! 194: new = Tk_CreateWindowFromPath(interp, tkwin, argv[1], (char *) NULL); ! 195: if (new == NULL) { ! 196: return TCL_ERROR; ! 197: } ! 198: ! 199: msgPtr = (Message *) ckalloc(sizeof(Message)); ! 200: msgPtr->tkwin = new; ! 201: msgPtr->interp = interp; ! 202: msgPtr->string = NULL; ! 203: msgPtr->textVarName = NULL; ! 204: msgPtr->border = NULL; ! 205: msgPtr->borderWidth = 0; ! 206: msgPtr->relief = TK_RELIEF_FLAT; ! 207: msgPtr->fontPtr = NULL; ! 208: msgPtr->fgColorPtr = NULL; ! 209: msgPtr->textGC = NULL; ! 210: msgPtr->padX = 0; ! 211: msgPtr->padY = 0; ! 212: msgPtr->width = 0; ! 213: msgPtr->aspect = 150; ! 214: msgPtr->justify = TK_JUSTIFY_LEFT; ! 215: msgPtr->cursor = None; ! 216: msgPtr->flags = 0; ! 217: ! 218: Tk_SetClass(msgPtr->tkwin, "Message"); ! 219: Tk_CreateEventHandler(msgPtr->tkwin, ExposureMask|StructureNotifyMask, ! 220: MessageEventProc, (ClientData) msgPtr); ! 221: Tcl_CreateCommand(interp, Tk_PathName(msgPtr->tkwin), MessageWidgetCmd, ! 222: (ClientData) msgPtr, (void (*)()) NULL); ! 223: if (ConfigureMessage(interp, msgPtr, argc-2, argv+2, 0) != TCL_OK) { ! 224: goto error; ! 225: } ! 226: ! 227: interp->result = Tk_PathName(msgPtr->tkwin); ! 228: return TCL_OK; ! 229: ! 230: error: ! 231: Tk_DestroyWindow(msgPtr->tkwin); ! 232: return TCL_ERROR; ! 233: } ! 234: ! 235: /* ! 236: *-------------------------------------------------------------- ! 237: * ! 238: * MessageWidgetCmd -- ! 239: * ! 240: * This procedure is invoked to process the Tcl command ! 241: * that corresponds to a widget managed by this module. ! 242: * See the user documentation for details on what it does. ! 243: * ! 244: * Results: ! 245: * A standard Tcl result. ! 246: * ! 247: * Side effects: ! 248: * See the user documentation. ! 249: * ! 250: *-------------------------------------------------------------- ! 251: */ ! 252: ! 253: static int ! 254: MessageWidgetCmd(clientData, interp, argc, argv) ! 255: ClientData clientData; /* Information about message widget. */ ! 256: Tcl_Interp *interp; /* Current interpreter. */ ! 257: int argc; /* Number of arguments. */ ! 258: char **argv; /* Argument strings. */ ! 259: { ! 260: register Message *msgPtr = (Message *) clientData; ! 261: int length; ! 262: char c; ! 263: ! 264: if (argc < 2) { ! 265: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], ! 266: " option ?arg arg ...?\"", (char *) NULL); ! 267: return TCL_ERROR; ! 268: } ! 269: c = argv[1][0]; ! 270: length = strlen(argv[1]); ! 271: if ((c == 'c') && (strncmp(argv[1], "configure", length) == 0)) { ! 272: if (argc == 2) { ! 273: return Tk_ConfigureInfo(interp, msgPtr->tkwin, configSpecs, ! 274: (char *) msgPtr, (char *) NULL, 0); ! 275: } else if (argc == 3) { ! 276: return Tk_ConfigureInfo(interp, msgPtr->tkwin, configSpecs, ! 277: (char *) msgPtr, argv[2], 0); ! 278: } else { ! 279: return ConfigureMessage(interp, msgPtr, argc-2, argv+2, ! 280: TK_CONFIG_ARGV_ONLY); ! 281: } ! 282: } else { ! 283: Tcl_AppendResult(interp, "bad option \"", argv[1], ! 284: "\": must be configure", (char *) NULL); ! 285: return TCL_ERROR; ! 286: } ! 287: } ! 288: ! 289: /* ! 290: *---------------------------------------------------------------------- ! 291: * ! 292: * DestroyMessage -- ! 293: * ! 294: * This procedure is invoked by Tk_EventuallyFree or Tk_Release ! 295: * to clean up the internal structure of a message at a safe time ! 296: * (when no-one is using it anymore). ! 297: * ! 298: * Results: ! 299: * None. ! 300: * ! 301: * Side effects: ! 302: * Everything associated with the message is freed up. ! 303: * ! 304: *---------------------------------------------------------------------- ! 305: */ ! 306: ! 307: static void ! 308: DestroyMessage(clientData) ! 309: ClientData clientData; /* Info about message widget. */ ! 310: { ! 311: register Message *msgPtr = (Message *) clientData; ! 312: ! 313: if (msgPtr->string != NULL) { ! 314: ckfree(msgPtr->string); ! 315: } ! 316: if (msgPtr->textVarName != NULL) { ! 317: Tcl_UntraceVar(msgPtr->interp, msgPtr->textVarName, ! 318: TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS, ! 319: MessageTextVarProc, (ClientData) msgPtr); ! 320: ckfree(msgPtr->textVarName); ! 321: } ! 322: if (msgPtr->border != NULL) { ! 323: Tk_Free3DBorder(msgPtr->border); ! 324: } ! 325: if (msgPtr->fontPtr != NULL) { ! 326: Tk_FreeFontStruct(msgPtr->fontPtr); ! 327: } ! 328: if (msgPtr->fgColorPtr != NULL) { ! 329: Tk_FreeColor(msgPtr->fgColorPtr); ! 330: } ! 331: if (msgPtr->textGC != None) { ! 332: Tk_FreeGC(msgPtr->textGC); ! 333: } ! 334: if (msgPtr->cursor != None) { ! 335: Tk_FreeCursor(msgPtr->cursor); ! 336: } ! 337: ckfree((char *) msgPtr); ! 338: } ! 339: ! 340: /* ! 341: *---------------------------------------------------------------------- ! 342: * ! 343: * ConfigureMessage -- ! 344: * ! 345: * This procedure is called to process an argv/argc list, plus ! 346: * the Tk option database, in order to configure (or ! 347: * reconfigure) a message widget. ! 348: * ! 349: * Results: ! 350: * The return value is a standard Tcl result. If TCL_ERROR is ! 351: * returned, then interp->result contains an error message. ! 352: * ! 353: * Side effects: ! 354: * Configuration information, such as text string, colors, font, ! 355: * etc. get set for msgPtr; old resources get freed, if there ! 356: * were any. ! 357: * ! 358: *---------------------------------------------------------------------- ! 359: */ ! 360: ! 361: static int ! 362: ConfigureMessage(interp, msgPtr, argc, argv, flags) ! 363: Tcl_Interp *interp; /* Used for error reporting. */ ! 364: register Message *msgPtr; /* Information about widget; may or may ! 365: * not already have values for some fields. */ ! 366: int argc; /* Number of valid entries in argv. */ ! 367: char **argv; /* Arguments. */ ! 368: int flags; /* Flags to pass to Tk_ConfigureWidget. */ ! 369: { ! 370: XGCValues gcValues; ! 371: GC newGC; ! 372: ! 373: /* ! 374: * Eliminate any existing trace on a variable monitored by the message. ! 375: */ ! 376: ! 377: if (msgPtr->textVarName != NULL) { ! 378: Tcl_UntraceVar(interp, msgPtr->textVarName, ! 379: TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS, ! 380: MessageTextVarProc, (ClientData) msgPtr); ! 381: } ! 382: ! 383: if (Tk_ConfigureWidget(interp, msgPtr->tkwin, configSpecs, ! 384: argc, argv, (char *) msgPtr, flags) != TCL_OK) { ! 385: return TCL_ERROR; ! 386: } ! 387: ! 388: /* ! 389: * If the message is to display the value of a variable, then set up ! 390: * a trace on the variable's value, create the variable if it doesn't ! 391: * exist, and fetch its current value. ! 392: */ ! 393: ! 394: if (msgPtr->textVarName != NULL) { ! 395: char *value; ! 396: ! 397: value = Tcl_GetVar(interp, msgPtr->textVarName, TCL_GLOBAL_ONLY); ! 398: if (value == NULL) { ! 399: Tcl_SetVar(interp, msgPtr->textVarName, msgPtr->string, ! 400: TCL_GLOBAL_ONLY); ! 401: } else { ! 402: if (msgPtr->string != NULL) { ! 403: ckfree(msgPtr->string); ! 404: } ! 405: msgPtr->string = ckalloc((unsigned) (strlen(value) + 1)); ! 406: strcpy(msgPtr->string, value); ! 407: } ! 408: Tcl_TraceVar(interp, msgPtr->textVarName, ! 409: TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS, ! 410: MessageTextVarProc, (ClientData) msgPtr); ! 411: } ! 412: ! 413: /* ! 414: * A few other options need special processing, such as setting ! 415: * the background from a 3-D border or handling special defaults ! 416: * that couldn't be specified to Tk_ConfigureWidget. ! 417: */ ! 418: ! 419: msgPtr->numChars = strlen(msgPtr->string); ! 420: ! 421: Tk_SetBackgroundFromBorder(msgPtr->tkwin, msgPtr->border); ! 422: ! 423: gcValues.font = msgPtr->fontPtr->fid; ! 424: gcValues.foreground = msgPtr->fgColorPtr->pixel; ! 425: newGC = Tk_GetGC(msgPtr->tkwin, GCForeground|GCFont, ! 426: &gcValues); ! 427: if (msgPtr->textGC != None) { ! 428: Tk_FreeGC(msgPtr->textGC); ! 429: } ! 430: msgPtr->textGC = newGC; ! 431: ! 432: if (msgPtr->padX == -1) { ! 433: msgPtr->padX = msgPtr->fontPtr->ascent/2; ! 434: } ! 435: ! 436: if (msgPtr->padY == -1) { ! 437: msgPtr->padY = msgPtr->fontPtr->ascent/4; ! 438: } ! 439: ! 440: if (msgPtr->justify == TK_JUSTIFY_FILL) { ! 441: interp->result = "can't use \"fill\" justify style in messages"; ! 442: return TCL_ERROR; ! 443: } ! 444: ! 445: /* ! 446: * Recompute the desired geometry for the window, and arrange for ! 447: * the window to be redisplayed. ! 448: */ ! 449: ! 450: ComputeMessageGeometry(msgPtr); ! 451: if ((msgPtr->tkwin != NULL) && Tk_IsMapped(msgPtr->tkwin) ! 452: && !(msgPtr->flags & REDRAW_PENDING)) { ! 453: Tk_DoWhenIdle(DisplayMessage, (ClientData) msgPtr); ! 454: msgPtr->flags |= REDRAW_PENDING|CLEAR_NEEDED; ! 455: } ! 456: ! 457: return TCL_OK; ! 458: } ! 459: ! 460: /* ! 461: *-------------------------------------------------------------- ! 462: * ! 463: * ComputeMessageGeometry -- ! 464: * ! 465: * Compute the desired geometry for a message window, ! 466: * taking into account the desired aspect ratio for the ! 467: * window. ! 468: * ! 469: * Results: ! 470: * None. ! 471: * ! 472: * Side effects: ! 473: * Tk_GeometryRequest is called to inform the geometry ! 474: * manager of the desired geometry for this window. ! 475: * ! 476: *-------------------------------------------------------------- ! 477: */ ! 478: ! 479: static void ! 480: ComputeMessageGeometry(msgPtr) ! 481: register Message *msgPtr; /* Information about window. */ ! 482: { ! 483: char *p; ! 484: int width, inc, height, numLines; ! 485: int thisWidth, maxWidth; ! 486: int aspect, lowerBound, upperBound; ! 487: ! 488: /* ! 489: * Compute acceptable bounds for the final aspect ratio. ! 490: */ ! 491: aspect = msgPtr->aspect/10; ! 492: if (aspect < 5) { ! 493: aspect = 5; ! 494: } ! 495: lowerBound = msgPtr->aspect - aspect; ! 496: upperBound = msgPtr->aspect + aspect; ! 497: ! 498: /* ! 499: * Do the computation in multiple passes: start off with ! 500: * a very wide window, and compute its height. Then change ! 501: * the width and try again. Reduce the size of the change ! 502: * and iterate until dimensions are found that approximate ! 503: * the desired aspect ratio. Or, if the user gave an explicit ! 504: * width then just use that. ! 505: */ ! 506: ! 507: if (msgPtr->width > 0) { ! 508: width = msgPtr->width; ! 509: inc = 0; ! 510: } else { ! 511: width = WidthOfScreen(Tk_Screen(msgPtr->tkwin))/2; ! 512: inc = width/2; ! 513: } ! 514: for ( ; ; inc /= 2) { ! 515: maxWidth = 0; ! 516: for (numLines = 1, p = msgPtr->string; ; numLines++) { ! 517: if (*p == '\n') { ! 518: p++; ! 519: continue; ! 520: } ! 521: p += TkMeasureChars(msgPtr->fontPtr, p, ! 522: msgPtr->numChars - (p - msgPtr->string), 0, width, ! 523: TK_WHOLE_WORDS|TK_AT_LEAST_ONE, &thisWidth); ! 524: if (thisWidth > maxWidth) { ! 525: maxWidth = thisWidth; ! 526: } ! 527: if (*p == 0) { ! 528: break; ! 529: } ! 530: ! 531: /* ! 532: * Skip spaces and tabs at the beginning of a line, unless ! 533: * they follow a user-requested newline. ! 534: */ ! 535: ! 536: while (isspace(*p)) { ! 537: if (*p == '\n') { ! 538: p++; ! 539: break; ! 540: } ! 541: p++; ! 542: } ! 543: } ! 544: ! 545: height = numLines * (msgPtr->fontPtr->ascent ! 546: + msgPtr->fontPtr->descent) + 2*msgPtr->borderWidth ! 547: + 2*msgPtr->padY; ! 548: if (inc <= 2) { ! 549: break; ! 550: } ! 551: aspect = (100*(maxWidth + 2*msgPtr->borderWidth ! 552: + 2*msgPtr->padX))/height; ! 553: if (aspect < lowerBound) { ! 554: width += inc; ! 555: } else if (aspect > upperBound) { ! 556: width -= inc; ! 557: } else { ! 558: break; ! 559: } ! 560: } ! 561: msgPtr->lineLength = maxWidth; ! 562: msgPtr->msgHeight = numLines * (msgPtr->fontPtr->ascent ! 563: + msgPtr->fontPtr->descent); ! 564: Tk_GeometryRequest(msgPtr->tkwin, ! 565: maxWidth + 2*msgPtr->borderWidth + 2*msgPtr->padX, height); ! 566: Tk_SetInternalBorder(msgPtr->tkwin, msgPtr->borderWidth); ! 567: } ! 568: ! 569: /* ! 570: *-------------------------------------------------------------- ! 571: * ! 572: * DisplayMessage -- ! 573: * ! 574: * This procedure redraws the contents of a message window. ! 575: * ! 576: * Results: ! 577: * None. ! 578: * ! 579: * Side effects: ! 580: * Information appears on the screen. ! 581: * ! 582: *-------------------------------------------------------------- ! 583: */ ! 584: ! 585: static void ! 586: DisplayMessage(clientData) ! 587: ClientData clientData; /* Information about window. */ ! 588: { ! 589: register Message *msgPtr = (Message *) clientData; ! 590: register Tk_Window tkwin = msgPtr->tkwin; ! 591: char *p; ! 592: int x, y, lineLength, numChars, charsLeft; ! 593: ! 594: msgPtr->flags &= ~REDRAW_PENDING; ! 595: if ((msgPtr->tkwin == NULL) || !Tk_IsMapped(tkwin)) { ! 596: return; ! 597: } ! 598: if (msgPtr->flags & CLEAR_NEEDED) { ! 599: XClearWindow(Tk_Display(tkwin), Tk_WindowId(tkwin)); ! 600: msgPtr->flags &= ~CLEAR_NEEDED; ! 601: } ! 602: ! 603: /* ! 604: * Compute starting y-location for message based on message size ! 605: * and anchor option. ! 606: */ ! 607: ! 608: switch (msgPtr->anchor) { ! 609: case TK_ANCHOR_NW: case TK_ANCHOR_N: case TK_ANCHOR_NE: ! 610: y = msgPtr->borderWidth + msgPtr->padY; ! 611: break; ! 612: case TK_ANCHOR_W: case TK_ANCHOR_CENTER: case TK_ANCHOR_E: ! 613: y = (Tk_Height(tkwin) - msgPtr->msgHeight)/2; ! 614: break; ! 615: default: ! 616: y = Tk_Height(tkwin) - msgPtr->borderWidth - msgPtr->padY ! 617: - msgPtr->msgHeight; ! 618: break; ! 619: } ! 620: y += msgPtr->fontPtr->ascent; ! 621: ! 622: /* ! 623: * Work through the string to display one line at a time. ! 624: * Display each line in three steps. First compute the ! 625: * line's width, then figure out where to display the ! 626: * line to justify it properly, then display the line. ! 627: */ ! 628: ! 629: for (p = msgPtr->string, charsLeft = msgPtr->numChars; *p != 0; ! 630: y += msgPtr->fontPtr->ascent + msgPtr->fontPtr->descent) { ! 631: if (*p == '\n') { ! 632: p++; ! 633: charsLeft--; ! 634: continue; ! 635: } ! 636: numChars = TkMeasureChars(msgPtr->fontPtr, p, charsLeft, 0, ! 637: msgPtr->lineLength, TK_WHOLE_WORDS|TK_AT_LEAST_ONE, ! 638: &lineLength); ! 639: switch (msgPtr->anchor) { ! 640: case TK_ANCHOR_NW: case TK_ANCHOR_W: case TK_ANCHOR_SW: ! 641: x = msgPtr->borderWidth + msgPtr->padX; ! 642: break; ! 643: case TK_ANCHOR_N: case TK_ANCHOR_CENTER: case TK_ANCHOR_S: ! 644: x = (Tk_Width(tkwin) - msgPtr->lineLength)/2; ! 645: break; ! 646: default: ! 647: x = Tk_Width(tkwin) - msgPtr->borderWidth - msgPtr->padX ! 648: - msgPtr->lineLength; ! 649: break; ! 650: } ! 651: if (msgPtr->justify == TK_JUSTIFY_CENTER) { ! 652: x += (msgPtr->lineLength - lineLength)/2; ! 653: } else if (msgPtr->justify == TK_JUSTIFY_RIGHT) { ! 654: x += msgPtr->lineLength - lineLength; ! 655: } ! 656: TkDisplayChars(Tk_Display(tkwin), Tk_WindowId(tkwin), ! 657: msgPtr->textGC, msgPtr->fontPtr, p, numChars, x, y, 0); ! 658: p += numChars; ! 659: charsLeft -= numChars; ! 660: ! 661: /* ! 662: * Skip blanks at the beginning of a line, unless they follow ! 663: * a user-requested newline. ! 664: */ ! 665: ! 666: while (isspace(*p)) { ! 667: charsLeft--; ! 668: if (*p == '\n') { ! 669: p++; ! 670: break; ! 671: } ! 672: p++; ! 673: } ! 674: } ! 675: ! 676: if (msgPtr->relief != TK_RELIEF_FLAT) { ! 677: Tk_Draw3DRectangle(Tk_Display(tkwin), Tk_WindowId(tkwin), ! 678: msgPtr->border, 0, 0, Tk_Width(tkwin), Tk_Height(tkwin), ! 679: msgPtr->borderWidth, msgPtr->relief); ! 680: } ! 681: } ! 682: ! 683: /* ! 684: *-------------------------------------------------------------- ! 685: * ! 686: * MessageEventProc -- ! 687: * ! 688: * This procedure is invoked by the Tk dispatcher for various ! 689: * events on messages. ! 690: * ! 691: * Results: ! 692: * None. ! 693: * ! 694: * Side effects: ! 695: * When the window gets deleted, internal structures get ! 696: * cleaned up. When it gets exposed, it is redisplayed. ! 697: * ! 698: *-------------------------------------------------------------- ! 699: */ ! 700: ! 701: static void ! 702: MessageEventProc(clientData, eventPtr) ! 703: ClientData clientData; /* Information about window. */ ! 704: XEvent *eventPtr; /* Information about event. */ ! 705: { ! 706: Message *msgPtr = (Message *) clientData; ! 707: ! 708: if ((eventPtr->type == Expose) && (eventPtr->xexpose.count == 0)) { ! 709: if ((msgPtr->tkwin != NULL) && !(msgPtr->flags & REDRAW_PENDING)) { ! 710: Tk_DoWhenIdle(DisplayMessage, (ClientData) msgPtr); ! 711: msgPtr->flags |= REDRAW_PENDING; ! 712: } ! 713: } else if (eventPtr->type == DestroyNotify) { ! 714: Tcl_DeleteCommand(msgPtr->interp, Tk_PathName(msgPtr->tkwin)); ! 715: msgPtr->tkwin = NULL; ! 716: if (msgPtr->flags & REDRAW_PENDING) { ! 717: Tk_CancelIdleCall(DisplayMessage, (ClientData) msgPtr); ! 718: } ! 719: Tk_EventuallyFree((ClientData) msgPtr, DestroyMessage); ! 720: } ! 721: } ! 722: ! 723: /* ! 724: *-------------------------------------------------------------- ! 725: * ! 726: * MessageTextVarProc -- ! 727: * ! 728: * This procedure is invoked when someone changes the variable ! 729: * whose contents are to be displayed in a message. ! 730: * ! 731: * Results: ! 732: * NULL is always returned. ! 733: * ! 734: * Side effects: ! 735: * The text displayed in the message will change to match the ! 736: * variable. ! 737: * ! 738: *-------------------------------------------------------------- ! 739: */ ! 740: ! 741: /* ARGSUSED */ ! 742: static char * ! 743: MessageTextVarProc(clientData, interp, name1, name2, flags) ! 744: ClientData clientData; /* Information about message. */ ! 745: Tcl_Interp *interp; /* Interpreter containing variable. */ ! 746: char *name1; /* Name of variable. */ ! 747: char *name2; /* Second part of variable name. */ ! 748: int flags; /* Information about what happened. */ ! 749: { ! 750: register Message *msgPtr = (Message *) clientData; ! 751: char *value; ! 752: ! 753: /* ! 754: * If the variable is unset, then immediately recreate it unless ! 755: * the whole interpreter is going away. ! 756: */ ! 757: ! 758: if (flags & TCL_TRACE_UNSETS) { ! 759: if ((flags & TCL_TRACE_DESTROYED) && !(flags & TCL_INTERP_DESTROYED)) { ! 760: Tcl_SetVar2(interp, name1, name2, msgPtr->string, ! 761: flags & TCL_GLOBAL_ONLY); ! 762: Tcl_TraceVar2(interp, name1, name2, ! 763: TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS, ! 764: MessageTextVarProc, clientData); ! 765: } ! 766: return (char *) NULL; ! 767: } ! 768: ! 769: value = Tcl_GetVar2(interp, name1, name2, flags & TCL_GLOBAL_ONLY); ! 770: if (value == NULL) { ! 771: value = ""; ! 772: } ! 773: if (msgPtr->string != NULL) { ! 774: ckfree(msgPtr->string); ! 775: } ! 776: msgPtr->numChars = strlen(value); ! 777: msgPtr->string = ckalloc((unsigned) (msgPtr->numChars + 1)); ! 778: strcpy(msgPtr->string, value); ! 779: ComputeMessageGeometry(msgPtr); ! 780: ! 781: msgPtr->flags |= CLEAR_NEEDED; ! 782: if ((msgPtr->tkwin != NULL) && Tk_IsMapped(msgPtr->tkwin) ! 783: && !(msgPtr->flags & REDRAW_PENDING)) { ! 784: Tk_DoWhenIdle(DisplayMessage, (ClientData) msgPtr); ! 785: msgPtr->flags |= REDRAW_PENDING; ! 786: } ! 787: return (char *) NULL; ! 788: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.