void
XeTeXFontInst_Mac::initialize(int &status)
{
if (m_descriptor == 0) {
status = 1;
return;
}
if (status != 0)
m_descriptor = 0;
// Create a copy of original font descriptor with font cascading (fallback) disabled
CFArrayRef emptyCascadeList = CFArrayCreate(NULL, NULL, 0, &kCFTypeArrayCallBacks);
const void* values[] = { emptyCascadeList };
static const void* attributeKeys[] = { kCTFontCascadeListAttribute };
CFDictionaryRef attributes = CFDictionaryCreate(NULL, attributeKeys, values, 1,
&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFRelease(emptyCascadeList);
m_descriptor = CTFontDescriptorCreateCopyWithAttributes(m_descriptor, attributes);
CFRelease(attributes);
m_fontRef = CTFontCreateWithFontDescriptor(m_descriptor, m_pointSize * 72.0 / 72.27, NULL);
if (m_fontRef) {
char *pathname;
uint32_t index;
pathname = getFileNameFromCTFont(m_fontRef, &index);
XeTeXFontInst::initialize(pathname, index, status);
} else {
status = 1;
CFRelease(m_descriptor);
m_descriptor = 0;
}
}
void drawTextWithFeature(CGContextRef context, CTFontDescriptorRef fontDescriptor, CFStringRef feature, int value, CGPoint location)
{
CGFloat fontSize = 25;
CGContextSetTextMatrix(context, CGAffineTransformScale(CGAffineTransformIdentity, 1, 1));
CGContextSetTextPosition(context, location.x, location.y);
CFNumberRef featureValue = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &value);
CFTypeRef featureDictionaryKeys[] = { kCTFontOpenTypeFeatureTag, kCTFontOpenTypeFeatureValue };
CFTypeRef featureDictionaryValues[] = { feature, featureValue };
CFDictionaryRef featureDictionary = CFDictionaryCreate(kCFAllocatorDefault, featureDictionaryKeys, featureDictionaryValues, 2, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFRelease(featureValue);
CFTypeRef featureSettingsValues[] = { featureDictionary };
CFArrayRef fontFeatureSettings = CFArrayCreate(kCFAllocatorDefault, featureSettingsValues, 1, &kCFTypeArrayCallBacks);
CFRelease(featureDictionary);
CFTypeRef fontDescriptorKeys[] = { kCTFontFeatureSettingsAttribute };
CFTypeRef fontDescriptorValues[] = { fontFeatureSettings };
CFDictionaryRef fontDescriptorAttributes = CFDictionaryCreate(kCFAllocatorDefault, fontDescriptorKeys, fontDescriptorValues, 1, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFRelease(fontFeatureSettings);
CTFontDescriptorRef modifiedFontDescriptor = CTFontDescriptorCreateCopyWithAttributes(fontDescriptor, fontDescriptorAttributes);
CFRelease(fontDescriptorAttributes);
CTFontRef font = CTFontCreateWithFontDescriptor(modifiedFontDescriptor, fontSize, nullptr);
CFRelease(modifiedFontDescriptor);
CFMutableStringRef string = CFStringCreateMutable(kCFAllocatorDefault, 0);
CFStringAppend(string, feature);
CFStringAppend(string, value ? CFSTR(" (on)") : CFSTR(" (off)"));
CFStringAppend(string, CFSTR(": ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
CGColorRef red = CGColorCreateGenericRGB(1, 0, 0, 1);
CFTypeRef lineKeys[] = { kCTForegroundColorAttributeName };
CFTypeRef lineValues[] = { red };
CFDictionaryRef lineAttributes = CFDictionaryCreate(kCFAllocatorDefault, lineKeys, lineValues, 1, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CGColorRelease(red);
CFAttributedStringRef attributedString = CFAttributedStringCreate(kCFAllocatorDefault, string, lineAttributes);
CFRelease(lineAttributes);
CFRelease(string);
CFMutableAttributedStringRef mutableAttributedString = CFAttributedStringCreateMutableCopy(kCFAllocatorDefault, 0, attributedString);
CFRelease(attributedString);
CTFontRef monospaceFont = CTFontCreateWithName(CFSTR("Courier"), fontSize, nullptr);
CFAttributedStringSetAttribute(mutableAttributedString, CFRangeMake(0, 12), kCTFontAttributeName, monospaceFont);
CFRelease(monospaceFont);
CFAttributedStringSetAttribute(mutableAttributedString, CFRangeMake(12, 52), kCTFontAttributeName, font);
CFRelease(font);
CTLineRef line = CTLineCreateWithAttributedString(mutableAttributedString);
CFRelease(mutableAttributedString);
CTLineDraw(line, context);
CFRelease(line);
}
FontPlatformData FontCustomPlatformData::fontPlatformData(const FontDescription& fontDescription, bool bold, bool italic, const FontFeatureSettings& fontFaceFeatures, const FontVariantSettings& fontFaceVariantSettings)
{
int size = fontDescription.computedPixelSize();
FontOrientation orientation = fontDescription.orientation();
FontWidthVariant widthVariant = fontDescription.widthVariant();
RetainPtr<CTFontRef> font = adoptCF(CTFontCreateWithFontDescriptor(m_fontDescriptor.get(), size, nullptr));
font = preparePlatformFont(font.get(), fontDescription.textRenderingMode(), &fontFaceFeatures, &fontFaceVariantSettings, fontDescription.featureSettings(), fontDescription.variantSettings());
return FontPlatformData(font.get(), size, bold, italic, orientation, widthVariant, fontDescription.textRenderingMode());
}
FontPlatformData FontCustomPlatformData::fontPlatformData(const FontDescription& fontDescription, bool bold, bool italic)
{
int size = fontDescription.computedPixelSize();
FontOrientation orientation = fontDescription.orientation();
FontWidthVariant widthVariant = fontDescription.widthVariant();
#if CORETEXT_WEB_FONTS
RetainPtr<CTFontRef> font = adoptCF(CTFontCreateWithFontDescriptor(m_fontDescriptor.get(), size, nullptr));
font = preparePlatformFont(font.get(), fontDescription.textRenderingMode(), fontDescription.featureSettings());
return FontPlatformData(font.get(), size, bold, italic, orientation, widthVariant, fontDescription.textRenderingMode());
#else
return FontPlatformData(m_cgFont.get(), size, bold, italic, orientation, widthVariant, fontDescription.textRenderingMode());
#endif
}
QString QFontDatabase::resolveFontFamilyAlias(const QString &family)
{
QCFString expectedFamily = QCFString(family);
QCFType<CFMutableDictionaryRef> attributes = CFDictionaryCreateMutable(NULL, 0,
&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFDictionaryAddValue(attributes, kCTFontFamilyNameAttribute, expectedFamily);
QCFType<CTFontDescriptorRef> descriptor = CTFontDescriptorCreateWithAttributes(attributes);
QCFType<CFMutableSetRef> mandatoryAttributes = CFSetCreateMutable(NULL, 0, &kCFTypeSetCallBacks);
CFSetAddValue(mandatoryAttributes, kCTFontFamilyNameAttribute);
QCFType<CTFontRef> font = CTFontCreateWithFontDescriptor(descriptor, 0.0, NULL);
QCFType<CTFontDescriptorRef> matched = CTFontDescriptorCreateMatchingFontDescriptor(descriptor, mandatoryAttributes);
if (!matched)
return family;
QCFString familyName = (CFStringRef) CTFontDescriptorCopyLocalizedAttribute(matched, kCTFontFamilyNameAttribute, NULL);
return familyName;
}
void sdl_osd_interface::init(running_machine &machine)
{
// call our parent
osd_interface::init(machine);
sdl_options &options = downcast<sdl_options &>(machine.options());
const char *stemp;
// Switchres
if (machine.options().modeline())
switchres_modeline_setup(machine);
// determine if we are benchmarking, and adjust options appropriately
int bench = options.bench();
astring error_string;
if (bench > 0)
{
options.set_value(OPTION_THROTTLE, false, OPTION_PRIORITY_MAXIMUM, error_string);
options.set_value(OPTION_SOUND, false, OPTION_PRIORITY_MAXIMUM, error_string);
options.set_value(SDLOPTION_VIDEO, "none", OPTION_PRIORITY_MAXIMUM, error_string);
options.set_value(OPTION_SECONDS_TO_RUN, bench, OPTION_PRIORITY_MAXIMUM, error_string);
assert(!error_string);
}
// Some driver options - must be before audio init!
stemp = options.audio_driver();
if (stemp != NULL && strcmp(stemp, SDLOPTVAL_AUTO) != 0)
{
mame_printf_verbose("Setting SDL audiodriver '%s' ...\n", stemp);
osd_setenv(SDLENV_AUDIODRIVER, stemp, 1);
}
stemp = options.video_driver();
if (stemp != NULL && strcmp(stemp, SDLOPTVAL_AUTO) != 0)
{
mame_printf_verbose("Setting SDL videodriver '%s' ...\n", stemp);
osd_setenv(SDLENV_VIDEODRIVER, stemp, 1);
}
#if (SDLMAME_SDL2)
stemp = options.render_driver();
if (stemp != NULL && strcmp(stemp, SDLOPTVAL_AUTO) != 0)
{
mame_printf_verbose("Setting SDL renderdriver '%s' ...\n", stemp);
//osd_setenv(SDLENV_RENDERDRIVER, stemp, 1);
SDL_SetHint(SDL_HINT_RENDER_DRIVER, stemp);
}
#endif
/* Set the SDL environment variable for drivers wanting to load the
* lib at startup.
*/
#if USE_OPENGL
/* FIXME: move lib loading code from drawogl.c here */
stemp = options.gl_lib();
if (stemp != NULL && strcmp(stemp, SDLOPTVAL_AUTO) != 0)
{
osd_setenv("SDL_VIDEO_GL_DRIVER", stemp, 1);
mame_printf_verbose("Setting SDL_VIDEO_GL_DRIVER = '%s' ...\n", stemp);
}
#endif
/* get number of processors */
stemp = options.numprocessors();
osd_num_processors = 0;
if (strcmp(stemp, "auto") != 0)
{
osd_num_processors = atoi(stemp);
if (osd_num_processors < 1)
{
mame_printf_warning("Warning: numprocessors < 1 doesn't make much sense. Assuming auto ...\n");
osd_num_processors = 0;
}
}
/* Initialize SDL */
if (!SDLMAME_INIT_IN_WORKER_THREAD)
{
#if (SDLMAME_SDL2)
if (SDL_InitSubSystem(SDL_INIT_TIMER|SDL_INIT_AUDIO| SDL_INIT_VIDEO| SDL_INIT_JOYSTICK|SDL_INIT_NOPARACHUTE)) {
#else
if (SDL_Init(SDL_INIT_TIMER|SDL_INIT_AUDIO| SDL_INIT_VIDEO| SDL_INIT_JOYSTICK|SDL_INIT_NOPARACHUTE)) {
#endif
mame_printf_error("Could not initialize SDL %s\n", SDL_GetError());
exit(-1);
}
osd_sdl_info();
}
// must be before sdlvideo_init!
machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(osd_exit), &machine));
defines_verbose();
if (!SDLMAME_HAS_DEBUGGER)
if (machine.debug_flags & DEBUG_FLAG_OSD_ENABLED)
{
mame_printf_error("sdlmame: -debug not supported on X11-less builds\n\n");
osd_exit(machine);
exit(-1);
}
if (sdlvideo_init(machine))
{
osd_exit(machine);
mame_printf_error("sdlvideo_init: Initialization failed!\n\n\n");
fflush(stderr);
fflush(stdout);
exit(-1);
}
sdlinput_init(machine);
sdlaudio_init(machine);
sdloutput_init(machine);
#ifdef SDLMAME_NETWORK
sdlnetdev_init(machine);
#endif
if (options.oslog())
machine.add_logerror_callback(output_oslog);
/* now setup watchdog */
int watchdog_timeout = options.watchdog();
int str = options.seconds_to_run();
/* only enable watchdog if seconds_to_run is enabled *and* relatively short (time taken from ui.c) */
if ((watchdog_timeout != 0) && (str > 0) && (str < 60*5 ))
{
m_watchdog = auto_alloc(machine, watchdog);
m_watchdog->setTimeout(watchdog_timeout);
}
#if (SDLMAME_SDL2)
SDL_EventState(SDL_TEXTINPUT, SDL_TRUE);
#else
SDL_EnableUNICODE(SDL_TRUE);
#endif
}
#ifdef SDLMAME_UNIX
#define POINT_SIZE 144.0
#ifdef SDLMAME_MACOSX
#define EXTRA_HEIGHT 1.0
#define EXTRA_WIDTH 1.15
//-------------------------------------------------
// font_open - attempt to "open" a handle to the
// font with the given name
//-------------------------------------------------
osd_font sdl_osd_interface::font_open(const char *_name, int &height)
{
CFStringRef font_name = NULL;
CTFontRef ct_font = NULL;
CTFontDescriptorRef font_descriptor;
CGAffineTransform affine_transform = CGAffineTransformIdentity;
astring name(_name);
if (name == "default")
{
name = "LucidaGrande";
}
/* handle bdf fonts in the core */
if (name.len() > 4)
if (name.makeupper().substr(name.len()-4,4) == ".BDF" )
return NULL;
font_name = CFStringCreateWithCString( NULL, _name, kCFStringEncodingUTF8 );
if( font_name != NULL )
{
font_descriptor = CTFontDescriptorCreateWithNameAndSize( font_name, POINT_SIZE );
if( font_descriptor != NULL )
{
ct_font = CTFontCreateWithFontDescriptor( font_descriptor, POINT_SIZE, &affine_transform );
CFRelease( font_descriptor );
}
}
CFRelease( font_name );
if (!ct_font)
{
printf("WARNING: Couldn't find/open font %s, using MAME default\n", name.cstr());
return NULL;
}
CFStringRef real_name = CTFontCopyPostScriptName( ct_font );
char real_name_c_string[255];
CFStringGetCString ( real_name, real_name_c_string, 255, kCFStringEncodingUTF8 );
mame_printf_verbose("Matching font: %s\n", real_name_c_string);
CFRelease( real_name );
CGFloat line_height = 0.0;
line_height += CTFontGetAscent(ct_font);
line_height += CTFontGetDescent(ct_font);
line_height += CTFontGetLeading(ct_font);
height = ceilf(line_height * EXTRA_HEIGHT);
return (osd_font)ct_font;
}
void QFontDatabase::load(const QFontPrivate *d, int script)
{
// sanity checks
if(!qApp)
qWarning("QFont: Must construct a QApplication before a QFont");
Q_ASSERT(script >= 0 && script < QUnicodeTables::ScriptCount);
Q_UNUSED(script);
QFontDef req = d->request;
req.pixelSize = qt_mac_pixelsize(req, d->dpi);
// set the point size to 0 to get better caching
req.pointSize = 0;
QFontCache::Key key = QFontCache::Key(req, QUnicodeTables::Common, d->screen);
if(!(d->engineData = QFontCache::instance()->findEngineData(key))) {
d->engineData = new QFontEngineData;
QFontCache::instance()->insertEngineData(key, d->engineData);
} else {
d->engineData->ref.ref();
}
if(d->engineData->engine) // already loaded
return;
// set it to the actual pointsize, so QFontInfo will do the right thing
req.pointSize = qRound(qt_mac_pointsize(d->request, d->dpi));
QFontEngine *e = QFontCache::instance()->findEngine(key);
if(!e && qt_enable_test_font && req.family == QLatin1String("__Qt__Box__Engine__")) {
e = new QTestFontEngine(req.pixelSize);
e->fontDef = req;
}
if(e) {
e->ref.ref();
d->engineData->engine = e;
return; // the font info and fontdef should already be filled
}
QFontEngine *engine = NULL;
#if defined(QT_MAC_USE_COCOA)
// Shortcut to get the font directly without going through the font database
if (!req.family.isEmpty() && !req.styleName.isEmpty()) {
QCFString expectedFamily = QCFString(req.family);
QCFString expectedStyle = QCFString(req.styleName);
QCFType<CFMutableDictionaryRef> attributes = CFDictionaryCreateMutable(NULL, 0,
&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFDictionaryAddValue(attributes, kCTFontFamilyNameAttribute, expectedFamily);
CFDictionaryAddValue(attributes, kCTFontStyleNameAttribute, expectedStyle);
QCFType<CTFontDescriptorRef> descriptor = CTFontDescriptorCreateWithAttributes(attributes);
CGAffineTransform transform = qt_transform_from_fontdef(req);
QCFType<CTFontRef> ctFont = CTFontCreateWithFontDescriptor(descriptor, req.pixelSize, &transform);
if (ctFont) {
QCFString familyName = CTFontCopyFamilyName(ctFont);
// Only accept the font if the family name is exactly the same as we specified
if (CFEqual(expectedFamily, familyName)) {
engine = new QCoreTextFontEngineMulti(ctFont, req, d->kerning);
}
}
}
#endif
if (!engine)
engine = loadFromDatabase(req, d);
if (engine) {
d->engineData->engine = engine;
engine->ref.ref();
QFontCache::instance()->insertEngine(key, engine);
}
}
static QFontEngine *loadFromDatabase(QFontDef &req, const QFontPrivate *d)
{
#if defined(QT_MAC_USE_COCOA)
QCFString fontName = NULL;
#else
ATSFontFamilyRef familyRef = 0;
ATSFontRef fontRef = 0;
#endif
QStringList family_list = familyList(req);
const char *stylehint = styleHint(req);
if (stylehint)
family_list << QLatin1String(stylehint);
// add QFont::defaultFamily() to the list, for compatibility with previous versions
family_list << QApplication::font().defaultFamily();
QMutexLocker locker(fontDatabaseMutex());
QFontDatabasePrivate *db = privateDb();
if (!db->count)
initializeDb();
for (int i = 0; i < family_list.size(); ++i) {
for (int k = 0; k < db->count; ++k) {
if (db->families[k]->name.compare(family_list.at(i), Qt::CaseInsensitive) == 0) {
#if defined(QT_MAC_USE_COCOA)
CFStringRef familyName = QCFString::toCFStringRef(db->families[k]->name);
QCFType<CTFontDescriptorRef> descriptor = CTFontDescriptorCreateWithAttributes(
QCFType<CFDictionaryRef>(CFDictionaryCreate(kCFAllocatorDefault,
(const void**)&kCTFontFamilyNameAttribute,
(const void**)&familyName, 1,
&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks)));
CFRelease(familyName);
QCFType<CTFontRef> ctFont = CTFontCreateWithFontDescriptor(descriptor, 0, NULL);
if (ctFont) {
fontName = CTFontCopyFullName(ctFont);
goto found;
}
#else
familyRef = ATSFontFamilyFindFromName(QCFString(db->families[k]->name), kATSOptionFlagsDefault);
if (familyRef) {
fontRef = ATSFontFindFromName(QCFString(db->families[k]->name), kATSOptionFlagsDefault);
goto found;
}
#endif
}
}
}
found:
#ifdef QT_MAC_USE_COCOA
if (fontName)
return new QCoreTextFontEngineMulti(fontName, req, d->kerning);
#else
if (familyRef) {
QCFString actualName;
if (ATSFontFamilyGetName(familyRef, kATSOptionFlagsDefault, &actualName) == noErr)
req.family = actualName;
return new QFontEngineMacMulti(familyRef, fontRef, req, d->kerning);
}
#endif
return NULL;
}
static OSStatus local_CoreTR(CGContextRef ctx, CGRect r, CFStringRef string,
CFStringRef fontName, CGFloat fontSize,
TRFallbackBehavior fallbackBehavior,
Boolean render, CGFloat baseline, TRInfo* oInfo)
{
if (!ctx || !string || !fontName) return paramErr;
CGContextSaveGState(ctx);
CGContextSetTextMatrix(ctx, CGAffineTransformIdentity);
CTFontDescriptorRef fdesc = CTFontDescriptorCreateWithNameAndSize(fontName, fontSize);
CTFontRef font = CTFontCreateWithFontDescriptor(fdesc, fontSize, NULL);
CFIndex slen = CFStringGetLength(string);
CFRange range = CFRangeMake(0L,slen);
UniChar* buff = calloc(slen, sizeof(UniChar));
CFStringGetCharacters(string, range, buff);
CGGlyph* glyphs = calloc(slen, sizeof(CGGlyph));
Boolean supported = CTFontGetGlyphsForCharacters(font, buff, glyphs, slen);
//NSLog(@"%@ supported for '%@'? %d", fontName, string, supported);
CFRelease(fdesc);
if (!supported)
{
if (fallbackBehavior == TRLastResortFallbackBehavior)
{
CFRelease(font);
fdesc = CTFontDescriptorCreateWithNameAndSize(CFSTR("LastResort"), fontSize);
font = CTFontCreateWithFontDescriptor(fdesc, fontSize, NULL);
CFRelease(fdesc);
supported = true;
}
else
{
CFRange rng = CFRangeMake(0L, CFStringGetLength(string));
CTFontRef font2 = CTFontCreateForString(font, string, rng);
CFRelease(font);
CFStringRef fontName2 = CTFontCopyName(font2, kCTFontFullNameKey);
fdesc = CTFontDescriptorCreateWithNameAndSize(fontName2, fontSize);
//NSLog(@"falling back to %@ from %@ : %@", fontName2, fontName, fdesc);
CFRelease(fontName2);
font = CTFontCreateWithFontDescriptor(fdesc, fontSize, NULL);
CFRelease(fdesc);
supported = CTFontGetGlyphsForCharacters(font, buff, glyphs, slen);
}
}
free(buff);
free(glyphs);
CFMutableDictionaryRef attrs = CFDictionaryCreateMutable(kCFAllocatorDefault,
1L, &kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
CFDictionarySetValue(attrs, kCTFontAttributeName, font);
CFAttributedStringRef attrStr = CFAttributedStringCreate(kCFAllocatorDefault,
string, attrs);
CFRelease(attrs);
CTLineRef line = CTLineCreateWithAttributedString(attrStr);
CFRelease(attrStr);
CGRect bounds = CTLineGetImageBounds(line, ctx);
CGFloat descent = CTFontGetDescent(font);
CGFloat ascent = CTFontGetAscent(font);
CFRelease(font);
if (baseline < 0.0L)
baseline = ((r.size.height - bounds.size.height + descent)/2.0L);
if (render && (supported || fallbackBehavior != TRNoRenderFallbackBehavior))
{
CGFloat x = r.origin.x + (r.size.width/2.0L) - (bounds.size.width/2.0L) - bounds.origin.x;
CGFloat y = r.origin.y + baseline;
CGPoint where = CGPointMake(x, y);
CGContextSetTextPosition(ctx, where.x, where.y);
CTLineDraw(line, ctx);
}
CFRelease(line);
if (oInfo)
{
oInfo->height = bounds.size.height + descent;
oInfo->width = bounds.size.width;
oInfo->ascent = ascent;
oInfo->descent = descent;
oInfo->baseline = baseline;
oInfo->fontSupported = supported;
}
CGContextRestoreGState(ctx);
return (supported)? noErr:kATSUFontsNotMatched;
}
static void *coretext_font_create_with_name_and_size(MCStringRef p_name, uint32_t p_size)
{
/*CFStringRef t_name;
t_name = CFStringCreateWithCString(NULL, p_name, kCFStringEncodingMacRoman);
CTFontRef t_font;
t_font = NULL;
if (t_name != NULL)
{
t_font = CTFontCreateWithName(t_name, p_size, NULL);
CFRelease(t_name);
}
return (void *)t_font;*/
bool t_success;
t_success = true;
MCAutoStringRefAsCFString t_cf_name;
t_success = t_cf_name . Lock(p_name);
CFDictionaryRef t_attributes;
t_attributes = NULL;
if (t_success)
{
// MW-2014-07-23: [[ Bug 12426 ]] Only specify the 'name' attribute in the font descriptor
// otherwise things don't work correctly on iOS. It seems going via a descriptor stops
// the warning on 10.9.
//
// Updated the font creation routine to use font descriptors. Though CTFontCreateWithName worked,
// it logged warnings (on 10.9) whenever it was passed a non-postscript font name. Hopefully using
// the display name first in the descriptor will remove the warnings but still keep the fall back behaviour.
CFStringRef t_keys[] =
{
// kCTFontDisplayNameAttribute,
kCTFontNameAttribute,
// kCTFontFamilyNameAttribute,
};
CFTypeRef t_values[] = {
*t_cf_name,
*t_cf_name,
*t_cf_name,
};
t_attributes = CFDictionaryCreate(NULL,
(const void **)&t_keys, (const void **)&t_values,
sizeof(t_keys) / sizeof(t_keys[0]),
&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
t_success = t_attributes != NULL;
}
CTFontDescriptorRef t_descriptor;
t_descriptor = NULL;
if (t_success)
{
t_descriptor = CTFontDescriptorCreateWithAttributes(t_attributes);
t_success = t_descriptor != NULL;
}
CTFontRef t_font;
t_font = NULL;
if (t_success)
t_font = CTFontCreateWithFontDescriptor(t_descriptor, p_size, NULL);
CFStringRef t_font_name = CTFontCopyFullName(t_font);
if (t_descriptor != NULL)
CFRelease(t_descriptor);
if (t_attributes != NULL)
CFRelease(t_attributes);
return (void *)t_font;
}
Memsubfont*
mksubfont(XFont *f, char *name, int lo, int hi, int size, int antialias)
{
CFStringRef s;
CGColorSpaceRef color;
CGContextRef ctxt;
CTFontRef font;
CTFontDescriptorRef desc;
CGRect bbox;
Memimage *m, *mc, *m1;
int x, y, y0;
int i, height, ascent;
Fontchar *fc, *fc0;
Memsubfont *sf;
CGFloat whitef[] = { 1.0, 1.0 };
CGColorRef white;
s = c2mac(name);
desc = CTFontDescriptorCreateWithNameAndSize(s, size);
CFRelease(s);
if(desc == nil)
return nil;
font = CTFontCreateWithFontDescriptor(desc, 0, nil);
CFRelease(desc);
if(font == nil)
return nil;
bbox = CTFontGetBoundingBox(font);
x = (int)(bbox.size.width*2 + 0.99999999);
fontheight(f, size, &height, &ascent);
y = height;
y0 = height - ascent;
m = allocmemimage(Rect(0, 0, x*(hi+1-lo)+1, y+1), GREY8);
if(m == nil)
return nil;
mc = allocmemimage(Rect(0, 0, x+1, y+1), GREY8);
if(mc == nil){
freememimage(m);
return nil;
}
memfillcolor(m, DBlack);
memfillcolor(mc, DBlack);
fc = malloc((hi+2 - lo) * sizeof fc[0]);
sf = malloc(sizeof *sf);
if(fc == nil || sf == nil) {
freememimage(m);
freememimage(mc);
free(fc);
free(sf);
return nil;
}
fc0 = fc;
color = CGColorSpaceCreateWithName(kCGColorSpaceGenericGray);
ctxt = CGBitmapContextCreate(byteaddr(mc, mc->r.min), Dx(mc->r), Dy(mc->r), 8,
mc->width*sizeof(u32int), color, kCGImageAlphaNone);
white = CGColorCreate(color, whitef);
CGColorSpaceRelease(color);
if(ctxt == nil) {
freememimage(m);
freememimage(mc);
free(fc);
free(sf);
return nil;
}
CGContextSetAllowsAntialiasing(ctxt, antialias);
CGContextSetTextPosition(ctxt, 0, 0); // XXX
#if OSX_VERSION >= 101400
CGContextSetAllowsFontSmoothing(ctxt, false);
#endif
x = 0;
for(i=lo; i<=hi; i++, fc++) {
char buf[20];
CFStringRef str;
CFDictionaryRef attrs;
CFAttributedStringRef attrString;
CTLineRef line;
CGRect r;
CGPoint p1;
CFStringRef keys[] = { kCTFontAttributeName, kCTForegroundColorAttributeName };
CFTypeRef values[] = { font, white };
sprint(buf, "%C", (Rune)mapUnicode(name, i));
str = c2mac(buf);
// See https://developer.apple.com/library/ios/documentation/StringsTextFonts/Conceptual/CoreText_Programming/LayoutOperations/LayoutOperations.html#//apple_ref/doc/uid/TP40005533-CH12-SW2
attrs = CFDictionaryCreate(kCFAllocatorDefault, (const void**)&keys,
(const void**)&values, sizeof(keys) / sizeof(keys[0]),
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
attrString = CFAttributedStringCreate(kCFAllocatorDefault, str, attrs);
CFRelease(str);
CFRelease(attrs);
line = CTLineCreateWithAttributedString(attrString);
CGContextSetTextPosition(ctxt, 0, y0);
r = CTLineGetImageBounds(line, ctxt);
memfillcolor(mc, DBlack);
CTLineDraw(line, ctxt);
CFRelease(line);
fc->x = x;
fc->top = 0;
fc->bottom = Dy(m->r);
// fprint(2, "printed %#x: %g %g\n", mapUnicode(i), p1.x, p1.y);
p1 = CGContextGetTextPosition(ctxt);
if(p1.x <= 0 || mapUnicode(name, i) == 0xfffd) {
fc->width = 0;
fc->left = 0;
if(i == 0) {
drawpjw(m, fc, x, (int)(bbox.size.width + 0.99999999), y, y - y0);
x += fc->width;
}
continue;
}
memimagedraw(m, Rect(x, 0, x + p1.x, y), mc, ZP, memopaque, ZP, S);
fc->width = p1.x;
fc->left = 0;
x += p1.x;
}
fc->x = x;
// round up to 32-bit boundary
// so that in-memory data is same
// layout as in-file data.
if(x == 0)
x = 1;
if(y == 0)
y = 1;
if(antialias)
x += -x & 3;
else
x += -x & 31;
m1 = allocmemimage(Rect(0, 0, x, y), antialias ? GREY8 : GREY1);
memimagedraw(m1, m1->r, m, m->r.min, memopaque, ZP, S);
freememimage(m);
freememimage(mc);
sf->name = nil;
sf->n = hi+1 - lo;
sf->height = Dy(m1->r);
sf->ascent = Dy(m1->r) - y0;
sf->info = fc0;
sf->bits = m1;
return sf;
}
static void
fontheight(XFont *f, int size, int *height, int *ascent)
{
int i;
CFStringRef s;
CGRect bbox;
CTFontRef font;
CTFontDescriptorRef desc;
CGContextRef ctxt;
CGColorSpaceRef color;
s = c2mac(f->name);
desc = CTFontDescriptorCreateWithNameAndSize(s, size);
CFRelease(s);
if(desc == nil)
return;
font = CTFontCreateWithFontDescriptor(desc, 0, nil);
CFRelease(desc);
if(font == nil)
return;
color = CGColorSpaceCreateWithName(kCGColorSpaceGenericGray);
ctxt = CGBitmapContextCreate(nil, 1, 1, 8, 1, color, kCGImageAlphaNone);
CGColorSpaceRelease(color);
CGContextSetTextPosition(ctxt, 0, 0);
for(i=0; i<nelem(lines); i++) {
CFStringRef keys[] = { kCTFontAttributeName };
CFTypeRef values[] = { font };
CFStringRef str;
CFDictionaryRef attrs;
CFAttributedStringRef attrString;
CGRect r;
CTLineRef line;
str = c2mac(lines[i]);
// See https://developer.apple.com/library/ios/documentation/StringsTextFonts/Conceptual/CoreText_Programming/LayoutOperations/LayoutOperations.html#//apple_ref/doc/uid/TP40005533-CH12-SW2
attrs = CFDictionaryCreate(kCFAllocatorDefault, (const void**)&keys,
(const void**)&values, sizeof(keys) / sizeof(keys[0]),
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
attrString = CFAttributedStringCreate(kCFAllocatorDefault, str, attrs);
CFRelease(str);
CFRelease(attrs);
line = CTLineCreateWithAttributedString(attrString);
r = CTLineGetImageBounds(line, ctxt);
r.size.width += r.origin.x;
r.size.height += r.origin.y;
CFRelease(line);
// fprint(2, "%s: %g %g %g %g\n", lines[i], r.origin.x, r.origin.y, r.size.width, r.size.height);
if(i == 0)
bbox = r;
if(bbox.origin.x > r.origin.x)
bbox.origin.x = r.origin.x;
if(bbox.origin.y > r.origin.y)
bbox.origin.y = r.origin.y;
if(bbox.size.width < r.size.width)
bbox.size.width = r.size.width;
if(bbox.size.height < r.size.height)
bbox.size.height = r.size.height;
}
bbox.size.width -= bbox.origin.x;
bbox.size.height -= bbox.origin.y;
*height = bbox.size.height + 0.999999;
*ascent = *height - (-bbox.origin.y + 0.999999);
CGContextRelease(ctxt);
CFRelease(font);
}