Reduce the #ifdef count a lot by adding debug-print macros

1 files changed, 1081 insertions, 1283 deletions

diff --git a/macosx/tkMacOSXFont.c b/macosx/tkMacOSXFont.c
index 87d4c9c..00e88ac 100644
--- a/macosx/tkMacOSXFont.c
+++ b/macosx/tkMacOSXFont.c
@@ -1,8 +1,8 @@
 /*
  * 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
  *
@@ -16,7 +16,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,16 +25,16 @@
  *   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,
- *   Hebrew, Arabic and Hindi fonts that actually come with the system.
+ *   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
- *   that such fonts can not be used for controls, because controls
- *   definitely require a family id (this assertion needs testing).
+ *   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 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.21 2006/12/30 23:15:22 cc_benny Exp $
+ * RCS: @(#) $Id: tkMacOSXFont.c,v 1.22 2007/04/13 14:51:18 dkf Exp $
  */
 
 #include "tkMacOSXInt.h"
@@ -46,40 +45,47 @@
 #define TK_MAC_DEBUG_FONTS
 #endif
 */
+#ifdef TK_MAC_DEBUG_FONTS
+#define FDBG DBG_MSG
+#else
+#define LOG_ON_ERR(...) /* nothing */
+#define FDBG(...) /* nothing */
+#endif
 
 /* Define macros only available on Mac OS X 10.3 or later */
 #ifndef FixedToInt
-#define FixedToInt(a)       ((short)(((Fixed)(a) + fixed1/2) >> 16))
+#define FixedToInt(a)	((short)(((Fixed)(a) + fixed1/2) >> 16))
 #endif
 #ifndef IntToFixed
-#define IntToFixed(a)       ((Fixed)(a) << 16)
+#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
- * 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
- * undercutting the system and behind the scenes pasting strings together that
- * look like they are on the same line and adjacent and that are drawn with
- * the same font. To do this we need some global data.
+ * 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 undercutting the system
+ * and behind the scenes pasting strings together that look like they are on
+ * the same line and adjacent and that are drawn with the same font. To do
+ * this we need some global data.
  */
+
 #define TK_MAC_COALESCE_LINE 0
 
 typedef TkMacOSXFont MacFont;
 typedef TkMacOSXFontDrawingContext DrawingContext;
 
 /*
- * 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
- * with ckrealloc().
+ * 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 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
- * non-case-sensitive version of that available.
+ * arrays. Unfortunately there seems to be no pre-packaged non-case-sensitive
+ * version of that available.
  */
 
 typedef struct {
@@ -89,43 +95,42 @@ 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;
@@ -135,7 +140,7 @@ static int antialiasedTextEnabled;
  */
 
 #define SYSTEMFONT_NAME "system"
-#define APPLFONT_NAME   "application"
+#define APPLFONT_NAME	"application"
 
 /*
  * Procedures used only in this file.
@@ -145,104 +150,88 @@ static int antialiasedTextEnabled;
  * 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 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);
 #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 DrawingContext *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 DrawingContext*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 void		InitFontFamilies(void);
+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 * 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 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);
 
 /*
  *-------------------------------------------------------------------------
  *
  * 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();
 
@@ -250,10 +239,7 @@ TkpFontPkgInit(
     Tcl_DStringInit(&currentLine);
 #endif
 
-#ifdef TK_MAC_DEBUG_FONTS
-    fprintf(stderr, "tkMacOSXFont.c (ATSU version) intialized "
-            "(" __TIME__ ")\n");
-#endif
+    FDBG("tkMacOSXFont.c (ATSU version) intialized (" __TIME__ ")");
 }
 
 /*
@@ -261,41 +247,41 @@ 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;
     MacFont * fontPtr;
 
     if (strcmp(name, SYSTEMFONT_NAME) == 0) {
-        familyId = GetSysFont();
+	familyId = GetSysFont();
     } else if (strcmp(name, APPLFONT_NAME) == 0) {
-        familyId = GetAppFont();
+	familyId = GetAppFont();
     } else {
-        return NULL;
+	return NULL;
     }
 
     fontPtr = (MacFont *) ckalloc(sizeof(MacFont));
@@ -309,74 +295,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 +374,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,23 +400,23 @@ 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());
 }
@@ -440,28 +426,30 @@ 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
-     * the information is only used for testing, such an effort seems not
-     * very useful. */
+    /*
+     * 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 the
+     * information is only used for testing, such an effort seems not very
+     * useful.
+     */
 }
 
 /*
@@ -469,24 +457,24 @@ 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;
     UniChar uchar = c;
@@ -497,8 +485,8 @@ TkpGetFontAttrsForChar(
     UniCharCount changedLength;
 
     /*
-     * Most of the attributes are just copied from the base font.  This
-     * assumes that all fonts can have all attributes.
+     * Most of the attributes are just copied from the base font. This assumes
+     * that all fonts can have all attributes.
      */
 
     *faPtr = fontPtr->font.fa;
