586 lines
21 KiB
C++
586 lines
21 KiB
C++
//
|
|
// "$Id$"
|
|
//
|
|
// MacOS font selection routines for the Fast Light Tool Kit (FLTK).
|
|
//
|
|
// Copyright 1998-2015 by Bill Spitzak and others.
|
|
//
|
|
// This library is free software. Distribution and use rights are outlined in
|
|
// the file "COPYING" which should have been included with this file. If this
|
|
// file is missing or damaged, see the license at:
|
|
//
|
|
// http://www.fltk.org/COPYING.php
|
|
//
|
|
// Please report all bugs and problems on the following page:
|
|
//
|
|
// http://www.fltk.org/str.php
|
|
//
|
|
|
|
#include <config.h>
|
|
#include <math.h>
|
|
|
|
Fl_Fontdesc* fl_fonts = NULL;
|
|
|
|
/* from fl_utf.c */
|
|
extern unsigned fl_utf8toUtf16(const char* src, unsigned srclen, unsigned short* dst, unsigned dstlen);
|
|
|
|
static CGAffineTransform font_mx = { 1, 0, 0, -1, 0, 0 };
|
|
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
|
|
static CFMutableDictionaryRef attributes = NULL;
|
|
#endif
|
|
|
|
const int Fl_X::CoreText_threshold = 100500; // this represents Mac OS 10.5
|
|
// condition when the ATSU API is available at compile time
|
|
#define HAS_ATSU (!__LP64__) && MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_11
|
|
|
|
Fl_Font_Descriptor::Fl_Font_Descriptor(const char* name, Fl_Fontsize Size) {
|
|
next = 0;
|
|
# if HAVE_GL
|
|
listbase = 0;
|
|
# endif
|
|
|
|
// knowWidths = 0;
|
|
// OpenGL needs those for its font handling
|
|
size = Size;
|
|
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
|
|
if (fl_mac_os_version >= Fl_X::CoreText_threshold) {
|
|
CFStringRef str = CFStringCreateWithCString(NULL, name, kCFStringEncodingUTF8);
|
|
fontref = CTFontCreateWithName(str, size, NULL);
|
|
CGGlyph glyph[2];
|
|
const UniChar A[2]={'W','.'};
|
|
CTFontGetGlyphsForCharacters(fontref, A, glyph, 2);
|
|
CGSize advances[2];
|
|
double w;
|
|
CTFontGetAdvancesForGlyphs(fontref, kCTFontHorizontalOrientation, glyph, advances, 2);
|
|
w = advances[0].width;
|
|
if ( fabs(advances[0].width - advances[1].width) < 1E-2 ) {//this is a fixed-width font
|
|
// slightly rescale fixed-width fonts so the character width has an integral value
|
|
CFRelease(fontref);
|
|
CGFloat fsize = size / ( w/floor(w + 0.5) );
|
|
fontref = CTFontCreateWithName(str, fsize, NULL);
|
|
w = CTFontGetAdvancesForGlyphs(fontref, kCTFontHorizontalOrientation, glyph, NULL, 1);
|
|
}
|
|
CFRelease(str);
|
|
ascent = (short)(CTFontGetAscent(fontref) + 0.5);
|
|
descent = (short)(CTFontGetDescent(fontref) + 0.5);
|
|
q_width = w + 0.5;
|
|
for (unsigned i = 0; i < sizeof(width)/sizeof(float*); i++) width[i] = NULL;
|
|
if (!attributes) {
|
|
static CFNumberRef zero_ref;
|
|
float zero = 0.;
|
|
zero_ref = CFNumberCreate(NULL, kCFNumberFloat32Type, &zero);
|
|
// deactivate kerning for all fonts, so that string width = sum of character widths
|
|
// which allows fast fl_width() implementation.
|
|
attributes = CFDictionaryCreateMutable(kCFAllocatorDefault,
|
|
3,
|
|
&kCFTypeDictionaryKeyCallBacks,
|
|
&kCFTypeDictionaryValueCallBacks);
|
|
CFDictionarySetValue (attributes, kCTKernAttributeName, zero_ref);
|
|
}
|
|
if (ascent == 0) { // this may happen with some third party fonts
|
|
CFDictionarySetValue (attributes, kCTFontAttributeName, fontref);
|
|
CFAttributedStringRef mastr = CFAttributedStringCreate(kCFAllocatorDefault, CFSTR("Wj"), attributes);
|
|
CTLineRef ctline = CTLineCreateWithAttributedString(mastr);
|
|
CFRelease(mastr);
|
|
CGFloat fascent, fdescent;
|
|
CTLineGetTypographicBounds(ctline, &fascent, &fdescent, NULL);
|
|
CFRelease(ctline);
|
|
ascent = (short)(fascent + 0.5);
|
|
descent = (short)(fdescent + 0.5);
|
|
}
|
|
}
|
|
else {
|
|
#endif
|
|
#if HAS_ATSU
|
|
OSStatus err;
|
|
// fill our structure with a few default values
|
|
ascent = Size*3/4.;
|
|
descent = Size-ascent;
|
|
q_width = Size*2/3.;
|
|
// now we allocate everything needed to render text in this font later
|
|
// get us the default layout and style
|
|
err = ATSUCreateTextLayout(&layout);
|
|
UniChar mTxt[2] = { 65, 0 };
|
|
err = ATSUSetTextPointerLocation(layout, mTxt, kATSUFromTextBeginning, 1, 1);
|
|
err = ATSUCreateStyle(&style);
|
|
err = ATSUSetRunStyle(layout, style, kATSUFromTextBeginning, kATSUToTextEnd);
|
|
// now set the actual font, size and attributes. We also set the font matrix to
|
|
// render our font up-side-down, so when rendered through our inverted CGContext,
|
|
// text will appear normal again.
|
|
Fixed fsize = IntToFixed(Size);
|
|
ATSUFontID fontID;
|
|
ATSUFindFontFromName(name, strlen(name), kFontFullName, kFontMacintoshPlatform, kFontNoScriptCode, kFontEnglishLanguage, &fontID);
|
|
|
|
// draw the font upside-down... Compensate for fltk/OSX origin differences
|
|
ATSUAttributeTag sTag[] = { kATSUFontTag, kATSUSizeTag, kATSUFontMatrixTag };
|
|
ByteCount sBytes[] = { sizeof(ATSUFontID), sizeof(Fixed), sizeof(CGAffineTransform) };
|
|
ATSUAttributeValuePtr sAttr[] = { &fontID, &fsize, &font_mx };
|
|
if (fontID != kATSUInvalidFontID) err = ATSUSetAttributes(style, 1, sTag, sBytes, sAttr); // set the font attribute
|
|
err = ATSUSetAttributes(style, 2, sTag + 1, sBytes + 1, sAttr + 1); // then the size and matrix attributes
|
|
// next, make sure that Quartz will only render at integer coordinates
|
|
ATSLineLayoutOptions llo = kATSLineUseDeviceMetrics | kATSLineDisableAllLayoutOperations;
|
|
ATSUAttributeTag aTag[] = { kATSULineLayoutOptionsTag };
|
|
ByteCount aBytes[] = { sizeof(ATSLineLayoutOptions) };
|
|
ATSUAttributeValuePtr aAttr[] = { &llo };
|
|
err = ATSUSetLineControls (layout, kATSUFromTextBeginning, 1, aTag, aBytes, aAttr);
|
|
// now we are finally ready to measure some letter to get the bounding box
|
|
Fixed bBefore, bAfter, bAscent, bDescent;
|
|
err = ATSUGetUnjustifiedBounds(layout, kATSUFromTextBeginning, 1, &bBefore, &bAfter, &bAscent, &bDescent);
|
|
// Requesting a certain height font on Mac does not guarantee that ascent+descent
|
|
// equal the requested height. fl_height will reflect the actual height that we got.
|
|
// The font "Apple Chancery" is a pretty extreme example of overlapping letters.
|
|
float fa = -FixedToFloat(bAscent), fd = -FixedToFloat(bDescent);
|
|
if (fa>0.0f && fd>0.0f) {
|
|
//float f = Size/(fa+fd);
|
|
ascent = int(fa); //int(fa*f+0.5f);
|
|
descent = int(fd); //Size - ascent;
|
|
}
|
|
int w = FixedToInt(bAfter);
|
|
if (w)
|
|
q_width = FixedToInt(bAfter);
|
|
|
|
# define ENABLE_TRANSIENT_FONTS 1
|
|
|
|
# ifdef ENABLE_TRANSIENT_FONTS
|
|
// Now, by way of experiment, try enabling Transient Font Matching, this will
|
|
// cause ATSU to find a suitable font to render any chars the current font can't do...
|
|
ATSUSetTransientFontMatching (layout, true);
|
|
# endif
|
|
#endif//HAS_ATSU
|
|
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
|
|
}
|
|
#endif
|
|
}
|
|
|
|
Fl_Font_Descriptor::~Fl_Font_Descriptor() {
|
|
/*
|
|
#if HAVE_GL
|
|
// ++ todo: remove OpenGL font alocations
|
|
// Delete list created by gl_draw(). This is not done by this code
|
|
// as it will link in GL unnecessarily. There should be some kind
|
|
// of "free" routine pointer, or a subclass?
|
|
// if (listbase) {
|
|
// int base = font->min_char_or_byte2;
|
|
// int size = font->max_char_or_byte2-base+1;
|
|
// int base = 0; int size = 256;
|
|
// glDeleteLists(listbase+base,size);
|
|
// }
|
|
#endif
|
|
*/
|
|
if (this == fl_graphics_driver->font_descriptor()) fl_graphics_driver->font_descriptor(NULL);
|
|
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
|
|
if (fl_mac_os_version >= Fl_X::CoreText_threshold) {
|
|
CFRelease(fontref);
|
|
for (unsigned i = 0; i < sizeof(width)/sizeof(float*); i++) {
|
|
if (width[i]) free(width[i]);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////
|
|
|
|
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
|
|
static Fl_Fontdesc built_in_table_PS[] = { // PostScript font names preferred when Mac OS ≥ 10.5
|
|
{"ArialMT"},
|
|
{"Arial-BoldMT"},
|
|
{"Arial-ItalicMT"},
|
|
{"Arial-BoldItalicMT"},
|
|
{"Courier"},
|
|
{"Courier-Bold"},
|
|
{"Courier-Oblique"},
|
|
{"Courier-BoldOblique"},
|
|
{"TimesNewRomanPSMT"},
|
|
{"TimesNewRomanPS-BoldMT"},
|
|
{"TimesNewRomanPS-ItalicMT"},
|
|
{"TimesNewRomanPS-BoldItalicMT"},
|
|
{"Symbol"},
|
|
{"Monaco"},
|
|
{"AndaleMono"}, // there is no bold Monaco font on standard Mac
|
|
{"ZapfDingbatsITC"}
|
|
};
|
|
#endif
|
|
|
|
static Fl_Fontdesc built_in_table_full[] = { // full font names used before 10.5
|
|
{"Arial"},
|
|
{"Arial Bold"},
|
|
{"Arial Italic"},
|
|
{"Arial Bold Italic"},
|
|
{"Courier"},
|
|
{"Courier Bold"},
|
|
{"Courier New Italic"},
|
|
{"Courier New Bold Italic"},
|
|
{"Times New Roman"},
|
|
{"Times New Roman Bold"},
|
|
{"Times New Roman Italic"},
|
|
{"Times New Roman Bold Italic"},
|
|
{"Symbol"},
|
|
{"Monaco"},
|
|
{"Andale Mono"}, // there is no bold Monaco font on standard Mac
|
|
{"Webdings"}
|
|
};
|
|
|
|
static UniChar *utfWbuf = 0;
|
|
static unsigned utfWlen = 0;
|
|
|
|
static UniChar *mac_Utf8_to_Utf16(const char *txt, int len, int *new_len)
|
|
{
|
|
unsigned wlen = fl_utf8toUtf16(txt, len, (unsigned short*)utfWbuf, utfWlen);
|
|
if (wlen >= utfWlen)
|
|
{
|
|
utfWlen = wlen + 100;
|
|
if (utfWbuf) free(utfWbuf);
|
|
utfWbuf = (UniChar*)malloc((utfWlen)*sizeof(UniChar));
|
|
wlen = fl_utf8toUtf16(txt, len, (unsigned short*)utfWbuf, utfWlen);
|
|
}
|
|
*new_len = wlen;
|
|
return utfWbuf;
|
|
} // mac_Utf8_to_Utf16
|
|
|
|
Fl_Fontdesc* Fl_X::calc_fl_fonts(void)
|
|
{
|
|
if (!fl_mac_os_version) fl_mac_os_version = calc_mac_os_version();
|
|
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
|
|
return (fl_mac_os_version >= Fl_X::CoreText_threshold ? built_in_table_PS : built_in_table_full);
|
|
#else
|
|
return built_in_table_full;
|
|
#endif
|
|
}
|
|
|
|
static Fl_Font_Descriptor* find(Fl_Font fnum, Fl_Fontsize size) {
|
|
if (!fl_fonts) fl_fonts = Fl_X::calc_fl_fonts();
|
|
Fl_Fontdesc* s = fl_fonts+fnum;
|
|
if (!s->name) s = fl_fonts; // use 0 if fnum undefined
|
|
Fl_Font_Descriptor* f;
|
|
for (f = s->first; f; f = f->next)
|
|
if (f->size == size) return f;
|
|
f = new Fl_Font_Descriptor(s->name, size);
|
|
f->next = s->first;
|
|
s->first = f;
|
|
return f;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////
|
|
// Public interface:
|
|
|
|
void Fl_Quartz_Graphics_Driver::font(Fl_Font fnum, Fl_Fontsize size) {
|
|
if (fnum==-1) {
|
|
Fl_Graphics_Driver::font(0, 0);
|
|
return;
|
|
}
|
|
Fl_Graphics_Driver::font(fnum, size);
|
|
this->font_descriptor( find(fnum, size) );
|
|
}
|
|
|
|
int Fl_Quartz_Graphics_Driver::height() {
|
|
if (!font_descriptor()) font(FL_HELVETICA, FL_NORMAL_SIZE);
|
|
Fl_Font_Descriptor *fl_fontsize = font_descriptor();
|
|
return fl_fontsize->ascent + fl_fontsize->descent;
|
|
}
|
|
|
|
int Fl_Quartz_Graphics_Driver::descent() {
|
|
if (!font_descriptor()) font(FL_HELVETICA, FL_NORMAL_SIZE);
|
|
Fl_Font_Descriptor *fl_fontsize = font_descriptor();
|
|
return fl_fontsize->descent+1;
|
|
}
|
|
|
|
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
|
|
// returns width of a pair of UniChar's in the surrogate range
|
|
static CGFloat surrogate_width(const UniChar *txt, Fl_Font_Descriptor *fl_fontsize)
|
|
{
|
|
CTFontRef font2 = fl_fontsize->fontref;
|
|
bool must_release = false;
|
|
CGGlyph glyphs[2];
|
|
bool b = CTFontGetGlyphsForCharacters(font2, txt, glyphs, 2);
|
|
CGSize a;
|
|
if(!b) { // the current font doesn't contain this char
|
|
CFStringRef str = CFStringCreateWithCharactersNoCopy(NULL, txt, 2, kCFAllocatorNull);
|
|
// find a font that contains it
|
|
font2 = CTFontCreateForString(font2, str, CFRangeMake(0,2));
|
|
must_release = true;
|
|
CFRelease(str);
|
|
b = CTFontGetGlyphsForCharacters(font2, txt, glyphs, 2);
|
|
}
|
|
if (b) CTFontGetAdvancesForGlyphs(font2, kCTFontHorizontalOrientation, glyphs, &a, 1);
|
|
else a.width = fl_fontsize->q_width;
|
|
if(must_release) CFRelease(font2);
|
|
return a.width;
|
|
}
|
|
|
|
static CGFloat variation_selector_width(CFStringRef str16, Fl_Font_Descriptor *fl_fontsize)
|
|
{
|
|
CGFloat retval;
|
|
CFDictionarySetValue(attributes, kCTFontAttributeName, fl_fontsize->fontref);
|
|
CFAttributedStringRef mastr = CFAttributedStringCreate(kCFAllocatorDefault, str16, attributes);
|
|
CTLineRef ctline = CTLineCreateWithAttributedString(mastr);
|
|
CFRelease(mastr);
|
|
retval = CTLineGetOffsetForStringIndex(ctline, 2, NULL);
|
|
CFRelease(ctline);
|
|
return retval;
|
|
}
|
|
#endif
|
|
|
|
static double fl_mac_width(const UniChar* txt, int n, Fl_Font_Descriptor *fl_fontsize) {
|
|
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
|
|
if (fl_mac_os_version >= Fl_X::CoreText_threshold) {
|
|
double retval = 0;
|
|
UniChar uni;
|
|
int i;
|
|
for (i = 0; i < n; i++) { // loop over txt
|
|
uni = txt[i];
|
|
if (uni >= 0xD800 && uni <= 0xDBFF) { // handles the surrogate range
|
|
retval += surrogate_width(&txt[i], fl_fontsize);
|
|
i++; // because a pair of UniChar's represent a single character
|
|
continue;
|
|
}
|
|
if (i+1 < n && txt[i+1] >= 0xFE00 && txt[i+1] <= 0xFE0F) { // handles variation selectors
|
|
CFStringRef substr = CFStringCreateWithCharacters(NULL, txt + i, 2);
|
|
retval += variation_selector_width(substr, fl_fontsize);
|
|
CFRelease(substr);
|
|
i++;
|
|
continue;
|
|
}
|
|
const int block = 0x10000 / (sizeof(fl_fontsize->width)/sizeof(float*)); // block size
|
|
// r: index of the character block containing uni
|
|
unsigned int r = uni >> 7; // change 7 if sizeof(width) is changed
|
|
if (!fl_fontsize->width[r]) { // this character block has not been hit yet
|
|
//fprintf(stderr,"r=%d size=%d name=%s\n",r,fl_fontsize->size,fl_fonts[fl_font()].name);
|
|
// allocate memory to hold width of each character in the block
|
|
fl_fontsize->width[r] = (float*) malloc(sizeof(float) * block);
|
|
UniChar ii = r * block;
|
|
CGSize advance_size;
|
|
CGGlyph glyph;
|
|
for (int j = 0; j < block; j++) { // loop over the block
|
|
// ii spans all characters of this block
|
|
bool b = CTFontGetGlyphsForCharacters(fl_fontsize->fontref, &ii, &glyph, 1);
|
|
if (b)
|
|
CTFontGetAdvancesForGlyphs(fl_fontsize->fontref, kCTFontHorizontalOrientation, &glyph, &advance_size, 1);
|
|
else
|
|
advance_size.width = -1e9; // calculate this later
|
|
// the width of one character of this block of characters
|
|
fl_fontsize->width[r][j] = advance_size.width;
|
|
ii++;
|
|
}
|
|
}
|
|
// sum the widths of all characters of txt
|
|
double wdt = fl_fontsize->width[r][uni & (block-1)];
|
|
if (wdt == -1e9) {
|
|
CGSize advance_size;
|
|
CGGlyph glyph;
|
|
CTFontRef font2 = fl_fontsize->fontref;
|
|
bool must_release = false;
|
|
bool b = CTFontGetGlyphsForCharacters(font2, &uni, &glyph, 1);
|
|
if (!b) { // the current font doesn't contain this char
|
|
CFStringRef str = CFStringCreateWithCharactersNoCopy(NULL, &uni, 1, kCFAllocatorNull);
|
|
// find a font that contains it
|
|
font2 = CTFontCreateForString(font2, str, CFRangeMake(0,1));
|
|
must_release = true;
|
|
CFRelease(str);
|
|
b = CTFontGetGlyphsForCharacters(font2, &uni, &glyph, 1);
|
|
}
|
|
if (b) CTFontGetAdvancesForGlyphs(font2, kCTFontHorizontalOrientation, &glyph, &advance_size, 1);
|
|
else advance_size.width = 0.;
|
|
// the width of the 'uni' character
|
|
wdt = fl_fontsize->width[r][uni & (block-1)] = advance_size.width;
|
|
if (must_release) CFRelease(font2);
|
|
}
|
|
retval += wdt;
|
|
}
|
|
return retval;
|
|
} else {
|
|
#endif
|
|
#if HAS_ATSU
|
|
OSStatus err;
|
|
Fixed bBefore, bAfter, bAscent, bDescent;
|
|
ATSUTextLayout layout;
|
|
ByteCount iSize;
|
|
ATSUAttributeTag iTag;
|
|
ATSUAttributeValuePtr iValuePtr;
|
|
|
|
// Here's my ATSU text measuring attempt... This seems to do the Right Thing
|
|
// now collect our ATSU resources and measure our text string
|
|
layout = fl_fontsize->layout;
|
|
// activate the current GC
|
|
iSize = sizeof(CGContextRef);
|
|
iTag = kATSUCGContextTag;
|
|
iValuePtr = &fl_gc;
|
|
ATSUSetLayoutControls(layout, 1, &iTag, &iSize, &iValuePtr);
|
|
// now measure the bounding box
|
|
err = ATSUSetTextPointerLocation(layout, txt, kATSUFromTextBeginning, n, n);
|
|
err = ATSUGetUnjustifiedBounds(layout, kATSUFromTextBeginning, n, &bBefore, &bAfter, &bAscent, &bDescent);
|
|
// If err is OK then return length, else return 0. Or something...
|
|
int len = FixedToInt(bAfter);
|
|
return len;
|
|
#endif
|
|
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
|
|
}
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
double Fl_Quartz_Graphics_Driver::width(const char* txt, int n) {
|
|
int wc_len = n;
|
|
UniChar *uniStr = mac_Utf8_to_Utf16(txt, n, &wc_len);
|
|
if (!font_descriptor()) font(FL_HELVETICA, FL_NORMAL_SIZE);
|
|
return fl_mac_width(uniStr, wc_len, font_descriptor());
|
|
}
|
|
|
|
double Fl_Quartz_Graphics_Driver::width(unsigned int wc) {
|
|
if (!font_descriptor()) font(FL_HELVETICA, FL_NORMAL_SIZE);
|
|
|
|
UniChar utf16[3];
|
|
int l = 1;
|
|
if (wc <= 0xFFFF) {
|
|
*utf16 = wc;
|
|
}
|
|
else {
|
|
// char buf[4];
|
|
// l = fl_utf8encode(wc, buf);
|
|
// l = (int)fl_utf8toUtf16(buf, l, utf16, 3);
|
|
l = (int)fl_ucs_to_Utf16(wc, utf16, 3);
|
|
}
|
|
return fl_mac_width(utf16, l, font_descriptor());
|
|
}
|
|
|
|
// text extent calculation
|
|
void Fl_Quartz_Graphics_Driver::text_extents(const char *str8, int n, int &dx, int &dy, int &w, int &h) {
|
|
if (!font_descriptor()) font(FL_HELVETICA, FL_NORMAL_SIZE);
|
|
Fl_Font_Descriptor *fl_fontsize = font_descriptor();
|
|
UniChar *txt = mac_Utf8_to_Utf16(str8, n, &n);
|
|
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
|
|
if (fl_mac_os_version >= Fl_X::CoreText_threshold) {
|
|
CFStringRef str16 = CFStringCreateWithCharactersNoCopy(NULL, txt, n, kCFAllocatorNull);
|
|
CFDictionarySetValue (attributes, kCTFontAttributeName, fl_fontsize->fontref);
|
|
CFAttributedStringRef mastr = CFAttributedStringCreate(kCFAllocatorDefault, str16, attributes);
|
|
CFRelease(str16);
|
|
CTLineRef ctline = CTLineCreateWithAttributedString(mastr);
|
|
CFRelease(mastr);
|
|
CGContextSetTextPosition(fl_gc, 0, 0);
|
|
CGContextSetShouldAntialias(fl_gc, true);
|
|
CGRect rect = CTLineGetImageBounds(ctline, fl_gc);
|
|
CGContextSetShouldAntialias(fl_gc, false);
|
|
CFRelease(ctline);
|
|
dx = floor(rect.origin.x + 0.5);
|
|
dy = floor(- rect.origin.y - rect.size.height + 0.5);
|
|
w = rect.size.width + 0.5;
|
|
h = rect.size.height + 0.5;
|
|
}
|
|
else {
|
|
#endif
|
|
#if HAS_ATSU
|
|
OSStatus err;
|
|
ATSUTextLayout layout;
|
|
ByteCount iSize;
|
|
ATSUAttributeTag iTag;
|
|
ATSUAttributeValuePtr iValuePtr;
|
|
|
|
// Here's my ATSU text measuring attempt... This seems to do the Right Thing
|
|
// now collect our ATSU resources and measure our text string
|
|
layout = fl_fontsize->layout;
|
|
// activate the current GC
|
|
iSize = sizeof(CGContextRef);
|
|
iTag = kATSUCGContextTag;
|
|
iValuePtr = &fl_gc;
|
|
ATSUSetLayoutControls(layout, 1, &iTag, &iSize, &iValuePtr);
|
|
// now measure the bounding box
|
|
err = ATSUSetTextPointerLocation(layout, txt, kATSUFromTextBeginning, n, n);
|
|
Rect bbox;
|
|
err = ATSUMeasureTextImage(layout, kATSUFromTextBeginning, n, 0, 0, &bbox);
|
|
w = bbox.right - bbox.left;
|
|
h = bbox.bottom - bbox.top;
|
|
dx = bbox.left;
|
|
dy = -bbox.bottom;
|
|
//printf("r: %d l: %d t: %d b: %d w: %d h: %d\n", bbox.right, bbox.left, bbox.top, bbox.bottom, w, h);
|
|
#endif
|
|
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
|
|
}
|
|
#endif
|
|
return;
|
|
} // fl_text_extents
|
|
|
|
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
|
|
static CGColorRef flcolortocgcolor(Fl_Color i)
|
|
{
|
|
uchar r, g, b;
|
|
Fl::get_color(i, r, g, b);
|
|
CGFloat components[4] = {r/255.0f, g/255.0f, b/255.0f, 1.};
|
|
static CGColorSpaceRef cspace = NULL;
|
|
if (cspace == NULL) {
|
|
cspace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
|
|
}
|
|
return CGColorCreate(cspace, components);
|
|
}
|
|
#endif
|
|
|
|
static void fl_mac_draw(const char *str, int n, float x, float y, Fl_Graphics_Driver *driver) {
|
|
// convert to UTF-16 first
|
|
UniChar *uniStr = mac_Utf8_to_Utf16(str, n, &n);
|
|
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
|
|
if (fl_mac_os_version >= Fl_X::CoreText_threshold) {
|
|
CFMutableStringRef str16 = CFStringCreateMutableWithExternalCharactersNoCopy(NULL, uniStr, n, n, kCFAllocatorNull);
|
|
if (str16 == NULL) return; // shd not happen
|
|
CGColorRef color = flcolortocgcolor(driver->color());
|
|
CFDictionarySetValue (attributes, kCTFontAttributeName, driver->font_descriptor()->fontref);
|
|
CFDictionarySetValue (attributes, kCTForegroundColorAttributeName, color);
|
|
CFAttributedStringRef mastr = CFAttributedStringCreate(kCFAllocatorDefault, str16, attributes);
|
|
CFRelease(str16);
|
|
CFRelease(color);
|
|
CTLineRef ctline = CTLineCreateWithAttributedString(mastr);
|
|
CFRelease(mastr);
|
|
CGContextSetTextMatrix(fl_gc, font_mx);
|
|
CGContextSetTextPosition(fl_gc, x, y);
|
|
CGContextSetShouldAntialias(fl_gc, true);
|
|
CTLineDraw(ctline, fl_gc);
|
|
CGContextSetShouldAntialias(fl_gc, false);
|
|
CFRelease(ctline);
|
|
} else {
|
|
#endif
|
|
#if HAS_ATSU
|
|
OSStatus err;
|
|
// now collect our ATSU resources
|
|
ATSUTextLayout layout = driver->font_descriptor()->layout;
|
|
|
|
ByteCount iSize = sizeof(CGContextRef);
|
|
ATSUAttributeTag iTag = kATSUCGContextTag;
|
|
ATSUAttributeValuePtr iValuePtr=&fl_gc;
|
|
ATSUSetLayoutControls(layout, 1, &iTag, &iSize, &iValuePtr);
|
|
|
|
err = ATSUSetTextPointerLocation(layout, uniStr, kATSUFromTextBeginning, n, n);
|
|
CGContextSetShouldAntialias(fl_gc, true);
|
|
err = ATSUDrawText(layout, kATSUFromTextBeginning, n, FloatToFixed(x), FloatToFixed(y));
|
|
CGContextSetShouldAntialias(fl_gc, false);
|
|
#endif
|
|
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void Fl_Quartz_Graphics_Driver::draw(const char *str, int n, float x, float y) {
|
|
// avoid a crash if no font has been selected by user yet !
|
|
if (!font_descriptor()) font(FL_HELVETICA, FL_NORMAL_SIZE);
|
|
fl_mac_draw(str, n, x, y, this);
|
|
}
|
|
|
|
void Fl_Quartz_Graphics_Driver::draw(const char* str, int n, int x, int y) {
|
|
// avoid a crash if no font has been selected by user yet !
|
|
if (!font_descriptor()) font(FL_HELVETICA, FL_NORMAL_SIZE);
|
|
fl_mac_draw(str, n, (float)x-0.0f, (float)y+0.5f, this);
|
|
}
|
|
|
|
void Fl_Quartz_Graphics_Driver::draw(int angle, const char *str, int n, int x, int y) {
|
|
CGContextSaveGState(fl_gc);
|
|
CGContextTranslateCTM(fl_gc, x, y);
|
|
CGContextRotateCTM(fl_gc, - angle*(M_PI/180) );
|
|
draw(str, n, 0, 0);
|
|
CGContextRestoreGState(fl_gc);
|
|
}
|
|
|
|
void Fl_Quartz_Graphics_Driver::rtl_draw(const char* c, int n, int x, int y) {
|
|
int dx, dy, w, h;
|
|
text_extents(c, n, dx, dy, w, h);
|
|
draw(c, n, x - w - dx, y);
|
|
}
|
|
|
|
//
|
|
// End of "$Id$".
|
|
//
|