/****************************************************************************\ Part of the XeTeX typesetting system Copyright (c) 1994-2008 by SIL International Copyright (c) 2009 by Jonathan Kew Copyright (c) 2012, 2013 by Jiang Jiang Copyright (c) 2012-2015 by Khaled Hosny SIL Author(s): Jonathan Kew Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Except as contained in this notice, the name of the copyright holders shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from the copyright holders. \****************************************************************************/ /* XeTeX_mac.c * additional plain C extensions for XeTeX - MacOS-specific routines */ #define EXTERN extern #include "xetexd.h" #include #include #include "XeTeX_ext.h" #include "XeTeXLayoutInterface.h" static inline double TeXtoPSPoints(double pts) { return pts * 72.0 / 72.27; } static inline double PStoTeXPoints(double pts) { return pts * 72.27 / 72.0; } static inline Fixed FixedPStoTeXPoints(double pts) { return D2Fix(PStoTeXPoints(pts)); } CTFontRef fontFromAttributes(CFDictionaryRef attributes) { return CFDictionaryGetValue(attributes, kCTFontAttributeName); } CTFontRef fontFromInteger(integer font) { CFDictionaryRef attributes = (CFDictionaryRef) fontlayoutengine[font]; return fontFromAttributes(attributes); } void DoAATLayout(void* p, int justify) { CFArrayRef glyphRuns; CFIndex i, j, runCount; CFIndex totalGlyphCount = 0; UInt16* glyphIDs; Fixed* glyphAdvances; void* glyph_info = NULL; FixedPoint* locations; CGFloat width; long txtLen; const UniChar* txtPtr; CFDictionaryRef attributes; CFStringRef string; CFAttributedStringRef attrString; CTTypesetterRef typesetter; CTLineRef line; memoryword* node = (memoryword*)p; unsigned f = native_font(node); if (fontarea[f] != AAT_FONT_FLAG) { fprintf(stderr, "internal error: DoAATLayout called for non-AAT font\n"); exit(1); } txtLen = native_length(node); txtPtr = (UniChar*)(node + native_node_size); attributes = fontlayoutengine[native_font(node)]; string = CFStringCreateWithCharactersNoCopy(NULL, txtPtr, txtLen, kCFAllocatorNull); attrString = CFAttributedStringCreate(NULL, string, attributes); CFRelease(string); typesetter = CTTypesetterCreateWithAttributedString(attrString); CFRelease(attrString); line = CTTypesetterCreateLine(typesetter, CFRangeMake(0, txtLen)); if (justify) { CGFloat lineWidth = TeXtoPSPoints(Fix2D(node_width(node))); CTLineRef justifiedLine = CTLineCreateJustifiedLine(line, TeXtoPSPoints(Fix2D(fract1)), lineWidth); // TODO(jjgod): how to handle the case when justification failed? for // now we just fallback to use the original line. if (justifiedLine) { CFRelease(line); line = justifiedLine; } } glyphRuns = CTLineGetGlyphRuns(line); runCount = CFArrayGetCount(glyphRuns); totalGlyphCount = CTLineGetGlyphCount(line); if (totalGlyphCount > 0) { glyph_info = xmalloc(totalGlyphCount * native_glyph_info_size); locations = (FixedPoint*)glyph_info; glyphIDs = (UInt16*)(locations + totalGlyphCount); glyphAdvances = xmalloc(totalGlyphCount * sizeof(Fixed)); totalGlyphCount = 0; width = 0; for (i = 0; i < runCount; i++) { CTRunRef run = CFArrayGetValueAtIndex(glyphRuns, i); CFIndex count = CTRunGetGlyphCount(run); CFDictionaryRef runAttributes = CTRunGetAttributes(run); CFBooleanRef vertical = CFDictionaryGetValue(runAttributes, kCTVerticalFormsAttributeName); // TODO(jjgod): Avoid unnecessary allocation with CTRunGetFoosPtr(). CGGlyph* glyphs = (CGGlyph*) xmalloc(count * sizeof(CGGlyph)); CGPoint* positions = (CGPoint*) xmalloc(count * sizeof(CGPoint)); CGSize* advances = (CGSize*) xmalloc(count * sizeof(CGSize)); CGFloat runWidth = CTRunGetTypographicBounds(run, CFRangeMake(0, 0), NULL, NULL, NULL); CTRunGetGlyphs(run, CFRangeMake(0, 0), glyphs); CTRunGetPositions(run, CFRangeMake(0, 0), positions); CTRunGetAdvances(run, CFRangeMake(0, 0), advances); for (j = 0; j < count; j++) { // XXX Core Text has that font cascading thing that will do // font substitution for missing glyphs, which we do not want // but I can not find a way to disable it yet, so if the font // of the resulting run is not the same font we asked for, use // the glyph at index 0 (usually .notdef) instead or we will be // showing garbage or even invalid glyphs if (!CFEqual(fontFromAttributes(attributes), fontFromAttributes(runAttributes))) glyphIDs[totalGlyphCount] = 0; else glyphIDs[totalGlyphCount] = glyphs[j]; // Swap X and Y when doing vertical layout if (vertical == kCFBooleanTrue) { locations[totalGlyphCount].x = -FixedPStoTeXPoints(positions[j].y); locations[totalGlyphCount].y = FixedPStoTeXPoints(positions[j].x); } else { locations[totalGlyphCount].x = FixedPStoTeXPoints(positions[j].x); locations[totalGlyphCount].y = -FixedPStoTeXPoints(positions[j].y); } glyphAdvances[totalGlyphCount] = advances[j].width; totalGlyphCount++; } width += FixedPStoTeXPoints(runWidth); free(glyphs); free(positions); free(advances); } } native_glyph_count(node) = totalGlyphCount; native_glyph_info_ptr(node) = glyph_info; if (!justify) { node_width(node) = width; if (totalGlyphCount > 0) { /* this is essentially a copy from similar code in XeTeX_ext.c, easier * to be done here */ if (fontletterspace[f] != 0) { Fixed lsDelta = 0; Fixed lsUnit = fontletterspace[f]; int i; for (i = 0; i < totalGlyphCount; ++i) { if (glyphAdvances[i] == 0 && lsDelta != 0) lsDelta -= lsUnit; locations[i].x += lsDelta; lsDelta += lsUnit; } if (lsDelta != 0) { lsDelta -= lsUnit; node_width(node) += lsDelta; } } } } free(glyphAdvances); CFRelease(line); CFRelease(typesetter); } static void getGlyphBBoxFromCTFont(CTFontRef font, UInt16 gid, GlyphBBox* bbox) { CGRect rect; bbox->xMin = 65536.0; bbox->yMin = 65536.0; bbox->xMax = -65536.0; bbox->yMax = -65536.0; rect = CTFontGetBoundingRectsForGlyphs(font, 0, /* Use default orientation for now, handle vertical later */ (const CGGlyph *) &gid, NULL, 1); if (CGRectIsNull(rect)) bbox->xMin = bbox->yMin = bbox->xMax = bbox->yMax = 0; else { bbox->yMin = PStoTeXPoints(rect.origin.y); bbox->yMax = PStoTeXPoints(rect.origin.y + rect.size.height); bbox->xMin = PStoTeXPoints(rect.origin.x); bbox->xMax = PStoTeXPoints(rect.origin.x + rect.size.width); } } void GetGlyphBBox_AAT(CFDictionaryRef attributes, UInt16 gid, GlyphBBox* bbox) /* returns glyph bounding box in TeX points */ { CTFontRef font = fontFromAttributes(attributes); return getGlyphBBoxFromCTFont(font, gid, bbox); } static double getGlyphWidthFromCTFont(CTFontRef font, UInt16 gid) { return PStoTeXPoints(CTFontGetAdvancesForGlyphs(font, kCTFontHorizontalOrientation, &gid, NULL, 1)); } double GetGlyphWidth_AAT(CFDictionaryRef attributes, UInt16 gid) /* returns TeX points */ { CTFontRef font = fontFromAttributes(attributes); return getGlyphWidthFromCTFont(font, gid); } void GetGlyphHeightDepth_AAT(CFDictionaryRef attributes, UInt16 gid, float* ht, float* dp) /* returns TeX points */ { GlyphBBox bbox; GetGlyphBBox_AAT(attributes, gid, &bbox); *ht = bbox.yMax; *dp = -bbox.yMin; } void GetGlyphSidebearings_AAT(CFDictionaryRef attributes, UInt16 gid, float* lsb, float* rsb) /* returns TeX points */ { CTFontRef font = fontFromAttributes(attributes); CGSize advances[1] = { CGSizeMake(0, 0) }; double advance = CTFontGetAdvancesForGlyphs(font, 0, &gid, advances, 1); GlyphBBox bbox; getGlyphBBoxFromCTFont(font, gid, &bbox); *lsb = bbox.xMin; *rsb = PStoTeXPoints(advance) - bbox.xMax; } double GetGlyphItalCorr_AAT(CFDictionaryRef attributes, UInt16 gid) { CTFontRef font = fontFromAttributes(attributes); CGSize advances[1] = { CGSizeMake(0, 0) }; double advance = CTFontGetAdvancesForGlyphs(font, 0, &gid, advances, 1); GlyphBBox bbox; getGlyphBBoxFromCTFont(font, gid, &bbox); if (bbox.xMax > PStoTeXPoints(advance)) return bbox.xMax - PStoTeXPoints(advance); return 0; } static int mapCharToGlyphFromCTFont(CTFontRef font, UInt32 ch) { CGGlyph glyphs[2] = { 0 }; UniChar txt[2]; int len = 1; if (ch > 0xffff) { ch -= 0x10000; txt[0] = 0xd800 + ch / 1024; txt[1] = 0xdc00 + ch % 1024; len = 2; } else { txt[0] = ch; } if (CTFontGetGlyphsForCharacters(font, txt, glyphs, len)) return glyphs[0]; return 0; } int MapCharToGlyph_AAT(CFDictionaryRef attributes, UInt32 ch) { CTFontRef font = fontFromAttributes(attributes); return mapCharToGlyphFromCTFont(font, ch); } static int GetGlyphIDFromCTFont(CTFontRef ctFontRef, const char* glyphName) { CFStringRef glyphname = CFStringCreateWithCStringNoCopy(kCFAllocatorDefault, glyphName, kCFStringEncodingUTF8, kCFAllocatorNull); int rval = CTFontGetGlyphWithName(ctFontRef, glyphname); CFRelease(glyphname); return rval; } int MapGlyphToIndex_AAT(CFDictionaryRef attributes, const char* glyphName) { CTFontRef font = fontFromAttributes(attributes); return GetGlyphIDFromCTFont(font, glyphName); } char* GetGlyphNameFromCTFont(CTFontRef ctFontRef, UInt16 gid, int* len) { CGFontRef cgfont; static char buffer[256]; buffer[0] = 0; *len = 0; cgfont = CTFontCopyGraphicsFont(ctFontRef, 0); if (cgfont && gid < CGFontGetNumberOfGlyphs(cgfont)) { CFStringRef glyphname = CGFontCopyGlyphNameForGlyph(cgfont, gid); if (glyphname) { if (CFStringGetCString(glyphname, buffer, 256, kCFStringEncodingUTF8)) { *len = strlen(buffer); } CFRelease(glyphname); } CGFontRelease(cgfont); } return &buffer[0]; } int GetFontCharRange_AAT(CFDictionaryRef attributes, int reqFirst) { if (reqFirst) { int ch = 0; while (MapCharToGlyph_AAT(attributes, ch) == 0 && ch < 0x10ffff) ++ch; return ch; } else { int ch = 0x10ffff; while (MapCharToGlyph_AAT(attributes, ch) == 0 && ch > 0) --ch; return ch; } } char* getNameFromCTFont(CTFontRef ctFontRef, CFStringRef nameKey) { char *buf; CFStringRef name = CTFontCopyName(ctFontRef, nameKey); CFIndex len = CFStringGetLength(name); len = len * 6 + 1; buf = xmalloc(len); if (CFStringGetCString(name, buf, len, kCFStringEncodingUTF8)) return buf; free(buf); return NULL; } char* getFileNameFromCTFont(CTFontRef ctFontRef, uint32_t *index) { char *ret = NULL; CFURLRef url = NULL; #if !defined(MAC_OS_X_VERSION_10_6) || MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_6 /* kCTFontURLAttribute was not avialable before 10.6 */ ATSFontRef atsFont; FSRef fsref; OSStatus status; atsFont = CTFontGetPlatformFont(ctFontRef, NULL); status = ATSFontGetFileReference(atsFont, &fsref); if (status == noErr) url = CFURLCreateFromFSRef(NULL, &fsref); #else url = (CFURLRef) CTFontCopyAttribute(ctFontRef, kCTFontURLAttribute); #endif if (url) { UInt8 pathname[PATH_MAX]; if (CFURLGetFileSystemRepresentation(url, true, pathname, PATH_MAX)) { FT_Error error; FT_Face face; *index = 0; if (!gFreeTypeLibrary) { error = FT_Init_FreeType(&gFreeTypeLibrary); if (error) { fprintf(stderr, "FreeType initialization failed! (%d)\n", error); exit(1); } } error = FT_New_Face(gFreeTypeLibrary, (char *) pathname, 0, &face); if (!error) { if (face->num_faces > 1) { int num_faces = face->num_faces; char *ps_name1 = getNameFromCTFont(ctFontRef, kCTFontPostScriptNameKey); int i; *index = -1; FT_Done_Face (face); for (i = 0; i < num_faces; i++) { error = FT_New_Face (gFreeTypeLibrary, (char *) pathname, i, &face); if (!error) { const char *ps_name2 = FT_Get_Postscript_Name(face); if (strcmp(ps_name1, ps_name2) == 0) { *index = i; break; } FT_Done_Face (face); } } free(ps_name1); } } if (*index != -1) ret = strdup((char *) pathname); } CFRelease(url); } return ret; } CFDictionaryRef findDictionaryInArrayWithIdentifier(CFArrayRef array, const void* identifierKey, int identifier) { CFDictionaryRef dict = NULL; if (array) { int value = -1; CFIndex i; for (i = 0; i < CFArrayGetCount(array); i++) { CFDictionaryRef item = CFArrayGetValueAtIndex(array, i); CFNumberRef itemId = CFDictionaryGetValue(item, identifierKey); if (itemId) { CFNumberGetValue(itemId, kCFNumberIntType, &value); if (value == identifier) { dict = item; break; } } } } return dict; } CFDictionaryRef findDictionaryInArray(CFArrayRef array, const void* nameKey, const char* name, int nameLength) { CFDictionaryRef dict = NULL; if (array) { CFStringRef itemName; CFIndex i; itemName = CFStringCreateWithBytes(NULL, (UInt8 *) name, nameLength, kCFStringEncodingUTF8, false); for (i = 0; i < CFArrayGetCount(array); i++) { CFDictionaryRef item = CFArrayGetValueAtIndex(array, i); CFStringRef iName = CFDictionaryGetValue(item, nameKey); if (iName && !CFStringCompare(itemName, iName, kCFCompareCaseInsensitive)) { dict = item; break; } } CFRelease(itemName); } return dict; } CFNumberRef findSelectorByName(CFDictionaryRef feature, const char* name, int nameLength) { CFNumberRef selector = NULL; CFArrayRef selectors = CFDictionaryGetValue(feature, kCTFontFeatureTypeSelectorsKey); if (selectors) { CFDictionaryRef s = findDictionaryInArray(selectors, kCTFontFeatureSelectorNameKey, name, nameLength); if (s) selector = CFDictionaryGetValue(s, kCTFontFeatureSelectorIdentifierKey); } return selector; } static CFDictionaryRef createFeatureSettingDictionary(CFNumberRef featureTypeIdentifier, CFNumberRef featureSelectorIdentifier) { const void* settingKeys[] = { kCTFontFeatureTypeIdentifierKey, kCTFontFeatureSelectorIdentifierKey }; const void* settingValues[] = { featureTypeIdentifier, featureSelectorIdentifier }; return CFDictionaryCreate(kCFAllocatorDefault, settingKeys, settingValues, 2, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); } const CFStringRef kXeTeXEmboldenAttributeName = CFSTR("XeTeXEmbolden"); void* loadAATfont(CTFontDescriptorRef descriptor, integer scaled_size, const char* cp1) { CTFontRef font, actualFont; CGFloat ctSize; CFMutableDictionaryRef stringAttributes, attributes; CGAffineTransform matrix; CFMutableArrayRef cascadeList; CTFontDescriptorRef lastResort; double tracking = 0.0; float extend = 1.0; float slant = 0.0; float embolden = 0.0; float letterspace = 0.0; uint32_t rgbValue; // create a base font instance for applying further attributes ctSize = TeXtoPSPoints(Fix2D(scaled_size)); font = CTFontCreateWithFontDescriptor(descriptor, ctSize, NULL); if (!font) return NULL; stringAttributes = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); attributes = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); if (cp1) { CFArrayRef features = CTFontCopyFeatures(font); CFMutableArrayRef featureSettings = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks); // interpret features following ":" while (*cp1) { CFDictionaryRef feature; int ret; const char* cp2; const char* cp3; // locate beginning of name=value pair if (*cp1 == ':' || *cp1 == ';') // skip over separator ++cp1; while (*cp1 == ' ' || *cp1 == '\t') // skip leading whitespace ++cp1; if (*cp1 == 0) // break if end of string break; // scan to end of pair cp2 = cp1; while (*cp2 && (*cp2 != ';') && (*cp2 != ':')) ++cp2; // look for the '=' separator cp3 = cp1; while ((cp3 < cp2) && (*cp3 != '=')) ++cp3; if (cp3 == cp2) goto bad_option; // now cp1 points to option name, cp3 to '=', cp2 to ';' or null // first try for a feature by this name feature = findDictionaryInArray(features, kCTFontFeatureTypeNameKey, cp1, cp3 - cp1); if (feature) { // look past the '=' separator for setting names int featLen = cp3 - cp1; int zeroInteger = 0; CFNumberRef zero = CFNumberCreate(NULL, kCFNumberIntType, &zeroInteger); ++cp3; while (cp3 < cp2) { CFNumberRef selector; int disable = 0; const char* cp4; // skip leading whitespace while (*cp3 == ' ' || *cp3 == '\t') ++cp3; // possibly multiple settings... if (*cp3 == '!') { // check for negation disable = 1; ++cp3; } // scan for end of setting name cp4 = cp3; while (cp4 < cp2 && *cp4 != ',') ++cp4; // now cp3 points to name, cp4 to ',' or ';' or null selector = findSelectorByName(feature, cp3, cp4 - cp3); if (selector && CFNumberCompare(selector, zero, NULL) >= 0) { CFNumberRef featureType = CFDictionaryGetValue(feature, kCTFontFeatureTypeIdentifierKey); CFDictionaryRef featureSetting = createFeatureSettingDictionary(featureType, selector); CFArrayAppendValue(featureSettings, featureSetting); CFRelease(featureSetting); } else { fontfeaturewarning(cp1, featLen, cp3, cp4 - cp3); } // point beyond setting name terminator cp3 = cp4 + 1; } CFRelease(zero); goto next_option; } // didn't find feature, try other options... ret = readCommonFeatures(cp1, cp2, &extend, &slant, &embolden, &letterspace, &rgbValue); if (ret == 1) goto next_option; else if (ret == -1) goto bad_option; if (strncmp(cp1, "tracking", 8) == 0) { CFNumberRef trackingNumber; cp3 = cp1 + 8; if (*cp3 != '=') goto bad_option; ++cp3; tracking = read_double(&cp3); trackingNumber = CFNumberCreate(NULL, kCFNumberDoubleType, &tracking); CFDictionaryAddValue(stringAttributes, kCTKernAttributeName, trackingNumber); CFRelease(trackingNumber); goto next_option; } bad_option: // not a name=value pair, or not recognized.... // check for plain "vertical" before complaining if (strncmp(cp1, "vertical", 8) == 0) { cp3 = cp2; if (*cp3 == ';' || *cp3 == ':') --cp3; while (*cp3 == '\0' || *cp3 == ' ' || *cp3 == '\t') --cp3; if (*cp3) ++cp3; if (cp3 == cp1 + 8) { int orientation = kCTFontVerticalOrientation; CFNumberRef orientationNumber = CFNumberCreate(NULL, kCFNumberIntType, &orientation); CFDictionaryAddValue(attributes, kCTFontOrientationAttribute, orientationNumber); CFRelease(orientationNumber); CFDictionaryAddValue(stringAttributes, kCTVerticalFormsAttributeName, kCFBooleanTrue); goto next_option; } } fontfeaturewarning(cp1, cp2 - cp1, 0, 0); next_option: // go to next name=value pair cp1 = cp2; } if (features) CFRelease(features); if (CFArrayGetCount(featureSettings)) CFDictionaryAddValue(attributes, kCTFontFeatureSettingsAttribute, featureSettings); CFRelease(featureSettings); } if ((loadedfontflags & FONT_FLAGS_COLORED) != 0) { CGFloat red = ((rgbValue & 0xFF000000) >> 24) / 255.0; CGFloat green = ((rgbValue & 0x00FF0000) >> 16) / 255.0; CGFloat blue = ((rgbValue & 0x0000FF00) >> 8 ) / 255.0; CGFloat alpha = ((rgbValue & 0x000000FF) ) / 255.0; CGColorRef color = CGColorCreateGenericRGB(red, green, blue, alpha); CFDictionaryAddValue(stringAttributes, kCTForegroundColorAttributeName, color); CGColorRelease(color); } matrix = CGAffineTransformIdentity; if (extend != 1.0 || slant != 0.0) matrix = CGAffineTransformMake(extend, 0, slant, 1.0, 0, 0); if (embolden != 0.0) { CFNumberRef emboldenNumber; embolden = embolden * Fix2D(scaled_size) / 100.0; emboldenNumber = CFNumberCreate(NULL, kCFNumberFloatType, &embolden); CFDictionaryAddValue(stringAttributes, kXeTeXEmboldenAttributeName, emboldenNumber); CFRelease(emboldenNumber); } if (letterspace != 0.0) loadedfontletterspace = (letterspace / 100.0) * scaled_size; // Disable Core Text font fallback (cascading) with only the last resort font // in the cascade list. cascadeList = CFArrayCreateMutable(NULL, 1, &kCFTypeArrayCallBacks); lastResort = CTFontDescriptorCreateWithNameAndSize(CFSTR("LastResort"), 0); CFArrayAppendValue(cascadeList, lastResort); CFRelease(lastResort); CFDictionaryAddValue(attributes, kCTFontCascadeListAttribute, cascadeList); CFRelease(cascadeList); descriptor = CTFontDescriptorCreateWithAttributes(attributes); CFRelease(attributes); actualFont = CTFontCreateCopyWithAttributes(font, ctSize, &matrix, descriptor); CFRelease(font); CFDictionaryAddValue(stringAttributes, kCTFontAttributeName, actualFont); CFRelease(actualFont); nativefonttypeflag = AAT_FONT_FLAG; return (void *) stringAttributes; }