@@ -515,57 +503,46 @@ TkpGetFontAttrsForChar(
     TkMacOSXLayoutSetString(fontPtr, &drawingContext, &uchar, 1);
 
     fontId = fontPtr->atsuFontId;
-    err = ATSUMatchFontsToText(
-        fontPtr->atsuLayout, 0, 1,
-        &fontId, &changedOffset, &changedLength);
+    err = ATSUMatchFontsToText(fontPtr->atsuLayout, 0, 1,
+	    &fontId, &changedOffset, &changedLength);
 #ifdef TK_MAC_DEBUG_FONTS
     if (err != kATSUFontsMatched && err != noErr) {
-        fprintf(stderr, "TkpGetFontAttrsForChar: "
-                "Can't match \\u%04X\n",
-                (unsigned) c);
+	FDBG("TkpGetFontAttrsForChar: 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);
+	/*
+	 * 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);
+	LOG_ON_ERR(FMGetFontFamilyInstanceFromFont);
+
+	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 (err != noErr) {
-            fprintf(stderr, "FMGetFontFamilyInstanceFromFont: Error %d\n",
-                    (int) err);
-        }
+	    if (i >= familyListMaxValid) {
+		FDBG("TkpGetFontAttrsForChar: Can't find font %d for \\u%04X",
+			(int) fontFamilyId, (unsigned) c);
+	    }
 #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
-        }
+	}
     }
 
 #if TK_MAC_USE_QUARZ
@@ -576,133 +553,124 @@ TkpGetFontAttrsForChar(
 /*
  *---------------------------------------------------------------------------
  *
- *  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;
+	FDBG("MeasureChars: bad parameters");
+	*lengthPtr = 0;
+	return 0;
     }
 
     /*
@@ -711,13 +679,11 @@ 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);
+	fflush(stdout);
 #endif
-        *lengthPtr = 0;
-        return 0;
+	FDBG("measure: '%.*s', empty", rangeLength, source+rangeStart);
+	*lengthPtr = 0;
+	return 0;
     }
 
 #if TK_MAC_USE_QUARZ
@@ -734,242 +700,217 @@ TkpMeasureCharsInContext(
     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.
+	     */
 
 #ifdef TK_MAC_DEBUG_FONTS
-            if ((err != noErr) && (err != kATSULineBreakInWord)) {
-                fprintf(stderr, "ATSUBreakLine(): Error %d for '%.*s'\n",
-                        (int) err, rangeLength, source+rangeStart);
-            }
+	    if ((err != noErr) && (err != kATSULineBreakInWord)) {
+		FDBG("ATSUBreakLine(): Error %d for '%.*s'",
+			(int) err, rangeLength, source+rangeStart);
+	    }
 #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);
-
-#ifdef TK_MAC_DEBUG_FONTS
-                fprintf(stderr, "measure: '%.*s', try until=%d, width=%d\n",
-                        rangeLength, source+rangeStart, (int) 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) {
-#ifdef TK_MAC_DEBUG_FONTS
-                    fprintf(stderr, "ATSUNextCursorPosition(): "
-                            "Can't move further "
-                            "(shouldn't happen, bad data?)\n");
-#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;
+	    FDBG("measure: '%.*s', break offset=%d, errcode=%d",
+		    rangeLength, source+rangeStart, (int) offset, (int) err);
+
+	    /*
+	     * 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);
+
+		FDBG("measure: '%.*s', try until=%d, width=%d",
+			rangeLength, source+rangeStart, (int) offset, curX);
+
+		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) {
+		    FDBG("ATSUNextCursorPosition(): Error %d", (int) err);
+		    break;
+		}
+		if (nextoffset <= offset) {
+		    FDBG("ATSUNextCursorPosition(): Can't move further "
+			    "(shouldn't happen, bad data?)");
+		    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;
     }
 
     Tcl_DStringFree(&ucharBuffer);
@@ -980,13 +921,12 @@ TkpMeasureCharsInContext(
 
 #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 " : "");
+    FDBG("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 " : "");
     fflush(stderr);
 #endif
 
@@ -999,42 +939,40 @@ 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);
 }
 
 
@@ -1043,46 +981,45 @@ Tk_DrawChars(
  *
  * 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.
  *
- *      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.
+ *	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.
  *
  *---------------------------------------------------------------------------
  */
 
 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. */
+    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;
@@ -1107,54 +1044,52 @@ TkpDrawCharsInContext(
     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);
+	    || 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();
+	if (TkSetMacColor(gc->foreground, &macColor)) {
+	    RGBForeColor(&macColor);
+	}
+	ShowPen();
+	MacFontDrawText(fontPtr, source, numBytes, rangeStart, rangeLength,
+		macWin->xOff + x, macWin->yOff + y);
+	HidePen();
     }
 
     RGBForeColor(&origColor);
@@ -1171,34 +1106,31 @@ TkpDrawCharsInContext(
  *
  * TkMacOSXQuarzStartDraw --
  *
- *      Setup a Quarz CGContext from the current QD GraphPort for use in
- *      drawing or measuring.
+ *	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.
+ *	A CGContext is allocated, configured and returned in
+ *	drawingContextPtr. Also drawingContextPtr->portRect is filled in.
  *
  * Side effects:
- *
- *      None.
+ *	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.
+ *	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. */
+    DrawingContext *drawingContextPtr)
+				/* Quarz context data filled in by this
+				 * function. */
 {
     GDHandle currentDevice;
     CGrafPtr destPort;
@@ -1213,53 +1145,47 @@ TkMacOSXQuarzStartDraw(
     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
+	/*
+	 * 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);
     } else {
-    fprintf(stderr, "QDBeginCGContext(): Error %d\n", (int) err);
- #endif
+	FDBG("QDBeginCGContext(): Error %d", (int) err);
     }
 
     drawingContextPtr->graphPort = destPort;
     drawingContextPtr->cgContext = outContext;
     drawingContextPtr->portRect = boundsRect;
-
 }
 
 /*
@@ -1267,16 +1193,16 @@ TkMacOSXQuarzStartDraw(
  *
  * TkMacOSXQuarzEndDraw --
  *
- *      Free the Quarz CGContext in drawingContextPtr.
+ *	Free the Quarz CGContext in drawingContextPtr.
  *
  * Results:
  *
- *      The CGContext is de-allocated.  drawingContextPtr->cgContext will be
- *      invalid after this.
+ *	The CGContext is de-allocated.	drawingContextPtr->cgContext will be
+ *	invalid after this.
  *
  * Side effects:
  *
- *      None.
+ *	None.
  *
  *-------------------------------------------------------------------------
  */
@@ -1287,8 +1213,8 @@ TkMacOSXQuarzEndDraw(
 {
     if (drawingContextPtr->cgContext) {
     QDEndCGContext(
-        drawingContextPtr->graphPort,
-        &drawingContextPtr->cgContext);
+	drawingContextPtr->graphPort,
+	&drawingContextPtr->cgContext);
     }
 }
 #endif /* TK_MAC_USE_QUARZ */
@@ -1298,28 +1224,28 @@ TkMacOSXQuarzEndDraw(
  *
  * MacFontDrawText --
  *
- *        Helper function for Tk_DrawChars.  Draws characters, using the
- *        screen font in fontPtr to draw multilingual characters.
+ *	Helper function for Tk_DrawChars. Draws characters, using the screen
+ *	font in fontPtr to draw multilingual characters.
  *
  * Results:
- *        None.
+ *	None.
  *
  * Side effects:
- *        Information gets drawn on the screen.
+ *	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. */
+    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. */
 {
     Fixed fx, fy;
     int ulen, urstart, urlen;
@@ -1332,12 +1258,11 @@ MacFontDrawText(
     Tcl_DString runString;
 #endif
 
-
 #if TK_MAC_USE_QUARZ
     TkMacOSXQuarzStartDraw(&drawingContext);
 
     /*
-     * Turn the y coordinate upside-down for Quarz drawing.  We would have
+     * 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.
@@ -1349,10 +1274,9 @@ MacFontDrawText(
     fy = IntToFixed(y);
 #endif
 
-
 #if TK_MAC_COALESCE_LINE
-    UpdateLineBuffer(
-            fontPtr, &drawingContext, source, numBytes, x, y, &lineOffset);
+    UpdateLineBuffer(fontPtr, &drawingContext, source, numBytes, x, y,
+	    &lineOffset);
 
     fx = IntToFixed(currentLeft);
 
@@ -1372,15 +1296,8 @@ MacFontDrawText(
     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
+    err = ATSUDrawText(fontPtr->atsuLayout, lineOffset+urstart, urlen, fx,fy);
+    LOG_ON_ERR(ATSUDrawText);
 
 #if !TK_MAC_COALESCE_LINE
     Tcl_DStringFree(&runString);
@@ -1390,46 +1307,42 @@ MacFontDrawText(
     TkMacOSXQuarzEndDraw(&drawingContext);
 #endif
 }
-
 
 /*
  *---------------------------------------------------------------------------
  *
  * 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".
+     * Instead the result of ATSUGetGlyphBounds() *does* include these "extra
+     * pixels".
      */
 
     ATSTrapezoid bounds;
@@ -1437,23 +1350,19 @@ MeasureStringWidth(
     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);
+    err = 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);
+	FDBG("ATSUGetGlyphBounds(): Error %d", (int) err);
     } else if (numBounds < 1) {
-        fprintf(stderr, "ATSUGetGlyphBounds(): No output\n");
+	FDBG("ATSUGetGlyphBounds(): No output");
     } else if (numBounds > 1) {
-        fprintf(stderr, "ATSUGetGlyphBounds(): More output\n");
+	FDBG("ATSUGetGlyphBounds(): More output");
     }
 #endif
 
@@ -1466,52 +1375,50 @@ 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 TkMacOSXLayoutSetString()).
  *
  *-------------------------------------------------------------------------
  */
 
 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 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 Tcl_UniChar * uchars;
     int ulen;
 
     if (y != currentY
-            || x < currentRight-1 || x > currentRight+2
-            || currentFontPtr != fontPtr) {
-        Tcl_DStringFree(&currentLine);
-        Tcl_DStringInit(&currentLine);
-        currentY = y;
-        currentLeft = x;
-        currentFontPtr = fontPtr;
-        *offset = 0;
+	    || x < currentRight-1 || x > currentRight+2
+	    || currentFontPtr != fontPtr) {
+	Tcl_DStringFree(&currentLine);
+	Tcl_DStringInit(&currentLine);
+	currentY = y;
+	currentLeft = x;
+	currentFontPtr = fontPtr;
+	*offset = 0;
     } else {
-        *offset = Tcl_DStringLength(&currentLine) / 2;
+	*offset = Tcl_DStringLength(&currentLine) / 2;
     }
 
     Tcl_UtfToUniCharDString(source, numBytes, &currentLine);
@@ -1529,33 +1436,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 +1472,31 @@ 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
+    LOG_ON_ERR(FetchFontInfo);
 
     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 {
-#ifdef TK_MAC_DEBUG_FONTS
-                fprintf(stderr, "Font family '%s': Not found\n", name);
-#endif
-            }
-        }
+	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 {
+		FDBG("Font family '%s': Not found", name);
+	    }
+	}
     }
 
     fontPtr->font.fid = (Font) fontPtr;
@@ -1612,11 +1512,11 @@ InitFont(
     fmPtr = &fontPtr->font.fm;
 
     /*
-     * 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
-     * it to the descent, as the Mac docs would indicate, would change
-     * the position of self-drawn underlines.
+     * 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 it to the descent, as the Mac
+     * docs would indicate, would change the position of self-drawn
+     * underlines.
      */
 
     fmPtr->ascent = fi.ascent + fi.leading;
@@ -1627,9 +1527,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,29 +1544,28 @@ 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,18 +1582,13 @@ 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
+    err = FMGetFontFromFontFamilyInstance(familyId, qdStyles, fontIdPtr,
+	    &stylesDone);
+    LOG_ON_ERR(FMGetFontFromFontFamilyInstance);
 
     /*
-     * We see what style bits are left and tell ATSU to synthesize what's
-     * left like QD does it.
+     * We see what style bits are left and tell ATSU to synthesize what's left
+     * like QD does it.
      */
 
     stylesLeft = qdStyles & ~(unsigned)stylesDone;
@@ -1705,24 +1598,16 @@ InitATSUObjects(
      */
 
     err = ATSUCreateStyle(stylePtr);
-#ifdef TK_MAC_DEBUG_FONTS
-    if (err != noErr) {
-        fprintf(stderr, "ATSUCreateStyle(): Error %d\n", (int) err);
-    }
-#endif
+    LOG_ON_ERR(ATSUCreateStyle);
     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
+    LOG_ON_ERR(ATSUCreateTextLayout);
     /*InitATSULayout(*layoutPtr);*/
 }
 
@@ -1731,25 +1616,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 +1641,59 @@ 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
+    OSStatus err = ATSUSetAttributes(style,
+	    sizeof(styleTags)/sizeof(styleTags[0]),
+	    styleTags, styleSizes, styleValues);
+    LOG_ON_ERR(ATSUSetAttributes);
 }
-
 
 /*
  *---------------------------------------------------------------------------
  *
  * 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 +1701,19 @@ 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
+	err = ATSUSetFontFeatures(style,
+		sizeof(fixed_featureTypes)/sizeof(fixed_featureTypes[0]),
+		fixed_featureTypes, fixed_featureSelectors);
+	LOG_ON_ERR(ATSUSetFontFeatures);
     }
 }
 
@@ -1853,17 +1722,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 +1742,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,20 +1750,18 @@ 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
@@ -1904,100 +1769,90 @@ AdjustFontHeight(
     TkMacOSXLayoutSetString(fontPtr, &drawingContext, chars, charslen);
 
     size.top = size.bottom = 0;
-    err = ATSUMeasureTextImage(
-        fontPtr->atsuLayout,
-        0, charslen,
-        0, 0,
-        &size);
+    err = ATSUMeasureTextImage(fontPtr->atsuLayout, 0, charslen, 0, 0, &size);
 
 #if TK_MAC_USE_QUARZ
     TkMacOSXQuarzEndDraw(&drawingContext);
 #endif
 
     if (err != noErr) {
-#ifdef TK_MAC_DEBUG_FONTS
-        fprintf(stderr, "ATSUMeasureTextImage(): Error %d\n", (int) err);
-#endif
+	FDBG("ATSUMeasureTextImage(): Error %d", (int) err);
     } 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;
-        }
+	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 TkMacOSXLayoutSetString(). 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
+ *	TkMacOSXLayoutSetString()).
  *
  *---------------------------------------------------------------------------
  */
 
 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 DrawingContext *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
+	    0
 #if TK_MAC_COALESCE_LINE
     /*
      * Options to use unconditionally, when we try to do coalescing in here.
      */
-        | kATSLineDisableAllLayoutOperations
-        | kATSLineFractDisable
-        | kATSLineUseDeviceMetrics
+	    | kATSLineDisableAllLayoutOperations
+	    | kATSLineFractDisable
+	    | kATSLineUseDeviceMetrics
 #endif
-        ;
+	    ;
 
     static const ATSUAttributeTag layoutTags[] = {
 #if TK_MAC_USE_QUARZ
-        kATSUCGContextTag,
+	kATSUCGContextTag,
 #endif
-        kATSULineLayoutOptionsTag,
+	kATSULineLayoutOptionsTag,
     };
     static const ByteCount layoutSizes[] = {
 #if TK_MAC_USE_QUARZ
-        sizeof(CGContextRef),
+	sizeof(CGContextRef),
 #endif
-        sizeof(ATSLineLayoutOptions),
+	sizeof(ATSLineLayoutOptions),
     };
     const ATSUAttributeValuePtr layoutValues[] = {
 #if TK_MAC_USE_QUARZ
-        (void*)&drawingContextPtr->cgContext,
+	(void*)&drawingContextPtr->cgContext,
 #endif
-        &layoutOptions,
+	&layoutOptions,
     };
 
     OSStatus err;
@@ -2007,29 +1862,16 @@ InitATSULayout(
      */
 
     if (fixed) {
-        layoutOptions |=
-                  kATSLineFractDisable
-                | kATSLineUseDeviceMetrics
-                ;
+	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);
-    }
-#endif
+    err = ATSUSetLayoutControls(layout,
+	    sizeof(layoutTags)/sizeof(layoutTags[0]),
+	    layoutTags, layoutSizes, layoutValues);
+    LOG_ON_ERR(ATSUSetLayoutControls);
 
     err = ATSUSetTransientFontMatching(layout, true);
-#ifdef TK_MAC_DEBUG_FONTS
-    if (err != noErr) {
-        fprintf(stderr, "ATSUSetTransientFontMatching(): Error %d\n",
-                (int) err);
-    }
-#endif
+    LOG_ON_ERR(ATSUSetTransientFontMatching);
 }
 
 /*
@@ -2037,83 +1879,68 @@ InitATSULayout(
  *
  * TkMacOSXLayoutSetString --
  *
- *      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 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. */
+				/* 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
+    err = ATSUSetTextPointerLocation(fontPtr->atsuLayout,
+	    uchars, kATSUFromTextBeginning, ulen, ulen);
+    LOG_ON_ERR(ATSUSetTextPointerLocation);
 
     /*
      * 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
+    err = ATSUSetRunStyle(fontPtr->atsuLayout, fontPtr->atsuStyle,
+	    kATSUFromTextBeginning, kATSUToTextEnd);
+    LOG_ON_ERR(ATSUSetRunStyle);
 
     /*
      * 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 +1951,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 +1992,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,38 +2018,34 @@ 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
-     * that doesn't work, because Carbon seems to cache the inital list of
-     * fonts.  Fonts newly installed don't show up with
-     * FMCreateFontFamilyIterator()/FMGetNextFontFamily() without a restart
-     * of the app.  Similar problem with fonts removed.
+     * 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
+     * FMCreateFontFamilyIterator()/FMGetNextFontFamily() without a restart of
+     * the app. Similar problem with fonts removed.
      */
 
-#ifdef TK_MAC_DEBUG_FONTS
-    fprintf(stderr, "Font family '%s': Not found\n", name);
-#endif
-
+    FDBG("Font family '%s': Not found", name);
     return NULL;
 }
 
