summaryrefslogtreecommitdiffstats
path: root/unix/tkUnixFont.c
diff options
context:
space:
mode:
Diffstat (limited to 'unix/tkUnixFont.c')
-rw-r--r--unix/tkUnixFont.c1572
1 files changed, 843 insertions, 729 deletions
diff --git a/unix/tkUnixFont.c b/unix/tkUnixFont.c
index 2b8d99d..897770b 100644
--- a/unix/tkUnixFont.c
+++ b/unix/tkUnixFont.c
@@ -1,15 +1,15 @@
/*
* tkUnixFont.c --
*
- * Contains the Unix implementation of the platform-independant
- * font package interface.
+ * Contains the Unix implementation of the platform-independent font
+ * package interface.
*
* Copyright (c) 1996-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.
+ * See the file "license.terms" for information on usage and redistribution of
+ * this file, and for a DISCLAIMER OF ALL WARRANTIES.
*/
-
+
#include "tkUnixInt.h"
#include "tkFont.h"
#include <netinet/in.h> /* for htons() prototype */
@@ -24,26 +24,26 @@ static CONST char *encodingList[] = {
};
/*
- * The following structure represents a font family. It is assumed that
- * all screen fonts constructed from the same "font family" share certain
- * properties; all screen fonts with the same "font family" point to a
- * shared instance of this structure. The most important shared property
- * is the character existence metrics, used to determine if a screen font
- * can display a given Unicode character.
+ * The following structure represents a font family. It is assumed that all
+ * screen fonts constructed from the same "font family" share certain
+ * properties; all screen fonts with the same "font family" point to a shared
+ * instance of this structure. The most important shared property is the
+ * character existence metrics, used to determine if a screen font can display
+ * a given Unicode character.
*
* Under Unix, there are three attributes that uniquely identify a "font
- * family": the foundry, face name, and charset.
+ * family": the foundry, face name, and charset.
*/
#define FONTMAP_SHIFT 10
-#define FONTMAP_PAGES (1 << (sizeof(Tcl_UniChar)*8 - FONTMAP_SHIFT))
+#define FONTMAP_PAGES (1 << (sizeof(Tcl_UniChar)*8 - FONTMAP_SHIFT))
#define FONTMAP_BITSPERPAGE (1 << FONTMAP_SHIFT)
typedef struct FontFamily {
struct FontFamily *nextPtr; /* Next in list of all known font families. */
int refCount; /* How many SubFonts are referring to this
- * FontFamily. When the refCount drops to
+ * FontFamily. When the refCount drops to
* zero, this FontFamily may be freed. */
/*
* Key.
@@ -57,58 +57,57 @@ typedef struct FontFamily {
* Derived properties.
*/
- int isTwoByteFont; /* 1 if this is a double-byte font, 0
+ int isTwoByteFont; /* 1 if this is a double-byte font, 0
* otherwise. */
char *fontMap[FONTMAP_PAGES];
/* Two-level sparse table used to determine
* quickly if the specified character exists.
* As characters are encountered, more pages
- * in this table are dynamically alloced. The
+ * in this table are dynamically alloced. The
* contents of each page is a bitmask
* consisting of FONTMAP_BITSPERPAGE bits,
* representing whether this font can be used
* to display the given character at the
- * corresponding bit position. The high bits
+ * corresponding bit position. The high bits
* of the character are used to pick which
* page of the table is used. */
} FontFamily;
/*
- * The following structure encapsulates an individual screen font. A font
+ * The following structure encapsulates an individual screen font. A font
* object is made up of however many SubFonts are necessary to display a
* stream of multilingual characters.
*/
typedef struct SubFont {
- char **fontMap; /* Pointer to font map from the FontFamily,
+ char **fontMap; /* Pointer to font map from the FontFamily,
* cached here to save a dereference. */
- XFontStruct *fontStructPtr; /* The specific screen font that will be
- * used when displaying/measuring chars
- * belonging to the FontFamily. */
+ XFontStruct *fontStructPtr; /* The specific screen font that will be used
+ * when displaying/measuring chars belonging
+ * to the FontFamily. */
FontFamily *familyPtr; /* The FontFamily for this SubFont. */
} SubFont;
/*
- * The following structure represents Unix's implementation of a font
- * object.
+ * The following structure represents Unix's implementation of a font object.
*/
-
+
#define SUBFONT_SPACE 3
#define BASE_CHARS 256
typedef struct UnixFont {
- TkFont font; /* Stuff used by generic font package. Must
- * be first in structure. */
+ TkFont font; /* Stuff used by generic font package. Must be
+ * first in structure. */
SubFont staticSubFonts[SUBFONT_SPACE];
/* Builtin space for a limited number of
* SubFonts. */
int numSubFonts; /* Length of following array. */
- SubFont *subFontArray; /* Array of SubFonts that have been loaded
- * in order to draw/measure all the characters
- * encountered by this font so far. All fonts
+ SubFont *subFontArray; /* Array of SubFonts that have been loaded in
+ * order to draw/measure all the characters
+ * encountered by this font so far. All fonts
* start off with one SubFont initialized by
* AllocFont() from the original set of font
- * attributes. Usually points to
+ * attributes. Usually points to
* staticSubFonts, but may point to malloced
* space if there are lots of SubFonts. */
SubFont controlSubFont; /* Font to use to display control-character
@@ -120,51 +119,50 @@ typedef struct UnixFont {
TkXLFDAttributes xa; /* Additional attributes that specify the
* preferred foundry and encoding to use when
* constructing additional SubFonts. */
- int widths[BASE_CHARS]; /* Widths of first 256 chars in the base
- * font, for handling common case. */
- int underlinePos; /* Offset from baseline to origin of
- * underline bar (used when drawing underlined
- * font) (pixels). */
- int barHeight; /* Height of underline or overstrike bar
- * (used when drawing underlined or strikeout
- * font) (pixels). */
+ int widths[BASE_CHARS]; /* Widths of first 256 chars in the base font,
+ * for handling common case. */
+ int underlinePos; /* Offset from baseline to origin of underline
+ * bar (used when drawing underlined font)
+ * (pixels). */
+ int barHeight; /* Height of underline or overstrike bar (used
+ * when drawing underlined or strikeout font)
+ * (pixels). */
} UnixFont;
/*
* The following structure and definition is used to keep track of the
- * alternative names for various encodings. Asking for an encoding that
+ * alternative names for various encodings. Asking for an encoding that
* matches one of the alias patterns will result in actually getting the
* encoding by its real name.
*/
-
+
typedef struct EncodingAlias {
char *realName; /* The real name of the encoding to load if
* the provided name matched the pattern. */
- char *aliasPattern; /* Pattern for encoding name, of the form
- * that is acceptable to Tcl_StringMatch. */
+ char *aliasPattern; /* Pattern for encoding name, of the form that
+ * is acceptable to Tcl_StringMatch. */
} EncodingAlias;
/*
* Just some utility structures used for passing around values in helper
- * procedures.
+ * functions.
*/
-
+
typedef struct FontAttributes {
TkFontAttributes fa;
TkXLFDAttributes xa;
} FontAttributes;
-
typedef struct ThreadSpecificData {
- FontFamily *fontFamilyList; /* The list of font families that are
- * currently loaded. As screen fonts
- * are loaded, this list grows to hold
- * information about what characters
- * exist in each font family. */
- FontFamily controlFamily; /* FontFamily used to handle control
- * character expansions. The encoding
- * of this FontFamily converts UTF-8 to
- * backslashed escape sequences. */
+ FontFamily *fontFamilyList; /* The list of font families that are
+ * currently loaded. As screen fonts are
+ * loaded, this list grows to hold information
+ * about what characters exist in each font
+ * family. */
+ FontFamily controlFamily; /* FontFamily used to handle control character
+ * expansions. The encoding of this FontFamily
+ * converts UTF-8 to backslashed escape
+ * sequences. */
} ThreadSpecificData;
static Tcl_ThreadDataKey dataKey;
@@ -172,7 +170,7 @@ static Tcl_ThreadDataKey dataKey;
* The set of builtin encoding alises to convert the XLFD names for the
* encodings into the names expected by the Tcl encoding package.
*/
-
+
static EncodingAlias encodingAliases[] = {
{"gb2312-raw", "gb2312*"},
{"big5", "big5*"},
@@ -200,83 +198,73 @@ static EncodingAlias encodingAliases[] = {
};
/*
- * Procedures used only in this file.
+ * Functions used only in this file.
*/
-static void FontPkgCleanup _ANSI_ARGS_((ClientData clientData));
-static FontFamily * AllocFontFamily _ANSI_ARGS_((Display *display,
- XFontStruct *fontStructPtr, int base));
-static SubFont * CanUseFallback _ANSI_ARGS_((UnixFont *fontPtr,
+static void FontPkgCleanup(ClientData clientData);
+static FontFamily * AllocFontFamily(Display *display,
+ XFontStruct *fontStructPtr, int base);
+static SubFont * CanUseFallback(UnixFont *fontPtr,
CONST char *fallbackName, int ch,
- SubFont **fixSubFontPtrPtr));
-static SubFont * CanUseFallbackWithAliases _ANSI_ARGS_((
- UnixFont *fontPtr, char *fallbackName,
- int ch, Tcl_DString *nameTriedPtr,
- SubFont **fixSubFontPtrPtr));
-static int ControlUtfProc _ANSI_ARGS_((ClientData clientData,
- CONST char *src, int srcLen, int flags,
- Tcl_EncodingState *statePtr, char *dst,
- int dstLen, int *srcReadPtr, int *dstWrotePtr,
- int *dstCharsPtr));
-static XFontStruct * CreateClosestFont _ANSI_ARGS_((Tk_Window tkwin,
+ SubFont **fixSubFontPtrPtr);
+static SubFont * CanUseFallbackWithAliases(UnixFont *fontPtr,
+ char *fallbackName, int ch,
+ Tcl_DString *nameTriedPtr,
+ SubFont **fixSubFontPtrPtr);
+static int ControlUtfProc(ClientData clientData, CONST char *src,
+ int srcLen, int flags, Tcl_EncodingState*statePtr,
+ char *dst, int dstLen, int *srcReadPtr,
+ int *dstWrotePtr, int *dstCharsPtr);
+static XFontStruct * CreateClosestFont(Tk_Window tkwin,
CONST TkFontAttributes *faPtr,
- CONST TkXLFDAttributes *xaPtr));
-static SubFont * FindSubFontForChar _ANSI_ARGS_((UnixFont *fontPtr,
- int ch, SubFont **fixSubFontPtrPtr));
-static void FontMapInsert _ANSI_ARGS_((SubFont *subFontPtr,
- int ch));
-static void FontMapLoadPage _ANSI_ARGS_((SubFont *subFontPtr,
- int row));
-static int FontMapLookup _ANSI_ARGS_((SubFont *subFontPtr,
- int ch));
-static void FreeFontFamily _ANSI_ARGS_((FontFamily *afPtr));
-static CONST char * GetEncodingAlias _ANSI_ARGS_((CONST char *name));
-static int GetFontAttributes _ANSI_ARGS_((Display *display,
- XFontStruct *fontStructPtr, FontAttributes *faPtr));
-static XFontStruct * GetScreenFont _ANSI_ARGS_((Display *display,
+ CONST TkXLFDAttributes *xaPtr);
+static SubFont * FindSubFontForChar(UnixFont *fontPtr, int ch,
+ SubFont **fixSubFontPtrPtr);
+static void FontMapInsert(SubFont *subFontPtr, int ch);
+static void FontMapLoadPage(SubFont *subFontPtr, int row);
+static int FontMapLookup(SubFont *subFontPtr, int ch);
+static void FreeFontFamily(FontFamily *afPtr);
+static CONST char * GetEncodingAlias(CONST char *name);
+static int GetFontAttributes(Display *display,
+ XFontStruct *fontStructPtr, FontAttributes *faPtr);
+static XFontStruct * GetScreenFont(Display *display,
FontAttributes *wantPtr, char **nameList,
- int bestIdx[], unsigned int bestScore[]));
-static XFontStruct * GetSystemFont _ANSI_ARGS_((Display *display));
-static int IdentifySymbolEncodings _ANSI_ARGS_((
- FontAttributes *faPtr));
-static void InitFont _ANSI_ARGS_((Tk_Window tkwin,
- XFontStruct *fontStructPtr, UnixFont *fontPtr));
-static void InitSubFont _ANSI_ARGS_((Display *display,
+ int bestIdx[], unsigned int bestScore[]);
+static XFontStruct * GetSystemFont(Display *display);
+static int IdentifySymbolEncodings(FontAttributes *faPtr);
+static void InitFont(Tk_Window tkwin, XFontStruct *fontStructPtr,
+ UnixFont *fontPtr);
+static void InitSubFont(Display *display,
XFontStruct *fontStructPtr, int base,
- SubFont *subFontPtr));
-static char ** ListFonts _ANSI_ARGS_((Display *display,
- CONST char *faceName, int *numNamesPtr));
-static char ** ListFontOrAlias _ANSI_ARGS_((Display *display,
- CONST char *faceName, int *numNamesPtr));
-static unsigned int RankAttributes _ANSI_ARGS_((FontAttributes *wantPtr,
- FontAttributes *gotPtr));
-static void ReleaseFont _ANSI_ARGS_((UnixFont *fontPtr));
-static void ReleaseSubFont _ANSI_ARGS_((Display *display,
- SubFont *subFontPtr));
-static int SeenName _ANSI_ARGS_((CONST char *name,
- Tcl_DString *dsPtr));
+ SubFont *subFontPtr);
+static char ** ListFonts(Display *display, CONST char *faceName,
+ int *numNamesPtr);
+static char ** ListFontOrAlias(Display *display, CONST char*faceName,
+ int *numNamesPtr);
+static unsigned int RankAttributes(FontAttributes *wantPtr,
+ FontAttributes *gotPtr);
+static void ReleaseFont(UnixFont *fontPtr);
+static void ReleaseSubFont(Display *display, SubFont *subFontPtr);
+static int SeenName(CONST char *name, Tcl_DString *dsPtr);
#ifndef WORDS_BIGENDIAN
-static int Ucs2beToUtfProc _ANSI_ARGS_((ClientData clientData,
- CONST char *src, int srcLen, int flags,
- Tcl_EncodingState *statePtr, char *dst, int dstLen,
- int *srcReadPtr, int *dstWrotePtr,
- int *dstCharsPtr));
-static int UtfToUcs2beProc _ANSI_ARGS_((ClientData clientData,
- CONST char *src, int srcLen, int flags,
- Tcl_EncodingState *statePtr, char *dst, int dstLen,
- int *srcReadPtr, int *dstWrotePtr,
- int *dstCharsPtr));
+static int Ucs2beToUtfProc(ClientData clientData, CONST char*src,
+ int srcLen, int flags, Tcl_EncodingState*statePtr,
+ char *dst, int dstLen, int *srcReadPtr,
+ int *dstWrotePtr, int *dstCharsPtr);
+static int UtfToUcs2beProc(ClientData clientData, CONST char*src,
+ int srcLen, int flags, Tcl_EncodingState*statePtr,
+ char *dst, int dstLen, int *srcReadPtr,
+ int *dstWrotePtr, int *dstCharsPtr);
#endif
-
/*
*-------------------------------------------------------------------------
*
* FontPkgCleanup --
*
- * This procedure is called when an application is created. It
- * initializes all the structures that are used by the
- * platform-dependent code on a per application basis.
+ * This function is called when an application is created. It initializes
+ * all the structures that are used by the platform-dependent code on a
+ * per application basis.
*
* Results:
* None.
@@ -288,11 +276,12 @@ static int UtfToUcs2beProc _ANSI_ARGS_((ClientData clientData,
*/
static void
-FontPkgCleanup(ClientData clientData)
+FontPkgCleanup(
+ ClientData clientData)
{
- ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
- Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
-
+ ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
+ Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+
if (tsdPtr->controlFamily.encoding != NULL) {
FontFamily *familyPtr = &tsdPtr->controlFamily;
int i;
@@ -312,9 +301,9 @@ FontPkgCleanup(ClientData clientData)
*
* TkpFontPkgInit --
*
- * This procedure is called when an application is created. It
- * initializes all the structures that are used by the
- * platform-dependent code on a per application basis.
+ * This function is called when an application is created. It initializes
+ * all the structures that are used by the platform-dependent code on a
+ * per application basis.
*
* Results:
* None.
@@ -326,22 +315,22 @@ FontPkgCleanup(ClientData clientData)
*/
void
-TkpFontPkgInit(mainPtr)
- TkMainInfo *mainPtr; /* The application being created. */
+TkpFontPkgInit(
+ TkMainInfo *mainPtr) /* The application being created. */
{
- ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
- Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+ ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
+ Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
Tcl_EncodingType type;
SubFont dummy;
int i;
if (tsdPtr->controlFamily.encoding == NULL) {
- type.encodingName = "X11ControlChars";
- type.toUtfProc = ControlUtfProc;
- type.fromUtfProc = ControlUtfProc;
- type.freeProc = NULL;
- type.clientData = NULL;
- type.nullSize = 0;
+ type.encodingName = "X11ControlChars";
+ type.toUtfProc = ControlUtfProc;
+ type.fromUtfProc = ControlUtfProc;
+ type.freeProc = NULL;
+ type.clientData = NULL;
+ type.nullSize = 0;
tsdPtr->controlFamily.refCount = 2;
tsdPtr->controlFamily.encoding = Tcl_CreateEncoding(&type);
@@ -356,16 +345,16 @@ TkpFontPkgInit(mainPtr)
#ifndef WORDS_BIGENDIAN
/*
- * UCS-2BE is unicode (UCS-2) in big-endian format. Define this
- * if native order isn't BE. It is used in iso10646 fonts.
+ * UCS-2BE is unicode (UCS-2) in big-endian format. Define this if
+ * native order isn't BE. It is used in iso10646 fonts.
*/
- type.encodingName = "ucs-2be";
- type.toUtfProc = Ucs2beToUtfProc;
- type.fromUtfProc = UtfToUcs2beProc;
- type.freeProc = NULL;
- type.clientData = NULL;
- type.nullSize = 2;
+ type.encodingName = "ucs-2be";
+ type.toUtfProc = Ucs2beToUtfProc;
+ type.fromUtfProc = UtfToUcs2beProc;
+ type.freeProc = NULL;
+ type.clientData = NULL;
+ type.nullSize = 2;
Tcl_CreateEncoding(&type);
#endif
Tcl_CreateThreadExitHandler(FontPkgCleanup, NULL);
@@ -377,8 +366,7 @@ TkpFontPkgInit(mainPtr)
*
* ControlUtfProc --
*
- * Convert from UTF-8 into the ASCII expansion of a control
- * character.
+ * Convert from UTF-8 into the ASCII expansion of a control character.
*
* Results:
* Returns TCL_OK if conversion was successful.
@@ -389,31 +377,30 @@ TkpFontPkgInit(mainPtr)
*-------------------------------------------------------------------------
*/
-static int
-ControlUtfProc(clientData, src, srcLen, flags, statePtr, dst, dstLen,
- srcReadPtr, dstWrotePtr, dstCharsPtr)
- ClientData clientData; /* Not used. */
- CONST char *src; /* Source string in UTF-8. */
- int srcLen; /* Source string length in bytes. */
- int flags; /* Conversion control flags. */
- Tcl_EncodingState *statePtr;/* Place for conversion routine to store
- * state information used during a piecewise
- * conversion. Contents of statePtr are
+static int
+ControlUtfProc(
+ ClientData clientData, /* Not used. */
+ CONST char *src, /* Source string in UTF-8. */
+ int srcLen, /* Source string length in bytes. */
+ int flags, /* Conversion control flags. */
+ Tcl_EncodingState *statePtr,/* Place for conversion routine to store state
+ * information used during a piecewise
+ * conversion. Contents of statePtr are
* initialized and/or reset by conversion
* routine under control of flags argument. */
- char *dst; /* Output buffer in which converted string
- * is stored. */
- int dstLen; /* The maximum length of output buffer in
+ char *dst, /* Output buffer in which converted string is
+ * stored. */
+ int dstLen, /* The maximum length of output buffer in
* bytes. */
- int *srcReadPtr; /* Filled with the number of bytes from the
- * source string that were converted. This
- * may be less than the original source length
- * if there was a problem converting some
- * source characters. */
- int *dstWrotePtr; /* Filled with the number of bytes that were
+ int *srcReadPtr, /* Filled with the number of bytes from the
+ * source string that were converted. This may
+ * be less than the original source length if
+ * there was a problem converting some source
+ * characters. */
+ int *dstWrotePtr, /* Filled with the number of bytes that were
* stored in the output buffer as a result of
* the conversion. */
- int *dstCharsPtr; /* Filled with the number of characters that
+ int *dstCharsPtr) /* Filled with the number of characters that
* correspond to the bytes stored in the
* output buffer. */
{
@@ -483,31 +470,30 @@ ControlUtfProc(clientData, src, srcLen, flags, statePtr, dst, dstLen,
*-------------------------------------------------------------------------
*/
-static int
-Ucs2beToUtfProc(clientData, src, srcLen, flags, statePtr, dst, dstLen,
- srcReadPtr, dstWrotePtr, dstCharsPtr)
- ClientData clientData; /* Not used. */
- CONST char *src; /* Source string in Unicode. */
- int srcLen; /* Source string length in bytes. */
- int flags; /* Conversion control flags. */
- Tcl_EncodingState *statePtr;/* Place for conversion routine to store
- * state information used during a piecewise
- * conversion. Contents of statePtr are
+static int
+Ucs2beToUtfProc(
+ ClientData clientData, /* Not used. */
+ CONST char *src, /* Source string in Unicode. */
+ int srcLen, /* Source string length in bytes. */
+ int flags, /* Conversion control flags. */
+ Tcl_EncodingState *statePtr,/* Place for conversion routine to store state
+ * information used during a piecewise
+ * conversion. Contents of statePtr are
* initialized and/or reset by conversion
* routine under control of flags argument. */
- char *dst; /* Output buffer in which converted string
- * is stored. */
- int dstLen; /* The maximum length of output buffer in
+ char *dst, /* Output buffer in which converted string is
+ * stored. */
+ int dstLen, /* The maximum length of output buffer in
* bytes. */
- int *srcReadPtr; /* Filled with the number of bytes from the
- * source string that were converted. This
- * may be less than the original source length
- * if there was a problem converting some
- * source characters. */
- int *dstWrotePtr; /* Filled with the number of bytes that were
+ int *srcReadPtr, /* Filled with the number of bytes from the
+ * source string that were converted. This may
+ * be less than the original source length if
+ * there was a problem converting some source
+ * characters. */
+ int *dstWrotePtr, /* Filled with the number of bytes that were
* stored in the output buffer as a result of
* the conversion. */
- int *dstCharsPtr; /* Filled with the number of characters that
+ int *dstCharsPtr) /* Filled with the number of characters that
* correspond to the bytes stored in the
* output buffer. */
{
@@ -534,10 +520,12 @@ Ucs2beToUtfProc(clientData, src, srcLen, flags, statePtr, dst, dstLen,
result = TCL_CONVERT_NOSPACE;
break;
}
+
/*
* Need to swap byte-order on little-endian machines (x86) for
- * UCS-2BE. We know this is an LE->BE swap.
+ * UCS-2BE. We know this is an LE->BE swap.
*/
+
dst += Tcl_UniCharToUtf(htons(*((short *)src)), dst);
src += 2 /* sizeof(UCS-2) */;
}
@@ -564,31 +552,31 @@ Ucs2beToUtfProc(clientData, src, srcLen, flags, statePtr, dst, dstLen,
*-------------------------------------------------------------------------
*/
-static int
-UtfToUcs2beProc(clientData, src, srcLen, flags, statePtr, dst, dstLen,
- srcReadPtr, dstWrotePtr, dstCharsPtr)
- ClientData clientData; /* TableEncodingData that specifies encoding. */
- CONST char *src; /* Source string in UTF-8. */
- int srcLen; /* Source string length in bytes. */
- int flags; /* Conversion control flags. */
- Tcl_EncodingState *statePtr;/* Place for conversion routine to store
- * state information used during a piecewise
- * conversion. Contents of statePtr are
+static int
+UtfToUcs2beProc(
+ ClientData clientData, /* TableEncodingData that specifies
+ * encoding. */
+ CONST char *src, /* Source string in UTF-8. */
+ int srcLen, /* Source string length in bytes. */
+ int flags, /* Conversion control flags. */
+ Tcl_EncodingState *statePtr,/* Place for conversion routine to store state
+ * information used during a piecewise
+ * conversion. Contents of statePtr are
* initialized and/or reset by conversion
* routine under control of flags argument. */
- char *dst; /* Output buffer in which converted string
- * is stored. */
- int dstLen; /* The maximum length of output buffer in
+ char *dst, /* Output buffer in which converted string is
+ * stored. */
+ int dstLen, /* The maximum length of output buffer in
* bytes. */
- int *srcReadPtr; /* Filled with the number of bytes from the
- * source string that were converted. This
- * may be less than the original source length
- * if there was a problem converting some
- * source characters. */
- int *dstWrotePtr; /* Filled with the number of bytes that were
+ int *srcReadPtr, /* Filled with the number of bytes from the
+ * source string that were converted. This may
+ * be less than the original source length if
+ * there was a problem converting some source
+ * characters. */
+ int *dstWrotePtr, /* Filled with the number of bytes that were
* stored in the output buffer as a result of
* the conversion. */
- int *dstCharsPtr; /* Filled with the number of characters that
+ int *dstCharsPtr) /* Filled with the number of characters that
* correspond to the bytes stored in the
* output buffer. */
{
@@ -604,7 +592,7 @@ UtfToUcs2beProc(clientData, src, srcLen, flags, statePtr, dst, dstLen,
}
dstStart = dst;
- dstEnd = dst + dstLen - 2 /* sizeof(UCS-2) */;
+ dstEnd = dst + dstLen - 2 /* sizeof(UCS-2) */;
result = TCL_OK;
for (numChars = 0; src < srcEnd; numChars++) {
@@ -622,12 +610,13 @@ UtfToUcs2beProc(clientData, src, srcLen, flags, statePtr, dst, dstLen,
break;
}
src += Tcl_UtfToUniChar(src, &ch);
+
/*
* Ensure big-endianness (store big bits first).
- * XXX: This hard-codes the assumed size of Tcl_UniChar as 2.
- * Make sure to work in char* for Tcl_UtfToUniChar alignment.
- * [Bug 1122671]
+ * XXX: This hard-codes the assumed size of Tcl_UniChar as 2. Make
+ * sure to work in char* for Tcl_UtfToUniChar alignment. [Bug 1122671]
*/
+
*dst++ = (ch >> 8);
*dst++ = (ch & 0xFF);
}
@@ -646,28 +635,28 @@ UtfToUcs2beProc(clientData, src, srcLen, flags, statePtr, dst, dstLen,
* Map a platform-specific native font name to a TkFont.
*
* Results:
- * The return value is a pointer to a TkFont that represents the
- * native font. If a native font by the given name could not be
- * found, the return value is NULL.
+ * The return value is a pointer to a TkFont that represents the native
+ * font. If a native font by the given name could not be found, the
+ * return value is NULL.
*
- * Every call to this procedure returns a new TkFont structure,
- * even if the name has already been seen before. The caller should
- * call TkpDeleteFont() when the font is no longer needed.
+ * Every call to this function returns a new TkFont structure, even if
+ * the name has already been seen before. The caller should call
+ * TkpDeleteFont() when the font is no longer needed.
*
- * The caller is responsible for initializing the memory associated
- * with the generic TkFont when this function returns and releasing
- * the contents of the generic TkFont before calling TkpDeleteFont().
+ * The caller is responsible for initializing the memory associated with
+ * the generic TkFont when this function returns and releasing the
+ * contents of the generic TkFont before calling TkpDeleteFont().
*
* Side effects:
* Memory allocated.
*
*---------------------------------------------------------------------------
*/
-
+
TkFont *
-TkpGetNativeFont(tkwin, name)
- Tk_Window tkwin; /* For display where font will be used. */
- CONST char *name; /* Platform-specific font name. */
+TkpGetNativeFont(
+ Tk_Window tkwin, /* For display where font will be used. */
+ CONST char *name) /* Platform-specific font name. */
{
UnixFont *fontPtr;
XFontStruct *fontStructPtr;
@@ -679,8 +668,8 @@ TkpGetNativeFont(tkwin, name)
* The behavior of X when given a name that isn't an XLFD is unspecified.
* For example, Exceed 6 returns a valid font for any random string. This
* is awkward since system names have higher priority than the other Tk
- * font syntaxes. So, we need to perform a quick sanity check on the
- * name and fail if it looks suspicious. We fail if the name:
+ * font syntaxes. So, we need to perform a quick sanity check on the name
+ * and fail if it looks suspicious. We fail if the name:
* - contains a space immediately before a dash
* - contains a space, but no '*' characters and fewer than 14 dashes
*/
@@ -705,18 +694,18 @@ TkpGetNativeFont(tkwin, name)
fontStructPtr = XLoadQueryFont(Tk_Display(tkwin), name);
if (fontStructPtr == NULL) {
/*
- * Handle all names that look like XLFDs here. Otherwise, when
- * TkpGetFontFromAttributes is called from generic code, any
- * foundry or encoding information specified in the XLFD will have
- * been parsed out and lost. But make sure we don't have an
- * "-option value" string since TkFontParseXLFD would return a
- * false success when attempting to parse it.
+ * Handle all names that look like XLFDs here. Otherwise, when
+ * TkpGetFontFromAttributes is called from generic code, any foundry
+ * or encoding information specified in the XLFD will have been parsed
+ * out and lost. But make sure we don't have an "-option value" string
+ * since TkFontParseXLFD would return a false success when attempting
+ * to parse it.
*/
if (name[0] == '-') {
if (name[1] != '*') {
char *dash;
-
+
dash = strchr(name + 1, '-');
if ((dash == NULL) || (isspace(UCHAR(dash[-1])))) {
return NULL;
@@ -739,41 +728,42 @@ TkpGetNativeFont(tkwin, name)
/*
*---------------------------------------------------------------------------
*
- * TkpGetFontFromAttributes --
+ * TkpGetFontFromAttributes --
*
- * Given a desired set of attributes for a font, find a font with
- * the closest matching attributes.
+ * Given a desired set of attributes for a font, find a font with the
+ * closest matching attributes.
*
* Results:
- * The return value is a pointer to a TkFont that represents the
- * font with the desired attributes. If a font with the desired
- * attributes could not be constructed, some other font will be
- * substituted automatically.
+ * The return value is a pointer to a TkFont that represents the font
+ * with the desired attributes. If a font with the desired attributes
+ * could not be constructed, some other font will be substituted
+ * automatically.
*
- * Every call to this procedure returns a new TkFont structure,
- * even if the specified attributes have already been seen before.
- * The caller should call TkpDeleteFont() to free the platform-
- * specific data when the font is no longer needed.
+ * Every call to this function returns a new TkFont structure, even if
+ * the specified attributes have already been seen before. The caller
+ * should call TkpDeleteFont() to free the platform- specific data when
+ * the font is no longer needed.
*
- * The caller is responsible for initializing the memory associated
- * with the generic TkFont when this function returns and releasing
- * the contents of the generic TkFont before calling TkpDeleteFont().
+ * The caller is responsible for initializing the memory associated with
+ * the generic TkFont when this function returns and releasing the
+ * contents of the generic TkFont before calling TkpDeleteFont().
*
* Side effects:
* Memory allocated.
*
*---------------------------------------------------------------------------
*/
+
TkFont *
-TkpGetFontFromAttributes(tkFontPtr, tkwin, faPtr)
- TkFont *tkFontPtr; /* If non-NULL, store the information in
- * this existing TkFont structure, rather than
+TkpGetFontFromAttributes(
+ TkFont *tkFontPtr, /* If non-NULL, store the information in this
+ * existing TkFont structure, rather than
* allocating a new structure to hold the
* font; the existing contents of the font
- * will be released. If NULL, a new TkFont
+ * will be released. If NULL, a new TkFont
* structure is allocated. */
- Tk_Window tkwin; /* For display where font will be used. */
- CONST TkFontAttributes *faPtr;
+ Tk_Window tkwin, /* For display where font will be used. */
+ CONST TkFontAttributes *faPtr)
/* Set of attributes to match. */
{
UnixFont *fontPtr;
@@ -803,9 +793,9 @@ TkpGetFontFromAttributes(tkFontPtr, tkwin, faPtr)
* TkpDeleteFont --
*
* Called to release a font allocated by TkpGetNativeFont() or
- * TkpGetFontFromAttributes(). The caller should have already
- * released the fields of the TkFont that are used exclusively by
- * the generic TkFont code.
+ * TkpGetFontFromAttributes(). The caller should have already released
+ * the fields of the TkFont that are used exclusively by the generic
+ * TkFont code.
*
* Results:
* None.
@@ -817,12 +807,11 @@ TkpGetFontFromAttributes(tkFontPtr, tkwin, faPtr)
*/
void
-TkpDeleteFont(tkFontPtr)
- TkFont *tkFontPtr; /* Token of font to be deleted. */
+TkpDeleteFont(
+ TkFont *tkFontPtr) /* Token of font to be deleted. */
{
- UnixFont *fontPtr;
+ UnixFont *fontPtr = (UnixFont *) tkFontPtr;
- fontPtr = (UnixFont *) tkFontPtr;
ReleaseFont(fontPtr);
}
@@ -831,8 +820,8 @@ TkpDeleteFont(tkFontPtr)
*
* TkpGetFontFamilies --
*
- * Return information about the font families that are available
- * on the display of the given window.
+ * Return information about the font families that are available on the
+ * display of the given window.
*
* Results:
* Modifies interp's result object to hold a list of all the available
@@ -845,19 +834,18 @@ TkpDeleteFont(tkFontPtr)
*/
void
-TkpGetFontFamilies(interp, tkwin)
- Tcl_Interp *interp; /* Interp to hold result. */
- Tk_Window tkwin; /* For display to query. */
+TkpGetFontFamilies(
+ Tcl_Interp *interp, /* Interp to hold result. */
+ Tk_Window tkwin) /* For display to query. */
{
int i, new, numNames;
- char *family;
+ char *family, **nameList;
Tcl_HashTable familyTable;
Tcl_HashEntry *hPtr;
Tcl_HashSearch search;
- char **nameList;
Tcl_Obj *resultPtr, *strPtr;
- resultPtr = Tcl_GetObjResult(interp);
+ resultPtr = Tcl_GetObjResult(interp);
Tcl_InitHashTable(&familyTable, TCL_STRING_KEYS);
nameList = ListFonts(Tk_Display(tkwin), "*", &numNames);
@@ -881,14 +869,13 @@ TkpGetFontFamilies(interp, tkwin)
continue; /* See comment above. */
}
*familyEnd = '\0';
- family = strchr(nameList[i] + 1, '-') + 1;
Tcl_CreateHashEntry(&familyTable, family, &new);
}
XFreeFontNames(nameList);
hPtr = Tcl_FirstHashEntry(&familyTable, &search);
while (hPtr != NULL) {
- strPtr = Tcl_NewStringObj(Tcl_GetHashKey(&familyTable, hPtr), -1);
+ strPtr = Tcl_NewStringObj(Tcl_GetHashKey(&familyTable, hPtr), -1);
Tcl_ListObjAppendElement(NULL, resultPtr, strPtr);
hPtr = Tcl_NextHashEntry(&search);
}
@@ -901,12 +888,12 @@ TkpGetFontFamilies(interp, tkwin)
*
* TkpGetSubFonts --
*
- * A function used by the testing package for querying the actual
- * screen fonts that make up a font object.
+ * A function used by the testing package for querying the actual screen
+ * fonts that make up a font object.
*
* Results:
- * Modifies interp's result object to hold a list containing the
- * names of the screen fonts that make up the given font object.
+ * Modifies interp's result object to hold a list containing the names of
+ * the screen fonts that make up the given font object.
*
* Side effects:
* None.
@@ -915,43 +902,80 @@ TkpGetFontFamilies(interp, tkwin)
*/
void
-TkpGetSubFonts(interp, tkfont)
- Tcl_Interp *interp;
- Tk_Font tkfont;
+TkpGetSubFonts(
+ Tcl_Interp *interp,
+ Tk_Font tkfont)
{
int i;
- Tcl_Obj *objv[3];
- Tcl_Obj *resultPtr, *listPtr;
+ Tcl_Obj *objv[3], *resultPtr, *listPtr;
UnixFont *fontPtr;
FontFamily *familyPtr;
- resultPtr = Tcl_GetObjResult(interp);
+ resultPtr = Tcl_GetObjResult(interp);
fontPtr = (UnixFont *) tkfont;
for (i = 0; i < fontPtr->numSubFonts; i++) {
familyPtr = fontPtr->subFontArray[i].familyPtr;
objv[0] = Tcl_NewStringObj(familyPtr->faceName, -1);
objv[1] = Tcl_NewStringObj(familyPtr->foundry, -1);
- objv[2] = Tcl_NewStringObj(Tcl_GetEncodingName(familyPtr->encoding), -1);
+ objv[2] = Tcl_NewStringObj(
+ Tcl_GetEncodingName(familyPtr->encoding), -1);
listPtr = Tcl_NewListObj(3, objv);
Tcl_ListObjAppendElement(NULL, resultPtr, listPtr);
}
}
/*
+ *----------------------------------------------------------------------
+ *
+ * TkpGetFontAttrsForChar --
+ *
+ * Retrieve the font attributes of the actual font used to render a given
+ * character.
+ *
+ * Results:
+ * None.
+ *
+ * Side effects:
+ * The font attributes are stored in *faPtr.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+TkpGetFontAttrsForChar(
+ Tk_Window tkwin, /* Window on the font's display */
+ Tk_Font tkfont, /* Font to query */
+ Tcl_UniChar c, /* Character of interest */
+ TkFontAttributes *faPtr) /* Output: Font attributes */
+{
+ FontAttributes atts;
+ UnixFont *fontPtr = (UnixFont *) tkfont;
+ /* Structure describing the logical font */
+ SubFont *lastSubFontPtr = &fontPtr->subFontArray[0];
+ /* Pointer to subfont array in case
+ * FindSubFontForChar needs to fix up the
+ * memory allocation */
+ SubFont *thisSubFontPtr = FindSubFontForChar(fontPtr, c, &lastSubFontPtr);
+ /* Pointer to the subfont to use for the given
+ * character */
+ GetFontAttributes(Tk_Display(tkwin), thisSubFontPtr->fontStructPtr, &atts);
+ *faPtr = atts.fa;
+}
+
+/*
*---------------------------------------------------------------------------
*
- * Tk_MeasureChars --
+ * Tk_MeasureChars --
*
- * Determine the number of characters from the string that will fit
- * in the given horizontal span. The measurement is done under the
- * assumption that Tk_DrawChars() will be used to actually display
- * the characters.
+ * Determine the number of characters from the string that will fit in
+ * the given horizontal span. The measurement is done under the
+ * assumption that Tk_DrawChars() will be used to actually display the
+ * characters.
*
* Results:
- * The return value is the number of bytes from source that
- * fit into the span that extends from 0 to maxLength. *lengthPtr is
- * filled with the x-coordinate of the right edge of the last
- * character that did fit.
+ * The return value is the number of bytes from source that fit into the
+ * span that extends from 0 to maxLength. *lengthPtr is filled with the
+ * x-coordinate of the right edge of the last character that did fit.
*
* Side effects:
* None.
@@ -960,26 +984,26 @@ TkpGetSubFonts(interp, tkfont)
*/
int
-Tk_MeasureChars(tkfont, source, numBytes, maxLength, flags, lengthPtr)
- Tk_Font tkfont; /* Font in which characters will be drawn. */
- CONST char *source; /* UTF-8 string to be displayed. Need not be
+Tk_MeasureChars(
+ Tk_Font tkfont, /* Font in which characters will be drawn. */
+ CONST char *source, /* UTF-8 string to be displayed. Need not be
* '\0' terminated. */
- int numBytes; /* Maximum number of bytes to consider
- * from source string. */
- int maxLength; /* If >= 0, maxLength specifies the longest
+ int numBytes, /* Maximum number of bytes to consider from
+ * source string. */
+ int maxLength, /* If >= 0, maxLength specifies the longest
* permissible line length in pixels; don't
* consider any character that would cross
- * this x-position. If < 0, then line length
+ * this x-position. If < 0, then line length
* is unbounded and the flags argument is
* ignored. */
- int flags; /* Various flag bits OR-ed together:
+ int flags, /* Various flag bits OR-ed together:
* TK_PARTIAL_OK means include the last char
* which only partially fit on this line.
* TK_WHOLE_WORDS means stop on a word
- * boundary, if possible.
- * TK_AT_LEAST_ONE means return at least one
- * character even if no characters fit. */
- int *lengthPtr; /* Filled with x-location just after the
+ * boundary, if possible. TK_AT_LEAST_ONE
+ * means return at least one character even if
+ * no characters fit. */
+ int *lengthPtr) /* Filled with x-location just after the
* terminating character. */
{
UnixFont *fontPtr;
@@ -988,9 +1012,9 @@ Tk_MeasureChars(tkfont, source, numBytes, maxLength, flags, lengthPtr)
/*
* Unix does not use kerning or fractional character widths when
- * displaying text on the screen. So that means we can safely measure
- * individual characters or spans of characters and add up the widths
- * w/o any "off-by-one-pixel" errors.
+ * displaying text on the screen. So that means we can safely measure
+ * individual characters or spans of characters and add up the widths w/o
+ * any "off-by-one-pixel" errors.
*/
fontPtr = (UnixFont *) tkfont;
@@ -1009,7 +1033,7 @@ Tk_MeasureChars(tkfont, source, numBytes, maxLength, flags, lengthPtr)
/*
* A three step process:
- * 1. Find a contiguous range of characters that can all be
+ * 1. Find a contiguous range of characters that can all be
* represented by a single screen font.
* 2. Convert those chars to the encoding of that font.
* 3. Measure converted chars.
@@ -1040,7 +1064,7 @@ Tk_MeasureChars(tkfont, source, numBytes, maxLength, flags, lengthPtr)
p = next;
}
familyPtr = lastSubFontPtr->familyPtr;
- Tcl_UtfToExternalDString(familyPtr->encoding, source, p - source,
+ Tcl_UtfToExternalDString(familyPtr->encoding, source, p - source,
&runString);
if (familyPtr->isTwoByteFont) {
curX += XTextWidth16(lastSubFontPtr->fontStructPtr,
@@ -1061,14 +1085,14 @@ Tk_MeasureChars(tkfont, source, numBytes, maxLength, flags, lengthPtr)
char buf[16];
/*
- * How many chars will fit in the space allotted?
- * This first version may be inefficient because it measures
- * every character individually.
+ * How many chars will fit in the space allotted? This first version
+ * may be inefficient because it measures every character
+ * individually.
*/
next = source + Tcl_UtfToUniChar(source, &ch);
newX = curX = termX = 0;
-
+
term = source;
end = source + numBytes;
@@ -1115,14 +1139,14 @@ Tk_MeasureChars(tkfont, source, numBytes, maxLength, flags, lengthPtr)
/*
* P points to the first character that doesn't fit in the desired
- * span. Use the flags to figure out what to return.
+ * span. Use the flags to figure out what to return.
*/
if ((flags & TK_PARTIAL_OK) && (p < end) && (curX < maxLength)) {
/*
- * Include the first character that didn't quite fit in the desired
- * span. The width returned will include the width of that extra
- * character.
+ * Include the first character that didn't quite fit in the
+ * desired span. The width returned will include the width of that
+ * extra character.
*/
curX = newX;
@@ -1141,7 +1165,7 @@ Tk_MeasureChars(tkfont, source, numBytes, maxLength, flags, lengthPtr)
}
curX = termX;
- curByte = term - source;
+ curByte = term - source;
}
*lengthPtr = curX;
@@ -1151,11 +1175,67 @@ Tk_MeasureChars(tkfont, source, numBytes, maxLength, flags, lengthPtr)
/*
*---------------------------------------------------------------------------
*
+ * TkpMeasureCharsInContext --
+ *
+ * Determine the number of bytes from the string that will fit in the
+ * given horizontal span. The measurement is done under the assumption
+ * that TkpDrawCharsInContext() will be used to actually display the
+ * characters.
+ *
+ * This one is almost the same as Tk_MeasureChars(), but with access to
+ * all the characters on the line for context. On X11 this context isn't
+ * consulted, so we just call Tk_MeasureChars().
+ *
+ * Results:
+ * The return value is the number of bytes from source that fit into the
+ * span that extends from 0 to maxLength. *lengthPtr is filled with the
+ * x-coordinate of the right edge of the last character that did fit.
+ *
+ * Side effects:
+ * None.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+int
+TkpMeasureCharsInContext(
+ Tk_Font tkfont, /* Font in which characters will be drawn. */
+ CONST char *source, /* UTF-8 string to be displayed. Need not be
+ * '\0' terminated. */
+ int numBytes, /* Maximum number of bytes to consider from
+ * source string in all. */
+ int rangeStart, /* Index of first byte to measure. */
+ int rangeLength, /* Length of range to measure in bytes. */
+ int maxLength, /* If >= 0, maxLength specifies the longest
+ * permissible line length; don't consider any
+ * character that would cross this x-position.
+ * If < 0, then line length is unbounded and
+ * the flags argument is ignored. */
+ int flags, /* Various flag bits OR-ed together:
+ * TK_PARTIAL_OK means include the last char
+ * which only partially fit on this line.
+ * TK_WHOLE_WORDS means stop on a word
+ * boundary, if possible. TK_AT_LEAST_ONE
+ * means return at least one character even if
+ * no characters fit. TK_ISOLATE_END means
+ * that the last character should not be
+ * considered in context with the rest of the
+ * string (used for breaking lines). */
+ int *lengthPtr) /* Filled with x-location just after the
+ * terminating character. */
+{
+ (void) numBytes; /*unused*/
+ return Tk_MeasureChars(tkfont, source + rangeStart, rangeLength,
+ maxLength, flags, lengthPtr);
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
* Tk_DrawChars --
*
- * Draw a string of characters on the screen. Tk_DrawChars()
- * expands control characters that occur in the string to
- * \xNN sequences.
+ * Draw a string of characters on the screen. Tk_DrawChars() expands
+ * control characters that occur in the string to \xNN sequences.
*
* Results:
* None.
@@ -1167,21 +1247,21 @@ Tk_MeasureChars(tkfont, source, numBytes, maxLength, flags, lengthPtr)
*/
void
-Tk_DrawChars(display, drawable, gc, tkfont, source, numBytes, x, y)
- Display *display; /* Display on which to draw. */
- Drawable drawable; /* Window or pixmap in which to draw. */
- GC gc; /* Graphics context for drawing characters. */
- Tk_Font tkfont; /* Font in which characters will be drawn;
+Tk_DrawChars(
+ Display *display, /* Display on which to draw. */
+ Drawable drawable, /* Window or pixmap in which to draw. */
+ GC gc, /* Graphics context for drawing characters. */
+ Tk_Font tkfont, /* Font in which characters will be drawn;
* must be the same as font used in GC. */
- CONST char *source; /* UTF-8 string to be displayed. Need not be
- * '\0' terminated. All Tk meta-characters
+ CONST char *source, /* UTF-8 string to be displayed. Need not be
+ * '\0' terminated. All Tk meta-characters
* (tabs, control characters, and newlines)
* should be stripped out of the string that
- * is passed to this function. If they are
- * not stripped out, they will be displayed as
+ * is passed to this function. If they are not
+ * stripped out, they will be displayed as
* regular printing characters. */
- int numBytes; /* Number of bytes in string. */
- int x, y; /* Coordinates at which to place origin of
+ int numBytes, /* Number of bytes in string. */
+ int x, int y) /* Coordinates at which to place origin of
* string when drawing. */
{
UnixFont *fontPtr;
@@ -1206,6 +1286,7 @@ Tk_DrawChars(display, drawable, gc, tkfont, source, numBytes, x, y)
/*
* Get the window width so we can abort drawing outside of the window
*/
+
if (XGetGeometry(display, drawable, &root, &rx, &ry, &width, &height,
&border_width, &depth) == False) {
window_width = INT_MAX;
@@ -1214,9 +1295,10 @@ Tk_DrawChars(display, drawable, gc, tkfont, source, numBytes, x, y)
}
#else
/*
- * This is used by default until we find a solution that doesn't
- * round-trip to the X server (need to get Tk cached window width).
+ * This is used by default until we find a solution that doesn't do a
+ * round-trip to the X server (needed to get Tk cached window width).
*/
+
window_width = 32768;
#endif
@@ -1233,13 +1315,13 @@ Tk_DrawChars(display, drawable, gc, tkfont, source, numBytes, x, y)
if ((thisSubFontPtr != lastSubFontPtr)
|| (p == end) || (p-source > 200)) {
if (p > source) {
- do_width = (needWidth || (p != end)) ? 1 : 0;
+ do_width = (needWidth || (p != end)) ? 1 : 0;
familyPtr = lastSubFontPtr->familyPtr;
Tcl_UtfToExternalDString(familyPtr->encoding, source,
p - source, &runString);
if (familyPtr->isTwoByteFont) {
- XDrawString16(display, drawable, gc, x, y,
+ XDrawString16(display, drawable, gc, x, y,
(XChar2b *) Tcl_DStringValue(&runString),
Tcl_DStringLength(&runString) / 2);
if (do_width) {
@@ -1263,7 +1345,7 @@ Tk_DrawChars(display, drawable, gc, tkfont, source, numBytes, x, y)
source = p;
XSetFont(display, gc, lastSubFontPtr->fontStructPtr->fid);
if (x > window_width) {
- break;
+ break;
}
}
p = next;
@@ -1284,30 +1366,71 @@ Tk_DrawChars(display, drawable, gc, tkfont, source, numBytes, x, y)
(unsigned) (x - xStart), (unsigned) fontPtr->barHeight);
}
}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * TkpDrawCharsInContext --
+ *
+ * Draw a string of characters on the screen like Tk_DrawChars(), but
+ * with access to all the characters on the line for context. On X11 this
+ * context isn't consulted, so we just call Tk_DrawChars().
+ *
+ * Results:
+ * None.
+ *
+ * Side effects:
+ * Information gets drawn on the screen.
+ *
+ *---------------------------------------------------------------------------
+ */
+void
+TkpDrawCharsInContext(
+ Display *display, /* Display on which to draw. */
+ Drawable drawable, /* Window or pixmap in which to draw. */
+ GC gc, /* Graphics context for drawing characters. */
+ Tk_Font tkfont, /* Font in which characters will be drawn;
+ * must be the same as font used in GC. */
+ CONST char *source, /* UTF-8 string to be displayed. Need not be
+ * '\0' terminated. All Tk meta-characters
+ * (tabs, control characters, and newlines)
+ * should be stripped out of the string that
+ * is passed to this function. If they are not
+ * stripped out, they will be displayed as
+ * regular printing characters. */
+ int numBytes, /* Number of bytes in string. */
+ int rangeStart, /* Index of first byte to draw. */
+ int rangeLength, /* Length of range to draw in bytes. */
+ int x, int y) /* Coordinates at which to place origin of the
+ * whole (not just the range) string when
+ * drawing. */
+{
+ (void) numBytes; /*unused*/
-
+ Tk_DrawChars(display, drawable, gc, tkfont, source + rangeStart,
+ rangeLength, x, y);
+}
/*
*-------------------------------------------------------------------------
*
* CreateClosestFont --
*
- * Helper for TkpGetNativeFont() and TkpGetFontFromAttributes().
- * Given a set of font attributes, construct a close XFontStruct.
- * If requested face name is not available, automatically
- * substitutes an alias for requested face name. If encoding is
- * not specified (or the requested one is not available),
- * automatically chooses another encoding from the list of
- * preferred encodings. If the foundry is not specified (or
- * is not available) automatically prefers "adobe" foundry.
- * For all other attributes, if the requested value was not
- * available, the appropriate "close" value will be used.
+ * Helper for TkpGetNativeFont() and TkpGetFontFromAttributes(). Given a
+ * set of font attributes, construct a close XFontStruct. If requested
+ * face name is not available, automatically substitutes an alias for
+ * requested face name. If encoding is not specified (or the requested
+ * one is not available), automatically chooses another encoding from the
+ * list of preferred encodings. If the foundry is not specified (or is
+ * not available) automatically prefers "adobe" foundry. For all other
+ * attributes, if the requested value was not available, the appropriate
+ * "close" value will be used.
*
* Results:
- * Return value is the XFontStruct that best matched the
- * requested attributes. The return value is never NULL; some
- * font will always be returned.
+ * Return value is the XFontStruct that best matched the requested
+ * attributes. The return value is never NULL; some font will always be
+ * returned.
*
* Side effects:
* None.
@@ -1316,19 +1439,18 @@ Tk_DrawChars(display, drawable, gc, tkfont, source, numBytes, x, y)
*/
static XFontStruct *
-CreateClosestFont(tkwin, faPtr, xaPtr)
- Tk_Window tkwin; /* For display where font will be used. */
- CONST TkFontAttributes *faPtr;
+CreateClosestFont(
+ Tk_Window tkwin, /* For display where font will be used. */
+ CONST TkFontAttributes *faPtr,
/* Set of generic attributes to match. */
- CONST TkXLFDAttributes *xaPtr;
+ CONST TkXLFDAttributes *xaPtr)
/* Set of X-specific attributes to match. */
{
FontAttributes want;
char **nameList;
- int numNames, nameIdx;
+ int numNames, nameIdx, bestIdx[2];
Display *display;
XFontStruct *fontStructPtr;
- int bestIdx[2];
unsigned int bestScore[2];
want.fa = *faPtr;
@@ -1362,7 +1484,7 @@ CreateClosestFont(tkwin, faPtr, xaPtr)
char ***fontFallbacks;
int i, j;
char *fallback;
-
+
fontFallbacks = TkFontGetFallbacks();
for (i = 0; fontFallbacks[i] != NULL; i++) {
for (j = 0; (fallback = fontFallbacks[i][j]) != NULL; j++) {
@@ -1387,7 +1509,8 @@ CreateClosestFont(tkwin, faPtr, xaPtr)
return GetSystemFont(display);
}
}
- found:
+
+ found:
bestIdx[0] = -1;
bestIdx[1] = -1;
bestScore[0] = (unsigned int) -1;
@@ -1412,9 +1535,10 @@ CreateClosestFont(tkwin, faPtr, xaPtr)
}
}
- fontStructPtr = GetScreenFont(display, &want, nameList, bestIdx, bestScore);
+ fontStructPtr = GetScreenFont(display, &want, nameList, bestIdx,
+ bestScore);
XFreeFontNames(nameList);
-
+
if (fontStructPtr == NULL) {
return GetSystemFont(display);
}
@@ -1427,12 +1551,12 @@ CreateClosestFont(tkwin, faPtr, xaPtr)
* InitFont --
*
* Helper for TkpGetNativeFont() and TkpGetFontFromAttributes().
- * Initializes the memory for a new UnixFont that wraps the
+ * Initializes the memory for a new UnixFont that wraps the
* platform-specific data.
*
- * The caller is responsible for initializing the fields of the
- * TkFont that are used exclusively by the generic TkFont code, and
- * for releasing those fields before calling TkpDeleteFont().
+ * The caller is responsible for initializing the fields of the TkFont
+ * that are used exclusively by the generic TkFont code, and for
+ * releasing those fields before calling TkpDeleteFont().
*
* Results:
* Fills the WinFont structure.
@@ -1441,17 +1565,17 @@ CreateClosestFont(tkwin, faPtr, xaPtr)
* Memory allocated.
*
*---------------------------------------------------------------------------
- */
+ */
static void
-InitFont(tkwin, fontStructPtr, fontPtr)
- Tk_Window tkwin; /* For screen where font will be used. */
- XFontStruct *fontStructPtr; /* X information about font. */
- UnixFont *fontPtr; /* Filled with information constructed from
+InitFont(
+ Tk_Window tkwin, /* For screen where font will be used. */
+ XFontStruct *fontStructPtr, /* X information about font. */
+ UnixFont *fontPtr) /* Filled with information constructed from
* the above arguments. */
{
- ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
- Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+ ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
+ Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
unsigned long value;
int minHi, maxHi, minLo, maxLo, fixed, width, limit, i, n;
FontAttributes fa;
@@ -1464,7 +1588,7 @@ InitFont(tkwin, fontStructPtr, fontPtr)
/*
* Get all font attributes and metrics.
*/
-
+
display = Tk_Display(tkwin);
GetFontAttributes(display, fontStructPtr, &fa);
@@ -1472,7 +1596,7 @@ InitFont(tkwin, fontStructPtr, fontPtr)
maxHi = fontStructPtr->max_byte1;
minLo = fontStructPtr->min_char_or_byte2;
maxLo = fontStructPtr->max_char_or_byte2;
-
+
fixed = 1;
if (fontStructPtr->per_char != NULL) {
width = 0;
@@ -1490,41 +1614,41 @@ InitFont(tkwin, fontStructPtr, fontPtr)
}
}
- fontPtr->font.fid = fontStructPtr->fid;
+ fontPtr->font.fid = fontStructPtr->fid;
- faPtr = &fontPtr->font.fa;
- faPtr->family = fa.fa.family;
- faPtr->size = TkFontGetPoints(tkwin, fa.fa.size);
- faPtr->weight = fa.fa.weight;
- faPtr->slant = fa.fa.slant;
- faPtr->underline = 0;
- faPtr->overstrike = 0;
+ faPtr = &fontPtr->font.fa;
+ faPtr->family = fa.fa.family;
+ faPtr->size = TkFontGetPoints(tkwin, fa.fa.size);
+ faPtr->weight = fa.fa.weight;
+ faPtr->slant = fa.fa.slant;
+ faPtr->underline = 0;
+ faPtr->overstrike = 0;
- fmPtr = &fontPtr->font.fm;
- fmPtr->ascent = fontStructPtr->ascent;
- fmPtr->descent = fontStructPtr->descent;
- fmPtr->maxWidth = fontStructPtr->max_bounds.width;
- fmPtr->fixed = fixed;
+ fmPtr = &fontPtr->font.fm;
+ fmPtr->ascent = fontStructPtr->ascent;
+ fmPtr->descent = fontStructPtr->descent;
+ fmPtr->maxWidth = fontStructPtr->max_bounds.width;
+ fmPtr->fixed = fixed;
- fontPtr->display = display;
- fontPtr->pixelSize = TkFontGetPixels(tkwin, fa.fa.size);
- fontPtr->xa = fa.xa;
+ fontPtr->display = display;
+ fontPtr->pixelSize = TkFontGetPixels(tkwin, fa.fa.size);
+ fontPtr->xa = fa.xa;
- fontPtr->numSubFonts = 1;
- fontPtr->subFontArray = fontPtr->staticSubFonts;
+ fontPtr->numSubFonts = 1;
+ fontPtr->subFontArray = fontPtr->staticSubFonts;
InitSubFont(display, fontStructPtr, 1, &fontPtr->subFontArray[0]);
- fontPtr->controlSubFont = fontPtr->subFontArray[0];
- subFontPtr = FindSubFontForChar(fontPtr, '0', NULL);
- controlPtr = &fontPtr->controlSubFont;
- controlPtr->fontStructPtr = subFontPtr->fontStructPtr;
- controlPtr->familyPtr = &tsdPtr->controlFamily;
- controlPtr->fontMap = tsdPtr->controlFamily.fontMap;
-
+ fontPtr->controlSubFont = fontPtr->subFontArray[0];
+ subFontPtr = FindSubFontForChar(fontPtr, '0', NULL);
+ controlPtr = &fontPtr->controlSubFont;
+ controlPtr->fontStructPtr = subFontPtr->fontStructPtr;
+ controlPtr->familyPtr = &tsdPtr->controlFamily;
+ controlPtr->fontMap = tsdPtr->controlFamily.fontMap;
+
pageMap = fontPtr->subFontArray[0].fontMap[0];
for (i = 0; i < 256; i++) {
- if ((minHi > 0) || (i < minLo) || (i > maxLo) ||
- (((pageMap[i >> 3] >> (i & 7)) & 1) == 0)) {
+ if ((minHi > 0) || (i < minLo) || (i > maxLo)
+ || (((pageMap[i>>3] >> (i&7)) & 1) == 0)) {
n = 0;
} else if (fontStructPtr->per_char == NULL) {
n = fontStructPtr->max_bounds.width;
@@ -1533,14 +1657,13 @@ InitFont(tkwin, fontStructPtr, fontPtr)
}
fontPtr->widths[i] = n;
}
-
if (XGetFontProperty(fontStructPtr, XA_UNDERLINE_POSITION, &value)) {
fontPtr->underlinePos = value;
} else {
/*
- * If the XA_UNDERLINE_POSITION property does not exist, the X
- * manual recommends using the following value:
+ * If the XA_UNDERLINE_POSITION property does not exist, the X manual
+ * recommends using the following value:
*/
fontPtr->underlinePos = fontStructPtr->descent / 2;
@@ -1551,10 +1674,10 @@ InitFont(tkwin, fontStructPtr, fontPtr)
}
if (fontPtr->barHeight == 0) {
/*
- * If the XA_UNDERLINE_THICKNESS property does not exist, the X
- * manual recommends using the width of the stem on a capital
- * letter. I don't know of a way to get the stem width of a letter,
- * so guess and use 1/3 the width of a capital I.
+ * If the XA_UNDERLINE_THICKNESS property does not exist, the X manual
+ * recommends using the width of the stem on a capital letter. I don't
+ * know of a way to get the stem width of a letter, so guess and use
+ * 1/3 the width of a capital I.
*/
fontPtr->barHeight = fontPtr->widths['I'] / 3;
@@ -1565,8 +1688,8 @@ InitFont(tkwin, fontStructPtr, fontPtr)
if (fontPtr->underlinePos + fontPtr->barHeight > fontStructPtr->descent) {
/*
* If this set of cobbled together values would cause the bottom of
- * the underline bar to stick below the descent of the font, jack
- * the underline up a bit higher.
+ * the underline bar to stick below the descent of the font, jack the
+ * underline up a bit higher.
*/
fontPtr->barHeight = fontStructPtr->descent - fontPtr->underlinePos;
@@ -1581,10 +1704,9 @@ InitFont(tkwin, fontStructPtr, fontPtr)
*-------------------------------------------------------------------------
*
* ReleaseFont --
- *
- * Called to release the unix-specific contents of a TkFont.
- * The caller is responsible for freeing the memory used by the
- * font itself.
+ *
+ * Called to release the unix-specific contents of a TkFont. The caller
+ * is responsible for freeing the memory used by the font itself.
*
* Results:
* None.
@@ -1594,10 +1716,10 @@ InitFont(tkwin, fontStructPtr, fontPtr)
*
*---------------------------------------------------------------------------
*/
-
+
static void
-ReleaseFont(fontPtr)
- UnixFont *fontPtr; /* The font to delete. */
+ReleaseFont(
+ UnixFont *fontPtr) /* The font to delete. */
{
int i;
@@ -1614,9 +1736,9 @@ ReleaseFont(fontPtr)
*
* InitSubFont --
*
- * Wrap a screen font and load the FontFamily that represents
- * it. Used to prepare a SubFont so that characters can be mapped
- * from UTF-8 to the charset of the font.
+ * Wrap a screen font and load the FontFamily that represents it. Used to
+ * prepare a SubFont so that characters can be mapped from UTF-8 to the
+ * charset of the font.
*
* Results:
* The subFontPtr is filled with information about the font.
@@ -1628,17 +1750,17 @@ ReleaseFont(fontPtr)
*/
static void
-InitSubFont(display, fontStructPtr, base, subFontPtr)
- Display *display; /* Display in which font will be used. */
- XFontStruct *fontStructPtr; /* The screen font. */
- int base; /* Non-zero if this SubFont is being used
- * as the base font for a font object. */
- SubFont *subFontPtr; /* Filled with SubFont constructed from
- * above attributes. */
+InitSubFont(
+ Display *display, /* Display in which font will be used. */
+ XFontStruct *fontStructPtr, /* The screen font. */
+ int base, /* Non-zero if this SubFont is being used as
+ * the base font for a font object. */
+ SubFont *subFontPtr) /* Filled with SubFont constructed from above
+ * attributes. */
{
subFontPtr->fontStructPtr = fontStructPtr;
- subFontPtr->familyPtr = AllocFontFamily(display, fontStructPtr, base);
- subFontPtr->fontMap = subFontPtr->familyPtr->fontMap;
+ subFontPtr->familyPtr = AllocFontFamily(display, fontStructPtr, base);
+ subFontPtr->fontMap = subFontPtr->familyPtr->fontMap;
}
/*
@@ -1646,8 +1768,8 @@ InitSubFont(display, fontStructPtr, base, subFontPtr)
*
* ReleaseSubFont --
*
- * Called to release the contents of a SubFont. The caller is
- * responsible for freeing the memory used by the SubFont itself.
+ * Called to release the contents of a SubFont. The caller is responsible
+ * for freeing the memory used by the SubFont itself.
*
* Results:
* None.
@@ -1659,9 +1781,9 @@ InitSubFont(display, fontStructPtr, base, subFontPtr)
*/
static void
-ReleaseSubFont(display, subFontPtr)
- Display *display; /* Display which owns screen font. */
- SubFont *subFontPtr; /* The SubFont to delete. */
+ReleaseSubFont(
+ Display *display, /* Display which owns screen font. */
+ SubFont *subFontPtr) /* The SubFont to delete. */
{
XFreeFont(display, subFontPtr->fontStructPtr);
FreeFontFamily(subFontPtr->familyPtr);
@@ -1672,43 +1794,41 @@ ReleaseSubFont(display, subFontPtr)
*
* AllocFontFamily --
*
- * Find the FontFamily structure associated with the given font
- * name. The information should be stored by the caller in a
- * SubFont and used when determining if that SubFont supports a
- * character.
+ * Find the FontFamily structure associated with the given font name.
+ * The information should be stored by the caller in a SubFont and used
+ * when determining if that SubFont supports a character.
*
- * Cannot use the string name used to construct the font as the
- * key, because the capitalization may not be canonical. Therefore
- * use the face name actually retrieved from the font metrics as
- * the key.
+ * Cannot use the string name used to construct the font as the key,
+ * because the capitalization may not be canonical. Therefore use the
+ * face name actually retrieved from the font metrics as the key.
*
* Results:
- * A pointer to a FontFamily. The reference count in the FontFamily
- * is automatically incremented. When the SubFont is released, the
- * reference count is decremented. When no SubFont is using this
- * FontFamily, it may be deleted.
+ * A pointer to a FontFamily. The reference count in the FontFamily is
+ * automatically incremented. When the SubFont is released, the reference
+ * count is decremented. When no SubFont is using this FontFamily, it may
+ * be deleted.
*
* Side effects:
- * A new FontFamily structure will be allocated if this font family
- * has not been seen. TrueType character existence metrics are
- * loaded into the FontFamily structure.
+ * A new FontFamily structure will be allocated if this font family has
+ * not been seen. TrueType character existence metrics are loaded into
+ * the FontFamily structure.
*
*-------------------------------------------------------------------------
*/
static FontFamily *
-AllocFontFamily(display, fontStructPtr, base)
- Display *display; /* Display in which font will be used. */
- XFontStruct *fontStructPtr; /* Screen font whose FontFamily is to be
+AllocFontFamily(
+ Display *display, /* Display in which font will be used. */
+ XFontStruct *fontStructPtr, /* Screen font whose FontFamily is to be
* returned. */
- int base; /* Non-zero if this font family is to be
- * used in the base font of a font object. */
+ int base) /* Non-zero if this font family is to be used
+ * in the base font of a font object. */
{
FontFamily *familyPtr;
FontAttributes fa;
Tcl_Encoding encoding;
- ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
- Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+ ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
+ Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
GetFontAttributes(display, fontStructPtr, &fa);
encoding = Tcl_GetEncoding(NULL, GetEncodingAlias(fa.xa.charset));
@@ -1729,26 +1849,26 @@ AllocFontFamily(display, fontStructPtr, base)
familyPtr->nextPtr = tsdPtr->fontFamilyList;
tsdPtr->fontFamilyList = familyPtr;
- /*
- * Set key for this FontFamily.
+ /*
+ * Set key for this FontFamily.
*/
-
+
familyPtr->foundry = fa.xa.foundry;
familyPtr->faceName = fa.fa.family;
familyPtr->encoding = encoding;
- /*
- * An initial refCount of 2 means that FontFamily information will
- * persist even when the SubFont that loaded the FontFamily is released.
- * Change it to 1 to cause FontFamilies to be unloaded when not in use.
+ /*
+ * An initial refCount of 2 means that FontFamily information will persist
+ * even when the SubFont that loaded the FontFamily is released. Change it
+ * to 1 to cause FontFamilies to be unloaded when not in use.
*/
familyPtr->refCount = 2;
/*
- * One byte/character fonts have both min_byte1 and max_byte1 0,
- * and max_char_or_byte2 <= 255.
- * Anything else specifies a two byte/character font.
+ * One byte/character fonts have both min_byte1 and max_byte1 0, and
+ * max_char_or_byte2 <= 255. Anything else specifies a two byte/character
+ * font.
*/
familyPtr->isTwoByteFont = !(
@@ -1763,9 +1883,9 @@ AllocFontFamily(display, fontStructPtr, base)
*
* FreeFontFamily --
*
- * Called to free an FontFamily when the SubFont is finished using
- * it. Frees the contents of the FontFamily and the memory used by
- * the FontFamily itself.
+ * Called to free an FontFamily when the SubFont is finished using it.
+ * Frees the contents of the FontFamily and the memory used by the
+ * FontFamily itself.
*
* Results:
* None.
@@ -1775,42 +1895,42 @@ AllocFontFamily(display, fontStructPtr, base)
*
*-------------------------------------------------------------------------
*/
-
+
static void
-FreeFontFamily(familyPtr)
- FontFamily *familyPtr; /* The FontFamily to delete. */
+FreeFontFamily(
+ FontFamily *familyPtr) /* The FontFamily to delete. */
{
FontFamily **familyPtrPtr;
- ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
- Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+ ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
+ Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
int i;
if (familyPtr == NULL) {
- return;
+ return;
}
familyPtr->refCount--;
if (familyPtr->refCount > 0) {
- return;
+ return;
}
Tcl_FreeEncoding(familyPtr->encoding);
for (i = 0; i < FONTMAP_PAGES; i++) {
- if (familyPtr->fontMap[i] != NULL) {
- ckfree(familyPtr->fontMap[i]);
- }
+ if (familyPtr->fontMap[i] != NULL) {
+ ckfree(familyPtr->fontMap[i]);
+ }
}
-
- /*
- * Delete from list.
+
+ /*
+ * Delete from list.
*/
-
+
for (familyPtrPtr = &tsdPtr->fontFamilyList; ; ) {
- if (*familyPtrPtr == familyPtr) {
- *familyPtrPtr = familyPtr->nextPtr;
+ if (*familyPtrPtr == familyPtr) {
+ *familyPtrPtr = familyPtr->nextPtr;
break;
}
familyPtrPtr = &(*familyPtrPtr)->nextPtr;
}
-
+
ckfree((char *) familyPtr);
}
@@ -1819,39 +1939,35 @@ FreeFontFamily(familyPtr)
*
* FindSubFontForChar --
*
- * Determine which screen font is necessary to use to
- * display the given character. If the font object does not have
- * a screen font that can display the character, another screen font
- * may be loaded into the font object, following a set of preferred
- * fallback rules.
+ * Determine which screen font is necessary to use to display the given
+ * character. If the font object does not have a screen font that can
+ * display the character, another screen font may be loaded into the font
+ * object, following a set of preferred fallback rules.
*
* Results:
- * The return value is the SubFont to use to display the given
- * character.
+ * The return value is the SubFont to use to display the given character.
*
* Side effects:
- * The contents of fontPtr are modified to cache the results
- * of the lookup and remember any SubFonts that were dynamically
- * loaded. The table of SubFonts might be extended, and if a non-NULL
- * reference to a subfont pointer is available, it is updated if it
- * previously pointed into the old subfont table.
+ * The contents of fontPtr are modified to cache the results of the
+ * lookup and remember any SubFonts that were dynamically loaded. The
+ * table of SubFonts might be extended, and if a non-NULL reference to a
+ * subfont pointer is available, it is updated if it previously pointed
+ * into the old subfont table.
*
*-------------------------------------------------------------------------
*/
static SubFont *
-FindSubFontForChar(fontPtr, ch, fixSubFontPtrPtr)
- UnixFont *fontPtr; /* The font object with which the character
+FindSubFontForChar(
+ UnixFont *fontPtr, /* The font object with which the character
* will be displayed. */
- int ch; /* The Unicode character to be displayed. */
- SubFont **fixSubFontPtrPtr; /* Subfont reference to fix up if we
+ int ch, /* The Unicode character to be displayed. */
+ SubFont **fixSubFontPtrPtr) /* Subfont reference to fix up if we
* reallocate our subfont table. */
{
int i, j, k, numNames;
- Tk_Uid faceName;
- char *fallback;
- char **aliases, **nameList, **anyFallbacks;
- char ***fontFallbacks;
+ Tk_Uid faceName;
+ char *fallback, **aliases, **nameList, **anyFallbacks, ***fontFallbacks;
SubFont *subFontPtr;
Tcl_DString ds;
@@ -1870,19 +1986,19 @@ FindSubFontForChar(fontPtr, ch, fixSubFontPtrPtr)
}
/*
- * Keep track of all face names that we check, so we don't check some
- * name multiple times if it can be reached by multiple paths.
+ * Keep track of all face names that we check, so we don't check some name
+ * multiple times if it can be reached by multiple paths.
*/
-
+
Tcl_DStringInit(&ds);
/*
- * Are there any other fonts with the same face name as the base
- * font that could display this character, e.g., if the base font
- * is adobe:fixed:iso8859-1, we could might be able to use
+ * Are there any other fonts with the same face name as the base font that
+ * could display this character, e.g., if the base font is
+ * adobe:fixed:iso8859-1, we could might be able to use
* misc:fixed:iso8859-8 or sony:fixed:jisx0208.1983-0
*/
-
+
faceName = fontPtr->font.fa.family;
if (SeenName(faceName, &ds) == 0) {
subFontPtr = CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr);
@@ -1904,7 +2020,7 @@ FindSubFontForChar(fontPtr, ch, fixSubFontPtrPtr)
goto tryfallbacks;
} else if (aliases != NULL) {
- /*
+ /*
* Or if an alias for the base font has a fallback...
*/
@@ -1917,11 +2033,11 @@ FindSubFontForChar(fontPtr, ch, fixSubFontPtrPtr)
}
continue;
- tryfallbacks:
+ tryfallbacks:
- /*
- * ...then see if we can use one of the fallbacks, or an
- * alias for one of the fallbacks.
+ /*
+ * ...then see if we can use one of the fallbacks, or an alias for one
+ * of the fallbacks.
*/
for (j = 0; (fallback = fontFallbacks[i][j]) != NULL; j++) {
@@ -1934,7 +2050,7 @@ FindSubFontForChar(fontPtr, ch, fixSubFontPtrPtr)
}
/*
- * See if we can use something from the global fallback list.
+ * See if we can use something from the global fallback list.
*/
anyFallbacks = TkFontGetGlobalClass();
@@ -1947,8 +2063,8 @@ FindSubFontForChar(fontPtr, ch, fixSubFontPtrPtr)
}
/*
- * Try all face names available in the whole system until we
- * find one that can be used.
+ * Try all face names available in the whole system until we find one that
+ * can be used.
*/
nameList = ListFonts(fontPtr->display, "*", &numNames);
@@ -1966,7 +2082,7 @@ FindSubFontForChar(fontPtr, ch, fixSubFontPtrPtr)
}
XFreeFontNames(nameList);
- end:
+ end:
Tcl_DStringFree(&ds);
if (subFontPtr == NULL) {
@@ -1989,24 +2105,23 @@ FindSubFontForChar(fontPtr, ch, fixSubFontPtrPtr)
* See if the screen font can display the given character.
*
* Results:
- * The return value is 0 if the screen font cannot display the
- * character, non-zero otherwise.
+ * The return value is 0 if the screen font cannot display the character,
+ * non-zero otherwise.
*
* Side effects:
- * New pages are added to the font mapping cache whenever the
- * character belongs to a page that hasn't been seen before.
- * When a page is loaded, information about all the characters on
- * that page is stored, not just for the single character in
- * question.
+ * New pages are added to the font mapping cache whenever the character
+ * belongs to a page that hasn't been seen before. When a page is loaded,
+ * information about all the characters on that page is stored, not just
+ * for the single character in question.
*
*-------------------------------------------------------------------------
*/
static int
-FontMapLookup(subFontPtr, ch)
- SubFont *subFontPtr; /* Contains font mapping cache to be queried
+FontMapLookup(
+ SubFont *subFontPtr, /* Contains font mapping cache to be queried
* and possibly updated. */
- int ch; /* Character to be tested. */
+ int ch) /* Character to be tested. */
{
int row, bitOffset;
@@ -2023,31 +2138,30 @@ FontMapLookup(subFontPtr, ch)
*
* FontMapInsert --
*
- * Tell the font mapping cache that the given screen font should be
- * used to display the specified character. This is called when no
- * font on the system can be be found that can display that
- * character; we lie to the font and tell it that it can display
- * the character, otherwise we would end up re-searching the entire
- * fallback hierarchy every time that character was seen.
+ * Tell the font mapping cache that the given screen font should be used
+ * to display the specified character. This is called when no font on the
+ * system can be be found that can display that character; we lie to the
+ * font and tell it that it can display the character, otherwise we would
+ * end up re-searching the entire fallback hierarchy every time that
+ * character was seen.
*
* Results:
* None.
*
* Side effects:
- * New pages are added to the font mapping cache whenever the
- * character belongs to a page that hasn't been seen before.
- * When a page is loaded, information about all the characters on
- * that page is stored, not just for the single character in
- * question.
+ * New pages are added to the font mapping cache whenever the character
+ * belongs to a page that hasn't been seen before. When a page is loaded,
+ * information about all the characters on that page is stored, not just
+ * for the single character in question.
*
*-------------------------------------------------------------------------
*/
static void
-FontMapInsert(subFontPtr, ch)
- SubFont *subFontPtr; /* Contains font mapping cache to be
+FontMapInsert(
+ SubFont *subFontPtr, /* Contains font mapping cache to be
* updated. */
- int ch; /* Character to be added to cache. */
+ int ch) /* Character to be added to cache. */
{
int row, bitOffset;
@@ -2064,25 +2178,25 @@ FontMapInsert(subFontPtr, ch)
*
* FontMapLoadPage --
*
- * Load information about all the characters on a given page.
- * This information consists of one bit per character that indicates
- * whether the associated screen font can (1) or cannot (0) display
- * the characters on the page.
+ * Load information about all the characters on a given page. This
+ * information consists of one bit per character that indicates whether
+ * the associated screen font can (1) or cannot (0) display the
+ * characters on the page.
*
* Results:
* None.
*
* Side effects:
- * Mempry allocated.
+ * Memory allocated.
*
*-------------------------------------------------------------------------
*/
-static void
-FontMapLoadPage(subFontPtr, row)
- SubFont *subFontPtr; /* Contains font mapping cache to be
+static void
+FontMapLoadPage(
+ SubFont *subFontPtr, /* Contains font mapping cache to be
* updated. */
- int row; /* Index of the page to be loaded into
- * the cache. */
+ int row) /* Index of the page to be loaded into the
+ * cache. */
{
char buf[16], src[TCL_UTF_MAX];
int minHi, maxHi, minLo, maxLo, scale, checkLo;
@@ -2090,8 +2204,8 @@ FontMapLoadPage(subFontPtr, row)
Tcl_Encoding encoding;
XFontStruct *fontStructPtr;
XCharStruct *widths;
- ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
- Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+ ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
+ Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
subFontPtr->fontMap[row] = (char *) ckalloc(FONTMAP_BITSPERPAGE / 8);
memset(subFontPtr->fontMap[row], 0, FONTMAP_BITSPERPAGE / 8);
@@ -2100,17 +2214,17 @@ FontMapLoadPage(subFontPtr, row)
return;
}
- fontStructPtr = subFontPtr->fontStructPtr;
- encoding = subFontPtr->familyPtr->encoding;
- isTwoByteFont = subFontPtr->familyPtr->isTwoByteFont;
+ fontStructPtr = subFontPtr->fontStructPtr;
+ encoding = subFontPtr->familyPtr->encoding;
+ isTwoByteFont = subFontPtr->familyPtr->isTwoByteFont;
- widths = fontStructPtr->per_char;
- minHi = fontStructPtr->min_byte1;
- maxHi = fontStructPtr->max_byte1;
- minLo = fontStructPtr->min_char_or_byte2;
- maxLo = fontStructPtr->max_char_or_byte2;
- scale = maxLo - minLo + 1;
- checkLo = minLo;
+ widths = fontStructPtr->per_char;
+ minHi = fontStructPtr->min_byte1;
+ maxHi = fontStructPtr->max_byte1;
+ minLo = fontStructPtr->min_char_or_byte2;
+ maxLo = fontStructPtr->max_char_or_byte2;
+ scale = maxLo - minLo + 1;
+ checkLo = minLo;
if (! isTwoByteFont) {
if (minLo < 32) {
@@ -2123,7 +2237,7 @@ FontMapLoadPage(subFontPtr, row)
int hi, lo;
if (Tcl_UtfToExternal(NULL, encoding, src, Tcl_UniCharToUtf(i, src),
- TCL_ENCODING_STOPONERROR, NULL, buf, sizeof(buf), NULL,
+ TCL_ENCODING_STOPONERROR, NULL, buf, sizeof(buf), NULL,
NULL, NULL) != TCL_OK) {
continue;
}
@@ -2138,7 +2252,7 @@ FontMapLoadPage(subFontPtr, row)
continue;
}
n = (hi - minHi) * scale + lo - minLo;
- if ((widths == NULL) || ((widths[n].width + widths[n].rbearing) != 0)) {
+ if ((widths == NULL) || (widths[n].width + widths[n].rbearing != 0)) {
bitOffset = i & (FONTMAP_BITSPERPAGE - 1);
subFontPtr->fontMap[row][bitOffset >> 3] |= 1 << (bitOffset & 7);
}
@@ -2150,43 +2264,41 @@ FontMapLoadPage(subFontPtr, row)
*
* CanUseFallbackWithAliases --
*
- * Helper function for FindSubFontForChar. Determine if the
- * specified face name (or an alias of the specified face name)
- * can be used to construct a screen font that can display the
- * given character.
+ * Helper function for FindSubFontForChar. Determine if the specified
+ * face name (or an alias of the specified face name) can be used to
+ * construct a screen font that can display the given character.
*
* Results:
* See CanUseFallback().
*
* Side effects:
- * If the name and/or one of its aliases was rejected, the
- * rejected string is recorded in nameTriedPtr so that it won't
- * be tried again. The table of SubFonts might be extended, and if
- * a non-NULL reference to a subfont pointer is available, it is
- * updated if it previously pointed into the old subfont table.
+ * If the name and/or one of its aliases was rejected, the rejected
+ * string is recorded in nameTriedPtr so that it won't be tried again.
+ * The table of SubFonts might be extended, and if a non-NULL reference
+ * to a subfont pointer is available, it is updated if it previously
+ * pointed into the old subfont table.
*
*---------------------------------------------------------------------------
*/
static SubFont *
-CanUseFallbackWithAliases(fontPtr, faceName, ch, nameTriedPtr,
- fixSubFontPtrPtr)
- UnixFont *fontPtr; /* The font object that will own the new
+CanUseFallbackWithAliases(
+ UnixFont *fontPtr, /* The font object that will own the new
* screen font. */
- char *faceName; /* Desired face name for new screen font. */
- int ch; /* The Unicode character that the new
- * screen font must be able to display. */
- Tcl_DString *nameTriedPtr; /* Records face names that have already
- * been tried. It is possible for the same
- * face name to be queried multiple times when
+ char *faceName, /* Desired face name for new screen font. */
+ int ch, /* The Unicode character that the new screen
+ * font must be able to display. */
+ Tcl_DString *nameTriedPtr, /* Records face names that have already been
+ * tried. It is possible for the same face
+ * name to be queried multiple times when
* trying to find a suitable screen font. */
- SubFont **fixSubFontPtrPtr; /* Subfont reference to fix up if we
+ SubFont **fixSubFontPtrPtr) /* Subfont reference to fix up if we
* reallocate our subfont table. */
{
SubFont *subFontPtr;
char **aliases;
int i;
-
+
if (SeenName(faceName, nameTriedPtr) == 0) {
subFontPtr = CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr);
if (subFontPtr != NULL) {
@@ -2213,9 +2325,9 @@ CanUseFallbackWithAliases(fontPtr, faceName, ch, nameTriedPtr,
*
* SeenName --
*
- * Used to determine we have already tried and rejected the given
- * face name when looking for a screen font that can support some
- * Unicode character.
+ * Used to determine we have already tried and rejected the given face
+ * name when looking for a screen font that can support some Unicode
+ * character.
*
* Results:
* The return value is 0 if this face name has not already been seen,
@@ -2228,9 +2340,9 @@ CanUseFallbackWithAliases(fontPtr, faceName, ch, nameTriedPtr,
*/
static int
-SeenName(name, dsPtr)
- CONST char *name; /* The name to check. */
- Tcl_DString *dsPtr; /* Contains names that have already been
+SeenName(
+ CONST char *name, /* The name to check. */
+ Tcl_DString *dsPtr) /* Contains names that have already been
* seen. */
{
CONST char *seen, *end;
@@ -2252,69 +2364,63 @@ SeenName(name, dsPtr)
*
* CanUseFallback --
*
- * If the specified screen font has not already been loaded
- * into the font object, determine if the specified screen
- * font can display the given character.
+ * If the specified screen font has not already been loaded into the font
+ * object, determine if the specified screen font can display the given
+ * character.
*
* Results:
- * The return value is a pointer to a newly allocated SubFont,
- * owned by the font object. This SubFont can be used to display
- * the given character. The SubFont represents the screen font
- * with the base set of font attributes from the font object, but
- * using the specified face name. NULL is returned if the font
- * object already holds a reference to the specified font or if
- * the specified font doesn't exist or cannot display the given
- * character.
+ * The return value is a pointer to a newly allocated SubFont, owned by
+ * the font object. This SubFont can be used to display the given
+ * character. The SubFont represents the screen font with the base set of
+ * font attributes from the font object, but using the specified face
+ * name. NULL is returned if the font object already holds a reference to
+ * the specified font or if the specified font doesn't exist or cannot
+ * display the given character.
*
- * Side effects:
- * The font object's subFontArray is updated to contain a reference
- * to the newly allocated SubFont. The table of SubFonts might be
- * extended, and if a non-NULL reference to a subfont pointer is
- * available, it is updated if it previously pointed into the old
- * subfont table.
+ * Side effects:
+ * The font object's subFontArray is updated to contain a reference to
+ * the newly allocated SubFont. The table of SubFonts might be extended,
+ * and if a non-NULL reference to a subfont pointer is available, it is
+ * updated if it previously pointed into the old subfont table.
*
*-------------------------------------------------------------------------
*/
static SubFont *
-CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr)
- UnixFont *fontPtr; /* The font object that will own the new
+CanUseFallback(
+ UnixFont *fontPtr, /* The font object that will own the new
* screen font. */
- CONST char *faceName; /* Desired face name for new screen font. */
- int ch; /* The Unicode character that the new
- * screen font must be able to display. */
- SubFont **fixSubFontPtrPtr; /* Subfont reference to fix up if we
+ CONST char *faceName, /* Desired face name for new screen font. */
+ int ch, /* The Unicode character that the new screen
+ * font must be able to display. */
+ SubFont **fixSubFontPtrPtr) /* Subfont reference to fix up if we
* reallocate our subfont table. */
{
- int i, nameIdx, numNames, srcLen;
+ int i, nameIdx, numNames, srcLen, numEncodings, bestIdx[2];
Tk_Uid hateFoundry;
- int bestIdx[2];
CONST char *charset, *hateCharset;
unsigned int bestScore[2];
- char **nameList, **nameListOrig;
+ char **nameList, **nameListOrig, src[TCL_UTF_MAX];
FontAttributes want, got;
- char src[TCL_UTF_MAX];
Display *display;
SubFont subFont;
XFontStruct *fontStructPtr;
Tcl_DString dsEncodings;
- int numEncodings;
Tcl_Encoding *encodingCachePtr;
/*
* Assume: the face name is times.
* Assume: adobe:times:iso8859-1 has already been used.
*
- * Are there any versions of times that can display this
- * character (e.g., perhaps linotype:times:iso8859-2)?
+ * Are there any versions of times that can display this character (e.g.,
+ * perhaps linotype:times:iso8859-2)?
* a. Get list of all times fonts.
* b1. Cross out all names whose encodings we've already used.
* b2. Cross out all names whose foundry & encoding we've already seen.
* c. Cross out all names whose encoding cannot handle the character.
* d. Rank each name and pick the best match.
- * e. If that font cannot actually display the character, cross
- * out all names with the same foundry and encoding and go
- * back to (c).
+ * e. If that font cannot actually display the character, cross out all
+ * names with the same foundry and encoding and go back to (c).
*/
display = fontPtr->display;
@@ -2339,7 +2445,7 @@ CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr)
charset = NULL; /* lint, since numNames must be > 0 to get here. */
- retry:
+ retry:
bestIdx[0] = -1;
bestIdx[1] = -1;
bestScore[0] = (unsigned int) -1;
@@ -2349,7 +2455,7 @@ CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr)
char dst[16];
int scalable, srcRead, dstWrote;
unsigned int score;
-
+
if (nameList[nameIdx] == NULL) {
continue;
}
@@ -2360,9 +2466,8 @@ CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr)
charset = GetEncodingAlias(got.xa.charset);
if (hateFoundry != NULL) {
/*
- * E. If the font we picked cannot actually display the
- * character, cross out all names with the same foundry and
- * encoding.
+ * E. If the font we picked cannot actually display the character,
+ * cross out all names with the same foundry and encoding.
*/
if ((hateFoundry == got.xa.foundry)
@@ -2373,7 +2478,7 @@ CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr)
/*
* B. Cross out all names whose encodings we've already used.
*/
-
+
for (i = 0; i < fontPtr->numSubFonts; i++) {
encoding = fontPtr->subFontArray[i].familyPtr->encoding;
if (strcmp(charset, Tcl_GetEncodingName(encoding)) == 0) {
@@ -2381,11 +2486,11 @@ CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr)
}
}
}
-
+
/*
* C. Cross out all names whose encoding cannot handle the character.
*/
-
+
encodingCachePtr = (Tcl_Encoding *) Tcl_DStringValue(&dsEncodings);
for (i = numEncodings; --i >= 0; encodingCachePtr++) {
encoding = *encodingCachePtr;
@@ -2403,8 +2508,8 @@ CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr)
sizeof(encoding));
numEncodings++;
}
- Tcl_UtfToExternal(NULL, encoding, src, srcLen,
- TCL_ENCODING_STOPONERROR, NULL, dst, sizeof(dst), &srcRead,
+ Tcl_UtfToExternal(NULL, encoding, src, srcLen,
+ TCL_ENCODING_STOPONERROR, NULL, dst, sizeof(dst), &srcRead,
&dstWrote, NULL);
if (dstWrote == 0) {
goto crossout;
@@ -2425,11 +2530,11 @@ CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr)
}
continue;
- crossout:
+ crossout:
if (nameList == nameListOrig) {
/*
- * Not allowed to change pointers to memory that X gives you,
- * so make a copy.
+ * Not allowed to change pointers to memory that X gives you, so
+ * make a copy.
*/
nameList = (char **) ckalloc(numNames * sizeof(char *));
@@ -2438,7 +2543,8 @@ CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr)
nameList[nameIdx] = NULL;
}
- fontStructPtr = GetScreenFont(display, &want, nameList, bestIdx, bestScore);
+ fontStructPtr = GetScreenFont(display, &want, nameList, bestIdx,
+ bestScore);
encodingCachePtr = (Tcl_Encoding *) Tcl_DStringValue(&dsEncodings);
for (i = numEncodings; --i >= 0; encodingCachePtr++) {
@@ -2475,8 +2581,9 @@ CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr)
if (fontPtr->numSubFonts >= SUBFONT_SPACE) {
SubFont *newPtr;
-
- newPtr = (SubFont *) ckalloc(sizeof(SubFont) * (fontPtr->numSubFonts + 1));
+
+ newPtr = (SubFont *)
+ ckalloc(sizeof(SubFont) * (fontPtr->numSubFonts + 1));
memcpy((char *) newPtr, fontPtr->subFontArray,
fontPtr->numSubFonts * sizeof(SubFont));
if (fixSubFontPtrPtr != NULL) {
@@ -2502,12 +2609,12 @@ CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr)
*
* RankAttributes --
*
- * Determine how close the attributes of the font in question match
- * the attributes that we want.
+ * Determine how close the attributes of the font in question match the
+ * attributes that we want.
*
* Results:
- * The return value is the score; lower numbers are better.
- * *scalablePtr is set to 0 if the font was not scalable, 1 otherwise.
+ * The return value is the score; lower numbers are better. *scalablePtr
+ * is set to 0 if the font was not scalable, 1 otherwise.
*
* Side effects:
* None.
@@ -2516,9 +2623,9 @@ CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr)
*/
static unsigned int
-RankAttributes(wantPtr, gotPtr)
- FontAttributes *wantPtr; /* The desired attributes. */
- FontAttributes *gotPtr; /* The attributes we have to live with. */
+RankAttributes(
+ FontAttributes *wantPtr, /* The desired attributes. */
+ FontAttributes *gotPtr) /* The attributes we have to live with. */
{
unsigned int penalty;
@@ -2544,8 +2651,8 @@ RankAttributes(wantPtr, gotPtr)
if (gotPtr->fa.size == 0) {
/*
- * A scalable font is almost always acceptable, but the
- * corresponding bitmapped font would be better.
+ * A scalable font is almost always acceptable, but the corresponding
+ * bitmapped font would be better.
*/
penalty += 10;
@@ -2555,7 +2662,7 @@ RankAttributes(wantPtr, gotPtr)
/*
* It's worse to be too large than to be too small.
*/
-
+
diff = (-gotPtr->fa.size - -wantPtr->fa.size);
if (diff > 0) {
penalty += 600;
@@ -2571,7 +2678,7 @@ RankAttributes(wantPtr, gotPtr)
penalty += 65000;
gotAlias = GetEncodingAlias(gotPtr->xa.charset);
- wantAlias = GetEncodingAlias(wantPtr->xa.charset);
+ wantAlias = GetEncodingAlias(wantPtr->xa.charset);
if (strcmp(gotAlias, wantAlias) != 0) {
penalty += 30000;
for (i = 0; encodingList[i] != NULL; i++) {
@@ -2592,9 +2699,8 @@ RankAttributes(wantPtr, gotPtr)
* GetScreenFont --
*
* Given the names for the best scalable and best bitmapped font,
- * actually construct an XFontStruct based on the best XLFD.
- * This is where all the alias and fallback substitution bottoms
- * out.
+ * actually construct an XFontStruct based on the best XLFD. This is
+ * where all the alias and fallback substitution bottoms out.
*
* Results:
* The screen font that best corresponds to the set of attributes.
@@ -2606,16 +2712,16 @@ RankAttributes(wantPtr, gotPtr)
*/
static XFontStruct *
-GetScreenFont(display, wantPtr, nameList, bestIdx, bestScore)
- Display *display; /* Display for new XFontStruct. */
- FontAttributes *wantPtr; /* Contains desired actual pixel-size if the
+GetScreenFont(
+ Display *display, /* Display for new XFontStruct. */
+ FontAttributes *wantPtr, /* Contains desired actual pixel-size if the
* best font was scalable. */
- char **nameList; /* Array of XLFDs. */
- int bestIdx[2]; /* Indices into above array for XLFD of
- * best bitmapped and best scalable font. */
- unsigned int bestScore[2]; /* Scores of best bitmapped and best
- * scalable font. XLFD corresponding to
- * lowest score will be constructed. */
+ char **nameList, /* Array of XLFDs. */
+ int bestIdx[2], /* Indices into above array for XLFD of best
+ * bitmapped and best scalable font. */
+ unsigned int bestScore[2]) /* Scores of best bitmapped and best scalable
+ * font. XLFD corresponding to lowest score
+ * will be constructed. */
{
XFontStruct *fontStructPtr;
@@ -2624,24 +2730,23 @@ GetScreenFont(display, wantPtr, nameList, bestIdx, bestScore)
}
/*
- * Now we know which is the closest matching scalable font and the
- * closest matching bitmapped font. If the scalable font was a
- * better match, try getting the scalable font; however, if the
- * scalable font was not actually available in the desired
- * pointsize, fall back to the closest bitmapped font.
+ * Now we know which is the closest matching scalable font and the closest
+ * matching bitmapped font. If the scalable font was a better match, try
+ * getting the scalable font; however, if the scalable font was not
+ * actually available in the desired pointsize, fall back to the closest
+ * bitmapped font.
*/
fontStructPtr = NULL;
if (bestScore[1] < bestScore[0]) {
- char *str, *rest;
- char buf[256];
+ char *str, *rest, buf[256];
int i;
-
+
/*
* Fill in the desired pixel size for this font.
*/
- tryscale:
+ tryscale:
str = nameList[bestIdx[1]];
for (i = 0; i < XLFD_PIXEL_SIZE; i++) {
str = strchr(str + 1, '-');
@@ -2661,8 +2766,8 @@ GetScreenFont(display, wantPtr, nameList, bestIdx, bestScore)
fontStructPtr = XLoadQueryFont(display, nameList[bestIdx[0]]);
if (fontStructPtr == NULL) {
/*
- * This shouldn't happen because the font name is one of the
- * names that X gave us to use, but it does anyhow.
+ * This shouldn't happen because the font name is one of the names
+ * that X gave us to use, but it does anyhow.
*/
if (bestScore[1] < INT_MAX) {
@@ -2679,22 +2784,22 @@ GetScreenFont(display, wantPtr, nameList, bestIdx, bestScore)
*
* GetSystemFont --
*
- * Absolute fallback mechanism, called when we need a font and no
- * other font can be found and/or instantiated.
+ * Absolute fallback mechanism, called when we need a font and no other
+ * font can be found and/or instantiated.
*
* Results:
- * A pointer to a font. Never NULL.
+ * A pointer to a font. Never NULL.
*
* Side effects:
- * If there are NO fonts installed on the system, this call will
- * panic, but how did you get X running in that case?
+ * If there are NO fonts installed on the system, this call will panic,
+ * but how did you get X running in that case?
*
*---------------------------------------------------------------------------
*/
static XFontStruct *
-GetSystemFont(display)
- Display *display; /* Display for new XFontStruct. */
+GetSystemFont(
+ Display *display) /* Display for new XFontStruct. */
{
XFontStruct *fontStructPtr;
@@ -2702,7 +2807,7 @@ GetSystemFont(display)
if (fontStructPtr == NULL) {
fontStructPtr = XLoadQueryFont(display, "*");
if (fontStructPtr == NULL) {
- panic("TkpGetFontFromAttributes: cannot get any font");
+ Tcl_Panic("TkpGetFontFromAttributes: cannot get any font");
}
}
return fontStructPtr;
@@ -2713,8 +2818,8 @@ GetSystemFont(display)
*
* GetFontAttributes --
*
- * Given a screen font, determine its actual attributes, which are
- * not necessarily the attributes that were used to construct it.
+ * Given a screen font, determine its actual attributes, which are not
+ * necessarily the attributes that were used to construct it.
*
* Results:
* *faPtr is filled with the screen font's attributes.
@@ -2726,14 +2831,14 @@ GetSystemFont(display)
*/
static int
-GetFontAttributes(display, fontStructPtr, faPtr)
- Display *display; /* Display that owns the screen font. */
- XFontStruct *fontStructPtr; /* Screen font to query. */
- FontAttributes *faPtr; /* For storing attributes of screen font. */
+GetFontAttributes(
+ Display *display, /* Display that owns the screen font. */
+ XFontStruct *fontStructPtr, /* Screen font to query. */
+ FontAttributes *faPtr) /* For storing attributes of screen font. */
{
unsigned long value;
char *name;
-
+
if ((XGetFontProperty(fontStructPtr, XA_FONT, &value) != False) &&
(value != 0)) {
name = XGetAtomName(display, (Atom) value);
@@ -2747,11 +2852,13 @@ GetFontAttributes(display, fontStructPtr, faPtr)
TkInitFontAttributes(&faPtr->fa);
TkInitXLFDAttributes(&faPtr->xa);
}
+
/*
- * Do last ditch check for family. It seems that some X servers can
- * fail on the X font calls above, slipping through earlier checks.
- * X-Win32 5.4 is one of these.
+ * Do last ditch check for family. It seems that some X servers can fail
+ * on the X font calls above, slipping through earlier checks. X-Win32 5.4
+ * is one of these.
*/
+
if (faPtr->fa.family == NULL) {
faPtr->fa.family = Tk_GetUid("");
faPtr->xa.foundry = Tk_GetUid("");
@@ -2765,8 +2872,8 @@ GetFontAttributes(display, fontStructPtr, faPtr)
*
* ListFonts --
*
- * Utility function to return the array of all XLFDs on the system
- * with the specified face name.
+ * Utility function to return the array of all XLFDs on the system with
+ * the specified face name.
*
* Results:
* The return value is an array of XLFDs, which should be freed with
@@ -2777,13 +2884,13 @@ GetFontAttributes(display, fontStructPtr, faPtr)
*
*---------------------------------------------------------------------------
*/
-
+
static char **
-ListFonts(display, faceName, numNamesPtr)
- Display *display; /* Display to query. */
- CONST char *faceName; /* Desired face name, or "*" for all. */
- int *numNamesPtr; /* Filled with length of returned array, or
- * 0 if no names were found. */
+ListFonts(
+ Display *display, /* Display to query. */
+ CONST char *faceName, /* Desired face name, or "*" for all. */
+ int *numNamesPtr) /* Filled with length of returned array, or 0
+ * if no names were found. */
{
char buf[256];
@@ -2792,15 +2899,15 @@ ListFonts(display, faceName, numNamesPtr)
}
static char **
-ListFontOrAlias(display, faceName, numNamesPtr)
- Display *display; /* Display to query. */
- CONST char *faceName; /* Desired face name, or "*" for all. */
- int *numNamesPtr; /* Filled with length of returned array, or
- * 0 if no names were found. */
+ListFontOrAlias(
+ Display *display, /* Display to query. */
+ CONST char *faceName, /* Desired face name, or "*" for all. */
+ int *numNamesPtr) /* Filled with length of returned array, or 0
+ * if no names were found. */
{
char **nameList, **aliases;
int i;
-
+
nameList = ListFonts(display, faceName, numNamesPtr);
if (nameList != NULL) {
return nameList;
@@ -2823,19 +2930,18 @@ ListFontOrAlias(display, faceName, numNamesPtr)
*
* IdentifySymbolEncodings --
*
- * If the font attributes refer to a symbol font, update the
- * charset field of the font attributes so that it reflects the
- * encoding of that symbol font. In general, the raw value for
- * the charset field parsed from an XLFD is meaningless for symbol
- * fonts.
+ * If the font attributes refer to a symbol font, update the charset
+ * field of the font attributes so that it reflects the encoding of that
+ * symbol font. In general, the raw value for the charset field parsed
+ * from an XLFD is meaningless for symbol fonts.
*
* Symbol fonts are all fonts whose name appears in the symbolClass.
*
* Results:
- * The return value is non-zero if the font attributes specify a
- * symbol font, or 0 otherwise. If a non-zero value is returned
- * the charset field of the font attributes will be changed to
- * the string that represents the actual encoding for the symbol font.
+ * The return value is non-zero if the font attributes specify a symbol
+ * font, or 0 otherwise. If a non-zero value is returned the charset
+ * field of the font attributes will be changed to the string that
+ * represents the actual encoding for the symbol font.
*
* Side effects:
* None.
@@ -2844,8 +2950,8 @@ ListFontOrAlias(display, faceName, numNamesPtr)
*/
static int
-IdentifySymbolEncodings(faPtr)
- FontAttributes *faPtr;
+IdentifySymbolEncodings(
+ FontAttributes *faPtr)
{
int i, j;
char **aliases, **symbolClass;
@@ -2872,14 +2978,14 @@ IdentifySymbolEncodings(faPtr)
*
* GetEncodingAlias --
*
- * Map the name of an encoding to another name that should be used
- * when actually loading the encoding. For instance, the encodings
- * "jisc6226.1978", "jisx0208.1983", "jisx0208.1990", and
- * "jisx0208.1996" are well-known names for the same encoding and
- * are represented by one encoding table: "jis0208".
+ * Map the name of an encoding to another name that should be used when
+ * actually loading the encoding. For instance, the encodings
+ * "jisc6226.1978", "jisx0208.1983", "jisx0208.1990", and "jisx0208.1996"
+ * are well-known names for the same encoding and are represented by one
+ * encoding table: "jis0208".
*
* Results:
- * As above. If the name has no alias, the original name is returned.
+ * As above. If the name has no alias, the original name is returned.
*
* Side effects:
* None.
@@ -2888,11 +2994,11 @@ IdentifySymbolEncodings(faPtr)
*/
static CONST char *
-GetEncodingAlias(name)
- CONST char *name; /* The name to look up. */
+GetEncodingAlias(
+ CONST char *name) /* The name to look up. */
{
EncodingAlias *aliasPtr;
-
+
for (aliasPtr = encodingAliases; aliasPtr->aliasPattern != NULL; ) {
if (Tcl_StringMatch((char *) name, aliasPtr->aliasPattern)) {
return aliasPtr->realName;
@@ -2901,3 +3007,11 @@ GetEncodingAlias(name)
}
return name;
}
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */