![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tkfont.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 tkfont.c CVS log | Up to [Micropolis - Activity] / micropolis / src / tk |
1.1 ! root 1: /* ! 2: * tkFont.c -- ! 3: * ! 4: * This file maintains a database of looked-up fonts for the Tk ! 5: * toolkit, in order to avoid round-trips to the server to map ! 6: * font names to XFontStructs. ! 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/tkFont.c,v 1.21 92/06/15 14:00:19 ouster Exp $ SPRITE (Berkeley)"; ! 20: #endif ! 21: ! 22: #include "tkconfig.h" ! 23: #include "tkint.h" ! 24: ! 25: /* ! 26: * This module caches extra information about fonts in addition to ! 27: * what X already provides. The extra information is used by the ! 28: * TkMeasureChars procedure, and consists of two parts: a type and ! 29: * a width. The type is one of the following: ! 30: * ! 31: * NORMAL: Standard character. ! 32: * TAB: Tab character: output enough space to ! 33: * get to next tab stop. ! 34: * NEWLINE: Newline character: don't output anything more ! 35: * on this line (character has infinite width). ! 36: * REPLACE: This character doesn't print: instead of ! 37: * displaying character, display a replacement ! 38: * sequence of the form "\xdd" where dd is the ! 39: * hex equivalent of the character. ! 40: * SKIP: Don't display anything for this character. This ! 41: * is only used where the font doesn't contain ! 42: * all the characters needed to generate ! 43: * replacement sequences. ! 44: * The width gives the total width of the displayed character or ! 45: * sequence: for replacement sequences, it gives the width of the ! 46: * sequence. ! 47: */ ! 48: ! 49: #define NORMAL 1 ! 50: #define TAB 2 ! 51: #define NEWLINE 3 ! 52: #define REPLACE 4 ! 53: #define SKIP 5 ! 54: ! 55: /* ! 56: * One of the following data structures exists for each font that is ! 57: * currently active. The structure is indexed with two hash tables, ! 58: * one based on font name and one based on XFontStruct address. ! 59: */ ! 60: ! 61: typedef struct { ! 62: XFontStruct *fontStructPtr; /* X information about font. */ ! 63: Display *display; /* Display to which font belongs. */ ! 64: int refCount; /* Number of active uses of this font. */ ! 65: char *types; /* Malloc'ed array giving types of all ! 66: * chars in the font (may be NULL). */ ! 67: unsigned char *widths; /* Malloc'ed array giving widths of all ! 68: * chars in the font (may be NULL). */ ! 69: int tabWidth; /* Width of tabs in this font. */ ! 70: Tcl_HashEntry *nameHashPtr; /* Entry in name-based hash table (needed ! 71: * when deleting this structure). */ ! 72: } TkFont; ! 73: ! 74: /* ! 75: * Hash table for name -> TkFont mapping, and key structure used to ! 76: * index into that table: ! 77: */ ! 78: ! 79: static Tcl_HashTable nameTable; ! 80: typedef struct { ! 81: Tk_Uid name; /* Name of font. */ ! 82: Display *display; /* Display for which font is valid. */ ! 83: } NameKey; ! 84: ! 85: /* ! 86: * Hash table for font struct -> TkFont mapping. This table is ! 87: * indexed by the XFontStruct address. ! 88: */ ! 89: ! 90: static Tcl_HashTable fontTable; ! 91: ! 92: static int initialized = 0; /* 0 means static structures haven't been ! 93: * initialized yet. */ ! 94: ! 95: /* ! 96: * To speed up TkMeasureChars, the variables below keep the last ! 97: * mapping from (XFontStruct *) to (TkFont *). ! 98: */ ! 99: ! 100: static TkFont *lastFontPtr = NULL; ! 101: static XFontStruct *lastFontStructPtr = NULL; ! 102: ! 103: /* ! 104: * Characters used when displaying control sequences as their ! 105: * hex equivalents. ! 106: */ ! 107: ! 108: static char hexChars[] = "0123456789abcdefx\\"; ! 109: ! 110: /* ! 111: * Forward declarations for procedures defined in this file: ! 112: */ ! 113: ! 114: static void FontInit _ANSI_ARGS_((void)); ! 115: static void SetFontMetrics _ANSI_ARGS_((TkFont *fontPtr)); ! 116: ! 117: /* ! 118: *---------------------------------------------------------------------- ! 119: * ! 120: * Tk_GetFontStruct -- ! 121: * ! 122: * Given a string name for a font, map the name to an XFontStruct ! 123: * describing the font. ! 124: * ! 125: * Results: ! 126: * The return value is normally a pointer to the font description ! 127: * for the desired font. If an error occurs in mapping the string ! 128: * to a font, then an error message will be left in interp->result ! 129: * and NULL will be returned. ! 130: * ! 131: * Side effects: ! 132: * The font is added to an internal database with a reference count. ! 133: * For each call to this procedure, there should eventually be a call ! 134: * to Tk_FreeFontStruct, so that the database is cleaned up when fonts ! 135: * aren't in use anymore. ! 136: * ! 137: *---------------------------------------------------------------------- ! 138: */ ! 139: ! 140: XFontStruct * ! 141: Tk_GetFontStruct(interp, tkwin, name) ! 142: Tcl_Interp *interp; /* Place to leave error message if ! 143: * font can't be found. */ ! 144: Tk_Window tkwin; /* Window in which font will be used. */ ! 145: Tk_Uid name; /* Name of font (in form suitable for ! 146: * passing to XLoadQueryFont). */ ! 147: { ! 148: NameKey nameKey; ! 149: Tcl_HashEntry *nameHashPtr, *fontHashPtr; ! 150: int new; ! 151: register TkFont *fontPtr; ! 152: XFontStruct *fontStructPtr; ! 153: ! 154: if (!initialized) { ! 155: FontInit(); ! 156: } ! 157: ! 158: /* ! 159: * First, check to see if there's already a mapping for this font ! 160: * name. ! 161: */ ! 162: ! 163: nameKey.name = name; ! 164: nameKey.display = Tk_Display(tkwin); ! 165: nameHashPtr = Tcl_CreateHashEntry(&nameTable, (char *) &nameKey, &new); ! 166: if (!new) { ! 167: fontPtr = (TkFont *) Tcl_GetHashValue(nameHashPtr); ! 168: fontPtr->refCount++; ! 169: return fontPtr->fontStructPtr; ! 170: } ! 171: ! 172: /* ! 173: * The name isn't currently known. Map from the name to a font, and ! 174: * add a new structure to the database. ! 175: */ ! 176: ! 177: fontStructPtr = XLoadQueryFont(nameKey.display, name); ! 178: if (fontStructPtr == NULL) { ! 179: Tcl_DeleteHashEntry(nameHashPtr); ! 180: Tcl_AppendResult(interp, "font \"", name, "\" doesn't exist", ! 181: (char *) NULL); ! 182: return NULL; ! 183: } ! 184: fontPtr = (TkFont *) ckalloc(sizeof(TkFont)); ! 185: fontPtr->display = nameKey.display; ! 186: fontPtr->fontStructPtr = fontStructPtr; ! 187: fontPtr->refCount = 1; ! 188: fontPtr->types = NULL; ! 189: fontPtr->widths = NULL; ! 190: fontPtr->nameHashPtr = nameHashPtr; ! 191: fontHashPtr = Tcl_CreateHashEntry(&fontTable, (char *) fontStructPtr, &new); ! 192: if (!new) { ! 193: panic("XFontStruct already registered in Tk_GetFontStruct"); ! 194: } ! 195: Tcl_SetHashValue(nameHashPtr, fontPtr); ! 196: Tcl_SetHashValue(fontHashPtr, fontPtr); ! 197: return fontPtr->fontStructPtr; ! 198: } ! 199: ! 200: /* ! 201: *-------------------------------------------------------------- ! 202: * ! 203: * Tk_NameOfFontStruct -- ! 204: * ! 205: * Given a font, return a textual string identifying it. ! 206: * ! 207: * Results: ! 208: * If font was created by Tk_GetFontStruct, then the return ! 209: * value is the "string" that was used to create it. ! 210: * Otherwise the return value is a string giving the X ! 211: * identifier for the font. The storage for the returned ! 212: * string is only guaranteed to persist up until the next ! 213: * call to this procedure. ! 214: * ! 215: * Side effects: ! 216: * None. ! 217: * ! 218: *-------------------------------------------------------------- ! 219: */ ! 220: ! 221: char * ! 222: Tk_NameOfFontStruct(fontStructPtr) ! 223: XFontStruct *fontStructPtr; /* Font whose name is desired. */ ! 224: { ! 225: Tcl_HashEntry *fontHashPtr; ! 226: TkFont *fontPtr; ! 227: static char string[20]; ! 228: ! 229: if (!initialized) { ! 230: printid: ! 231: sprintf(string, "font id 0x%x", fontStructPtr->fid); ! 232: return string; ! 233: } ! 234: fontHashPtr = Tcl_FindHashEntry(&fontTable, (char *) fontStructPtr); ! 235: if (fontHashPtr == NULL) { ! 236: goto printid; ! 237: } ! 238: fontPtr = (TkFont *) Tcl_GetHashValue(fontHashPtr); ! 239: return ((NameKey *) fontPtr->nameHashPtr->key.words)->name; ! 240: } ! 241: ! 242: /* ! 243: *---------------------------------------------------------------------- ! 244: * ! 245: * Tk_FreeFontStruct -- ! 246: * ! 247: * This procedure is called to release a font allocated by ! 248: * Tk_GetFontStruct. ! 249: * ! 250: * Results: ! 251: * None. ! 252: * ! 253: * Side effects: ! 254: * The reference count associated with font is decremented, and ! 255: * the font is officially deallocated if no-one is using it ! 256: * anymore. ! 257: * ! 258: *---------------------------------------------------------------------- ! 259: */ ! 260: ! 261: void ! 262: Tk_FreeFontStruct(fontStructPtr) ! 263: XFontStruct *fontStructPtr; /* Font to be released. */ ! 264: { ! 265: Tcl_HashEntry *fontHashPtr; ! 266: register TkFont *fontPtr; ! 267: ! 268: if (!initialized) { ! 269: panic("Tk_FreeFontStruct called before Tk_GetFontStruct"); ! 270: } ! 271: ! 272: fontHashPtr = Tcl_FindHashEntry(&fontTable, (char *) fontStructPtr); ! 273: if (fontHashPtr == NULL) { ! 274: panic("Tk_FreeFontStruct received unknown font argument"); ! 275: } ! 276: fontPtr = (TkFont *) Tcl_GetHashValue(fontHashPtr); ! 277: fontPtr->refCount--; ! 278: if (fontPtr->refCount == 0) { ! 279: XFreeFont(fontPtr->display, fontPtr->fontStructPtr); ! 280: Tcl_DeleteHashEntry(fontPtr->nameHashPtr); ! 281: Tcl_DeleteHashEntry(fontHashPtr); ! 282: if (fontPtr->types != NULL) { ! 283: ckfree(fontPtr->types); ! 284: } ! 285: if (fontPtr->widths != NULL) { ! 286: ckfree((char *) fontPtr->widths); ! 287: } ! 288: ckfree((char *) fontPtr); ! 289: lastFontStructPtr = NULL; ! 290: } ! 291: } ! 292: ! 293: /* ! 294: *---------------------------------------------------------------------- ! 295: * ! 296: * FontInit -- ! 297: * ! 298: * Initialize the structure used for font management. ! 299: * ! 300: * Results: ! 301: * None. ! 302: * ! 303: * Side effects: ! 304: * Read the code. ! 305: * ! 306: *---------------------------------------------------------------------- ! 307: */ ! 308: ! 309: static void ! 310: FontInit() ! 311: { ! 312: initialized = 1; ! 313: Tcl_InitHashTable(&nameTable, sizeof(NameKey)/sizeof(int)); ! 314: Tcl_InitHashTable(&fontTable, TCL_ONE_WORD_KEYS); ! 315: } ! 316: ! 317: /* ! 318: *-------------------------------------------------------------- ! 319: * ! 320: * SetFontMetrics -- ! 321: * ! 322: * This procedure is called to fill in the "widths" and "types" ! 323: * arrays for a font. ! 324: * ! 325: * Results: ! 326: * None. ! 327: * ! 328: * Side effects: ! 329: * FontPtr gets modified to hold font metric information. ! 330: * ! 331: *-------------------------------------------------------------- ! 332: */ ! 333: ! 334: static void ! 335: SetFontMetrics(fontPtr) ! 336: register TkFont *fontPtr; /* Font structure in which to ! 337: * set metrics. */ ! 338: { ! 339: int i, replaceOK, baseWidth; ! 340: register XFontStruct *fontStructPtr = fontPtr->fontStructPtr; ! 341: char *p; ! 342: ! 343: /* ! 344: * Pass 1: initialize the arrays. ! 345: */ ! 346: ! 347: fontPtr->types = (char *) ckalloc(256); ! 348: fontPtr->widths = (unsigned char *) ckalloc(256); ! 349: for (i = 0; i < 256; i++) { ! 350: fontPtr->types[i] = REPLACE; ! 351: } ! 352: ! 353: /* ! 354: * Pass 2: for all characters that exist in the font and are ! 355: * not control characters, fill in the type and width ! 356: * information. ! 357: */ ! 358: ! 359: for (i = ' '; i < 256; i++) { ! 360: if ((i == 0177) || (i < fontStructPtr->min_char_or_byte2) ! 361: || (i > fontStructPtr->max_char_or_byte2)) { ! 362: continue; ! 363: } ! 364: fontPtr->types[i] = NORMAL; ! 365: if (fontStructPtr->per_char == NULL) { ! 366: fontPtr->widths[i] = fontStructPtr->min_bounds.width; ! 367: } else { ! 368: fontPtr->widths[i] = fontStructPtr->per_char[i ! 369: - fontStructPtr->min_char_or_byte2].width; ! 370: } ! 371: } ! 372: ! 373: /* ! 374: * Pass 3: fill in information for characters that have to ! 375: * be replaced with "\xhh" strings. If the font doesn't ! 376: * have the characters needed for this, then just use the ! 377: * font's default character. ! 378: */ ! 379: ! 380: replaceOK = 1; ! 381: baseWidth = fontPtr->widths['\\'] + fontPtr->widths['x']; ! 382: for (p = hexChars; *p != 0; p++) { ! 383: if (fontPtr->types[*p] != NORMAL) { ! 384: replaceOK = 0; ! 385: break; ! 386: } ! 387: } ! 388: for (i = 0; i < 256; i++) { ! 389: if (fontPtr->types[i] != REPLACE) { ! 390: continue; ! 391: } ! 392: if (replaceOK) { ! 393: fontPtr->widths[i] = baseWidth ! 394: + fontPtr->widths[hexChars[i & 0xf]] ! 395: + fontPtr->widths[hexChars[(i>>4) & 0xf]]; ! 396: } else { ! 397: fontPtr->types[i] = SKIP; ! 398: fontPtr->widths[i] = 0; ! 399: } ! 400: } ! 401: ! 402: /* ! 403: * Lastly, fill in special information for newline and tab. ! 404: */ ! 405: ! 406: fontPtr->types['\n'] = NEWLINE; ! 407: fontPtr->widths['\n'] = 0; ! 408: fontPtr->types['\t'] = TAB; ! 409: fontPtr->widths['\t'] = 0; ! 410: if (fontPtr->types['0'] == NORMAL) { ! 411: fontPtr->tabWidth = 8*fontPtr->widths['0']; ! 412: } else { ! 413: fontPtr->tabWidth = 8*fontStructPtr->max_bounds.width; ! 414: } ! 415: ! 416: /* ! 417: * Make sure the tab width isn't zero (some fonts may not have enough ! 418: * information to set a reasonable tab width). ! 419: */ ! 420: ! 421: if (fontPtr->tabWidth == 0) { ! 422: fontPtr->tabWidth = 1; ! 423: } ! 424: } ! 425: ! 426: /* ! 427: *-------------------------------------------------------------- ! 428: * ! 429: * TkMeasureChars -- ! 430: * ! 431: * Measure the number of characters from a string that ! 432: * will fit in a given horizontal span. The measurement ! 433: * is done under the assumption that TkDisplayChars will ! 434: * be used to actually display the characters. ! 435: * ! 436: * Results: ! 437: * The return value is the number of characters from source ! 438: * that fit in the span given by startX and maxX. *nextXPtr ! 439: * is filled in with the x-coordinate at which the first ! 440: * character that didn't fit would be drawn, if it were to ! 441: * be drawn. ! 442: * ! 443: * Side effects: ! 444: * None. ! 445: * ! 446: *-------------------------------------------------------------- ! 447: */ ! 448: ! 449: int ! 450: TkMeasureChars(fontStructPtr, source, maxChars, startX, maxX, flags, nextXPtr) ! 451: XFontStruct *fontStructPtr; /* Font in which to draw characters. */ ! 452: char *source; /* Characters to be displayed. Need not ! 453: * be NULL-terminated. */ ! 454: int maxChars; /* Maximum # of characters to consider from ! 455: * source. */ ! 456: int startX; /* X-position at which first character will ! 457: * be drawn. */ ! 458: int maxX; /* Don't consider any character that would ! 459: * cross this x-position. */ ! 460: int flags; /* Various flag bits OR-ed together. ! 461: * TK_WHOLE_WORDS means stop on a word boundary ! 462: * (just before a space character) if ! 463: * possible. TK_AT_LEAST_ONE means always ! 464: * return a value of at least one, even ! 465: * if the character doesn't fit. ! 466: * TK_PARTIAL_OK means it's OK to display only ! 467: * a part of the last character in the line. ! 468: * TK_NEWLINES_NOT_SPECIAL means that newlines ! 469: * are treated just like other control chars: ! 470: * they don't terminate the line,*/ ! 471: int *nextXPtr; /* Return x-position of terminating ! 472: * character here. */ ! 473: { ! 474: register TkFont *fontPtr; ! 475: register char *p; /* Current character. */ ! 476: register int c; ! 477: char *term; /* Pointer to most recent character that ! 478: * may legally be a terminating character. */ ! 479: int termX; /* X-position just after term. */ ! 480: int curX; /* X-position corresponding to p. */ ! 481: int newX; /* X-position corresponding to p+1. */ ! 482: int type; ! 483: ! 484: /* ! 485: * Find the TkFont structure for this font, and make sure its ! 486: * font metrics exist. ! 487: */ ! 488: ! 489: if (lastFontStructPtr == fontStructPtr) { ! 490: fontPtr = lastFontPtr; ! 491: } else { ! 492: Tcl_HashEntry *fontHashPtr; ! 493: ! 494: if (!initialized) { ! 495: badArg: ! 496: panic("TkMeasureChars received unknown font argument"); ! 497: } ! 498: ! 499: fontHashPtr = Tcl_FindHashEntry(&fontTable, (char *) fontStructPtr); ! 500: if (fontHashPtr == NULL) { ! 501: goto badArg; ! 502: } ! 503: fontPtr = (TkFont *) Tcl_GetHashValue(fontHashPtr); ! 504: lastFontStructPtr = fontPtr->fontStructPtr; ! 505: lastFontPtr = fontPtr; ! 506: } ! 507: if (fontPtr->types == NULL) { ! 508: SetFontMetrics(fontPtr); ! 509: } ! 510: ! 511: /* ! 512: * Scan the input string one character at a time, until a character ! 513: * is found that crosses maxX. ! 514: */ ! 515: ! 516: newX = curX = startX; ! 517: termX = 0; /* Not needed, but eliminates compiler warning. */ ! 518: term = source; ! 519: for (p = source, c = *p & 0xff; maxChars > 0; p++, maxChars--) { ! 520: type = fontPtr->types[c]; ! 521: if (type == NORMAL) { ! 522: newX += fontPtr->widths[c]; ! 523: } else if (type == TAB) { ! 524: newX += fontPtr->tabWidth; ! 525: newX -= newX % fontPtr->tabWidth; ! 526: } else if (type == REPLACE) { ! 527: replaceType: ! 528: newX += fontPtr->widths['\\'] + fontPtr->widths['x'] ! 529: + fontPtr->widths[hexChars[(c >> 4) & 0xf]] ! 530: + fontPtr->widths[hexChars[c & 0xf]]; ! 531: } else if (type == NEWLINE) { ! 532: if (flags & TK_NEWLINES_NOT_SPECIAL) { ! 533: goto replaceType; ! 534: } ! 535: break; ! 536: } else if (type != SKIP) { ! 537: panic("Unknown type %d in TkMeasureChars", type); ! 538: } ! 539: if (newX > maxX) { ! 540: break; ! 541: } ! 542: c = p[1] & 0xff; ! 543: if (isspace(c) || (c == 0)) { ! 544: term = p+1; ! 545: termX = newX; ! 546: } ! 547: curX = newX; ! 548: } ! 549: ! 550: /* ! 551: * P points to the first character that doesn't fit in the desired ! 552: * span. Use the flags to figure out what to return. ! 553: */ ! 554: ! 555: if ((flags & TK_PARTIAL_OK) && (curX < maxX)) { ! 556: curX = newX; ! 557: p++; ! 558: } ! 559: if ((flags & TK_AT_LEAST_ONE) && (term == source) && (maxChars > 0) ! 560: & !isspace(*term)) { ! 561: term = p; ! 562: termX = curX; ! 563: if (term == source) { ! 564: term++; ! 565: termX = newX; ! 566: } ! 567: } else if ((maxChars == 0) || !(flags & TK_WHOLE_WORDS)) { ! 568: term = p; ! 569: termX = curX; ! 570: } ! 571: *nextXPtr = termX; ! 572: return term-source; ! 573: } ! 574: ! 575: /* ! 576: *-------------------------------------------------------------- ! 577: * ! 578: * TkDisplayChars -- ! 579: * ! 580: * Draw a string of characters on the screen, converting ! 581: * tabs to the right number of spaces and control characters ! 582: * to sequences of the form "\xhh" where hh are two hex ! 583: * digits. ! 584: * ! 585: * Results: ! 586: * None. ! 587: * ! 588: * Side effects: ! 589: * Information gets drawn on the screen. ! 590: * ! 591: *-------------------------------------------------------------- ! 592: */ ! 593: ! 594: void ! 595: TkDisplayChars(display, drawable, gc, fontStructPtr, string, numChars, ! 596: x, y, flags) ! 597: Display *display; /* Display on which to draw. */ ! 598: Drawable drawable; /* Window or pixmap in which to draw. */ ! 599: GC gc; /* Graphics context for actually drawing ! 600: * characters. */ ! 601: XFontStruct *fontStructPtr; /* Font used in GC; must have been allocated ! 602: * by Tk_GetFontStruct. Used to compute sizes ! 603: * of tabs, etc. */ ! 604: char *string; /* Characters to be displayed. */ ! 605: int numChars; /* Number of characters to display from ! 606: * string. */ ! 607: int x, y; /* Coordinates at which to draw string. */ ! 608: int flags; /* Flags to control display. Only ! 609: * TK_NEWLINES_NOT_SPECIAL is supported right ! 610: * now. See TkMeasureChars for information ! 611: * about it. */ ! 612: { ! 613: register TkFont *fontPtr; ! 614: register char *p; /* Current character being scanned. */ ! 615: register int c; ! 616: int type; ! 617: char *start; /* First character waiting to be displayed. */ ! 618: int startX; /* X-coordinate corresponding to start. */ ! 619: int curX; /* X-coordinate corresponding to p. */ ! 620: char replace[10]; ! 621: ! 622: /* ! 623: * Find the TkFont structure for this font, and make sure its ! 624: * font metrics exist. ! 625: */ ! 626: ! 627: if (lastFontStructPtr == fontStructPtr) { ! 628: fontPtr = lastFontPtr; ! 629: } else { ! 630: Tcl_HashEntry *fontHashPtr; ! 631: ! 632: if (!initialized) { ! 633: badArg: ! 634: panic("TkDisplayChars received unknown font argument"); ! 635: } ! 636: ! 637: fontHashPtr = Tcl_FindHashEntry(&fontTable, (char *) fontStructPtr); ! 638: if (fontHashPtr == NULL) { ! 639: goto badArg; ! 640: } ! 641: fontPtr = (TkFont *) Tcl_GetHashValue(fontHashPtr); ! 642: lastFontStructPtr = fontPtr->fontStructPtr; ! 643: lastFontPtr = fontPtr; ! 644: } ! 645: if (fontPtr->types == NULL) { ! 646: SetFontMetrics(fontPtr); ! 647: } ! 648: ! 649: /* ! 650: * Scan the string one character at a time. Display control ! 651: * characters immediately, but delay displaying normal characters ! 652: * in order to pass many characters to the server all together. ! 653: */ ! 654: ! 655: startX = curX = x; ! 656: start = string; ! 657: for (p = string; numChars > 0; numChars--, p++) { ! 658: c = *p & 0xff; ! 659: type = fontPtr->types[c]; ! 660: if (type == NORMAL) { ! 661: curX += fontPtr->widths[c]; ! 662: continue; ! 663: } ! 664: if (p != start) { ! 665: XDrawString(display, drawable, gc, startX, y, start, p - start); ! 666: startX = curX; ! 667: } ! 668: if (type == TAB) { ! 669: curX += fontPtr->tabWidth; ! 670: curX -= curX % fontPtr->tabWidth; ! 671: } else if (type == REPLACE) { ! 672: doReplace: ! 673: replace[0] = '\\'; ! 674: replace[1] = 'x'; ! 675: replace[2] = hexChars[(c >> 4) & 0xf]; ! 676: replace[3] = hexChars[c & 0xf]; ! 677: XDrawString(display, drawable, gc, startX, y, replace, 4); ! 678: curX += fontPtr->widths[replace[0]] ! 679: + fontPtr->widths[replace[1]] ! 680: + fontPtr->widths[replace[2]] ! 681: + fontPtr->widths[replace[3]]; ! 682: } else if (type == NEWLINE) { ! 683: if (flags & TK_NEWLINES_NOT_SPECIAL) { ! 684: goto doReplace; ! 685: } ! 686: y += fontStructPtr->ascent + fontStructPtr->descent; ! 687: curX = x; ! 688: } else if (type != SKIP) { ! 689: panic("Unknown type %d in TkDisplayChars", type); ! 690: } ! 691: startX = curX; ! 692: start = p+1; ! 693: } ! 694: ! 695: /* ! 696: * At the very end, there may be one last batch of normal characters ! 697: * to display. ! 698: */ ! 699: ! 700: if (p != start) { ! 701: XDrawString(display, drawable, gc, startX, y, start, p - start); ! 702: } ! 703: } ! 704: ! 705: /* ! 706: *---------------------------------------------------------------------- ! 707: * ! 708: * TkUnderlineChars -- ! 709: * ! 710: * This procedure draws an underline for a given range of characters ! 711: * in a given string, using appropriate information for the string's ! 712: * font. It doesn't draw the characters (which are assumed to have ! 713: * been displayed previously); it just draws the underline. ! 714: * ! 715: * Results: ! 716: * None. ! 717: * ! 718: * Side effects: ! 719: * Information gets displayed in "drawable". ! 720: * ! 721: *---------------------------------------------------------------------- ! 722: */ ! 723: ! 724: void ! 725: TkUnderlineChars(display, drawable, gc, fontStructPtr, string, x, y, ! 726: flags, firstChar, lastChar) ! 727: Display *display; /* Display on which to draw. */ ! 728: Drawable drawable; /* Window or pixmap in which to draw. */ ! 729: GC gc; /* Graphics context for actually drawing ! 730: * underline. */ ! 731: XFontStruct *fontStructPtr; /* Font used in GC; must have been allocated ! 732: * by Tk_GetFontStruct. Used to character ! 733: * dimensions, etc. */ ! 734: char *string; /* String containing characters to be ! 735: * underlined. */ ! 736: int x, y; /* Coordinates at which first character of ! 737: * string is drawn. */ ! 738: int flags; /* Flags that were passed to TkDisplayChars. */ ! 739: int firstChar; /* Index of first character to underline. */ ! 740: int lastChar; /* Index of last character to underline. */ ! 741: { ! 742: int xUnder, yUnder, width, height; ! 743: unsigned long value; ! 744: ! 745: /* ! 746: * First compute the vertical span of the underline, using font ! 747: * properties if they exist. ! 748: */ ! 749: ! 750: if (XGetFontProperty(fontStructPtr, XA_UNDERLINE_POSITION, &value)) { ! 751: yUnder = y + value; ! 752: } else { ! 753: yUnder = y + fontStructPtr->max_bounds.descent/2; ! 754: } ! 755: if (XGetFontProperty(fontStructPtr, XA_UNDERLINE_THICKNESS, &value)) { ! 756: height = value; ! 757: } else { ! 758: height = 2; ! 759: } ! 760: ! 761: /* ! 762: * Now compute the horizontal span of the underline. ! 763: */ ! 764: ! 765: TkMeasureChars(fontStructPtr, string, firstChar, x, (int) 1000000, flags, ! 766: &xUnder); ! 767: TkMeasureChars(fontStructPtr, string+firstChar, lastChar+1-firstChar, ! 768: xUnder, (int) 1000000, flags, &width); ! 769: width -= xUnder; ! 770: ! 771: XFillRectangle(display, drawable, gc, xUnder, yUnder, ! 772: (unsigned int) width, (unsigned int) height); ! 773: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.