@@ -2231,16 +2054,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.
  *
  *-------------------------------------------------------------------------
  */
@@ -2255,15 +2078,11 @@ InitFontFamilies(void)
      */
 
     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
+    LOG_ON_ERR(ATSFontFamilyApplyFunction);
 
     AddFontFamily(APPLFONT_NAME, GetAppFont());
     AddFontFamily(SYSTEMFONT_NAME, GetSysFont());
@@ -2273,7 +2092,7 @@ InitFontFamilies(void)
 
 static OSStatus
 FontFamilyEnumCallback(
-    ATSFontFamilyRef family, 
+    ATSFontFamilyRef family,
     void *refCon)
 {
     OSStatus err;
@@ -2283,7 +2102,7 @@ FontFamilyEnumCallback(
 
     err = GetFontFamilyName(family, name, sizeof(name));
     if (err == noErr) {
-        AddFontFamily(name, family);
+	AddFontFamily(name, family);
     }
 
     return noErr;
@@ -2295,28 +2114,28 @@ FontFamilyEnumCallback(
  *
  * 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;
@@ -2328,11 +2147,9 @@ GetFontFamilyName(
     name[0] = 0;
 
     err = FMGetFontFamilyName(fontFamily, nativeName);
+    LOG_ON_ERR(FMGetFontFamilyName);
     if (err != noErr) {
-#ifdef TK_MAC_DEBUG_FONTS
-        fprintf(stderr, "FMGetFontFamilyName(): Error %d\n", (int) err);
-#endif
-        return err;
+	return err;
     }
 
     /*
@@ -2342,35 +2159,26 @@ GetFontFamilyName(
 
     encoding = kTextEncodingMacRoman;
     err = FMGetFontFamilyTextEncoding(fontFamily, &encoding);
-#ifdef TK_MAC_DEBUG_FONTS
-    if (err != noErr) {
-        fprintf(stderr, "FMGetFontFamilyTextEncoding(): Error %d\n", (int) err);
-    }
-#endif
+    LOG_ON_ERR(FMGetFontFamilyTextEncoding);
 
     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
+    LOG_ON_ERR(RevertTextEncodingToScriptInfo);
 
     /*
-     * 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
-     * than if that happens it would be a bug in
-     * FMGetFontFamilyTextEncoding() or RevertTextEncodingToScriptInfo().
+     * 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 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 +2189,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 +2229,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 +2248,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 +2260,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 +2302,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 +2322,8 @@ static void
 SortFontFamilies(void)
 {
     if (familyListNextFree > 0) {
-        qsort(  familyList, familyListNextFree, sizeof(*familyList),
-                CompareFontFamilies);
+	qsort(familyList, familyListNextFree, sizeof(*familyList),
+		CompareFontFamilies);
     }
     familyListMaxValid = familyListNextFree;
 }
@@ -2530,21 +2333,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 +2357,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,43 +2375,39 @@ 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;
     stringMemory->nextFree += len;
 
     memcpy(result, in, len);
-
     return result;
 }
 
@@ -2621,29 +2416,29 @@ 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
-     * definition of the encoding of the parameter searchChar from MacRoman
-     * to UniChar for that.
+     * 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.
      *
      * The system uses font fallback for controls, so we don't really need
      * this. */
@@ -2656,30 +2451,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,47 +2483,53 @@ 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;
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */