summaryrefslogtreecommitdiffstats
path: root/macosx
diff options
context:
space:
mode:
authordas <das>2006-03-22 00:21:15 (GMT)
committerdas <das>2006-03-22 00:21:15 (GMT)
commit2579527c4a82ca0cea032dfa5e9ed757f43cd59e (patch)
treefedd23bf410c6a013f190bd8aa27dbf9999214f1 /macosx
parenta035d9f0c9008fbb62a43d011474036c0c56ed3c (diff)
downloadtk-2579527c4a82ca0cea032dfa5e9ed757f43cd59e.zip
tk-2579527c4a82ca0cea032dfa5e9ed757f43cd59e.tar.gz
tk-2579527c4a82ca0cea032dfa5e9ed757f43cd59e.tar.bz2
* generic/tkFont.c: implementation of ATSUI text rendering
* generic/tkInt.h: in TkAqua provided by Benjamin * generic/tkTextDisp.c: Riefenstahl. [Patch 638966] * library/demos/unicodeout.tcl: * macosx/tkMacOSXFont.h (new file): * macosx/tkMacOSXFont.c: * tests/font.test: * unix/tkUnixFont.c: * win/tkWinFont.c: * generic/tkFont.c: moved MODULE_SCOPE declarations of * generic/tkFont.h: font helper procs into header files. * macosx/tkMacOSXButton.c: * macosx/tkMacOSXFont.h: * macosx/tkMacOSXMenubutton.c: * macosx/Wish.xcode/project.pbxproj: add new tkMacOSXFont.h file, * macosx/Wish.xcodeproj/project.pbxproj: turn off dead code stripping as it interferes with -sectcreate (rdar://4486223). * macosx/Wish.xcode/default.pbxuser: add TCLLIBPATH=/Library/Tcl * macosx/Wish.xcodeproj/default.pbxuser: env var setting to tktest. * unix/configure.in: fix detection of symbols build when enabling TkAqua debug code; filter nm output of libtclstub better to avoid error on intel macs [Bug 1415789]. * unix/configure: autoconf-2.59
Diffstat (limited to 'macosx')
-rw-r--r--macosx/Wish.xcode/default.pbxuser5
-rw-r--r--macosx/Wish.xcode/project.pbxproj11
-rw-r--r--macosx/Wish.xcodeproj/default.pbxuser5
-rw-r--r--macosx/Wish.xcodeproj/project.pbxproj6
-rw-r--r--macosx/tkMacOSXButton.c6
-rw-r--r--macosx/tkMacOSXFont.c3633
-rw-r--r--macosx/tkMacOSXFont.h113
-rw-r--r--macosx/tkMacOSXMenubutton.c6
8 files changed, 2180 insertions, 1605 deletions
diff --git a/macosx/Wish.xcode/default.pbxuser b/macosx/Wish.xcode/default.pbxuser
index 164d686..9121060 100644
--- a/macosx/Wish.xcode/default.pbxuser
+++ b/macosx/Wish.xcode/default.pbxuser
@@ -80,6 +80,11 @@
value = "${SRCROOT}/../../tk/library";
},
{
+ active = YES;
+ name = TCLLIBPATH;
+ value = /Library/Tcl;
+ },
+ {
active = NO;
name = DYLD_PRINT_LIBRARIES;
},
diff --git a/macosx/Wish.xcode/project.pbxproj b/macosx/Wish.xcode/project.pbxproj
index 6049eb4..608dea1 100644
--- a/macosx/Wish.xcode/project.pbxproj
+++ b/macosx/Wish.xcode/project.pbxproj
@@ -27,7 +27,7 @@
buildSettings = {
BUILD_STYLE = Deployment;
CONFIGURE_ARGS = "$(value) --disable-symbols";
- DEAD_CODE_STRIPPING = YES;
+ DEAD_CODE_STRIPPING = NO;
DEPLOYMENT_POSTPROCESSING = YES;
GCC_DEBUGGING_SYMBOLS = full;
GCC_ENABLE_FIX_AND_CONTINUE = NO;
@@ -466,6 +466,14 @@
//F92
//F93
//F94
+ F93E5EFD09CF8711008FA367 = {
+ fileEncoding = 4;
+ isa = PBXFileReference;
+ lastKnownFileType = sourcecode.c.h;
+ path = tkMacOSXFont.h;
+ refType = 4;
+ sourceTree = "<group>";
+ };
F966BA0308F27A37005CB29B = {
children = (
F966BA0408F27A37005CB29B,
@@ -3699,6 +3707,7 @@
F966BBD408F27A3B005CB29B,
F966BBD508F27A3B005CB29B,
F966BBD608F27A3B005CB29B,
+ F93E5EFD09CF8711008FA367,
F966BBD708F27A3B005CB29B,
F966BBD808F27A3B005CB29B,
F966BBDA08F27A3B005CB29B,
diff --git a/macosx/Wish.xcodeproj/default.pbxuser b/macosx/Wish.xcodeproj/default.pbxuser
index 1695fa5..c30bf3f 100644
--- a/macosx/Wish.xcodeproj/default.pbxuser
+++ b/macosx/Wish.xcodeproj/default.pbxuser
@@ -81,6 +81,11 @@
value = "${SRCROOT}/../../tk/library";
},
{
+ active = YES;
+ name = TCLLIBPATH;
+ value = /Library/Tcl;
+ },
+ {
active = NO;
name = DYLD_PRINT_LIBRARIES;
},
diff --git a/macosx/Wish.xcodeproj/project.pbxproj b/macosx/Wish.xcodeproj/project.pbxproj
index 29331fc..d832275 100644
--- a/macosx/Wish.xcodeproj/project.pbxproj
+++ b/macosx/Wish.xcodeproj/project.pbxproj
@@ -300,6 +300,7 @@
/* Begin PBXFileReference section */
8DD76FB20486AB0100D96B5E /* tktest */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = tktest; sourceTree = BUILT_PRODUCTS_DIR; };
+ F93E5EFD09CF8711008FA367 /* tkMacOSXFont.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tkMacOSXFont.h; sourceTree = "<group>"; };
F966BA0408F27A37005CB29B /* error.xbm */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; path = error.xbm; sourceTree = "<group>"; };
F966BA0508F27A37005CB29B /* gray12.xbm */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; path = gray12.xbm; sourceTree = "<group>"; };
F966BA0608F27A37005CB29B /* gray25.xbm */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; path = gray25.xbm; sourceTree = "<group>"; };
@@ -2087,6 +2088,7 @@
F966BBD408F27A3B005CB29B /* tkMacOSXEvent.c */,
F966BBD508F27A3B005CB29B /* tkMacOSXEvent.h */,
F966BBD608F27A3B005CB29B /* tkMacOSXFont.c */,
+ F93E5EFD09CF8711008FA367 /* tkMacOSXFont.h */,
F966BBD708F27A3B005CB29B /* tkMacOSXHLEvents.c */,
F966BBD808F27A3B005CB29B /* tkMacOSXInit.c */,
F966BBDA08F27A3B005CB29B /* tkMacOSXInt.h */,
@@ -3704,7 +3706,7 @@
);
BINDIR = "${PREFIX}/bin";
CONFIGURE_ARGS = "--enable-threads ${CONFIGURE_ARGS}";
- DEAD_CODE_STRIPPING = YES;
+ DEAD_CODE_STRIPPING = NO;
DEPLOYMENT_POSTPROCESSING = YES;
GCC_DEBUGGING_SYMBOLS = full;
GCC_DYNAMIC_NO_PIC = YES;
@@ -3906,7 +3908,7 @@
buildSettings = {
BINDIR = "${PREFIX}/bin";
CONFIGURE_ARGS = "--enable-threads ${CONFIGURE_ARGS}";
- DEAD_CODE_STRIPPING = YES;
+ DEAD_CODE_STRIPPING = NO;
DEPLOYMENT_POSTPROCESSING = YES;
GCC_DEBUGGING_SYMBOLS = full;
GCC_DYNAMIC_NO_PIC = YES;
diff --git a/macosx/tkMacOSXButton.c b/macosx/tkMacOSXButton.c
index 8effde3..ed75502 100644
--- a/macosx/tkMacOSXButton.c
+++ b/macosx/tkMacOSXButton.c
@@ -10,11 +10,12 @@
* See the file "license.terms" for information on usage and redistribution
* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
*
- * RCS: @(#) $Id: tkMacOSXButton.c,v 1.16 2005/11/27 02:36:14 das Exp $
+ * RCS: @(#) $Id: tkMacOSXButton.c,v 1.17 2006/03/22 00:21:17 das Exp $
*/
#include "tkButton.h"
#include "tkMacOSXInt.h"
+#include "tkMacOSXFont.h"
#include "tkMacOSXDebug.h"
#define DEFAULT_USE_TK_TEXT 0
@@ -109,9 +110,6 @@ static void SetupBevelButton _ANSI_ARGS_((MacButton *butPtr,
ControlRef controlHandle,
GWorldPtr destPort, GC gc, Pixmap pixmap));
-MODULE_SCOPE int TkFontGetFirstTextLayout(Tk_TextLayout layout, Tk_Font * font, char * dst);
-MODULE_SCOPE void TkMacOSXInitControlFontStyle(Tk_Font tkfont,ControlFontStylePtr fsPtr);
-
/*
* The class procedure table for the button widgets.
*/
diff --git a/macosx/tkMacOSXFont.c b/macosx/tkMacOSXFont.c
index 2059662..f55542d 100644
--- a/macosx/tkMacOSXFont.c
+++ b/macosx/tkMacOSXFont.c
@@ -1,8 +1,13 @@
-/*
+/*
* tkMacOSXFont.c --
*
- * Contains the Macintosh implementation of the platform-independant
- * font package interface.
+ * 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
+ *
+ * Some functions were originally copied verbatim from the QuickDraw version
+ * of tkMacOSXFont.c, which had these copyright notices:
*
* Copyright (c) 1990-1994 The Regents of the University of California.
* Copyright (c) 1994-1997 Sun Microsystems, Inc.
@@ -11,370 +16,267 @@
* See the file "license.terms" for information on usage and redistribution
* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
*
- * RCS: @(#) $Id: tkMacOSXFont.c,v 1.11 2005/12/08 07:50:14 das Exp $
+ *
+ * Todos:
+ *
+ * - Get away from Font Manager and Quickdraw functions as much as possible,
+ * replace with ATS functions instead.
+ *
+ * - Use Font Manager functions to translate ids from ATS to Font Manager
+ * 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.
+ * 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).
+ *
+ * RCS: @(#) $Id: tkMacOSXFont.c,v 1.12 2006/03/22 00:21:17 das Exp $
*/
-#include <Carbon/Carbon.h>
#include "tkMacOSXInt.h"
-#include "tkFont.h"
+#include "tkMacOSXFont.h"
/*
- * For doing things with Mac strings and Fixed numbers. This probably should move
- * the mac header file.
+#ifdef TK_MAC_DEBUG
+#define TK_MAC_DEBUG_FONTS
+#endif
+*/
+
+typedef TkMacOSXFont MacFont;
+typedef TkMacOSXFontDrawingContext DrawingContext;
+
+/*
+ * Features that we still may want to disable again. See first occurrance of
+ * these macros in #if statements for respective general discussions.
*/
-#ifndef StrLength
-#define StrLength(s) (*((unsigned char *) (s)))
-#endif
-#ifndef StrBody
-#define StrBody(s) ((char *) (s) + 1)
-#endif
-#define pstrcmp(s1, s2) RelString((s1), (s2), 1, 1)
-#define pstrcasecmp(s1, s2) RelString((s1), (s2), 0, 1)
+/* #define TK_MAC_COALESCE_LINE 1 */
+/* #define TK_MAC_USE_MEASURETEXTIMAGE 1 */
+/* #define TK_MAC_USE_GETGLYPHBOUNDS 1 */
-#ifndef Fixed2Int
-#define Fixed2Int(f) ((f) >> 16)
-#define Int2Fixed(i) ((i) << 16)
-#endif
/*
- * The preferred font encodings.
+ * 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.
*/
-static CONST char *encodingList[] = {
- "macRoman", "macJapan", NULL
-};
+typedef struct {
+ const char * name;
+ FMFontFamily familyId;
+} MacFontFamily;
+
+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. */
/*
- * The following structures are used to map the script/language codes of a
- * font to the name that should be passed to Tcl_GetTextEncoding() to obtain
- * the encoding for that font. The set of numeric constants is fixed and
- * defined by Apple.
+ * 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
+ * re-initialize this, you can just ckfree() all the StringBlocks in the list
+ * and start over.
*/
-
-static TkStateMap scriptMap[] = {
- {smRoman, "macRoman"},
- {smJapanese, "macJapan"},
- {smTradChinese, "macChinese"},
- {smKorean, "macKorean"},
- {smArabic, "macArabic"},
- {smHebrew, "macHebrew"},
- {smGreek, "macGreek"},
- {smCyrillic, "macCyrillic"},
- {smRSymbol, "macRSymbol"},
- {smDevanagari, "macDevanagari"},
- {smGurmukhi, "macGurmukhi"},
- {smGujarati, "macGujarati"},
- {smOriya, "macOriya"},
- {smBengali, "macBengali"},
- {smTamil, "macTamil"},
- {smTelugu, "macTelugu"},
- {smKannada, "macKannada"},
- {smMalayalam, "macMalayalam"},
- {smSinhalese, "macSinhalese"},
- {smBurmese, "macBurmese"},
- {smKhmer, "macKhmer"},
- {smThai, "macThailand"},
- {smLaotian, "macLaos"},
- {smGeorgian, "macGeorgia"},
- {smArmenian, "macArmenia"},
- {smSimpChinese, "macSimpChinese"},
- {smTibetan, "macTIbet"},
- {smMongolian, "macMongolia"},
- {smGeez, "macEthiopia"},
- {smEastEurRoman, "macCentEuro"},
- {smVietnamese, "macVietnam"},
- {smExtArabic, "macSindhi"},
- {0, NULL}
-};
-
-static TkStateMap romanMap[] = {
- {langCroatian, "macCroatian"},
- {langSlovenian, "macCroatian"},
- {langIcelandic, "macIceland"},
- {langRomanian, "macRomania"},
- {langTurkish, "macTurkish"},
- {langGreek, "macGreek"},
- {0, NULL}
-};
-
-static TkStateMap cyrillicMap[] = {
- {langUkrainian, "macUkraine"},
- {langBulgarian, "macBulgaria"},
- {0, NULL}
-};
+
+#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. */
+} StringBlock;
+
+static StringBlock * stringMemory = NULL;
+
+
+#if TK_MAC_COALESCE_LINE
/*
- * The following structure represents a font family. It is assumed that
- * all screen fonts constructed from the same "font family" share certain
- * properties; all screen fonts with the same "font family" point to a
- * shared instance of this structure. The most important shared property
- * is the character existence metrics, used to determine if a screen font
- * can display a given Unicode character.
- *
- * Under Macintosh, a "font family" is uniquely identified by its face number.
+ * 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 avoid lines that
+ * tremble and shiver while the cursor passes through them, we undercut the
+ * system and behind the scenes paste 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.
*/
+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. */
-#define FONTMAP_SHIFT 10
+#endif /* TK_MAC_COALESCE_LINE */
-#define FONTMAP_PAGES (1 << (sizeof(Tcl_UniChar) * 8 - FONTMAP_SHIFT))
-#define FONTMAP_BITSPERPAGE (1 << FONTMAP_SHIFT)
+static int TkMacOSXAntialiasedTextEnabled = -1;
-typedef struct FontFamily {
- struct FontFamily *nextPtr; /* Next in list of all known font families. */
- int refCount; /* How many SubFonts are referring to this
- * FontFamily. When the refCount drops to
- * zero, this FontFamily may be freed. */
- /*
- * Key.
- */
+/*
+ * The names for our two "native" fonts.
+ */
- FMFontFamily faceNum; /* Unique face number key for this FontFamily. */
-
- /*
- * Derived properties.
- */
-
- Tcl_Encoding encoding; /* Encoding for this font family. */
- int isSymbolFont; /* Non-zero if this is a symbol family. */
- int isMultiByteFont; /* Non-zero if this is a multi-byte family. */
- char typeTable[256]; /* Table that identfies all lead bytes for a
- * multi-byte family, used when measuring chars.
- * If a byte is a lead byte, the value at the
- * corresponding position in the typeTable is 1,
- * otherwise 0. If this is a single-byte font,
- * all entries are 0. */
- char *fontMap[FONTMAP_PAGES];
- /* Two-level sparse table used to determine
- * quickly if the specified character exists.
- * As characters are encountered, more pages
- * in this table are dynamically added. The
- * contents of each page is a bitmask
- * consisting of FONTMAP_BITSPERPAGE bits,
- * representing whether this font can be used
- * to display the given character at the
- * corresponding bit position. The high bits
- * of the character are used to pick which
- * page of the table is used. */
-} FontFamily;
+#define SYSTEMFONT_NAME "system"
+#define APPLFONT_NAME "application"
+
+/*
+ * Procedures used only in this file.
+ */
/*
- * The following structure encapsulates an individual screen font. A font
- * object is made up of however many SubFonts are necessary to display a
- * stream of multilingual characters.
+ * The actual workers.
*/
-typedef struct SubFont {
- char **fontMap; /* Pointer to font map from the FontFamily,
- * cached here to save a dereference. */
- FontFamily *familyPtr; /* The FontFamily for this SubFont. */
-} SubFont;
+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);
+#endif /* TK_MAC_COALESCE_LINE */
/*
- * The following structure represents Macintosh's implementation of a font
- * object.
+ * Initialization and setup of a font data structure.
*/
-#define SUBFONT_SPACE 3
-
-typedef struct MacFont {
- TkFont font; /* Stuff used by generic font package. Must
- * be first in structure. */
- SubFont staticSubFonts[SUBFONT_SPACE];
- /* Builtin space for a limited number of
- * SubFonts. */
- int numSubFonts; /* Length of following array. */
- SubFont *subFontArray; /* Array of SubFonts that have been loaded
- * in order to draw/measure all the characters
- * encountered by this font so far. All fonts
- * start off with one SubFont initialized by
- * AllocFont() from the original set of font
- * attributes. Usually points to
- * staticSubFonts, but may point to malloced
- * space if there are lots of SubFonts. */
-
- short size; /* Font size in pixels, constructed from
- * font attributes. */
- short style; /* Style bits, constructed from font
- * attributes. */
-} MacFont;
+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);
/*
- * The following structure is used to map between the UTF-8 name for a font and
- * the name that the Macintosh uses to refer to the font, in order to determine
- * if a font exists. The Macintosh names for fonts are stored in the encoding
- * of the font itself.
+ * Finding fonts by name.
*/
-
-typedef struct FontNameMap {
- Tk_Uid utfName; /* The name of the font in UTF-8. */
- StringPtr nativeName; /* The name of the font in the font's encoding. */
- FMFontFamily faceNum; /* Unique face number for this font. */
-} FontNameMap;
+
+static const MacFontFamily * FindFontFamilyOrAlias(
+ const char * name);
+static const MacFontFamily * FindFontFamilyOrAliasOrFallback(
+ const char * name);
/*
- * The list of font families that are currently loaded. As screen fonts
- * are loaded, this list grows to hold information about what characters
- * exist in each font family.
+ * Doing interesting things with font families and fonts.
*/
-static FontFamily *fontFamilyList = NULL;
+static void InitFontFamilies(void);
+static OSStatus GetFontFamilyName(
+ FMFontFamily fontFamily, char * name, int numBytes);
/*
- * Information cached about the system at startup time.
+ * Accessor functions and internal utilities for the font family list.
*/
-
-static FontNameMap *gFontNameMap = NULL;
-static GWorldPtr gWorld = NULL;
+
+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);
/*
- * Procedures used only in this file.
+ * Trace interface for configuring anti-aliasing through a global variable.
+ */
+
+static char * TkMacOSXAntialiasedTextVariableProc(
+ ClientData clientData, Tcl_Interp * interp,
+ const char * name1, const char * name2,
+ int flag);
+
+/*
+ * For doing things with Fixed numbers. FIXME: This probably should move to
+ * tkMacOSXInt.h.
*/
-static FontFamily * AllocFontFamily(CONST MacFont *fontPtr, int family);
-static SubFont * CanUseFallback(MacFont *fontPtr, CONST char *fallbackName, int ch, SubFont **fixSubFontPtrPtr);
-static SubFont * CanUseFallbackWithAliases(MacFont *fontPtr, CONST char *faceName, int ch, Tcl_DString *nameTriedPtr, SubFont **fixSubFontPtrPtr);
-static SubFont * FindSubFontForChar(MacFont *fontPtr, int ch, SubFont **fixSubFontPtrPtr);
-static void FontMapInsert(SubFont *subFontPtr, int ch);
-static void FontMapLoadPage(SubFont *subFontPtr, int row);
-static int FontMapLookup(SubFont *subFontPtr, int ch);
-static void FreeFontFamily(FontFamily *familyPtr);
-static void InitFont(Tk_Window tkwin, int family, int size, int style, MacFont *fontPtr);
-static void InitSubFont(CONST MacFont *fontPtr, int family, SubFont *subFontPtr);
-static void MultiFontDrawText(MacFont *fontPtr, CONST char *source, int numBytes, int x, int y);
-static void ReleaseFont(MacFont *fontPtr);
-static void ReleaseSubFont(SubFont *subFontPtr);
-static int SeenName(CONST char *name, Tcl_DString *dsPtr);
-
-static CONST char * BreakLine(FontFamily *familyPtr, int flags, CONST char *source, int numBytes, int *widthPtr);
-static int GetFamilyNum(CONST char *faceName, short *familyPtr);
-static int GetFamilyOrAliasNum(CONST char *faceName, short *familyPtr);
-static Tcl_Encoding GetFontEncoding(int faceNum, int allowSymbol, int *isSymbolPtr);
-static Tk_Uid GetUtfFaceName(StringPtr faceNameStr);
-
-MODULE_SCOPE void TkMacOSXInitControlFontStyle(Tk_Font tkfont,
- ControlFontStylePtr fsPtr);
+#ifndef Fixed2Int
+#define Fixed2Int(f) ((f+0x8000) >> 16)
+#define Int2Fixed(i) ((i) << 16)
+#endif
+
/*
*-------------------------------------------------------------------------
- *
+ *
* TkpFontPkgInit --
*
* This procedure is called when an application is created. It
- * initializes all the structures that are used by the
+ * initializes all the structures that are used by the
* platform-dependant code on a per application basis.
*
* Results:
- * None.
+ * None.
*
* Side effects:
- * See comments below.
+ * Initialization of variables local to this file.
*
*-------------------------------------------------------------------------
*/
void
-TkpFontPkgInit(mainPtr)
- TkMainInfo *mainPtr; /* The application being created. */
+TkpFontPkgInit(
+ TkMainInfo * mainPtr) /* The application being created. */
{
- FMFontFamilyIterator fontFamilyIterator;
- FMFontFamily fontFamily;
- FontNameMap *tmpFontNameMap, *newFontNameMap, *mapPtr;
- int i, j, numFonts, fontMapOffset, isSymbol;
- Str255 nativeName;
- Tcl_DString ds;
- Tcl_Encoding encoding;
- Tcl_Encoding *encodings;
-
- if (gWorld == NULL) {
- Rect rect = {0, 0, 1, 1};
- SetFractEnable(0);
- /*
- * Used for saving and restoring state while drawing and measuring.
- */
- if (NewGWorld(&gWorld, 0, &rect, NULL, NULL, 0) != noErr) {
- Tcl_Panic("TkpFontPkgInit: NewGWorld failed");
- }
- /*
- * The name of each font is stored in the encoding of that font.
- * How would we translate a name from UTF-8 into the native encoding
- * of the font unless we knew the encoding of that font? We can't.
- * So, precompute the UTF-8 and native names of all fonts on the
- * system. The when the user asks for font by its UTF-8 name, we
- * lookup the name in that table and really ask for the font by its
- * native name. Any unknown UTF-8 names will be mapped to the system
- * font.
- */
- FMCreateFontFamilyIterator (NULL, NULL, kFMDefaultOptions, &fontFamilyIterator);
- numFonts = 0;
- while (FMGetNextFontFamily(&fontFamilyIterator, &fontFamily) != kFMIterationCompleted) {
- numFonts++;
- }
- tmpFontNameMap = (FontNameMap *) ckalloc(sizeof(FontNameMap) * numFonts);
- encodings = (Tcl_Encoding *) ckalloc(sizeof(Tcl_Encoding) * numFonts);
- mapPtr = tmpFontNameMap;
- FMResetFontFamilyIterator(NULL, NULL, kFMDefaultOptions, &fontFamilyIterator);
- i = 0;
- while (FMGetNextFontFamily(&fontFamilyIterator, &fontFamily) != kFMIterationCompleted) {
- mapPtr->faceNum = fontFamily;
- encodings[i] = GetFontEncoding(mapPtr->faceNum, 0, &isSymbol);
- FMGetFontFamilyName(fontFamily, nativeName );
- Tcl_ExternalToUtfDString(encodings[i], StrBody(nativeName), StrLength(nativeName), &ds);
- mapPtr->utfName = Tk_GetUid(Tcl_DStringValue(&ds));
- mapPtr->nativeName = (StringPtr) ckalloc(StrLength(nativeName) + 1);
- memcpy(mapPtr->nativeName, nativeName, StrLength(nativeName) + 1);
- Tcl_DStringFree(&ds);
- mapPtr++;
- i++;
- }
- FMDisposeFontFamilyIterator (&fontFamilyIterator);
-
- /*
- * Reorder FontNameMap so fonts with the preferred encodings are at
- * the front of the list. The relative order of fonts that all have
- * the same encoding is preserved. Fonts with unknown encodings get
- * stuck at the end.
- */
- newFontNameMap = (FontNameMap *) ckalloc(sizeof(FontNameMap) * (numFonts + 1));
- fontMapOffset = 0;
- for (i = 0; encodingList[i] != NULL; i++) {
- encoding = Tcl_GetEncoding(NULL, encodingList[i]);
- if (encoding == NULL) {
- continue;
- }
- for (j = 0; j < numFonts; j++) {
- if (encodings[j] == encoding) {
- newFontNameMap[fontMapOffset] = tmpFontNameMap[j];
- fontMapOffset++;
- Tcl_FreeEncoding(encodings[j]);
- tmpFontNameMap[j].utfName = NULL;
- }
- }
- Tcl_FreeEncoding(encoding);
- }
- for (i = 0; i < numFonts; i++) {
- if (tmpFontNameMap[i].utfName != NULL) {
- newFontNameMap[fontMapOffset] = tmpFontNameMap[i];
- fontMapOffset++;
- Tcl_FreeEncoding(encodings[i]);
- }
- }
- if (fontMapOffset != numFonts) {
- Tcl_Panic("TkpFontPkgInit: unexpected number of fonts");
- }
+ InitFontFamilies();
- mapPtr = &newFontNameMap[numFonts];
- mapPtr->utfName = NULL;
- mapPtr->nativeName = NULL;
- mapPtr->faceNum = 0;
+#if TK_MAC_COALESCE_LINE
+ Tcl_DStringInit(&currentLine);
+#endif
- ckfree((char *) tmpFontNameMap);
- ckfree((char *) encodings);
-
- gFontNameMap = newFontNameMap;
- }
+#ifdef TK_MAC_DEBUG_FONTS
+ fprintf(stderr, "tkMacOSXFont.c (ATSU version) intialized "
+ "(" __TIME__ ")\n");*/
+#endif
}
+
/*
*---------------------------------------------------------------------------
@@ -384,13 +286,13 @@ TkpFontPkgInit(mainPtr)
* Map a platform-specific native font name to a TkFont.
*
* Results:
- * The return value is a pointer to a TkFont that represents the
+ * 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.
+ * 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
@@ -405,43 +307,43 @@ TkpFontPkgInit(mainPtr)
TkFont *
TkpGetNativeFont(
Tk_Window tkwin, /* For display where font will be used. */
- CONST char *name) /* Platform-specific font name. */
+ const char * name) /* Platform-specific font name. */
{
- SInt16 family;
- MacFont *fontPtr;
-
- if (strcmp(name, "system") == 0) {
- family = GetSysFont();
- } else if (strcmp(name, "application") == 0) {
- family = GetAppFont();
+ FMFontFamily familyId;
+ MacFont * fontPtr;
+
+ if (strcmp(name, SYSTEMFONT_NAME) == 0) {
+ familyId = GetSysFont();
+ } else if (strcmp(name, APPLFONT_NAME) == 0) {
+ familyId = GetAppFont();
} else {
return NULL;
}
-
+
fontPtr = (MacFont *) ckalloc(sizeof(MacFont));
- InitFont(tkwin, family, 0, 0, fontPtr);
-
+ InitFont(tkwin, familyId, NULL, 0, 0, fontPtr);
+
return (TkFont *) fontPtr;
}
/*
*---------------------------------------------------------------------------
*
- * TkpGetFontFromAttributes --
+ * TkpGetFontFromAttributes --
*
- * Given a desired set of attributes for a font, find a font with
- * the closest matching attributes.
+ * Given a desired set of attributes for a font, find a font with the
+ * closest matching attributes.
*
* Results:
- * The return value is a pointer to a TkFont that represents the
- * font with the desired attributes. If a font with the desired
- * attributes could not be constructed, some other font will be
- * substituted automatically.
+ * The return value is a pointer to a TkFont that represents the font
+ * with the desired attributes. If a font with the desired attributes
+ * could not be constructed, some other font will be substituted
+ * automatically.
*
- * Every call to this procedure returns a new TkFont structure,
- * even if the specified attributes have already been seen before.
- * The caller should call TkpDeleteFont() to free the platform-
- * specific data when the font is no longer needed.
+ * Every call to this 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
@@ -452,65 +354,45 @@ TkpGetNativeFont(
*
*---------------------------------------------------------------------------
*/
+
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 faceNum, style;
- int i, j;
- CONST char *faceName, *fallback;
- char ***fallbacks;
- MacFont *fontPtr;
-
- /*
- * Algorithm to get the closest font to the one requested.
- *
- * try fontname
- * try all aliases for fontname
- * foreach fallback for fontname
- * try the fallback
- * try all aliases for the fallback
- */
-
- faceNum = 0;
- faceName = faPtr->family;
- if (faceName != NULL) {
- if (GetFamilyOrAliasNum(faceName, &faceNum) != 0) {
- goto found;
- }
- fallbacks = TkFontGetFallbacks();
- for (i = 0; fallbacks[i] != NULL; i++) {
- for (j = 0; (fallback = fallbacks[i][j]) != NULL; j++) {
- if (strcasecmp(faceName, fallback) == 0) {
- for (j = 0; (fallback = fallbacks[i][j]) != NULL; j++) {
- if (GetFamilyOrAliasNum(fallback, &faceNum)) {
- goto found;
- }
- }
- }
- break;
- }
+ short qdStyle;
+ FMFontFamily familyId;
+ 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;
}
}
-
- found:
- style = 0;
+
if (faPtr->weight != TK_FW_NORMAL) {
- style |= bold;
+ qdStyle |= bold;
}
if (faPtr->slant != TK_FS_ROMAN) {
- style |= italic;
+ qdStyle |= italic;
}
if (faPtr->underline) {
- style |= underline;
+ qdStyle |= underline;
}
if (tkFontPtr == NULL) {
fontPtr = (MacFont *) ckalloc(sizeof(MacFont));
@@ -518,8 +400,8 @@ TkpGetFontFromAttributes(
fontPtr = (MacFont *) tkFontPtr;
ReleaseFont(fontPtr);
}
- InitFont(tkwin, faceNum, faPtr->size, style, fontPtr);
-
+ InitFont(tkwin, familyId, name, faPtr->size, qdStyle, fontPtr);
+
return (TkFont *) fontPtr;
}
@@ -530,26 +412,23 @@ TkpGetFontFromAttributes(
*
* 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.
+ * released the fields of the TkFont that are used exclusively by the
+ * generic TkFont code.
*
* Results:
- * None.
+ * TkFont is deallocated.
*
* Side effects:
- * TkFont is deallocated.
+ * None.
*
*---------------------------------------------------------------------------
*/
void
TkpDeleteFont(
- TkFont *tkFontPtr) /* Token of font to be deleted. */
+ TkFont * tkFontPtr) /* Token of font to be deleted. */
{
- MacFont *fontPtr;
-
- fontPtr = (MacFont *) tkFontPtr;
- ReleaseFont(fontPtr);
+ ReleaseFont((MacFont *) tkFontPtr);
}
/*
@@ -557,8 +436,8 @@ 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
@@ -569,20 +448,13 @@ TkpDeleteFont(
*
*---------------------------------------------------------------------------
*/
-
+
void
TkpGetFontFamilies(
- Tcl_Interp *interp, /* Interp to hold result. */
+ Tcl_Interp * interp, /* Interp to hold result. */
Tk_Window tkwin) /* For display to query. */
-{
- FontNameMap *mapPtr;
- Tcl_Obj *resultPtr, *strPtr;
-
- resultPtr = Tcl_GetObjResult(interp);
- for (mapPtr = gFontNameMap; mapPtr->utfName != NULL; mapPtr++) {
- strPtr = Tcl_NewStringObj(mapPtr->utfName, -1);
- Tcl_ListObjAppendElement(NULL, resultPtr, strPtr);
- }
+{
+ Tcl_SetObjResult(interp,EnumFontFamilies());
}
/*
@@ -590,38 +462,28 @@ TkpGetFontFamilies(
*
* TkpGetSubFonts --
*
- * A function used by the testing package for querying the actual
+ * 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.
*
*-------------------------------------------------------------------------
*/
-
+
void
-TkpGetSubFonts(interp, tkfont)
- Tcl_Interp *interp; /* Interp to hold result. */
- Tk_Font tkfont; /* Font object to query. */
+TkpGetSubFonts(
+ Tcl_Interp * interp, /* Interp to hold result. */
+ Tk_Font tkfont) /* Font object to query. */
{
- int i;
- Tcl_Obj *resultPtr, *strPtr;
- MacFont *fontPtr;
- FontFamily *familyPtr;
- Str255 nativeName;
-
- resultPtr = Tcl_GetObjResult(interp);
- fontPtr = (MacFont *) tkfont;
- for (i = 0; i < fontPtr->numSubFonts; i++) {
- familyPtr = fontPtr->subFontArray[i].familyPtr;
- GetFontName(familyPtr->faceNum, nativeName);
- strPtr = Tcl_NewStringObj(GetUtfFaceName(nativeName), -1);
- Tcl_ListObjAppendElement(NULL, resultPtr, strPtr);
- }
+ /* 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. */
}
/*
@@ -629,166 +491,417 @@ TkpGetSubFonts(interp, tkfont)
*
* 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().
*
* 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.
*
*---------------------------------------------------------------------------
*/
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. */
{
- MacFont *fontPtr;
- SubFont *thisSubFontPtr, *lastSubFontPtr;
- CGrafPtr saveWorld;
- GDHandle saveDevice;
- int curX, curByte;
+ return TkpMeasureCharsInContext(
+ tkfont, source, numBytes, 0, numBytes, maxLength, flags, lengthPtr);
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * TkpMeasureCharsInContext --
+ *
+ * Determine the number of bytes from the string that will fit in the
+ * given horizontal span. The measurement is done under the assumption
+ * that TkpDrawCharsInContext() will be used to actually display the
+ * characters.
+ *
+ * This one is almost the same as Tk_MeasureChars(), but with access to
+ * all the characters on the line for context.
+ *
+ * Results:
+ * The return value is the number of bytes from source that
+ * fit into the span that extends from 0 to maxLength. *lengthPtr is
+ * filled with the x-coordinate of the right edge of the last
+ * character that did fit.
+ *
+ * Side effects:
+ * None.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+int
+TkpMeasureCharsInContext(
+ Tk_Font tkfont, /* Font in which characters will be drawn. */
+ const char * source, /* UTF-8 string to be displayed. Need not be
+ * '\0' terminated. */
+ int numBytes, /* Maximum number of bytes to consider from
+ * source string in all. */
+ int rangeStart, /* Index of first byte to measure. */
+ int rangeLength, /* Length of range to measure in bytes. */
+ int maxLength, /* If >= 0, maxLength specifies the longest
+ * permissible line length; don't consider any
+ * character that would cross this x-position.
+ * If < 0, then line length is unbounded and the
+ * flags argument is ignored. */
+ int flags, /* Various flag bits OR-ed together:
+ * TK_PARTIAL_OK means include the last char
+ * which only partially 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;
+ int ulen, urstart, urlen, urend;
+ Tcl_DString ucharBuffer;
+ DrawingContext drawingContext;
+
/*
- * According to "Inside Macintosh: Text", the Macintosh may
- * automatically substitute
- * ligatures or context-sensitive presentation forms when
- * measuring/displaying text within a font run. We cannot safely
- * measure individual characters and add up the widths w/o errors.
- * However, if we convert a range of text from UTF-8 to, say,
- * Shift-JIS, and get the offset into the Shift-JIS string as to
- * where a word or line break would occur, then can we map that
- * number back to UTF-8?
+ * Sanity checks.
*/
-
- fontPtr = (MacFont *) tkfont;
- GetGWorld(&saveWorld, &saveDevice);
- SetGWorld(gWorld, NULL);
-
- TextSize(fontPtr->size);
- TextFace(fontPtr->style);
+ if ((rangeStart < 0) || ((rangeStart+rangeLength) > numBytes)) {
+#ifdef TK_MAC_DEBUG
+ fprintf(stderr, "MeasureChars: bad parameters\n");
+#endif
+ *lengthPtr = 0;
+ return 0;
+ }
+
+ /*
+ * Get simple no-brainers out of the way.
+ */
+
+ if (rangeLength == 0 || (maxLength == 0 && !(flags & TK_AT_LEAST_ONE))) {
+#ifdef TK_MAC_DEBUG_FONTS
+ fflush(stdout);
+ fprintf(stderr, "measure: '%.*s', empty\n",
+ rangeLength, source+rangeStart);
+ fflush(stderr);
+#endif
+ *lengthPtr = 0;
+ return 0;
+ }
+
+#if TK_MAC_USE_QUARZ
+ TkMacOSXQuarzStartDraw(&drawingContext);
+#endif
+
+ Tcl_DStringInit(&ucharBuffer);
+ uchars = Tcl_UtfToUniCharDString(source, numBytes, &ucharBuffer);
+ ulen = Tcl_DStringLength(&ucharBuffer) / sizeof(uchars[0]);
+ TkMacOSXLayoutSetString(fontPtr, &drawingContext, uchars, ulen);
+
+ urstart = Tcl_NumUtfChars(source, rangeStart);
+ urlen = Tcl_NumUtfChars(source+rangeStart,rangeLength);
+ urend = urstart + urlen;
+
+ if (maxLength < 0) {
+
+ curX = MeasureStringWidth(fontPtr, urstart, urend);
+ curByte = rangeLength;
- lastSubFontPtr = &fontPtr->subFontArray[0];
-
- if (numBytes == 0) {
- curX = 0;
- curByte = 0;
- } else if (maxLength < 0) {
- CONST char *p, *end, *next;
- Tcl_UniChar ch;
- FontFamily *familyPtr;
- Tcl_DString runString;
-
- /*
- * A three step process:
- * 1. Find a contiguous range of characters that can all be
- * represented by a single screen font.
- * 2. Convert those chars to the encoding of that font.
- * 3. Measure converted chars.
- */
-
- curX = 0;
- end = source + numBytes;
- for (p = source; p < end; ) {
- next = p + Tcl_UtfToUniChar(p, &ch);
- thisSubFontPtr = FindSubFontForChar(fontPtr, ch, &lastSubFontPtr);
- if (thisSubFontPtr != lastSubFontPtr) {
- familyPtr = lastSubFontPtr->familyPtr;
- TextFont(familyPtr->faceNum);
- Tcl_UtfToExternalDString(familyPtr->encoding, source,
- p - source, &runString);
- curX += TextWidth(Tcl_DStringValue(&runString), 0,
- Tcl_DStringLength(&runString));
- Tcl_DStringFree(&runString);
- lastSubFontPtr = thisSubFontPtr;
- source = p;
- }
- p = next;
- }
- familyPtr = lastSubFontPtr->familyPtr;
- TextFont(familyPtr->faceNum);
- Tcl_UtfToExternalDString(familyPtr->encoding, source, p - source,
- &runString);
- curX += TextWidth(Tcl_DStringValue(&runString), 0,
- Tcl_DStringLength(&runString));
- Tcl_DStringFree(&runString);
- curByte = numBytes;
} else {
- CONST char *p, *end, *next, *sourceOrig;
- int widthLeft;
- Tcl_UniChar ch;
- CONST char *rest = NULL;
-
+
+ UniCharArrayOffset offset = 0;
+ OSStatus err;
+
/*
- * How many chars will fit in the space allotted?
+ * Have some upper limit on the size actually used.
*/
-
+
if (maxLength > 32767) {
maxLength = 32767;
}
-
- widthLeft = maxLength;
- sourceOrig = source;
- end = source + numBytes;
- for (p = source; p < end; p = next) {
- next = p + Tcl_UtfToUniChar(p, &ch);
- thisSubFontPtr = FindSubFontForChar(fontPtr, ch, &lastSubFontPtr);
- if (thisSubFontPtr != lastSubFontPtr) {
- if (p > source) {
- rest = BreakLine(lastSubFontPtr->familyPtr, flags, source,
- p - source, &widthLeft);
- flags &= ~TK_AT_LEAST_ONE;
- if (rest != NULL) {
- p = source;
- break;
+
+ 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 Int2Fixed(2), so we
+ * need at least Int2Fixed(3) (at least that's the current state
+ * of my knowledge).
+ */
+
+ err = ATSUBreakLine(
+ fontPtr->atsuLayout,
+ urstart,
+ Int2Fixed(maxLength+1),
+ false, /* !iUseAsSoftLineBreak */
+ &offset);
+
+ /*
+ * There is no way to signal an error from this routine, so we
+ * use predefined offset=urstart and otherwise ignore the
+ * possibility.
+ */
+
+ if ((err != noErr) && (err != kATSULineBreakInWord)) {
+#ifdef TK_MAC_DEBUG
+ fprintf(stderr, "ATSUBreakLine(): Error %d for '%.*s'\n",
+ (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 > 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 == urstart) || (uchars[offset] != ' ')) {
+ while ((offset < urend)
+ && (uchars[offset] != ' ')) {
+ offset++;
+ }
+ }
+ } else {
+
+ /*
+ * If we are not at the end of a word, we need to look
+ * backward.
+ */
+
+ if ((offset != urend) && (uchars[offset] != ' ')) {
+ while ((offset > urstart)
+ && (uchars[offset-1] != ' ')) {
+ offset--;
+ }
+ while ((offset > urstart)
+ && (uchars[offset-1] == ' ')) {
+ offset--;
+ }
}
}
- lastSubFontPtr = thisSubFontPtr;
- source = p;
}
}
-
- if (p > source) {
- rest = BreakLine(lastSubFontPtr->familyPtr, flags, source, p - source,
- &widthLeft);
+
+ if (offset > 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 <= urend)) {
+
+ UniCharArrayOffset lastOffset = offset;
+ UniCharArrayOffset nextoffset;
+ int lastX = -1;
+ int wantonemorechar = -1; /* undecided */
+
+ while (offset <= 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 == 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 >= 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
+ fprintf(stderr, "ATSUNextCursorPosition(): "
+ "Error %d\n", (int) err);
+#endif
+ break;
+ }
+ if (nextoffset <= offset) {
+#ifdef TK_MAC_DEBUG
+ 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 (rest == NULL) {
- curByte = numBytes;
- } else {
- curByte = rest - sourceOrig;
+
+ if (curX < 0) {
+ if (flags & TK_ISOLATE_END) {
+ TkMacOSXLayoutSetString(fontPtr, &drawingContext,
+ uchars, offset);
+ }
+ curX = MeasureStringWidth(fontPtr, urstart, offset);
}
- curX = maxLength - widthLeft;
+
+ curByte = Tcl_UtfAtIndex(source, offset) - source;
+ curByte -= rangeStart;
}
- SetGWorld(saveWorld, saveDevice);
+ Tcl_DStringFree(&ucharBuffer);
+
+#if TK_MAC_USE_QUARZ
+ TkMacOSXQuarzEndDraw(&drawingContext);
+#endif
+
+#ifdef TK_MAC_DEBUG_FONTS
+ fflush(stdout);
+ fprintf(stderr, "measure: '%.*s', maxpix=%d, -> width=%d, bytes=%d, "
+ "flags=%s%s%s%s\n",
+ rangeLength, source+rangeStart, maxLength, curX, curByte,
+ flags & TK_PARTIAL_OK ? "partialOk " : "",
+ flags & TK_WHOLE_WORDS ? "wholeWords " : "",
+ flags & TK_AT_LEAST_ONE ? "atLeastOne " : "",
+ flags & TK_ISOLATE_END ? "isolateEnd " : "");
+ fflush(stderr);
+#endif
*lengthPtr = curX;
return curByte;
@@ -797,392 +910,606 @@ Tk_MeasureChars(
/*
*---------------------------------------------------------------------------
*
- * BreakLine --
+ * Tk_DrawChars --
*
- * Determine where the given line of text should be broken so that it
- * fits in the specified range. Before calling this function, the
- * font values and graphics port must be set.
+ * 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().
*
* Results:
- * The return value is NULL if the specified range is larger that the
- * space the text needs, and *widthLeftPtr is filled with how much
- * space is left in the range after measuring the whole text buffer.
- * Otherwise, the return value is a pointer into the text buffer that
- * indicates where the line should be broken (up to, but not including
- * that character), and *widthLeftPtr is filled with how much space is
- * left in the range after measuring up to that character.
+ *
+ * None.
*
* Side effects:
- * None.
+ *
+ * Information gets drawn on the screen.
*
*---------------------------------------------------------------------------
*/
-
-static CONST char *
-BreakLine(
- FontFamily *familyPtr, /* FontFamily that describes the font values
- * that are already selected into the graphics
- * port. */
- 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. */
- 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 *widthLeftPtr) /* On input, specifies size of range into
- * which characters from source buffer should
- * be fit. On output, filled with how much
- * space is left after fitting as many
- * characters as possible into the range.
- * Result may be negative if TK_AT_LEAST_ONE
- * was specified in the flags argument. */
-{
- Fixed pixelWidth, widthLeft;
- StyledLineBreakCode breakCode;
- Tcl_DString runString;
- long textOffset;
- Boolean leadingEdge;
- Point point;
- int charOffset, thisCharWasDoubleByte;
- char *p, *end, *typeTable;
-
- TextFont(familyPtr->faceNum);
- Tcl_UtfToExternalDString(familyPtr->encoding, source, numBytes,
- &runString);
- pixelWidth = Int2Fixed(*widthLeftPtr) + 1;
- if (flags & TK_WHOLE_WORDS) {
- textOffset = (flags & TK_AT_LEAST_ONE);
- widthLeft = pixelWidth;
- breakCode = StyledLineBreak(Tcl_DStringValue(&runString),
- Tcl_DStringLength(&runString), 0, Tcl_DStringLength(&runString),
- 0, &widthLeft, &textOffset);
- if (breakCode != smBreakOverflow) {
- /*
- * StyledLineBreak includes all the space characters at the end of
- * line that we want to suppress.
- */
-
- textOffset = VisibleLength(Tcl_DStringValue(&runString), textOffset);
- goto getoffset;
- }
- } else {
- point.v = 1;
- point.h = 1;
- textOffset = PixelToChar(Tcl_DStringValue(&runString),
- Tcl_DStringLength(&runString), 0, pixelWidth, &leadingEdge,
- &widthLeft, smOnlyStyleRun, point, point);
- if (Fixed2Int(widthLeft) < 0) {
- goto getoffset;
- }
- }
- *widthLeftPtr = Fixed2Int(widthLeft);
- Tcl_DStringFree(&runString);
- return NULL;
- /*
- * The conversion routine that converts UTF-8 to the target encoding
- * must map one UTF-8 character to exactly one encoding-specific
- * character, so that the following algorithm works:
- *
- * 1. Get byte offset of where line should be broken.
- * 2. Get char offset corresponding to that byte offset.
- * 3. Map that char offset to byte offset in UTF-8 string.
- */
-
- getoffset:
- thisCharWasDoubleByte = 0;
- if (familyPtr->isMultiByteFont == 0) {
- charOffset = textOffset;
- } else {
- charOffset = 0;
- typeTable = familyPtr->typeTable;
-
- p = Tcl_DStringValue(&runString);
- end = p + textOffset;
- thisCharWasDoubleByte = typeTable[*((unsigned char *) p)];
- for ( ; p < end; p++) {
- thisCharWasDoubleByte = typeTable[*((unsigned char *) p)];
- p += thisCharWasDoubleByte;
- charOffset++;
- }
- }
-
- if ((flags & TK_WHOLE_WORDS) == 0) {
- if ((flags & TK_PARTIAL_OK) && (leadingEdge != 0)) {
- textOffset += thisCharWasDoubleByte;
- textOffset++;
- charOffset++;
- } else if (((flags & TK_PARTIAL_OK) == 0) && (leadingEdge == 0)) {
- textOffset -= thisCharWasDoubleByte;
- textOffset--;
- charOffset--;
- }
- }
- if ((textOffset == 0) && (Tcl_DStringLength(&runString) > 0)
- && (flags & TK_AT_LEAST_ONE)) {
- p = Tcl_DStringValue(&runString);
- textOffset += familyPtr->typeTable[*((unsigned char *) p)];
- textOffset++;
- charOffset++;
- }
- *widthLeftPtr = Fixed2Int(pixelWidth)
- - TextWidth(Tcl_DStringValue(&runString), 0, textOffset);
- Tcl_DStringFree(&runString);
- return Tcl_UtfAtIndex(source, charOffset);
+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. */
+{
+ TkpDrawCharsInContext(display, drawable, gc, tkfont, source, numBytes,
+ 0, numBytes, x, y);
}
+
/*
*---------------------------------------------------------------------------
*
- * Tk_DrawChars --
+ * TkpDrawCharsInContext --
*
- * Draw a string of characters on the screen.
+ * Draw a string of characters on the screen like Tk_DrawChars(), with
+ * access to all the characters on the line for context.
*
* Results:
- * None.
+ * None.
*
* Side effects:
- * Information gets drawn on the screen.
+ * Information gets drawn on the screen.
+ *
+ * Todo:
+ *
+ * We could try to implement a correct stipple algorithm.
+ *
+ * The fiddling with QD GraphPorts can be replaced with just working
+ * with the Quarz CGContext (see TkMacOSXQuarzStartDraw()), once we
+ * decide to stick to Quarz and really forget about QD drawing in here.
*
*---------------------------------------------------------------------------
*/
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
- * string when drawing. */
+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. */
{
- MacFont *fontPtr;
- MacDrawable *macWin;
+ const MacFont * fontPtr;
+ MacDrawable * macWin;
RGBColor macColor, origColor;
GWorldPtr destPort;
CGrafPtr saveWorld;
GDHandle saveDevice;
- short txFont, txFace, txSize;
BitMapPtr stippleMap;
- Rect portRect;
+ Rect portRect;
- fontPtr = (MacFont *) tkfont;
+ fontPtr = (const MacFont *) tkfont;
macWin = (MacDrawable *) drawable;
destPort = TkMacOSXGetDrawablePort(drawable);
GetPortBounds(destPort, &portRect);
GetGWorld(&saveWorld, &saveDevice);
SetGWorld(destPort, NULL);
-
+
TkMacOSXSetUpClippingRgn(drawable);
TkMacOSXSetUpGraphicsPort(gc, destPort);
- txFont = GetPortTextFont(destPort);
- txFace = GetPortTextFace(destPort);
- txSize = GetPortTextSize(destPort);
GetForeColor(&origColor);
-
+
if ((gc->fill_style == FillStippled
|| gc->fill_style == FillOpaqueStippled)
&& gc->stipple != None) {
+
Pixmap pixmap;
GWorldPtr bufferPort;
Pattern white;
stippleMap = TkMacOSXMakeStippleMap(drawable, gc->stipple);
- pixmap = Tk_GetPixmap(display, drawable,
+ pixmap = Tk_GetPixmap(display, drawable,
stippleMap->bounds.right, stippleMap->bounds.bottom, 0);
-
+
bufferPort = TkMacOSXGetDrawablePort(pixmap);
SetGWorld(bufferPort, NULL);
-
- if (TkSetMacColor(gc->foreground, &macColor) == true) {
+
+ if (TkSetMacColor(gc->foreground, &macColor)) {
RGBForeColor(&macColor);
}
GetQDGlobalsWhite(&white);
ShowPen();
FillRect(&stippleMap->bounds, &white);
- MultiFontDrawText(fontPtr, source, numBytes, 0, 0);
+ MacFontDrawText(fontPtr, source, numBytes, rangeStart, rangeLength,
+ 0, 0);
HidePen();
SetGWorld(destPort, NULL);
- CopyDeepMask(GetPortBitMapForCopyBits(bufferPort), stippleMap,
+
+ 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
+
+ /*
+ * 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) == true) {
+ } else {
+ if (TkSetMacColor(gc->foreground, &macColor)) {
RGBForeColor(&macColor);
}
ShowPen();
- MultiFontDrawText(fontPtr, source, numBytes, macWin->xOff + x,
- macWin->yOff + y);
+ MacFontDrawText(fontPtr, source, numBytes, rangeStart, rangeLength,
+ macWin->xOff + x, macWin->yOff + y);
HidePen();
}
- TextFont(txFont);
- TextSize(txSize);
- TextFace(txFace);
RGBForeColor(&origColor);
+
SetGWorld(saveWorld, saveDevice);
}
+#if TK_MAC_USE_QUARZ
+/*
+ *-------------------------------------------------------------------------
+ *
+ * TkMacOSXQuarzStartDraw --
+ *
+ * Setup a Quarz CGContext from the current QD GraphPort for use in
+ * drawing or measuring.
+ *
+ * Results:
+ *
+ * A CGContext is allocated, configured and returned in
+ * drawingContextPtr. Also drawingContextPtr->portRect is filled in.
+ *
+ * Side effects:
+ *
+ * None.
+ *
+ * Assumptions:
+ *
+ * The current QD GraphPort contains all the data necessary. This is
+ * clearly the case for the actual drawing, but not so clear for
+ * measuring. OTOH for measuring the specific parameters are not really
+ * interesting and the GraphPort is not changed either. The
+ * availability of a CGContext may be important for the measuring
+ * process though.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+void
+TkMacOSXQuarzStartDraw(
+ DrawingContext * drawingContextPtr) /* Quarz context data filled in
+ * by this function. */
+{
+ GDHandle currentDevice;
+ RgnHandle clipRgn;
+ RGBColor qdColor;
+ double red, green, blue;
+
+ /*
+ * Create the CGContext.
+ */
+
+ GetGWorld(&drawingContextPtr->graphPort, &currentDevice);
+ QDBeginCGContext(
+ drawingContextPtr->graphPort,
+ &drawingContextPtr->cgContext);
+ CGContextSaveGState(
+ drawingContextPtr->cgContext);
+
+ /*
+ * Sync some parameters, most notably the clipping region. I'm not sure
+ * if that part of the code is right, as the coordinate systems of the
+ * graphPort and the cgContext are different.
+ */
+
+ SyncCGContextOriginWithPort(
+ drawingContextPtr->cgContext, drawingContextPtr->graphPort);
+ GetPortBounds(drawingContextPtr->graphPort, &drawingContextPtr->portRect);
+
+ clipRgn = NewRgn();
+ GetPortClipRegion(drawingContextPtr->graphPort, clipRgn);
+ ClipCGContextToRegion(
+ drawingContextPtr->cgContext,
+ &drawingContextPtr->portRect, clipRgn);
+ DisposeRgn(clipRgn);
+
+ /*
+ * 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(&qdColor);
+ red = (double) qdColor.red / (double) 0xFFFF;
+ green = (double) qdColor.green / (double) 0xFFFF;
+ blue = (double) qdColor.blue / (double) 0xFFFF;
+ CGContextSetRGBFillColor(
+ drawingContextPtr->cgContext, red, green, blue, 1.0);
+/* CGContextSetRGBStrokeColor( */
+/* drawingContextPtr->cgContext, red, green, blue, 1.0); */
+}
+#endif /* TK_MAC_USE_QUARZ */
+
+#if TK_MAC_USE_QUARZ
+/*
+ *-------------------------------------------------------------------------
+ *
+ * TkMacOSXQuarzEndDraw --
+ *
+ * Free the Quarz CGContext in drawingContextPtr.
+ *
+ * Results:
+ *
+ * The CGContext is de-allocated. drawingContextPtr->cgContext will be
+ * invalid after this.
+ *
+ * Side effects:
+ *
+ * None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+void
+TkMacOSXQuarzEndDraw(
+ DrawingContext * drawingContextPtr)
+{
+ CGContextRestoreGState(
+ drawingContextPtr->cgContext);
+ QDEndCGContext(
+ drawingContextPtr->graphPort,
+ &drawingContextPtr->cgContext);
+}
+#endif /* TK_MAC_USE_QUARZ */
+
/*
*-------------------------------------------------------------------------
*
- * MultiFontDrawText --
+ * MacFontDrawText --
*
- * Helper function for Tk_DrawChars. Draws characters, using the
- * various screen fonts in fontPtr to draw multilingual characters.
- * Note: No bidirectional support.
+ * Helper function for Tk_DrawChars. Draws characters, using the
+ * screen font in fontPtr to draw multilingual characters.
*
* Results:
* None.
*
* Side effects:
- * Information gets drawn on the screen.
- * Contents of fontPtr may be modified if more subfonts were loaded
- * in order to draw all the multilingual characters in the given
- * string.
+ * Information gets drawn on the screen.
*
*-------------------------------------------------------------------------
*/
static void
-MultiFontDrawText(
- MacFont *fontPtr, /* Contains set of fonts to use when drawing
+MacFontDrawText(
+ const MacFont * fontPtr, /* Contains font to use when drawing
* following string. */
- CONST char *source, /* Potentially multilingual UTF-8 string. */
+ const char * source, /* Potentially multilingual UTF-8 string. */
int numBytes, /* Length of string in bytes. */
- int x, int y) /* Coordinates at which to place origin *
- * of string when drawing. */
+ 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. */
{
- SubFont *thisSubFontPtr, *lastSubFontPtr;
- FontFamily *familyPtr;
+ Fixed fx, fy;
+ int ulen, urstart, urlen;
+ const UniChar * uchars;
+ int lineOffset;
+ DrawingContext drawingContext;
+ OSStatus err;
+
+#if !TK_MAC_COALESCE_LINE
Tcl_DString runString;
- CONST char *p, *end, *next;
- Tcl_UniChar ch;
-
- TextSize(fontPtr->size);
- TextFace(fontPtr->style);
-
- lastSubFontPtr = &fontPtr->subFontArray[0];
-
- end = source + numBytes;
- for (p = source; p < end; ) {
- next = p + Tcl_UtfToUniChar(p, &ch);
- thisSubFontPtr = FindSubFontForChar(fontPtr, ch, &lastSubFontPtr);
- if (thisSubFontPtr != lastSubFontPtr) {
- if (p > source) {
- familyPtr = lastSubFontPtr->familyPtr;
- TextFont(familyPtr->faceNum);
- Tcl_UtfToExternalDString(familyPtr->encoding, source,
- p - source, &runString);
- MoveTo((short) x, (short) y);
- DrawText(Tcl_DStringValue(&runString), 0,
- Tcl_DStringLength(&runString));
- x += TextWidth(Tcl_DStringValue(&runString), 0,
- Tcl_DStringLength(&runString));
- Tcl_DStringFree(&runString);
- source = p;
- }
- lastSubFontPtr = thisSubFontPtr;
- }
- p = next;
- }
- if (p > source) {
- familyPtr = lastSubFontPtr->familyPtr;
- TextFont(familyPtr->faceNum);
- Tcl_UtfToExternalDString(familyPtr->encoding, source,
- p - source, &runString);
- MoveTo((short) x, (short) y);
- DrawText(Tcl_DStringValue(&runString), 0,
- Tcl_DStringLength(&runString));
- Tcl_DStringFree(&runString);
+#endif
+
+
+#if TK_MAC_USE_QUARZ
+ TkMacOSXQuarzStartDraw(&drawingContext);
+
+ /*
+ * Turn the y coordinate upside-down for Quarz drawing. We would have
+ * liked to just use a CTM transform in the CGContext, but than we get
+ * upside-down text, so doing it that way gets more painfull than to just
+ * hack around the problem right here.
+ */
+
+ y = drawingContext.portRect.bottom - drawingContext.portRect.top - y;
+ fy = Int2Fixed(y);
+#else
+ fy = Int2Fixed(y);
+#endif
+
+
+#if TK_MAC_COALESCE_LINE
+ UpdateLineBuffer(
+ fontPtr, &drawingContext, source, numBytes, x, y, &lineOffset);
+
+ fx = Int2Fixed(currentLeft);
+
+ uchars = (const Tcl_UniChar*) Tcl_DStringValue(&currentLine);
+ ulen = Tcl_DStringLength(&currentLine) / sizeof(uchars[0]);
+#else
+ lineOffset = 0;
+ fx = Int2Fixed(x);
+
+ Tcl_DStringInit(&runString);
+ uchars = Tcl_UtfToUniCharDString(source, numBytes, &runString);
+ ulen = Tcl_DStringLength(&runString) / sizeof(uchars[0]);
+
+ TkMacOSXLayoutSetString(fontPtr, &drawingContext, uchars, ulen);
+#endif
+
+ urstart = Tcl_NumUtfChars(source, rangeStart);
+ urlen = Tcl_NumUtfChars(source+rangeStart,rangeLength);
+
+ err = ATSUDrawText(
+ fontPtr->atsuLayout,
+ lineOffset+urstart, urlen,
+ fx, fy);
+ if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+ fprintf(stderr, "ATSUDrawText(): Error %d\n", (int) err);
+#endif
}
+
+#if !TK_MAC_COALESCE_LINE
+ Tcl_DStringFree(&runString);
+#endif
+
+#if TK_MAC_USE_QUARZ
+ TkMacOSXQuarzEndDraw(&drawingContext);
+#endif
}
+
/*
*---------------------------------------------------------------------------
*
- * TkMacOSXIsCharacterMissing --
+ * MeasureStringWidth --
*
- * Given a tkFont and a character determines whether the character has
- * a glyph defined in the font or not. Note that this is potentially
- * not compatible with Mac OS 8 as it looks at the font handle
- * structure directly. Looks into the character array of the font
- * handle to determine whether the glyph is defined or not.
+ * Low-level measuring of strings.
*
* Results:
- * Returns a 1 if the character is missing, a 0 if it is not.
+ *
+ * The width of the string in pixels.
*
* Side effects:
- * None.
+ *
+ * None.
+ *
+ * Assumptions:
+ *
+ * fontPtr->atsuLayout is setup with the actual string data to measure.
*
*---------------------------------------------------------------------------
*/
-
-int
-TkMacOSXIsCharacterMissing(
- Tk_Font tkfont, /* The font we are looking in. */
- unsigned int searchChar) /* The character we are looking for. */
+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. */
{
-/*
- * For some reason, FMSwapFont always returns a NULL font handle under OS X
- * Until we figure this one out, return 0;
- */
-#ifdef MAC_OSX_TK
- return 0;
-#else
- MacFont *fontPtr = (MacFont *) tkfont;
- FMInput fm;
- FontRec **fontRecHandle;
- FMOutPtr fmOutPtr;
-
-
- fm.family = fontPtr->subFontArray[0].familyPtr->faceNum;
- fm.size = fontPtr->size;
- fm.face = fontPtr->style;
- fm.needBits = 0;
- fm.device = 0;
- fm.numer.h = fm.numer.v = fm.denom.h = fm.denom.v = 1;
-
- fmOutPtr = FMSwapFont(&fm);
- fprintf(stderr,"fmOut %08x, handle %08x\n", (int)fmOutPtr, fmOutPtr->fontHandle);
-
-#if !defined(UNIVERSAL_INTERFACES_VERSION) || (UNIVERSAL_INTERFACES_VERSION < 0x0300)
- fontRecHandle = (FontRec **) FMSwapFont(&fm)->fontResult;
-#else
- fontRecHandle = (FontRec **) FMSwapFont(&fm)->fontHandle;
+#if TK_MAC_USE_MEASURETEXTIMAGE
+
+ /*
+ * This implementation of measuring via ATSUMeasureTextImage() 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".
+ *
+ * Instead ATSUMeasureTextImage() *does* include these "extra pixels."
+ * Also ATSUMeasureTextImage() has the important property that it will
+ * measure 'a' and 'a-umlaut' the same, even when expressed as decomposed
+ * characters, while the other implementations use some strange
+ * interpolation instead, possibly to generate some cute intermediate
+ * cursor positions automatically.
+ */
+
+ OSStatus err;
+ Rect size;
+
+ size.left = size.right = 0;
+ err = ATSUMeasureTextImage(
+ fontPtr->atsuLayout,
+ start, end-start,
+ 0, 0,
+ &size);
+ if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+ fprintf(stderr, "ATSUMeasureTextImage(): Error %d\n", (int) err);
#endif
- return *(short *) ((long) &(*fontRecHandle)->owTLoc
- + ((long)((*fontRecHandle)->owTLoc + searchChar
- - (*fontRecHandle)->firstChar) * sizeof(short))) == -1;
+ }
+
+ return size.right - size.left;
+
+#elif TK_MAC_USE_GETGLYPHBOUNDS
+
+ /*
+ * 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".
+ *
+ * Instead I would assume that ATSUGetGlyphBounds() *does* include these
+ * "extra pixels." Still this implementation works slightly better with
+ * the main page of demos/widgets than the one via
+ * ATSUOffsetToPosition(), so I prefer this one if we use
+ * TK_MAC_COALESCE_LINE locally.
+ */
+
+ ATSTrapezoid bounds;
+ ItemCount numBounds;
+ OSStatus err;
+
+ if (end <= start) {
+ return 0;
+ }
+
+ bounds.upperRight.x = bounds.upperLeft.x = 0;
+ err = ATSUGetGlyphBounds(
+ fontPtr->atsuLayout,
+ 0, 0,
+ start, end-start,
+ kATSUseDeviceOrigins,
+ 1, &bounds, &numBounds);
+#ifdef TK_MAC_DEBUG
+ if (err != noErr) {
+ fprintf(stderr, "ATSUGetGlyphBounds(): Error %d\n", (int) err);
+ } else if (numBounds < 1) {
+ fprintf(stderr, "ATSUGetGlyphBounds(): No output\n");
+ } else if (numBounds > 1) {
+ fprintf(stderr, "ATSUGetGlyphBounds(): More output\n");
+ }
#endif
+
+ return Fixed2Int(bounds.upperRight.x - bounds.upperLeft.x);
+
+#else /* ! TK_MAC_USE_GETGLYPHBOUNDS */
+
+ /*
+ * This implementation via ATSUOffsetToPosition() is in principle the
+ * right thing to do. But with TK_MAC_COALESCE_LINE and this, the
+ * "tremble and shiver" (see discussion of TK_MAC_COALESCE_LINE at the
+ * top) on the main page of demos/widgets is quite a bit more noticable
+ * than with the ATSUGetGlyphBounds() implementation.
+ */
+
+ ATSUCaret mainCaretStart, secCaretStart, mainCaretEnd, secCaretEnd;
+ Boolean isSplit;
+ OSStatus err;
+
+ if (end <= start) {
+ return 0;
+ }
+
+ mainCaretStart.fX = mainCaretEnd.fX = 0;
+
+ if (start != 0) {
+ err = ATSUOffsetToPosition(
+ fontPtr->atsuLayout,
+ start, false,
+ &mainCaretStart, &secCaretStart, &isSplit);
+ if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+ fprintf(stderr, "ATSUOffsetToPosition(): Error %d\n", (int) err);
+#endif
+ }
+ }
+
+ if (end != 0) {
+ err = ATSUOffsetToPosition(
+ fontPtr->atsuLayout,
+ end, false,
+ &mainCaretEnd, &secCaretEnd, &isSplit);
+ if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+ fprintf(stderr, "ATSUOffsetToPosition(): Error %d\n", (int) err);
+#endif
+ }
+ }
+
+ return Fixed2Int(mainCaretEnd.fX - mainCaretStart.fX);
+
+#endif /* ? TK_MAC_USE_GETGLYPHBOUNDS */
+}
+
+#if TK_MAC_COALESCE_LINE
+/*
+ *-------------------------------------------------------------------------
+ *
+ * UpdateLineBuffer --
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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 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;
+ } else {
+ *offset = Tcl_DStringLength(&currentLine) / 2;
+ }
+
+ Tcl_UtfToUniCharDString(source, numBytes, &currentLine);
+ uchars = (const Tcl_UniChar*) Tcl_DStringValue(&currentLine);
+ ulen = Tcl_DStringLength(&currentLine) / sizeof(*uchars);
+ TkMacOSXLayoutSetString(fontPtr, drawingContextPtr, uchars, ulen);
+ currentRight = x + MeasureStringWidth(fontPtr, *offset, ulen);
+
+ return uchars;
}
+#endif /* TK_MAC_COALESCE_LINE */
/*
*---------------------------------------------------------------------------
@@ -1190,12 +1517,12 @@ TkMacOSXIsCharacterMissing(
* InitFont --
*
* Helper for TkpGetNativeFont() and TkpGetFontFromAttributes().
- * Initializes the memory for a MacFont that wraps the platform-specific
- * data.
+ * 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.
@@ -1204,984 +1531,1105 @@ TkMacOSXIsCharacterMissing(
* Memory allocated.
*
*---------------------------------------------------------------------------
- */
+ */
static void
InitFont(
- Tk_Window tkwin, /* For display where font will be used. */
- int faceNum, /* Macintosh font number. */
- int size, /* Point size for Macintosh font. */
- int style, /* Macintosh 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. */
{
- Str255 nativeName;
+ OSStatus err;
FontInfo fi;
- TkFontAttributes *faPtr;
- TkFontMetrics *fmPtr;
- CGrafPtr saveWorld;
- GDHandle saveDevice;
- short pixels;
+ TkFontAttributes * faPtr;
+ TkFontMetrics * fmPtr;
+ short points;
+ int iWidth, wWidth;
if (size == 0) {
- size = -GetDefFontSize();
+ size = GetDefFontSize();
}
- pixels = (short) TkFontGetPixels(tkwin, size);
-
- GetGWorld(&saveWorld, &saveDevice);
- SetGWorld(gWorld, NULL);
- TextFont(faceNum);
-
-
- TextSize(pixels);
- TextFace(style);
+ points = (short) TkFontGetPoints(tkwin, size);
+
+ err = FetchFontInfo(familyId, points, qdStyle, &fi);
+ if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+ fprintf(stderr, "FetchFontInfo(): Error %d\n", (int) err);
+#endif
+ }
+
+ 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
+ fprintf(stderr, "Font family '%s': Not found\n", name);
+#endif
+ }
+ }
+ }
+
+ fontPtr->font.fid = (Font) fontPtr;
- GetFontInfo(&fi);
- GetFontName(faceNum, nativeName);
- fontPtr->font.fid = (Font) fontPtr;
-
faPtr = &fontPtr->font.fa;
- faPtr->family = GetUtfFaceName(nativeName);
- faPtr->size = TkFontGetPoints(tkwin, size);
- faPtr->weight = (style & bold) ? TK_FW_BOLD : TK_FW_NORMAL;
- faPtr->slant = (style & italic) ? TK_FS_ITALIC : TK_FS_ROMAN;
- faPtr->underline = ((style & underline) != 0);
+ faPtr->family = familyName;
+ faPtr->size = points;
+ faPtr->weight = (qdStyle & bold) ? TK_FW_BOLD : TK_FW_NORMAL;
+ faPtr->slant = (qdStyle & italic) ? TK_FS_ITALIC : TK_FS_ROMAN;
+ faPtr->underline = ((qdStyle & underline) != 0);
faPtr->overstrike = 0;
-
+
fmPtr = &fontPtr->font.fm;
- fmPtr->ascent = fi.ascent;
- fmPtr->descent = fi.descent;
+
+ /*
+ * 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;
+ fmPtr->descent = fi.descent;
fmPtr->maxWidth = fi.widMax;
- fmPtr->fixed = (CharWidth('i') == CharWidth('w'));
-
- fontPtr->size = pixels;
- fontPtr->style = (short) style;
-
- fontPtr->numSubFonts = 1;
- fontPtr->subFontArray = fontPtr->staticSubFonts;
- InitSubFont(fontPtr, faceNum, &fontPtr->subFontArray[0]);
- SetGWorld(saveWorld, saveDevice);
+ fontPtr->qdFont = familyId;
+ fontPtr->qdSize = points;
+ fontPtr->qdStyle = (short) qdStyle;
+
+ InitATSUObjects(
+ familyId, points, qdStyle,
+ &fontPtr->atsuFontId, &fontPtr->atsuLayout, &fontPtr->atsuStyle);
+
+ Tk_MeasureChars((Tk_Font)fontPtr, "i", 1, -1, 0, &iWidth);
+ Tk_MeasureChars((Tk_Font)fontPtr, "w", 1, -1, 0, &wWidth);
+ fmPtr->fixed = iWidth == wWidth;
+
+ SetFontFeatures(fontPtr->atsuFontId, fmPtr->fixed, fontPtr->atsuStyle);
+
+ AdjustFontHeight(fontPtr);
}
/*
- *-------------------------------------------------------------------------
+ *---------------------------------------------------------------------------
*
- * ReleaseFont --
- *
- * Called to release the Macintosh-specific contents of a TkFont.
- * The caller is responsible for freeing the memory used by the
- * font itself.
+ * InitATSUObjects --
+ *
+ * Helper for InitFont(). Initializes the ATSU data handles for a
+ * MacFont.
*
* Results:
- * None.
+ *
+ * Sets up all we know and can do at this point in time in fontIdPtr,
+ * layoutPtr and stylePtr.
*
* Side effects:
- * Memory is freed.
+ *
+ * Allocates data structures inside of ATSU.
*
*---------------------------------------------------------------------------
*/
-
+
static void
-ReleaseFont(
- MacFont *fontPtr) /* The font to delete. */
+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. */
{
- int i;
+ OSStatus err;
+ FMFontStyle stylesDone, stylesLeft;
+
+ /*
+ * Defaults in case of error.
+ */
- for (i = 0; i < fontPtr->numSubFonts; i++) {
- ReleaseSubFont(&fontPtr->subFontArray[i]);
+ *fontIdPtr = GetAppFont();
+ *stylePtr = 0;
+ *layoutPtr = 0;
+
+ /*
+ * Generate a font id from family id and QD style bits.
+ */
+
+ err = FMGetFontFromFontFamilyInstance(
+ familyId, qdStyles, fontIdPtr, &stylesDone);
+ if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+ fprintf(stderr, "FMGetFontFromFontFamilyInstance(): Error %d\n",
+ (int) err);
+#endif
}
- if (fontPtr->subFontArray != fontPtr->staticSubFonts) {
- ckfree((char *) fontPtr->subFontArray);
+
+ /*
+ * We see what style bits are left and tell ATSU to synthesize what's
+ * left like QD does it.
+ */
+
+ stylesLeft = qdStyles & ~(unsigned)stylesDone;
+
+ /*
+ * Create the style and set its attributes.
+ */
+
+ err = ATSUCreateStyle(stylePtr);
+ if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+ fprintf(stderr, "ATSUCreateStyle(): Error %d\n", (int) err);
+#endif
+ }
+ InitATSUStyle(*fontIdPtr, ptSize, stylesLeft, *stylePtr);
+
+ /*
+ * 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);
+ if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+ fprintf(stderr, "ATSUCreateTextLayout(): Error %d\n", (int) err);
+#endif
}
+ /*InitATSULayout(*layoutPtr);*/
}
/*
- *-------------------------------------------------------------------------
+ *---------------------------------------------------------------------------
*
- * InitSubFont --
+ * InitATSUStyle --
*
- * Wrap a screen font and load the FontFamily that represents
- * it. Used to prepare a SubFont so that characters can be mapped
- * from UTF-8 to the charset of the font.
+ * Helper for InitATSUObjects(). Initializes the ATSU style for a
+ * MacFont.
*
* Results:
- * The subFontPtr is filled with information about the font.
+ *
+ * Sets up all parameters needed for an ATSU style.
*
* Side effects:
- * None.
*
- *-------------------------------------------------------------------------
+ * Allocates data structures for the style inside of ATSU.
+ *
+ *---------------------------------------------------------------------------
*/
static void
-InitSubFont(
- CONST MacFont *fontPtr, /* Font object in which the SubFont will be
- * used. */
- int faceNum, /* The font number. */
- SubFont *subFontPtr) /* Filled with SubFont constructed from
- * above attributes. */
+InitATSUStyle(
+ ATSUFontID fontId, /* The font id to use. */
+ short ptSize, short qdStyles, /* Additional font parameters. */
+ ATSUStyle style) /* The style handle to configure. */
{
- subFontPtr->familyPtr = AllocFontFamily(fontPtr, faceNum);
- subFontPtr->fontMap = subFontPtr->familyPtr->fontMap;
+ /*
+ * Attributes for the style.
+ */
+
+ Fixed fsize = Int2Fixed(ptSize);
+ Boolean
+ isBold = (qdStyles&bold) != 0,
+ isUnderline = (qdStyles&underline) != 0,
+ isItalic = (qdStyles&italic) != 0;
+
+ ATSStyleRenderingOptions options =
+ TkMacOSXAntialiasedTextEnabled == -1 ? kATSStyleNoOptions :
+ TkMacOSXAntialiasedTextEnabled == 0 ? kATSStyleNoAntiAliasing :
+ kATSStyleApplyAntiAliasing;
+
+ static const ATSUAttributeTag styleTags[] = {
+ kATSUFontTag, kATSUSizeTag,
+ kATSUQDBoldfaceTag, kATSUQDItalicTag, kATSUQDUnderlineTag,
+ kATSUStyleRenderingOptionsTag,
+ };
+ static const ByteCount styleSizes[] = {
+ sizeof(ATSUFontID), sizeof(Fixed),
+ sizeof(Boolean), sizeof(Boolean), sizeof(Boolean),
+ sizeof(ATSStyleRenderingOptions),
+ };
+ const ATSUAttributeValuePtr styleValues[] = {
+ &fontId, &fsize,
+ &isBold, &isItalic, &isUnderline,
+ &options,
+ };
+
+ OSStatus err;
+
+ err = ATSUSetAttributes(
+ style,
+ sizeof(styleTags)/sizeof(styleTags[0]),
+ styleTags, styleSizes, styleValues);
+ if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+ fprintf(stderr, "ATSUSetAttributes(): Error %d\n", (int) err);
+#endif
+ }
}
+
/*
- *-------------------------------------------------------------------------
+ *---------------------------------------------------------------------------
*
- * ReleaseSubFont --
+ * SetFontFeatures --
*
- * Called to release the contents of a SubFont. The caller is
- * responsible for freeing the memory used by the SubFont itself.
+ * Helper for InitFont(). Request specific font features of the ATSU
+ * style object for a MacFont.
*
* Results:
- * None.
+ *
+ * None.
*
* Side effects:
- * Memory and resources are freed.
+ *
+ * Specific font features are enabled on the ATSU style object.
*
*---------------------------------------------------------------------------
*/
static void
-ReleaseSubFont(
- SubFont *subFontPtr) /* The SubFont to delete. */
+SetFontFeatures(
+ ATSUFontID fontId, /* The font id to use. */
+ int fixed, /* Is this a fixed font? */
+ ATSUStyle style) /* The style handle to configure. */
{
- FreeFontFamily(subFontPtr->familyPtr);
+ /*
+ * Don't use the standard latin ligatures, if this is determined to be a
+ * fixed-width font.
+ */
+
+ static const ATSUFontFeatureType fixed_featureTypes[] = {
+ kLigaturesType, kLigaturesType
+ };
+ static const ATSUFontFeatureSelector fixed_featureSelectors[] = {
+ kCommonLigaturesOffSelector, kRareLigaturesOffSelector
+ };
+
+ OSStatus err;
+
+ if (fixed) {
+ err = ATSUSetFontFeatures(
+ style,
+ sizeof(fixed_featureTypes)/sizeof(fixed_featureTypes[0]),
+ fixed_featureTypes, fixed_featureSelectors);
+ if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+ fprintf(stderr, "ATSUSetFontFeatures(): Error %d\n", (int) err);
+#endif
+ }
+ }
}
/*
- *-------------------------------------------------------------------------
+ *---------------------------------------------------------------------------
*
- * AllocFontFamily --
+ * AdjustFontHeight --
*
- * Find the FontFamily structure associated with the given font
- * family. The information should be stored by the caller in a
- * SubFont and used when determining if that SubFont supports a
- * character.
+ * Helper for InitFont(). Check font height against some real world
+ * examples.
*
* Results:
- * A pointer to a FontFamily. The reference count in the FontFamily
- * is automatically incremented. When the SubFont is released, the
- * reference count is decremented. When no SubFont is using this
- * FontFamily, it may be deleted.
+ *
+ * None.
*
* Side effects:
- * A new FontFamily structure will be allocated if this font family
- * has not been seen.
*
- *-------------------------------------------------------------------------
+ * The metrics in fontPtr->font.fm are adjusted so that typical combined
+ * characters fit into ascent+descent.
+ *
+ *---------------------------------------------------------------------------
*/
-static FontFamily *
-AllocFontFamily(
- CONST MacFont *fontPtr, /* Font object in which the FontFamily will
- * be used. */
- int faceNum) /* The font number. */
+static void
+AdjustFontHeight(
+ MacFont * fontPtr)
{
- FontFamily *familyPtr;
- int i;
-
- familyPtr = fontFamilyList;
- for (; familyPtr != NULL; familyPtr = familyPtr->nextPtr) {
- if (familyPtr->faceNum == faceNum) {
- familyPtr->refCount++;
- return familyPtr;
- }
- }
+ /*
+ * 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
+ * typical composed characters from the Latin-1 range and corrects these
+ * factors, especially the ascent.
+ *
+ * A font requested with a pixel size may thus have a larger line height
+ * 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
+ * find it now [BR].
+ */
- familyPtr = (FontFamily *) ckalloc(sizeof(FontFamily));
- memset(familyPtr, 0, sizeof(FontFamily));
- familyPtr->nextPtr = fontFamilyList;
- fontFamilyList = familyPtr;
+ static const UniChar chars[]
+ /* Auml, Aacute, Acirc, Atilde, Ccedilla */
+ = {0x00C4, 0x00C1, 0x00C2, 0x00C3, 0x00C7};
+ static const int charslen = sizeof(chars) / sizeof(chars[0]);
- /*
- * Set key for this FontFamily.
- */
-
- familyPtr->faceNum = faceNum;
+ DrawingContext drawingContext;
+ Rect size;
+ OSStatus err;
- /*
- * An initial refCount of 2 means that FontFamily information will
- * persist even when the SubFont that loaded the FontFamily is released.
- * Change it to 1 to cause FontFamilies to be unloaded when not in use.
- */
-
- familyPtr->refCount = 2;
- familyPtr->encoding = GetFontEncoding(faceNum, 1, &familyPtr->isSymbolFont);
- familyPtr->isMultiByteFont = 0;
- FillParseTable(familyPtr->typeTable, FontToScript(faceNum));
- for (i = 0; i < 256; i++) {
- if (familyPtr->typeTable[i] != 0) {
- familyPtr->isMultiByteFont = 1;
- break;
+
+#if TK_MAC_USE_QUARZ
+ TkMacOSXQuarzStartDraw(&drawingContext);
+#endif
+
+ TkMacOSXLayoutSetString(fontPtr, &drawingContext, chars, charslen);
+
+ size.top = size.bottom = 0;
+ err = ATSUMeasureTextImage(
+ fontPtr->atsuLayout,
+ 0, charslen,
+ 0, 0,
+ &size);
+
+#if TK_MAC_USE_QUARZ
+ TkMacOSXQuarzEndDraw(&drawingContext);
+#endif
+
+ if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+ fprintf(stderr, "ATSUMeasureTextImage(): Error %d\n", (int) err);
+#endif
+ } else {
+ TkFontMetrics * fmPtr = &fontPtr->font.fm;
+ int ascent = -size.top;
+ int descent = size.bottom;
+
+ if (ascent > fmPtr->ascent) {
+ fmPtr->ascent = ascent;
+ }
+ if (descent > fmPtr->descent) {
+ fmPtr->descent = descent;
}
}
- return familyPtr;
}
+
/*
- *-------------------------------------------------------------------------
+ *---------------------------------------------------------------------------
*
- * FreeFontFamily --
+ * InitATSULayout --
*
- * Called to free a FontFamily when the SubFont is finished using it.
- * Frees the contents of the FontFamily and the memory used by the
- * FontFamily itself.
+ * Helper for TkMacOSXLayoutSetString(). Initializes the ATSU layout
+ * object for a MacFont and a specific string.
*
* Results:
- * None.
+ *
+ * Sets up all parameters needed for an ATSU layout object.
*
* Side effects:
- * None.
*
- *-------------------------------------------------------------------------
+ * 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()).
+ *
+ *---------------------------------------------------------------------------
*/
-
+
static void
-FreeFontFamily(
- FontFamily *familyPtr) /* The FontFamily to delete. */
+InitATSULayout(
+ const DrawingContext * drawingContextPtr,
+ /* Specifies the CGContext to use. */
+ ATSUTextLayout layout, /* The layout object to configure. */
+ int fixed) /* Is this a fixed font? */
{
- FontFamily **familyPtrPtr;
- int i;
+ /*
+ * Attributes for the layout.
+ */
+
+ ATSLineLayoutOptions layoutOptions =
+ 0
+#if TK_MAC_COALESCE_LINE
+ /*
+ * Options to use unconditionally, when we try to do coalescing in here.
+ */
+ | kATSLineDisableAllLayoutOperations
+ | kATSLineFractDisable
+ | kATSLineUseDeviceMetrics
+#endif
+ ;
+
+ static const ATSUAttributeTag layoutTags[] = {
+#if TK_MAC_USE_QUARZ
+ kATSUCGContextTag,
+#endif
+ kATSULineLayoutOptionsTag,
+ };
+ static const ByteCount layoutSizes[] = {
+#if TK_MAC_USE_QUARZ
+ sizeof(CGContextRef),
+#endif
+ sizeof(ATSLineLayoutOptions),
+ };
+ const ATSUAttributeValuePtr layoutValues[] = {
+#if TK_MAC_USE_QUARZ
+ (void*)&drawingContextPtr->cgContext,
+#endif
+ &layoutOptions,
+ };
+
+ OSStatus err;
- if (familyPtr == NULL) {
- return;
+ /*
+ * Ensure W(abcdefg) == W(a)*7 for fixed fonts (Latin scripts only).
+ */
+
+ if (fixed) {
+ layoutOptions |=
+ kATSLineFractDisable
+ | kATSLineUseDeviceMetrics
+ ;
}
- familyPtr->refCount--;
- if (familyPtr->refCount > 0) {
- return;
+
+ err = ATSUSetLayoutControls(
+ layout,
+ sizeof(layoutTags)/sizeof(layoutTags[0]),
+ layoutTags, layoutSizes, layoutValues);
+ if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+ fprintf(stderr, "ATSUSetLayoutControls(): Error %d\n", (int) err);
+#endif
}
- Tcl_FreeEncoding(familyPtr->encoding);
- for (i = 0; i < FONTMAP_PAGES; i++) {
- if (familyPtr->fontMap[i] != NULL) {
- ckfree((char *) familyPtr->fontMap[i]);
- }
+
+ err = ATSUSetTransientFontMatching(layout, true);
+ if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+ fprintf(stderr, "ATSUSetTransientFontMatching(): Error %d\n",
+ (int) err);
+#endif
}
-
- /*
- * Delete from list.
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * TkMacOSXLayoutSetString --
+ *
+ * Setup the MacFont for a specific string.
+ *
+ * Results:
+ *
+ * Sets up all parameters so that ATSU can work with the objects in
+ * MacFont.
+ *
+ * Side effects:
+ *
+ * Sets parameters on the layout object fontPtr->atsuLayout.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+void
+TkMacOSXLayoutSetString(
+ const MacFont * fontPtr, /* The fontPtr to configure. */
+ const DrawingContext * drawingContextPtr,
+ /* For the CGContext to be used.*/
+ const UniChar * uchars, int ulen) /* The UniChar string to set into
+ * fontPtr->atsuLayout. */
+{
+ OSStatus err;
+ err = ATSUSetTextPointerLocation(
+ fontPtr->atsuLayout,
+ uchars, kATSUFromTextBeginning, ulen,
+ ulen);
+ if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+ fprintf(stderr, "ATSUSetTextPointerLocation(): Error %d\n", (int) err);
+#endif
+ }
+
+ /*
+ * Styles can only be set after the text is set.
*/
-
- for (familyPtrPtr = &fontFamilyList; ; ) {
- if (*familyPtrPtr == familyPtr) {
- *familyPtrPtr = familyPtr->nextPtr;
- break;
- }
- familyPtrPtr = &(*familyPtrPtr)->nextPtr;
+
+ err = ATSUSetRunStyle(
+ fontPtr->atsuLayout, fontPtr->atsuStyle,
+ kATSUFromTextBeginning, kATSUToTextEnd);
+ if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+ fprintf(stderr, "ATSUSetRunStyle(): Error %d\n", (int) err);
+#endif
}
-
- ckfree((char *) familyPtr);
+
+ /*
+ * Layout attributes can only be set after the styles are set.
+ */
+
+ InitATSULayout(
+ drawingContextPtr, fontPtr->atsuLayout,
+ fontPtr->font.fm.fixed);
}
+
/*
*-------------------------------------------------------------------------
*
- * FindSubFontForChar --
+ * ReleaseFont --
*
- * Determine which physical screen font is necessary to use to
- * display the given character. If the font object does not have
- * a screen font that can display the character, another screen font
- * may be loaded into the font object, following a set of preferred
- * fallback rules.
+ * Called to release the Macintosh-specific contents of a TkFont. The
+ * caller is responsible for freeing the memory used by the font
+ * itself.
*
* Results:
- * The return value is the SubFont to use to display the given
- * character.
+ * None.
*
* Side effects:
- * The contents of fontPtr are modified to cache the results
- * of the lookup and remember any SubFonts that were dynamically
- * loaded. The table of SubFonts might be extended, and if a non-NULL
- * reference to a subfont pointer is available, it is updated if it
- * previously pointed into the old subfont table.
+ * Memory is freed.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+static void
+ReleaseFont(
+ MacFont * fontPtr) /* The font to delete. */
+{
+ ATSUDisposeTextLayout(fontPtr->atsuLayout);
+ ATSUDisposeStyle(fontPtr->atsuStyle);
+}
+
+/*
+ *-------------------------------------------------------------------------
+ *
+ * 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.
+ *
+ * FindFontFamilyOrAlias also considers font aliases as determined by
+ * TkFontGetAliasList().
+ *
+ * FindFontFamilyOrAliasOrFallback also considers font aliases as
+ * determined by TkFontGetFallbacks().
+ *
+ * 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
+ *
+ * Results:
+ *
+ * The return value is NULL if the specified font family does not exist,
+ * a valid MacFontFamily* otherwise.
+ *
+ * Side effects:
+ *
+ * None.
*
*-------------------------------------------------------------------------
*/
-static SubFont *
-FindSubFontForChar(
- MacFont *fontPtr, /* The font object with which the character
- * will be displayed. */
- int ch, /* The Unicode character to be displayed. */
- SubFont **fixSubFontPtrPtr) /* Subfont reference to fix up if we
- * reallocate our subfont table. */
+static const MacFontFamily *
+FindFontFamilyOrAlias(
+ const char * name) /* Name or alias name of the font to find. */
{
- int i, j, k;
- CONST char *fallbackName;
- char **aliases;
- SubFont *subFontPtr;
- FontNameMap *mapPtr;
- Tcl_DString faceNames;
- char ***fontFallbacks;
- char **anyFallbacks;
-
- if (FontMapLookup(&fontPtr->subFontArray[0], ch)) {
- return &fontPtr->subFontArray[0];
+ const MacFontFamily * familyPtr;
+ char ** aliases;
+ int i;
+
+ familyPtr = FindFontFamily(name);
+ if (familyPtr != NULL) {
+ return familyPtr;
}
- for (i = 1; i < fontPtr->numSubFonts; i++) {
- if (FontMapLookup(&fontPtr->subFontArray[i], ch)) {
- return &fontPtr->subFontArray[i];
+ aliases = TkFontGetAliasList(name);
+ if (aliases != NULL) {
+ for (i = 0; aliases[i] != NULL; i++) {
+ familyPtr = FindFontFamily(aliases[i]);
+ if (familyPtr != NULL) {
+ return familyPtr;
+ }
}
}
+ return NULL;
+}
- /*
- * Keep track of all face names that we check, so we don't check some
- * name multiple times if it can be reached by multiple paths.
- */
-
- Tcl_DStringInit(&faceNames);
-
- aliases = TkFontGetAliasList(fontPtr->font.fa.family);
-
- subFontPtr = NULL;
- fontFallbacks = TkFontGetFallbacks();
- for (i = 0; fontFallbacks[i] != NULL; i++) {
- for (j = 0; fontFallbacks[i][j] != NULL; j++) {
- fallbackName = fontFallbacks[i][j];
- if (strcasecmp(fallbackName, fontPtr->font.fa.family) == 0) {
- /*
- * If the base font has a fallback...
- */
-
- goto tryfallbacks;
- } else if (aliases != NULL) {
- /*
- * Or if an alias for the base font has a fallback...
- */
+static const MacFontFamily *
+FindFontFamilyOrAliasOrFallback(
+ const char * name) /* Name or alias name of the font to find. */
+{
+ const MacFontFamily * familyPtr;
+ const char * fallback;
+ char *** fallbacks;
+ int i, j;
- for (k = 0; aliases[k] != NULL; k++) {
- if (strcasecmp(aliases[k], fallbackName) == 0) {
- goto tryfallbacks;
+ familyPtr = FindFontFamilyOrAlias(name);
+ if (familyPtr != NULL) {
+ 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;
}
}
}
- }
- continue;
-
- /*
- * ...then see if we can use one of the fallbacks, or an
- * alias for one of the fallbacks.
- */
-
- tryfallbacks:
- for (j = 0; fontFallbacks[i][j] != NULL; j++) {
- fallbackName = fontFallbacks[i][j];
- subFontPtr = CanUseFallbackWithAliases(fontPtr, fallbackName,
- ch, &faceNames, fixSubFontPtrPtr);
- if (subFontPtr != NULL) {
- goto end;
- }
+ break; /* benny: This "break" is a carry-over from
+ * tkMacOSXFont.c, but what is actually its purpose
+ * ???? */
}
}
-
- /*
- * See if we can use something from the global fallback list.
- */
- anyFallbacks = TkFontGetGlobalClass();
- for (i = 0; anyFallbacks[i] != NULL; i++) {
- fallbackName = anyFallbacks[i];
- subFontPtr = CanUseFallbackWithAliases(fontPtr, fallbackName, ch,
- &faceNames, fixSubFontPtrPtr);
- if (subFontPtr != NULL) {
- goto end;
- }
- }
/*
- * Try all face names available in the whole system until we
- * find one that can be used.
+ * 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.
*/
- for (mapPtr = gFontNameMap; mapPtr->utfName != NULL; mapPtr++) {
- fallbackName = mapPtr->utfName;
- if (SeenName(fallbackName, &faceNames) == 0) {
- subFontPtr = CanUseFallback(fontPtr, fallbackName, ch,
- fixSubFontPtrPtr);
- if (subFontPtr != NULL) {
- goto end;
- }
- }
- }
-
- end:
- Tcl_DStringFree(&faceNames);
-
- if (subFontPtr == NULL) {
- /*
- * No font can display this character. We will use the base font
- * and have it display the "unknown" character.
- */
+#ifdef TK_MAC_DEBUG
+ fprintf(stderr, "Font family '%s': Not found\n", name);
+#endif
- subFontPtr = &fontPtr->subFontArray[0];
- FontMapInsert(subFontPtr, ch);
- }
- return subFontPtr;
+ return NULL;
}
/*
*-------------------------------------------------------------------------
*
- * FontMapLookup --
+ * InitFontFamilies --
*
- * See if the screen font can display the given character.
+ * Helper to TkpFontPkgInit. Use the Font Manager to fill in the
+ * familyList global array.
*
* Results:
- * The return value is 0 if the screen font cannot display the
- * character, non-zero otherwise.
+ *
+ * None.
*
* Side effects:
- * New pages are added to the font mapping cache whenever the
- * character belongs to a page that hasn't been seen before.
- * When a page is loaded, information about all the characters on
- * that page is stored, not just for the single character in
- * question.
+ *
+ * Allocates memory.
*
*-------------------------------------------------------------------------
*/
-static int
-FontMapLookup(
- SubFont *subFontPtr, /* Contains font mapping cache to be queried
- * and possibly updated. */
- int ch) /* Character to be tested. */
+static void
+InitFontFamilies(void)
{
- int row, bitOffset;
+ OSStatus err;
- row = ch >> FONTMAP_SHIFT;
- if (subFontPtr->fontMap[row] == NULL) {
- FontMapLoadPage(subFontPtr, row);
+ err = ATSFontFamilyApplyFunction(FontFamilyEnumCallback,NULL);
+ if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+ fprintf(stderr, "ATSFontFamilyApplyFunction(): Error %d\n", (int) err);
+#endif
}
- bitOffset = ch & (FONTMAP_BITSPERPAGE - 1);
- return (subFontPtr->fontMap[row][bitOffset >> 3] >> (bitOffset & 7)) & 1;
+
+ AddFontFamily(APPLFONT_NAME, GetAppFont());
+ AddFontFamily(SYSTEMFONT_NAME, GetSysFont());
+
+ SortFontFamilies();
}
+
+static OSStatus
+FontFamilyEnumCallback(
+ ATSFontFamilyRef family,
+ void *refCon)
+{
+ OSStatus err;
+ char name[260] = "";
+
+ (void) refCon;
+
+ err = GetFontFamilyName(family, name, sizeof(name));
+ if (err == noErr) {
+ AddFontFamily(name, family);
+ }
+
+ return noErr;
+}
+
/*
*-------------------------------------------------------------------------
*
- * FontMapInsert --
+ * GetFontFamilyName --
*
- * Tell the font mapping cache that the given screen font should be
- * used to display the specified character. This is called when no
- * font on the system can be be found that can display that
- * character; we lie to the font and tell it that it can display
- * the character, otherwise we would end up re-searching the entire
- * fallback hierarchy every time that character was seen.
+ * 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. Hint: The MacOSX font selector seems to use the localized
+ * family name given by ATSUFindFontName(kFontFamilyName,
+ * GetCurrentLanguage()).
*
* Results:
- * None.
+ *
+ * An OS error code, noErr on success. name is filled with the
+ * resulting name.
*
* Side effects:
- * New pages are added to the font mapping cache whenever the
- * character belongs to a page that hasn't been seen before.
- * When a page is loaded, information about all the characters on
- * that page is stored, not just for the single character in
- * question.
+ *
+ * None.
*
*-------------------------------------------------------------------------
*/
-static void
-FontMapInsert(
- SubFont *subFontPtr, /* Contains font mapping cache to be
- * updated. */
- int ch) /* Character to be added to cache. */
+static OSStatus
+GetFontFamilyName(
+ FMFontFamily fontFamily, /* The font family for which to find the
+ * name. */
+ char * name, int numBytes) /* Filled with the result. */
{
- int row, bitOffset;
+ OSStatus err;
+ Str255 nativeName;
+ CFStringRef cfString;
+ TextEncoding encoding;
+ ScriptCode nameencoding;
+
+ nativeName[0] = 0;
+ name[0] = 0;
+
+ err = FMGetFontFamilyName(fontFamily, nativeName);
+ if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+ fprintf(stderr, "FMGetFontFamilyName(): Error %d\n", (int) err);
+#endif
+ return err;
+ }
+
+ /*
+ * QuickDraw font names are encoded with the script that the font uses.
+ * So we determine that encoding and than we reencode the name.
+ */
- row = ch >> FONTMAP_SHIFT;
- if (subFontPtr->fontMap[row] == NULL) {
- FontMapLoadPage(subFontPtr, row);
+ encoding = kTextEncodingMacRoman;
+ err = FMGetFontFamilyTextEncoding(fontFamily, &encoding);
+ if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+ fprintf(stderr, "FMGetFontFamilyTextEncoding(): Error %d\n", (int) err);
+#endif
}
- bitOffset = ch & (FONTMAP_BITSPERPAGE - 1);
- subFontPtr->fontMap[row][bitOffset >> 3] |= 1 << (bitOffset & 7);
+
+ nameencoding = encoding;
+ err = RevertTextEncodingToScriptInfo(encoding, &nameencoding, NULL, NULL);
+ if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+ fprintf(stderr, "RevertTextEncodingToScriptInfo(): Error %d\n",
+ (int) err);
+#endif
+ }
+
+ /*
+ * 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);
+ CFStringGetCString(
+ cfString, name, numBytes, kCFStringEncodingUTF8);
+ CFRelease(cfString);
+
+ return noErr;
}
/*
*-------------------------------------------------------------------------
*
- * FontMapLoadPage --
+ * FindFontFamily --
*
- * Load information about all the characters on a given page.
- * This information consists of one bit per character that indicates
- * whether the associated HFONT can (1) or cannot (0) display the
- * characters on the page.
+ * 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:
- * None.
+ *
+ * MacFontFamily: A pair of family id and the actual name registered for
+ * the font.
*
* Side effects:
- * Mempry allocated.
+ *
+ * None.
+ *
+ * Assumption:
+ *
+ * Requires the familyList array to be sorted.
*
*-------------------------------------------------------------------------
*/
-static void
-FontMapLoadPage(
- SubFont *subFontPtr, /* Contains font mapping cache to be
- * updated. */
- int row) /* Index of the page to be loaded into
- * the cache. */
-{
- FMInput fm;
- FMOutPtr fmOut;
- int i, end, bitOffset, isMultiByteFont;
- char src[TCL_UTF_MAX];
- unsigned char buf[16];
- int srcRead, dstWrote;
- Tcl_Encoding encoding;
- Handle fHandle = NULL;
-
- subFontPtr->fontMap[row] = (char *) ckalloc(FONTMAP_BITSPERPAGE / 8);
- memset(subFontPtr->fontMap[row], 0, FONTMAP_BITSPERPAGE / 8);
-
- encoding = subFontPtr->familyPtr->encoding;
-
- fm.family = subFontPtr->familyPtr->faceNum;
- fm.size = 12;
- fm.face = 0;
- fm.needBits = 0;
- fm.device = 0;
- fm.numer.h = 1;
- fm.numer.v = 1;
- fm.denom.h = 1;
- fm.denom.v = 1;
- /*
-#if !defined(UNIVERSAL_INTERFACES_VERSION) || (UNIVERSAL_INTERFACES_VERSION < 0x0300)
- fHandle = FMSwapFont(&fm)->fontHandle;
-#else
- fHandle = FMSwapFont(&fm)->fontHandle;
-#endif
-*/
-/*
- * For some reason, FMSwapFont alywas returns a structure where the returned font handle
- * is NULL. Until we figure this one out, assume all characters are allowed
- */
- fmOut = FMSwapFont(&fm);
- fHandle = fmOut->fontHandle;
- isMultiByteFont = subFontPtr->familyPtr->isMultiByteFont;
-#ifndef MAC_OSX_TK
- GetResInfo(fHandle, &theID, &theType, theName);
- fprintf ( stderr, "ResError() %d, %x\n", ResError (), fHandle );
- if (theType == 'sfnt') {
-#endif
- /*
- * Found an outline font which has very complex font record.
- * Let's just assume *ALL* the characters are allowed.
- */
- end = (row + 1) << FONTMAP_SHIFT;
- for (i = row << FONTMAP_SHIFT; i < end; i++) {
- if (Tcl_UtfToExternal(NULL, encoding, src, Tcl_UniCharToUtf(i,
- src),
- TCL_ENCODING_STOPONERROR, NULL, (char *) buf,
- sizeof(buf),
- &srcRead, &dstWrote, NULL) == TCL_OK) {
- bitOffset = i & (FONTMAP_BITSPERPAGE - 1);
- subFontPtr->fontMap[row][bitOffset >> 3] |= 1
- << (bitOffset & 7);
- }
- }
-#ifndef MAC_OSX_TK
- } else {
- /*
- * Found an old bitmap font which has a well-defined record.
- * We can check the width table to see which characters exist.
- */
+static const MacFontFamily *
+FindFontFamily(
+ const char * name) /* The family name. Note: Names are compared
+ * non-case-sensitive. */
+{
+ const MacFontFamily key = {name,-1};
- fontRecPtr = *((FontRec **) fHandle );
- widths = (short *) ((long) &fontRecPtr->owTLoc
- + ((long) (fontRecPtr->owTLoc - fontRecPtr->firstChar)
- * sizeof(short)));
-
- end = (row + 1) << FONTMAP_SHIFT;
- for (i = row << FONTMAP_SHIFT; i < end; i++) {
- if (Tcl_UtfToExternal(NULL, encoding, src,
- Tcl_UniCharToUtf(i, src),
- TCL_ENCODING_STOPONERROR, NULL, (char *) buf, sizeof(buf),
- &srcRead, &dstWrote, NULL) == TCL_OK) {
-
- if (((isMultiByteFont != 0) && (buf[0] > 31))
- || (widths[buf[0]] != -1)) {
- if ((buf[0] == 0x11) && (widths[0x12] == -1)) {
- continue;
- }
-
- /*
- * Mac's char existence metrics are only for one-byte
- * characters. If we have a double-byte char, just
- * assume that the font supports that char if the font's
- * encoding supports that char.
- */
-
- bitOffset = i & (FONTMAP_BITSPERPAGE - 1);
- subFontPtr->fontMap[row][bitOffset >> 3] |= 1
- << (bitOffset & 7);
- }
- }
- }
+ if(familyListMaxValid <= 0) {
+ return NULL;
}
-#endif
+
+ return bsearch(
+ &key,
+ familyList, familyListMaxValid, sizeof(*familyList),
+ CompareFontFamilies);
}
/*
- *---------------------------------------------------------------------------
+ *-------------------------------------------------------------------------
*
- * CanUseFallbackWithAliases --
+ * EnumFontFamilies --
*
- * Helper function for FindSubFontForChar. Determine if the
- * specified face name (or an alias of the specified face name)
- * can be used to construct a screen font that can display the
- * given character.
+ * Create a Tcl list with the registered names in the global familyList.
*
* Results:
- * See CanUseFallback().
+ *
+ * A Tcl list of names.
*
* Side effects:
- * If the name and/or one of its aliases was rejected, the
- * rejected string is recorded in nameTriedPtr so that it won't
- * be tried again. The table of SubFonts might be extended, and if
- * a non-NULL reference to a subfont pointer is available, it is
- * updated if it previously pointed into the old subfont table.
*
- *---------------------------------------------------------------------------
+ * None.
+ *
+ *-------------------------------------------------------------------------
*/
-static SubFont *
-CanUseFallbackWithAliases(
- MacFont *fontPtr, /* The font object that will own the new
- * screen font. */
- CONST char *faceName, /* Desired face name for new screen font. */
- int ch, /* The Unicode character that the new
- * screen font must be able to display. */
- Tcl_DString *nameTriedPtr, /* Records face names that have already
- * been tried. It is possible for the same
- * face name to be queried multiple times when
- * trying to find a suitable screen font. */
- SubFont **fixSubFontPtrPtr) /* Subfont reference to fix up if we
- * reallocate our subfont table. */
+static Tcl_Obj *
+EnumFontFamilies(void)
{
- SubFont *subFontPtr;
- char **aliases;
int i;
-
- if (SeenName(faceName, nameTriedPtr) == 0) {
- subFontPtr = CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr);
- if (subFontPtr != NULL) {
- return subFontPtr;
- }
- }
- aliases = TkFontGetAliasList(faceName);
- if (aliases != NULL) {
- for (i = 0; aliases[i] != NULL; i++) {
- if (SeenName(aliases[i], nameTriedPtr) == 0) {
- subFontPtr = CanUseFallback(fontPtr, aliases[i], ch,
- fixSubFontPtrPtr);
- if (subFontPtr != NULL) {
- return subFontPtr;
- }
- }
- }
+ Tcl_Obj * tclList;
+
+ tclList = Tcl_NewListObj(0, NULL);
+ for (i=0; i<familyListMaxValid; ++i) {
+ Tcl_ListObjAppendElement(
+ NULL, tclList, Tcl_NewStringObj(familyList[i].name, -1));
}
- return NULL;
+
+ return tclList;
}
/*
- *---------------------------------------------------------------------------
+ *-------------------------------------------------------------------------
*
- * SeenName --
+ * AddFontFamily --
*
- * Used to determine we have already tried and rejected the given
- * face name when looking for a screen font that can support some
- * Unicode character.
+ * Register a font family in familyList. Until SortFontFamilies() is
+ * called, this is not actually available for FindFontFamily().
*
* Results:
- * The return value is 0 if this face name has not already been seen,
- * non-zero otherwise.
+ *
+ * MacFontFamily: The new pair of family id and the actual name
+ * registered for the font.
*
* Side effects:
- * None.
*
- *---------------------------------------------------------------------------
+ * New entry in familyList and familyListNextFree updated.
+ *
+ *-------------------------------------------------------------------------
*/
-static int
-SeenName(
- CONST char *name, /* The name to check. */
- Tcl_DString *dsPtr) /* Contains names that have already been
- * seen. */
+static const MacFontFamily *
+AddFontFamily(
+ const char * name, /* Font family name to register. */
+ FMFontFamily familyId) /* Font family id to register. */
{
- CONST char *seen, *end;
+ MacFontFamily * familyPtr;
- seen = Tcl_DStringValue(dsPtr);
- end = seen + Tcl_DStringLength(dsPtr);
- while (seen < end) {
- if (strcasecmp(seen, name) == 0) {
- return 1;
- }
- seen += strlen(seen) + 1;
+ if (familyListNextFree >= familyListSize) {
+ familyListSize += 100;
+ familyList = (MacFontFamily *) ckrealloc(
+ (void*) familyList,
+ familyListSize * sizeof(*familyList));
}
- Tcl_DStringAppend(dsPtr, (char *) name, (int) (strlen(name) + 1));
- return 0;
+
+ familyPtr = familyList + familyListNextFree;
+ ++familyListNextFree;
+
+ familyPtr->name = AddString(name);
+ familyPtr->familyId = familyId;
+
+ return familyPtr;
}
/*
*-------------------------------------------------------------------------
*
- * CanUseFallback --
+ * SortFontFamilies --
*
- * If the specified physical screen font has not already been loaded
- * into the font object, determine if the specified physical screen
- * font can display the given character.
+ * 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:
- * The return value is a pointer to a newly allocated SubFont, owned
- * by the font object. This SubFont can be used to display the given
- * character. The SubFont represents the screen font with the base set
- * of font attributes from the font object, but using the specified
- * font name. NULL is returned if the font object already holds
- * a reference to the specified physical font or if the specified
- * physical font cannot display the given character.
- *
- * Side effects:
- * The font object's subFontArray is updated to contain a reference
- * to the newly allocated SubFont. The table of SubFonts might be
- * extended, and if a non-NULL reference to a subfont pointer is
- * available, it is updated if it previously pointed into the old
- * subfont table.
+ *
+ * None.
+ *
+ * Side effects:
+ *
+ * familyList is sorted and familyListMaxValid is updated.
*
*-------------------------------------------------------------------------
*/
-static SubFont *
-CanUseFallback(
- MacFont *fontPtr, /* The font object that will own the new
- * screen font. */
- CONST char *faceName, /* Desired face name for new screen font. */
- int ch, /* The Unicode character that the new
- * screen font must be able to display. */
- SubFont **fixSubFontPtrPtr) /* Subfont reference to fix up if we
- * reallocate our subfont table. */
+static void
+SortFontFamilies(void)
{
- int i;
- SubFont subFont;
- short faceNum;
-
- if (GetFamilyNum(faceName, &faceNum) == 0) {
- return NULL;
- }
-
- /*
- * Skip all fonts we've already used.
- */
-
- for (i = 0; i < fontPtr->numSubFonts; i++) {
- if (faceNum == fontPtr->subFontArray[i].familyPtr->faceNum) {
- return NULL;
- }
- }
-
- /*
- * Load this font and see if it has the desired character.
- */
-
- InitSubFont(fontPtr, faceNum, &subFont);
- if (((ch < 256) && (subFont.familyPtr->isSymbolFont))
- || (FontMapLookup(&subFont, ch) == 0)) {
- ReleaseSubFont(&subFont);
- return NULL;
- }
-
- if (fontPtr->numSubFonts >= SUBFONT_SPACE) {
- SubFont *newPtr;
- newPtr = (SubFont *) ckalloc(sizeof(SubFont)
- * (fontPtr->numSubFonts + 1));
- memcpy((char *) newPtr, fontPtr->subFontArray,
- fontPtr->numSubFonts * sizeof(SubFont));
- if (fixSubFontPtrPtr != NULL) {
- /*
- * Fix up the variable pointed to by fixSubFontPtrPtr so it
- * still points into the live array. [Bug 618872]
- */
- *fixSubFontPtrPtr =
- newPtr + (*fixSubFontPtrPtr - fontPtr->subFontArray);
- }
- if (fontPtr->subFontArray != fontPtr->staticSubFonts) {
- ckfree((char *) fontPtr->subFontArray);
- }
- fontPtr->subFontArray = newPtr;
+ if (familyListNextFree > 0) {
+ qsort( familyList, familyListNextFree, sizeof(*familyList),
+ CompareFontFamilies);
}
- fontPtr->subFontArray[fontPtr->numSubFonts] = subFont;
- fontPtr->numSubFonts++;
- return &fontPtr->subFontArray[fontPtr->numSubFonts - 1];
+ familyListMaxValid = familyListNextFree;
}
/*
*-------------------------------------------------------------------------
*
- * GetFamilyNum --
+ * CompareFontFamilies --
*
- * Determines 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.
+ * Comparison function used by SortFontFamilies() and FindFontFamily().
*
* Results:
- * The return value is 0 if the specified font family does not exist,
- * non-zero otherwise. *faceNumPtr is filled with the unique face
- * number that identifies the screen font, or 0 if the font family
- * did not exist.
+ *
+ * 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] ;-).
*
* Side effects:
- * None.
+ *
+ * None.
*
*-------------------------------------------------------------------------
*/
static int
-GetFamilyNum(
- CONST char *faceName, /* UTF-8 name of font family to query. */
- short *faceNumPtr) /* Filled with font number for above family. */
+CompareFontFamilies(
+ const void * vp1,
+ const void * vp2)
{
- FontNameMap *mapPtr;
-
- if (faceName != NULL) {
- for (mapPtr = gFontNameMap; mapPtr->utfName != NULL; mapPtr++) {
- if (strcasecmp(faceName, mapPtr->utfName) == 0) {
- *faceNumPtr = mapPtr->faceNum;
- return 1;
- }
- }
- }
- *faceNumPtr = 0;
- return 0;
-}
+ const char * name1;
+ const char * name2;
+ int len1;
+ int len2;
+ int diff;
-static int
-GetFamilyOrAliasNum(
- CONST char *faceName, /* UTF-8 name of font family to query. */
- short *faceNumPtr) /* Filled with font number for above family. */
-{
- char **aliases;
- int i;
-
- if (GetFamilyNum(faceName, faceNumPtr) != 0) {
- return 1;
- }
- aliases = TkFontGetAliasList(faceName);
- if (aliases != NULL) {
- for (i = 0; aliases[i] != NULL; i++) {
- if (GetFamilyNum(aliases[i], faceNumPtr) != 0) {
- return 1;
- }
- }
- }
- return 0;
+ name1 = ((const MacFontFamily *) vp1)->name;
+ name2 = ((const MacFontFamily *) vp2)->name;
+
+ len1 = Tcl_NumUtfChars(name1, -1);
+ len2 = Tcl_NumUtfChars(name2, -1);
+
+ diff = Tcl_UtfNcasecmp(name1, name2, len1<len2 ? len1 : len2);
+
+ return diff == 0 ? len1-len2 : diff;
}
/*
*-------------------------------------------------------------------------
*
- * GetUtfFaceName --
+ * AddString --
*
- * Given the native name for a Macintosh font (in which the name of
- * the font is in the encoding of the font itself), return the UTF-8
- * name that corresponds to that font. The specified font name must
- * refer to a font that actually exists on the machine.
- *
- * This function is used to obtain the UTF-8 name when querying the
- * properties of a Macintosh font object.
+ * Helper for AddFontFamily(). Allocates a string in the one-shot
+ * allocator.
*
* Results:
- * The return value is a pointer to the UTF-8 of the specified font.
+ *
+ * A duplicated string in the one-shot allocator.
*
* Side effects:
- * None.
*
- *------------------------------------------------------------------------
+ * May allocate a new memory block.
+ *
+ *-------------------------------------------------------------------------
*/
-
-static Tk_Uid
-GetUtfFaceName(
- StringPtr nativeName) /* Pascal name for font in native encoding. */
+
+static const char *
+AddString(
+ const char * in) /* String to add, zero-terminated. */
{
- FontNameMap *mapPtr;
+ int len;
+ char * result;
- for (mapPtr = gFontNameMap; mapPtr->utfName != NULL; mapPtr++) {
- if (pstrcmp(nativeName, mapPtr->nativeName) == 0) {
- return mapPtr->utfName;
- }
+ 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;
}
- Tcl_Panic("GetUtfFaceName: unexpected nativeName");
- return NULL;
+
+ result = stringMemory->strings + stringMemory->nextFree;
+ stringMemory->nextFree += len;
+
+ memcpy(result, in, len);
+
+ return result;
}
/*
- *------------------------------------------------------------------------
- *
- * GetFontEncoding --
+ *---------------------------------------------------------------------------
*
- * Return a string that can be passed to Tcl_GetTextEncoding() and
- * used to convert bytes from UTF-8 into the encoding of the
- * specified font.
+ * TkMacOSXIsCharacterMissing --
*
- * The desired encoding to use to convert the name of a symbolic
- * font into UTF-8 is macRoman, while the desired encoding to use
- * to convert bytes in a symbolic font to UTF-8 is the corresponding
- * symbolic encoding. Due to this dual interpretatation of symbolic
- * fonts, the caller can specify what type of encoding to return
- * should the specified font be symbolic.
+ * Given a tkFont and a character determine whether the character has
+ * a glyph defined in the font or not.
*
* Results:
- * The return value is a string that specifies the font's encoding.
- * If the font's encoding could not be identified, NULL is returned.
+ * Returns a 1 if the character is missing, a 0 if it is not.
*
* Side effects:
* None.
*
- *------------------------------------------------------------------------
+ *---------------------------------------------------------------------------
*/
-
-static Tcl_Encoding
-GetFontEncoding(
- int faceNum, /* Macintosh font number. */
- int allowSymbol, /* If non-zero, then the encoding string
- * for symbol fonts will be the corresponding
- * symbol encoding. Otherwise, the encoding
- * string for symbol fonts will be
- * "macRoman". */
- int *isSymbolPtr) /* Filled with non-zero if this font is a
- * symbol font, 0 otherwise. */
+
+int
+TkMacOSXIsCharacterMissing(
+ Tk_Font tkfont, /* The font we are looking in. */
+ unsigned int searchChar) /* The character we are looking for. */
{
- Str255 faceName;
- int script, lang;
- char *name;
-
- if (allowSymbol != 0) {
- GetFontName(faceNum, faceName);
- if (pstrcasecmp(faceName, "\psymbol") == 0) {
- *isSymbolPtr = 1;
- return Tcl_GetEncoding(NULL, "symbol");
- }
- if (pstrcasecmp(faceName, "\pzapf dingbats") == 0) {
- *isSymbolPtr = 1;
- return Tcl_GetEncoding(NULL, "macDingbats");
- }
- }
- *isSymbolPtr = 0;
- script = FontToScript(faceNum);
- lang = GetScriptVariable(script, smScriptLang);
- name = NULL;
- if (script == smRoman) {
- name = TkFindStateString(romanMap, lang);
- } else if (script == smCyrillic) {
- name = TkFindStateString(cyrillicMap, lang);
- }
- if (name == NULL) {
- name = TkFindStateString(scriptMap, script);
- }
- return Tcl_GetEncoding(NULL, name);
+ /* 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.
+ *
+ * The system uses font fallback for controls, so we don't really need
+ * this. */
+
+ return 0;
}
/*
@@ -2202,20 +2650,20 @@ GetFontEncoding(
*/
void
-TkMacOSXInitControlFontStyle(Tk_Font tkfont, ControlFontStylePtr fsPtr)
+TkMacOSXInitControlFontStyle(
+ Tk_Font tkfont, /* Tk font object to use for the control. */
+ ControlFontStylePtr fsPtr) /* The style object to configure. */
{
- MacFont *fontPtr;
- FontFamily *lastFamilyPtr;
+ const MacFont * fontPtr;
fontPtr = (MacFont *) tkfont;
- lastFamilyPtr = fontPtr->subFontArray[0].familyPtr;
fsPtr->flags =
kControlUseFontMask|
kControlUseSizeMask|
kControlUseFaceMask|
kControlUseJustMask;
- fsPtr->font = lastFamilyPtr->faceNum;
- fsPtr->size = fontPtr->size;
- fsPtr->style = fontPtr->style;
+ fsPtr->font = fontPtr->qdFont;
+ fsPtr->size = fontPtr->qdSize;
+ fsPtr->style = fontPtr->qdStyle;
fsPtr->just = teCenter;
}
@@ -2224,77 +2672,74 @@ TkMacOSXInitControlFontStyle(Tk_Font tkfont, ControlFontStylePtr fsPtr)
*
* TkMacOSXUseAntialiasedText --
*
- * Enables or disables application-wide use of quickdraw
- * antialiased text (where available).
- * Sets up a linked tcl global boolean variable with write trace
- * to allow disabling of antialiased text from tcl.
+ * Enables or disables application-wide use of antialiased text (where
+ * available). Sets up a linked Tcl global boolean variable with write
+ * trace 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.
+ *
+ * This function is also called once from tkMacOSXInit.c:TkpInit() to
+ * install the trace in an interpreter. The value given in TkpInit()
+ * determines the actual default value.
+ *
+ * FIXME: Initialization should be a separate function, so that the
+ * default given here (see variable declaration above) remains the real
+ * default.
*
* Results:
- * TCL_OK if facility was sucessfully enabled/disabled.
- * TCL_ERROR if an error occurred or if facility is not available.
+ *
+ * TCL_OK.
*
* Side effects:
+ *
* None.
*
*----------------------------------------------------------------------
*/
-/* define constants from 10.2 Quickdraw.h to enable compilation in 10.1 */
-#define kQDUseTrueTypeScalerGlyphs (1 << 0)
-#define kQDUseCGTextRendering (1 << 1)
-#define kQDUseCGTextMetrics (1 << 2)
-
-static int TkMacOSXAntialiasedTextEnabled = FALSE;
-
-static char *
-TkMacOSXAntialiasedTextVariableProc(clientData, interp, name1, name2, flags)
- ClientData clientData;
- Tcl_Interp *interp;
- CONST char *name1;
- CONST char *name2;
- int flags;
-{
- TkMacOSXUseAntialiasedText(interp, TkMacOSXAntialiasedTextEnabled);
- return (char *) NULL;
-}
-
MODULE_SCOPE int
-TkMacOSXUseAntialiasedText(interp, enable)
- Tcl_Interp *interp;
- int enable;
+TkMacOSXUseAntialiasedText(
+ Tcl_Interp * interp, /* The Tcl interpreter to receive the
+ * variable .*/
+ int enable) /* Initial value. */
{
static Boolean initialized = FALSE;
- static UInt32 (*swaptextflags)(UInt32) = NULL;
-
+
if(!initialized) {
- swaptextflags = TkMacOSXGetNamedSymbol("QD", "_QDSwapTextFlags");
- if (!swaptextflags) {
- swaptextflags = TkMacOSXGetNamedSymbol("QD", "_SwapQDTextFlags");
- }
initialized = TRUE;
- TkMacOSXAntialiasedTextEnabled = (swaptextflags ? enable : FALSE);
if (Tcl_CreateNamespace(interp, "::tk::mac", NULL, NULL) == NULL) {
Tcl_ResetResult(interp);
}
- if (Tcl_TraceVar(interp, "::tk::mac::antialiasedtext",
+ if (Tcl_TraceVar(interp, "::tk::mac::antialiasedtext",
TCL_GLOBAL_ONLY | TCL_TRACE_WRITES,
TkMacOSXAntialiasedTextVariableProc, NULL) != TCL_OK) {
Tcl_ResetResult(interp);
}
if (Tcl_LinkVar(interp, "::tk::mac::antialiasedtext",
- (char *) &TkMacOSXAntialiasedTextEnabled,
- TCL_LINK_BOOLEAN) != TCL_OK) {
+ (char *) &TkMacOSXAntialiasedTextEnabled,
+ TCL_LINK_INT) != TCL_OK) {
Tcl_ResetResult(interp);
}
}
- if (swaptextflags) {
- swaptextflags(enable ? kQDUseCGTextRendering | kQDUseCGTextMetrics
- : kQDUseTrueTypeScalerGlyphs);
- TkMacOSXAntialiasedTextEnabled = enable;
- return TCL_OK;
- } else {
- TkMacOSXAntialiasedTextEnabled = FALSE;
- return TCL_ERROR;
- }
+
+ TkMacOSXAntialiasedTextEnabled = enable;
+
+ return TCL_OK;
+}
+
+static char *
+TkMacOSXAntialiasedTextVariableProc(
+ ClientData clientData,
+ Tcl_Interp * interp,
+ const char * name1,
+ const char * name2,
+ int flags)
+{
+ TkMacOSXUseAntialiasedText(interp, TkMacOSXAntialiasedTextEnabled);
+ return NULL;
}
diff --git a/macosx/tkMacOSXFont.h b/macosx/tkMacOSXFont.h
new file mode 100644
index 0000000..ad16185
--- /dev/null
+++ b/macosx/tkMacOSXFont.h
@@ -0,0 +1,113 @@
+/*
+ * tkMacOSXFont.h --
+ *
+ * Private functions and structs exported from tkMacOSXFont.c
+ * for use in ATSU specific extensions.
+ *
+ * Copyright 2002-2004 Benjamin Riefenstahl, Benjamin.Riefenstahl@epost.de
+ *
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * RCS: @(#) $Id: tkMacOSXFont.h,v 1.1 2006/03/22 00:21:18 das Exp $
+ */
+
+#ifndef TKMACOSXFONT_H
+#define TKMACOSXFONT_H 1
+
+#include "tkFont.h"
+
+/*
+ * Switches
+ */
+
+#define TK_MAC_USE_QUARZ 1
+
+/*
+ * Types
+ */
+
+/*
+ * The following structure represents our Macintosh-specific implementation
+ * of a font object.
+ */
+
+typedef struct {
+ TkFont font; /* Stuff used by generic font package. Must
+ * be first in structure. */
+
+ /*
+ * The ATSU view of the font and other text properties. Used for drawing
+ * and measuring.
+ */
+
+ ATSUFontID atsuFontId; /* == FMFont. */
+ ATSUTextLayout atsuLayout; /* ATSU layout object, representing the whole
+ * text that ATSU sees with some option
+ * bits. */
+ ATSUStyle atsuStyle; /* ATSU style object, representing a run of
+ * text with the same properties. */
+
+ /*
+ * The QuickDraw view of the font. Used to configure controls.
+ */
+
+ FMFontFamily qdFont; /* == FMFontFamilyId, Carbon replacement for
+ * QD face numbers. */
+ short qdSize; /* Font size in points. */
+ short qdStyle; /* QuickDraw style bits. */
+} TkMacOSXFont;
+
+
+#if TK_MAC_USE_QUARZ
+
+/*
+ * To use Quarz drawing we need some additional context. FIXME: We would
+ * have liked to use the similar functions from tkMacOSXDraw.c to do this
+ * (TkMacOSXSetUpCGContext(), etc), but a) those don't quite work for us
+ * (e.g. we can't use a simple upside-down coordinate system transformation,
+ * as we don't want upside-down characters ;-), and b) we don't have the
+ * necessary context information (MacDrawable), that we need as parameter for
+ * those functions. So I just cobbled together a limited edition, getting
+ * the necessary parameters from the current QD GraphPort.
+ */
+
+typedef struct {
+ CGContextRef cgContext; /* Quarz context. */
+ CGrafPtr graphPort; /* QD graph port to which this belongs.
+ * Needed for releasing cgContext. */
+ Rect portRect; /* Cached size of port. */
+} TkMacOSXFontDrawingContext;
+
+#else /* ! TK_MAC_USE_QUARZ */
+
+/*
+ * Just a dummy, so we don't have to #ifdef the parameter lists of functions
+ * that use this.
+ */
+
+typedef struct {} DrawingContext;
+
+#endif /* ? TK_MAC_USE_QUARZ */
+
+
+/*
+ * Function prototypes
+ */
+
+MODULE_SCOPE void TkMacOSXLayoutSetString(const TkMacOSXFont * fontPtr,
+ const TkMacOSXFontDrawingContext *drawingContextPtr,
+ const UniChar * uchars, int ulen);
+MODULE_SCOPE void TkMacOSXInitControlFontStyle(Tk_Font tkfont,
+ ControlFontStylePtr fsPtr);
+
+#if TK_MAC_USE_QUARZ
+MODULE_SCOPE void TkMacOSXQuarzStartDraw(
+ TkMacOSXFontDrawingContext * contextPtr);
+MODULE_SCOPE void TkMacOSXQuarzEndDraw(
+ TkMacOSXFontDrawingContext * contextPtr);
+#endif /* TK_MAC_USE_QUARZ */
+
+
+#endif /*TKMACOSXFONT_H*/
+
diff --git a/macosx/tkMacOSXMenubutton.c b/macosx/tkMacOSXMenubutton.c
index f6ed8b9..ef1ec4e 100644
--- a/macosx/tkMacOSXMenubutton.c
+++ b/macosx/tkMacOSXMenubutton.c
@@ -10,13 +10,14 @@
* See the file "license.terms" for information on usage and redistribution
* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
*
- * RCS: @(#) $Id: tkMacOSXMenubutton.c,v 1.8 2005/11/27 06:47:25 das Exp $
+ * RCS: @(#) $Id: tkMacOSXMenubutton.c,v 1.9 2006/03/22 00:21:18 das Exp $
*/
#include <Carbon/Carbon.h>
#include "tkMenu.h"
#include "tkMenubutton.h"
#include "tkMacOSXInt.h"
+#include "tkMacOSXFont.h"
#include "tkMacOSXDebug.h"
#if !defined(MAC_OS_X_VERSION_10_3) || \
@@ -90,9 +91,6 @@ static void CompareControlTitleParams(
int * styleChanged
);
-MODULE_SCOPE int TkFontGetFirstTextLayout(Tk_TextLayout layout, Tk_Font * font, char * dst);
-MODULE_SCOPE void TkMacOSXInitControlFontStyle(Tk_Font tkfont,ControlFontStylePtr fsPtr);
-
/*
* The structure below defines menubutton class behavior by means of
* procedures that can be invoked from generic window code.