/* * tkFont.c -- * * This file maintains a database of fonts for the Tk toolkit. * It also provides several utility procedures for measuring and * displaying text. * * Copyright (c) 1990-1994 The Regents of the University of California. * Copyright (c) 1994-1997 Sun Microsystems, Inc. * * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * * SCCS: @(#) tkFont.c 1.74 97/10/10 14:34:11 */ #include "tkInt.h" #include "tkFont.h" /* * The following structure is used to keep track of all the fonts that * exist in the current application. It must be stored in the * TkMainInfo for the application. */ typedef struct TkFontInfo { Tcl_HashTable fontCache; /* Map a string to an existing Tk_Font. * Keys are CachedFontKey structs, values are * TkFont structs. */ Tcl_HashTable namedTable; /* Map a name to a set of attributes for a * font, used when constructing a Tk_Font from * a named font description. Keys are * Tk_Uids, values are NamedFont structs. */ TkMainInfo *mainPtr; /* Application that owns this structure. */ int updatePending; } TkFontInfo; /* * The following structure is used as a key in the fontCache. */ typedef struct CachedFontKey { Display *display; /* Display for which font was constructed. */ Tk_Uid string; /* String that describes font. */ } CachedFontKey; /* * The following data structure is used to keep track of the font attributes * for each named font that has been defined. The named font is only deleted * when the last reference to it goes away. */ typedef struct NamedFont { int refCount; /* Number of users of named font. */ int deletePending; /* Non-zero if font should be deleted when * last reference goes away. */ TkFontAttributes fa; /* Desired attributes for named font. */ } NamedFont; /* * The following two structures are used to keep track of string * measurement information when using the text layout facilities. * * A LayoutChunk represents a contiguous range of text that can be measured * and displayed by low-level text calls. In general, chunks will be * delimited by newlines and tabs. Low-level, platform-specific things * like kerning and non-integer character widths may occur between the * characters in a single chunk, but not between characters in different * chunks. * * A TextLayout is a collection of LayoutChunks. It can be displayed with * respect to any origin. It is the implementation of the Tk_TextLayout * opaque token. */ typedef struct LayoutChunk { CONST char *start; /* Pointer to simple string to be displayed. * This is a pointer into the TkTextLayout's * string. */ int numChars; /* The number of characters in this chunk. */ int numDisplayChars; /* The number of characters to display when * this chunk is displayed. Can be less than * numChars if extra space characters were * absorbed by the end of the chunk. This * will be < 0 if this is a chunk that is * holding a tab or newline. */ int x, y; /* The origin of the first character in this * chunk with respect to the upper-left hand * corner of the TextLayout. */ int totalWidth; /* Width in pixels of this chunk. Used * when hit testing the invisible spaces at * the end of a chunk. */ int displayWidth; /* Width in pixels of the displayable * characters in this chunk. Can be less than * width if extra space characters were * absorbed by the end of the chunk. */ } LayoutChunk; typedef struct TextLayout { Tk_Font tkfont; /* The font used when laying out the text. */ CONST char *string; /* The string that was layed out. */ int width; /* The maximum width of all lines in the * text layout. */ int numChunks; /* Number of chunks actually used in * following array. */ LayoutChunk chunks[1]; /* Array of chunks. The actual size will * be maxChunks. THIS FIELD MUST BE THE LAST * IN THE STRUCTURE. */ } TextLayout; /* * The following structures are used as two-way maps between the values for * the fields in the TkFontAttributes structure and the strings used in * Tcl, when parsing both option-value format and style-list format font * name strings. */ static TkStateMap weightMap[] = { {TK_FW_NORMAL, "normal"}, {TK_FW_BOLD, "bold"}, {TK_FW_UNKNOWN, NULL} }; static TkStateMap slantMap[] = { {TK_FS_ROMAN, "roman"}, {TK_FS_ITALIC, "italic"}, {TK_FS_UNKNOWN, NULL} }; static TkStateMap underlineMap[] = { {1, "underline"}, {0, NULL} }; static TkStateMap overstrikeMap[] = { {1, "overstrike"}, {0, NULL} }; /* * The following structures are used when parsing XLFD's into a set of * TkFontAttributes. */ static TkStateMap xlfdWeightMap[] = { {TK_FW_NORMAL, "normal"}, {TK_FW_NORMAL, "medium"}, {TK_FW_NORMAL, "book"}, {TK_FW_NORMAL, "light"}, {TK_FW_BOLD, "bold"}, {TK_FW_BOLD, "demi"}, {TK_FW_BOLD, "demibold"}, {TK_FW_NORMAL, NULL} /* Assume anything else is "normal". */ }; static TkStateMap xlfdSlantMap[] = { {TK_FS_ROMAN, "r"}, {TK_FS_ITALIC, "i"}, {TK_FS_OBLIQUE, "o"}, {TK_FS_ROMAN, NULL} /* Assume anything else is "roman". */ }; static TkStateMap xlfdSetwidthMap[] = { {TK_SW_NORMAL, "normal"}, {TK_SW_CONDENSE, "narrow"}, {TK_SW_CONDENSE, "semicondensed"}, {TK_SW_CONDENSE, "condensed"}, {TK_SW_UNKNOWN, NULL} }; static TkStateMap xlfdCharsetMap[] = { {TK_CS_NORMAL, "iso8859"}, {TK_CS_SYMBOL, "adobe"}, {TK_CS_SYMBOL, "sun"}, {TK_CS_OTHER, NULL} }; /* * The following structure and defines specify the valid builtin options * when configuring a set of font attributes. */ static char *fontOpt[] = { "-family", "-size", "-weight", "-slant", "-underline", "-overstrike", NULL }; #define FONT_FAMILY 0 #define FONT_SIZE 1 #define FONT_WEIGHT 2 #define FONT_SLANT 3 #define FONT_UNDERLINE 4 #define FONT_OVERSTRIKE 5 #define FONT_NUMFIELDS 6 /* Length of fontOpt array. */ #define GetFontAttributes(tkfont) \ ((CONST TkFontAttributes *) &((TkFont *) (tkfont))->fa) #define GetFontMetrics(tkfont) \ ((CONST TkFontMetrics *) &((TkFont *) (tkfont))->fm) static int ConfigAttributesObj _ANSI_ARGS_((Tcl_Interp *interp, Tk_Window tkwin, int objc, Tcl_Obj *CONST objv[], TkFontAttributes *faPtr)); static int FieldSpecified _ANSI_ARGS_((CONST char *field)); static int GetAttributeInfoObj _ANSI_ARGS_((Tcl_Interp *interp, CONST TkFontAttributes *faPtr, Tcl_Obj *objPtr)); static LayoutChunk * NewChunk _ANSI_ARGS_((TextLayout **layoutPtrPtr, int *maxPtr, CONST char *start, int numChars, int curX, int newX, int y)); static int ParseFontNameObj _ANSI_ARGS_((Tcl_Interp *interp, Tk_Window tkwin, Tcl_Obj *objPtr, TkFontAttributes *faPtr)); static void RecomputeWidgets _ANSI_ARGS_((TkWindow *winPtr)); static void TheWorldHasChanged _ANSI_ARGS_(( ClientData clientData)); static void UpdateDependantFonts _ANSI_ARGS_((TkFontInfo *fiPtr, Tk_Window tkwin, Tcl_HashEntry *namedHashPtr)); /* *--------------------------------------------------------------------------- * * TkFontPkgInit -- * * This procedure is called when an application is created. It * initializes all the structures that are used by the font * package on a per application basis. * * Results: * Returns a token that must be stored in the TkMainInfo for this * application. * * Side effects: * Memory allocated. * *--------------------------------------------------------------------------- */ void TkFontPkgInit(mainPtr) TkMainInfo *mainPtr; /* The application being created. */ { TkFontInfo *fiPtr; fiPtr = (TkFontInfo *) ckalloc(sizeof(TkFontInfo)); Tcl_InitHashTable(&fiPtr->fontCache, sizeof(CachedFontKey) / sizeof(int)); Tcl_InitHashTable(&fiPtr->namedTable, TCL_ONE_WORD_KEYS); fiPtr->mainPtr = mainPtr; fiPtr->updatePending = 0; mainPtr->fontInfoPtr = fiPtr; } /* *--------------------------------------------------------------------------- * * TkFontPkgFree -- * * This procedure is called when an application is deleted. It * deletes all the structures that were used by the font package * for this application. * * Results: * None. * * Side effects: * Memory freed. * *--------------------------------------------------------------------------- */ void TkFontPkgFree(mainPtr) TkMainInfo *mainPtr; /* The application being deleted. */ { TkFontInfo *fiPtr; Tcl_HashEntry *hPtr; Tcl_HashSearch search; fiPtr = mainPtr->fontInfoPtr; if (fiPtr->fontCache.numEntries != 0) { panic("TkFontPkgFree: all fonts should have been freed already"); } Tcl_DeleteHashTable(&fiPtr->fontCache); hPtr = Tcl_FirstHashEntry(&fiPtr->namedTable, &search); while (hPtr != NULL) { ckfree((char *) Tcl_GetHashValue(hPtr)); hPtr = Tcl_NextHashEntry(&search); } Tcl_DeleteHashTable(&fiPtr->namedTable); if (fiPtr->updatePending != 0) { Tcl_CancelIdleCall(TheWorldHasChanged, (ClientData) fiPtr); } ckfree((char *) fiPtr); } /* *--------------------------------------------------------------------------- * * Tk_FontObjCmd -- * * This procedure is implemented to process the "font" Tcl command. * See the user documentation for details on what it does. * * Results: * A standard Tcl result. * * Side effects: * See the user documentation. * *---------------------------------------------------------------------- */ int Tk_FontObjCmd(clientData, interp, objc, objv) ClientData clientData; /* Main window associated with interpreter. */ Tcl_Interp *interp; /* Current interpreter. */ int objc; /* Number of arguments. */ Tcl_Obj *CONST objv[]; /* Argument objects. */ { int index; Tk_Window tkwin; TkFontInfo *fiPtr; static char *optionStrings[] = { "actual", "configure", "create", "delete", "families", "measure", "metrics", "names", NULL }; enum options { FONT_ACTUAL, FONT_CONFIGURE, FONT_CREATE, FONT_DELETE, FONT_FAMILIES, FONT_MEASURE, FONT_METRICS, FONT_NAMES }; tkwin = (Tk_Window) clientData; fiPtr = ((TkWindow *) tkwin)->mainPtr->fontInfoPtr; if (objc < 2) { Tcl_WrongNumArgs(interp, 1, objv, "option ?arg?"); return TCL_ERROR; } if (Tcl_GetIndexFromObj(interp, objv[1], optionStrings, "option", 0, &index) != TCL_OK) { return TCL_ERROR; } switch ((enum options) index) { case FONT_ACTUAL: { int skip, result; Tk_Font tkfont; Tcl_Obj *objPtr; CONST TkFontAttributes *faPtr; skip = TkGetDisplayOf(interp, objc - 3, objv + 3, &tkwin); if (skip < 0) { return TCL_ERROR; } if ((objc < 3) || (objc - skip > 4)) { Tcl_WrongNumArgs(interp, 2, objv, #ifdef STk_CODE "font ?:displayof window? ?option?"); #else "font ?-displayof window? ?option?"); #endif return TCL_ERROR; } tkfont = Tk_GetFontFromObj(interp, tkwin, objv[2]); if (tkfont == NULL) { return TCL_ERROR; } objc -= skip; objv += skip; faPtr = GetFontAttributes(tkfont); objPtr = NULL; if (objc > 3) { objPtr = objv[3]; } result = GetAttributeInfoObj(interp, faPtr, objPtr); Tk_FreeFont(tkfont); return result; } case FONT_CONFIGURE: { int result; char *string; Tcl_Obj *objPtr; NamedFont *nfPtr; Tcl_HashEntry *namedHashPtr; if (objc < 3) { Tcl_WrongNumArgs(interp, 2, objv, "fontname ?options?"); return TCL_ERROR; } string = Tk_GetUid(Tcl_GetStringFromObj(objv[2], NULL)); namedHashPtr = Tcl_FindHashEntry(&fiPtr->namedTable, string); nfPtr = NULL; /* lint. */ if (namedHashPtr != NULL) { nfPtr = (NamedFont *) Tcl_GetHashValue(namedHashPtr); } if ((namedHashPtr == NULL) || (nfPtr->deletePending != 0)) { Tcl_AppendStringsToObj(Tcl_GetObjResult(interp), "named font \"", string, "\" doesn't exist", NULL); return TCL_ERROR; } if (objc == 3) { objPtr = NULL; } else if (objc == 4) { objPtr = objv[3]; } else { result = ConfigAttributesObj(interp, tkwin, objc - 3, objv + 3, &nfPtr->fa); UpdateDependantFonts(fiPtr, tkwin, namedHashPtr); return result; } return GetAttributeInfoObj(interp, &nfPtr->fa, objPtr); } case FONT_CREATE: { int skip, i; char *name; char buf[32]; TkFontAttributes fa; Tcl_HashEntry *namedHashPtr; skip = 3; if (objc < 3) { name = NULL; } else { name = Tcl_GetStringFromObj(objv[2], NULL); if (name[0] == '-') { name = NULL; } } if (name == NULL) { /* * No font name specified. Generate one of the form "fontX". */ for (i = 1; ; i++) { sprintf(buf, "font%d", i); namedHashPtr = Tcl_FindHashEntry(&fiPtr->namedTable, Tk_GetUid(buf)); if (namedHashPtr == NULL) { break; } } name = buf; skip = 2; } TkInitFontAttributes(&fa); if (ConfigAttributesObj(interp, tkwin, objc - skip, objv + skip, &fa) != TCL_OK) { return TCL_ERROR; } if (TkCreateNamedFont(interp, tkwin, name, &fa) != TCL_OK) { return TCL_ERROR; } Tcl_SetStringObj(Tcl_GetObjResult(interp), name, -1); break; } case FONT_DELETE: { int i; char *string; NamedFont *nfPtr; Tcl_HashEntry *namedHashPtr; /* * Delete the named font. If there are still widgets using this * font, then it isn't deleted right away. */ if (objc < 3) { Tcl_WrongNumArgs(interp, 2, objv, "fontname ?fontname ...?"); return TCL_ERROR; } for (i = 2; i < objc; i++) { string = Tk_GetUid(Tcl_GetStringFromObj(objv[i], NULL)); namedHashPtr = Tcl_FindHashEntry(&fiPtr->namedTable, string); if (namedHashPtr == NULL) { Tcl_AppendStringsToObj(Tcl_GetObjResult(interp), "named font \"", string, "\" doesn't exist", (char *) NULL); return TCL_ERROR; } nfPtr = (NamedFont *) Tcl_GetHashValue(namedHashPtr); if (nfPtr->refCount != 0) { nfPtr->deletePending = 1; } else { Tcl_DeleteHashEntry(namedHashPtr); ckfree((char *) nfPtr); } } break; } case FONT_FAMILIES: { int skip; skip = TkGetDisplayOf(interp, objc - 2, objv + 2, &tkwin); if (skip < 0) { return TCL_ERROR; } if (objc - skip != 2) { #ifdef STk_CODE Tcl_WrongNumArgs(interp, 2, objv, "?:displayof window?"); #else Tcl_WrongNumArgs(interp, 2, objv, "?-displayof window?"); #endif return TCL_ERROR; } TkpGetFontFamilies(interp, tkwin); #ifdef STk_CODE Tcl_SetObjResult(interp, STk_create_tcl_object( STk_convert_Tcl_string2list(interp->result))); #endif break; } case FONT_MEASURE: { char *string; Tk_Font tkfont; int length, skip; skip = TkGetDisplayOf(interp, objc - 3, objv + 3, &tkwin); if (skip < 0) { return TCL_ERROR; } if (objc - skip != 4) { Tcl_WrongNumArgs(interp, 2, objv, #ifdef STk_CODE "font ?:displayof window? text"); #else "font ?-displayof window? text"); #endif return TCL_ERROR; } tkfont = Tk_GetFontFromObj(interp, tkwin, objv[2]); if (tkfont == NULL) { return TCL_ERROR; } string = Tcl_GetStringFromObj(objv[3 + skip], &length); Tcl_SetIntObj(Tcl_GetObjResult(interp), Tk_TextWidth(tkfont, string, length)); Tk_FreeFont(tkfont); break; } case FONT_METRICS: { char buf[64]; Tk_Font tkfont; int skip, index, i; CONST TkFontMetrics *fmPtr; static char *switches[] = { "-ascent", "-descent", "-linespace", "-fixed", NULL }; skip = TkGetDisplayOf(interp, objc - 3, objv + 3, &tkwin); if (skip < 0) { return TCL_ERROR; } if ((objc < 3) || ((objc - skip) > 4)) { Tcl_WrongNumArgs(interp, 2, objv, #ifdef STk_CODE "font ?:displayof window? ?option?"); #else "font ?-displayof window? ?option?"); #endif return TCL_ERROR; } tkfont = Tk_GetFontFromObj(interp, tkwin, objv[2]); if (tkfont == NULL) { return TCL_ERROR; } objc -= skip; objv += skip; fmPtr = GetFontMetrics(tkfont); if (objc == 3) { #ifdef STk_CODE sprintf(buf, ":ascent %d :descent %d :linespace %d :fixed #%c", fmPtr->ascent, fmPtr->descent, fmPtr->ascent + fmPtr->descent, fmPtr->fixed? 't' : 'f'); Tcl_SetObjResult(interp, STk_create_tcl_object( STk_convert_Tcl_string2list(buf))); #else sprintf(buf, "-ascent %d -descent %d -linespace %d -fixed %d", fmPtr->ascent, fmPtr->descent, fmPtr->ascent + fmPtr->descent, fmPtr->fixed); Tcl_SetStringObj(Tcl_GetObjResult(interp), buf, -1); #endif } else { if (Tcl_GetIndexFromObj(interp, objv[3], switches, "metric", 0, &index) != TCL_OK) { Tk_FreeFont(tkfont); return TCL_ERROR; } i = 0; /* Needed only to prevent compiler * warning. */ switch (index) { case 0: i = fmPtr->ascent; break; case 1: i = fmPtr->descent; break; case 2: i = fmPtr->ascent + fmPtr->descent; break; case 3: i = fmPtr->fixed; break; } #ifdef STk_CODE if (index == 3) Tcl_SetBooleanObj(Tcl_GetObjResult(interp), i); else #endif Tcl_SetIntObj(Tcl_GetObjResult(interp), i); } Tk_FreeFont(tkfont); break; } case FONT_NAMES: { char *string; Tcl_Obj *strPtr; NamedFont *nfPtr; Tcl_HashSearch search; Tcl_HashEntry *namedHashPtr; if (objc != 2) { #ifdef STk_CODE Tcl_WrongNumArgs(interp, 1, objv, "'names"); #else Tcl_WrongNumArgs(interp, 1, objv, "names"); #endif return TCL_ERROR; } namedHashPtr = Tcl_FirstHashEntry(&fiPtr->namedTable, &search); while (namedHashPtr != NULL) { nfPtr = (NamedFont *) Tcl_GetHashValue(namedHashPtr); if (nfPtr->deletePending == 0) { string = Tcl_GetHashKey(&fiPtr->namedTable, namedHashPtr); strPtr = Tcl_NewStringObj(string, -1); Tcl_ListObjAppendElement(NULL, Tcl_GetObjResult(interp), strPtr); } namedHashPtr = Tcl_NextHashEntry(&search); } break; } } return TCL_OK; } /* *--------------------------------------------------------------------------- * * UpdateDependantFonts, TheWorldHasChanged, RecomputeWidgets -- * * Called when the attributes of a named font changes. Updates all * the instantiated fonts that depend on that named font and then * uses the brute force approach and prepares every widget to * recompute its geometry. * * Results: * None. * * Side effects: * Things get queued for redisplay. * *--------------------------------------------------------------------------- */ static void UpdateDependantFonts(fiPtr, tkwin, namedHashPtr) TkFontInfo *fiPtr; /* Info about application's fonts. */ Tk_Window tkwin; /* A window in the application. */ Tcl_HashEntry *namedHashPtr;/* The named font that is changing. */ { Tcl_HashEntry *cacheHashPtr; Tcl_HashSearch search; TkFont *fontPtr; NamedFont *nfPtr; nfPtr = (NamedFont *) Tcl_GetHashValue(namedHashPtr); if (nfPtr->refCount == 0) { /* * Well nobody's using this named font, so don't have to tell * any widgets to recompute themselves. */ return; } cacheHashPtr = Tcl_FirstHashEntry(&fiPtr->fontCache, &search); while (cacheHashPtr != NULL) { fontPtr = (TkFont *) Tcl_GetHashValue(cacheHashPtr); if (fontPtr->namedHashPtr == namedHashPtr) { TkpGetFontFromAttributes(fontPtr, tkwin, &nfPtr->fa); if (fiPtr->updatePending == 0) { fiPtr->updatePending = 1; Tcl_DoWhenIdle(TheWorldHasChanged, (ClientData) fiPtr); } } cacheHashPtr = Tcl_NextHashEntry(&search); } } static void TheWorldHasChanged(clientData) ClientData clientData; /* Info about application's fonts. */ { TkFontInfo *fiPtr; fiPtr = (TkFontInfo *) clientData; fiPtr->updatePending = 0; RecomputeWidgets(fiPtr->mainPtr->winPtr); } static void RecomputeWidgets(winPtr) TkWindow *winPtr; /* Window to which command is sent. */ { if ((winPtr->classProcsPtr != NULL) && (winPtr->classProcsPtr->geometryProc != NULL)) { (*winPtr->classProcsPtr->geometryProc)(winPtr->instanceData); } for (winPtr = winPtr->childList; winPtr != NULL; winPtr = winPtr->nextPtr) { RecomputeWidgets(winPtr); } } /* *--------------------------------------------------------------------------- * * TkCreateNamedFont -- * * Create the specified named font with the given attributes in the * named font table associated with the interp. * * Results: * Returns TCL_OK if the font was successfully created, or TCL_ERROR * if the named font already existed. If TCL_ERROR is returned, an * error message is left in interp->result. * * Side effects: * Assume there used to exist a named font by the specified name, and * that the named font had been deleted, but there were still some * widgets using the named font at the time it was deleted. If a * new named font is created with the same name, all those widgets * that were using the old named font will be redisplayed using * the new named font's attributes. * *--------------------------------------------------------------------------- */ int TkCreateNamedFont(interp, tkwin, name, faPtr) Tcl_Interp *interp; /* Interp for error return. */ Tk_Window tkwin; /* A window associated with interp. */ CONST char *name; /* Name for the new named font. */ TkFontAttributes *faPtr; /* Attributes for the new named font. */ { TkFontInfo *fiPtr; Tcl_HashEntry *namedHashPtr; int new; NamedFont *nfPtr; fiPtr = ((TkWindow *) tkwin)->mainPtr->fontInfoPtr; name = Tk_GetUid(name); namedHashPtr = Tcl_CreateHashEntry(&fiPtr->namedTable, name, &new); if (new == 0) { nfPtr = (NamedFont *) Tcl_GetHashValue(namedHashPtr); if (nfPtr->deletePending == 0) { interp->result[0] = '\0'; Tcl_AppendResult(interp, "font \"", name, "\" already exists", (char *) NULL); return TCL_ERROR; } /* * Recreating a named font with the same name as a previous * named font. Some widgets were still using that named * font, so they need to get redisplayed. */ nfPtr->fa = *faPtr; nfPtr->deletePending = 0; UpdateDependantFonts(fiPtr, tkwin, namedHashPtr); return TCL_OK; } nfPtr = (NamedFont *) ckalloc(sizeof(NamedFont)); nfPtr->deletePending = 0; Tcl_SetHashValue(namedHashPtr, nfPtr); nfPtr->fa = *faPtr; nfPtr->refCount = 0; nfPtr->deletePending = 0; return TCL_OK; } /* *--------------------------------------------------------------------------- * * Tk_GetFont -- * * Given a string description of a font, map the description to a * corresponding Tk_Font that represents the font. * * Results: * The return value is token for the font, or NULL if an error * prevented the font from being created. If NULL is returned, an * error message will be left in interp->result. * * Side effects: * Calls Tk_GetFontFromObj(), which modifies interp's result object, * then copies the string from the result object into interp->result. * This procedure will go away when Tk_ConfigureWidget() is * made into an object command. * *--------------------------------------------------------------------------- */ Tk_Font Tk_GetFont(interp, tkwin, string) Tcl_Interp *interp; /* Interp for database and error return. */ Tk_Window tkwin; /* For display on which font will be used. */ CONST char *string; /* String describing font, as: named font, * native format, or parseable string. */ { Tcl_Obj *strPtr; Tk_Font tkfont; strPtr = Tcl_NewStringObj((char *) string, -1); tkfont = Tk_GetFontFromObj(interp, tkwin, strPtr); if (tkfont == NULL) { Tcl_SetResult(interp, Tcl_GetStringFromObj(Tcl_GetObjResult(interp), NULL), TCL_VOLATILE); } Tcl_DecrRefCount(strPtr); /* done with object */ return tkfont; } /* *--------------------------------------------------------------------------- * * Tk_GetFontFromObj -- * * Given a string description of a font, map the description to a * corresponding Tk_Font that represents the font. * * Results: * The return value is token for the font, or NULL if an error * prevented the font from being created. If NULL is returned, an * error message will be left in interp's result object. * * Side effects: * The font is added to an internal database with a reference * count. For each call to this procedure, there should eventually * be a call to Tk_FreeFont() so that the database is cleaned up when * fonts aren't in use anymore. * *--------------------------------------------------------------------------- */ Tk_Font Tk_GetFontFromObj(interp, tkwin, objPtr) Tcl_Interp *interp; /* Interp for database and error return. */ Tk_Window tkwin; /* For display on which font will be used. */ Tcl_Obj *objPtr; /* Object describing font, as: named font, * native format, or parseable string. */ { TkFontInfo *fiPtr; CachedFontKey key; Tcl_HashEntry *cacheHashPtr, *namedHashPtr; TkFont *fontPtr; int new, descent; NamedFont *nfPtr; char *string; fiPtr = ((TkWindow *) tkwin)->mainPtr->fontInfoPtr; string = Tcl_GetStringFromObj(objPtr, NULL); key.display = Tk_Display(tkwin); key.string = Tk_GetUid(string); cacheHashPtr = Tcl_CreateHashEntry(&fiPtr->fontCache, (char *) &key, &new); if (new == 0) { /* * We have already constructed a font with this description for * this display. Bump the reference count of the cached font. */ fontPtr = (TkFont *) Tcl_GetHashValue(cacheHashPtr); fontPtr->refCount++; return (Tk_Font) fontPtr; } namedHashPtr = Tcl_FindHashEntry(&fiPtr->namedTable, key.string); if (namedHashPtr != NULL) { /* * Construct a font based on a named font. */ nfPtr = (NamedFont *) Tcl_GetHashValue(namedHashPtr); nfPtr->refCount++; fontPtr = TkpGetFontFromAttributes(NULL, tkwin, &nfPtr->fa); } else { /* * Native font? */ fontPtr = TkpGetNativeFont(tkwin, string); if (fontPtr == NULL) { TkFontAttributes fa; TkInitFontAttributes(&fa); if (ParseFontNameObj(interp, tkwin, objPtr, &fa) != TCL_OK) { Tcl_DeleteHashEntry(cacheHashPtr); return NULL; } /* * String contained the attributes inline. */ fontPtr = TkpGetFontFromAttributes(NULL, tkwin, &fa); } } Tcl_SetHashValue(cacheHashPtr, fontPtr); fontPtr->refCount = 1; fontPtr->cacheHashPtr = cacheHashPtr; fontPtr->namedHashPtr = namedHashPtr; Tk_MeasureChars((Tk_Font) fontPtr, "0", 1, 0, 0, &fontPtr->tabWidth); if (fontPtr->tabWidth == 0) { fontPtr->tabWidth = fontPtr->fm.maxWidth; } fontPtr->tabWidth *= 8; /* * Make sure the tab width isn't zero (some fonts may not have enough * information to set a reasonable tab width). */ if (fontPtr->tabWidth == 0) { fontPtr->tabWidth = 1; } /* * Get information used for drawing underlines in generic code on a * non-underlined font. */ descent = fontPtr->fm.descent; fontPtr->underlinePos = descent / 2; fontPtr->underlineHeight = fontPtr->fa.pointsize / 10; if (fontPtr->underlineHeight == 0) { fontPtr->underlineHeight = 1; } if (fontPtr->underlinePos + fontPtr->underlineHeight > descent) { /* * If this set of values would cause the bottom of the underline * bar to stick below the descent of the font, jack the underline * up a bit higher. */ fontPtr->underlineHeight = descent - fontPtr->underlinePos; if (fontPtr->underlineHeight == 0) { fontPtr->underlinePos--; fontPtr->underlineHeight = 1; } } return (Tk_Font) fontPtr; } /* *--------------------------------------------------------------------------- * * Tk_NameOfFont -- * * Given a font, return a textual string identifying it. * * Results: * The return value is the description that was passed to * Tk_GetFont() to create the font. The storage for the returned * string is only guaranteed to persist until the font is deleted. * The caller should not modify this string. * * Side effects: * None. * *--------------------------------------------------------------------------- */ char * Tk_NameOfFont(tkfont) Tk_Font tkfont; /* Font whose name is desired. */ { TkFont *fontPtr; Tcl_HashEntry *hPtr; CachedFontKey *keyPtr; fontPtr = (TkFont *) tkfont; hPtr = fontPtr->cacheHashPtr; keyPtr = (CachedFontKey *) Tcl_GetHashKey(hPtr->tablePtr, hPtr); return (char *) keyPtr->string; } /* *--------------------------------------------------------------------------- * * Tk_FreeFont -- * * Called to release a font allocated by Tk_GetFont(). * * Results: * None. * * Side effects: * The reference count associated with font is decremented, and * only deallocated when no one is using it. * *--------------------------------------------------------------------------- */ void Tk_FreeFont(tkfont) Tk_Font tkfont; /* Font to be released. */ { TkFont *fontPtr; NamedFont *nfPtr; if (tkfont == NULL) { return; } fontPtr = (TkFont *) tkfont; fontPtr->refCount--; if (fontPtr->refCount == 0) { if (fontPtr->namedHashPtr != NULL) { /* * The font is being deleted. Determine if the associated named * font definition should and/or can be deleted too. */ nfPtr = (NamedFont *) Tcl_GetHashValue(fontPtr->namedHashPtr); nfPtr->refCount--; if ((nfPtr->refCount == 0) && (nfPtr->deletePending != 0)) { Tcl_DeleteHashEntry(fontPtr->namedHashPtr); ckfree((char *) nfPtr); } } Tcl_DeleteHashEntry(fontPtr->cacheHashPtr); TkpDeleteFont(fontPtr); } } /* *--------------------------------------------------------------------------- * * Tk_FontId -- * * Given a font, return an opaque handle that should be selected * into the XGCValues structure in order to get the constructed * gc to use this font. This procedure would go away if the * XGCValues structure were replaced with a TkGCValues structure. * * Results: * As above. * * Side effects: * None. * *--------------------------------------------------------------------------- */ Font Tk_FontId(tkfont) Tk_Font tkfont; /* Font that is going to be selected into GC. */ { TkFont *fontPtr; fontPtr = (TkFont *) tkfont; return fontPtr->fid; } /* *--------------------------------------------------------------------------- * * Tk_GetFontMetrics -- * * Returns overall ascent and descent metrics for the given font. * These values can be used to space multiple lines of text and * to align the baselines of text in different fonts. * * Results: * If *heightPtr is non-NULL, it is filled with the overall height * of the font, which is the sum of the ascent and descent. * If *ascentPtr or *descentPtr is non-NULL, they are filled with * the ascent and/or descent information for the font. * * Side effects: * None. * *--------------------------------------------------------------------------- */ void Tk_GetFontMetrics(tkfont, fmPtr) Tk_Font tkfont; /* Font in which metrics are calculated. */ Tk_FontMetrics *fmPtr; /* Pointer to structure in which font * metrics for tkfont will be stored. */ { TkFont *fontPtr; fontPtr = (TkFont *) tkfont; fmPtr->ascent = fontPtr->fm.ascent; fmPtr->descent = fontPtr->fm.descent; fmPtr->linespace = fontPtr->fm.ascent + fontPtr->fm.descent; } /* *--------------------------------------------------------------------------- * * Tk_PostscriptFontName -- * * Given a Tk_Font, return the name of the corresponding Postscript * font. * * Results: * The return value is the pointsize of the given Tk_Font. * The name of the Postscript font is appended to dsPtr. * * Side effects: * If the font does not exist on the printer, the print job will * fail at print time. Given a "reasonable" Postscript printer, * the following Tk_Font font families should print correctly: * * Avant Garde, Arial, Bookman, Courier, Courier New, Geneva, * Helvetica, Monaco, New Century Schoolbook, New York, * Palatino, Symbol, Times, Times New Roman, Zapf Chancery, * and Zapf Dingbats. * * Any other Tk_Font font families may not print correctly * because the computed Postscript font name may be incorrect. * *--------------------------------------------------------------------------- */ int Tk_PostscriptFontName(tkfont, dsPtr) Tk_Font tkfont; /* Font in which text will be printed. */ Tcl_DString *dsPtr; /* Pointer to an initialized Tcl_DString to * which the name of the Postscript font that * corresponds to tkfont will be appended. */ { TkFont *fontPtr; char *family, *weightString, *slantString; char *src, *dest; int upper, len; len = Tcl_DStringLength(dsPtr); fontPtr = (TkFont *) tkfont; /* * Convert the case-insensitive Tk_Font family name to the * case-sensitive Postscript family name. Take out any spaces and * capitalize the first letter of each word. */ family = fontPtr->fa.family; if (strncasecmp(family, "itc ", 4) == 0) { family = family + 4; } if ((strcasecmp(family, "Arial") == 0) || (strcasecmp(family, "Geneva") == 0)) { family = "Helvetica"; } else if ((strcasecmp(family, "Times New Roman") == 0) || (strcasecmp(family, "New York") == 0)) { family = "Times"; } else if ((strcasecmp(family, "Courier New") == 0) || (strcasecmp(family, "Monaco") == 0)) { family = "Courier"; } else if (strcasecmp(family, "AvantGarde") == 0) { family = "AvantGarde"; } else if (strcasecmp(family, "ZapfChancery") == 0) { family = "ZapfChancery"; } else if (strcasecmp(family, "ZapfDingbats") == 0) { family = "ZapfDingbats"; } else { /* * Inline, capitalize the first letter of each word, lowercase the * rest of the letters in each word, and then take out the spaces * between the words. This may make the DString shorter, which is * safe to do. */ Tcl_DStringAppend(dsPtr, family, -1); src = dest = Tcl_DStringValue(dsPtr) + len; upper = 1; for (; *src != '\0'; src++, dest++) { while (isspace(UCHAR(*src))) { src++; upper = 1; } *dest = *src; if ((upper != 0) && (islower(UCHAR(*src)))) { *dest = toupper(UCHAR(*src)); } upper = 0; } *dest = '\0'; Tcl_DStringSetLength(dsPtr, dest - Tcl_DStringValue(dsPtr)); family = Tcl_DStringValue(dsPtr) + len; } if (family != Tcl_DStringValue(dsPtr) + len) { Tcl_DStringAppend(dsPtr, family, -1); family = Tcl_DStringValue(dsPtr) + len; } if (strcasecmp(family, "NewCenturySchoolbook") == 0) { Tcl_DStringSetLength(dsPtr, len); Tcl_DStringAppend(dsPtr, "NewCenturySchlbk", -1); family = Tcl_DStringValue(dsPtr) + len; } /* * Get the string to use for the weight. */ weightString = NULL; if (fontPtr->fa.weight == TK_FW_NORMAL) { if (strcmp(family, "Bookman") == 0) { weightString = "Light"; } else if (strcmp(family, "AvantGarde") == 0) { weightString = "Book"; } else if (strcmp(family, "ZapfChancery") == 0) { weightString = "Medium"; } } else { if ((strcmp(family, "Bookman") == 0) || (strcmp(family, "AvantGarde") == 0)) { weightString = "Demi"; } else { weightString = "Bold"; } } /* * Get the string to use for the slant. */ slantString = NULL; if (fontPtr->fa.slant == TK_FS_ROMAN) { ; } else { if ((strcmp(family, "Helvetica") == 0) || (strcmp(family, "Courier") == 0) || (strcmp(family, "AvantGarde") == 0)) { slantString = "Oblique"; } else { slantString = "Italic"; } } /* * The string "Roman" needs to be added to some fonts that are not bold * and not italic. */ if ((slantString == NULL) && (weightString == NULL)) { if ((strcmp(family, "Times") == 0) || (strcmp(family, "NewCenturySchlbk") == 0) || (strcmp(family, "Palatino") == 0)) { Tcl_DStringAppend(dsPtr, "-Roman", -1); } } else { Tcl_DStringAppend(dsPtr, "-", -1); if (weightString != NULL) { Tcl_DStringAppend(dsPtr, weightString, -1); } if (slantString != NULL) { Tcl_DStringAppend(dsPtr, slantString, -1); } } return fontPtr->fa.pointsize; } /* *--------------------------------------------------------------------------- * * Tk_TextWidth -- * * A wrapper function for the more complicated interface of * Tk_MeasureChars. Computes how much space the given * simple string needs. * * Results: * The return value is the width (in pixels) of the given string. * * Side effects: * None. * *--------------------------------------------------------------------------- */ int Tk_TextWidth(tkfont, string, numChars) Tk_Font tkfont; /* Font in which text will be measured. */ CONST char *string; /* String whose width will be computed. */ int numChars; /* Number of characters to consider from * string, or < 0 for strlen(). */ { int width; if (numChars < 0) { numChars = strlen(string); } Tk_MeasureChars(tkfont, string, numChars, 0, 0, &width); return width; } /* *--------------------------------------------------------------------------- * * Tk_UnderlineChars -- * * This procedure draws an underline for a given range of characters * in a given string. It doesn't draw the characters (which are * assumed to have been displayed previously); it just draws the * underline. This procedure would mainly be used to quickly * underline a few characters without having to construct an * underlined font. To produce properly underlined text, the * appropriate underlined font should be constructed and used. * * Results: * None. * * Side effects: * Information gets displayed in "drawable". * *---------------------------------------------------------------------- */ void Tk_UnderlineChars(display, drawable, gc, tkfont, string, x, y, firstChar, lastChar) Display *display; /* Display on which to draw. */ Drawable drawable; /* Window or pixmap in which to draw. */ GC gc; /* Graphics context for actually drawing * line. */ Tk_Font tkfont; /* Font used in GC; must have been allocated * by Tk_GetFont(). Used for character * dimensions, etc. */ CONST char *string; /* String containing characters to be * underlined or overstruck. */ int x, y; /* Coordinates at which first character of * string is drawn. */ int firstChar; /* Index of first character. */ int lastChar; /* Index of one after the last character. */ { TkFont *fontPtr; int startX, endX; fontPtr = (TkFont *) tkfont; Tk_MeasureChars(tkfont, string, firstChar, 0, 0, &startX); Tk_MeasureChars(tkfont, string, lastChar, 0, 0, &endX); XFillRectangle(display, drawable, gc, x + startX, y + fontPtr->underlinePos, (unsigned int) (endX - startX), (unsigned int) fontPtr->underlineHeight); } /* *--------------------------------------------------------------------------- * * Tk_ComputeTextLayout -- * * Computes the amount of screen space needed to display a * multi-line, justified string of text. Records all the * measurements that were done to determine to size and * positioning of the individual lines of text; this information * can be used by the Tk_DrawTextLayout() procedure to * display the text quickly (without remeasuring it). * * This procedure is useful for simple widgets that want to * display single-font, multi-line text and want Tk to handle the * details. * * Results: * The return value is a Tk_TextLayout token that holds the * measurement information for the given string. The token is * only valid for the given string. If the string is freed, * the token is no longer valid and must also be freed. To free * the token, call Tk_FreeTextLayout(). * * The dimensions of the screen area needed to display the text * are stored in *widthPtr and *heightPtr. * * Side effects: * Memory is allocated to hold the measurement information. * *--------------------------------------------------------------------------- */ Tk_TextLayout Tk_ComputeTextLayout(tkfont, string, numChars, wrapLength, justify, flags, widthPtr, heightPtr) Tk_Font tkfont; /* Font that will be used to display text. */ CONST char *string; /* String whose dimensions are to be * computed. */ int numChars; /* Number of characters to consider from * string, or < 0 for strlen(). */ int wrapLength; /* Longest permissible line length, in * pixels. <= 0 means no automatic wrapping: * just let lines get as long as needed. */ Tk_Justify justify; /* How to justify lines. */ int flags; /* Flag bits OR-ed together. * TK_IGNORE_TABS means that tab characters * should not be expanded. TK_IGNORE_NEWLINES * means that newline characters should not * cause a line break. */ int *widthPtr; /* Filled with width of string. */ int *heightPtr; /* Filled with height of string. */ { TkFont *fontPtr; CONST char *start, *end, *special; int n, y, charsThisChunk, maxChunks; int baseline, height, curX, newX, maxWidth; TextLayout *layoutPtr; LayoutChunk *chunkPtr; CONST TkFontMetrics *fmPtr; #define MAX_LINES 50 int staticLineLengths[MAX_LINES]; int *lineLengths; int maxLines, curLine, layoutHeight; lineLengths = staticLineLengths; maxLines = MAX_LINES; fontPtr = (TkFont *) tkfont; fmPtr = &fontPtr->fm; height = fmPtr->ascent + fmPtr->descent; if (numChars < 0) { numChars = strlen(string); } maxChunks = 1; layoutPtr = (TextLayout *) ckalloc(sizeof(TextLayout) + (maxChunks - 1) * sizeof(LayoutChunk)); layoutPtr->tkfont = tkfont; layoutPtr->string = string; layoutPtr->numChunks = 0; baseline = fmPtr->ascent; maxWidth = 0; /* * Divide the string up into simple strings and measure each string. */ curX = 0; end = string + numChars; special = string; flags &= TK_IGNORE_TABS | TK_IGNORE_NEWLINES; flags |= TK_WHOLE_WORDS | TK_AT_LEAST_ONE; curLine = 0; for (start = string; start < end; ) { if (start >= special) { /* * Find the next special character in the string. */ for (special = start; special < end; special++) { if (!(flags & TK_IGNORE_NEWLINES)) { if ((*special == '\n') || (*special == '\r')) { break; } } if (!(flags & TK_IGNORE_TABS)) { if (*special == '\t') { break; } } } } /* * Special points at the next special character (or the end of the * string). Process characters between start and special. */ chunkPtr = NULL; if (start < special) { charsThisChunk = Tk_MeasureChars(tkfont, start, special - start, wrapLength - curX, flags, &newX); newX += curX; flags &= ~TK_AT_LEAST_ONE; if (charsThisChunk > 0) { chunkPtr = NewChunk(&layoutPtr, &maxChunks, start, charsThisChunk, curX, newX, baseline); start += charsThisChunk; curX = newX; } } if ((start == special) && (special < end)) { /* * Handle the special character. */ chunkPtr = NULL; if (*special == '\t') { newX = curX + fontPtr->tabWidth; newX -= newX % fontPtr->tabWidth; NewChunk(&layoutPtr, &maxChunks, start, 1, curX, newX, baseline)->numDisplayChars = -1; start++; if ((start < end) && ((wrapLength <= 0) || (newX <= wrapLength))) { /* * More chars can still fit on this line. */ curX = newX; flags &= ~TK_AT_LEAST_ONE; continue; } } else { NewChunk(&layoutPtr, &maxChunks, start, 1, curX, 1000000000, baseline)->numDisplayChars = -1; start++; goto wrapLine; } } /* * No more characters are going to go on this line, either because * no more characters can fit or there are no more characters left. * Consume all extra spaces at end of line. */ while ((start < end) && isspace(UCHAR(*start))) { if (!(flags & TK_IGNORE_NEWLINES)) { if ((*start == '\n') || (*start == '\r')) { break; } } if (!(flags & TK_IGNORE_TABS)) { if (*start == '\t') { break; } } start++; } if (chunkPtr != NULL) { /* * Append all the extra spaces on this line to the end of the * last text chunk. */ charsThisChunk = start - (chunkPtr->start + chunkPtr->numChars); if (charsThisChunk > 0) { chunkPtr->numChars += Tk_MeasureChars(tkfont, chunkPtr->start + chunkPtr->numChars, charsThisChunk, 0, 0, &chunkPtr->totalWidth); chunkPtr->totalWidth += curX; } } wrapLine: flags |= TK_AT_LEAST_ONE; /* * Save current line length, then move current position to start of * next line. */ if (curX > maxWidth) { maxWidth = curX; } /* * Remember width of this line, so that all chunks on this line * can be centered or right justified, if necessary. */ if (curLine >= maxLines) { int *newLengths; newLengths = (int *) ckalloc(2 * maxLines * sizeof(int)); memcpy((void *) newLengths, lineLengths, maxLines * sizeof(int)); if (lineLengths != staticLineLengths) { ckfree((char *) lineLengths); } lineLengths = newLengths; maxLines *= 2; } lineLengths[curLine] = curX; curLine++; curX = 0; baseline += height; } /* * If last line ends with a newline, then we need to make a 0 width * chunk on the next line. Otherwise "Hello" and "Hello\n" are the * same height. */ if ((layoutPtr->numChunks > 0) && ((flags & TK_IGNORE_NEWLINES) == 0)) { if (layoutPtr->chunks[layoutPtr->numChunks - 1].start[0] == '\n') { chunkPtr = NewChunk(&layoutPtr, &maxChunks, start, 0, curX, 1000000000, baseline); chunkPtr->numDisplayChars = -1; baseline += height; } } /* * Using maximum line length, shift all the chunks so that the lines are * all justified correctly. */ curLine = 0; chunkPtr = layoutPtr->chunks; y = chunkPtr->y; for (n = 0; n < layoutPtr->numChunks; n++) { int extra; if (chunkPtr->y != y) { curLine++; y = chunkPtr->y; } extra = maxWidth - lineLengths[curLine]; if (justify == TK_JUSTIFY_CENTER) { chunkPtr->x += extra / 2; } else if (justify == TK_JUSTIFY_RIGHT) { chunkPtr->x += extra; } chunkPtr++; } layoutPtr->width = maxWidth; layoutHeight = baseline - fmPtr->ascent; if (layoutPtr->numChunks == 0) { layoutHeight = height; /* * This fake chunk is used by the other procedures so that they can * pretend that there is a chunk with no chars in it, which makes * the coding simpler. */ layoutPtr->numChunks = 1; layoutPtr->chunks[0].start = string; layoutPtr->chunks[0].numChars = 0; layoutPtr->chunks[0].numDisplayChars = -1; layoutPtr->chunks[0].x = 0; layoutPtr->chunks[0].y = fmPtr->ascent; layoutPtr->chunks[0].totalWidth = 0; layoutPtr->chunks[0].displayWidth = 0; } if (widthPtr != NULL) { *widthPtr = layoutPtr->width; } if (heightPtr != NULL) { *heightPtr = layoutHeight; } if (lineLengths != staticLineLengths) { ckfree((char *) lineLengths); } return (Tk_TextLayout) layoutPtr; } /* *--------------------------------------------------------------------------- * * Tk_FreeTextLayout -- * * This procedure is called to release the storage associated with * a Tk_TextLayout when it is no longer needed. * * Results: * None. * * Side effects: * Memory is freed. * *--------------------------------------------------------------------------- */ void Tk_FreeTextLayout(textLayout) Tk_TextLayout textLayout; /* The text layout to be released. */ { TextLayout *layoutPtr; layoutPtr = (TextLayout *) textLayout; if (layoutPtr != NULL) { ckfree((char *) layoutPtr); } } /* *--------------------------------------------------------------------------- * * Tk_DrawTextLayout -- * * Use the information in the Tk_TextLayout token to display a * multi-line, justified string of text. * * This procedure is useful for simple widgets that need to * display single-font, multi-line text and want Tk to handle * the details. * * Results: * None. * * Side effects: * Text drawn on the screen. * *--------------------------------------------------------------------------- */ void Tk_DrawTextLayout(display, drawable, gc, layout, x, y, firstChar, lastChar) Display *display; /* Display on which to draw. */ Drawable drawable; /* Window or pixmap in which to draw. */ GC gc; /* Graphics context to use for drawing text. */ Tk_TextLayout layout; /* Layout information, from a previous call * to Tk_ComputeTextLayout(). */ int x, y; /* Upper-left hand corner of rectangle in * which to draw (pixels). */ int firstChar; /* The index of the first character to draw * from the given text item. 0 specfies the * beginning. */ int lastChar; /* The index just after the last character * to draw from the given text item. A number * < 0 means to draw all characters. */ { TextLayout *layoutPtr; int i, numDisplayChars, drawX; LayoutChunk *chunkPtr; layoutPtr = (TextLayout *) layout; if (layoutPtr == NULL) { return; } if (lastChar < 0) { lastChar = 100000000; } chunkPtr = layoutPtr->chunks; for (i = 0; i < layoutPtr->numChunks; i++) { numDisplayChars = chunkPtr->numDisplayChars; if ((numDisplayChars > 0) && (firstChar < numDisplayChars)) { if (firstChar <= 0) { drawX = 0; firstChar = 0; } else { Tk_MeasureChars(layoutPtr->tkfont, chunkPtr->start, firstChar, 0, 0, &drawX); } if (lastChar < numDisplayChars) { numDisplayChars = lastChar; } Tk_DrawChars(display, drawable, gc, layoutPtr->tkfont, chunkPtr->start + firstChar, numDisplayChars - firstChar, x + chunkPtr->x + drawX, y + chunkPtr->y); } firstChar -= chunkPtr->numChars; lastChar -= chunkPtr->numChars; if (lastChar <= 0) { break; } chunkPtr++; } } /* *--------------------------------------------------------------------------- * * Tk_UnderlineTextLayout -- * * Use the information in the Tk_TextLayout token to display an * underline below an individual character. This procedure does * not draw the text, just the underline. * * This procedure is useful for simple widgets that need to * display single-font, multi-line text with an individual * character underlined and want Tk to handle the details. * To display larger amounts of underlined text, construct * and use an underlined font. * * Results: * None. * * Side effects: * Underline drawn on the screen. * *--------------------------------------------------------------------------- */ void Tk_UnderlineTextLayout(display, drawable, gc, layout, x, y, underline) Display *display; /* Display on which to draw. */ Drawable drawable; /* Window or pixmap in which to draw. */ GC gc; /* Graphics context to use for drawing text. */ Tk_TextLayout layout; /* Layout information, from a previous call * to Tk_ComputeTextLayout(). */ int x, y; /* Upper-left hand corner of rectangle in * which to draw (pixels). */ int underline; /* Index of the single character to * underline, or -1 for no underline. */ { TextLayout *layoutPtr; TkFont *fontPtr; int xx, yy, width, height; if ((Tk_CharBbox(layout, underline, &xx, &yy, &width, &height) != 0) && (width != 0)) { layoutPtr = (TextLayout *) layout; fontPtr = (TkFont *) layoutPtr->tkfont; XFillRectangle(display, drawable, gc, x + xx, y + yy + fontPtr->fm.ascent + fontPtr->underlinePos, (unsigned int) width, (unsigned int) fontPtr->underlineHeight); } } /* *--------------------------------------------------------------------------- * * Tk_PointToChar -- * * Use the information in the Tk_TextLayout token to determine the * character closest to the given point. The point must be * specified with respect to the upper-left hand corner of the * text layout, which is considered to be located at (0, 0). * * Any point whose y-value is less that 0 will be considered closest * to the first character in the text layout; any point whose y-value * is greater than the height of the text layout will be considered * closest to the last character in the text layout. * * Any point whose x-value is less than 0 will be considered closest * to the first character on that line; any point whose x-value is * greater than the width of the text layout will be considered * closest to the last character on that line. * * Results: * The return value is the index of the character that was * closest to the point. Given a text layout with no characters, * the value 0 will always be returned, referring to a hypothetical * zero-width placeholder character. * * Side effects: * None. * *--------------------------------------------------------------------------- */ int Tk_PointToChar(layout, x, y) Tk_TextLayout layout; /* Layout information, from a previous call * to Tk_ComputeTextLayout(). */ int x, y; /* Coordinates of point to check, with * respect to the upper-left corner of the * text layout. */ { TextLayout *layoutPtr; LayoutChunk *chunkPtr, *lastPtr; TkFont *fontPtr; int i, n, dummy, baseline, pos; if (y < 0) { /* * Point lies above any line in this layout. Return the index of * the first char. */ return 0; } /* * Find which line contains the point. */ layoutPtr = (TextLayout *) layout; fontPtr = (TkFont *) layoutPtr->tkfont; lastPtr = chunkPtr = layoutPtr->chunks; for (i = 0; i < layoutPtr->numChunks; i++) { baseline = chunkPtr->y; if (y < baseline + fontPtr->fm.descent) { if (x < chunkPtr->x) { /* * Point is to the left of all chunks on this line. Return * the index of the first character on this line. */ return chunkPtr->start - layoutPtr->string; } if (x >= layoutPtr->width) { /* * If point lies off right side of the text layout, return * the last char in the last chunk on this line. Without * this, it might return the index of the first char that * was located outside of the text layout. */ x = INT_MAX; } /* * Examine all chunks on this line to see which one contains * the specified point. */ lastPtr = chunkPtr; while ((i < layoutPtr->numChunks) && (chunkPtr->y == baseline)) { if (x < chunkPtr->x + chunkPtr->totalWidth) { /* * Point falls on one of the characters in this chunk. */ if (chunkPtr->numDisplayChars < 0) { /* * This is a special chunk that encapsulates a single * tab or newline char. */ return chunkPtr->start - layoutPtr->string; } n = Tk_MeasureChars((Tk_Font) fontPtr, chunkPtr->start, chunkPtr->numChars, x + 1 - chunkPtr->x, TK_PARTIAL_OK, &dummy); return (chunkPtr->start + n - 1) - layoutPtr->string; } lastPtr = chunkPtr; chunkPtr++; i++; } /* * Point is to the right of all chars in all the chunks on this * line. Return the index just past the last char in the last * chunk on this line. */ pos = (lastPtr->start + lastPtr->numChars) - layoutPtr->string; if (i < layoutPtr->numChunks) { pos--; } return pos; } lastPtr = chunkPtr; chunkPtr++; } /* * Point lies below any line in this text layout. Return the index * just past the last char. */ return (lastPtr->start + lastPtr->numChars) - layoutPtr->string; } /* *--------------------------------------------------------------------------- * * Tk_CharBbox -- * * Use the information in the Tk_TextLayout token to return the * bounding box for the character specified by index. * * The width of the bounding box is the advance width of the * character, and does not include and left- or right-bearing. * Any character that extends partially outside of the * text layout is considered to be truncated at the edge. Any * character which is located completely outside of the text * layout is considered to be zero-width and pegged against * the edge. * * The height of the bounding box is the line height for this font, * extending from the top of the ascent to the bottom of the * descent. Information about the actual height of the individual * letter is not available. * * A text layout that contains no characters is considered to * contain a single zero-width placeholder character. * * Results: * The return value is 0 if the index did not specify a character * in the text layout, or non-zero otherwise. In that case, * *bbox is filled with the bounding box of the character. * * Side effects: * None. * *--------------------------------------------------------------------------- */ int Tk_CharBbox(layout, index, xPtr, yPtr, widthPtr, heightPtr) Tk_TextLayout layout; /* Layout information, from a previous call to * Tk_ComputeTextLayout(). */ int index; /* The index of the character whose bbox is * desired. */ int *xPtr, *yPtr; /* Filled with the upper-left hand corner, in * pixels, of the bounding box for the character * specified by index, if non-NULL. */ int *widthPtr, *heightPtr; /* Filled with the width and height of the * bounding box for the character specified by * index, if non-NULL. */ { TextLayout *layoutPtr; LayoutChunk *chunkPtr; int i, x, w; Tk_Font tkfont; TkFont *fontPtr; if (index < 0) { return 0; } layoutPtr = (TextLayout *) layout; chunkPtr = layoutPtr->chunks; tkfont = layoutPtr->tkfont; fontPtr = (TkFont *) tkfont; for (i = 0; i < layoutPtr->numChunks; i++) { if (chunkPtr->numDisplayChars < 0) { if (index == 0) { x = chunkPtr->x; w = chunkPtr->totalWidth; goto check; } } else if (index < chunkPtr->numChars) { if (xPtr != NULL) { Tk_MeasureChars(tkfont, chunkPtr->start, index, 0, 0, &x); x += chunkPtr->x; } if (widthPtr != NULL) { Tk_MeasureChars(tkfont, chunkPtr->start + index, 1, 0, 0, &w); } goto check; } index -= chunkPtr->numChars; chunkPtr++; } if (index == 0) { /* * Special case to get location just past last char in layout. */ chunkPtr--; x = chunkPtr->x + chunkPtr->totalWidth; w = 0; } else { return 0; } /* * Ensure that the bbox lies within the text layout. This forces all * chars that extend off the right edge of the text layout to have * truncated widths, and all chars that are completely off the right * edge of the text layout to peg to the edge and have 0 width. */ check: if (yPtr != NULL) { *yPtr = chunkPtr->y - fontPtr->fm.ascent; } if (heightPtr != NULL) { *heightPtr = fontPtr->fm.ascent + fontPtr->fm.descent; } if (x > layoutPtr->width) { x = layoutPtr->width; } if (xPtr != NULL) { *xPtr = x; } if (widthPtr != NULL) { if (x + w > layoutPtr->width) { w = layoutPtr->width - x; } *widthPtr = w; } return 1; } /* *--------------------------------------------------------------------------- * * Tk_DistanceToTextLayout -- * * Computes the distance in pixels from the given point to the * given text layout. Non-displaying space characters that occur * at the end of individual lines in the text layout are ignored * for hit detection purposes. * * Results: * The return value is 0 if the point (x, y) is inside the text * layout. If the point isn't inside the text layout then the * return value is the distance in pixels from the point to the * text item. * * Side effects: * None. * *--------------------------------------------------------------------------- */ int Tk_DistanceToTextLayout(layout, x, y) Tk_TextLayout layout; /* Layout information, from a previous call * to Tk_ComputeTextLayout(). */ int x, y; /* Coordinates of point to check, with * respect to the upper-left corner of the * text layout (in pixels). */ { int i, x1, x2, y1, y2, xDiff, yDiff, dist, minDist, ascent, descent; LayoutChunk *chunkPtr; TextLayout *layoutPtr; TkFont *fontPtr; layoutPtr = (TextLayout *) layout; fontPtr = (TkFont *) layoutPtr->tkfont; ascent = fontPtr->fm.ascent; descent = fontPtr->fm.descent; minDist = 0; chunkPtr = layoutPtr->chunks; for (i = 0; i < layoutPtr->numChunks; i++) { if (chunkPtr->start[0] == '\n') { /* * Newline characters are not counted when computing distance * (but tab characters would still be considered). */ chunkPtr++; continue; } x1 = chunkPtr->x; y1 = chunkPtr->y - ascent; x2 = chunkPtr->x + chunkPtr->displayWidth; y2 = chunkPtr->y + descent; if (x < x1) { xDiff = x1 - x; } else if (x >= x2) { xDiff = x - x2 + 1; } else { xDiff = 0; } if (y < y1) { yDiff = y1 - y; } else if (y >= y2) { yDiff = y - y2 + 1; } else { yDiff = 0; } if ((xDiff == 0) && (yDiff == 0)) { return 0; } dist = (int) hypot((double) xDiff, (double) yDiff); if ((dist < minDist) || (minDist == 0)) { minDist = dist; } chunkPtr++; } return minDist; } /* *--------------------------------------------------------------------------- * * Tk_IntersectTextLayout -- * * Determines whether a text layout lies entirely inside, * entirely outside, or overlaps a given rectangle. Non-displaying * space characters that occur at the end of individual lines in * the text layout are ignored for intersection calculations. * * Results: * The return value is -1 if the text layout is entirely outside of * the rectangle, 0 if it overlaps, and 1 if it is entirely inside * of the rectangle. * * Side effects: * None. * *--------------------------------------------------------------------------- */ int Tk_IntersectTextLayout(layout, x, y, width, height) Tk_TextLayout layout; /* Layout information, from a previous call * to Tk_ComputeTextLayout(). */ int x, y; /* Upper-left hand corner, in pixels, of * rectangular area to compare with text * layout. Coordinates are with respect to * the upper-left hand corner of the text * layout itself. */ int width, height; /* The width and height of the above * rectangular area, in pixels. */ { int result, i, x1, y1, x2, y2; TextLayout *layoutPtr; LayoutChunk *chunkPtr; TkFont *fontPtr; int left, top, right, bottom; /* * Scan the chunks one at a time, seeing whether each is entirely in, * entirely out, or overlapping the rectangle. If an overlap is * detected, return immediately; otherwise wait until all chunks have * been processed and see if they were all inside or all outside. */ layoutPtr = (TextLayout *) layout; chunkPtr = layoutPtr->chunks; fontPtr = (TkFont *) layoutPtr->tkfont; left = x; top = y; right = x + width; bottom = y + height; result = 0; for (i = 0; i < layoutPtr->numChunks; i++) { if (chunkPtr->start[0] == '\n') { /* * Newline characters are not counted when computing area * intersection (but tab characters would still be considered). */ chunkPtr++; continue; } x1 = chunkPtr->x; y1 = chunkPtr->y - fontPtr->fm.ascent; x2 = chunkPtr->x + chunkPtr->displayWidth; y2 = chunkPtr->y + fontPtr->fm.descent; if ((right < x1) || (left >= x2) || (bottom < y1) || (top >= y2)) { if (result == 1) { return 0; } result = -1; } else if ((x1 < left) || (x2 >= right) || (y1 < top) || (y2 >= bottom)) { return 0; } else if (result == -1) { return 0; } else { result = 1; } chunkPtr++; } return result; } /* *--------------------------------------------------------------------------- * * Tk_TextLayoutToPostscript -- * * Outputs the contents of a text layout in Postscript format. * The set of lines in the text layout will be rendered by the user * supplied Postscript function. The function should be of the form: * * justify x y string function -- * * Justify is -1, 0, or 1, depending on whether the following string * should be left, center, or right justified, x and y is the * location for the origin of the string, string is the sequence * of characters to be printed, and function is the name of the * caller-provided function; the function should leave nothing * on the stack. * * The meaning of the origin of the string (x and y) depends on * the justification. For left justification, x is where the * left edge of the string should appear. For center justification, * x is where the center of the string should appear. And for right * justification, x is where the right edge of the string should * appear. This behavior is necessary because, for example, right * justified text on the screen is justified with screen metrics. * The same string needs to be justified with printer metrics on * the printer to appear in the correct place with respect to other * similarly justified strings. In all circumstances, y is the * location of the baseline for the string. * * Results: * Interp->result is modified to hold the Postscript code that * will render the text layout. * * Side effects: * None. * *--------------------------------------------------------------------------- */ void Tk_TextLayoutToPostscript(interp, layout) Tcl_Interp *interp; /* Filled with Postscript code. */ Tk_TextLayout layout; /* The layout to be rendered. */ { #define MAXUSE 128 char buf[MAXUSE+10]; LayoutChunk *chunkPtr; int i, j, used, c, baseline; TextLayout *layoutPtr; layoutPtr = (TextLayout *) layout; chunkPtr = layoutPtr->chunks; baseline = chunkPtr->y; used = 0; buf[used++] = '('; for (i = 0; i < layoutPtr->numChunks; i++) { if (baseline != chunkPtr->y) { buf[used++] = ')'; buf[used++] = '\n'; buf[used++] = '('; baseline = chunkPtr->y; } if (chunkPtr->numDisplayChars <= 0) { if (chunkPtr->start[0] == '\t') { buf[used++] = '\\'; buf[used++] = 't'; } } else { for (j = 0; j < chunkPtr->numDisplayChars; j++) { c = UCHAR(chunkPtr->start[j]); if ((c == '(') || (c == ')') || (c == '\\') || (c < 0x20) || (c >= UCHAR(0x7f))) { /* * Tricky point: the "03" is necessary in the sprintf * below, so that a full three digits of octal are * always generated. Without the "03", a number * following this sequence could be interpreted by * Postscript as part of this sequence. */ sprintf(buf + used, "\\%03o", c); used += 4; } else { buf[used++] = c; } if (used >= MAXUSE) { buf[used] = '\0'; Tcl_AppendResult(interp, buf, (char *) NULL); used = 0; } } } if (used >= MAXUSE) { /* * If there are a whole bunch of returns or tabs in a row, * then buf[] could get filled up. */ buf[used] = '\0'; Tcl_AppendResult(interp, buf, (char *) NULL); used = 0; } chunkPtr++; } buf[used++] = ')'; buf[used++] = '\n'; buf[used] = '\0'; Tcl_AppendResult(interp, buf, (char *) NULL); } /* *--------------------------------------------------------------------------- * * TkInitFontAttributes -- * * Initialize the font attributes structure to contain sensible * values. This must be called before using any other font * attributes functions. * * Results: * None. * * Side effects. * None. * *--------------------------------------------------------------------------- */ void TkInitFontAttributes(faPtr) TkFontAttributes *faPtr; /* The attributes structure to initialize. */ { faPtr->family = NULL; faPtr->pointsize = 0; faPtr->weight = TK_FW_NORMAL; faPtr->slant = TK_FS_ROMAN; faPtr->underline = 0; faPtr->overstrike = 0; } /* *--------------------------------------------------------------------------- * * ConfigAttributesObj -- * * Process command line options to fill in fields of a properly * initialized font attributes structure. * * Results: * A standard Tcl return value. If TCL_ERROR is returned, an * error message will be left in interp's result object. * * Side effects: * The fields of the font attributes structure get filled in with * information from argc/argv. If an error occurs while parsing, * the font attributes structure will contain all modifications * specified in the command line options up to the point of the * error. * *--------------------------------------------------------------------------- */ static int ConfigAttributesObj(interp, tkwin, objc, objv, faPtr) Tcl_Interp *interp; /* Interp for error return. */ Tk_Window tkwin; /* For display on which font will be used. */ int objc; /* Number of elements in argv. */ Tcl_Obj *CONST objv[]; /* Command line options. */ TkFontAttributes *faPtr; /* Font attributes structure whose fields * are to be modified. Structure must already * be properly initialized. */ { int i, n, index; Tcl_Obj *value; char *option, *string; if (objc & 1) { string = Tcl_GetStringFromObj(objv[objc - 1], NULL); Tcl_AppendStringsToObj(Tcl_GetObjResult(interp), "missing value for \"", string, "\" option", (char *) NULL); return TCL_ERROR; } for (i = 0; i < objc; i += 2) { option = Tcl_GetStringFromObj(objv[i], NULL); value = objv[i + 1]; if (Tcl_GetIndexFromObj(interp, objv[i], fontOpt, "option", 1, &index) != TCL_OK) { return TCL_ERROR; } switch (index) { case FONT_FAMILY: string = Tcl_GetStringFromObj(value, NULL); faPtr->family = Tk_GetUid(string); break; case FONT_SIZE: if (Tcl_GetIntFromObj(interp, value, &n) != TCL_OK) { return TCL_ERROR; } faPtr->pointsize = n; break; case FONT_WEIGHT: string = Tcl_GetStringFromObj(value, NULL); n = TkFindStateNum(interp, option, weightMap, string); if (n == TK_FW_UNKNOWN) { return TCL_ERROR; } faPtr->weight = n; break; case FONT_SLANT: string = Tcl_GetStringFromObj(value, NULL); n = TkFindStateNum(interp, option, slantMap, string); if (n == TK_FS_UNKNOWN) { return TCL_ERROR; } faPtr->slant = n; break; case FONT_UNDERLINE: if (Tcl_GetBooleanFromObj(interp, value, &n) != TCL_OK) { return TCL_ERROR; } faPtr->underline = n; break; case FONT_OVERSTRIKE: if (Tcl_GetBooleanFromObj(interp, value, &n) != TCL_OK) { return TCL_ERROR; } faPtr->overstrike = n; break; } } return TCL_OK; } /* *--------------------------------------------------------------------------- * * GetAttributeInfoObj -- * * Return information about the font attributes as a Tcl list. * * Results: * The return value is TCL_OK if the objPtr was non-NULL and * specified a valid font attribute, TCL_ERROR otherwise. If TCL_OK * is returned, the interp's result object is modified to hold a * description of either the current value of a single option, or a * list of all options and their current values for the given font * attributes. If TCL_ERROR is returned, the interp's result is * set to an error message describing that the objPtr did not refer * to a valid option. * * Side effects: * None. * *--------------------------------------------------------------------------- */ static int GetAttributeInfoObj(interp, faPtr, objPtr) Tcl_Interp *interp; /* Interp to hold result. */ CONST TkFontAttributes *faPtr; /* The font attributes to inspect. */ Tcl_Obj *objPtr; /* If non-NULL, indicates the single * option whose value is to be * returned. Otherwise * information is returned for * all options. */ { int i, index, start, end, num; #ifdef STk_CODE int bool; #endif char *str; Tcl_Obj *newPtr; start = 0; end = FONT_NUMFIELDS; if (objPtr != NULL) { if (Tcl_GetIndexFromObj(interp, objPtr, fontOpt, "option", 1, &index) != TCL_OK) { return TCL_ERROR; } start = index; end = index + 1; } for (i = start; i < end; i++) { str = NULL; num = 0; /* Needed only to prevent compiler * warning. */ #ifdef STk_CODE bool =-1; #endif switch (i) { case FONT_FAMILY: str = faPtr->family; if (str == NULL) { str = ""; } break; case FONT_SIZE: num = faPtr->pointsize; break; case FONT_WEIGHT: str = TkFindStateString(weightMap, faPtr->weight); break; case FONT_SLANT: str = TkFindStateString(slantMap, faPtr->slant); break; case FONT_UNDERLINE: #ifdef STk_CODE bool = faPtr->underline; #else num = faPtr->underline; #endif break; case FONT_OVERSTRIKE: #ifdef STk_CODE bool = faPtr->overstrike; #else num = faPtr->overstrike; #endif break; } if (objPtr == NULL) { Tcl_ListObjAppendElement(NULL, Tcl_GetObjResult(interp), #ifdef STk_CODE STk_NewKeywordObj(fontOpt[i])); #else Tcl_NewStringObj(fontOpt[i], -1)); #endif if (str != NULL) { newPtr = Tcl_NewStringObj(str, -1); } else { #ifdef STk_CODE newPtr = (bool < 0) ? Tcl_NewIntObj(num) : Tcl_NewBooleanObj(bool); #else newPtr = Tcl_NewIntObj(num); #endif } Tcl_ListObjAppendElement(NULL, Tcl_GetObjResult(interp), newPtr); } else { if (str != NULL) { Tcl_SetStringObj(Tcl_GetObjResult(interp), str, -1); } else { #ifdef STk_CODE if (bool >= 0) Tcl_SetBooleanObj(Tcl_GetObjResult(interp), bool); else #endif Tcl_SetIntObj(Tcl_GetObjResult(interp), num); } } } return TCL_OK; } /* *--------------------------------------------------------------------------- * * ParseFontNameObj -- * * Converts a object into a set of font attributes that can be used * to construct a font. * * The string rep of the object can be one of the following forms: * XLFD (see X documentation) * "Family [size [style] [style ...]]" * "-option value [-option value ...]" * * Results: * The return value is TCL_ERROR if the object was syntactically * invalid. In that case an error message is left in interp's * result object. Otherwise, fills the font attribute buffer with * the values parsed from the string and returns TCL_OK; * * Side effects: * None. * *--------------------------------------------------------------------------- */ static int ParseFontNameObj(interp, tkwin, objPtr, faPtr) Tcl_Interp *interp; /* Interp for error return. */ Tk_Window tkwin; /* For display on which font is used. */ Tcl_Obj *objPtr; /* Parseable font description object. */ TkFontAttributes *faPtr; /* Font attributes structure whose fields * are to be modified. Structure must already * be properly initialized. */ { char *dash; int objc, result, i, n; Tcl_Obj **objv; TkXLFDAttributes xa; char *string; string = Tcl_GetStringFromObj(objPtr, NULL); if (*string == '-') { /* * This may be an XLFD or an "-option value" string. * * If the string begins with "-*" or a "-foundry-family-*" pattern, * then consider it an XLFD. */ if (string[1] == '*') { goto xlfd; } dash = strchr(string + 1, '-'); if ((dash != NULL) && (!isspace(UCHAR(dash[-1])))) { goto xlfd; } if (Tcl_ListObjGetElements(interp, objPtr, &objc, &objv) != TCL_OK) { return TCL_ERROR; } return ConfigAttributesObj(interp, tkwin, objc, objv, faPtr); } if (*string == '*') { /* * This appears to be an XLFD. */ xlfd: xa.fa = *faPtr; result = TkParseXLFD(string, &xa); if (result == TCL_OK) { *faPtr = xa.fa; return result; } } /* * Wasn't an XLFD or "-option value" string. Try it as a * "font size style" list. */ if (Tcl_ListObjGetElements(interp, objPtr, &objc, &objv) != TCL_OK) { return TCL_ERROR; } if (objc < 1) { Tcl_AppendStringsToObj(Tcl_GetObjResult(interp), "font \"", string, "\" doesn't exist", (char *) NULL); return TCL_ERROR; } faPtr->family = Tk_GetUid(Tcl_GetStringFromObj(objv[0], NULL)); if (objc > 1) { if (Tcl_GetIntFromObj(interp, objv[1], &n) != TCL_OK) { return TCL_ERROR; } faPtr->pointsize = n; } i = 2; if (objc == 3) { if (Tcl_ListObjGetElements(interp, objv[2], &objc, &objv) != TCL_OK) { return TCL_ERROR; } i = 0; } for ( ; i < objc; i++) { string = Tcl_GetStringFromObj(objv[i], NULL); n = TkFindStateNum(NULL, NULL, weightMap, string); if (n != TK_FW_UNKNOWN) { faPtr->weight = n; continue; } n = TkFindStateNum(NULL, NULL, slantMap, string); if (n != TK_FS_UNKNOWN) { faPtr->slant = n; continue; } n = TkFindStateNum(NULL, NULL, underlineMap, string); if (n != 0) { faPtr->underline = n; continue; } n = TkFindStateNum(NULL, NULL, overstrikeMap, string); if (n != 0) { faPtr->overstrike = n; continue; } /* * Unknown style. */ Tcl_AppendStringsToObj(Tcl_GetObjResult(interp), "unknown font style \"", string, "\"", (char *) NULL); return TCL_ERROR; } return TCL_OK; } /* *--------------------------------------------------------------------------- * * TkParseXLFD -- * * Break up a fully specified XLFD into a set of font attributes. * * Results: * Return value is TCL_ERROR if string was not a fully specified XLFD. * Otherwise, fills font attribute buffer with the values parsed * from the XLFD and returns TCL_OK. * * Side effects: * None. * *--------------------------------------------------------------------------- */ int TkParseXLFD(string, xaPtr) CONST char *string; /* Parseable font description string. */ TkXLFDAttributes *xaPtr; /* XLFD attributes structure whose fields * are to be modified. Structure must already * be properly initialized. */ { char *src; CONST char *str; int i, j; char *field[XLFD_NUMFIELDS + 2]; Tcl_DString ds; memset(field, '\0', sizeof(field)); str = string; if (*str == '-') { str++; } Tcl_DStringInit(&ds); Tcl_DStringAppend(&ds, (char *) str, -1); src = Tcl_DStringValue(&ds); field[0] = src; for (i = 0; *src != '\0'; src++) { if (isupper(UCHAR(*src))) { *src = tolower(UCHAR(*src)); } if (*src == '-') { i++; if (i > XLFD_NUMFIELDS) { break; } *src = '\0'; field[i] = src + 1; } } /* * An XLFD of the form -adobe-times-medium-r-*-12-*-* is pretty common, * but it is (strictly) malformed, because the first * is eliding both * the Setwidth and the Addstyle fields. If the Addstyle field is a * number, then assume the above incorrect form was used and shift all * the rest of the fields up by one, so the number gets interpreted * as a pixelsize. This fix is so that we don't get a million reports * that "it works under X, but gives a syntax error under Windows". */ if ((i > XLFD_ADD_STYLE) && (FieldSpecified(field[XLFD_ADD_STYLE]))) { if (atoi(field[XLFD_ADD_STYLE]) != 0) { for (j = XLFD_NUMFIELDS - 1; j >= XLFD_ADD_STYLE; j--) { field[j + 1] = field[j]; } field[XLFD_ADD_STYLE] = NULL; i++; } } /* * Bail if we don't have enough of the fields (up to pointsize). */ if (i < XLFD_FAMILY) { Tcl_DStringFree(&ds); return TCL_ERROR; } if (FieldSpecified(field[XLFD_FOUNDRY])) { xaPtr->foundry = Tk_GetUid(field[XLFD_FOUNDRY]); } if (FieldSpecified(field[XLFD_FAMILY])) { xaPtr->fa.family = Tk_GetUid(field[XLFD_FAMILY]); } if (FieldSpecified(field[XLFD_WEIGHT])) { xaPtr->fa.weight = TkFindStateNum(NULL, NULL, xlfdWeightMap, field[XLFD_WEIGHT]); } if (FieldSpecified(field[XLFD_SLANT])) { xaPtr->slant = TkFindStateNum(NULL, NULL, xlfdSlantMap, field[XLFD_SLANT]); if (xaPtr->slant == TK_FS_ROMAN) { xaPtr->fa.slant = TK_FS_ROMAN; } else { xaPtr->fa.slant = TK_FS_ITALIC; } } if (FieldSpecified(field[XLFD_SETWIDTH])) { xaPtr->setwidth = TkFindStateNum(NULL, NULL, xlfdSetwidthMap, field[XLFD_SETWIDTH]); } /* XLFD_ADD_STYLE ignored. */ /* * Pointsize in tenths of a point, but treat it as tenths of a pixel. */ if (FieldSpecified(field[XLFD_POINT_SIZE])) { if (field[XLFD_POINT_SIZE][0] == '[') { /* * Some X fonts have the point size specified as follows: * * [ N1 N2 N3 N4 ] * * where N1 is the point size (in points, not decipoints!), and * N2, N3, and N4 are some additional numbers that I don't know * the purpose of, so I ignore them. */ xaPtr->fa.pointsize = atoi(field[XLFD_POINT_SIZE] + 1); } else if (Tcl_GetInt(NULL, field[XLFD_POINT_SIZE], &xaPtr->fa.pointsize) == TCL_OK) { xaPtr->fa.pointsize /= 10; } else { return TCL_ERROR; } } /* * Pixel height of font. If specified, overrides pointsize. */ if (FieldSpecified(field[XLFD_PIXEL_SIZE])) { if (field[XLFD_PIXEL_SIZE][0] == '[') { /* * Some X fonts have the pixel size specified as follows: * * [ N1 N2 N3 N4 ] * * where N1 is the pixel size, and where N2, N3, and N4 * are some additional numbers that I don't know * the purpose of, so I ignore them. */ xaPtr->fa.pointsize = atoi(field[XLFD_PIXEL_SIZE] + 1); } else if (Tcl_GetInt(NULL, field[XLFD_PIXEL_SIZE], &xaPtr->fa.pointsize) != TCL_OK) { return TCL_ERROR; } } xaPtr->fa.pointsize = -xaPtr->fa.pointsize; /* XLFD_RESOLUTION_X ignored. */ /* XLFD_RESOLUTION_Y ignored. */ /* XLFD_SPACING ignored. */ /* XLFD_AVERAGE_WIDTH ignored. */ if (FieldSpecified(field[XLFD_REGISTRY])) { xaPtr->charset = TkFindStateNum(NULL, NULL, xlfdCharsetMap, field[XLFD_REGISTRY]); } if (FieldSpecified(field[XLFD_ENCODING])) { xaPtr->encoding = atoi(field[XLFD_ENCODING]); } Tcl_DStringFree(&ds); return TCL_OK; } /* *--------------------------------------------------------------------------- * * FieldSpecified -- * * Helper function for TkParseXLFD(). Determines if a field in the * XLFD was set to a non-null, non-don't-care value. * * Results: * The return value is 0 if the field in the XLFD was not set and * should be ignored, non-zero otherwise. * * Side effects: * None. * *--------------------------------------------------------------------------- */ static int FieldSpecified(field) CONST char *field; /* The field of the XLFD to check. Strictly * speaking, only when the string is "*" does it mean * don't-care. However, an unspecified or question * mark is also interpreted as don't-care. */ { char ch; if (field == NULL) { return 0; } ch = field[0]; return (ch != '*' && ch != '?'); } /* *--------------------------------------------------------------------------- * * NewChunk -- * * Helper function for Tk_ComputeTextLayout(). Encapsulates a * measured set of characters in a chunk that can be quickly * drawn. * * Results: * A pointer to the new chunk in the text layout. * * Side effects: * The text layout is reallocated to hold more chunks as necessary. * * Currently, Tk_ComputeTextLayout() stores contiguous ranges of * "normal" characters in a chunk, along with individual tab * and newline chars in their own chunks. All characters in the * text layout are accounted for. * *--------------------------------------------------------------------------- */ static LayoutChunk * NewChunk(layoutPtrPtr, maxPtr, start, numChars, curX, newX, y) TextLayout **layoutPtrPtr; int *maxPtr; CONST char *start; int numChars; int curX; int newX; int y; { TextLayout *layoutPtr; LayoutChunk *chunkPtr; int maxChunks; size_t s; layoutPtr = *layoutPtrPtr; maxChunks = *maxPtr; if (layoutPtr->numChunks == maxChunks) { maxChunks *= 2; s = sizeof(TextLayout) + ((maxChunks - 1) * sizeof(LayoutChunk)); layoutPtr = (TextLayout *) ckrealloc((char *) layoutPtr, s); *layoutPtrPtr = layoutPtr; *maxPtr = maxChunks; } chunkPtr = &layoutPtr->chunks[layoutPtr->numChunks]; chunkPtr->start = start; chunkPtr->numChars = numChars; chunkPtr->numDisplayChars = numChars; chunkPtr->x = curX; chunkPtr->y = y; chunkPtr->totalWidth = newX - curX; chunkPtr->displayWidth = newX - curX; layoutPtr->numChunks++; return chunkPtr; }