785 lines
22 KiB
C
785 lines
22 KiB
C
|
/*
|
|||
|
* tkFont.c --
|
|||
|
*
|
|||
|
* This file maintains a database of looked-up fonts for the Tk
|
|||
|
* toolkit, in order to avoid round-trips to the server to map
|
|||
|
* font names to XFontStructs.
|
|||
|
*
|
|||
|
* Copyright (c) 1990-1993 The Regents of the University of California.
|
|||
|
* All rights reserved.
|
|||
|
*
|
|||
|
* Permission is hereby granted, without written agreement and without
|
|||
|
* license or royalty fees, to use, copy, modify, and distribute this
|
|||
|
* software and its documentation for any purpose, provided that the
|
|||
|
* above copyright notice and the following two paragraphs appear in
|
|||
|
* all copies of this software.
|
|||
|
*
|
|||
|
* IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
|
|||
|
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
|
|||
|
* OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
|
|||
|
* CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
*
|
|||
|
* THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
|
|||
|
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
|
|||
|
* AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
|
|||
|
* ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
|
|||
|
* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
|
|||
|
*/
|
|||
|
|
|||
|
#ifndef lint
|
|||
|
static char rcsid[] = "$Header: /user6/ouster/wish/RCS/tkFont.c,v 1.24 93/08/18 16:25:30 ouster Exp $ SPRITE (Berkeley)";
|
|||
|
#endif
|
|||
|
|
|||
|
#include "tkConfig.h"
|
|||
|
#include "tkInt.h"
|
|||
|
|
|||
|
/*
|
|||
|
* This module caches extra information about fonts in addition to
|
|||
|
* what X already provides. The extra information is used by the
|
|||
|
* TkMeasureChars procedure, and consists of two parts: a type and
|
|||
|
* a width. The type is one of the following:
|
|||
|
*
|
|||
|
* NORMAL: Standard character.
|
|||
|
* TAB: Tab character: output enough space to
|
|||
|
* get to next tab stop.
|
|||
|
* NEWLINE: Newline character: don't output anything more
|
|||
|
* on this line (character has infinite width).
|
|||
|
* REPLACE: This character doesn't print: instead of
|
|||
|
* displaying character, display a replacement
|
|||
|
* sequence of the form "\xdd" where dd is the
|
|||
|
* hex equivalent of the character.
|
|||
|
* SKIP: Don't display anything for this character. This
|
|||
|
* is only used where the font doesn't contain
|
|||
|
* all the characters needed to generate
|
|||
|
* replacement sequences.
|
|||
|
* The width gives the total width of the displayed character or
|
|||
|
* sequence: for replacement sequences, it gives the width of the
|
|||
|
* sequence.
|
|||
|
*/
|
|||
|
|
|||
|
#define NORMAL 1
|
|||
|
#define TAB 2
|
|||
|
#define NEWLINE 3
|
|||
|
#define REPLACE 4
|
|||
|
#define SKIP 5
|
|||
|
|
|||
|
/*
|
|||
|
* One of the following data structures exists for each font that is
|
|||
|
* currently active. The structure is indexed with two hash tables,
|
|||
|
* one based on font name and one based on XFontStruct address.
|
|||
|
*/
|
|||
|
|
|||
|
typedef struct {
|
|||
|
XFontStruct *fontStructPtr; /* X information about font. */
|
|||
|
Display *display; /* Display to which font belongs. */
|
|||
|
int refCount; /* Number of active uses of this font. */
|
|||
|
char *types; /* Malloc'ed array giving types of all
|
|||
|
* chars in the font (may be NULL). */
|
|||
|
unsigned char *widths; /* Malloc'ed array giving widths of all
|
|||
|
* chars in the font (may be NULL). */
|
|||
|
int tabWidth; /* Width of tabs in this font. */
|
|||
|
Tcl_HashEntry *nameHashPtr; /* Entry in name-based hash table (needed
|
|||
|
* when deleting this structure). */
|
|||
|
} TkFont;
|
|||
|
|
|||
|
/*
|
|||
|
* Hash table for name -> TkFont mapping, and key structure used to
|
|||
|
* index into that table:
|
|||
|
*/
|
|||
|
|
|||
|
static Tcl_HashTable nameTable;
|
|||
|
typedef struct {
|
|||
|
Tk_Uid name; /* Name of font. */
|
|||
|
Display *display; /* Display for which font is valid. */
|
|||
|
} NameKey;
|
|||
|
|
|||
|
/*
|
|||
|
* Hash table for font struct -> TkFont mapping. This table is
|
|||
|
* indexed by the XFontStruct address.
|
|||
|
*/
|
|||
|
|
|||
|
static Tcl_HashTable fontTable;
|
|||
|
|
|||
|
static int initialized = 0; /* 0 means static structures haven't been
|
|||
|
* initialized yet. */
|
|||
|
|
|||
|
/*
|
|||
|
* To speed up TkMeasureChars, the variables below keep the last
|
|||
|
* mapping from (XFontStruct *) to (TkFont *).
|
|||
|
*/
|
|||
|
|
|||
|
static TkFont *lastFontPtr = NULL;
|
|||
|
static XFontStruct *lastFontStructPtr = NULL;
|
|||
|
|
|||
|
/*
|
|||
|
* Characters used when displaying control sequences as their
|
|||
|
* hex equivalents.
|
|||
|
*/
|
|||
|
|
|||
|
static char hexChars[] = "0123456789abcdefx\\";
|
|||
|
|
|||
|
/*
|
|||
|
* Forward declarations for procedures defined in this file:
|
|||
|
*/
|
|||
|
|
|||
|
static void FontInit _ANSI_ARGS_((void));
|
|||
|
static void SetFontMetrics _ANSI_ARGS_((TkFont *fontPtr));
|
|||
|
|
|||
|
/*
|
|||
|
*----------------------------------------------------------------------
|
|||
|
*
|
|||
|
* Tk_GetFontStruct --
|
|||
|
*
|
|||
|
* Given a string name for a font, map the name to an XFontStruct
|
|||
|
* describing the font.
|
|||
|
*
|
|||
|
* Results:
|
|||
|
* The return value is normally a pointer to the font description
|
|||
|
* for the desired font. If an error occurs in mapping the string
|
|||
|
* to a font, then an error message will be left in interp->result
|
|||
|
* and NULL will be returned.
|
|||
|
*
|
|||
|
* 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_FreeFontStruct, so that the database is cleaned up when fonts
|
|||
|
* aren't in use anymore.
|
|||
|
*
|
|||
|
*----------------------------------------------------------------------
|
|||
|
*/
|
|||
|
|
|||
|
XFontStruct *
|
|||
|
Tk_GetFontStruct(interp, tkwin, name)
|
|||
|
Tcl_Interp *interp; /* Place to leave error message if
|
|||
|
* font can't be found. */
|
|||
|
Tk_Window tkwin; /* Window in which font will be used. */
|
|||
|
Tk_Uid name; /* Name of font (in form suitable for
|
|||
|
* passing to XLoadQueryFont). */
|
|||
|
{
|
|||
|
NameKey nameKey;
|
|||
|
Tcl_HashEntry *nameHashPtr, *fontHashPtr;
|
|||
|
int new;
|
|||
|
register TkFont *fontPtr;
|
|||
|
XFontStruct *fontStructPtr;
|
|||
|
|
|||
|
if (!initialized) {
|
|||
|
FontInit();
|
|||
|
}
|
|||
|
|
|||
|
/*
|
|||
|
* First, check to see if there's already a mapping for this font
|
|||
|
* name.
|
|||
|
*/
|
|||
|
|
|||
|
nameKey.name = name;
|
|||
|
nameKey.display = Tk_Display(tkwin);
|
|||
|
nameHashPtr = Tcl_CreateHashEntry(&nameTable, (char *) &nameKey, &new);
|
|||
|
if (!new) {
|
|||
|
fontPtr = (TkFont *) Tcl_GetHashValue(nameHashPtr);
|
|||
|
fontPtr->refCount++;
|
|||
|
return fontPtr->fontStructPtr;
|
|||
|
}
|
|||
|
|
|||
|
/*
|
|||
|
* The name isn't currently known. Map from the name to a font, and
|
|||
|
* add a new structure to the database.
|
|||
|
*/
|
|||
|
|
|||
|
fontStructPtr = XLoadQueryFont(nameKey.display, name);
|
|||
|
if (fontStructPtr == NULL) {
|
|||
|
Tcl_DeleteHashEntry(nameHashPtr);
|
|||
|
Tcl_AppendResult(interp, "font \"", name, "\" doesn't exist",
|
|||
|
(char *) NULL);
|
|||
|
return NULL;
|
|||
|
}
|
|||
|
fontPtr = (TkFont *) ckalloc(sizeof(TkFont));
|
|||
|
fontPtr->display = nameKey.display;
|
|||
|
fontPtr->fontStructPtr = fontStructPtr;
|
|||
|
fontPtr->refCount = 1;
|
|||
|
fontPtr->types = NULL;
|
|||
|
fontPtr->widths = NULL;
|
|||
|
fontPtr->nameHashPtr = nameHashPtr;
|
|||
|
fontHashPtr = Tcl_CreateHashEntry(&fontTable, (char *) fontStructPtr, &new);
|
|||
|
if (!new) {
|
|||
|
panic("XFontStruct already registered in Tk_GetFontStruct");
|
|||
|
}
|
|||
|
Tcl_SetHashValue(nameHashPtr, fontPtr);
|
|||
|
Tcl_SetHashValue(fontHashPtr, fontPtr);
|
|||
|
return fontPtr->fontStructPtr;
|
|||
|
}
|
|||
|
|
|||
|
/*
|
|||
|
*--------------------------------------------------------------
|
|||
|
*
|
|||
|
* Tk_NameOfFontStruct --
|
|||
|
*
|
|||
|
* Given a font, return a textual string identifying it.
|
|||
|
*
|
|||
|
* Results:
|
|||
|
* If font was created by Tk_GetFontStruct, then the return
|
|||
|
* value is the "string" that was used to create it.
|
|||
|
* Otherwise the return value is a string giving the X
|
|||
|
* identifier for the font. The storage for the returned
|
|||
|
* string is only guaranteed to persist up until the next
|
|||
|
* call to this procedure.
|
|||
|
*
|
|||
|
* Side effects:
|
|||
|
* None.
|
|||
|
*
|
|||
|
*--------------------------------------------------------------
|
|||
|
*/
|
|||
|
|
|||
|
char *
|
|||
|
Tk_NameOfFontStruct(fontStructPtr)
|
|||
|
XFontStruct *fontStructPtr; /* Font whose name is desired. */
|
|||
|
{
|
|||
|
Tcl_HashEntry *fontHashPtr;
|
|||
|
TkFont *fontPtr;
|
|||
|
static char string[20];
|
|||
|
|
|||
|
if (!initialized) {
|
|||
|
printid:
|
|||
|
sprintf(string, "font id 0x%x", fontStructPtr->fid);
|
|||
|
return string;
|
|||
|
}
|
|||
|
fontHashPtr = Tcl_FindHashEntry(&fontTable, (char *) fontStructPtr);
|
|||
|
if (fontHashPtr == NULL) {
|
|||
|
goto printid;
|
|||
|
}
|
|||
|
fontPtr = (TkFont *) Tcl_GetHashValue(fontHashPtr);
|
|||
|
return ((NameKey *) fontPtr->nameHashPtr->key.words)->name;
|
|||
|
}
|
|||
|
|
|||
|
/*
|
|||
|
*----------------------------------------------------------------------
|
|||
|
*
|
|||
|
* Tk_FreeFontStruct --
|
|||
|
*
|
|||
|
* This procedure is called to release a font allocated by
|
|||
|
* Tk_GetFontStruct.
|
|||
|
*
|
|||
|
* Results:
|
|||
|
* None.
|
|||
|
*
|
|||
|
* Side effects:
|
|||
|
* The reference count associated with font is decremented, and
|
|||
|
* the font is officially deallocated if no-one is using it
|
|||
|
* anymore.
|
|||
|
*
|
|||
|
*----------------------------------------------------------------------
|
|||
|
*/
|
|||
|
|
|||
|
void
|
|||
|
Tk_FreeFontStruct(fontStructPtr)
|
|||
|
XFontStruct *fontStructPtr; /* Font to be released. */
|
|||
|
{
|
|||
|
Tcl_HashEntry *fontHashPtr;
|
|||
|
register TkFont *fontPtr;
|
|||
|
|
|||
|
if (!initialized) {
|
|||
|
panic("Tk_FreeFontStruct called before Tk_GetFontStruct");
|
|||
|
}
|
|||
|
|
|||
|
fontHashPtr = Tcl_FindHashEntry(&fontTable, (char *) fontStructPtr);
|
|||
|
if (fontHashPtr == NULL) {
|
|||
|
panic("Tk_FreeFontStruct received unknown font argument");
|
|||
|
}
|
|||
|
fontPtr = (TkFont *) Tcl_GetHashValue(fontHashPtr);
|
|||
|
fontPtr->refCount--;
|
|||
|
if (fontPtr->refCount == 0) {
|
|||
|
XFreeFont(fontPtr->display, fontPtr->fontStructPtr);
|
|||
|
Tcl_DeleteHashEntry(fontPtr->nameHashPtr);
|
|||
|
Tcl_DeleteHashEntry(fontHashPtr);
|
|||
|
if (fontPtr->types != NULL) {
|
|||
|
ckfree(fontPtr->types);
|
|||
|
}
|
|||
|
if (fontPtr->widths != NULL) {
|
|||
|
ckfree((char *) fontPtr->widths);
|
|||
|
}
|
|||
|
ckfree((char *) fontPtr);
|
|||
|
lastFontStructPtr = NULL;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
/*
|
|||
|
*----------------------------------------------------------------------
|
|||
|
*
|
|||
|
* FontInit --
|
|||
|
*
|
|||
|
* Initialize the structure used for font management.
|
|||
|
*
|
|||
|
* Results:
|
|||
|
* None.
|
|||
|
*
|
|||
|
* Side effects:
|
|||
|
* Read the code.
|
|||
|
*
|
|||
|
*----------------------------------------------------------------------
|
|||
|
*/
|
|||
|
|
|||
|
static void
|
|||
|
FontInit()
|
|||
|
{
|
|||
|
initialized = 1;
|
|||
|
Tcl_InitHashTable(&nameTable, sizeof(NameKey)/sizeof(int));
|
|||
|
Tcl_InitHashTable(&fontTable, TCL_ONE_WORD_KEYS);
|
|||
|
}
|
|||
|
|
|||
|
/*
|
|||
|
*--------------------------------------------------------------
|
|||
|
*
|
|||
|
* SetFontMetrics --
|
|||
|
*
|
|||
|
* This procedure is called to fill in the "widths" and "types"
|
|||
|
* arrays for a font.
|
|||
|
*
|
|||
|
* Results:
|
|||
|
* None.
|
|||
|
*
|
|||
|
* Side effects:
|
|||
|
* FontPtr gets modified to hold font metric information.
|
|||
|
*
|
|||
|
*--------------------------------------------------------------
|
|||
|
*/
|
|||
|
|
|||
|
static void
|
|||
|
SetFontMetrics(fontPtr)
|
|||
|
register TkFont *fontPtr; /* Font structure in which to
|
|||
|
* set metrics. */
|
|||
|
{
|
|||
|
int i, replaceOK, baseWidth;
|
|||
|
register XFontStruct *fontStructPtr = fontPtr->fontStructPtr;
|
|||
|
char *p;
|
|||
|
|
|||
|
/*
|
|||
|
* Pass 1: initialize the arrays.
|
|||
|
*/
|
|||
|
|
|||
|
fontPtr->types = (char *) ckalloc(256);
|
|||
|
fontPtr->widths = (unsigned char *) ckalloc(256);
|
|||
|
for (i = 0; i < 256; i++) {
|
|||
|
fontPtr->types[i] = REPLACE;
|
|||
|
}
|
|||
|
|
|||
|
/*
|
|||
|
* Pass 2: for all characters that exist in the font and are
|
|||
|
* not control characters, fill in the type and width
|
|||
|
* information.
|
|||
|
*/
|
|||
|
|
|||
|
for (i = ' '; i < 256; i++) {
|
|||
|
if ((i == 0177) || (i < fontStructPtr->min_char_or_byte2)
|
|||
|
|| (i > fontStructPtr->max_char_or_byte2)) {
|
|||
|
continue;
|
|||
|
}
|
|||
|
fontPtr->types[i] = NORMAL;
|
|||
|
if (fontStructPtr->per_char == NULL) {
|
|||
|
fontPtr->widths[i] = fontStructPtr->min_bounds.width;
|
|||
|
} else {
|
|||
|
fontPtr->widths[i] = fontStructPtr->per_char[i
|
|||
|
- fontStructPtr->min_char_or_byte2].width;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
/*
|
|||
|
* Pass 3: fill in information for characters that have to
|
|||
|
* be replaced with "\xhh" strings. If the font doesn't
|
|||
|
* have the characters needed for this, then just use the
|
|||
|
* font's default character.
|
|||
|
*/
|
|||
|
|
|||
|
replaceOK = 1;
|
|||
|
baseWidth = fontPtr->widths['\\'] + fontPtr->widths['x'];
|
|||
|
for (p = hexChars; *p != 0; p++) {
|
|||
|
if (fontPtr->types[*p] != NORMAL) {
|
|||
|
replaceOK = 0;
|
|||
|
break;
|
|||
|
}
|
|||
|
}
|
|||
|
for (i = 0; i < 256; i++) {
|
|||
|
if (fontPtr->types[i] != REPLACE) {
|
|||
|
continue;
|
|||
|
}
|
|||
|
if (replaceOK) {
|
|||
|
fontPtr->widths[i] = baseWidth
|
|||
|
+ fontPtr->widths[hexChars[i & 0xf]]
|
|||
|
+ fontPtr->widths[hexChars[(i>>4) & 0xf]];
|
|||
|
} else {
|
|||
|
fontPtr->types[i] = SKIP;
|
|||
|
fontPtr->widths[i] = 0;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
/*
|
|||
|
* Lastly, fill in special information for newline and tab.
|
|||
|
*/
|
|||
|
|
|||
|
fontPtr->types['\n'] = NEWLINE;
|
|||
|
fontPtr->widths['\n'] = 0;
|
|||
|
fontPtr->types['\t'] = TAB;
|
|||
|
fontPtr->widths['\t'] = 0;
|
|||
|
if (fontPtr->types['0'] == NORMAL) {
|
|||
|
fontPtr->tabWidth = 8*fontPtr->widths['0'];
|
|||
|
} else {
|
|||
|
fontPtr->tabWidth = 8*fontStructPtr->max_bounds.width;
|
|||
|
}
|
|||
|
|
|||
|
/*
|
|||
|
* 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;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
/*
|
|||
|
*--------------------------------------------------------------
|
|||
|
*
|
|||
|
* TkMeasureChars --
|
|||
|
*
|
|||
|
* Measure the number of characters from a string that
|
|||
|
* will fit in a given horizontal span. The measurement
|
|||
|
* is done under the assumption that TkDisplayChars will
|
|||
|
* be used to actually display the characters.
|
|||
|
*
|
|||
|
* Results:
|
|||
|
* The return value is the number of characters from source
|
|||
|
* that fit in the span given by startX and maxX. *nextXPtr
|
|||
|
* is filled in with the x-coordinate at which the first
|
|||
|
* character that didn't fit would be drawn, if it were to
|
|||
|
* be drawn.
|
|||
|
*
|
|||
|
* Side effects:
|
|||
|
* None.
|
|||
|
*
|
|||
|
*--------------------------------------------------------------
|
|||
|
*/
|
|||
|
|
|||
|
int
|
|||
|
TkMeasureChars(fontStructPtr, source, maxChars, startX, maxX, flags, nextXPtr)
|
|||
|
XFontStruct *fontStructPtr; /* Font in which to draw characters. */
|
|||
|
char *source; /* Characters to be displayed. Need not
|
|||
|
* be NULL-terminated. */
|
|||
|
int maxChars; /* Maximum # of characters to consider from
|
|||
|
* source. */
|
|||
|
int startX; /* X-position at which first character will
|
|||
|
* be drawn. */
|
|||
|
int maxX; /* Don't consider any character that would
|
|||
|
* cross this x-position. */
|
|||
|
int flags; /* Various flag bits OR-ed together.
|
|||
|
* TK_WHOLE_WORDS means stop on a word boundary
|
|||
|
* (just before a space character) if
|
|||
|
* possible. TK_AT_LEAST_ONE means always
|
|||
|
* return a value of at least one, even
|
|||
|
* if the character doesn't fit.
|
|||
|
* TK_PARTIAL_OK means it's OK to display only
|
|||
|
* a part of the last character in the line.
|
|||
|
* TK_NEWLINES_NOT_SPECIAL means that newlines
|
|||
|
* are treated just like other control chars:
|
|||
|
* they don't terminate the line,*/
|
|||
|
int *nextXPtr; /* Return x-position of terminating
|
|||
|
* character here. */
|
|||
|
{
|
|||
|
register TkFont *fontPtr;
|
|||
|
register char *p; /* Current character. */
|
|||
|
register int c;
|
|||
|
char *term; /* Pointer to most recent character that
|
|||
|
* may legally be a terminating character. */
|
|||
|
int termX; /* X-position just after term. */
|
|||
|
int curX; /* X-position corresponding to p. */
|
|||
|
int newX; /* X-position corresponding to p+1. */
|
|||
|
int type;
|
|||
|
|
|||
|
/*
|
|||
|
* Find the TkFont structure for this font, and make sure its
|
|||
|
* font metrics exist.
|
|||
|
*/
|
|||
|
|
|||
|
if (lastFontStructPtr == fontStructPtr) {
|
|||
|
fontPtr = lastFontPtr;
|
|||
|
} else {
|
|||
|
Tcl_HashEntry *fontHashPtr;
|
|||
|
|
|||
|
if (!initialized) {
|
|||
|
badArg:
|
|||
|
panic("TkMeasureChars received unknown font argument");
|
|||
|
}
|
|||
|
|
|||
|
fontHashPtr = Tcl_FindHashEntry(&fontTable, (char *) fontStructPtr);
|
|||
|
if (fontHashPtr == NULL) {
|
|||
|
goto badArg;
|
|||
|
}
|
|||
|
fontPtr = (TkFont *) Tcl_GetHashValue(fontHashPtr);
|
|||
|
lastFontStructPtr = fontPtr->fontStructPtr;
|
|||
|
lastFontPtr = fontPtr;
|
|||
|
}
|
|||
|
if (fontPtr->types == NULL) {
|
|||
|
SetFontMetrics(fontPtr);
|
|||
|
}
|
|||
|
|
|||
|
/*
|
|||
|
* Scan the input string one character at a time, until a character
|
|||
|
* is found that crosses maxX.
|
|||
|
*/
|
|||
|
|
|||
|
newX = curX = startX;
|
|||
|
termX = 0; /* Not needed, but eliminates compiler warning. */
|
|||
|
term = source;
|
|||
|
for (p = source, c = *p & 0xff; maxChars > 0; p++, maxChars--) {
|
|||
|
type = fontPtr->types[c];
|
|||
|
if (type == NORMAL) {
|
|||
|
newX += fontPtr->widths[c];
|
|||
|
} else if (type == TAB) {
|
|||
|
newX += fontPtr->tabWidth;
|
|||
|
newX -= newX % fontPtr->tabWidth;
|
|||
|
} else if (type == REPLACE) {
|
|||
|
replaceType:
|
|||
|
newX += fontPtr->widths['\\'] + fontPtr->widths['x']
|
|||
|
+ fontPtr->widths[hexChars[(c >> 4) & 0xf]]
|
|||
|
+ fontPtr->widths[hexChars[c & 0xf]];
|
|||
|
} else if (type == NEWLINE) {
|
|||
|
if (flags & TK_NEWLINES_NOT_SPECIAL) {
|
|||
|
goto replaceType;
|
|||
|
}
|
|||
|
break;
|
|||
|
} else if (type != SKIP) {
|
|||
|
panic("Unknown type %d in TkMeasureChars", type);
|
|||
|
}
|
|||
|
if (newX > maxX) {
|
|||
|
break;
|
|||
|
}
|
|||
|
c = p[1] & 0xff;
|
|||
|
if (isspace(UCHAR(c)) || (c == 0)) {
|
|||
|
term = p+1;
|
|||
|
termX = newX;
|
|||
|
}
|
|||
|
curX = newX;
|
|||
|
}
|
|||
|
|
|||
|
/*
|
|||
|
* P points to the first character that doesn't fit in the desired
|
|||
|
* span. Use the flags to figure out what to return.
|
|||
|
*/
|
|||
|
|
|||
|
if ((flags & TK_PARTIAL_OK) && (curX < maxX)) {
|
|||
|
curX = newX;
|
|||
|
p++;
|
|||
|
}
|
|||
|
if ((flags & TK_AT_LEAST_ONE) && (term == source) && (maxChars > 0)
|
|||
|
&& !isspace(UCHAR(*term))) {
|
|||
|
term = p;
|
|||
|
termX = curX;
|
|||
|
if (term == source) {
|
|||
|
term++;
|
|||
|
termX = newX;
|
|||
|
}
|
|||
|
} else if ((maxChars == 0) || !(flags & TK_WHOLE_WORDS)) {
|
|||
|
term = p;
|
|||
|
termX = curX;
|
|||
|
}
|
|||
|
*nextXPtr = termX;
|
|||
|
return term-source;
|
|||
|
}
|
|||
|
|
|||
|
/*
|
|||
|
*--------------------------------------------------------------
|
|||
|
*
|
|||
|
* TkDisplayChars --
|
|||
|
*
|
|||
|
* Draw a string of characters on the screen, converting
|
|||
|
* tabs to the right number of spaces and control characters
|
|||
|
* to sequences of the form "\xhh" where hh are two hex
|
|||
|
* digits.
|
|||
|
*
|
|||
|
* Results:
|
|||
|
* None.
|
|||
|
*
|
|||
|
* Side effects:
|
|||
|
* Information gets drawn on the screen.
|
|||
|
*
|
|||
|
*--------------------------------------------------------------
|
|||
|
*/
|
|||
|
|
|||
|
void
|
|||
|
TkDisplayChars(display, drawable, gc, fontStructPtr, string, numChars,
|
|||
|
x, y, flags)
|
|||
|
Display *display; /* Display on which to draw. */
|
|||
|
Drawable drawable; /* Window or pixmap in which to draw. */
|
|||
|
GC gc; /* Graphics context for actually drawing
|
|||
|
* characters. */
|
|||
|
XFontStruct *fontStructPtr; /* Font used in GC; must have been allocated
|
|||
|
* by Tk_GetFontStruct. Used to compute sizes
|
|||
|
* of tabs, etc. */
|
|||
|
char *string; /* Characters to be displayed. */
|
|||
|
int numChars; /* Number of characters to display from
|
|||
|
* string. */
|
|||
|
int x, y; /* Coordinates at which to draw string. */
|
|||
|
int flags; /* Flags to control display. Only
|
|||
|
* TK_NEWLINES_NOT_SPECIAL is supported right
|
|||
|
* now. See TkMeasureChars for information
|
|||
|
* about it. */
|
|||
|
{
|
|||
|
register TkFont *fontPtr;
|
|||
|
register char *p; /* Current character being scanned. */
|
|||
|
register int c;
|
|||
|
int type;
|
|||
|
char *start; /* First character waiting to be displayed. */
|
|||
|
int startX; /* X-coordinate corresponding to start. */
|
|||
|
int curX; /* X-coordinate corresponding to p. */
|
|||
|
char replace[10];
|
|||
|
|
|||
|
/*
|
|||
|
* Find the TkFont structure for this font, and make sure its
|
|||
|
* font metrics exist.
|
|||
|
*/
|
|||
|
|
|||
|
if (lastFontStructPtr == fontStructPtr) {
|
|||
|
fontPtr = lastFontPtr;
|
|||
|
} else {
|
|||
|
Tcl_HashEntry *fontHashPtr;
|
|||
|
|
|||
|
if (!initialized) {
|
|||
|
badArg:
|
|||
|
panic("TkDisplayChars received unknown font argument");
|
|||
|
}
|
|||
|
|
|||
|
fontHashPtr = Tcl_FindHashEntry(&fontTable, (char *) fontStructPtr);
|
|||
|
if (fontHashPtr == NULL) {
|
|||
|
goto badArg;
|
|||
|
}
|
|||
|
fontPtr = (TkFont *) Tcl_GetHashValue(fontHashPtr);
|
|||
|
lastFontStructPtr = fontPtr->fontStructPtr;
|
|||
|
lastFontPtr = fontPtr;
|
|||
|
}
|
|||
|
if (fontPtr->types == NULL) {
|
|||
|
SetFontMetrics(fontPtr);
|
|||
|
}
|
|||
|
|
|||
|
/*
|
|||
|
* Scan the string one character at a time. Display control
|
|||
|
* characters immediately, but delay displaying normal characters
|
|||
|
* in order to pass many characters to the server all together.
|
|||
|
*/
|
|||
|
|
|||
|
startX = curX = x;
|
|||
|
start = string;
|
|||
|
for (p = string; numChars > 0; numChars--, p++) {
|
|||
|
c = *p & 0xff;
|
|||
|
type = fontPtr->types[c];
|
|||
|
if (type == NORMAL) {
|
|||
|
curX += fontPtr->widths[c];
|
|||
|
continue;
|
|||
|
}
|
|||
|
if (p != start) {
|
|||
|
XDrawString(display, drawable, gc, startX, y, start, p - start);
|
|||
|
startX = curX;
|
|||
|
}
|
|||
|
if (type == TAB) {
|
|||
|
curX += fontPtr->tabWidth;
|
|||
|
curX -= curX % fontPtr->tabWidth;
|
|||
|
} else if (type == REPLACE) {
|
|||
|
doReplace:
|
|||
|
replace[0] = '\\';
|
|||
|
replace[1] = 'x';
|
|||
|
replace[2] = hexChars[(c >> 4) & 0xf];
|
|||
|
replace[3] = hexChars[c & 0xf];
|
|||
|
XDrawString(display, drawable, gc, startX, y, replace, 4);
|
|||
|
curX += fontPtr->widths[replace[0]]
|
|||
|
+ fontPtr->widths[replace[1]]
|
|||
|
+ fontPtr->widths[replace[2]]
|
|||
|
+ fontPtr->widths[replace[3]];
|
|||
|
} else if (type == NEWLINE) {
|
|||
|
if (flags & TK_NEWLINES_NOT_SPECIAL) {
|
|||
|
goto doReplace;
|
|||
|
}
|
|||
|
y += fontStructPtr->ascent + fontStructPtr->descent;
|
|||
|
curX = x;
|
|||
|
} else if (type != SKIP) {
|
|||
|
panic("Unknown type %d in TkDisplayChars", type);
|
|||
|
}
|
|||
|
startX = curX;
|
|||
|
start = p+1;
|
|||
|
}
|
|||
|
|
|||
|
/*
|
|||
|
* At the very end, there may be one last batch of normal characters
|
|||
|
* to display.
|
|||
|
*/
|
|||
|
|
|||
|
if (p != start) {
|
|||
|
XDrawString(display, drawable, gc, startX, y, start, p - start);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
/*
|
|||
|
*----------------------------------------------------------------------
|
|||
|
*
|
|||
|
* TkUnderlineChars --
|
|||
|
*
|
|||
|
* This procedure draws an underline for a given range of characters
|
|||
|
* in a given string, using appropriate information for the string's
|
|||
|
* font. It doesn't draw the characters (which are assumed to have
|
|||
|
* been displayed previously); it just draws the underline.
|
|||
|
*
|
|||
|
* Results:
|
|||
|
* None.
|
|||
|
*
|
|||
|
* Side effects:
|
|||
|
* Information gets displayed in "drawable".
|
|||
|
*
|
|||
|
*----------------------------------------------------------------------
|
|||
|
*/
|
|||
|
|
|||
|
void
|
|||
|
TkUnderlineChars(display, drawable, gc, fontStructPtr, string, x, y,
|
|||
|
flags, 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
|
|||
|
* underline. */
|
|||
|
XFontStruct *fontStructPtr; /* Font used in GC; must have been allocated
|
|||
|
* by Tk_GetFontStruct. Used to character
|
|||
|
* dimensions, etc. */
|
|||
|
char *string; /* String containing characters to be
|
|||
|
* underlined. */
|
|||
|
int x, y; /* Coordinates at which first character of
|
|||
|
* string is drawn. */
|
|||
|
int flags; /* Flags that were passed to TkDisplayChars. */
|
|||
|
int firstChar; /* Index of first character to underline. */
|
|||
|
int lastChar; /* Index of last character to underline. */
|
|||
|
{
|
|||
|
int xUnder, yUnder, width, height;
|
|||
|
unsigned long value;
|
|||
|
|
|||
|
/*
|
|||
|
* First compute the vertical span of the underline, using font
|
|||
|
* properties if they exist.
|
|||
|
*/
|
|||
|
|
|||
|
if (XGetFontProperty(fontStructPtr, XA_UNDERLINE_POSITION, &value)) {
|
|||
|
yUnder = y + value;
|
|||
|
} else {
|
|||
|
yUnder = y + fontStructPtr->max_bounds.descent/2;
|
|||
|
}
|
|||
|
if (XGetFontProperty(fontStructPtr, XA_UNDERLINE_THICKNESS, &value)) {
|
|||
|
height = value;
|
|||
|
} else {
|
|||
|
height = 2;
|
|||
|
}
|
|||
|
|
|||
|
/*
|
|||
|
* Now compute the horizontal span of the underline.
|
|||
|
*/
|
|||
|
|
|||
|
TkMeasureChars(fontStructPtr, string, firstChar, x, (int) 1000000, flags,
|
|||
|
&xUnder);
|
|||
|
TkMeasureChars(fontStructPtr, string+firstChar, lastChar+1-firstChar,
|
|||
|
xUnder, (int) 1000000, flags, &width);
|
|||
|
width -= xUnder;
|
|||
|
|
|||
|
XFillRectangle(display, drawable, gc, xUnder, yUnder,
|
|||
|
(unsigned int) width, (unsigned int) height);
|
|||
|
}
|