diff options
Diffstat (limited to 'macosx/tkMacOSXFont.c')
| -rw-r--r-- | macosx/tkMacOSXFont.c | 2520 |
1 files changed, 1056 insertions, 1464 deletions
diff --git a/macosx/tkMacOSXFont.c b/macosx/tkMacOSXFont.c index 2f81ae5..1a4a399 100644 --- a/macosx/tkMacOSXFont.c +++ b/macosx/tkMacOSXFont.c @@ -1,10 +1,11 @@ /* * tkMacOSXFont.c -- * - * Contains the Macintosh implementation of the platform-independant - * font package interface. This version uses ATSU instead of Quickdraw. + * Contains the Macintosh implementation of the platform-independant + * font package interface. This version uses ATSU instead of Quickdraw. * * Copyright 2002-2004 Benjamin Riefenstahl, Benjamin.Riefenstahl@epost.de + * Copyright (c) 2006-2007 Daniel A. Steffen <das@users.sourceforge.net> * * Some functions were originally copied verbatim from the QuickDraw version * of tkMacOSXFont.c, which had these copyright notices: @@ -16,7 +17,6 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * * Todos: * * - Get away from Font Manager and Quickdraw functions as much as possible, @@ -26,39 +26,31 @@ * instead of just assuming that they are the same. * * - Get a second font register going for fonts that are not assigned to a - * font family by the OS. On my system I have 27 fonts of that type, + * font family by the OS. On my system I have 27 fonts of that type, * Hebrew, Arabic and Hindi fonts that actually come with the system. * FMGetFontFamilyInstanceFromFont() returns -981 (kFMInvalidFontFamilyErr) * for these and they are not listed when enumerating families, but they - * are when enumerating fonts directly. The problem that the OS sees may - * be that at least some of them do not contain any Latin characters. Note + * are when enumerating fonts directly. The problem that the OS sees may + * be that at least some of them do not contain any Latin characters. Note * that such fonts can not be used for controls, because controls * definitely require a family id (this assertion needs testing). * - * RCS: @(#) $Id: tkMacOSXFont.c,v 1.23 2007/04/21 19:06:38 hobbs Exp $ + * RCS: @(#) $Id: tkMacOSXFont.c,v 1.24 2007/04/23 21:24:33 das Exp $ */ #include "tkMacOSXInt.h" #include "tkMacOSXFont.h" /* -#ifdef TK_MAC_DEBUG +#ifdef TK_MAC_DEBUG #define TK_MAC_DEBUG_FONTS #endif */ -/* Define macros only available on Mac OS X 10.3 or later */ -#ifndef FixedToInt -#define FixedToInt(a) ((short)(((Fixed)(a) + fixed1/2) >> 16)) -#endif -#ifndef IntToFixed -#define IntToFixed(a) ((Fixed)(a) << 16) -#endif - /* - * Problem: The sum of two parts is not the same as the whole. In particular + * Problem: The sum of two parts is not the same as the whole. In particular * the width of two separately measured strings will usually be larger than - * the width of them pasted together. Tk has a design bug here, because it + * the width of them pasted together. Tk has a design bug here, because it * generally assumes that this kind of arithmetic works. * To workaround this, #define TK_MAC_COALESCE_LINE to 1 below, we then avoid * lines that tremble and shiver while the cursor passes through them by @@ -68,17 +60,45 @@ */ #define TK_MAC_COALESCE_LINE 0 -typedef TkMacOSXFont MacFont; -typedef TkMacOSXFontDrawingContext DrawingContext; +/* + * The following structure represents our Macintosh-specific implementation + * of a font object. + */ + +typedef struct { + TkFont font; /* Stuff used by generic font package. Must + * be first in structure. */ + + /* + * The ATSU view of the font and other text properties. Used for drawing + * and measuring. + */ + + ATSUFontID atsuFontId; /* == FMFont. */ + ATSUTextLayout atsuLayout; /* ATSU layout object, representing the whole + * text that ATSU sees with some option + * bits. */ + ATSUStyle atsuStyle; /* ATSU style object, representing a run of + * text with the same properties. */ + + /* + * The QuickDraw view of the font. Used to configure controls. + */ + + FMFontFamily qdFont; /* == FMFontFamilyId, Carbon replacement for + * QD face numbers. */ + short qdSize; /* Font size in points. */ + short qdStyle; /* QuickDraw style bits. */ +} MacFont; /* - * Information about font families, initialized at startup time. Font + * Information about font families, initialized at startup time. Font * families are described by a mapping from UTF-8 names to MacOS font family - * IDs. The whole list is kept as the sorted array "familyList", allocated + * IDs. The whole list is kept as the sorted array "familyList", allocated * with ckrealloc(). * * Note: This would have been easier, if we could just have used Tcl hash - * arrays. Unfortunately there seems to be no pre-packaged + * arrays. Unfortunately there seems to be no pre-packaged * non-case-sensitive version of that available. */ @@ -89,137 +109,121 @@ typedef struct { static MacFontFamily * familyList = NULL; static int - familyListNextFree = 0, /* The next free slot in familyList. */ - familyListMaxValid = 0, /* The top of the sorted area. */ - familyListSize = 0; /* The size of the whole array. */ + familyListNextFree = 0, /* The next free slot in familyList. */ + familyListMaxValid = 0, /* The top of the sorted area. */ + familyListSize = 0; /* The size of the whole array. */ /* * A simple one-shot sub-allocator for fast and efficient allocation of - * strings. Used by the familyList array for the names. These strings are - * only allocated once at startup and never freed. If you ever need to + * strings. Used by the familyList array for the names. These strings are + * only allocated once at startup and never freed. If you ever need to * re-initialize this, you can just ckfree() all the StringBlocks in the list * and start over. */ -#define STRING_BLOCK_MAX (1024-8) /* Make sizeof(StringBlock) == - * 1024. */ +#define STRING_BLOCK_MAX (1024-8) /* Make sizeof(StringBlock) == + * 1024. */ typedef struct StringBlock { - struct StringBlock * next; /* Starting from "stringMemory" these - * blocks form a linked list. */ - int nextFree; /* Top of the used area in the - * "strings" member. */ - char strings[STRING_BLOCK_MAX]; /* The actual memory managed here. */ + struct StringBlock *next; /* Starting from "stringMemory" these + * blocks form a linked list. */ + int nextFree; /* Top of the used area in the + * "strings" member. */ + char strings[STRING_BLOCK_MAX]; /* The actual memory managed here. */ } StringBlock; -static StringBlock * stringMemory = NULL; - +static StringBlock *stringMemory = NULL; #if TK_MAC_COALESCE_LINE -static Tcl_DString currentLine; /* The current line as seen so far. This - * contains a Tcl_UniChar DString. */ +static Tcl_DString currentLine; /* The current line as seen so far. This + * contains a Tcl_UniChar DString. */ static int - currentY = -1, /* The Y position (row in pixels) of the - * current line. */ - currentLeft = -1, /* The left edge (pixels) of the current - * line. */ - currentRight = -1; /* The right edge (pixels) of the current - * line. */ -static const MacFont * currentFontPtr = NULL; - /* The font of the current line. */ + currentY = -1, /* The Y position (row in pixels) of the + * current line. */ + currentLeft = -1, /* The left edge (pixels) of the current + * line. */ + currentRight = -1; /* The right edge (pixels) of the current + * line. */ +static const MacFont *currentFontPtr = NULL; + /* The font of the current line. */ #endif /* TK_MAC_COALESCE_LINE */ static int antialiasedTextEnabled; /* - * The names for our two "native" fonts. + * The names for our "native" fonts. */ -#define SYSTEMFONT_NAME "system" -#define APPLFONT_NAME "application" +#define SYSTEMFONT_NAME "system" +#define APPLFONT_NAME "application" +#define MENUITEMFONT_NAME "menu" /* * Procedures used only in this file. */ +static void LayoutSetString(const MacFont *fontPtr, + const TkMacOSXDrawingContext *drawingContextPtr, + const UniChar * uchars, int ulen); + /* * The actual workers. */ -static void MacFontDrawText( - const MacFont * fontPtr, - const char * source, int numBytes, - int rangeStart, int rangeLength, - int x, int y); -static int MeasureStringWidth( - const MacFont * fontPtr, - int start, int end); +static int MeasureStringWidth(const MacFont *fontPtr, int start, int end); #if TK_MAC_COALESCE_LINE -static const Tcl_UniChar * UpdateLineBuffer( - const MacFont * fontPtr, - const DrawingContext * drawingContextPtr, - const char * source, int numBytes, - int x, int y, - int * offset); +static const Tcl_UniChar *UpdateLineBuffer(const MacFont *fontPtr, + const TkMacOSXDrawingContext *drawingContextPtr, const char *source, + int numBytes, int x, int y, int * offset); #endif /* TK_MAC_COALESCE_LINE */ /* * Initialization and setup of a font data structure. */ -static void InitFont( - Tk_Window tkwin, - FMFontFamily familyId, const char * familyName, - int size, int qdStyle, MacFont * fontPtr); -static void InitATSUObjects( - FMFontFamily familyId, - short qdsize, short qdStyle, - ATSUFontID * fontIdPtr, - ATSUTextLayout * layoutPtr, ATSUStyle * stylePtr); -static void InitATSUStyle( - ATSUFontID fontId, short ptSize, short qdStyle, - ATSUStyle style); -static void SetFontFeatures( - ATSUFontID fontId, int fixed, - ATSUStyle style); -static void AdjustFontHeight( - MacFont * fontPtr); -static void InitATSULayout( - const DrawingContext * drawingContextPtr, - ATSUTextLayout layout, int fixed); -static void ReleaseFont( - MacFont * fontPtr); +static void InitFont(Tk_Window tkwin, FMFontFamily familyId, + const char *familyName, int size, int qdStyle, MacFont *fontPtr); +static void InitATSUObjects(FMFontFamily familyId, short qdsize, short qdStyle, + ATSUFontID *fontIdPtr, ATSUTextLayout *layoutPtr, ATSUStyle *stylePtr); +static void InitATSUStyle(ATSUFontID fontId, short ptSize, short qdStyle, + ATSUStyle style); +static void SetFontFeatures(ATSUFontID fontId, int fixed, ATSUStyle style); +static void AdjustFontHeight(MacFont *fontPtr); +static void InitATSULayout(const TkMacOSXDrawingContext *drawingContextPtr, + ATSUTextLayout layout, int fixed); +static void ReleaseFont(MacFont *fontPtr); /* * Finding fonts by name. */ -static const MacFontFamily * FindFontFamilyOrAlias( - const char * name); -static const MacFontFamily * FindFontFamilyOrAliasOrFallback( - const char * name); +static const MacFontFamily *FindFontFamilyOrAlias(const char *name); +static const MacFontFamily *FindFontFamilyOrAliasOrFallback(const char *name); /* * Doing interesting things with font families and fonts. */ static void InitFontFamilies(void); -static OSStatus GetFontFamilyName( - FMFontFamily fontFamily, char * name, int numBytes); +static OSStatus GetFontFamilyName(FMFontFamily fontFamily, char *name, + int numBytes); /* * Accessor functions and internal utilities for the font family list. */ -static const MacFontFamily * AddFontFamily( - const char * name, FMFontFamily familyId); -static const MacFontFamily * FindFontFamily(const char * name); -static Tcl_Obj * EnumFontFamilies(void); +static const MacFontFamily *AddFontFamily(const char *name, + FMFontFamily familyId); +static const MacFontFamily *FindFontFamily(const char *name); +static Tcl_Obj *EnumFontFamilies(void); static OSStatus FontFamilyEnumCallback(ATSFontFamilyRef family, void *refCon); static void SortFontFamilies(void); -static int CompareFontFamilies(const void * vp1, const void * vp2); -static const char * AddString(const char * in); +static int CompareFontFamilies(const void *vp1, const void *vp2); +static const char *AddString(const char *in); +static OSStatus GetThemeFontAndFamily(const ThemeFontID themeFontId, + FMFontFamily *fontFamily, unsigned char *fontName, SInt16 *fontSize, + Style *fontStyle); /* @@ -227,33 +231,60 @@ static const char * AddString(const char * in); * * TkpFontPkgInit -- * - * This procedure is called when an application is created. It - * initializes all the structures that are used by the - * platform-dependant code on a per application basis. + * This procedure is called when an application is created. It + * initializes all the structures that are used by the + * platform-dependant code on a per application basis. * * Results: - * None. + * None. * * Side effects: - * Initialization of variables local to this file. + * Initialization of variables local to this file. * *------------------------------------------------------------------------- */ void TkpFontPkgInit( - TkMainInfo * mainPtr) /* The application being created. */ + TkMainInfo *mainPtr) /* The application being created. */ { InitFontFamilies(); #if TK_MAC_COALESCE_LINE Tcl_DStringInit(¤tLine); #endif +} + +/* + *--------------------------------------------------------------------------- + * + * GetThemeFontAndFamily -- + * + * Wrapper around the GetThemeFont and FMGetFontFamilyFromName APIs. + * + *--------------------------------------------------------------------------- + */ -#ifdef TK_MAC_DEBUG_FONTS - fprintf(stderr, "tkMacOSXFont.c (ATSU version) intialized " - "(" __TIME__ ")\n"); -#endif +OSStatus +GetThemeFontAndFamily( + const ThemeFontID themeFontId, + FMFontFamily* fontFamily, + unsigned char *fontName, + SInt16 *fontSize, + Style *fontStyle) +{ + OSStatus err = ChkErr(GetThemeFont, themeFontId, smSystemScript, fontName, + fontSize, fontStyle); + + if (err == noErr) { + *fontFamily = FMGetFontFamilyFromName(fontName); + if (*fontFamily == kInvalidFontFamily) { + err = kFMInvalidFontFamilyErr; + TkMacOSXDbgMsg("FMGetFontFamilyFromName failed."); + } + } + + return err; } /* @@ -261,45 +292,56 @@ TkpFontPkgInit( * * TkpGetNativeFont -- * - * Map a platform-specific native font name to a TkFont. + * 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 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. * - * The caller is responsible for initializing the memory associated - * with the generic TkFont when this function returns and releasing - * the contents of the generics 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 generics TkFont before calling TkpDeleteFont(). * * Side effects: - * None. + * None. * *--------------------------------------------------------------------------- */ TkFont * TkpGetNativeFont( - Tk_Window tkwin, /* For display where font will be used. */ - const char * name) /* Platform-specific font name. */ + Tk_Window tkwin, /* For display where font will be used. */ + const char * name) /* Platform-specific font name. */ { - FMFontFamily familyId; + ThemeFontID themeFontId; + FMFontFamily fontFamily; + Str255 fontName; + SInt16 fontSize; + Style fontStyle; MacFont * fontPtr; if (strcmp(name, SYSTEMFONT_NAME) == 0) { - familyId = GetSysFont(); + themeFontId = kThemeSystemFont; } else if (strcmp(name, APPLFONT_NAME) == 0) { - familyId = GetAppFont(); + themeFontId = kThemeApplicationFont; + } else if (strcmp(name, MENUITEMFONT_NAME) == 0) { + themeFontId = kThemeMenuItemFont; } else { - return NULL; + return NULL; } + if (GetThemeFontAndFamily(themeFontId, &fontFamily, fontName, &fontSize, + &fontStyle) != noErr) { + return NULL; + } + CopyPascalStringToC(fontName, (char*)fontName); fontPtr = (MacFont *) ckalloc(sizeof(MacFont)); - InitFont(tkwin, familyId, NULL, 0, 0, fontPtr); + InitFont(tkwin, fontFamily, (char*)fontName, fontSize, fontStyle, fontPtr); return (TkFont *) fontPtr; } @@ -309,74 +351,74 @@ TkpGetNativeFont( * * 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 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. * - * 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: - * None. + * None. * *--------------------------------------------------------------------------- */ TkFont * 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 structure is - * allocated. */ - Tk_Window tkwin, /* For display where font will be used. */ - const TkFontAttributes * faPtr) - /* Set of attributes to match. */ + 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 + * structure is allocated. */ + Tk_Window tkwin, /* For display where font will be used. */ + const TkFontAttributes *faPtr) + /* Set of attributes to match. */ { short qdStyle; FMFontFamily familyId; - const char * name; - const MacFontFamily * familyPtr; - MacFont * fontPtr; + const char *name; + const MacFontFamily *familyPtr; + MacFont *fontPtr; familyId = GetAppFont(); name = NULL; qdStyle = 0; if (faPtr->family != NULL) { - familyPtr = FindFontFamilyOrAliasOrFallback(faPtr->family); - if (familyPtr != NULL) { - name = familyPtr->name; - familyId = familyPtr->familyId; - } + familyPtr = FindFontFamilyOrAliasOrFallback(faPtr->family); + if (familyPtr != NULL) { + name = familyPtr->name; + familyId = familyPtr->familyId; + } } if (faPtr->weight != TK_FW_NORMAL) { - qdStyle |= bold; + qdStyle |= bold; } if (faPtr->slant != TK_FS_ROMAN) { - qdStyle |= italic; + qdStyle |= italic; } if (faPtr->underline) { - qdStyle |= underline; + qdStyle |= underline; } if (tkFontPtr == NULL) { - fontPtr = (MacFont *) ckalloc(sizeof(MacFont)); + fontPtr = (MacFont *) ckalloc(sizeof(MacFont)); } else { - fontPtr = (MacFont *) tkFontPtr; - ReleaseFont(fontPtr); + fontPtr = (MacFont *) tkFontPtr; + ReleaseFont(fontPtr); } InitFont(tkwin, familyId, name, faPtr->size, qdStyle, fontPtr); @@ -388,23 +430,23 @@ TkpGetFontFromAttributes( * * 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. + * 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. * * Results: - * TkFont is deallocated. + * TkFont is deallocated. * * Side effects: - * None. + * None. * *--------------------------------------------------------------------------- */ void TkpDeleteFont( - TkFont * tkFontPtr) /* Token of font to be deleted. */ + TkFont *tkFontPtr) /* Token of font to be deleted. */ { ReleaseFont((MacFont *) tkFontPtr); } @@ -414,25 +456,25 @@ TkpDeleteFont( * * 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 - * font families. + * Modifies interp's result object to hold a list of all the available + * font families. * * Side effects: - * None. + * None. * *--------------------------------------------------------------------------- */ void TkpGetFontFamilies( - Tcl_Interp * interp, /* Interp to hold result. */ - Tk_Window tkwin) /* For display to query. */ + Tcl_Interp *interp, /* Interp to hold result. */ + Tk_Window tkwin) /* For display to query. */ { - Tcl_SetObjResult(interp,EnumFontFamilies()); + Tcl_SetObjResult(interp, EnumFontFamilies()); } /* @@ -440,26 +482,26 @@ TkpGetFontFamilies( * * 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. + * None. * *------------------------------------------------------------------------- */ void TkpGetSubFonts( - Tcl_Interp * interp, /* Interp to hold result. */ - Tk_Font tkfont) /* Font object to query. */ + Tcl_Interp *interp, /* Interp to hold result. */ + Tk_Font tkfont) /* Font object to query. */ { /* We don't know much about our fallback fonts, ATSU does all that for - * us. We could use ATSUMatchFont to implement this function. But as + * us. We could use ATSUMatchFont to implement this function. But as * the information is only used for testing, such an effort seems not * very useful. */ } @@ -469,35 +511,35 @@ TkpGetSubFonts( * * TkpGetFontAttrsForChar -- * - * Retrieve the font attributes of the actual font used to render a - * given character. + * Retrieve the font attributes of the actual font used to render a + * given character. * * Results: - * None. + * None. * * Side effects: - * The font attributes are stored in *faPtr. + * 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 */ + 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 */ { - TkMacOSXFont* fontPtr = (TkMacOSXFont*) tkfont; + const MacFont * fontPtr = (const MacFont *) tkfont; UniChar uchar = c; - DrawingContext drawingContext; + TkMacOSXDrawingContext drawingContext; OSStatus err; ATSUFontID fontId; UniCharArrayOffset changedOffset; UniCharCount changedLength; /* - * Most of the attributes are just copied from the base font. This + * Most of the attributes are just copied from the base font. This * assumes that all fonts can have all attributes. */ @@ -507,202 +549,172 @@ TkpGetFontAttrsForChar( * But the name of the actual font may still differ, so we activate the * string as an ATSU layout and ask ATSU about the fallback. */ + TkMacOSXSetupDrawingContext(Tk_WindowId(tkwin), NULL, 1, &drawingContext); -#if TK_MAC_USE_QUARZ - TkMacOSXQuarzStartDraw(&drawingContext); -#endif - - TkMacOSXLayoutSetString(fontPtr, &drawingContext, &uchar, 1); + LayoutSetString(fontPtr, &drawingContext, &uchar, 1); fontId = fontPtr->atsuFontId; err = ATSUMatchFontsToText( - fontPtr->atsuLayout, 0, 1, - &fontId, &changedOffset, &changedLength); -#ifdef TK_MAC_DEBUG_FONTS + fontPtr->atsuLayout, 0, 1, + &fontId, &changedOffset, &changedLength); if (err != kATSUFontsMatched && err != noErr) { - fprintf(stderr, "TkpGetFontAttrsForChar: " - "Can't match \\u%04X\n", - (unsigned) c); + TkMacOSXDbgMsg("Can't match \\u%04X", (unsigned) c); } -#endif if (err == kATSUFontsMatched) { - - /* - * A fallback was used and the actual font is in fontId. Determine - * the name. - */ - - FMFontFamily fontFamilyId; - FMFontStyle fontStyle; - int i; - - err = FMGetFontFamilyInstanceFromFont( - fontId, &fontFamilyId, &fontStyle); -#ifdef TK_MAC_DEBUG_FONTS - if (err != noErr) { - fprintf(stderr, "FMGetFontFamilyInstanceFromFont: Error %d\n", - (int) err); - } -#endif - - if (err == noErr) { - - /* - * Find the canonical name in our global list. - */ - - for (i=0; i<familyListMaxValid; ++i) { - if (fontFamilyId == familyList[i].familyId) { - faPtr->family = familyList[i].name; - break; - } - } -#ifdef TK_MAC_DEBUG_FONTS - if (i >= familyListMaxValid) { - fprintf(stderr, "TkpGetFontAttrsForChar: " - "Can't find font %d for \\u%04X\n", - (int) fontFamilyId, (unsigned) c); - } -#endif - } + /* + * A fallback was used and the actual font is in fontId. Determine + * the name. + */ + + FMFontFamily fontFamilyId; + FMFontStyle fontStyle; + int i; + + err = ChkErr(FMGetFontFamilyInstanceFromFont, fontId, &fontFamilyId, + &fontStyle); + if (err == noErr) { + /* + * Find the canonical name in our global list. + */ + + for (i=0; i<familyListMaxValid; ++i) { + if (fontFamilyId == familyList[i].familyId) { + faPtr->family = familyList[i].name; + break; + } + } + if (i >= familyListMaxValid) { + TkMacOSXDbgMsg("Can't find font %d for \\u%04X", fontFamilyId, + (unsigned) c); + } + } } -#if TK_MAC_USE_QUARZ - TkMacOSXQuarzEndDraw(&drawingContext); -#endif + TkMacOSXRestoreDrawingContext(&drawingContext); } /* *--------------------------------------------------------------------------- * - * 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. * - * With ATSUI we need the line context to do this right, so we have the - * actual implementation in TkpMeasureCharsInContext(). + * With ATSUI we need the line context to do this right, so we have the + * actual implementation in TkpMeasureCharsInContext(). * * 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. + * None. * * Todo: - * - * Effects of the "flags" parameter are untested. + * Effects of the "flags" parameter are untested. * *--------------------------------------------------------------------------- */ int 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 - * 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. */ - int * lengthPtr) /* Filled with x-location just after the - * terminating character. */ + 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 + * 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. */ + int *lengthPtr) /* Filled with x-location just after the + * terminating character. */ { - return TkpMeasureCharsInContext( - tkfont, source, numBytes, 0, numBytes, maxLength, flags, lengthPtr); + return TkpMeasureCharsInContext(tkfont, source, numBytes, 0, numBytes, + maxLength, flags, lengthPtr); } /* *--------------------------------------------------------------------------- * - * TkpMeasureCharsInContext -- + * 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. + * 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. + * This one is almost the same as Tk_MeasureChars(), but with access to + * all the characters on the line for context. * * 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. + * 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 fits on this line. - * TK_WHOLE_WORDS means stop on a word boundary, - * if possible. - * TK_AT_LEAST_ONE means return at least one - * character (or at least the first partial word - * in case TK_WHOLE_WORDS is also set) even if no - * characters (words) 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. */ + 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 fits on this line. + * TK_WHOLE_WORDS means stop on a word + * boundary, if possible. TK_AT_LEAST_ONE + * means return at least one character (or at + * least the first partial word in case + * TK_WHOLE_WORDS is also set) even if no + * characters (words) 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. */ { - const MacFont * fontPtr = (const MacFont *) tkfont; - int curX = -1; - int curByte = 0; - UniChar * uchars; + const MacFont *fontPtr = (const MacFont *) tkfont; + int curX = -1, curByte = 0; + UniChar *uchars; int ulen, urstart, urlen, urend; Tcl_DString ucharBuffer; - DrawingContext drawingContext; - /* * Sanity checks. */ - if ((rangeStart < 0) || ((rangeStart+rangeLength) > numBytes)) { -#ifdef TK_MAC_DEBUG_FONTS - fprintf(stderr, "MeasureChars: bad parameters\n"); -#endif - *lengthPtr = 0; - return 0; + if (rangeStart < 0 || (rangeStart+rangeLength) > numBytes) { + TkMacOSXDbgMsg("Bad parameters"); + *lengthPtr = 0; + return 0; } /* @@ -710,284 +722,243 @@ TkpMeasureCharsInContext( */ if (rangeLength == 0 || (maxLength == 0 && !(flags & TK_AT_LEAST_ONE))) { -#ifdef TK_MAC_DEBUG_FONTS - fflush(stdout); - fprintf(stderr, "measure: '%.*s', empty\n", - rangeLength, source+rangeStart); - fflush(stderr); -#endif - *lengthPtr = 0; - return 0; + *lengthPtr = 0; + return 0; } -#if TK_MAC_USE_QUARZ - TkMacOSXQuarzStartDraw(&drawingContext); -#endif - Tcl_DStringInit(&ucharBuffer); uchars = Tcl_UtfToUniCharDString(source, numBytes, &ucharBuffer); ulen = Tcl_DStringLength(&ucharBuffer) / sizeof(Tcl_UniChar); - TkMacOSXLayoutSetString(fontPtr, &drawingContext, uchars, ulen); + LayoutSetString(fontPtr, NULL, uchars, ulen); urstart = Tcl_NumUtfChars(source, rangeStart); urlen = Tcl_NumUtfChars(source+rangeStart,rangeLength); urend = urstart + urlen; if (maxLength < 0) { - - curX = MeasureStringWidth(fontPtr, urstart, urend); - curByte = rangeLength; - + curX = MeasureStringWidth(fontPtr, urstart, urend); + curByte = rangeLength; } else { - - UniCharArrayOffset offset = 0; - OSStatus err; - - /* - * Have some upper limit on the size actually used. - */ - - if (maxLength > 32767) { - maxLength = 32767; - } - - offset = urstart; - err = noErr; - - if (maxLength > 1) { - - /* - * Let the system do some work by calculating a line break. - * - * Somehow ATSUBreakLine seems to assume that it needs at least - * one pixel padding. So we add one to the limit. Note also - * that ATSUBreakLine sometimes runs into an endless loop when - * the third parameter is equal or less than IntToFixed(2), so we - * need at least IntToFixed(3) (at least that's the current state - * of my knowledge). - */ - - err = ATSUBreakLine( - fontPtr->atsuLayout, - urstart, - IntToFixed(maxLength+1), - false, /* !iUseAsSoftLineBreak */ - &offset); - - /* - * There is no way to signal an error from this routine, so we - * use predefined offset=urstart and otherwise ignore the - * possibility. - */ + UniCharArrayOffset offset = 0; + OSStatus err; + + /* + * Have some upper limit on the size actually used. + */ + + if (maxLength > 32767) { + maxLength = 32767; + } + + offset = urstart; + err = noErr; + + if (maxLength > 1) { + /* + * Let the system do some work by calculating a line break. + * + * Somehow ATSUBreakLine seems to assume that it needs at least + * one pixel padding. So we add one to the limit. Note also + * that ATSUBreakLine sometimes runs into an endless loop when + * the third parameter is equal or less than IntToFixed(2), so we + * need at least IntToFixed(3) (at least that's the current state + * of my knowledge). + */ + + err = ATSUBreakLine(fontPtr->atsuLayout, urstart, + IntToFixed(maxLength+1), false, /* !iUseAsSoftLineBreak */ + &offset); + + /* + * There is no way to signal an error from this routine, so we + * use predefined offset=urstart and otherwise ignore the + * possibility. + */ + + if ((err != noErr) && (err != kATSULineBreakInWord)) { + TkMacOSXDbgMsg("ATSUBreakLine failed: %ld for '%.*s'", err, + rangeLength, source+rangeStart); + } #ifdef TK_MAC_DEBUG_FONTS - if ((err != noErr) && (err != kATSULineBreakInWord)) { - fprintf(stderr, "ATSUBreakLine(): Error %d for '%.*s'\n", - (int) err, rangeLength, source+rangeStart); - } + TkMacOSXDbgMsg("measure: '%.*s', break offset=%ld, errcode=%ld", + rangeLength, source+rangeStart, offset, err); #endif -#ifdef TK_MAC_DEBUG_FONTS - fprintf(stderr, "measure: '%.*s', break offset=%d, errcode=%d\n", - rangeLength, source+rangeStart, (int) offset, (int) err); -#endif - - /* - * ATSUBreakLine includes the whitespace that separates words, - * but we don't want that. Besides, ATSUBreakLine thinks that - * spaces don't occupy pixels at the end of the break, which is - * also something we like to decide for ourself. - */ - - while ((offset > (UniCharArrayOffset)urstart) && (uchars[offset-1] == ' ')) { - offset--; - } - - /* - * Fix up left-overs for the TK_WHOLE_WORDS case. - */ - - if (flags & TK_WHOLE_WORDS) { - if(flags & TK_AT_LEAST_ONE) { - - /* - * If we are the the start of the range, we need to look - * forward. If we are not at the end of a word, we must - * be in the middle of the first word, so we also look - * forward. - */ - - if ((offset == (UniCharArrayOffset)urstart) || (uchars[offset] != ' ')) { - while ((offset < (UniCharArrayOffset)urend) - && (uchars[offset] != ' ')) { - offset++; - } - } - } else { - - /* - * If we are not at the end of a word, we need to look - * backward. - */ - - if ((offset != (UniCharArrayOffset)urend) && (uchars[offset] != ' ')) { - while ((offset > (UniCharArrayOffset)urstart) - && (uchars[offset-1] != ' ')) { - offset--; - } - while ((offset > (UniCharArrayOffset)urstart) - && (uchars[offset-1] == ' ')) { - offset--; - } - } - } - } - } - - if (offset > (UniCharArrayOffset)urend) { - offset = urend; - } - - /* - * If "flags" says that we don't actually want a word break, we need - * to find the next character break ourself, as ATSUBreakLine() will - * only give us word breaks. Do a simple linear search. - */ - - if ((err != kATSULineBreakInWord) - && !(flags & TK_WHOLE_WORDS) - && (offset <= (UniCharArrayOffset)urend)) { - - UniCharArrayOffset lastOffset = offset; - UniCharArrayOffset nextoffset; - int lastX = -1; - int wantonemorechar = -1; /* undecided */ - - while (offset <= (UniCharArrayOffset)urend) { - - if (flags & TK_ISOLATE_END) { - TkMacOSXLayoutSetString(fontPtr, &drawingContext, - uchars, offset); - } - curX = MeasureStringWidth(fontPtr, urstart, offset); + /* + * ATSUBreakLine includes the whitespace that separates words, + * but we don't want that. Besides, ATSUBreakLine thinks that + * spaces don't occupy pixels at the end of the break, which is + * also something we like to decide for ourself. + */ + + while ((offset > (UniCharArrayOffset)urstart) && + (uchars[offset-1] == ' ')) { + offset--; + } + + /* + * Fix up left-overs for the TK_WHOLE_WORDS case. + */ + + if (flags & TK_WHOLE_WORDS) { + if (flags & TK_AT_LEAST_ONE) { + /* + * If we are the the start of the range, we need to look + * forward. If we are not at the end of a word, we must + * be in the middle of the first word, so we also look + * forward. + */ + + if ((offset == (UniCharArrayOffset)urstart) || + (uchars[offset] != ' ')) { + while ((offset < (UniCharArrayOffset)urend) + && (uchars[offset] != ' ')) { + offset++; + } + } + } else { + /* + * If we are not at the end of a word, we need to look + * backward. + */ + + if ((offset != (UniCharArrayOffset)urend) && + (uchars[offset] != ' ')) { + while ((offset > (UniCharArrayOffset)urstart) + && (uchars[offset-1] != ' ')) { + offset--; + } + while ((offset > (UniCharArrayOffset)urstart) + && (uchars[offset-1] == ' ')) { + offset--; + } + } + } + } + } + + if (offset > (UniCharArrayOffset)urend) { + offset = urend; + } + + /* + * If "flags" says that we don't actually want a word break, we need + * to find the next character break ourself, as ATSUBreakLine() will + * only give us word breaks. Do a simple linear search. + */ + + if ((err != kATSULineBreakInWord) + && !(flags & TK_WHOLE_WORDS) + && (offset <= (UniCharArrayOffset)urend)) { + UniCharArrayOffset lastOffset = offset; + UniCharArrayOffset nextoffset; + int lastX = -1; + int wantonemorechar = -1; /* undecided */ + + while (offset <= (UniCharArrayOffset)urend) { + if (flags & TK_ISOLATE_END) { + LayoutSetString(fontPtr, NULL, uchars, offset); + } + curX = MeasureStringWidth(fontPtr, urstart, offset); #ifdef TK_MAC_DEBUG_FONTS - fprintf(stderr, "measure: '%.*s', try until=%d, width=%d\n", - rangeLength, source+rangeStart, (int) offset, curX); + TkMacOSXDbgMsg("measure: '%.*s', try until=%ld, width=%d", + rangeLength, source+rangeStart, offset, curX); #endif - if (curX > maxLength) { - - /* - * Even if we are over the limit, we may want another - * character in some situations. Than we keep looking - * for one more character. - */ - - if (wantonemorechar == -1) { - wantonemorechar = - ((flags & TK_AT_LEAST_ONE) - && (lastOffset == (UniCharArrayOffset)urstart)) - || - ((flags & TK_PARTIAL_OK) - && (lastX != maxLength)) - ; - if (!wantonemorechar) { - break; - } - lastX = curX; - } - - /* - * There may belong combining marks to this character. - * Wait for a new curX to collect them all. - */ - - if (lastX != curX) { - break; - } - } - - /* - * Save this position, so we can come back to it. - */ - - lastX = curX; - lastOffset = offset; - - /* - * Increment offset by one character, taking combining marks - * into account. - */ - - if (offset >= (UniCharArrayOffset)urend) { - break; - } - nextoffset = 0; - if (flags & TK_ISOLATE_END) { - TkMacOSXLayoutSetString(fontPtr, &drawingContext, - uchars, ulen); - } - err = ATSUNextCursorPosition( - fontPtr->atsuLayout, - offset, - kATSUByCluster, - &nextoffset); - if (err != noErr) { -#ifdef TK_MAC_DEBUG_FONTS - fprintf(stderr, "ATSUNextCursorPosition(): " - "Error %d\n", (int) err); -#endif - break; - } - if (nextoffset <= offset) { + if (curX > maxLength) { + /* + * Even if we are over the limit, we may want another + * character in some situations. Than we keep looking + * for one more character. + */ + + if (wantonemorechar == -1) { + wantonemorechar = ((flags & TK_AT_LEAST_ONE) && + (lastOffset == (UniCharArrayOffset)urstart)) || + ((flags & TK_PARTIAL_OK) && + (lastX != maxLength)); + if (!wantonemorechar) { + break; + } + lastX = curX; + } + + /* + * There may belong combining marks to this character. + * Wait for a new curX to collect them all. + */ + + if (lastX != curX) { + break; + } + } + + /* + * Save this position, so we can come back to it. + */ + + lastX = curX; + lastOffset = offset; + + /* + * Increment offset by one character, taking combining marks + * into account. + */ + + if (offset >= (UniCharArrayOffset)urend) { + break; + } + nextoffset = 0; + if (flags & TK_ISOLATE_END) { + LayoutSetString(fontPtr, NULL, uchars, ulen); + } + err = ChkErr(ATSUNextCursorPosition, fontPtr->atsuLayout, + offset, kATSUByCluster, &nextoffset); + if (err != noErr) { + break; + } + if (nextoffset <= offset) { #ifdef TK_MAC_DEBUG_FONTS - fprintf(stderr, "ATSUNextCursorPosition(): " - "Can't move further " - "(shouldn't happen, bad data?)\n"); + TkMacOSXDbgMsg("ATSUNextCursorPosition: Can't move further" + " (shouldn't happen, bad data?)"); #endif - break; - } - - offset = nextoffset; - } - - /* - * We have overshot one character, so backup one position. - */ - - curX = lastX; - offset = lastOffset; - } - - if (curX < 0) { - if (flags & TK_ISOLATE_END) { - TkMacOSXLayoutSetString(fontPtr, &drawingContext, - uchars, offset); - } - curX = MeasureStringWidth(fontPtr, urstart, offset); - } - - curByte = Tcl_UtfAtIndex(source, offset) - source; - curByte -= rangeStart; + break; + } + + offset = nextoffset; + } + + /* + * We have overshot one character, so backup one position. + */ + + curX = lastX; + offset = lastOffset; + } + + if (curX < 0) { + if (flags & TK_ISOLATE_END) { + LayoutSetString(fontPtr, NULL, uchars, offset); + } + curX = MeasureStringWidth(fontPtr, urstart, offset); + } + + curByte = Tcl_UtfAtIndex(source, offset) - source; + curByte -= rangeStart; } Tcl_DStringFree(&ucharBuffer); -#if TK_MAC_USE_QUARZ - TkMacOSXQuarzEndDraw(&drawingContext); -#endif - #ifdef TK_MAC_DEBUG_FONTS - fflush(stdout); - fprintf(stderr, "measure: '%.*s', maxpix=%d, -> width=%d, bytes=%d, " - "flags=%s%s%s%s\n", - rangeLength, source+rangeStart, maxLength, curX, curByte, - flags & TK_PARTIAL_OK ? "partialOk " : "", - flags & TK_WHOLE_WORDS ? "wholeWords " : "", - flags & TK_AT_LEAST_ONE ? "atLeastOne " : "", - flags & TK_ISOLATE_END ? "isolateEnd " : ""); - fflush(stderr); + TkMacOSXDbgMsg("measure: '%.*s', maxpix=%d, -> width=%d, bytes=%d, " + "flags=%s%s%s%s", rangeLength, source+rangeStart, maxLength, curX, + curByte, + flags & TK_PARTIAL_OK ? "partialOk " : "", + flags & TK_WHOLE_WORDS ? "wholeWords " : "", + flags & TK_AT_LEAST_ONE ? "atLeastOne " : "", + flags & TK_ISOLATE_END ? "isolateEnd " : ""); #endif *lengthPtr = curX; @@ -999,360 +970,120 @@ TkpMeasureCharsInContext( * * Tk_DrawChars -- * - * Draw a string of characters on the screen. + * Draw a string of characters on the screen. * - * With ATSUI we need the line context to do this right, so we have the - * actual implementation in TkpDrawCharsInContext(). + * With ATSUI we need the line context to do this right, so we have the + * actual implementation in TkpDrawCharsInContext(). * * Results: - * - * None. + * None. * * Side effects: - * - * Information gets drawn on the screen. + * Information gets drawn on the screen. * *--------------------------------------------------------------------------- */ void 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 - * (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 x, int y) /* Coordinates at which to place origin of the - * string when drawing. */ + 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 x, int y) /* Coordinates at which to place origin of the + * string when drawing. */ { TkpDrawCharsInContext(display, drawable, gc, tkfont, source, numBytes, - 0, numBytes, x, y); + 0, numBytes, x, y); } - /* *--------------------------------------------------------------------------- * * TkpDrawCharsInContext -- * - * Draw a string of characters on the screen like Tk_DrawChars(), with - * access to all the characters on the line for context. + * Draw a string of characters on the screen like Tk_DrawChars(), with + * access to all the characters on the line for context. * * Results: - * None. + * None. * * Side effects: - * Information gets drawn on the screen. + * Information gets drawn on the screen. * * Todo: - * - * We could try to implement a correct stipple algorithm. - * - * The fiddling with QD GraphPorts can be replaced with just working - * with the Quarz CGContext (see TkMacOSXQuarzStartDraw()), once we - * decide to stick to Quarz and really forget about QD drawing in here. + * Stippled text drawing. * *--------------------------------------------------------------------------- */ 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. */ -{ - const MacFont * fontPtr; - MacDrawable * macWin; - RGBColor macColor, origColor; - GWorldPtr destPort; - CGrafPtr saveWorld; - GDHandle saveDevice; - BitMapPtr stippleMap; - Rect portRect; - - fontPtr = (const MacFont *) tkfont; - macWin = (MacDrawable *) drawable; - - destPort = TkMacOSXGetDrawablePort(drawable); - GetPortBounds(destPort, &portRect); - GetGWorld(&saveWorld, &saveDevice); - SetGWorld(destPort, NULL); - - TkMacOSXSetUpClippingRgn(drawable); - TkMacOSXSetUpGraphicsPort(gc, destPort); - - GetForeColor(&origColor); - - if ((gc->fill_style == FillStippled - || gc->fill_style == FillOpaqueStippled) - && gc->stipple != None) { - - Pixmap pixmap; - GWorldPtr bufferPort; - Pattern white; - - stippleMap = TkMacOSXMakeStippleMap(drawable, gc->stipple); - - pixmap = Tk_GetPixmap(display, drawable, - stippleMap->bounds.right, stippleMap->bounds.bottom, 0); - - bufferPort = TkMacOSXGetDrawablePort(pixmap); - SetGWorld(bufferPort, NULL); - - if (TkSetMacColor(gc->foreground, &macColor)) { - RGBForeColor(&macColor); - } - GetQDGlobalsWhite(&white); - ShowPen(); - FillRect(&stippleMap->bounds, &white); - MacFontDrawText(fontPtr, source, numBytes, rangeStart, rangeLength, - 0, 0); - HidePen(); - - SetGWorld(destPort, NULL); - - CopyDeepMask(GetPortBitMapForCopyBits(bufferPort), stippleMap, - GetPortBitMapForCopyBits(destPort), &stippleMap->bounds, - &stippleMap->bounds, &portRect, - srcOr, NULL); - - /* - * TODO: this doesn't work quite right - it does a blend. you can't - * draw white text when you have a stipple. - */ - - Tk_FreePixmap(display, pixmap); - ckfree(stippleMap->baseAddr); - ckfree((char *)stippleMap); - } else { - if (TkSetMacColor(gc->foreground, &macColor)) { - RGBForeColor(&macColor); - } - ShowPen(); - MacFontDrawText(fontPtr, source, numBytes, rangeStart, rangeLength, - macWin->xOff + x, macWin->yOff + y); - HidePen(); - } - - RGBForeColor(&origColor); - - SetGWorld(saveWorld, saveDevice); -} - -#if TK_MAC_USE_QUARZ -#define RGBFLOATRED(c) (float)((float)(c.red) / 65535.0f) -#define RGBFLOATGREEN(c) (float)((float)(c.green) / 65535.0f) -#define RGBFLOATBLUE(c) (float)((float)(c.blue) / 65535.0f) -/* - *------------------------------------------------------------------------- - * - * TkMacOSXQuarzStartDraw -- - * - * Setup a Quarz CGContext from the current QD GraphPort for use in - * drawing or measuring. - * - * Results: - * - * A CGContext is allocated, configured and returned in - * drawingContextPtr. Also drawingContextPtr->portRect is filled in. - * - * Side effects: - * - * None. - * - * Assumptions: - * - * The current QD GraphPort contains all the data necessary. This is - * clearly the case for the actual drawing, but not so clear for - * measuring. OTOH for measuring the specific parameters are not really - * interesting and the GraphPort is not changed either. The - * availability of a CGContext may be important for the measuring - * process though. - * - *------------------------------------------------------------------------- - */ - -void -TkMacOSXQuarzStartDraw( - DrawingContext * drawingContextPtr) /* Quarz context data filled in - * by this function. */ -{ - GDHandle currentDevice; - CGrafPtr destPort; - RGBColor macColor; - CGContextRef outContext; - OSStatus err; - Rect boundsRect; - static RgnHandle clipRgn = NULL; - - GetGWorld(&destPort, ¤tDevice); - - err = QDBeginCGContext(destPort, &outContext); - - if (err == noErr && outContext) { - /* - * Now clip the CG Context to the port. We also have to intersect our clip - * region with the port visible region so we don't overwrite the window - * decoration. - */ - - if (!clipRgn) { - clipRgn = NewRgn(); - } - - GetPortBounds(destPort, &boundsRect); - - RectRgn(clipRgn, &boundsRect); - SectRegionWithPortClipRegion(destPort, clipRgn); - SectRegionWithPortVisibleRegion(destPort, clipRgn); - ClipCGContextToRegion(outContext, &boundsRect, clipRgn); - SetEmptyRgn(clipRgn); - - /* - * Note: You have to call SyncCGContextOriginWithPort - * AFTER all the clip region manipulations. - */ - - SyncCGContextOriginWithPort(outContext, destPort); - - /* - * Scale the color values, as QD uses UInt16 with the range [0..2^16-1] - * while Quarz uses float with [0..1]. NB: Only - * CGContextSetRGBFillColor() seems to be actually used by ATSU. - */ - - GetForeColor(&macColor); - CGContextSetRGBFillColor(outContext, - RGBFLOATRED(macColor), - RGBFLOATGREEN(macColor), - RGBFLOATBLUE(macColor), - 1.0f); - #ifdef TK_MAC_DEBUG_FONTS - } else { - fprintf(stderr, "QDBeginCGContext(): Error %d\n", (int) err); - #endif - } - - drawingContextPtr->graphPort = destPort; - drawingContextPtr->cgContext = outContext; - drawingContextPtr->portRect = boundsRect; - -} - -/* - *------------------------------------------------------------------------- - * - * TkMacOSXQuarzEndDraw -- - * - * Free the Quarz CGContext in drawingContextPtr. - * - * Results: - * - * The CGContext is de-allocated. drawingContextPtr->cgContext will be - * invalid after this. - * - * Side effects: - * - * None. - * - *------------------------------------------------------------------------- - */ - -void -TkMacOSXQuarzEndDraw( - DrawingContext * drawingContextPtr) -{ - if (drawingContextPtr->cgContext) { - QDEndCGContext( - drawingContextPtr->graphPort, - &drawingContextPtr->cgContext); - } -} -#endif /* TK_MAC_USE_QUARZ */ - -/* - *------------------------------------------------------------------------- - * - * MacFontDrawText -- - * - * Helper function for Tk_DrawChars. Draws characters, using the - * screen font in fontPtr to draw multilingual characters. - * - * Results: - * None. - * - * Side effects: - * Information gets drawn on the screen. - * - *------------------------------------------------------------------------- - */ - -static void -MacFontDrawText( - const MacFont * fontPtr, /* Contains font to use when drawing - * following string. */ - const char * source, /* Potentially multilingual UTF-8 string. */ - int numBytes, /* Length of string in bytes. */ - 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 - * string when drawing. */ + 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. */ { + const MacFont * fontPtr = (const MacFont *) tkfont; + MacDrawable *macWin = (MacDrawable *) drawable; Fixed fx, fy; int ulen, urstart, urlen; const UniChar * uchars; int lineOffset; - DrawingContext drawingContext; - OSStatus err; - + TkMacOSXDrawingContext drawingContext; #if !TK_MAC_COALESCE_LINE Tcl_DString runString; #endif + TkMacOSXSetupDrawingContext(drawable, gc, 1, &drawingContext); -#if TK_MAC_USE_QUARZ - TkMacOSXQuarzStartDraw(&drawingContext); - - /* - * Turn the y coordinate upside-down for Quarz drawing. We would have - * liked to just use a CTM transform in the CGContext, but than we get - * upside-down text, so doing it that way gets more painfull than to just - * hack around the problem right here. - */ - - y = drawingContext.portRect.bottom - drawingContext.portRect.top - y; - fy = IntToFixed(y); -#else - fy = IntToFixed(y); +#if 0 + /* TODO: implement stippled text drawing */ + if ((gc->fill_style == FillStippled + || gc->fill_style == FillOpaqueStippled) + && gc->stipple != None) { + #error Stippling not implemented + } #endif + x += macWin->xOff; + y += macWin->yOff; + /* Turn the y coordinate upside-down for Quarz drawing. */ + if (drawingContext.context) { + CGContextConcatCTM(drawingContext.context, CGAffineTransformMake(1.0, + 0.0, 0.0, -1.0, 0.0, drawingContext.portBounds.bottom - + drawingContext.portBounds.top)); + y = drawingContext.portBounds.bottom - + drawingContext.portBounds.top - y; + } + fy = IntToFixed(y); #if TK_MAC_COALESCE_LINE UpdateLineBuffer( - fontPtr, &drawingContext, source, numBytes, x, y, &lineOffset); + fontPtr, &drawingContext, source, numBytes, x, y, &lineOffset); fx = IntToFixed(currentLeft); @@ -1366,67 +1097,54 @@ MacFontDrawText( uchars = Tcl_UtfToUniCharDString(source, numBytes, &runString); ulen = Tcl_DStringLength(&runString) / sizeof(uchars[0]); - TkMacOSXLayoutSetString(fontPtr, &drawingContext, uchars, ulen); + LayoutSetString(fontPtr, &drawingContext, uchars, ulen); #endif urstart = Tcl_NumUtfChars(source, rangeStart); urlen = Tcl_NumUtfChars(source+rangeStart,rangeLength); - err = ATSUDrawText( - fontPtr->atsuLayout, - lineOffset+urstart, urlen, - fx, fy); -#ifdef TK_MAC_DEBUG_FONTS - if (err != noErr) { - fprintf(stderr, "ATSUDrawText(): Error %d\n", (int) err); - } -#endif + ChkErr(ATSUDrawText, fontPtr->atsuLayout, lineOffset+urstart, urlen, fx, + fy); #if !TK_MAC_COALESCE_LINE Tcl_DStringFree(&runString); #endif -#if TK_MAC_USE_QUARZ - TkMacOSXQuarzEndDraw(&drawingContext); -#endif + TkMacOSXRestoreDrawingContext(&drawingContext); } - /* *--------------------------------------------------------------------------- * * MeasureStringWidth -- * - * Low-level measuring of strings. + * Low-level measuring of strings. * * Results: - * - * The width of the string in pixels. + * The width of the string in pixels. * * Side effects: - * - * None. + * None. * * Assumptions: - * - * fontPtr->atsuLayout is setup with the actual string data to measure. + * fontPtr->atsuLayout is setup with the actual string data to measure. * *--------------------------------------------------------------------------- */ static int MeasureStringWidth( - const MacFont * fontPtr, /* Contains font, ATSU layout and string data - * to measure. */ - int start, int end) /* Start and end positions to measure in that - * string. */ + const MacFont *fontPtr, /* Contains font, ATSU layout and string data + * to measure. */ + int start, int end) /* Start and end positions to measure in that + * string. */ { /* * This implementation of measuring via ATSUGetGlyphBounds() does not * quite conform with the specification given for [font measure]: * - * The return value is the total width in pixels of text, not - * including the extra pixels used by highly exagerrated characters - * such as cursive "f". + * The return value is the total width in pixels of text, not + * including the extra pixels used by highly exagerrated characters + * such as cursive "f". * * Instead the result of ATSUGetGlyphBounds() *does* include these * "extra pixels". @@ -1434,26 +1152,18 @@ MeasureStringWidth( ATSTrapezoid bounds; ItemCount numBounds; - OSStatus err; if (end <= start) { - return 0; + return 0; } bounds.upperRight.x = bounds.upperLeft.x = 0; - err = ATSUGetGlyphBounds( - fontPtr->atsuLayout, - 0, 0, - start, end-start, - kATSUseFractionalOrigins, - 1, &bounds, &numBounds); + ChkErr(ATSUGetGlyphBounds, fontPtr->atsuLayout, 0, 0, start, end-start, + kATSUseFractionalOrigins, 1, &bounds, &numBounds); #ifdef TK_MAC_DEBUG_FONTS - if (err != noErr) { - fprintf(stderr, "ATSUGetGlyphBounds(): Error %d\n", (int) err); - } else if (numBounds < 1) { - fprintf(stderr, "ATSUGetGlyphBounds(): No output\n"); - } else if (numBounds > 1) { - fprintf(stderr, "ATSUGetGlyphBounds(): More output\n"); + if (numBounds < 1 || numBounds > 1) { + TkMacOSXDbgMsg("ATSUGetGlyphBounds: %s output", + numBounds < 1 ? "No " : "More"); } #endif @@ -1466,58 +1176,57 @@ MeasureStringWidth( * * UpdateLineBuffer -- * - * See the general dicussion of TK_MAC_COALESCE_LINE on the header - * pages. This function maintains the data for this feature. + * See the general dicussion of TK_MAC_COALESCE_LINE on the header + * pages. This function maintains the data for this feature. * * Results: * - * The Tcl_UniChar string of the whole line as seen so far. + * The Tcl_UniChar string of the whole line as seen so far. * * Side effects: + * "*offset" is filled with the index of the first new character in + * "currentLine". The globals currentLine, currentY, currentLeft, + * currentRight and currentFontPtr are updated as necessary. * - * "*offset" is filled with the index of the first new character in - * "currentLine". The globals currentLine, currentY, currentLeft, - * currentRight and currentFontPtr are updated as necessary. - * - * The currentLine string is set as the current text in - * fontPtr->atsuLayout (see TkMacOSXLayoutSetString()). + * The currentLine string is set as the current text in + * fontPtr->atsuLayout (see LayoutSetString()). * *------------------------------------------------------------------------- */ static const Tcl_UniChar * UpdateLineBuffer( - const MacFont * fontPtr,/* The font to be used for the new piece of - * text. */ - const DrawingContext * drawingContextPtr, - /* The Quarz drawing parameters. Needed for - * measuring the new piece. */ - const char * source, /* A new piece of line to be added. */ - int numBytes, /* Length of the new piece. */ - int x, int y, /* Position of the new piece in the window. */ - int * offset) /* Filled with the offset of the new piece in - * currentLine. */ + const MacFont *fontPtr, /* The font to be used for the new piece of + * text. */ + const TkMacOSXDrawingContext *drawingContextPtr, + /* The Quarz drawing parameters. Needed for + * measuring the new piece. */ + const char *source, /* A new piece of line to be added. */ + int numBytes, /* Length of the new piece. */ + int x, int y, /* Position of the new piece in the window. */ + int *offset) /* Filled with the offset of the new piece in + * currentLine. */ { const Tcl_UniChar * uchars; int ulen; if (y != currentY - || x < currentRight-1 || x > currentRight+2 - || currentFontPtr != fontPtr) { - Tcl_DStringFree(¤tLine); - Tcl_DStringInit(¤tLine); - currentY = y; - currentLeft = x; - currentFontPtr = fontPtr; - *offset = 0; + || x < currentRight-1 || x > currentRight+2 + || currentFontPtr != fontPtr) { + Tcl_DStringFree(¤tLine); + Tcl_DStringInit(¤tLine); + currentY = y; + currentLeft = x; + currentFontPtr = fontPtr; + *offset = 0; } else { - *offset = Tcl_DStringLength(¤tLine) / 2; + *offset = Tcl_DStringLength(¤tLine) / 2; } Tcl_UtfToUniCharDString(source, numBytes, ¤tLine); uchars = (const Tcl_UniChar*) Tcl_DStringValue(¤tLine); ulen = Tcl_DStringLength(¤tLine) / sizeof(*uchars); - TkMacOSXLayoutSetString(fontPtr, drawingContextPtr, uchars, ulen); + LayoutSetString(fontPtr, drawingContextPtr, uchars, ulen); currentRight = x + MeasureStringWidth(fontPtr, *offset, ulen); return uchars; @@ -1529,33 +1238,33 @@ UpdateLineBuffer( * * InitFont -- * - * Helper for TkpGetNativeFont() and TkpGetFontFromAttributes(). - * Initializes the memory for a MacFont that wraps the - * platform-specific data. + * Helper for TkpGetNativeFont() and TkpGetFontFromAttributes(). + * Initializes the memory for a MacFont 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 MacFont structure. + * Fills the MacFont structure. * * Side effects: - * Memory allocated. + * Memory allocated. * *--------------------------------------------------------------------------- */ static void InitFont( - Tk_Window tkwin, /* For display where font will be used. */ - FMFontFamily familyId, /* The font family to initialize for. */ - const char * familyName,/* The font family name, if known. Otherwise - * this can be NULL. */ - int size, /* Point size for the font. */ - int qdStyle, /* QuickDraw style bits. */ - MacFont * fontPtr) /* Filled with information constructed from the - * above arguments. */ + Tk_Window tkwin, /* For display where font will be used. */ + FMFontFamily familyId, /* The font family to initialize for. */ + const char * familyName, /* The font family name, if known. Otherwise + * this can be NULL. */ + int size, /* Point size for the font. */ + int qdStyle, /* QuickDraw style bits. */ + MacFont * fontPtr) /* Filled with information constructed from the + * above arguments. */ { OSStatus err; FontInfo fi; @@ -1565,38 +1274,30 @@ InitFont( int periodWidth, wWidth; if (size == 0) { - size = GetDefFontSize(); + size = GetDefFontSize(); } points = (short) TkFontGetPoints(tkwin, size); - - err = FetchFontInfo(familyId, points, qdStyle, &fi); -#ifdef TK_MAC_DEBUG_FONTS - if (err != noErr) { - fprintf(stderr, "FetchFontInfo(): Error %d\n", (int) err); - } -#endif - + ChkErr(FetchFontInfo, familyId, points, qdStyle, &fi); if (familyName == NULL) { - char name[256] = ""; - const MacFontFamily * familyPtr; - - err = GetFontFamilyName(familyId, name, sizeof(name)); - if (err == noErr) { - - /* - * We find the canonical font name, so we can avoid unnecessary - * memory management. - */ - - familyPtr = FindFontFamily(name); - if (familyPtr != NULL) { - familyName = familyPtr->name; - } else { + char name[256] = ""; + const MacFontFamily * familyPtr; + + err = ChkErr(GetFontFamilyName, familyId, name, sizeof(name)); + if (err == noErr) { + /* + * We find the canonical font name, so we can avoid unnecessary + * memory management. + */ + + familyPtr = FindFontFamily(name); + if (familyPtr != NULL) { + familyName = familyPtr->name; + } else { #ifdef TK_MAC_DEBUG_FONTS - fprintf(stderr, "Font family '%s': Not found\n", name); + TkMacOSXDbgMsg("Font family '%s' not found", name); #endif - } - } + } + } } fontPtr->font.fid = (Font) fontPtr; @@ -1613,8 +1314,8 @@ InitFont( /* * Note: Macs measure the line height as ascent + descent + - * leading. Leading as a separate entity does not exist in X11 - * and Tk. We add it to the ascent at the moment, because adding + * leading. Leading as a separate entity does not exist in X11 + * and Tk. We add it to the ascent at the moment, because adding * it to the descent, as the Mac docs would indicate, would change * the position of self-drawn underlines. */ @@ -1627,9 +1328,8 @@ InitFont( fontPtr->qdSize = points; fontPtr->qdStyle = (short) qdStyle; - InitATSUObjects( - familyId, points, qdStyle, - &fontPtr->atsuFontId, &fontPtr->atsuLayout, &fontPtr->atsuStyle); + InitATSUObjects(familyId, points, qdStyle, &fontPtr->atsuFontId, + &fontPtr->atsuLayout, &fontPtr->atsuStyle); Tk_MeasureChars((Tk_Font)fontPtr, ".", 1, -1, 0, &periodWidth); Tk_MeasureChars((Tk_Font)fontPtr, "W", 1, -1, 0, &wWidth); @@ -1645,31 +1345,29 @@ InitFont( * * InitATSUObjects -- * - * Helper for InitFont(). Initializes the ATSU data handles for a - * MacFont. + * Helper for InitFont(). Initializes the ATSU data handles for a + * MacFont. * * Results: - * - * Sets up all we know and can do at this point in time in fontIdPtr, - * layoutPtr and stylePtr. + * Sets up all we know and can do at this point in time in fontIdPtr, + * layoutPtr and stylePtr. * * Side effects: - * - * Allocates data structures inside of ATSU. + * Allocates data structures inside of ATSU. * *--------------------------------------------------------------------------- */ static void InitATSUObjects( - FMFontFamily familyId, /* The font family to use. */ - short ptSize, short qdStyles, /* The additional font parameters. */ - ATSUFontID * fontIdPtr, /* Filled with the font id. */ - ATSUTextLayout * layoutPtr, /* Filled with the ATSU layout handle. */ - ATSUStyle * stylePtr) /* Filled with the ATSU style handle, - * configured with all parameters. */ + FMFontFamily familyId, /* The font family to use. */ + short ptSize, short qdStyles, + /* The additional font parameters. */ + ATSUFontID *fontIdPtr, /* Filled with the font id. */ + ATSUTextLayout *layoutPtr, /* Filled with the ATSU layout handle. */ + ATSUStyle *stylePtr) /* Filled with the ATSU style handle, + * configured with all parameters. */ { - OSStatus err; FMFontStyle stylesDone, stylesLeft; /* @@ -1684,14 +1382,8 @@ InitATSUObjects( * Generate a font id from family id and QD style bits. */ - err = FMGetFontFromFontFamilyInstance( - familyId, qdStyles, fontIdPtr, &stylesDone); -#ifdef TK_MAC_DEBUG_FONTS - if (err != noErr) { - fprintf(stderr, "FMGetFontFromFontFamilyInstance(): Error %d\n", - (int) err); - } -#endif + ChkErr(FMGetFontFromFontFamilyInstance, familyId, qdStyles, fontIdPtr, + &stylesDone); /* * We see what style bits are left and tell ATSU to synthesize what's @@ -1704,25 +1396,15 @@ InitATSUObjects( * Create the style and set its attributes. */ - err = ATSUCreateStyle(stylePtr); -#ifdef TK_MAC_DEBUG_FONTS - if (err != noErr) { - fprintf(stderr, "ATSUCreateStyle(): Error %d\n", (int) err); - } -#endif + ChkErr(ATSUCreateStyle, stylePtr); InitATSUStyle(*fontIdPtr, ptSize, stylesLeft, *stylePtr); /* - * Create the layout. Note: We can't set the layout attributes here, + * Create the layout. Note: We can't set the layout attributes here, * because the text and the style must be set first. */ - err = ATSUCreateTextLayout(layoutPtr); -#ifdef TK_MAC_DEBUG_FONTS - if (err != noErr) { - fprintf(stderr, "ATSUCreateTextLayout(): Error %d\n", (int) err); - } -#endif + ChkErr(ATSUCreateTextLayout, layoutPtr); /*InitATSULayout(*layoutPtr);*/ } @@ -1731,25 +1413,24 @@ InitATSUObjects( * * InitATSUStyle -- * - * Helper for InitATSUObjects(). Initializes the ATSU style for a - * MacFont. + * Helper for InitATSUObjects(). Initializes the ATSU style for a + * MacFont. * * Results: - * - * Sets up all parameters needed for an ATSU style. + * Sets up all parameters needed for an ATSU style. * * Side effects: - * - * Allocates data structures for the style inside of ATSU. + * Allocates data structures for the style inside of ATSU. * *--------------------------------------------------------------------------- */ static void InitATSUStyle( - ATSUFontID fontId, /* The font id to use. */ - short ptSize, short qdStyles, /* Additional font parameters. */ - ATSUStyle style) /* The style handle to configure. */ + ATSUFontID fontId, /* The font id to use. */ + short ptSize, short qdStyles, + /* Additional font parameters. */ + ATSUStyle style) /* The style handle to configure. */ { /* * Attributes for the style. @@ -1757,69 +1438,57 @@ InitATSUStyle( Fixed fsize = IntToFixed(ptSize); Boolean - isBold = (qdStyles&bold) != 0, - isUnderline = (qdStyles&underline) != 0, - isItalic = (qdStyles&italic) != 0; + isBold = (qdStyles&bold) != 0, + isUnderline = (qdStyles&underline) != 0, + isItalic = (qdStyles&italic) != 0; ATSStyleRenderingOptions options = - antialiasedTextEnabled == -1 ? kATSStyleNoOptions : - antialiasedTextEnabled == 0 ? kATSStyleNoAntiAliasing : - kATSStyleApplyAntiAliasing; + antialiasedTextEnabled == -1 ? kATSStyleNoOptions : + antialiasedTextEnabled == 0 ? kATSStyleNoAntiAliasing : + kATSStyleApplyAntiAliasing; static const ATSUAttributeTag styleTags[] = { - kATSUFontTag, kATSUSizeTag, - kATSUQDBoldfaceTag, kATSUQDItalicTag, kATSUQDUnderlineTag, - kATSUStyleRenderingOptionsTag, + kATSUFontTag, kATSUSizeTag, + kATSUQDBoldfaceTag, kATSUQDItalicTag, kATSUQDUnderlineTag, + kATSUStyleRenderingOptionsTag, }; static const ByteCount styleSizes[] = { - sizeof(ATSUFontID), sizeof(Fixed), - sizeof(Boolean), sizeof(Boolean), sizeof(Boolean), - sizeof(ATSStyleRenderingOptions), + sizeof(ATSUFontID), sizeof(Fixed), + sizeof(Boolean), sizeof(Boolean), sizeof(Boolean), + sizeof(ATSStyleRenderingOptions), }; const ATSUAttributeValuePtr styleValues[] = { - &fontId, &fsize, - &isBold, &isItalic, &isUnderline, - &options, + &fontId, &fsize, + &isBold, &isItalic, &isUnderline, + &options, }; - OSStatus err; - - err = ATSUSetAttributes( - style, - sizeof(styleTags)/sizeof(styleTags[0]), - styleTags, styleSizes, styleValues); -#ifdef TK_MAC_DEBUG_FONTS - if (err != noErr) { - fprintf(stderr, "ATSUSetAttributes(): Error %d\n", (int) err); - } -#endif + ChkErr(ATSUSetAttributes, style, sizeof(styleTags)/sizeof(styleTags[0]), + styleTags, styleSizes, styleValues); } - /* *--------------------------------------------------------------------------- * * SetFontFeatures -- * - * Helper for InitFont(). Request specific font features of the ATSU - * style object for a MacFont. + * Helper for InitFont(). Request specific font features of the ATSU + * style object for a MacFont. * * Results: - * - * None. + * None. * * Side effects: - * - * Specific font features are enabled on the ATSU style object. + * Specific font features are enabled on the ATSU style object. * *--------------------------------------------------------------------------- */ static void SetFontFeatures( - ATSUFontID fontId, /* The font id to use. */ - int fixed, /* Is this a fixed font? */ - ATSUStyle style) /* The style handle to configure. */ + ATSUFontID fontId, /* The font id to use. */ + int fixed, /* Is this a fixed font? */ + ATSUStyle style) /* The style handle to configure. */ { /* * Don't use the standard latin ligatures, if this is determined to be a @@ -1827,24 +1496,16 @@ SetFontFeatures( */ static const ATSUFontFeatureType fixed_featureTypes[] = { - kLigaturesType, kLigaturesType + kLigaturesType, kLigaturesType }; static const ATSUFontFeatureSelector fixed_featureSelectors[] = { - kCommonLigaturesOffSelector, kRareLigaturesOffSelector + kCommonLigaturesOffSelector, kRareLigaturesOffSelector }; - OSStatus err; - if (fixed) { - err = ATSUSetFontFeatures( - style, - sizeof(fixed_featureTypes)/sizeof(fixed_featureTypes[0]), - fixed_featureTypes, fixed_featureSelectors); -#ifdef TK_MAC_DEBUG_FONTS - if (err != noErr) { - fprintf(stderr, "ATSUSetFontFeatures(): Error %d\n", (int) err); - } -#endif + ChkErr(ATSUSetFontFeatures, style, sizeof(fixed_featureTypes) / + sizeof(fixed_featureTypes[0]), fixed_featureTypes, + fixed_featureSelectors); } } @@ -1853,17 +1514,15 @@ SetFontFeatures( * * AdjustFontHeight -- * - * Helper for InitFont(). Check font height against some real world - * examples. + * Helper for InitFont(). Check font height against some real world + * examples. * * Results: - * - * None. + * None. * * Side effects: - * - * The metrics in fontPtr->font.fm are adjusted so that typical combined - * characters fit into ascent+descent. + * The metrics in fontPtr->font.fm are adjusted so that typical combined + * characters fit into ascent+descent. * *--------------------------------------------------------------------------- */ @@ -1875,7 +1534,7 @@ AdjustFontHeight( /* * The standard values for ascent, descent and leading as determined in * InitFont do not take composition into account, they are designed for - * plain ASCII characters. This code measures the actual size of some + * plain ASCII characters. This code measures the actual size of some * typical composed characters from the Latin-1 range and corrects these * factors, especially the ascent. * @@ -1883,237 +1542,174 @@ AdjustFontHeight( * than requested. * * An alternative would be to instruct ATSU to shrink oversized combined - * characters. I think I have seen that feature somewhere, but I can't + * characters. I think I have seen that feature somewhere, but I can't * find it now [BR]. */ static const UniChar chars[] - /* Auml, Aacute, Acirc, Atilde, Ccedilla */ - = {0x00C4, 0x00C1, 0x00C2, 0x00C3, 0x00C7}; + /* Auml, Aacute, Acirc, Atilde, Ccedilla */ + = {0x00C4, 0x00C1, 0x00C2, 0x00C3, 0x00C7}; static const int charslen = sizeof(chars) / sizeof(chars[0]); - - DrawingContext drawingContext; Rect size; OSStatus err; - -#if TK_MAC_USE_QUARZ - TkMacOSXQuarzStartDraw(&drawingContext); -#endif - - TkMacOSXLayoutSetString(fontPtr, &drawingContext, chars, charslen); + LayoutSetString(fontPtr, NULL, chars, charslen); size.top = size.bottom = 0; - err = ATSUMeasureTextImage( - fontPtr->atsuLayout, - 0, charslen, - 0, 0, - &size); - -#if TK_MAC_USE_QUARZ - TkMacOSXQuarzEndDraw(&drawingContext); -#endif + err = ChkErr(ATSUMeasureTextImage, fontPtr->atsuLayout, 0, charslen, 0, 0, + &size); - if (err != noErr) { -#ifdef TK_MAC_DEBUG_FONTS - fprintf(stderr, "ATSUMeasureTextImage(): Error %d\n", (int) err); -#endif - } else { - TkFontMetrics * fmPtr = &fontPtr->font.fm; - int ascent = -size.top; - int descent = size.bottom; - - if (ascent > fmPtr->ascent) { - fmPtr->ascent = ascent; - } - if (descent > fmPtr->descent) { - fmPtr->descent = descent; - } + if (err == noErr) { + TkFontMetrics * fmPtr = &fontPtr->font.fm; + int ascent = -size.top; + int descent = size.bottom; + + if (ascent > fmPtr->ascent) { + fmPtr->ascent = ascent; + } + if (descent > fmPtr->descent) { + fmPtr->descent = descent; + } } } - /* *--------------------------------------------------------------------------- * * InitATSULayout -- * - * Helper for TkMacOSXLayoutSetString(). Initializes the ATSU layout - * object for a MacFont and a specific string. + * Helper for LayoutSetString(). Initializes the ATSU layout + * object for a MacFont and a specific string. * * Results: - * - * Sets up all parameters needed for an ATSU layout object. + * Sets up all parameters needed for an ATSU layout object. * * Side effects: - * - * Allocates data structures for the layout object inside of ATSU. + * Allocates data structures for the layout object inside of ATSU. * * Assumptions: - * - * The actual string data and style information is already set by - * ATSUSetTextPointerLocation() and ATSUSetRunStyle() (see - * TkMacOSXLayoutSetString()). + * The actual string data and style information is already set by + * ATSUSetTextPointerLocation() and ATSUSetRunStyle() (see + * LayoutSetString()). * *--------------------------------------------------------------------------- */ static void InitATSULayout( - const DrawingContext * drawingContextPtr, - /* Specifies the CGContext to use. */ - ATSUTextLayout layout, /* The layout object to configure. */ - int fixed) /* Is this a fixed font? */ + const TkMacOSXDrawingContext *drawingContextPtr, + /* Specifies the CGContext to use. */ + ATSUTextLayout layout, /* The layout object to configure. */ + int fixed) /* Is this a fixed font? */ { /* * Attributes for the layout. */ - ATSLineLayoutOptions layoutOptions = - 0 + ATSLineLayoutOptions layoutOptions = 0 #if TK_MAC_COALESCE_LINE - /* - * Options to use unconditionally, when we try to do coalescing in here. - */ - | kATSLineDisableAllLayoutOperations - | kATSLineFractDisable - | kATSLineUseDeviceMetrics + /* + * Options to use unconditionally when we try to do coalescing. + */ + | kATSLineDisableAllLayoutOperations + | kATSLineFractDisable + | kATSLineUseDeviceMetrics #endif - ; + ; + CGContextRef context = drawingContextPtr ? + drawingContextPtr->context : NULL; static const ATSUAttributeTag layoutTags[] = { -#if TK_MAC_USE_QUARZ - kATSUCGContextTag, -#endif - kATSULineLayoutOptionsTag, + kATSUCGContextTag, + kATSULineLayoutOptionsTag, }; static const ByteCount layoutSizes[] = { -#if TK_MAC_USE_QUARZ - sizeof(CGContextRef), -#endif - sizeof(ATSLineLayoutOptions), + sizeof(CGContextRef), + sizeof(ATSLineLayoutOptions), }; const ATSUAttributeValuePtr layoutValues[] = { -#if TK_MAC_USE_QUARZ - (void*)&drawingContextPtr->cgContext, -#endif - &layoutOptions, + &context, + &layoutOptions, }; - OSStatus err; - /* * Ensure W(abcdefg) == W(a)*7 for fixed fonts (Latin scripts only). */ if (fixed) { - layoutOptions |= - kATSLineFractDisable - | kATSLineUseDeviceMetrics - ; - } - - err = ATSUSetLayoutControls( - layout, - sizeof(layoutTags)/sizeof(layoutTags[0]), - layoutTags, layoutSizes, layoutValues); -#ifdef TK_MAC_DEBUG_FONTS - if (err != noErr) { - fprintf(stderr, "ATSUSetLayoutControls(): Error %d\n", (int) err); + layoutOptions |= kATSLineFractDisable | kATSLineUseDeviceMetrics; } -#endif - err = ATSUSetTransientFontMatching(layout, true); -#ifdef TK_MAC_DEBUG_FONTS - if (err != noErr) { - fprintf(stderr, "ATSUSetTransientFontMatching(): Error %d\n", - (int) err); - } -#endif + ChkErr(ATSUSetLayoutControls, layout, sizeof(layoutTags) / + sizeof(layoutTags[0]), layoutTags, layoutSizes, layoutValues); + ChkErr(ATSUSetTransientFontMatching, layout, true); } /* *--------------------------------------------------------------------------- * - * TkMacOSXLayoutSetString -- + * LayoutSetString -- * - * Setup the MacFont for a specific string. + * Setup the MacFont for a specific string. * * Results: - * - * Sets up all parameters so that ATSU can work with the objects in - * MacFont. + * Sets up all parameters so that ATSU can work with the objects in + * MacFont. * * Side effects: - * - * Sets parameters on the layout object fontPtr->atsuLayout. + * Sets parameters on the layout object fontPtr->atsuLayout. * *--------------------------------------------------------------------------- */ void -TkMacOSXLayoutSetString( - const MacFont * fontPtr, /* The fontPtr to configure. */ - const DrawingContext * drawingContextPtr, - /* For the CGContext to be used.*/ - const UniChar * uchars, int ulen) /* The UniChar string to set into - * fontPtr->atsuLayout. */ +LayoutSetString( + const MacFont *fontPtr, /* The fontPtr to configure. */ + const TkMacOSXDrawingContext *drawingContextPtr, + /* For the CGContext to be used.*/ + const UniChar *uchars, int ulen) + /* The UniChar string to set into + * fontPtr->atsuLayout. */ { - OSStatus err; - err = ATSUSetTextPointerLocation( - fontPtr->atsuLayout, - uchars, kATSUFromTextBeginning, ulen, - ulen); -#ifdef TK_MAC_DEBUG_FONTS - if (err != noErr) { - fprintf(stderr, "ATSUSetTextPointerLocation(): Error %d\n", (int) err); - } -#endif + ChkErr(ATSUSetTextPointerLocation, fontPtr->atsuLayout, uchars, + kATSUFromTextBeginning, ulen, ulen); /* * Styles can only be set after the text is set. */ - err = ATSUSetRunStyle( - fontPtr->atsuLayout, fontPtr->atsuStyle, - kATSUFromTextBeginning, kATSUToTextEnd); -#ifdef TK_MAC_DEBUG_FONTS - if (err != noErr) { - fprintf(stderr, "ATSUSetRunStyle(): Error %d\n", (int) err); - } -#endif + ChkErr(ATSUSetRunStyle, fontPtr->atsuLayout, fontPtr->atsuStyle, + kATSUFromTextBeginning, kATSUToTextEnd); /* * Layout attributes can only be set after the styles are set. */ - InitATSULayout( - drawingContextPtr, fontPtr->atsuLayout, - fontPtr->font.fm.fixed); + InitATSULayout(drawingContextPtr, fontPtr->atsuLayout, + fontPtr->font.fm.fixed); } - /* *------------------------------------------------------------------------- * * ReleaseFont -- * - * Called to release the Macintosh-specific contents of a TkFont. The - * caller is responsible for freeing the memory used by the font - * itself. + * Called to release the Macintosh-specific contents of a TkFont. The + * caller is responsible for freeing the memory used by the font + * itself. * * Results: - * None. + * None. * * Side effects: - * Memory is freed. + * Memory is freed. * *--------------------------------------------------------------------------- */ static void ReleaseFont( - MacFont * fontPtr) /* The font to delete. */ + MacFont *fontPtr) /* The font to delete. */ { ATSUDisposeTextLayout(fontPtr->atsuLayout); ATSUDisposeStyle(fontPtr->atsuStyle); @@ -2124,40 +1720,40 @@ ReleaseFont( * * FindFontFamilyOrAlias, FindFontFamilyOrAliasOrFallback -- * - * Determine if any physical screen font exists on the system with The - * given family name. If the family exists, then it should be possible - * to construct some physical screen font with that family name. + * Determine if any physical screen font exists on the system with the + * given family name. If the family exists, then it should be possible + * to construct some physical screen font with that family name. * - * FindFontFamilyOrAlias also considers font aliases as determined by - * TkFontGetAliasList(). + * FindFontFamilyOrAlias also considers font aliases as determined by + * TkFontGetAliasList(). * - * FindFontFamilyOrAliasOrFallback also considers font aliases as - * determined by TkFontGetFallbacks(). + * FindFontFamilyOrAliasOrFallback also considers font aliases as + * determined by TkFontGetFallbacks(). * - * The overall algorithm to get the closest font to the one requested is - * this: + * The overall algorithm to get the closest font to the one requested is + * this: * - * try fontname - * try all aliases for fontname - * foreach fallback for fontname - * try the fallback - * try all aliases for the fallback + * try fontname + * try all aliases for fontname + * foreach fallback for fontname + * try the fallback + * try all aliases for the fallback * * Results: * - * The return value is NULL if the specified font family does not exist, - * a valid MacFontFamily* otherwise. + * The return value is NULL if the specified font family does not exist, + * a valid MacFontFamily* otherwise. * * Side effects: * - * None. + * None. * *------------------------------------------------------------------------- */ static const MacFontFamily * FindFontFamilyOrAlias( - const char * name) /* Name or alias name of the font to find. */ + const char *name) /* Name or alias name of the font to find. */ { const MacFontFamily * familyPtr; char ** aliases; @@ -2165,24 +1761,24 @@ FindFontFamilyOrAlias( familyPtr = FindFontFamily(name); if (familyPtr != NULL) { - return familyPtr; + return familyPtr; } aliases = TkFontGetAliasList(name); if (aliases != NULL) { - for (i = 0; aliases[i] != NULL; i++) { - familyPtr = FindFontFamily(aliases[i]); - if (familyPtr != NULL) { - return familyPtr; - } - } + for (i = 0; aliases[i] != NULL; i++) { + familyPtr = FindFontFamily(aliases[i]); + if (familyPtr != NULL) { + return familyPtr; + } + } } return NULL; } - + static const MacFontFamily * FindFontFamilyOrAliasOrFallback( - const char * name) /* Name or alias name of the font to find. */ + const char *name) /* Name or alias name of the font to find. */ { const MacFontFamily * familyPtr; const char * fallback; @@ -2191,36 +1787,36 @@ FindFontFamilyOrAliasOrFallback( familyPtr = FindFontFamilyOrAlias(name); if (familyPtr != NULL) { - return familyPtr; + return familyPtr; } fallbacks = TkFontGetFallbacks(); for (i = 0; fallbacks[i] != NULL; i++) { - for (j = 0; (fallback = fallbacks[i][j]) != NULL; j++) { - if (strcasecmp(name, fallback) == 0) { - for (j = 0; (fallback = fallbacks[i][j]) != NULL; j++) { - familyPtr = FindFontFamilyOrAlias(fallback); - if (familyPtr != NULL) { - return familyPtr; - } - } - } - break; /* benny: This "break" is a carry-over from - * tkMacOSXFont.c, but what is actually its purpose - * ???? */ - } + for (j = 0; (fallback = fallbacks[i][j]) != NULL; j++) { + if (strcasecmp(name, fallback) == 0) { + for (j = 0; (fallback = fallbacks[i][j]) != NULL; j++) { + familyPtr = FindFontFamilyOrAlias(fallback); + if (familyPtr != NULL) { + return familyPtr; + } + } + } + break; /* benny: This "break" is a carry-over from + * tkMacOSXFont.c, but what is actually its purpose + * ???? */ + } } /* - * FIXME: We would have liked to recover by re-enumerating fonts. But + * FIXME: We would have liked to recover by re-enumerating fonts. But * that doesn't work, because Carbon seems to cache the inital list of - * fonts. Fonts newly installed don't show up with + * fonts. Fonts newly installed don't show up with * FMCreateFontFamilyIterator()/FMGetNextFontFamily() without a restart - * of the app. Similar problem with fonts removed. + * of the app. Similar problem with fonts removed. */ #ifdef TK_MAC_DEBUG_FONTS - fprintf(stderr, "Font family '%s': Not found\n", name); + TkMacOSXDbgMsg("Font family '%s' not found", name); #endif return NULL; @@ -2231,16 +1827,16 @@ FindFontFamilyOrAliasOrFallback( * * InitFontFamilies -- * - * Helper to TkpFontPkgInit. Use the Font Manager to fill in the - * familyList global array. + * Helper to TkpFontPkgInit. Use the Font Manager to fill in the + * familyList global array. * * Results: * - * None. + * None. * * Side effects: * - * Allocates memory. + * Allocates memory. * *------------------------------------------------------------------------- */ @@ -2248,32 +1844,58 @@ FindFontFamilyOrAliasOrFallback( static void InitFontFamilies(void) { - OSStatus err; + FMFontFamily fontFamily; + Str255 fontName; + SInt16 fontSize; + Style fontStyle; /* * Has this been called before? */ if (familyListNextFree > 0) { - return; + return; } - err = ATSFontFamilyApplyFunction(FontFamilyEnumCallback,NULL); -#ifdef TK_MAC_DEBUG_FONTS - if (err != noErr) { - fprintf(stderr, "ATSFontFamilyApplyFunction(): Error %d\n", (int) err); - } -#endif + ChkErr(ATSFontFamilyApplyFunction, FontFamilyEnumCallback,NULL); - AddFontFamily(APPLFONT_NAME, GetAppFont()); - AddFontFamily(SYSTEMFONT_NAME, GetSysFont()); + if (GetThemeFontAndFamily(kThemeSystemFont, &fontFamily, fontName, + &fontSize, &fontStyle) == noErr) { + AddFontFamily(SYSTEMFONT_NAME, fontFamily); + } + if (GetThemeFontAndFamily(kThemeApplicationFont, &fontFamily, fontName, + &fontSize, &fontStyle) == noErr) { + AddFontFamily(APPLFONT_NAME, fontFamily); + } + if (GetThemeFontAndFamily(kThemeMenuItemFont, &fontFamily, fontName, + &fontSize, &fontStyle) == noErr) { + AddFontFamily(MENUITEMFONT_NAME, fontFamily); + } SortFontFamilies(); } + +/* + *------------------------------------------------------------------------- + * + * FontFamilyEnumCallback -- + * + * Callback for ATSFontFamilyApplyFunction(). + * + * Results: + * + * noErr. + * + * Side effects: + * + * None. + * + *------------------------------------------------------------------------- + */ static OSStatus FontFamilyEnumCallback( - ATSFontFamilyRef family, + ATSFontFamilyRef family, void *refCon) { OSStatus err; @@ -2281,42 +1903,41 @@ FontFamilyEnumCallback( (void) refCon; - err = GetFontFamilyName(family, name, sizeof(name)); + err = ChkErr(GetFontFamilyName, family, name, sizeof(name)); if (err == noErr) { - AddFontFamily(name, family); + AddFontFamily(name, family); } return noErr; } - /* *------------------------------------------------------------------------- * * GetFontFamilyName -- * - * Use the Font Manager to get the name of a given FMFontfamily. This - * currently gets the standard, non-localized QuickDraw name. Other - * names would be possible, see docs for ATSUFindFontName for a - * selection. The MacOSX font selector seems to use the localized - * family name given by ATSUFindFontName(kFontFamilyName), but that API - * doesn't give us a name at all for some fonts. + * Use the Font Manager to get the name of a given FMFontfamily. This + * currently gets the standard, non-localized QuickDraw name. Other + * names would be possible, see docs for ATSUFindFontName for a + * selection. The MacOSX font selector seems to use the localized + * family name given by ATSUFindFontName(kFontFamilyName), but that API + * doesn't give us a name at all for some fonts. * * Results: - * An OS error code, noErr on success. name is filled with the - * resulting name. + * An OS error code, noErr on success. name is filled with the + * resulting name. * * Side effects: - * None. + * None. * *------------------------------------------------------------------------- */ static OSStatus GetFontFamilyName( - FMFontFamily fontFamily, /* The font family for which to find the - * name. */ - char * name, int numBytes) /* Filled with the result. */ + FMFontFamily fontFamily, /* The font family for which to find the + * name. */ + char * name, int numBytes) /* Filled with the result. */ { OSStatus err; Str255 nativeName; @@ -2326,13 +1947,9 @@ GetFontFamilyName( nativeName[0] = 0; name[0] = 0; - - err = FMGetFontFamilyName(fontFamily, nativeName); + err = ChkErr(FMGetFontFamilyName, fontFamily, nativeName); if (err != noErr) { -#ifdef TK_MAC_DEBUG_FONTS - fprintf(stderr, "FMGetFontFamilyName(): Error %d\n", (int) err); -#endif - return err; + return err; } /* @@ -2341,36 +1958,25 @@ GetFontFamilyName( */ encoding = kTextEncodingMacRoman; - err = FMGetFontFamilyTextEncoding(fontFamily, &encoding); -#ifdef TK_MAC_DEBUG_FONTS - if (err != noErr) { - fprintf(stderr, "FMGetFontFamilyTextEncoding(): Error %d\n", (int) err); - } -#endif - + ChkErr(FMGetFontFamilyTextEncoding, fontFamily, &encoding); nameencoding = encoding; - err = RevertTextEncodingToScriptInfo(encoding, &nameencoding, NULL, NULL); -#ifdef TK_MAC_DEBUG_FONTS - if (err != noErr) { - fprintf(stderr, "RevertTextEncodingToScriptInfo(): Error %d\n", - (int) err); - } -#endif + ChkErr(RevertTextEncodingToScriptInfo, encoding, &nameencoding, NULL, + NULL); /* - * Note: We could use Tcl facilities to do the re-encoding here. We'd + * Note: We could use Tcl facilities to do the re-encoding here. We'd * have to maintain tables to map OS encoding codes to Tcl encoding names - * like tkMacOSXFont.c did. Using native re-encoding directly instead is - * a lot easier and future-proof than that. There is one snag, though: I - * have seen CFStringGetCString() crash with invalid encoding ids. But + * like tkMacOSXFont.c did. Using native re-encoding directly instead is + * a lot easier and future-proof than that. There is one snag, though: I + * have seen CFStringGetCString() crash with invalid encoding ids. But * than if that happens it would be a bug in * FMGetFontFamilyTextEncoding() or RevertTextEncodingToScriptInfo(). */ cfString = CFStringCreateWithPascalStringNoCopy( - NULL, nativeName, nameencoding, kCFAllocatorNull); + NULL, nativeName, nameencoding, kCFAllocatorNull); CFStringGetCString( - cfString, name, numBytes, kCFStringEncodingUTF8); + cfString, name, numBytes, kCFStringEncodingUTF8); CFRelease(cfString); return noErr; @@ -2381,41 +1987,39 @@ GetFontFamilyName( * * FindFontFamily -- * - * Find the font family with the given name in the global familyList. - * Uses bsearch() for convenient access. Comparision is done - * non-case-sensitively with CompareFontFamilies() which see. + * Find the font family with the given name in the global familyList. + * Uses bsearch() for convenient access. Comparision is done + * non-case-sensitively with CompareFontFamilies() which see. * * Results: * - * MacFontFamily: A pair of family id and the actual name registered for - * the font. + * MacFontFamily: A pair of family id and the actual name registered for + * the font. * * Side effects: * - * None. + * None. * * Assumption: * - * Requires the familyList array to be sorted. + * Requires the familyList array to be sorted. * *------------------------------------------------------------------------- */ static const MacFontFamily * FindFontFamily( - const char * name) /* The family name. Note: Names are compared - * non-case-sensitive. */ + const char *name) /* The family name. Note: Names are compared + * non-case-sensitive. */ { const MacFontFamily key = {name,-1}; if(familyListMaxValid <= 0) { - return NULL; + return NULL; } - return bsearch( - &key, - familyList, familyListMaxValid, sizeof(*familyList), - CompareFontFamilies); + return bsearch(&key, familyList, familyListMaxValid, sizeof(*familyList), + CompareFontFamilies); } /* @@ -2423,15 +2027,13 @@ FindFontFamily( * * EnumFontFamilies -- * - * Create a Tcl list with the registered names in the global familyList. + * Create a Tcl list with the registered names in the global familyList. * * Results: - * - * A Tcl list of names. + * A Tcl list of names. * * Side effects: - * - * None. + * None. * *------------------------------------------------------------------------- */ @@ -2444,8 +2046,8 @@ EnumFontFamilies(void) tclList = Tcl_NewListObj(0, NULL); for (i=0; i<familyListMaxValid; ++i) { - Tcl_ListObjAppendElement( - NULL, tclList, Tcl_NewStringObj(familyList[i].name, -1)); + Tcl_ListObjAppendElement(NULL, tclList, + Tcl_NewStringObj(familyList[i].name, -1)); } return tclList; @@ -2456,33 +2058,32 @@ EnumFontFamilies(void) * * AddFontFamily -- * - * Register a font family in familyList. Until SortFontFamilies() is - * called, this is not actually available for FindFontFamily(). + * Register a font family in familyList. Until SortFontFamilies() is + * called, this is not actually available for FindFontFamily(). * * Results: * - * MacFontFamily: The new pair of family id and the actual name - * registered for the font. + * MacFontFamily: The new pair of family id and the actual name + * registered for the font. * * Side effects: * - * New entry in familyList and familyListNextFree updated. + * New entry in familyList and familyListNextFree updated. * *------------------------------------------------------------------------- */ static const MacFontFamily * AddFontFamily( - const char * name, /* Font family name to register. */ - FMFontFamily familyId) /* Font family id to register. */ + const char *name, /* Font family name to register. */ + FMFontFamily familyId) /* Font family id to register. */ { MacFontFamily * familyPtr; if (familyListNextFree >= familyListSize) { - familyListSize += 100; - familyList = (MacFontFamily *) ckrealloc( - (void*) familyList, - familyListSize * sizeof(*familyList)); + familyListSize += 100; + familyList = (MacFontFamily *) ckrealloc((void*) familyList, + familyListSize * sizeof(*familyList)); } familyPtr = familyList + familyListNextFree; @@ -2499,18 +2100,18 @@ AddFontFamily( * * SortFontFamilies -- * - * Sort the entries in familyList. Only after calling - * SortFontFamilies(), the new families registered with AddFontFamily() - * are actually available for FindFontFamily(), because FindFontFamily() - * requires the array to be sorted. + * Sort the entries in familyList. Only after calling + * SortFontFamilies(), the new families registered with AddFontFamily() + * are actually available for FindFontFamily(), because FindFontFamily() + * requires the array to be sorted. * * Results: * - * None. + * None. * * Side effects: * - * familyList is sorted and familyListMaxValid is updated. + * familyList is sorted and familyListMaxValid is updated. * *------------------------------------------------------------------------- */ @@ -2519,8 +2120,8 @@ static void SortFontFamilies(void) { if (familyListNextFree > 0) { - qsort( familyList, familyListNextFree, sizeof(*familyList), - CompareFontFamilies); + qsort(familyList, familyListNextFree, sizeof(*familyList), + CompareFontFamilies); } familyListMaxValid = familyListNextFree; } @@ -2530,21 +2131,19 @@ SortFontFamilies(void) * * CompareFontFamilies -- * - * Comparison function used by SortFontFamilies() and FindFontFamily(). + * Comparison function used by SortFontFamilies() and FindFontFamily(). * * Results: + * Result as required to generate a stable sort order for bsearch() and + * qsort(). The ordering is not case-sensitive as far as + * Tcl_UtfNcasecmp() (which see) can provide that. * - * Result as required to generate a stable sort order for bsearch() and - * qsort(). The ordering is not case-sensitive as far as - * Tcl_UtfNcasecmp() (which see) can provide that. - * - * Note: It would be faster to compare first the length and the actual - * strings only as a tie-breaker, but than the ordering wouldn't look so - * pretty in [font families] ;-). + * Note: It would be faster to compare first the length and the actual + * strings only as a tie-breaker, but than the ordering wouldn't look so + * pretty in [font families] ;-). * * Side effects: - * - * None. + * None. * *------------------------------------------------------------------------- */ @@ -2556,9 +2155,7 @@ CompareFontFamilies( { const char * name1; const char * name2; - int len1; - int len2; - int diff; + int len1, len2, diff; name1 = ((const MacFontFamily *) vp1)->name; name2 = ((const MacFontFamily *) vp2)->name; @@ -2576,36 +2173,34 @@ CompareFontFamilies( * * AddString -- * - * Helper for AddFontFamily(). Allocates a string in the one-shot - * allocator. + * Helper for AddFontFamily(). Allocates a string in the one-shot + * allocator. * * Results: - * - * A duplicated string in the one-shot allocator. + * A duplicated string in the one-shot allocator. * * Side effects: - * - * May allocate a new memory block. + * May allocate a new memory block. * *------------------------------------------------------------------------- */ static const char * AddString( - const char * in) /* String to add, zero-terminated. */ + const char *in) /* String to add, zero-terminated. */ { int len; - char * result; - + char *result; + len = strlen(in) +1; if (stringMemory == NULL - || (stringMemory->nextFree+len) > STRING_BLOCK_MAX ) { - StringBlock * newblock = - (StringBlock *) ckalloc(sizeof(StringBlock)); - newblock->next = stringMemory; - newblock->nextFree = 0; - stringMemory = newblock; + || (stringMemory->nextFree+len) > STRING_BLOCK_MAX) { + StringBlock * newblock = (StringBlock *) ckalloc(sizeof(StringBlock)); + + newblock->next = stringMemory; + newblock->nextFree = 0; + stringMemory = newblock; } result = stringMemory->strings + stringMemory->nextFree; @@ -2621,27 +2216,27 @@ AddString( * * TkMacOSXIsCharacterMissing -- * - * Given a tkFont and a character determine whether the character has - * a glyph defined in the font or not. + * Given a tkFont and a character determine whether the character has + * a glyph defined in the font or not. * * Results: - * Returns a 1 if the character is missing, a 0 if it is not. + * Returns a 1 if the character is missing, a 0 if it is not. * * Side effects: - * None. + * None. * *--------------------------------------------------------------------------- */ int TkMacOSXIsCharacterMissing( - Tk_Font tkfont, /* The font we are looking in. */ - unsigned int searchChar) /* The character we are looking for. */ + Tk_Font tkfont, /* The font we are looking in. */ + unsigned int searchChar) /* The character we are looking for. */ { /* Background: This function is private and only used in * tkMacOSXMenu.c:FindMarkCharacter(). * - * We could use ATSUMatchFont() to implement. We'd have to change the + * We could use ATSUMatchFont() to implement. We'd have to change the * definition of the encoding of the parameter searchChar from MacRoman * to UniChar for that. * @@ -2656,30 +2251,27 @@ TkMacOSXIsCharacterMissing( * * TkMacOSXInitControlFontStyle -- * - * This procedure sets up the appropriate ControlFontStyleRec - * for a Mac control. + * This procedure sets up the appropriate ControlFontStyleRec + * for a Mac control. * * Results: - * None. + * None. * * Side effects: - * None. + * None. * *---------------------------------------------------------------------- */ void TkMacOSXInitControlFontStyle( - Tk_Font tkfont, /* Tk font object to use for the control. */ - ControlFontStylePtr fsPtr) /* The style object to configure. */ + Tk_Font tkfont, /* Tk font object to use for the control. */ + ControlFontStylePtr fsPtr) /* The style object to configure. */ { - const MacFont * fontPtr; - fontPtr = (MacFont *) tkfont; - fsPtr->flags = - kControlUseFontMask| - kControlUseSizeMask| - kControlUseFaceMask| - kControlUseJustMask; + const MacFont * fontPtr = (MacFont *) tkfont; + + fsPtr->flags = kControlUseFontMask | kControlUseSizeMask | + kControlUseFaceMask | kControlUseJustMask; fsPtr->font = fontPtr->qdFont; fsPtr->size = fontPtr->qdSize; fsPtr->style = fontPtr->qdStyle; @@ -2691,46 +2283,46 @@ TkMacOSXInitControlFontStyle( * * TkMacOSXUseAntialiasedText -- * - * Enables or disables application-wide use of antialiased text (where - * available). Sets up a linked Tcl global variable to allow - * disabling of antialiased text from tcl. - * The possible values for this variable are: + * Enables or disables application-wide use of antialiased text (where + * available). Sets up a linked Tcl global variable to allow + * disabling of antialiased text from tcl. + * The possible values for this variable are: * - * -1 - Use system default as configurable in "System Preferences" -> - * "General". - * 0 - Unconditionally disable antialiasing. - * 1 - Unconditionally enable antialiasing. + * -1 - Use system default as configurable in "System Preferences" -> + * "General". + * 0 - Unconditionally disable antialiasing. + * 1 - Unconditionally enable antialiasing. * * Results: * - * TCL_OK. + * TCL_OK. * * Side effects: * - * None. + * None. * *---------------------------------------------------------------------- */ MODULE_SCOPE int TkMacOSXUseAntialiasedText( - Tcl_Interp * interp, /* The Tcl interpreter to receive the - * variable .*/ - int enable) /* Initial value. */ + Tcl_Interp * interp, /* The Tcl interpreter to receive the + * variable.*/ + int enable) /* Initial value. */ { static Boolean initialized = FALSE; - if(!initialized) { - initialized = TRUE; - - if (Tcl_CreateNamespace(interp, "::tk::mac", NULL, NULL) == NULL) { - Tcl_ResetResult(interp); - } - if (Tcl_LinkVar(interp, "::tk::mac::antialiasedtext", - (char *) &antialiasedTextEnabled, - TCL_LINK_INT) != TCL_OK) { - Tcl_ResetResult(interp); - } + if (!initialized) { + initialized = TRUE; + + if (Tcl_CreateNamespace(interp, "::tk::mac", NULL, NULL) == NULL) { + Tcl_ResetResult(interp); + } + if (Tcl_LinkVar(interp, "::tk::mac::antialiasedtext", + (char *) &antialiasedTextEnabled, + TCL_LINK_INT) != TCL_OK) { + Tcl_ResetResult(interp); + } } antialiasedTextEnabled = enable; return TCL_OK; |