src/macfont.m

   1 /* Font driver on macOS Core text.
   2    Copyright (C) 2009-2017 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Emacs.
   5
   6 GNU Emacs is free software: you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation, either version 3 of the License, or (at
   9 your option) any later version.
  10
  11 GNU Emacs is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  18
  19 Original author: YAMAMOTO Mitsuharu
  20 */
  21
  22 #include <config.h>
  23
  24 #include "lisp.h"
  25 #include "dispextern.h"
  26 #include "frame.h"
  27 #include "blockinput.h"
  28 #include "character.h"
  29 #include "charset.h"
  30 #include "composite.h"
  31 #include "fontset.h"
  32 #include "font.h"
  33 #include "termchar.h"
  34 #include "nsgui.h"
  35 #include "nsterm.h"
  36 #include "macfont.h"
  37 #include "macuvs.h"
  38
  39 #include <libkern/OSByteOrder.h>
  40
  41 static double mac_font_get_advance_width_for_glyph (CTFontRef, CGGlyph);
  42 static CGRect mac_font_get_bounding_rect_for_glyph (CTFontRef, CGGlyph);
  43 static CFArrayRef mac_font_create_available_families (void);
  44 static Boolean mac_font_equal_in_postscript_name (CTFontRef, CTFontRef);
  45 static CTLineRef mac_font_create_line_with_string_and_font (CFStringRef,
  46                                                             CTFontRef);
  47 static Boolean mac_font_descriptor_supports_languages (CTFontDescriptorRef,
  48                                                        CFArrayRef);
  49 static CFStringRef mac_font_create_preferred_family_for_attributes (CFDictionaryRef);
  50 static CFIndex mac_font_shape (CTFontRef, CFStringRef,
  51                                struct mac_glyph_layout *, CFIndex);
  52 static CFArrayRef mac_font_copy_default_descriptors_for_language (CFStringRef);
  53 static CFStringRef mac_font_copy_default_name_for_charset_and_languages (CFCharacterSetRef, CFArrayRef);
  54 #if USE_CT_GLYPH_INFO
  55 static CGGlyph mac_ctfont_get_glyph_for_cid (CTFontRef, CTCharacterCollection,
  56                                              CGFontIndex);
  57 #endif
  58
  59 struct macfont_metrics;
  60
  61 /* The actual structure for Mac font that can be cast to struct font.  */
  62
  63 struct macfont_info
  64 {
  65   struct font font;
  66   CTFontRef macfont;
  67   CGFontRef cgfont;
  68   ScreenFontRef screen_font;
  69   struct macfont_cache *cache;
  70   struct macfont_metrics **metrics;
  71   short metrics_nrows;
  72   bool_bf synthetic_italic_p : 1;
  73   bool_bf synthetic_bold_p : 1;
  74   unsigned spacing : 2;
  75   unsigned antialias : 2;
  76   bool_bf color_bitmap_p : 1;
  77 };
  78
  79 /* Values for the `spacing' member in `struct macfont_info'.  */
  80
  81 enum
  82   {
  83     MACFONT_SPACING_PROPORTIONAL,
  84     MACFONT_SPACING_MONO,
  85     MACFONT_SPACING_SYNTHETIC_MONO,
  86   };
  87
  88 /* Values for the `antialias' member in `struct macfont_info'.  */
  89
  90 enum
  91   {
  92     MACFONT_ANTIALIAS_DEFAULT,
  93     MACFONT_ANTIALIAS_OFF,
  94     MACFONT_ANTIALIAS_ON,
  95   };
  96
  97 enum {FONT_SLANT_SYNTHETIC_ITALIC = 200}; /* FC_SLANT_ITALIC + 100 */
  98 enum {FONT_WEIGHT_SYNTHETIC_BOLD = 200};  /* FC_WEIGHT_BOLD */
  99 enum {FONT_SPACING_SYNTHETIC_MONO = FONT_SPACING_MONO};
 100
 101 static const CGAffineTransform synthetic_italic_atfm = {1, 0, 0.25, 1, 0, 0};
 102 static const CGFloat synthetic_bold_factor = 0.024;
 103
 104 static Boolean cfnumber_get_font_symbolic_traits_value (CFNumberRef,
 105                                                         CTFontSymbolicTraits *);
 106 static void macfont_store_descriptor_attributes (CTFontDescriptorRef,
 107                                                  Lisp_Object);
 108 static Lisp_Object macfont_descriptor_entity (CTFontDescriptorRef, Lisp_Object,
 109                                               CTFontSymbolicTraits);
 110 static CFStringRef macfont_create_family_with_symbol (Lisp_Object);
 111 static int macfont_glyph_extents (struct font *, CGGlyph,
 112                                   struct font_metrics *, CGFloat *, int);
 113 static CFMutableDictionaryRef macfont_create_attributes_with_spec (Lisp_Object);
 114 static Boolean macfont_supports_charset_and_languages_p (CTFontDescriptorRef,
 115                                                          CFCharacterSetRef,
 116                                                          Lisp_Object,
 117                                                          CFArrayRef);
 118 static Boolean macfont_closest_traits_index_p (CFArrayRef, CTFontSymbolicTraits,
 119                                                CFIndex);
 120 static CFDataRef mac_font_copy_uvs_table (CTFontRef);
 121 static void mac_font_get_glyphs_for_variants (CFDataRef, UTF32Char,
 122                                               const UTF32Char [],
 123                                               CGGlyph [], CFIndex);
 124
 125 /* From CFData to a lisp string.  Always returns a unibyte string.  */
 126
 127 static Lisp_Object
 128 cfdata_to_lisp (CFDataRef data)
 129 {
 130   CFIndex len = CFDataGetLength (data);
 131   Lisp_Object result = make_uninit_string (len);
 132
 133   CFDataGetBytes (data, CFRangeMake (0, len), SDATA (result));
 134
 135   return result;
 136 }
 137
 138
 139
 140 /* From CFString to a lisp string.  Returns a unibyte string
 141    containing a UTF-8 byte sequence.  */
 142
 143 static Lisp_Object
 144 cfstring_to_lisp_nodecode (CFStringRef string)
 145 {
 146   Lisp_Object result = Qnil;
 147   CFDataRef data;
 148   const char *s = CFStringGetCStringPtr (string, kCFStringEncodingUTF8);
 149
 150   if (s)
 151     {
 152       CFIndex i, length = CFStringGetLength (string);
 153
 154       for (i = 0; i < length; i++)
 155         if (CFStringGetCharacterAtIndex (string, i) == 0)
 156           break;
 157
 158       if (i == length)
 159         return make_unibyte_string (s, strlen (s));
 160     }
 161
 162   data = CFStringCreateExternalRepresentation (NULL, string,
 163                                                kCFStringEncodingUTF8, '?');
 164   if (data)
 165     {
 166       result = cfdata_to_lisp (data);
 167       CFRelease (data);
 168     }
 169
 170   return result;
 171 }
 172
 173 /* Lisp string containing a UTF-8 byte sequence to CFString.  Unlike
 174    cfstring_create_with_utf8_cstring, this function preserves NUL
 175    characters.  */
 176
 177 static CFStringRef
 178 cfstring_create_with_string_noencode (Lisp_Object s)
 179 {
 180   CFStringRef string = CFStringCreateWithBytes (NULL, SDATA (s), SBYTES (s),
 181                                                 kCFStringEncodingUTF8, false);
 182
 183   if (string == NULL)
 184     /* Failed to interpret as UTF 8.  Fall back on Mac Roman.  */
 185     string = CFStringCreateWithBytes (NULL, SDATA (s), SBYTES (s),
 186                                       kCFStringEncodingMacRoman, false);
 187
 188   return string;
 189 }
 190
 191 static CFIndex
 192 mac_font_get_weight (CTFontRef font)
 193 {
 194   NSFont *nsFont = (NSFont *) font;
 195
 196   return [[NSFontManager sharedFontManager] weightOfFont:nsFont];
 197 }
 198
 199 static CGFloat
 200 mac_screen_font_get_advance_width_for_glyph (ScreenFontRef font, CGGlyph glyph)
 201 {
 202   NSSize advancement = [(NSFont *)font advancementForGlyph:glyph];
 203
 204   return advancement.width;
 205 }
 206
 207 #if !USE_CT_GLYPH_INFO
 208 static CGGlyph
 209 mac_font_get_glyph_for_cid (CTFontRef font, NSCharacterCollection collection,
 210                             CGFontIndex cid)
 211 {
 212   CGGlyph result = kCGFontIndexInvalid;
 213   NSFont *nsFont = (NSFont *) font;
 214   unichar characters[] = {0xfffd};
 215   NSString *string =
 216     [NSString stringWithCharacters:characters
 217                             length:ARRAYELTS (characters)];
 218   NSGlyphInfo *glyphInfo =
 219     [NSGlyphInfo glyphInfoWithCharacterIdentifier:cid
 220                                        collection:collection
 221                                        baseString:string];
 222   NSDictionary *attributes =
 223     [NSDictionary dictionaryWithObjectsAndKeys:nsFont,NSFontAttributeName,
 224                   glyphInfo,NSGlyphInfoAttributeName,nil];
 225   NSTextStorage *textStorage =
 226     [[NSTextStorage alloc] initWithString:string
 227                                attributes:attributes];
 228   NSLayoutManager *layoutManager = [[NSLayoutManager alloc] init];
 229   NSTextContainer *textContainer = [[NSTextContainer alloc] init];
 230   NSFont *fontInTextStorage;
 231
 232   [layoutManager addTextContainer:textContainer];
 233   [textContainer release];
 234   [textStorage addLayoutManager:layoutManager];
 235   [layoutManager release];
 236
 237   /* Force layout.  */
 238   (void) [layoutManager glyphRangeForTextContainer:textContainer];
 239
 240   fontInTextStorage = [textStorage attribute:NSFontAttributeName atIndex:0
 241                               effectiveRange:NULL];
 242   if (fontInTextStorage == nsFont
 243       || [[fontInTextStorage fontName] isEqualToString:[nsFont fontName]])
 244     {
 245       NSGlyph glyph = [layoutManager glyphAtIndex:0];
 246
 247       if (glyph < [nsFont numberOfGlyphs])
 248         result = glyph;
 249     }
 250
 251   [textStorage release];
 252
 253   return result;
 254 }
 255 #endif
 256
 257 static ScreenFontRef
 258 mac_screen_font_create_with_name (CFStringRef name, CGFloat size)
 259 {
 260   NSFont *result, *font;
 261
 262   font = [NSFont fontWithName:((NSString *) name) size:size];
 263   result = [font screenFont];
 264
 265   return (ScreenFontRef)[result retain];
 266 }
 267
 268
 269 static Boolean
 270 mac_screen_font_get_metrics (ScreenFontRef font, CGFloat *ascent,
 271                              CGFloat *descent, CGFloat *leading)
 272 {
 273   NSFont *nsFont = [(NSFont *)font printerFont];
 274   NSTextStorage *textStorage;
 275   NSLayoutManager *layoutManager;
 276   NSTextContainer *textContainer;
 277   NSRect usedRect;
 278   NSPoint spaceLocation;
 279   CGFloat descender;
 280
 281   textStorage = [[NSTextStorage alloc] initWithString:@" "];
 282   layoutManager = [[NSLayoutManager alloc] init];
 283   textContainer = [[NSTextContainer alloc] init];
 284
 285   [textStorage setFont:nsFont];
 286   [textContainer setLineFragmentPadding:0];
 287
 288   [layoutManager addTextContainer:textContainer];
 289   [textContainer release];
 290   [textStorage addLayoutManager:layoutManager];
 291   [layoutManager release];
 292
 293   if (!(textStorage && layoutManager && textContainer))
 294     {
 295       [textStorage release];
 296
 297       return false;
 298     }
 299
 300   usedRect = [layoutManager lineFragmentUsedRectForGlyphAtIndex:0
 301                                                  effectiveRange:NULL];
 302   spaceLocation = [layoutManager locationForGlyphAtIndex:0];
 303   [textStorage release];
 304
 305   *ascent = spaceLocation.y;
 306   *descent = NSHeight (usedRect) - spaceLocation.y;
 307   *leading = 0;
 308   descender = [nsFont descender];
 309   if (- descender < *descent)
 310     {
 311       *leading = *descent + descender;
 312       *descent = - descender;
 313     }
 314
 315   return true;
 316 }
 317
 318 static CFIndex
 319 mac_font_shape_1 (NSFont *font, NSString *string,
 320                   struct mac_glyph_layout *glyph_layouts, CFIndex glyph_len)
 321 {
 322   NSUInteger i;
 323   CFIndex result = 0;
 324   NSTextStorage *textStorage;
 325   NSLayoutManager *layoutManager;
 326   NSTextContainer *textContainer;
 327   NSUInteger stringLength;
 328   NSPoint spaceLocation;
 329   NSUInteger used, numberOfGlyphs;
 330
 331   textStorage = [[NSTextStorage alloc] initWithString:string];
 332   layoutManager = [[NSLayoutManager alloc] init];
 333   textContainer = [[NSTextContainer alloc] init];
 334
 335   /* Append a trailing space to measure baseline position.  */
 336   [textStorage appendAttributedString:([[[NSAttributedString alloc]
 337                                           initWithString:@" "] autorelease])];
 338   [textStorage setFont:font];
 339   [textContainer setLineFragmentPadding:0];
 340
 341   [layoutManager addTextContainer:textContainer];
 342   [textContainer release];
 343   [textStorage addLayoutManager:layoutManager];
 344   [layoutManager release];
 345
 346   if (!(textStorage && layoutManager && textContainer))
 347     {
 348       [textStorage release];
 349
 350       return 0;
 351     }
 352
 353   stringLength = [string length];
 354
 355   /* Force layout.  */
 356   (void) [layoutManager glyphRangeForTextContainer:textContainer];
 357
 358   spaceLocation = [layoutManager locationForGlyphAtIndex:stringLength];
 359
 360   /* Remove the appended trailing space because otherwise it may
 361      generate a wrong result for a right-to-left text.  */
 362   [textStorage beginEditing];
 363   [textStorage deleteCharactersInRange:(NSMakeRange (stringLength, 1))];
 364   [textStorage endEditing];
 365   (void) [layoutManager glyphRangeForTextContainer:textContainer];
 366
 367   i = 0;
 368   while (i < stringLength)
 369     {
 370       NSRange range;
 371       NSFont *fontInTextStorage =
 372         [textStorage attribute:NSFontAttributeName atIndex:i
 373                      longestEffectiveRange:&range
 374                        inRange:(NSMakeRange (0, stringLength))];
 375
 376       if (!(fontInTextStorage == font
 377             || [[fontInTextStorage fontName] isEqualToString:[font fontName]]))
 378         break;
 379       i = NSMaxRange (range);
 380     }
 381   if (i < stringLength)
 382     /* Make the test `used <= glyph_len' below fail if textStorage
 383        contained some fonts other than the specified one.  */
 384     used = glyph_len + 1;
 385   else
 386     {
 387       NSRange range = NSMakeRange (0, stringLength);
 388
 389       range = [layoutManager glyphRangeForCharacterRange:range
 390                                     actualCharacterRange:NULL];
 391       numberOfGlyphs = NSMaxRange (range);
 392       used = numberOfGlyphs;
 393       for (i = 0; i < numberOfGlyphs; i++)
 394         if ([layoutManager notShownAttributeForGlyphAtIndex:i])
 395           used--;
 396     }
 397
 398   if (0 < used && used <= glyph_len)
 399     {
 400       NSUInteger glyphIndex, prevGlyphIndex;
 401       unsigned char bidiLevel;
 402       NSUInteger *permutation;
 403       NSRange compRange, range;
 404       CGFloat totalAdvance;
 405
 406       glyphIndex = 0;
 407       while ([layoutManager notShownAttributeForGlyphAtIndex:glyphIndex])
 408         glyphIndex++;
 409
 410       /* For now we assume the direction is not changed within the
 411          string.  */
 412       [layoutManager getGlyphsInRange:(NSMakeRange (glyphIndex, 1))
 413                                glyphs:NULL
 414                            properties:NULL
 415                      characterIndexes:NULL
 416                            bidiLevels:&bidiLevel];
 417       if (bidiLevel & 1)
 418         permutation = xmalloc (sizeof (NSUInteger) * used);
 419       else
 420         permutation = NULL;
 421
 422 #define RIGHT_TO_LEFT_P permutation
 423
 424       /* Fill the `comp_range' member of struct mac_glyph_layout, and
 425          setup a permutation for right-to-left text.  */
 426       compRange = NSMakeRange (0, 0);
 427       for (range = NSMakeRange (0, 0); NSMaxRange (range) < used;
 428            range.length++)
 429         {
 430           struct mac_glyph_layout *gl = glyph_layouts + NSMaxRange (range);
 431           NSUInteger characterIndex =
 432             [layoutManager characterIndexForGlyphAtIndex:glyphIndex];
 433
 434           gl->string_index = characterIndex;
 435
 436           if (characterIndex >= NSMaxRange (compRange))
 437             {
 438               compRange.location = NSMaxRange (compRange);
 439               do
 440                 {
 441                   NSRange characterRange =
 442                     [string
 443                       rangeOfComposedCharacterSequenceAtIndex:characterIndex];
 444
 445                   compRange.length =
 446                     NSMaxRange (characterRange) - compRange.location;
 447                   [layoutManager glyphRangeForCharacterRange:compRange
 448                                         actualCharacterRange:&characterRange];
 449                   characterIndex = NSMaxRange (characterRange) - 1;
 450                 }
 451               while (characterIndex >= NSMaxRange (compRange));
 452
 453               if (RIGHT_TO_LEFT_P)
 454                 for (i = 0; i < range.length; i++)
 455                   permutation[range.location + i] = NSMaxRange (range) - i - 1;
 456
 457               range = NSMakeRange (NSMaxRange (range), 0);
 458             }
 459
 460           gl->comp_range.location = compRange.location;
 461           gl->comp_range.length = compRange.length;
 462
 463           while (++glyphIndex < numberOfGlyphs)
 464             if (![layoutManager notShownAttributeForGlyphAtIndex:glyphIndex])
 465               break;
 466         }
 467       if (RIGHT_TO_LEFT_P)
 468         for (i = 0; i < range.length; i++)
 469           permutation[range.location + i] = NSMaxRange (range) - i - 1;
 470
 471       /* Then fill the remaining members.  */
 472       glyphIndex = prevGlyphIndex = 0;
 473       while ([layoutManager notShownAttributeForGlyphAtIndex:glyphIndex])
 474         glyphIndex++;
 475
 476       if (!RIGHT_TO_LEFT_P)
 477         totalAdvance = 0;
 478       else
 479         {
 480           NSUInteger nrects;
 481           NSRect *glyphRects =
 482             [layoutManager
 483               rectArrayForGlyphRange:(NSMakeRange (0, numberOfGlyphs))
 484               withinSelectedGlyphRange:(NSMakeRange (NSNotFound, 0))
 485                      inTextContainer:textContainer rectCount:&nrects];
 486
 487           totalAdvance = NSMaxX (glyphRects[0]);
 488         }
 489
 490       for (i = 0; i < used; i++)
 491         {
 492           struct mac_glyph_layout *gl;
 493           NSPoint location;
 494           NSUInteger nextGlyphIndex;
 495           NSRange glyphRange;
 496           NSRect *glyphRects;
 497           NSUInteger nrects;
 498
 499           if (!RIGHT_TO_LEFT_P)
 500             gl = glyph_layouts + i;
 501           else
 502             {
 503               NSUInteger dest = permutation[i];
 504
 505               gl = glyph_layouts + dest;
 506               if (i < dest)
 507                 {
 508                   CFIndex tmp = gl->string_index;
 509
 510                   gl->string_index = glyph_layouts[i].string_index;
 511                   glyph_layouts[i].string_index = tmp;
 512                 }
 513             }
 514           gl->glyph_id = [layoutManager glyphAtIndex:glyphIndex];
 515
 516           location = [layoutManager locationForGlyphAtIndex:glyphIndex];
 517           gl->baseline_delta = spaceLocation.y - location.y;
 518
 519           for (nextGlyphIndex = glyphIndex + 1; nextGlyphIndex < numberOfGlyphs;
 520                nextGlyphIndex++)
 521             if (![layoutManager
 522                    notShownAttributeForGlyphAtIndex:nextGlyphIndex])
 523               break;
 524
 525           if (!RIGHT_TO_LEFT_P)
 526             {
 527               CGFloat maxX;
 528
 529               if (prevGlyphIndex == 0)
 530                 glyphRange = NSMakeRange (0, nextGlyphIndex);
 531               else
 532                 glyphRange = NSMakeRange (glyphIndex,
 533                                           nextGlyphIndex - glyphIndex);
 534               glyphRects =
 535                 [layoutManager
 536                   rectArrayForGlyphRange:glyphRange
 537                   withinSelectedGlyphRange:(NSMakeRange (NSNotFound, 0))
 538                          inTextContainer:textContainer rectCount:&nrects];
 539               maxX = max (NSMaxX (glyphRects[0]), totalAdvance);
 540               gl->advance_delta = location.x - totalAdvance;
 541               gl->advance = maxX - totalAdvance;
 542               totalAdvance = maxX;
 543             }
 544           else
 545             {
 546               CGFloat minX;
 547
 548               if (nextGlyphIndex == numberOfGlyphs)
 549                 glyphRange = NSMakeRange (prevGlyphIndex,
 550                                           numberOfGlyphs - prevGlyphIndex);
 551               else
 552                 glyphRange = NSMakeRange (prevGlyphIndex,
 553                                           glyphIndex + 1 - prevGlyphIndex);
 554               glyphRects =
 555                 [layoutManager
 556                   rectArrayForGlyphRange:glyphRange
 557                   withinSelectedGlyphRange:(NSMakeRange (NSNotFound, 0))
 558                          inTextContainer:textContainer rectCount:&nrects];
 559               minX = min (NSMinX (glyphRects[0]), totalAdvance);
 560               gl->advance = totalAdvance - minX;
 561               totalAdvance = minX;
 562               gl->advance_delta = location.x - totalAdvance;
 563             }
 564
 565           prevGlyphIndex = glyphIndex + 1;
 566           glyphIndex = nextGlyphIndex;
 567         }
 568
 569       if (RIGHT_TO_LEFT_P)
 570         xfree (permutation);
 571
 572 #undef RIGHT_TO_LEFT_P
 573
 574       result = used;
 575     }
 576   [textStorage release];
 577
 578   return result;
 579 }
 580
 581 static CFIndex
 582 mac_screen_font_shape (ScreenFontRef font, CFStringRef string,
 583                        struct mac_glyph_layout *glyph_layouts,
 584                        CFIndex glyph_len)
 585 {
 586   return mac_font_shape_1 ([(NSFont *)font printerFont],
 587                            (NSString *) string,
 588                            glyph_layouts, glyph_len);
 589 }
 590
 591 static CGColorRef
 592 get_cgcolor(unsigned long idx, struct frame *f)
 593 {
 594   NSColor *nsColor = ns_lookup_indexed_color (idx, f);
 595   [nsColor set];
 596   CGColorSpaceRef colorSpace = [[nsColor colorSpace] CGColorSpace];
 597   NSInteger noc = [nsColor numberOfComponents];
 598   CGFloat *components = xmalloc (sizeof(CGFloat)*(1+noc));
 599   CGColorRef cgColor;
 600
 601   [nsColor getComponents: components];
 602   cgColor = CGColorCreate (colorSpace, components);
 603   xfree (components);
 604   return cgColor;
 605 }
 606
 607 #define CG_SET_FILL_COLOR_WITH_FACE_FOREGROUND(context, face, f)        \
 608   do {                                                                  \
 609     CGColorRef refcol_ = get_cgcolor (NS_FACE_FOREGROUND (face), f);    \
 610     CGContextSetFillColorWithColor (context, refcol_) ;                 \
 611     CGColorRelease (refcol_);                                           \
 612   } while (0)
 613 #define CG_SET_FILL_COLOR_WITH_FACE_BACKGROUND(context, face, f)        \
 614   do {                                                                  \
 615     CGColorRef refcol_ = get_cgcolor (NS_FACE_BACKGROUND (face), f);    \
 616     CGContextSetFillColorWithColor (context, refcol_);                  \
 617     CGColorRelease (refcol_);                                           \
 618   } while (0)
 619 #define CG_SET_STROKE_COLOR_WITH_FACE_FOREGROUND(context, face, f)      \
 620   do {                                                                  \
 621     CGColorRef refcol_ = get_cgcolor (NS_FACE_FOREGROUND (face), f);    \
 622     CGContextSetStrokeColorWithColor (context, refcol_);                \
 623     CGColorRelease (refcol_);                                           \
 624   } while (0)
 625
 626
 627 \f
 628 /* Mac font driver.  */
 629
 630 static struct
 631 {
 632   /* registry name */
 633   const char *name;
 634   /* characters to distinguish the charset from the others */
 635   int uniquifier[6];
 636   /* additional constraint by language */
 637   CFStringRef lang;
 638   /* set on demand */
 639   CFCharacterSetRef cf_charset;
 640   CFStringRef cf_charset_string;
 641 } cf_charset_table[] =
 642   { { "iso8859-1", { 0x00A0, 0x00A1, 0x00B4, 0x00BC, 0x00D0 } },
 643     { "iso8859-2", { 0x00A0, 0x010E }},
 644     { "iso8859-3", { 0x00A0, 0x0108 }},
 645     { "iso8859-4", { 0x00A0, 0x00AF, 0x0128, 0x0156, 0x02C7 }},
 646     { "iso8859-5", { 0x00A0, 0x0401 }},
 647     { "iso8859-6", { 0x00A0, 0x060C }},
 648     { "iso8859-7", { 0x00A0, 0x0384 }},
 649     { "iso8859-8", { 0x00A0, 0x05D0 }},
 650     { "iso8859-9", { 0x00A0, 0x00A1, 0x00BC, 0x011E }},
 651     { "iso8859-10", { 0x00A0, 0x00D0, 0x0128, 0x2015 }},
 652     { "iso8859-11", { 0x00A0, 0x0E01 }},
 653     { "iso8859-13", { 0x00A0, 0x201C }},
 654     { "iso8859-14", { 0x00A0, 0x0174 }},
 655     { "iso8859-15", { 0x00A0, 0x00A1, 0x00D0, 0x0152 }},
 656     { "iso8859-16", { 0x00A0, 0x0218}},
 657     { "gb2312.1980-0", { 0x4E13 }, CFSTR ("zh-Hans")},
 658     { "big5-0", { /* 0xF6B1 in ftfont.c */ 0x4EDC }, CFSTR ("zh-Hant") },
 659     { "jisx0208.1983-0", { 0x4E55 }, CFSTR ("ja")},
 660     { "ksc5601.1987-0", { 0xAC00 }, CFSTR ("ko")},
 661     { "cns11643.1992-1", { 0xFE32 }, CFSTR ("zh-Hant")},
 662     { "cns11643.1992-2", { 0x4E33, 0x7934 }},
 663     { "cns11643.1992-3", { 0x201A9 }},
 664     { "cns11643.1992-4", { 0x20057 }},
 665     { "cns11643.1992-5", { 0x20000 }},
 666     { "cns11643.1992-6", { 0x20003 }},
 667     { "cns11643.1992-7", { 0x20055 }},
 668     { "gbk-0", { 0x4E06 }, CFSTR ("zh-Hans")},
 669     { "jisx0212.1990-0", { 0x4E44 }},
 670     { "jisx0213.2000-1", { 0xFA10 }, CFSTR ("ja")},
 671     { "jisx0213.2000-2", { 0xFA49 }},
 672     { "jisx0213.2004-1", { 0x20B9F }},
 673     { "viscii1.1-1", { 0x1EA0, 0x1EAE, 0x1ED2 }, CFSTR ("vi")},
 674     { "tis620.2529-1", { 0x0E01 }, CFSTR ("th")},
 675     { "windows-1251", { 0x0401, 0x0490 }, CFSTR ("ru")},
 676     { "koi8-r", { 0x0401, 0x2219 }, CFSTR ("ru")},
 677     { "mulelao-1", { 0x0E81 }, CFSTR ("lo")},
 678     { "unicode-sip", { 0x20000 }},
 679     { NULL }
 680   };
 681
 682 #if MAC_OS_X_VERSION_MIN_REQUIRED < 1080
 683 static const struct
 684 {
 685   CFStringRef language;
 686   CFStringRef font_names[3];
 687 } macfont_language_default_font_names[] = {
 688   { CFSTR ("ja"), { CFSTR ("HiraKakuProN-W3"), /* 10.5 - 10.9 */
 689                     CFSTR ("HiraKakuPro-W3"),  /* 10.4 */
 690                     NULL }},
 691   { CFSTR ("ko"), { CFSTR ("AppleSDGothicNeo-Regular"), /* 10.8 - 10.9 */
 692                     CFSTR ("AppleGothic"), /* 10.4 - 10.7 */
 693                     NULL }},
 694   { CFSTR ("zh-Hans"), { CFSTR ("STHeitiSC-Light"), /* 10.6 - 10.9 */
 695                          CFSTR ("STXihei"),         /* 10.4 - 10.5 */
 696                          NULL }},
 697   { CFSTR ("zh-Hant"), { CFSTR ("STHeitiTC-Light"), /* 10.6 - 10.9 */
 698                          CFSTR ("LiHeiPro"),        /* 10.4 - 10.5 */
 699                          NULL }},
 700   { NULL }
 701 };
 702 #endif
 703
 704 static CGFloat macfont_antialias_threshold;
 705
 706 void
 707 macfont_update_antialias_threshold (void)
 708 {
 709   int threshold;
 710   Boolean valid_p;
 711
 712   threshold =
 713     CFPreferencesGetAppIntegerValue (CFSTR ("AppleAntiAliasingThreshold"),
 714                                      kCFPreferencesCurrentApplication,
 715                                      &valid_p);
 716   if (valid_p)
 717     macfont_antialias_threshold = threshold;
 718 }
 719
 720 static inline Lisp_Object
 721 macfont_intern_prop_cfstring (CFStringRef cfstring)
 722 {
 723   Lisp_Object string = cfstring_to_lisp_nodecode (cfstring);
 724
 725   return font_intern_prop (SSDATA (string), SBYTES (string), 1);
 726 }
 727
 728 static inline CFIndex
 729 macfont_store_utf32char_to_unichars (UTF32Char c, UniChar *unichars)
 730 {
 731   if (c < 0x10000)
 732     {
 733       unichars[0] = c;
 734
 735       return 1;
 736     }
 737   else
 738     {
 739       c -= 0x10000;
 740       unichars[0] = (c >> 10) + 0xD800;
 741       unichars[1] = (c & 0x3FF) + 0xDC00;
 742
 743       return 2;
 744     }
 745 }
 746
 747 static Boolean
 748 cfnumber_get_font_symbolic_traits_value (CFNumberRef number,
 749                                          CTFontSymbolicTraits *sym_traits)
 750 {
 751   SInt64 sint64_value;
 752
 753   /* Getting symbolic traits with kCFNumberSInt32Type is lossy on Mac
 754      OS X 10.6 when the value is greater than or equal to 1 << 31.  */
 755   if (CFNumberGetValue (number, kCFNumberSInt64Type, &sint64_value))
 756     {
 757       *sym_traits = (CTFontSymbolicTraits) sint64_value;
 758
 759       return true;
 760     }
 761
 762   return false;
 763 }
 764
 765 static CGFloat
 766 mac_font_descriptor_get_adjusted_weight (CTFontDescriptorRef desc, CGFloat val)
 767 {
 768   long percent_val = lround (val * 100);
 769
 770   if (percent_val == -40)
 771     {
 772       CTFontRef font = NULL;
 773       CFStringRef name =
 774         CTFontDescriptorCopyAttribute (desc, kCTFontNameAttribute);
 775
 776       if (name)
 777         {
 778           font = CTFontCreateWithName (name, 0, NULL);
 779           CFRelease (name);
 780         }
 781       if (font)
 782         {
 783           CFIndex weight = mac_font_get_weight (font);
 784
 785           /* Workaround for crash when displaying Oriya characters
 786              with Arial Unicode MS on OS X 10.11.  */
 787           if (weight == 5)
 788             val = 0;
 789           CFRelease (font);
 790         }
 791     }
 792
 793   return val;
 794 }
 795
 796 static void
 797 macfont_store_descriptor_attributes (CTFontDescriptorRef desc,
 798                                      Lisp_Object spec_or_entity)
 799 {
 800   CFStringRef str;
 801   CFDictionaryRef dict;
 802   CFNumberRef num;
 803   CGFloat floatval;
 804
 805   str = CTFontDescriptorCopyAttribute (desc, kCTFontFamilyNameAttribute);
 806   if (str)
 807     {
 808       ASET (spec_or_entity, FONT_FAMILY_INDEX,
 809             macfont_intern_prop_cfstring (str));
 810       CFRelease (str);
 811     }
 812   dict = CTFontDescriptorCopyAttribute (desc, kCTFontTraitsAttribute);
 813   if (dict)
 814     {
 815       struct {
 816         enum font_property_index index;
 817         CFStringRef trait;
 818         CGPoint points[6];
 819         CGFloat (*adjust_func) (CTFontDescriptorRef, CGFloat);
 820       } numeric_traits[] =
 821           {{FONT_WEIGHT_INDEX, kCTFontWeightTrait,
 822             {{-0.4, 50},        /* light */
 823              {-0.24, 87.5},     /* (semi-light + normal) / 2 */
 824              {0, 100},          /* normal */
 825              {0.24, 140},       /* (semi-bold + normal) / 2 */
 826              {0.4, 200},        /* bold */
 827              {CGFLOAT_MAX, CGFLOAT_MAX}},
 828             mac_font_descriptor_get_adjusted_weight},
 829            {FONT_SLANT_INDEX, kCTFontSlantTrait,
 830             {{0, 100}, {0.1, 200}, {CGFLOAT_MAX, CGFLOAT_MAX}}, NULL},
 831            {FONT_WIDTH_INDEX, kCTFontWidthTrait,
 832             {{0, 100}, {1, 200}, {CGFLOAT_MAX, CGFLOAT_MAX}}, NULL}};
 833       int i;
 834
 835       for (i = 0; i < ARRAYELTS (numeric_traits); i++)
 836         {
 837           num = CFDictionaryGetValue (dict, numeric_traits[i].trait);
 838           if (num && CFNumberGetValue (num, kCFNumberCGFloatType, &floatval))
 839             {
 840               CGPoint *point = numeric_traits[i].points;
 841
 842               if (numeric_traits[i].adjust_func)
 843                 floatval = (*numeric_traits[i].adjust_func) (desc, floatval);
 844               while (point->x < floatval)
 845                 point++;
 846               if (point == numeric_traits[i].points)
 847                 point++;
 848               else if (point->x == CGFLOAT_MAX)
 849                 point--;
 850               floatval = (point - 1)->y + ((floatval - (point - 1)->x)
 851                                            * ((point->y - (point - 1)->y)
 852                                               / (point->x - (point - 1)->x)));
 853               FONT_SET_STYLE (spec_or_entity, numeric_traits[i].index,
 854                               make_number (lround (floatval)));
 855             }
 856         }
 857
 858       num = CFDictionaryGetValue (dict, kCTFontSymbolicTrait);
 859       if (num)
 860         {
 861           CTFontSymbolicTraits sym_traits;
 862           int spacing;
 863
 864           cfnumber_get_font_symbolic_traits_value (num, &sym_traits);
 865           spacing = (sym_traits & kCTFontTraitMonoSpace
 866                      ? FONT_SPACING_MONO : FONT_SPACING_PROPORTIONAL);
 867           ASET (spec_or_entity, FONT_SPACING_INDEX, make_number (spacing));
 868         }
 869
 870       CFRelease (dict);
 871     }
 872   num = CTFontDescriptorCopyAttribute (desc, kCTFontSizeAttribute);
 873   if (num && CFNumberGetValue (num, kCFNumberCGFloatType, &floatval))
 874     ASET (spec_or_entity, FONT_SIZE_INDEX, make_number (floatval));
 875   else
 876     ASET (spec_or_entity, FONT_SIZE_INDEX, make_number (0));
 877   if (num)
 878     CFRelease (num);
 879 }
 880
 881 static Lisp_Object
 882 macfont_descriptor_entity (CTFontDescriptorRef desc, Lisp_Object extra,
 883                            CTFontSymbolicTraits synth_sym_traits)
 884 {
 885   Lisp_Object entity;
 886   CFDictionaryRef dict;
 887   CTFontSymbolicTraits sym_traits = 0;
 888   CFStringRef name;
 889
 890   entity = font_make_entity ();
 891
 892   ASET (entity, FONT_TYPE_INDEX, Qmac_ct);
 893   ASET (entity, FONT_REGISTRY_INDEX, Qiso10646_1);
 894
 895   macfont_store_descriptor_attributes (desc, entity);
 896
 897   dict = CTFontDescriptorCopyAttribute (desc, kCTFontTraitsAttribute);
 898   if (dict)
 899     {
 900       CFNumberRef num = CFDictionaryGetValue (dict, kCTFontSymbolicTrait);
 901
 902       if (num)
 903         cfnumber_get_font_symbolic_traits_value (num, &sym_traits);
 904       CFRelease (dict);
 905     }
 906   if (EQ (AREF (entity, FONT_SIZE_INDEX), make_number (0)))
 907     ASET (entity, FONT_AVGWIDTH_INDEX, make_number (0));
 908   ASET (entity, FONT_EXTRA_INDEX, Fcopy_sequence (extra));
 909   name = CTFontDescriptorCopyAttribute (desc, kCTFontNameAttribute);
 910   font_put_extra (entity, QCfont_entity,
 911                   make_save_ptr_int ((void *) name, sym_traits));
 912   if (synth_sym_traits & kCTFontTraitItalic)
 913     FONT_SET_STYLE (entity, FONT_SLANT_INDEX,
 914                     make_number (FONT_SLANT_SYNTHETIC_ITALIC));
 915   if (synth_sym_traits & kCTFontTraitBold)
 916     FONT_SET_STYLE (entity, FONT_WEIGHT_INDEX,
 917                     make_number (FONT_WEIGHT_SYNTHETIC_BOLD));
 918   if (synth_sym_traits & kCTFontTraitMonoSpace)
 919     ASET (entity, FONT_SPACING_INDEX,
 920           make_number (FONT_SPACING_SYNTHETIC_MONO));
 921
 922   return entity;
 923 }
 924
 925 /* Cache for font family name symbols vs CFStrings.  A value of nil
 926 means the cache has been invalidated.  Otherwise the value is a Lisp
 927 hash table whose keys are symbols and the value for a key is either
 928 nil (no corresponding family name) or a Lisp save value wrapping the
 929 corresponding family name in CFString.  */
 930
 931 static Lisp_Object macfont_family_cache;
 932
 933 static void
 934 macfont_invalidate_family_cache (void)
 935 {
 936   if (HASH_TABLE_P (macfont_family_cache))
 937     {
 938       struct Lisp_Hash_Table *h = XHASH_TABLE (macfont_family_cache);
 939       ptrdiff_t i, size = HASH_TABLE_SIZE (h);
 940
 941       for (i = 0; i < size; ++i)
 942         if (!NILP (HASH_HASH (h, i)))
 943           {
 944             Lisp_Object value = HASH_VALUE (h, i);
 945
 946             if (SAVE_VALUEP (value))
 947               CFRelease (XSAVE_POINTER (value, 0));
 948           }
 949       macfont_family_cache = Qnil;
 950     }
 951 }
 952
 953 static bool
 954 macfont_get_family_cache_if_present (Lisp_Object symbol, CFStringRef *string)
 955 {
 956   if (HASH_TABLE_P (macfont_family_cache))
 957     {
 958       struct Lisp_Hash_Table *h = XHASH_TABLE (macfont_family_cache);
 959       ptrdiff_t i = hash_lookup (h, symbol, NULL);
 960
 961       if (i >= 0)
 962         {
 963           Lisp_Object value = HASH_VALUE (h, i);
 964
 965           *string = SAVE_VALUEP (value) ? XSAVE_POINTER (value, 0) : NULL;
 966
 967           return true;
 968         }
 969     }
 970
 971   return false;
 972 }
 973
 974 static void
 975 macfont_set_family_cache (Lisp_Object symbol, CFStringRef string)
 976 {
 977   struct Lisp_Hash_Table *h;
 978   ptrdiff_t i;
 979   EMACS_UINT hash;
 980   Lisp_Object value;
 981
 982   if (!HASH_TABLE_P (macfont_family_cache))
 983     macfont_family_cache = CALLN (Fmake_hash_table, QCtest, Qeq);
 984
 985   h = XHASH_TABLE (macfont_family_cache);
 986   i = hash_lookup (h, symbol, &hash);
 987   value = string ? make_save_ptr ((void *) CFRetain (string)) : Qnil;
 988   if (i >= 0)
 989     {
 990       Lisp_Object old_value = HASH_VALUE (h, i);
 991
 992       if (SAVE_VALUEP (old_value))
 993         CFRelease (XSAVE_POINTER (old_value, 0));
 994       set_hash_value_slot (h, i, value);
 995     }
 996   else
 997     hash_put (h, symbol, value, hash);
 998 }
 999
1000 /* Cache of all the available font family names except "LastResort"
1001 and those start with ".".  NULL means the cache has been invalidated.
1002 Otherwise, the value is CFArray of CFStrings and the elements are
1003 sorted in the canonical order (CTFontManagerCompareFontFamilyNames on
1004 Mac OS X 10.6 and later).  */
1005
1006 static CFArrayRef macfont_available_families_cache = NULL;
1007
1008 static void
1009 macfont_invalidate_available_families_cache (void)
1010 {
1011   if (macfont_available_families_cache)
1012     {
1013       CFRelease (macfont_available_families_cache);
1014       macfont_available_families_cache = NULL;
1015     }
1016 }
1017
1018 static void
1019 macfont_handle_font_change_notification (CFNotificationCenterRef center,
1020                                          void *observer,
1021                                          CFStringRef name, const void *object,
1022                                          CFDictionaryRef userInfo)
1023 {
1024   macfont_invalidate_family_cache ();
1025   macfont_invalidate_available_families_cache ();
1026 }
1027
1028 static void
1029 macfont_init_font_change_handler (void)
1030 {
1031   static bool initialized = false;
1032
1033   if (initialized)
1034     return;
1035
1036   initialized = true;
1037   CFNotificationCenterAddObserver
1038     (CFNotificationCenterGetLocalCenter (), NULL,
1039      macfont_handle_font_change_notification,
1040      kCTFontManagerRegisteredFontsChangedNotification,
1041      NULL, CFNotificationSuspensionBehaviorCoalesce);
1042 }
1043
1044 static CFArrayRef
1045 macfont_copy_available_families_cache (void)
1046 {
1047   macfont_init_font_change_handler ();
1048
1049   if (macfont_available_families_cache == NULL)
1050     macfont_available_families_cache = mac_font_create_available_families ();
1051
1052   return (macfont_available_families_cache
1053           ? CFRetain (macfont_available_families_cache) : NULL);
1054 }
1055
1056 static CFStringRef
1057 macfont_create_family_with_symbol (Lisp_Object symbol)
1058 {
1059   CFStringRef result = NULL, family_name;
1060   CFDictionaryRef attributes = NULL;
1061   CTFontDescriptorRef pat_desc = NULL;
1062
1063   if (macfont_get_family_cache_if_present (symbol, &result))
1064     return result ? CFRetain (result) : NULL;
1065
1066   family_name = cfstring_create_with_string_noencode (SYMBOL_NAME (symbol));
1067   if (family_name)
1068     {
1069       attributes =
1070         CFDictionaryCreate (NULL,
1071                             (const void **) &kCTFontFamilyNameAttribute,
1072                             (const void **) &family_name, 1,
1073                             &kCFTypeDictionaryKeyCallBacks,
1074                             &kCFTypeDictionaryValueCallBacks);
1075       CFRelease (family_name);
1076     }
1077   if (attributes)
1078     {
1079       pat_desc = CTFontDescriptorCreateWithAttributes (attributes);
1080       CFRelease (attributes);
1081     }
1082   if (pat_desc)
1083     {
1084       CTFontDescriptorRef desc =
1085         CTFontDescriptorCreateMatchingFontDescriptor (pat_desc, NULL);
1086
1087       if (desc)
1088         {
1089           result =
1090             CTFontDescriptorCopyAttribute (desc, kCTFontFamilyNameAttribute);
1091           CFRelease (desc);
1092         }
1093       macfont_set_family_cache (symbol, result);
1094       CFRelease (pat_desc);
1095     }
1096
1097   return result;
1098 }
1099
1100 #define WIDTH_FRAC_BITS         (4)
1101 #define WIDTH_FRAC_SCALE        (2 * ((1 << (WIDTH_FRAC_BITS - 1)) - 1))
1102
1103 struct macfont_metrics
1104 {
1105   unsigned char lbearing_low, rbearing_low;
1106   signed lbearing_high : 4, rbearing_high : 4;
1107   unsigned char ascent_low, descent_low;
1108   signed ascent_high : 4, descent_high : 4;
1109
1110   /* These two members are used for fixed-point representation of
1111      glyph width.  The `width_int' member is an integer that is
1112      closest to the width.  The `width_frac' member is the fractional
1113      adjustment representing a value in [-.5, .5], multiplied by
1114      WIDTH_FRAC_SCALE.  For synthetic monospace fonts, they represent
1115      the advance delta for centering instead of the glyph width.  */
1116   signed width_frac : WIDTH_FRAC_BITS, width_int : 16 - WIDTH_FRAC_BITS;
1117 };
1118
1119 #define METRICS_VALUE(metrics, member)                          \
1120   (((metrics)->member##_high << 8) | (metrics)->member##_low)
1121 #define METRICS_SET_VALUE(metrics, member, value)                   \
1122   do {short tmp = (value); (metrics)->member##_low = tmp & 0xff;    \
1123     (metrics)->member##_high = tmp >> 8;} while (0)
1124
1125 enum metrics_status
1126 {
1127   METRICS_INVALID = -1,    /* metrics entry is invalid */
1128   METRICS_WIDTH_VALID = -2 /* width is valid but others are invalid */
1129 };
1130
1131 #define METRICS_STATUS(metrics)                                         \
1132   (METRICS_VALUE (metrics, ascent) + METRICS_VALUE (metrics, descent))
1133 #define METRICS_SET_STATUS(metrics, status)                     \
1134   do {METRICS_SET_VALUE (metrics, ascent, 0);                   \
1135     METRICS_SET_VALUE (metrics, descent, status);} while (0)
1136
1137 #define METRICS_NCOLS_PER_ROW   (128)
1138 #define LCD_FONT_SMOOTHING_LEFT_MARGIN  (0.396f)
1139 #define LCD_FONT_SMOOTHING_RIGHT_MARGIN (0.396f)
1140
1141 static int
1142 macfont_glyph_extents (struct font *font, CGGlyph glyph,
1143                        struct font_metrics *metrics, CGFloat *advance_delta,
1144                        int force_integral_p)
1145 {
1146   struct macfont_info *macfont_info = (struct macfont_info *) font;
1147   CTFontRef macfont = macfont_info->macfont;
1148   int row, col;
1149   struct macfont_metrics *cache;
1150   int width;
1151
1152   row = glyph / METRICS_NCOLS_PER_ROW;
1153   col = glyph % METRICS_NCOLS_PER_ROW;
1154   if (row >= macfont_info->metrics_nrows)
1155     {
1156       macfont_info->metrics =
1157         xrealloc (macfont_info->metrics,
1158                   sizeof (struct macfont_metrics *) * (row + 1));
1159       memset (macfont_info->metrics + macfont_info->metrics_nrows, 0,
1160               (sizeof (struct macfont_metrics *)
1161                * (row + 1 - macfont_info->metrics_nrows)));
1162       macfont_info->metrics_nrows = row + 1;
1163     }
1164   if (macfont_info->metrics[row] == NULL)
1165     {
1166       struct macfont_metrics *new;
1167       int i;
1168
1169       new = xmalloc (sizeof (struct macfont_metrics) * METRICS_NCOLS_PER_ROW);
1170       for (i = 0; i < METRICS_NCOLS_PER_ROW; i++)
1171         METRICS_SET_STATUS (new + i, METRICS_INVALID);
1172       macfont_info->metrics[row] = new;
1173     }
1174   cache = macfont_info->metrics[row] + col;
1175
1176   if (METRICS_STATUS (cache) == METRICS_INVALID)
1177     {
1178       CGFloat fwidth;
1179
1180       if (macfont_info->screen_font)
1181         fwidth = mac_screen_font_get_advance_width_for_glyph (macfont_info->screen_font, glyph);
1182       else
1183         fwidth = mac_font_get_advance_width_for_glyph (macfont, glyph);
1184
1185       /* For synthetic mono fonts, cache->width_{int,frac} holds the
1186          advance delta value.  */
1187       if (macfont_info->spacing == MACFONT_SPACING_SYNTHETIC_MONO)
1188         fwidth = (font->pixel_size - fwidth) / 2;
1189       cache->width_int = lround (fwidth);
1190       cache->width_frac = lround ((fwidth - cache->width_int)
1191                                   * WIDTH_FRAC_SCALE);
1192       METRICS_SET_STATUS (cache, METRICS_WIDTH_VALID);
1193     }
1194   if (macfont_info->spacing == MACFONT_SPACING_SYNTHETIC_MONO)
1195     width = font->pixel_size;
1196   else
1197     width = cache->width_int;
1198
1199   if (metrics)
1200     {
1201       if (METRICS_STATUS (cache) == METRICS_WIDTH_VALID)
1202         {
1203           CGRect bounds = mac_font_get_bounding_rect_for_glyph (macfont, glyph);
1204
1205           if (macfont_info->synthetic_italic_p)
1206             {
1207               /* We assume the members a, b, c, and d in
1208                  synthetic_italic_atfm are non-negative.  */
1209               bounds.origin =
1210                 CGPointApplyAffineTransform (bounds.origin,
1211                                              synthetic_italic_atfm);
1212               bounds.size =
1213                 CGSizeApplyAffineTransform (bounds.size, synthetic_italic_atfm);
1214             }
1215           if (macfont_info->synthetic_bold_p && ! force_integral_p)
1216             {
1217               CGFloat d = - synthetic_bold_factor * CTFontGetSize (macfont) / 2;
1218
1219               bounds = CGRectInset (bounds, d, d);
1220             }
1221           switch (macfont_info->spacing)
1222             {
1223             case MACFONT_SPACING_PROPORTIONAL:
1224               bounds.origin.x += - (cache->width_frac
1225                                     / (CGFloat) (WIDTH_FRAC_SCALE * 2));
1226               break;
1227             case MACFONT_SPACING_MONO:
1228               break;
1229             case MACFONT_SPACING_SYNTHETIC_MONO:
1230               bounds.origin.x += (cache->width_int
1231                                   + (cache->width_frac
1232                                      / (CGFloat) WIDTH_FRAC_SCALE));
1233               break;
1234             }
1235           if (bounds.size.width > 0)
1236             {
1237               bounds.origin.x -= LCD_FONT_SMOOTHING_LEFT_MARGIN;
1238               bounds.size.width += (LCD_FONT_SMOOTHING_LEFT_MARGIN
1239                                     + LCD_FONT_SMOOTHING_RIGHT_MARGIN);
1240             }
1241           bounds = CGRectIntegral (bounds);
1242           METRICS_SET_VALUE (cache, lbearing, CGRectGetMinX (bounds));
1243           METRICS_SET_VALUE (cache, rbearing, CGRectGetMaxX (bounds));
1244           METRICS_SET_VALUE (cache, ascent, CGRectGetMaxY (bounds));
1245           METRICS_SET_VALUE (cache, descent, -CGRectGetMinY (bounds));
1246         }
1247       metrics->lbearing = METRICS_VALUE (cache, lbearing);
1248       metrics->rbearing = METRICS_VALUE (cache, rbearing);
1249       metrics->width = width;
1250       metrics->ascent = METRICS_VALUE (cache, ascent);
1251       metrics->descent = METRICS_VALUE (cache, descent);
1252     }
1253
1254   if (advance_delta)
1255     {
1256       switch (macfont_info->spacing)
1257         {
1258         case MACFONT_SPACING_PROPORTIONAL:
1259           *advance_delta = (force_integral_p ? 0
1260                             : - (cache->width_frac
1261                                  / (CGFloat) (WIDTH_FRAC_SCALE * 2)));
1262           break;
1263         case MACFONT_SPACING_MONO:
1264           *advance_delta = 0;
1265           break;
1266         case MACFONT_SPACING_SYNTHETIC_MONO:
1267           *advance_delta = (force_integral_p ? cache->width_int
1268                             : (cache->width_int
1269                                + (cache->width_frac
1270                                   / (CGFloat) WIDTH_FRAC_SCALE)));
1271           break;
1272         }
1273     }
1274
1275   return width;
1276 }
1277
1278 static CFMutableDictionaryRef macfont_cache_dictionary;
1279
1280 /* Threshold used in row_nkeys_or_perm.  This must be less than or
1281    equal to the number of rows that are invalid as BMP (i.e., from
1282    U+D800 to U+DFFF).  */
1283 #define ROW_PERM_OFFSET (8)
1284
1285 /* The number of glyphs that can be stored in a value for a single
1286    entry of CFDictionary.  */
1287 #define NGLYPHS_IN_VALUE (sizeof (void *) / sizeof (CGGlyph))
1288
1289 struct macfont_cache
1290 {
1291   int reference_count;
1292   CFCharacterSetRef cf_charset;
1293   struct {
1294     /* The cached glyph for a BMP character c is stored in
1295        matrix[row_nkeys_or_perm[c / 256] - ROW_PERM_OFFSET][c % 256]
1296        if row_nkeys_or_perm[c / 256] >= ROW_PERM_OFFSET.  */
1297     unsigned char row_nkeys_or_perm[256];
1298     CGGlyph **matrix;
1299
1300     /* Number of rows for which the BMP cache is allocated so far.
1301        I.e., matrix[0] ... matrix[nrows - 1] are non-NULL.  */
1302     int nrows;
1303
1304     /* The cached glyph for a character c is stored as the (c %
1305        NGLYPHS_IN_VALUE)-th CGGlyph block of a value for the key (c /
1306        NGLYPHS_IN_VALUE).  However, the glyph for a BMP character c is
1307        not stored here if row_nkeys_or_perm[c / 256] >=
1308        ROW_PERM_OFFSET.  */
1309     CFMutableDictionaryRef dictionary;
1310   } glyph;
1311
1312   struct {
1313     /* UVS (Unicode Variation Sequence) subtable data, which is of
1314        type CFDataRef if available.  NULL means it is not initialized
1315        yet.  kCFNull means the subtable is not found and there is no
1316        suitable fallback table for this font.  */
1317     CFTypeRef table;
1318
1319     /* Character collection specifying the destination of the mapping
1320        provided by `table' above.  If `table' is obtained from the UVS
1321        subtable in the font cmap table, then the value of this member
1322        should be NSIdentityMappingCharacterCollection.  */
1323     NSCharacterCollection collection;
1324   } uvs;
1325 };
1326
1327 static struct macfont_cache *macfont_lookup_cache (CFStringRef);
1328 static struct macfont_cache *macfont_retain_cache (struct macfont_cache *);
1329 static void macfont_release_cache (struct macfont_cache *);
1330 static CFCharacterSetRef macfont_get_cf_charset (struct font *);
1331 static CFCharacterSetRef macfont_get_cf_charset_for_name (CFStringRef);
1332 static CGGlyph macfont_get_glyph_for_character (struct font *, UTF32Char);
1333 static CGGlyph macfont_get_glyph_for_cid (struct font *font,
1334                                           NSCharacterCollection, CGFontIndex);
1335 static CFDataRef macfont_get_uvs_table (struct font *, NSCharacterCollection *);
1336
1337 static struct macfont_cache *
1338 macfont_lookup_cache (CFStringRef key)
1339 {
1340   struct macfont_cache *cache;
1341
1342   if (macfont_cache_dictionary == NULL)
1343     {
1344       macfont_cache_dictionary =
1345         CFDictionaryCreateMutable (NULL, 0,
1346                                    &kCFTypeDictionaryKeyCallBacks, NULL);
1347       cache = NULL;
1348     }
1349   else
1350     cache = ((struct macfont_cache *)
1351              CFDictionaryGetValue (macfont_cache_dictionary, key));
1352
1353   if (cache == NULL)
1354     {
1355       CTFontRef macfont = CTFontCreateWithName (key, 0, NULL);
1356
1357       if (macfont)
1358         {
1359           cache = xzalloc (sizeof (struct macfont_cache));
1360           /* Treat the LastResort font as if it contained glyphs for
1361              all characters.  This may look too rough, but neither
1362              CTFontCopyCharacterSet nor -[NSFont coveredCharacterSet]
1363              for this font is correct for non-BMP characters on Mac OS
1364              X 10.5, anyway.  */
1365           if (CFEqual (key, CFSTR ("LastResort")))
1366             {
1367               CFRange range = CFRangeMake (0, MAX_UNICODE_CHAR + 1);
1368
1369               cache->cf_charset =
1370                 CFCharacterSetCreateWithCharactersInRange (NULL, range);
1371             }
1372           if (cache->cf_charset == NULL)
1373             cache->cf_charset = CTFontCopyCharacterSet (macfont);
1374           CFDictionaryAddValue (macfont_cache_dictionary, key,
1375                                 (const void *) cache);
1376           CFRelease (macfont);
1377         }
1378     }
1379
1380   return cache;
1381 }
1382
1383 static struct macfont_cache *
1384 macfont_retain_cache (struct macfont_cache *cache)
1385 {
1386   cache->reference_count++;
1387
1388   return cache;
1389 }
1390
1391 static void
1392 macfont_release_cache (struct macfont_cache *cache)
1393 {
1394   if (--cache->reference_count == 0)
1395     {
1396       int i;
1397
1398       for (i = 0; i < cache->glyph.nrows; i++)
1399         xfree (cache->glyph.matrix[i]);
1400       xfree (cache->glyph.matrix);
1401       if (cache->glyph.dictionary)
1402         CFRelease (cache->glyph.dictionary);
1403       memset (&cache->glyph, 0, sizeof (cache->glyph));
1404       if (cache->uvs.table)
1405         CFRelease (cache->uvs.table);
1406       memset (&cache->uvs, 0, sizeof (cache->uvs));
1407     }
1408 }
1409
1410 static CFCharacterSetRef
1411 macfont_get_cf_charset (struct font *font)
1412 {
1413   struct macfont_info *macfont_info = (struct macfont_info *) font;
1414
1415   return macfont_info->cache->cf_charset;
1416 }
1417
1418 static CFCharacterSetRef
1419 macfont_get_cf_charset_for_name (CFStringRef name)
1420 {
1421   struct macfont_cache *cache = macfont_lookup_cache (name);
1422
1423   return cache->cf_charset;
1424 }
1425
1426 static CGGlyph
1427 macfont_get_glyph_for_character (struct font *font, UTF32Char c)
1428 {
1429   struct macfont_info *macfont_info = (struct macfont_info *) font;
1430   CTFontRef macfont = macfont_info->macfont;
1431   struct macfont_cache *cache = macfont_info->cache;
1432
1433   if (c < 0xD800 || (c > 0xDFFF && c < 0x10000))
1434     {
1435       int row = c / 256;
1436       int nkeys_or_perm = cache->glyph.row_nkeys_or_perm[row];
1437
1438       if (nkeys_or_perm < ROW_PERM_OFFSET)
1439         {
1440           UniChar unichars[256], ch;
1441           CGGlyph *glyphs;
1442           int i, len;
1443           int nrows;
1444           dispatch_queue_t queue;
1445           dispatch_group_t group = NULL;
1446
1447           if (row != 0)
1448             {
1449               CFMutableDictionaryRef dictionary;
1450               uintptr_t key, value;
1451               int nshifts;
1452               CGGlyph glyph;
1453
1454               if (cache->glyph.dictionary == NULL)
1455                 cache->glyph.dictionary =
1456                   CFDictionaryCreateMutable (NULL, 0, NULL, NULL);
1457               dictionary = cache->glyph.dictionary;
1458               key = c / NGLYPHS_IN_VALUE;
1459               nshifts = ((c % NGLYPHS_IN_VALUE) * sizeof (CGGlyph) * 8);
1460               value = ((uintptr_t)
1461                        CFDictionaryGetValue (dictionary, (const void *) key));
1462               glyph = (value >> nshifts);
1463               if (glyph)
1464                 return glyph;
1465
1466               if (nkeys_or_perm + 1 != ROW_PERM_OFFSET)
1467                 {
1468                   ch = c;
1469                   if (!CTFontGetGlyphsForCharacters (macfont, &ch, &glyph, 1)
1470                       || glyph == 0)
1471                     glyph = kCGFontIndexInvalid;
1472
1473                   if (value == 0)
1474                     cache->glyph.row_nkeys_or_perm[row] = nkeys_or_perm + 1;
1475                   value |= ((uintptr_t) glyph << nshifts);
1476                   CFDictionarySetValue (dictionary, (const void *) key,
1477                                         (const void *) value);
1478
1479                   return glyph;
1480                 }
1481
1482               queue =
1483                 dispatch_get_global_queue (DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
1484               group = dispatch_group_create ();
1485               dispatch_group_async (group, queue, ^{
1486                   int nkeys;
1487                   uintptr_t key;
1488                   nkeys = nkeys_or_perm;
1489                   for (key = row * (256 / NGLYPHS_IN_VALUE); ; key++)
1490                     if (CFDictionaryContainsKey (dictionary,
1491                                                  (const void *) key))
1492                       {
1493                         CFDictionaryRemoveValue (dictionary,
1494                                                  (const void *) key);
1495                         if (--nkeys == 0)
1496                           break;
1497                       }
1498                 });
1499             }
1500
1501           len = 0;
1502           for (i = 0; i < 256; i++)
1503             {
1504               ch = row * 256 + i;
1505               if (CFCharacterSetIsLongCharacterMember (cache->cf_charset, ch))
1506                 unichars[len++] = ch;
1507             }
1508
1509           glyphs = xmalloc (sizeof (CGGlyph) * 256);
1510           if (len > 0)
1511             {
1512               CTFontGetGlyphsForCharacters (macfont, unichars, glyphs, len);
1513               while (i > len)
1514                 {
1515                   int next = unichars[len - 1] % 256;
1516
1517                   while (--i > next)
1518                     glyphs[i] = kCGFontIndexInvalid;
1519
1520                   len--;
1521                   glyphs[i] = glyphs[len];
1522                   if (len == 0)
1523                     break;
1524                 }
1525             }
1526           if (i > len)
1527             while (i-- > 0)
1528               glyphs[i] = kCGFontIndexInvalid;
1529
1530           nrows = cache->glyph.nrows;
1531           nkeys_or_perm = nrows + ROW_PERM_OFFSET;
1532           cache->glyph.row_nkeys_or_perm[row] = nkeys_or_perm;
1533           nrows++;
1534           cache->glyph.matrix = xrealloc (cache->glyph.matrix,
1535                                           sizeof (CGGlyph *) * nrows);
1536           cache->glyph.matrix[nrows - 1] = glyphs;
1537           cache->glyph.nrows = nrows;
1538
1539           if (group)
1540             {
1541               dispatch_group_wait (group, DISPATCH_TIME_FOREVER);
1542               dispatch_release (group);
1543             }
1544         }
1545
1546       return cache->glyph.matrix[nkeys_or_perm - ROW_PERM_OFFSET][c % 256];
1547     }
1548   else
1549     {
1550       uintptr_t key, value;
1551       int nshifts;
1552       CGGlyph glyph;
1553
1554       if (cache->glyph.dictionary == NULL)
1555         cache->glyph.dictionary =
1556           CFDictionaryCreateMutable (NULL, 0, NULL, NULL);
1557       key = c / NGLYPHS_IN_VALUE;
1558       nshifts = ((c % NGLYPHS_IN_VALUE) * sizeof (CGGlyph) * 8);
1559       value = (uintptr_t) CFDictionaryGetValue (cache->glyph.dictionary,
1560                                                 (const void *) key);
1561       glyph = (value >> nshifts);
1562       if (glyph == 0)
1563         {
1564           UniChar unichars[2];
1565           CGGlyph glyphs[2];
1566           CFIndex count = macfont_store_utf32char_to_unichars (c, unichars);
1567
1568           if (CTFontGetGlyphsForCharacters (macfont, unichars, glyphs, count))
1569             glyph = glyphs[0];
1570           if (glyph == 0)
1571             glyph = kCGFontIndexInvalid;
1572
1573           value |= ((uintptr_t) glyph << nshifts);
1574           CFDictionarySetValue (cache->glyph.dictionary,
1575                                 (const void *) key, (const void *) value);
1576         }
1577
1578       return glyph;
1579     }
1580 }
1581
1582 static CGGlyph
1583 macfont_get_glyph_for_cid (struct font *font, NSCharacterCollection collection,
1584                            CGFontIndex cid)
1585 {
1586   struct macfont_info *macfont_info = (struct macfont_info *) font;
1587   CTFontRef macfont = macfont_info->macfont;
1588
1589   /* Cache it? */
1590   return mac_font_get_glyph_for_cid (macfont, collection, cid);
1591 }
1592
1593 static CFDataRef
1594 macfont_get_uvs_table (struct font *font, NSCharacterCollection *collection)
1595 {
1596   struct macfont_info *macfont_info = (struct macfont_info *) font;
1597   CTFontRef macfont = macfont_info->macfont;
1598   struct macfont_cache *cache = macfont_info->cache;
1599   CFDataRef result = NULL;
1600
1601   if (cache->uvs.table == NULL)
1602     {
1603       CFDataRef uvs_table = mac_font_copy_uvs_table (macfont);
1604       NSCharacterCollection uvs_collection =
1605         NSIdentityMappingCharacterCollection;
1606
1607       if (uvs_table == NULL
1608           && mac_font_get_glyph_for_cid (macfont,
1609                                          NSAdobeJapan1CharacterCollection,
1610                                          6480) != kCGFontIndexInvalid)
1611         {
1612           /* If the glyph for U+4E55 is accessible via its CID 6480,
1613              then we use the Adobe-Japan1 UVS table, which maps a
1614              variation sequence to a CID, as a fallback.  */
1615           static CFDataRef mac_uvs_table_adobe_japan1 = NULL;
1616
1617           if (mac_uvs_table_adobe_japan1 == NULL)
1618             mac_uvs_table_adobe_japan1 =
1619               CFDataCreateWithBytesNoCopy (NULL,
1620                                            mac_uvs_table_adobe_japan1_bytes,
1621                                            sizeof (mac_uvs_table_adobe_japan1_bytes),
1622                                            kCFAllocatorNull);
1623           if (mac_uvs_table_adobe_japan1)
1624             {
1625               uvs_table = CFRetain (mac_uvs_table_adobe_japan1);
1626               uvs_collection = NSAdobeJapan1CharacterCollection;
1627             }
1628         }
1629       if (uvs_table == NULL)
1630         cache->uvs.table = kCFNull;
1631       else
1632         cache->uvs.table = uvs_table;
1633       cache->uvs.collection = uvs_collection;
1634     }
1635
1636   if (cache->uvs.table != kCFNull)
1637     {
1638       result = cache->uvs.table;
1639       *collection = cache->uvs.collection;
1640     }
1641
1642   return result;
1643 }
1644
1645 static Lisp_Object macfont_get_cache (struct frame *);
1646 static Lisp_Object macfont_list (struct frame *, Lisp_Object);
1647 static Lisp_Object macfont_match (struct frame *, Lisp_Object);
1648 static Lisp_Object macfont_list_family (struct frame *);
1649 static void macfont_free_entity (Lisp_Object);
1650 static Lisp_Object macfont_open (struct frame *, Lisp_Object, int);
1651 static void macfont_close (struct font *);
1652 static int macfont_has_char (Lisp_Object, int);
1653 static unsigned macfont_encode_char (struct font *, int);
1654 static void macfont_text_extents (struct font *, unsigned int *, int,
1655                                   struct font_metrics *);
1656 static int macfont_draw (struct glyph_string *, int, int, int, int, bool);
1657 static Lisp_Object macfont_shape (Lisp_Object);
1658 static int macfont_variation_glyphs (struct font *, int c,
1659                                      unsigned variations[256]);
1660 static void macfont_filter_properties (Lisp_Object, Lisp_Object);
1661
1662 static struct font_driver const macfont_driver =
1663   {
1664   .type = LISPSYM_INITIALLY (Qmac_ct),
1665   .get_cache = macfont_get_cache,
1666   .list = macfont_list,
1667   .match = macfont_match,
1668   .list_family = macfont_list_family,
1669   .free_entity = macfont_free_entity,
1670   .open = macfont_open,
1671   .close = macfont_close,
1672   .has_char = macfont_has_char,
1673   .encode_char = macfont_encode_char,
1674   .text_extents = macfont_text_extents,
1675   .draw = macfont_draw,
1676   .shape = macfont_shape,
1677   .get_variation_glyphs = macfont_variation_glyphs,
1678   .filter_properties = macfont_filter_properties,
1679   };
1680
1681 static Lisp_Object
1682 macfont_get_cache (struct frame * f)
1683 {
1684   Display_Info *dpyinfo = FRAME_DISPLAY_INFO (f);
1685
1686   return (dpyinfo->name_list_element);
1687 }
1688
1689 static int
1690 macfont_get_charset (Lisp_Object registry)
1691 {
1692   char *str = SSDATA (SYMBOL_NAME (registry));
1693   char *re = alloca (SBYTES (SYMBOL_NAME (registry)) * 2 + 1);
1694   Lisp_Object regexp;
1695   int i, j;
1696
1697   for (i = j = 0; i < SBYTES (SYMBOL_NAME (registry)); i++, j++)
1698     {
1699       if (str[i] == '.')
1700         re[j++] = '\\';
1701       else if (str[i] == '*')
1702         re[j++] = '.';
1703       re[j] = str[i];
1704       if (re[j] == '?')
1705         re[j] = '.';
1706     }
1707   re[j] = '\0';
1708   regexp = make_unibyte_string (re, j);
1709   for (i = 0; cf_charset_table[i].name; i++)
1710     if (fast_c_string_match_ignore_case
1711         (regexp, cf_charset_table[i].name,
1712          strlen (cf_charset_table[i].name)) >= 0)
1713       break;
1714   if (! cf_charset_table[i].name)
1715     return -1;
1716   if (! cf_charset_table[i].cf_charset)
1717     {
1718       int *uniquifier = cf_charset_table[i].uniquifier;
1719       UniChar *unichars = alloca (sizeof (cf_charset_table[i].uniquifier));
1720       CFIndex count = 0;
1721       CFStringRef string;
1722       CFMutableCharacterSetRef charset = CFCharacterSetCreateMutable (NULL);
1723
1724       if (! charset)
1725         return -1;
1726       for (j = 0; uniquifier[j]; j++)
1727         {
1728           count += macfont_store_utf32char_to_unichars (uniquifier[j],
1729                                                         unichars + count);
1730           CFCharacterSetAddCharactersInRange (charset,
1731                                               CFRangeMake (uniquifier[j], 1));
1732         }
1733
1734       string = CFStringCreateWithCharacters (NULL, unichars, count);
1735       if (! string)
1736         {
1737           CFRelease (charset);
1738           return -1;
1739         }
1740       cf_charset_table[i].cf_charset = CFCharacterSetCreateCopy (NULL,
1741                                                                  charset);
1742       CFRelease (charset);
1743       /* CFCharacterSetCreateWithCharactersInString does not handle
1744          surrogate pairs properly as of Mac OS X 10.5.  */
1745       cf_charset_table[i].cf_charset_string = string;
1746     }
1747   return i;
1748 }
1749
1750 struct OpenTypeSpec
1751 {
1752   Lisp_Object script;
1753   unsigned int script_tag, langsys_tag;
1754   int nfeatures[2];
1755   unsigned int *features[2];
1756 };
1757
1758 #define OTF_SYM_TAG(SYM, TAG)                               \
1759   do {                                                      \
1760     unsigned char *p = SDATA (SYMBOL_NAME (SYM));           \
1761     TAG = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];     \
1762   } while (0)
1763
1764 #define OTF_TAG_STR(TAG, P)                     \
1765   do {                                          \
1766     (P)[0] = (char) (TAG >> 24);                \
1767     (P)[1] = (char) ((TAG >> 16) & 0xFF);       \
1768     (P)[2] = (char) ((TAG >> 8) & 0xFF);        \
1769     (P)[3] = (char) (TAG & 0xFF);               \
1770     (P)[4] = '\0';                              \
1771   } while (0)
1772
1773 static struct OpenTypeSpec *
1774 macfont_get_open_type_spec (Lisp_Object otf_spec)
1775 {
1776   struct OpenTypeSpec *spec = xmalloc (sizeof *spec);
1777   Lisp_Object val;
1778   int i, j;
1779   bool negative;
1780
1781   if (! spec)
1782     return NULL;
1783   spec->script = XCAR (otf_spec);
1784   if (! NILP (spec->script))
1785     {
1786       OTF_SYM_TAG (spec->script, spec->script_tag);
1787       val = assq_no_quit (spec->script, Votf_script_alist);
1788       if (CONSP (val) && SYMBOLP (XCDR (val)))
1789         spec->script = XCDR (val);
1790       else
1791         spec->script = Qnil;
1792     }
1793   else
1794     spec->script_tag = 0x44464C54;      /* "DFLT" */
1795   otf_spec = XCDR (otf_spec);
1796   spec->langsys_tag = 0;
1797   if (! NILP (otf_spec))
1798     {
1799       val = XCAR (otf_spec);
1800       if (! NILP (val))
1801         OTF_SYM_TAG (val, spec->langsys_tag);
1802       otf_spec = XCDR (otf_spec);
1803     }
1804   spec->nfeatures[0] = spec->nfeatures[1] = 0;
1805   for (i = 0; i < 2 && ! NILP (otf_spec); i++, otf_spec = XCDR (otf_spec))
1806     {
1807       Lisp_Object len;
1808
1809       val = XCAR (otf_spec);
1810       if (NILP (val))
1811         continue;
1812       len = Flength (val);
1813       spec->features[i] =
1814         (min (PTRDIFF_MAX, SIZE_MAX) / sizeof (int) < XINT (len)
1815          ? 0
1816          : malloc (XINT (len) * sizeof *spec->features[i]));
1817       if (! spec->features[i])
1818         {
1819           if (i > 0 && spec->features[0])
1820             free (spec->features[0]);
1821           free (spec);
1822           return NULL;
1823         }
1824       for (j = 0, negative = 0; CONSP (val); val = XCDR (val))
1825         {
1826           if (NILP (XCAR (val)))
1827             negative = 1;
1828           else
1829             {
1830               unsigned int tag;
1831
1832               OTF_SYM_TAG (XCAR (val), tag);
1833               spec->features[i][j++] = negative ? tag & 0x80000000 : tag;
1834             }
1835         }
1836       spec->nfeatures[i] = j;
1837     }
1838   return spec;
1839 }
1840
1841 static CFMutableDictionaryRef
1842 macfont_create_attributes_with_spec (Lisp_Object spec)
1843 {
1844   Lisp_Object tmp, extra;
1845   CFMutableArrayRef langarray = NULL;
1846   CFCharacterSetRef charset = NULL;
1847   CFStringRef charset_string = NULL;
1848   CFMutableDictionaryRef attributes = NULL, traits = NULL;
1849   Lisp_Object script = Qnil;
1850   Lisp_Object registry;
1851   int cf_charset_idx, i;
1852   struct OpenTypeSpec *otspec = NULL;
1853   struct {
1854     enum font_property_index index;
1855     CFStringRef trait;
1856     CGPoint points[6];
1857   } numeric_traits[] =
1858       {{FONT_WEIGHT_INDEX, kCTFontWeightTrait,
1859         {{-0.4, 50},            /* light */
1860          {-0.24, 87.5},         /* (semi-light + normal) / 2 */
1861          {0, 100},              /* normal */
1862          {0.24, 140},           /* (semi-bold + normal) / 2 */
1863          {0.4, 200},            /* bold */
1864          {CGFLOAT_MAX, CGFLOAT_MAX}}},
1865        {FONT_SLANT_INDEX, kCTFontSlantTrait,
1866         {{0, 100}, {0.1, 200}, {CGFLOAT_MAX, CGFLOAT_MAX}}},
1867        {FONT_WIDTH_INDEX, kCTFontWidthTrait,
1868         {{0, 100}, {1, 200}, {CGFLOAT_MAX, CGFLOAT_MAX}}}};
1869
1870   registry = AREF (spec, FONT_REGISTRY_INDEX);
1871   if (NILP (registry)
1872       || EQ (registry, Qascii_0)
1873       || EQ (registry, Qiso10646_1)
1874       || EQ (registry, Qunicode_bmp))
1875     cf_charset_idx = -1;
1876   else
1877     {
1878       CFStringRef lang;
1879
1880       cf_charset_idx = macfont_get_charset (registry);
1881       if (cf_charset_idx < 0)
1882         goto err;
1883       charset = cf_charset_table[cf_charset_idx].cf_charset;
1884       charset_string = cf_charset_table[cf_charset_idx].cf_charset_string;
1885       lang = cf_charset_table[cf_charset_idx].lang;
1886       if (lang)
1887         {
1888           langarray = CFArrayCreateMutable (NULL, 0, &kCFTypeArrayCallBacks);
1889           if (! langarray)
1890             goto err;
1891           CFArrayAppendValue (langarray, lang);
1892         }
1893     }
1894
1895   for (extra = AREF (spec, FONT_EXTRA_INDEX);
1896        CONSP (extra); extra = XCDR (extra))
1897     {
1898       Lisp_Object key, val;
1899
1900       tmp = XCAR (extra);
1901       key = XCAR (tmp), val = XCDR (tmp);
1902       if (EQ (key, QClang))
1903         {
1904           if (! langarray)
1905             langarray = CFArrayCreateMutable (NULL, 0, &kCFTypeArrayCallBacks);
1906           if (! langarray)
1907             goto err;
1908           if (SYMBOLP (val))
1909             val = list1 (val);
1910           for (; CONSP (val); val = XCDR (val))
1911             if (SYMBOLP (XCAR (val)))
1912               {
1913                 CFStringRef lang =
1914                   cfstring_create_with_string_noencode (SYMBOL_NAME
1915                                                         (XCAR (val)));
1916
1917                 if (lang == NULL)
1918                   goto err;
1919                 CFArrayAppendValue (langarray, lang);
1920                 CFRelease (lang);
1921               }
1922         }
1923       else if (EQ (key, QCotf))
1924         {
1925           otspec = macfont_get_open_type_spec (val);
1926           if (! otspec)
1927             goto err;
1928           script = otspec->script;
1929         }
1930       else if (EQ (key, QCscript))
1931         script = val;
1932     }
1933
1934   if (! NILP (script) && ! charset)
1935     {
1936       Lisp_Object chars = assq_no_quit (script, Vscript_representative_chars);
1937
1938       if (CONSP (chars) && CONSP (CDR (chars)))
1939         {
1940           CFMutableStringRef string = CFStringCreateMutable (NULL, 0);
1941           CFMutableCharacterSetRef cs = CFCharacterSetCreateMutable (NULL);
1942
1943           if (! string || !cs)
1944             {
1945               if (string)
1946                 CFRelease (string);
1947               else if (cs)
1948                 CFRelease (cs);
1949               goto err;
1950             }
1951           for (chars = XCDR (chars); CONSP (chars); chars = XCDR (chars))
1952             if (CHARACTERP (XCAR (chars)))
1953               {
1954                 UniChar unichars[2];
1955                 CFIndex count =
1956                   macfont_store_utf32char_to_unichars (XFASTINT (XCAR (chars)),
1957                                                        unichars);
1958                 CFRange range = CFRangeMake (XFASTINT (XCAR (chars)), 1);
1959
1960                 CFStringAppendCharacters (string, unichars, count);
1961                 CFCharacterSetAddCharactersInRange (cs, range);
1962               }
1963           charset = cs;
1964           /* CFCharacterSetCreateWithCharactersInString does not
1965              handle surrogate pairs properly as of Mac OS X 10.5.  */
1966           charset_string = string;
1967         }
1968     }
1969
1970   attributes = CFDictionaryCreateMutable (NULL, 0,
1971                                           &kCFTypeDictionaryKeyCallBacks,
1972                                           &kCFTypeDictionaryValueCallBacks);
1973   if (! attributes)
1974     goto err;
1975
1976   tmp = AREF (spec, FONT_FAMILY_INDEX);
1977   if (SYMBOLP (tmp) && ! NILP (tmp))
1978     {
1979       CFStringRef family = macfont_create_family_with_symbol (tmp);
1980
1981       if (! family)
1982         goto err;
1983       CFDictionaryAddValue (attributes, kCTFontFamilyNameAttribute,
1984                             family);
1985       CFRelease (family);
1986     }
1987
1988   traits = CFDictionaryCreateMutable (NULL, 4,
1989                                       &kCFTypeDictionaryKeyCallBacks,
1990                                       &kCFTypeDictionaryValueCallBacks);
1991   if (! traits)
1992     goto err;
1993
1994   for (i = 0; i < ARRAYELTS (numeric_traits); i++)
1995     {
1996       tmp = AREF (spec, numeric_traits[i].index);
1997       if (INTEGERP (tmp))
1998         {
1999           CGPoint *point = numeric_traits[i].points;
2000           CGFloat floatval = (XINT (tmp) >> 8); // XXX
2001           CFNumberRef num;
2002
2003           while (point->y < floatval)
2004             point++;
2005           if (point == numeric_traits[i].points)
2006             point++;
2007           else if (point->y == CGFLOAT_MAX)
2008             point--;
2009           floatval = (point - 1)->x + ((floatval - (point - 1)->y)
2010                                        * ((point->x - (point - 1)->x)
2011                                           / (point->y - (point - 1)->y)));
2012           if (floatval > 1.0)
2013             floatval = 1.0;
2014           else if (floatval < -1.0)
2015             floatval = -1.0;
2016           num = CFNumberCreate (NULL, kCFNumberCGFloatType, &floatval);
2017           if (! num)
2018             goto err;
2019           CFDictionaryAddValue (traits, numeric_traits[i].trait, num);
2020           CFRelease (num);
2021         }
2022     }
2023   if (CFDictionaryGetCount (traits))
2024     CFDictionaryAddValue (attributes, kCTFontTraitsAttribute, traits);
2025
2026   if (charset)
2027     CFDictionaryAddValue (attributes, kCTFontCharacterSetAttribute,
2028                           charset);
2029   if (charset_string)
2030     CFDictionaryAddValue (attributes, MAC_FONT_CHARACTER_SET_STRING_ATTRIBUTE,
2031                           charset_string);
2032   if (langarray)
2033     CFDictionaryAddValue (attributes, kCTFontLanguagesAttribute, langarray);
2034
2035   goto finish;
2036
2037  err:
2038   if (attributes)
2039     {
2040       CFRelease (attributes);
2041       attributes = NULL;
2042     }
2043
2044  finish:
2045   if (langarray) CFRelease (langarray);
2046   if (charset && cf_charset_idx < 0) CFRelease (charset);
2047   if (charset_string && cf_charset_idx < 0) CFRelease (charset_string);
2048   if (traits) CFRelease (traits);
2049   if (otspec)
2050     {
2051       if (otspec->nfeatures[0] > 0)
2052         free (otspec->features[0]);
2053       if (otspec->nfeatures[1] > 0)
2054         free (otspec->features[1]);
2055       free (otspec);
2056     }
2057
2058   return attributes;
2059 }
2060
2061 static Boolean
2062 macfont_supports_charset_and_languages_p (CTFontDescriptorRef desc,
2063                                           CFCharacterSetRef charset,
2064                                           Lisp_Object chars,
2065                                           CFArrayRef languages)
2066 {
2067   Boolean result = true;
2068
2069   if (charset || VECTORP (chars))
2070     {
2071       CFCharacterSetRef desc_charset =
2072         CTFontDescriptorCopyAttribute (desc, kCTFontCharacterSetAttribute);
2073
2074       if (desc_charset == NULL)
2075         result = false;
2076       else
2077         {
2078           if (charset)
2079             result = CFCharacterSetIsSupersetOfSet (desc_charset, charset);
2080           else                  /* VECTORP (chars) */
2081             {
2082               ptrdiff_t j;
2083
2084               for (j = 0; j < ASIZE (chars); j++)
2085                 if (TYPE_RANGED_INTEGERP (UTF32Char, AREF (chars, j))
2086                     && CFCharacterSetIsLongCharacterMember (desc_charset,
2087                                                             XFASTINT (AREF (chars, j))))
2088                   break;
2089               if (j == ASIZE (chars))
2090                 result = false;
2091             }
2092           CFRelease (desc_charset);
2093         }
2094     }
2095   if (result && languages)
2096     result = mac_font_descriptor_supports_languages (desc, languages);
2097
2098   return result;
2099 }
2100
2101 static int
2102 macfont_traits_distance (CTFontSymbolicTraits sym_traits1,
2103                          CTFontSymbolicTraits sym_traits2)
2104 {
2105   CTFontSymbolicTraits diff = (sym_traits1 ^ sym_traits2);
2106   int distance = 0;
2107
2108   /* We prefer synthetic bold of italic to synthetic italic of bold
2109      when both bold and italic are available but bold-italic is not
2110      available.  */
2111   if (diff & kCTFontTraitBold)
2112     distance |= (1 << 0);
2113   if (diff & kCTFontTraitItalic)
2114     distance |= (1 << 1);
2115   if (diff & kCTFontTraitMonoSpace)
2116     distance |= (1 << 2);
2117
2118   return distance;
2119 }
2120
2121 static Boolean
2122 macfont_closest_traits_index_p (CFArrayRef traits_array,
2123                                 CTFontSymbolicTraits target,
2124                                 CFIndex index)
2125 {
2126   CFIndex i, count = CFArrayGetCount (traits_array);
2127   CTFontSymbolicTraits traits;
2128   int my_distance;
2129
2130   traits = ((CTFontSymbolicTraits) (uintptr_t)
2131             CFArrayGetValueAtIndex (traits_array, index));
2132   my_distance = macfont_traits_distance (target, traits);
2133
2134   for (i = 0; i < count; i++)
2135     if (i != index)
2136       {
2137         traits = ((CTFontSymbolicTraits) (uintptr_t)
2138                   CFArrayGetValueAtIndex (traits_array, i));
2139         if (macfont_traits_distance (target, traits) < my_distance)
2140           return false;
2141       }
2142
2143   return true;
2144 }
2145
2146 static Lisp_Object
2147 macfont_list (struct frame *f, Lisp_Object spec)
2148 {
2149   Lisp_Object val = Qnil, family, extra;
2150   int i, n;
2151   CFStringRef family_name = NULL;
2152   CFMutableDictionaryRef attributes = NULL, traits;
2153   Lisp_Object chars = Qnil;
2154   int spacing = -1;
2155   CTFontSymbolicTraits synth_sym_traits = 0;
2156   CFArrayRef families;
2157   CFIndex families_count;
2158   CFCharacterSetRef charset = NULL;
2159   CFArrayRef languages = NULL;
2160
2161   block_input ();
2162
2163   family = AREF (spec, FONT_FAMILY_INDEX);
2164   if (! NILP (family))
2165     {
2166       family_name = macfont_create_family_with_symbol (family);
2167       if (family_name == NULL)
2168         goto finish;
2169     }
2170
2171   attributes = macfont_create_attributes_with_spec (spec);
2172   if (! attributes)
2173     goto finish;
2174
2175   languages = CFDictionaryGetValue (attributes, kCTFontLanguagesAttribute);
2176
2177   if (INTEGERP (AREF (spec, FONT_SPACING_INDEX)))
2178     spacing = XINT (AREF (spec, FONT_SPACING_INDEX));
2179
2180   traits = ((CFMutableDictionaryRef)
2181             CFDictionaryGetValue (attributes, kCTFontTraitsAttribute));
2182
2183   n = FONT_SLANT_NUMERIC (spec);
2184   if (n < 0 || n == FONT_SLANT_SYNTHETIC_ITALIC)
2185     {
2186       synth_sym_traits |= kCTFontTraitItalic;
2187       if (traits)
2188         CFDictionaryRemoveValue (traits, kCTFontSlantTrait);
2189     }
2190
2191   n = FONT_WEIGHT_NUMERIC (spec);
2192   if (n < 0 || n == FONT_WEIGHT_SYNTHETIC_BOLD)
2193     {
2194       synth_sym_traits |= kCTFontTraitBold;
2195       if (traits)
2196         CFDictionaryRemoveValue (traits, kCTFontWeightTrait);
2197     }
2198
2199   if (languages
2200       && (spacing < 0 || spacing == FONT_SPACING_SYNTHETIC_MONO))
2201     {
2202       CFStringRef language = CFArrayGetValueAtIndex (languages, 0);
2203
2204       if (CFStringHasPrefix (language, CFSTR ("ja"))
2205           || CFStringHasPrefix (language, CFSTR ("ko"))
2206           || CFStringHasPrefix (language, CFSTR ("zh")))
2207         synth_sym_traits |= kCTFontTraitMonoSpace;
2208     }
2209
2210   /* Create array of families.  */
2211   if (family_name)
2212     families = CFArrayCreate (NULL, (const void **) &family_name,
2213                               1, &kCFTypeArrayCallBacks);
2214   else
2215     {
2216       CFStringRef pref_family;
2217       CFIndex families_count, pref_family_index = -1;
2218
2219       families = macfont_copy_available_families_cache ();
2220       if (families == NULL)
2221         goto err;
2222
2223       families_count = CFArrayGetCount (families);
2224
2225       /* Move preferred family to the front if exists.  */
2226       pref_family =
2227         mac_font_create_preferred_family_for_attributes (attributes);
2228       if (pref_family)
2229         {
2230           pref_family_index =
2231             CFArrayGetFirstIndexOfValue (families,
2232                                          CFRangeMake (0, families_count),
2233                                          pref_family);
2234           CFRelease (pref_family);
2235         }
2236       if (pref_family_index > 0)
2237         {
2238           CFMutableArrayRef mutable_families =
2239             CFArrayCreateMutable (NULL, families_count, &kCFTypeArrayCallBacks);
2240
2241           if (mutable_families)
2242             {
2243               CFArrayAppendValue (mutable_families,
2244                                   CFArrayGetValueAtIndex (families,
2245                                                           pref_family_index));
2246               CFArrayAppendArray (mutable_families, families,
2247                                   CFRangeMake (0, pref_family_index));
2248               if (pref_family_index + 1 < families_count)
2249                 CFArrayAppendArray (mutable_families, families,
2250                                     CFRangeMake (pref_family_index + 1,
2251                                                  families_count
2252                                                  - (pref_family_index + 1)));
2253               CFRelease (families);
2254               families = mutable_families;
2255             }
2256         }
2257     }
2258
2259   charset = CFDictionaryGetValue (attributes, kCTFontCharacterSetAttribute);
2260   if (charset)
2261     {
2262       CFRetain (charset);
2263       CFDictionaryRemoveValue (attributes, kCTFontCharacterSetAttribute);
2264     }
2265   else
2266     {
2267       val = assq_no_quit (QCscript, AREF (spec, FONT_EXTRA_INDEX));
2268       if (! NILP (val))
2269         {
2270           val = assq_no_quit (XCDR (val), Vscript_representative_chars);
2271           if (CONSP (val) && VECTORP (XCDR (val)))
2272             chars = XCDR (val);
2273         }
2274       val = Qnil;
2275     }
2276
2277   if (languages)
2278     {
2279       CFRetain (languages);
2280       CFDictionaryRemoveValue (attributes, kCTFontLanguagesAttribute);
2281     }
2282
2283   val = Qnil;
2284   extra = AREF (spec, FONT_EXTRA_INDEX);
2285   families_count = CFArrayGetCount (families);
2286   for (i = 0; i < families_count; i++)
2287     {
2288       CFStringRef family_name = CFArrayGetValueAtIndex (families, i);
2289       CTFontDescriptorRef pat_desc;
2290       CFArrayRef descs;
2291       CFIndex descs_count;
2292       CFMutableArrayRef filtered_descs, traits_array;
2293       Lisp_Object entity;
2294       int j;
2295
2296       CFDictionarySetValue (attributes, kCTFontFamilyNameAttribute,
2297                             family_name);
2298       pat_desc = CTFontDescriptorCreateWithAttributes (attributes);
2299       if (! pat_desc)
2300         goto err;
2301
2302       /* CTFontDescriptorCreateMatchingFontDescriptors on Mac OS X
2303          10.7 returns NULL if pat_desc represents the LastResort font.
2304          So we use CTFontDescriptorCreateMatchingFontDescriptor (no
2305          trailing "s") for such a font.  */
2306       if (!CFEqual (family_name, CFSTR ("LastResort")))
2307         descs = CTFontDescriptorCreateMatchingFontDescriptors (pat_desc, NULL);
2308       else
2309         {
2310           CTFontDescriptorRef lr_desc =
2311             CTFontDescriptorCreateMatchingFontDescriptor (pat_desc, NULL);
2312           if (lr_desc)
2313             {
2314               descs = CFArrayCreate (NULL, (const void **) &lr_desc, 1,
2315                                      &kCFTypeArrayCallBacks);
2316               CFRelease (lr_desc);
2317             }
2318           else
2319             descs = NULL;
2320         }
2321       CFRelease (pat_desc);
2322       if (! descs)
2323         continue;
2324
2325       descs_count = CFArrayGetCount (descs);
2326       if (descs_count == 0
2327           || !macfont_supports_charset_and_languages_p (CFArrayGetValueAtIndex (descs, 0),
2328                                                         charset, chars,
2329                                                         languages))
2330         {
2331           CFRelease (descs);
2332           continue;
2333         }
2334
2335       filtered_descs =
2336         CFArrayCreateMutable (NULL, descs_count, &kCFTypeArrayCallBacks);
2337       traits_array = CFArrayCreateMutable (NULL, descs_count, NULL);
2338       for (j = 0; j < descs_count; j++)
2339         {
2340           CTFontDescriptorRef desc = CFArrayGetValueAtIndex (descs, j);
2341           CFDictionaryRef dict;
2342           CFNumberRef num;
2343           CTFontSymbolicTraits sym_traits;
2344
2345           dict = CTFontDescriptorCopyAttribute (desc, kCTFontTraitsAttribute);
2346           if (dict == NULL)
2347             continue;
2348
2349           num = CFDictionaryGetValue (dict, kCTFontSymbolicTrait);
2350           CFRelease (dict);
2351           if (num == NULL
2352               || !cfnumber_get_font_symbolic_traits_value (num, &sym_traits))
2353             continue;
2354
2355           if (spacing >= 0
2356               && !(synth_sym_traits & kCTFontTraitMonoSpace)
2357               && (((sym_traits & kCTFontTraitMonoSpace) != 0)
2358                   != (spacing >= FONT_SPACING_MONO)))
2359             continue;
2360
2361           /* Don't use a color bitmap font until it is supported on
2362              free platforms.  */
2363           if (sym_traits & kCTFontTraitColorGlyphs)
2364             continue;
2365
2366           if (j > 0
2367               && !macfont_supports_charset_and_languages_p (desc, charset,
2368                                                             chars, languages))
2369             continue;
2370
2371           CFArrayAppendValue (filtered_descs, desc);
2372           CFArrayAppendValue (traits_array,
2373                               (const void *) (uintptr_t) sym_traits);
2374         }
2375
2376       CFRelease (descs);
2377       descs = filtered_descs;
2378       descs_count = CFArrayGetCount (descs);
2379
2380       for (j = 0; j < descs_count; j++)
2381         {
2382           CTFontDescriptorRef desc = CFArrayGetValueAtIndex (descs, j);
2383           CTFontSymbolicTraits sym_traits =
2384             ((CTFontSymbolicTraits) (uintptr_t)
2385              CFArrayGetValueAtIndex (traits_array, j));
2386           CTFontSymbolicTraits mask_min, mask_max, imask, bmask, mmask;
2387
2388           mask_min = ((synth_sym_traits ^ sym_traits)
2389                       & (kCTFontTraitItalic | kCTFontTraitBold));
2390           if (FONT_SLANT_NUMERIC (spec) < 0)
2391             mask_min &= ~kCTFontTraitItalic;
2392           if (FONT_WEIGHT_NUMERIC (spec) < 0)
2393             mask_min &= ~kCTFontTraitBold;
2394
2395           mask_max = (synth_sym_traits & ~sym_traits);
2396           /* Synthetic bold does not work for bitmap-only fonts on Mac
2397              OS X 10.6.  */
2398           if ((mask_min ^ mask_max) & kCTFontTraitBold)
2399             {
2400               CFNumberRef format =
2401                 CTFontDescriptorCopyAttribute (desc, kCTFontFormatAttribute);
2402
2403               if (format)
2404                 {
2405                   uint32_t format_val;
2406
2407                   if (CFNumberGetValue (format, kCFNumberSInt32Type,
2408                                         &format_val)
2409                       && format_val == kCTFontFormatBitmap)
2410                     mask_max &= ~kCTFontTraitBold;
2411                 }
2412             }
2413           if (spacing >= 0)
2414             mask_min |= (mask_max & kCTFontTraitMonoSpace);
2415
2416           for (mmask = (mask_min & kCTFontTraitMonoSpace);
2417                mmask <= (mask_max & kCTFontTraitMonoSpace);
2418                mmask += kCTFontTraitMonoSpace)
2419             for (bmask = (mask_min & kCTFontTraitBold);
2420                  bmask <= (mask_max & kCTFontTraitBold);
2421                  bmask += kCTFontTraitBold)
2422               for (imask = (mask_min & kCTFontTraitItalic);
2423                    imask <= (mask_max & kCTFontTraitItalic);
2424                    imask += kCTFontTraitItalic)
2425                 {
2426                   CTFontSymbolicTraits synth = (imask | bmask | mmask);
2427
2428                   if (synth == 0
2429                       || macfont_closest_traits_index_p (traits_array,
2430                                                          (sym_traits | synth),
2431                                                          j))
2432                     {
2433                       entity = macfont_descriptor_entity (desc, extra, synth);
2434                       if (! NILP (entity))
2435                         val = Fcons (entity, val);
2436                     }
2437                 }
2438         }
2439
2440       CFRelease (traits_array);
2441       CFRelease (descs);
2442     }
2443
2444   CFRelease (families);
2445   val = Fnreverse (val);
2446   goto finish;
2447  err:
2448   val = Qnil;
2449
2450  finish:
2451   FONT_ADD_LOG ("macfont-list", spec, val);
2452   if (charset) CFRelease (charset);
2453   if (languages) CFRelease (languages);
2454   if (attributes) CFRelease (attributes);
2455   if (family_name) CFRelease (family_name);
2456
2457   unblock_input ();
2458
2459   return val;
2460 }
2461
2462 static Lisp_Object
2463 macfont_match (struct frame * frame, Lisp_Object spec)
2464 {
2465   Lisp_Object entity = Qnil;
2466   CFMutableDictionaryRef attributes;
2467   CTFontDescriptorRef pat_desc = NULL, desc = NULL;
2468
2469   block_input ();
2470
2471   attributes = macfont_create_attributes_with_spec (spec);
2472   if (attributes)
2473     {
2474       pat_desc = CTFontDescriptorCreateWithAttributes (attributes);
2475       CFRelease (attributes);
2476     }
2477   if (pat_desc)
2478     {
2479       desc = CTFontDescriptorCreateMatchingFontDescriptor (pat_desc, NULL);
2480       CFRelease (pat_desc);
2481     }
2482   if (desc)
2483     {
2484       entity = macfont_descriptor_entity (desc, AREF (spec, FONT_EXTRA_INDEX),
2485                                           0);
2486       CFRelease (desc);
2487     }
2488   unblock_input ();
2489
2490   FONT_ADD_LOG ("macfont-match", spec, entity);
2491   return entity;
2492 }
2493
2494 static Lisp_Object
2495 macfont_list_family (struct frame *frame)
2496 {
2497   Lisp_Object list = Qnil;
2498   CFArrayRef families;
2499
2500   block_input ();
2501
2502   families = macfont_copy_available_families_cache ();
2503   if (families)
2504     {
2505       CFIndex i, count = CFArrayGetCount (families);
2506
2507       for (i = 0; i < count; i++)
2508         list = Fcons (macfont_intern_prop_cfstring (CFArrayGetValueAtIndex (families, i)), list);
2509       CFRelease (families);
2510     }
2511
2512   unblock_input ();
2513
2514   return list;
2515 }
2516
2517 static void
2518 macfont_free_entity (Lisp_Object entity)
2519 {
2520   Lisp_Object val = assq_no_quit (QCfont_entity,
2521                                   AREF (entity, FONT_EXTRA_INDEX));
2522   CFStringRef name = XSAVE_POINTER (XCDR (val), 0);
2523
2524   block_input ();
2525   CFRelease (name);
2526   unblock_input ();
2527 }
2528
2529 static Lisp_Object
2530 macfont_open (struct frame * f, Lisp_Object entity, int pixel_size)
2531 {
2532   Lisp_Object val, font_object;
2533   CFStringRef font_name;
2534   struct macfont_info *macfont_info = NULL;
2535   struct font *font;
2536   int size;
2537   CTFontRef macfont;
2538   CTFontSymbolicTraits sym_traits;
2539   int i, total_width;
2540   CGGlyph glyph;
2541   CGFloat ascent, descent, leading;
2542
2543   val = assq_no_quit (QCfont_entity, AREF (entity, FONT_EXTRA_INDEX));
2544   if (! CONSP (val)
2545       || XTYPE (XCDR (val)) != Lisp_Misc
2546       || XMISCTYPE (XCDR (val)) != Lisp_Misc_Save_Value)
2547     return Qnil;
2548   font_name = XSAVE_POINTER (XCDR (val), 0);
2549   sym_traits = XSAVE_INTEGER (XCDR (val), 1);
2550
2551   size = XINT (AREF (entity, FONT_SIZE_INDEX));
2552   if (size == 0)
2553     size = pixel_size;
2554
2555   block_input ();
2556   macfont = CTFontCreateWithName (font_name, size, NULL);
2557   if (macfont)
2558     {
2559       int fontsize = (int) [((NSFont *) macfont) pointSize];
2560       if (fontsize != size) size = fontsize;
2561     }
2562   unblock_input ();
2563   if (! macfont)
2564     return Qnil;
2565
2566   font_object = font_build_object (VECSIZE (struct macfont_info),
2567                                    Qmac_ct, entity, size);
2568   font = XFONT_OBJECT (font_object);
2569   font->pixel_size = size;
2570   font->driver = &macfont_driver;
2571   font->encoding_charset = font->repertory_charset = -1;
2572
2573   block_input ();
2574
2575   macfont_info = (struct macfont_info *) font;
2576   macfont_info->macfont = macfont;
2577   macfont_info->cgfont = CTFontCopyGraphicsFont (macfont, NULL);
2578
2579   val = assq_no_quit (QCdestination, AREF (entity, FONT_EXTRA_INDEX));
2580   if (CONSP (val) && EQ (XCDR (val), make_number (1)))
2581     macfont_info->screen_font = mac_screen_font_create_with_name (font_name,
2582                                                                   size);
2583   else
2584     macfont_info->screen_font = NULL;
2585   macfont_info->cache = macfont_lookup_cache (font_name);
2586   macfont_retain_cache (macfont_info->cache);
2587   macfont_info->metrics = NULL;
2588   macfont_info->metrics_nrows = 0;
2589   macfont_info->synthetic_italic_p = 0;
2590   macfont_info->synthetic_bold_p = 0;
2591   macfont_info->spacing = MACFONT_SPACING_PROPORTIONAL;
2592   macfont_info->antialias = MACFONT_ANTIALIAS_DEFAULT;
2593   if (!(sym_traits & kCTFontTraitItalic)
2594       && FONT_SLANT_NUMERIC (entity) == FONT_SLANT_SYNTHETIC_ITALIC)
2595     macfont_info->synthetic_italic_p = 1;
2596   if (!(sym_traits & kCTFontTraitBold)
2597       && FONT_WEIGHT_NUMERIC (entity) == FONT_WEIGHT_SYNTHETIC_BOLD)
2598     macfont_info->synthetic_bold_p = 1;
2599   if (sym_traits & kCTFontTraitMonoSpace)
2600     macfont_info->spacing = MACFONT_SPACING_MONO;
2601   else if (INTEGERP (AREF (entity, FONT_SPACING_INDEX))
2602            && (XINT (AREF (entity, FONT_SPACING_INDEX))
2603                == FONT_SPACING_SYNTHETIC_MONO))
2604     macfont_info->spacing = MACFONT_SPACING_SYNTHETIC_MONO;
2605   if (macfont_info->synthetic_italic_p || macfont_info->synthetic_bold_p)
2606     macfont_info->antialias = MACFONT_ANTIALIAS_ON;
2607   else
2608     {
2609       val = assq_no_quit (QCantialias, AREF (entity, FONT_EXTRA_INDEX));
2610       if (CONSP (val))
2611         macfont_info->antialias =
2612           NILP (XCDR (val)) ? MACFONT_ANTIALIAS_OFF : MACFONT_ANTIALIAS_ON;
2613     }
2614   macfont_info->color_bitmap_p = 0;
2615   if (sym_traits & kCTFontTraitColorGlyphs)
2616     macfont_info->color_bitmap_p = 1;
2617
2618   glyph = macfont_get_glyph_for_character (font, ' ');
2619   if (glyph != kCGFontIndexInvalid)
2620     font->space_width = macfont_glyph_extents (font, glyph, NULL, NULL, 0);
2621   else
2622     /* dirty workaround */
2623     font->space_width = pixel_size;
2624
2625   total_width = font->space_width;
2626   for (i = 1; i < 95; i++)
2627     {
2628       glyph = macfont_get_glyph_for_character (font, ' ' + i);
2629       if (glyph == kCGFontIndexInvalid)
2630         break;
2631       total_width += macfont_glyph_extents (font, glyph, NULL, NULL, 0);
2632     }
2633   if (i == 95)
2634     font->average_width = total_width / 95;
2635   else
2636     font->average_width = font->space_width; /* XXX */
2637
2638   if (!(macfont_info->screen_font
2639         && mac_screen_font_get_metrics (macfont_info->screen_font,
2640                                         &ascent, &descent, &leading)))
2641     {
2642       CFStringRef family_name;
2643
2644       ascent = CTFontGetAscent (macfont);
2645       descent = CTFontGetDescent (macfont);
2646       leading = CTFontGetLeading (macfont);
2647       /* AppKit and WebKit do some adjustment to the heights of
2648          Courier, Helvetica, and Times.  */
2649       family_name = CTFontCopyFamilyName (macfont);
2650       if (family_name)
2651         {
2652           if (CFEqual (family_name, CFSTR ("Courier"))
2653               || CFEqual (family_name, CFSTR ("Helvetica"))
2654               || CFEqual (family_name, CFSTR ("Times")))
2655             ascent += (ascent + descent) * .15f;
2656           else if (CFStringHasPrefix (family_name, CFSTR ("Hiragino")))
2657             {
2658               leading *= .25f;
2659               ascent += leading;
2660             }
2661           CFRelease (family_name);
2662         }
2663     }
2664   font->ascent = ascent + 0.5f;
2665   val = assq_no_quit (QCminspace, AREF (entity, FONT_EXTRA_INDEX));
2666   if (CONSP (val) && !NILP (XCDR (val)))
2667     font->descent = descent + 0.5f;
2668   else
2669     font->descent = descent + leading + 0.5f;
2670   font->height = font->ascent + font->descent;
2671
2672   font->underline_position = - CTFontGetUnderlinePosition (macfont) + 0.5f;
2673   font->underline_thickness = CTFontGetUnderlineThickness (macfont) + 0.5f;
2674
2675   unblock_input ();
2676
2677   /* Unfortunately Xft doesn't provide a way to get minimum char
2678      width.  So, we use space_width instead.  */
2679   font->min_width = font->max_width = font->space_width; /* XXX */
2680
2681   font->baseline_offset = 0;
2682   font->relative_compose = 0;
2683   font->default_ascent = 0;
2684   font->vertical_centering = 0;
2685
2686   return font_object;
2687 }
2688
2689 static void
2690 macfont_close (struct font *font)
2691 {
2692   struct macfont_info *macfont_info = (struct macfont_info *) font;
2693
2694   if (macfont_info->cache)
2695     {
2696       int i;
2697
2698       block_input ();
2699       CFRelease (macfont_info->macfont);
2700       CGFontRelease (macfont_info->cgfont);
2701       if (macfont_info->screen_font)
2702         CFRelease (macfont_info->screen_font);
2703       macfont_release_cache (macfont_info->cache);
2704       for (i = 0; i < macfont_info->metrics_nrows; i++)
2705         if (macfont_info->metrics[i])
2706           xfree (macfont_info->metrics[i]);
2707       if (macfont_info->metrics)
2708         xfree (macfont_info->metrics);
2709       macfont_info->cache = NULL;
2710       unblock_input ();
2711     }
2712 }
2713
2714 static int
2715 macfont_has_char (Lisp_Object font, int c)
2716 {
2717   int result;
2718   CFCharacterSetRef charset;
2719
2720   block_input ();
2721   if (FONT_ENTITY_P (font))
2722     {
2723       Lisp_Object val;
2724       CFStringRef name;
2725
2726       val = assq_no_quit (QCfont_entity, AREF (font, FONT_EXTRA_INDEX));
2727       val = XCDR (val);
2728       name = XSAVE_POINTER (val, 0);
2729       charset = macfont_get_cf_charset_for_name (name);
2730     }
2731   else
2732     charset = macfont_get_cf_charset (XFONT_OBJECT (font));
2733
2734   result = CFCharacterSetIsLongCharacterMember (charset, c);
2735   unblock_input ();
2736
2737   return result;
2738 }
2739
2740 static unsigned
2741 macfont_encode_char (struct font *font, int c)
2742 {
2743   CGGlyph glyph;
2744
2745   block_input ();
2746   glyph = macfont_get_glyph_for_character (font, c);
2747   unblock_input ();
2748
2749   return glyph != kCGFontIndexInvalid ? glyph : FONT_INVALID_CODE;
2750 }
2751
2752 static void
2753 macfont_text_extents (struct font *font, unsigned int *code, int nglyphs,
2754                       struct font_metrics *metrics)
2755 {
2756   int width, i;
2757
2758   block_input ();
2759   width = macfont_glyph_extents (font, code[0], metrics, NULL, 0);
2760   for (i = 1; i < nglyphs; i++)
2761     {
2762       struct font_metrics m;
2763       int w = macfont_glyph_extents (font, code[i], metrics ? &m : NULL,
2764                                      NULL, 0);
2765
2766       if (metrics)
2767         {
2768           if (width + m.lbearing < metrics->lbearing)
2769             metrics->lbearing = width + m.lbearing;
2770           if (width + m.rbearing > metrics->rbearing)
2771             metrics->rbearing = width + m.rbearing;
2772           if (m.ascent > metrics->ascent)
2773             metrics->ascent = m.ascent;
2774           if (m.descent > metrics->descent)
2775             metrics->descent = m.descent;
2776         }
2777       width += w;
2778     }
2779   unblock_input ();
2780
2781   if (metrics)
2782     metrics->width = width;
2783 }
2784
2785 static int
2786 macfont_draw (struct glyph_string *s, int from, int to, int x, int y,
2787               bool with_background)
2788 {
2789   struct frame * f = s->f;
2790   struct macfont_info *macfont_info = (struct macfont_info *) s->font;
2791   CGRect background_rect;
2792   CGPoint text_position;
2793   CGGlyph *glyphs;
2794   CGPoint *positions;
2795   CGFloat font_size = CTFontGetSize (macfont_info->macfont);
2796   bool no_antialias_p =
2797     (NILP (ns_antialias_text)
2798      || macfont_info->antialias == MACFONT_ANTIALIAS_OFF
2799      || (macfont_info->antialias == MACFONT_ANTIALIAS_DEFAULT
2800          && font_size <= macfont_antialias_threshold));
2801   int len = to - from;
2802   struct face *face = s->face;
2803   CGContextRef context;
2804
2805   block_input ();
2806
2807   if (with_background)
2808     background_rect = CGRectMake (x, y - FONT_BASE (s->font),
2809                                   s->width, FONT_HEIGHT (s->font));
2810   else
2811     background_rect = CGRectNull;
2812
2813   text_position = CGPointMake (x, -y);
2814   glyphs = xmalloc (sizeof (CGGlyph) * len);
2815   {
2816     CGFloat advance_delta = 0;
2817     int i;
2818     CGFloat total_width = 0;
2819
2820     positions = xmalloc (sizeof (CGPoint) * len);
2821     for (i = 0; i < len; i++)
2822       {
2823         int width;
2824
2825         glyphs[i] = s->char2b[from + i];
2826         width = (s->padding_p ? 1
2827                  : macfont_glyph_extents (s->font, glyphs[i],
2828                                           NULL, &advance_delta,
2829                                           no_antialias_p));
2830         positions[i].x = total_width + advance_delta;
2831         positions[i].y = 0;
2832         total_width += width;
2833       }
2834   }
2835
2836   context = [[NSGraphicsContext currentContext] graphicsPort];
2837   CGContextSaveGState (context);
2838
2839   if (!CGRectIsNull (background_rect))
2840     {
2841       if (s->hl == DRAW_MOUSE_FACE)
2842         {
2843           face = FACE_FROM_ID_OR_NULL (s->f,
2844                                        MOUSE_HL_INFO (s->f)->mouse_face_face_id);
2845           if (!face)
2846             face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
2847         }
2848       CG_SET_FILL_COLOR_WITH_FACE_BACKGROUND (context, face, f);
2849       CGContextFillRects (context, &background_rect, 1);
2850     }
2851
2852   if (macfont_info->cgfont)
2853     {
2854       CGAffineTransform atfm;
2855
2856       CGContextScaleCTM (context, 1, -1);
2857       CG_SET_FILL_COLOR_WITH_FACE_FOREGROUND (context, face, s->f);
2858       if (macfont_info->synthetic_italic_p)
2859         atfm = synthetic_italic_atfm;
2860       else
2861         atfm = CGAffineTransformIdentity;
2862       if (macfont_info->synthetic_bold_p && ! no_antialias_p)
2863         {
2864           CGContextSetTextDrawingMode (context, kCGTextFillStroke);
2865
2866           /* Stroke line width for text drawing is not correctly
2867              scaled on Retina display/HiDPI mode when drawn to screen
2868              (whereas it is correctly scaled when drawn to bitmaps),
2869              and synthetic bold looks thinner on such environments.
2870              Apple says there are no plans to address this issue
2871              (rdar://11644870) currently.  So we add a workaround.  */
2872 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_7
2873           CGContextSetLineWidth (context, synthetic_bold_factor * font_size
2874                                  * [[FRAME_NS_VIEW(f) window] backingScaleFactor]);
2875 #else
2876           CGContextSetLineWidth (context, synthetic_bold_factor * font_size);
2877 #endif
2878           CG_SET_STROKE_COLOR_WITH_FACE_FOREGROUND (context, face, f);
2879         }
2880       if (no_antialias_p)
2881         CGContextSetShouldAntialias (context, false);
2882
2883       CGContextSetTextMatrix (context, atfm);
2884       CGContextSetTextPosition (context, text_position.x, text_position.y);
2885
2886 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
2887       if (macfont_info->color_bitmap_p
2888 #if MAC_OS_X_VERSION_MIN_REQUIRED < 1070
2889           && CTFontDrawGlyphs != NULL
2890 #endif
2891           )
2892         {
2893           if (len > 0)
2894             {
2895               CTFontDrawGlyphs (macfont_info->macfont, glyphs, positions, len,
2896                                 context);
2897             }
2898         }
2899       else
2900 #endif  /* MAC_OS_X_VERSION_MAX_ALLOWED >= 1070 */
2901         {
2902           CGContextSetFont (context, macfont_info->cgfont);
2903           CGContextSetFontSize (context, font_size);
2904           CGContextShowGlyphsAtPositions (context, glyphs, positions, len);
2905         }
2906     }
2907
2908
2909   xfree (glyphs);
2910   xfree (positions);
2911   CGContextRestoreGState (context);
2912
2913   unblock_input ();
2914
2915   return len;
2916 }
2917
2918 static Lisp_Object
2919 macfont_shape (Lisp_Object lgstring)
2920 {
2921   struct font *font = CHECK_FONT_GET_OBJECT (LGSTRING_FONT (lgstring));
2922   struct macfont_info *macfont_info = (struct macfont_info *) font;
2923   CTFontRef macfont = macfont_info->macfont;
2924   ptrdiff_t glyph_len, len, i, j;
2925   CFIndex nonbmp_len;
2926   UniChar *unichars;
2927   CFIndex *nonbmp_indices;
2928   CFStringRef string;
2929   CFIndex used = 0;
2930   struct mac_glyph_layout *glyph_layouts;
2931
2932   glyph_len = LGSTRING_GLYPH_LEN (lgstring);
2933   nonbmp_len = 0;
2934   for (i = 0; i < glyph_len; i++)
2935     {
2936       Lisp_Object lglyph = LGSTRING_GLYPH (lgstring, i);
2937
2938       if (NILP (lglyph))
2939         break;
2940       if (LGLYPH_CHAR (lglyph) >= 0x10000)
2941         nonbmp_len++;
2942     }
2943
2944   len = i;
2945
2946   if (INT_MAX / 2 < len)
2947     memory_full (SIZE_MAX);
2948
2949   unichars = alloca (sizeof (UniChar) * (len + nonbmp_len));
2950   nonbmp_indices = alloca (sizeof (CFIndex) * (nonbmp_len + 1));
2951   for (i = j = 0; i < len; i++)
2952     {
2953       UTF32Char c = LGLYPH_CHAR (LGSTRING_GLYPH (lgstring, i));
2954
2955       if (macfont_store_utf32char_to_unichars (c, unichars + i + j) > 1)
2956         {
2957           nonbmp_indices[j] = i + j;
2958           j++;
2959         }
2960     }
2961   nonbmp_indices[j] = len + j;  /* sentinel */
2962
2963   block_input ();
2964
2965   string = CFStringCreateWithCharactersNoCopy (NULL, unichars, len + nonbmp_len,
2966                                                kCFAllocatorNull);
2967   if (string)
2968     {
2969       glyph_layouts = alloca (sizeof (struct mac_glyph_layout) * glyph_len);
2970       if (macfont_info->screen_font)
2971         used = mac_screen_font_shape (macfont_info->screen_font, string,
2972                                       glyph_layouts, glyph_len);
2973       else
2974         used = mac_font_shape (macfont, string, glyph_layouts, glyph_len);
2975       CFRelease (string);
2976     }
2977
2978   unblock_input ();
2979
2980   if (used == 0)
2981     return Qnil;
2982
2983   block_input ();
2984
2985   for (i = 0; i < used; i++)
2986     {
2987       Lisp_Object lglyph = LGSTRING_GLYPH (lgstring, i);
2988       struct mac_glyph_layout *gl = glyph_layouts + i;
2989       EMACS_INT from, to;
2990       struct font_metrics metrics;
2991       int xoff, yoff, wadjust;
2992
2993       if (NILP (lglyph))
2994         {
2995           lglyph = Fmake_vector (make_number (LGLYPH_SIZE), Qnil);
2996           LGSTRING_SET_GLYPH (lgstring, i, lglyph);
2997         }
2998
2999       from = gl->comp_range.location;
3000       /* Convert UTF-16 index to UTF-32.  */
3001       j = 0;
3002       while (nonbmp_indices[j] < from)
3003         j++;
3004       from -= j;
3005       LGLYPH_SET_FROM (lglyph, from);
3006
3007       to = gl->comp_range.location + gl->comp_range.length;
3008       /* Convert UTF-16 index to UTF-32.  */
3009       while (nonbmp_indices[j] < to)
3010         j++;
3011       to -= j;
3012       LGLYPH_SET_TO (lglyph, to - 1);
3013
3014       /* LGLYPH_CHAR is used in `describe-char' for checking whether
3015          the composition is trivial.  */
3016       {
3017         UTF32Char c;
3018
3019         if (unichars[gl->string_index] >= 0xD800
3020             && unichars[gl->string_index] < 0xDC00)
3021           c = (((unichars[gl->string_index] - 0xD800) << 10)
3022                + (unichars[gl->string_index + 1] - 0xDC00) + 0x10000);
3023         else
3024           c = unichars[gl->string_index];
3025         if (macfont_get_glyph_for_character (font, c) != gl->glyph_id)
3026           c = 0;
3027         LGLYPH_SET_CHAR (lglyph, c);
3028       }
3029
3030       {
3031         unsigned long cc = gl->glyph_id;
3032         LGLYPH_SET_CODE (lglyph, cc);
3033       }
3034
3035       macfont_glyph_extents (font, gl->glyph_id, &metrics, NULL, 0);
3036       LGLYPH_SET_WIDTH (lglyph, metrics.width);
3037       LGLYPH_SET_LBEARING (lglyph, metrics.lbearing);
3038       LGLYPH_SET_RBEARING (lglyph, metrics.rbearing);
3039       LGLYPH_SET_ASCENT (lglyph, metrics.ascent);
3040       LGLYPH_SET_DESCENT (lglyph, metrics.descent);
3041
3042       xoff = lround (gl->advance_delta);
3043       yoff = lround (- gl->baseline_delta);
3044       wadjust = lround (gl->advance);
3045       if (xoff != 0 || yoff != 0 || wadjust != metrics.width)
3046         {
3047           Lisp_Object vec;
3048
3049           vec = Fmake_vector (make_number (3), Qnil);
3050           ASET (vec, 0, make_number (xoff));
3051           ASET (vec, 1, make_number (yoff));
3052           ASET (vec, 2, make_number (wadjust));
3053           LGLYPH_SET_ADJUSTMENT (lglyph, vec);
3054         }
3055     }
3056
3057   unblock_input ();
3058
3059   return make_number (used);
3060 }
3061
3062 /* Structures for the UVS subtable (format 14) in the cmap table.  */
3063 typedef UInt8 UINT24[3];
3064
3065 #pragma pack(push, 1)
3066 struct variation_selector_record
3067 {
3068   UINT24 var_selector;
3069   UInt32 default_uvs_offset, non_default_uvs_offset;
3070 };
3071 struct uvs_table
3072 {
3073   UInt16 format;
3074   UInt32 length, num_var_selector_records;
3075   struct variation_selector_record variation_selector_records[1];
3076 };
3077 #define SIZEOF_UVS_TABLE_HEADER                                         \
3078   (sizeof (struct uvs_table) - sizeof (struct variation_selector_record))
3079
3080 struct unicode_value_range
3081 {
3082   UINT24 start_unicode_value;
3083   UInt8 additional_count;
3084 };
3085 struct default_uvs_table {
3086   UInt32 num_unicode_value_ranges;
3087   struct unicode_value_range unicode_value_ranges[1];
3088 };
3089 #define SIZEOF_DEFAULT_UVS_TABLE_HEADER                                 \
3090   (sizeof (struct default_uvs_table) - sizeof (struct unicode_value_range))
3091
3092 struct uvs_mapping
3093 {
3094   UINT24 unicode_value;
3095   UInt16 glyph_id;
3096 };
3097 struct non_default_uvs_table
3098 {
3099   UInt32 num_uvs_mappings;
3100   struct uvs_mapping uvs_mappings[1];
3101 };
3102 #define SIZEOF_NON_DEFAULT_UVS_TABLE_HEADER                             \
3103   (sizeof (struct non_default_uvs_table) - sizeof (struct uvs_mapping))
3104 #pragma pack(pop)
3105
3106 /* Read big endian values.  The argument LVAL must be an lvalue.  */
3107 /* I suppose OSReadBigInt* takes care of unaligned data.  At least, we
3108    can find "... = OSReadBigInt32(cdb, 2);" followed by "... =
3109    OSReadBigInt16(cdb, 7);" in a sample code by Apple.  */
3110 #define BUINT8_VALUE(lval)      (*((UInt8 *) &(lval)))
3111 #define BUINT16_VALUE(lval)     OSReadBigInt16 (&(lval), 0)
3112 /* Succeeding one byte should also be accessible.  */
3113 #define BUINT24_VALUE(lval)     (OSReadBigInt32 (&(lval), 0) >> 8)
3114 #define BUINT32_VALUE(lval)     OSReadBigInt32 (&(lval), 0)
3115
3116 /* Return UVS subtable for the specified FONT.  If the subtable is not
3117    found or ill-formatted, then return NULL.  */
3118
3119 static CFDataRef
3120 mac_font_copy_uvs_table (CTFontRef font)
3121 {
3122   CFDataRef cmap_table, uvs_table = NULL;
3123
3124   cmap_table = CTFontCopyTable (font, cmapFontTableTag,
3125                                 kCTFontTableOptionNoOptions);
3126   if (cmap_table)
3127     {
3128       sfntCMapHeader *cmap = (sfntCMapHeader *) CFDataGetBytePtr (cmap_table);
3129       struct uvs_table *uvs;
3130       struct variation_selector_record *records;
3131       UInt32 cmap_len, ntables, i, uvs_offset, uvs_len, nrecords;
3132
3133 #if __LP64__
3134       if (CFDataGetLength (cmap_table) > UINT32_MAX)
3135         goto finish;
3136 #endif
3137
3138       cmap_len = CFDataGetLength (cmap_table);
3139       if (sizeof_sfntCMapHeader > cmap_len)
3140         goto finish;
3141
3142       ntables = BUINT16_VALUE (cmap->numTables);
3143       if (ntables > ((cmap_len - sizeof_sfntCMapHeader)
3144                      / sizeof_sfntCMapEncoding))
3145         goto finish;
3146
3147       for (i = 0; i < ntables; i++)
3148         if ((BUINT16_VALUE (cmap->encoding[i].platformID)
3149              == kFontUnicodePlatform)
3150             && (BUINT16_VALUE (cmap->encoding[i].scriptID)
3151                 == 5)) /* kFontUnicodeV4_0VariationSequenceSemantics */
3152           {
3153             uvs_offset = BUINT32_VALUE (cmap->encoding[i].offset);
3154             break;
3155           }
3156       if (i == ntables
3157           || uvs_offset > cmap_len
3158           || SIZEOF_UVS_TABLE_HEADER > cmap_len - uvs_offset)
3159         goto finish;
3160
3161       uvs = (struct uvs_table *) ((UInt8 *) cmap + uvs_offset);
3162       uvs_len = BUINT32_VALUE (uvs->length);
3163       if (uvs_len > cmap_len - uvs_offset
3164           || SIZEOF_UVS_TABLE_HEADER > uvs_len)
3165         goto finish;
3166
3167       if (BUINT16_VALUE (uvs->format) != 14)
3168         goto finish;
3169
3170       nrecords = BUINT32_VALUE (uvs->num_var_selector_records);
3171       if (nrecords > ((uvs_len - SIZEOF_UVS_TABLE_HEADER)
3172                       / sizeof (struct variation_selector_record)))
3173         goto finish;
3174
3175       records = uvs->variation_selector_records;
3176       for (i = 0; i < nrecords; i++)
3177         {
3178           UInt32 default_uvs_offset, non_default_uvs_offset;
3179
3180           default_uvs_offset = BUINT32_VALUE (records[i].default_uvs_offset);
3181           if (default_uvs_offset)
3182             {
3183               struct default_uvs_table *default_uvs;
3184               UInt32 nranges;
3185
3186               if (default_uvs_offset > uvs_len
3187                   || (SIZEOF_DEFAULT_UVS_TABLE_HEADER
3188                       > uvs_len - default_uvs_offset))
3189                 goto finish;
3190
3191               default_uvs = ((struct default_uvs_table *)
3192                              ((UInt8 *) uvs + default_uvs_offset));
3193               nranges = BUINT32_VALUE (default_uvs->num_unicode_value_ranges);
3194               if (nranges > ((uvs_len - default_uvs_offset
3195                               - SIZEOF_DEFAULT_UVS_TABLE_HEADER)
3196                              / sizeof (struct unicode_value_range)))
3197                 goto finish;
3198               /* Now 2 * nranges can't overflow, so we can safely use
3199                  `(lo + hi) / 2' instead of `lo + (hi - lo) / 2' in
3200                  mac_font_get_glyphs_for_variants.  */
3201             }
3202
3203           non_default_uvs_offset =
3204             BUINT32_VALUE (records[i].non_default_uvs_offset);
3205           if (non_default_uvs_offset)
3206             {
3207               struct non_default_uvs_table *non_default_uvs;
3208               UInt32 nmappings;
3209
3210               if (non_default_uvs_offset > uvs_len
3211                   || (SIZEOF_NON_DEFAULT_UVS_TABLE_HEADER
3212                       > uvs_len - non_default_uvs_offset))
3213                 goto finish;
3214
3215               non_default_uvs = ((struct non_default_uvs_table *)
3216                                  ((UInt8 *) uvs + non_default_uvs_offset));
3217               nmappings = BUINT32_VALUE (non_default_uvs->num_uvs_mappings);
3218               if (nmappings > ((uvs_len - non_default_uvs_offset
3219                                 - SIZEOF_NON_DEFAULT_UVS_TABLE_HEADER)
3220                                / sizeof (struct uvs_mapping)))
3221                 goto finish;
3222               /* Now 2 * nmappings can't overflow, so we can safely
3223                  use `(lo + hi) / 2' instead of `lo + (hi - lo) / 2'
3224                  in mac_font_get_glyphs_for_variants.  */
3225             }
3226         }
3227
3228       uvs_table = CFDataCreate (NULL, (UInt8 *) uvs, uvs_len);
3229
3230     finish:
3231       CFRelease (cmap_table);
3232     }
3233
3234   return uvs_table;
3235 }
3236
3237 /* Find an entry in the given UVS subtable UVS_TABLE for a variation
3238    sequence consisting of the given base character C and each
3239    variation selector SELECTORS[i] for 0 <= i < COUNT, and store the
3240    result (explained below) into the corresponding GLYPHS[i].  If the
3241    entry is found in the Default UVS Table, then the result is 0.  If
3242    the entry is found in the Non-Default UVS Table, then the result is
3243    the associated glyph ID.  Otherwise, kCGFontIndexInvalid.  The
3244    elements in SELECTORS must be sorted in strictly increasing
3245    order.  */
3246
3247 static void
3248 mac_font_get_glyphs_for_variants (CFDataRef uvs_table, UTF32Char c,
3249                                   const UTF32Char selectors[], CGGlyph glyphs[],
3250                                   CFIndex count)
3251 {
3252   struct uvs_table *uvs = (struct uvs_table *) CFDataGetBytePtr (uvs_table);
3253   struct variation_selector_record *records = uvs->variation_selector_records;
3254   CFIndex i;
3255   UInt32 ir, nrecords;
3256   dispatch_queue_t queue =
3257     dispatch_get_global_queue (DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
3258   dispatch_group_t group = dispatch_group_create ();
3259
3260   nrecords = BUINT32_VALUE (uvs->num_var_selector_records);
3261   i = 0;
3262   ir = 0;
3263   while (i < count && ir < nrecords)
3264     {
3265       UInt32 default_uvs_offset, non_default_uvs_offset;
3266
3267       if (selectors[i] < BUINT24_VALUE (records[ir].var_selector))
3268         {
3269           glyphs[i++] = kCGFontIndexInvalid;
3270           continue;
3271         }
3272       else if (selectors[i] > BUINT24_VALUE (records[ir].var_selector))
3273         {
3274           ir++;
3275           continue;
3276         }
3277
3278       /* selectors[i] == BUINT24_VALUE (records[ir].var_selector) */
3279       default_uvs_offset = BUINT32_VALUE (records[ir].default_uvs_offset);
3280       non_default_uvs_offset =
3281         BUINT32_VALUE (records[ir].non_default_uvs_offset);
3282       dispatch_group_async (group, queue, ^{
3283           glyphs[i] = kCGFontIndexInvalid;
3284
3285           if (default_uvs_offset)
3286             {
3287               struct default_uvs_table *default_uvs =
3288                 (struct default_uvs_table *) ((UInt8 *) uvs
3289                                               + default_uvs_offset);
3290               struct unicode_value_range *ranges =
3291                 default_uvs->unicode_value_ranges;
3292               UInt32 lo, hi;
3293
3294               lo = 0;
3295               hi = BUINT32_VALUE (default_uvs->num_unicode_value_ranges);
3296               while (lo < hi)
3297                 {
3298                   UInt32 mid = (lo + hi) / 2;
3299
3300                   if (c < BUINT24_VALUE (ranges[mid].start_unicode_value))
3301                     hi = mid;
3302                   else
3303                     lo = mid + 1;
3304                 }
3305               if (hi > 0
3306                   && (c <= (BUINT24_VALUE (ranges[hi - 1].start_unicode_value)
3307                             + BUINT8_VALUE (ranges[hi - 1].additional_count))))
3308                 glyphs[i] = 0;
3309             }
3310
3311           if (glyphs[i] == kCGFontIndexInvalid && non_default_uvs_offset)
3312             {
3313               struct non_default_uvs_table *non_default_uvs =
3314                 (struct non_default_uvs_table *) ((UInt8 *) uvs
3315                                                   + non_default_uvs_offset);
3316               struct uvs_mapping *mappings = non_default_uvs->uvs_mappings;
3317               UInt32 lo, hi;
3318
3319               lo = 0;
3320               hi = BUINT32_VALUE (non_default_uvs->num_uvs_mappings);
3321               while (lo < hi)
3322                 {
3323                   UInt32 mid = (lo + hi) / 2;
3324
3325                   if (c < BUINT24_VALUE (mappings[mid].unicode_value))
3326                     hi = mid;
3327                   else
3328                     lo = mid + 1;
3329                 }
3330               if (hi > 0 &&
3331                   BUINT24_VALUE (mappings[hi - 1].unicode_value) == c)
3332                 glyphs[i] = BUINT16_VALUE (mappings[hi - 1].glyph_id);
3333             }
3334         });
3335       i++;
3336       ir++;
3337     }
3338   while (i < count)
3339     glyphs[i++] = kCGFontIndexInvalid;
3340   dispatch_group_wait (group, DISPATCH_TIME_FOREVER);
3341   dispatch_release (group);
3342 }
3343
3344 static int
3345 macfont_variation_glyphs (struct font *font, int c, unsigned variations[256])
3346 {
3347   CFDataRef uvs_table;
3348   NSCharacterCollection uvs_collection;
3349   int i, n = 0;
3350
3351   block_input ();
3352   uvs_table = macfont_get_uvs_table (font, &uvs_collection);
3353
3354   if (uvs_table)
3355     {
3356       UTF32Char selectors[256];
3357       CGGlyph glyphs[256];
3358
3359       for (i = 0; i < 16; i++)
3360         selectors[i] = 0xFE00 + i;
3361       for (; i < 256; i++)
3362         selectors[i] = 0xE0100 + (i - 16);
3363       mac_font_get_glyphs_for_variants (uvs_table, c, selectors, glyphs, 256);
3364       for (i = 0; i < 256; i++)
3365         {
3366           CGGlyph glyph = glyphs[i];
3367
3368           if (uvs_collection != NSIdentityMappingCharacterCollection
3369               && glyph != kCGFontIndexInvalid)
3370             glyph = macfont_get_glyph_for_cid (font, uvs_collection, glyph);
3371           if (glyph == kCGFontIndexInvalid)
3372             variations[i] = 0;
3373           else
3374             {
3375               variations[i] = (glyph ? glyph
3376                                : macfont_get_glyph_for_character (font, c));
3377               n++;
3378             }
3379         }
3380     }
3381   unblock_input ();
3382
3383   return n;
3384 }
3385
3386 static const char *const macfont_booleans[] = {
3387   ":antialias",
3388   ":minspace",
3389   NULL,
3390 };
3391
3392 static const char *const macfont_non_booleans[] = {
3393   ":lang",
3394   ":script",
3395   ":destination",
3396   NULL,
3397 };
3398
3399 static void
3400 macfont_filter_properties (Lisp_Object font, Lisp_Object alist)
3401 {
3402   font_filter_properties (font, alist, macfont_booleans, macfont_non_booleans);
3403 }
3404
3405 static Boolean
3406 mac_font_descriptor_supports_languages (CTFontDescriptorRef descriptor,
3407                                         CFArrayRef languages)
3408 {
3409   Boolean result = true;
3410   CFArrayRef desc_languages =
3411     CTFontDescriptorCopyAttribute (descriptor, kCTFontLanguagesAttribute);
3412
3413   if (desc_languages == NULL)
3414     result = false;
3415   else
3416     {
3417       CFRange range = CFRangeMake (0, CFArrayGetCount (desc_languages));
3418       CFIndex i, languages_count = CFArrayGetCount (languages);
3419
3420       for (i = 0; i < languages_count; i++)
3421         {
3422           CFStringRef language = CFArrayGetValueAtIndex (languages, i);
3423
3424           if (!CFArrayContainsValue (desc_languages, range, language)
3425               /* PingFang SC contains "zh" and "zh-Hant" as covered
3426                  languages, but does not contain "zh-Hans".  */
3427               && !(CFEqual (language, CFSTR ("zh-Hans"))
3428                    && CFArrayContainsValue (desc_languages, range,
3429                                             CFSTR ("zh"))))
3430             {
3431               result = false;
3432               break;
3433             }
3434         }
3435       CFRelease (desc_languages);
3436     }
3437
3438   return result;
3439 }
3440
3441 static CFStringRef
3442 mac_font_create_preferred_family_for_attributes (CFDictionaryRef attributes)
3443 {
3444   CFStringRef result = NULL;
3445   CFStringRef charset_string =
3446     CFDictionaryGetValue (attributes, MAC_FONT_CHARACTER_SET_STRING_ATTRIBUTE);
3447
3448   if (charset_string && CFStringGetLength (charset_string) > 0)
3449     {
3450       CFStringRef keys[] = {
3451 #if MAC_OS_X_VERSION_MIN_REQUIRED >= 1090
3452         kCTLanguageAttributeName
3453 #else
3454         CFSTR ("NSLanguage")
3455 #endif
3456       };
3457       CFTypeRef values[] = {NULL};
3458       CFIndex num_values = 0;
3459       CFArrayRef languages
3460         = CFDictionaryGetValue (attributes, kCTFontLanguagesAttribute);
3461
3462       if (languages && CFArrayGetCount (languages) > 0)
3463         {
3464           if (CTGetCoreTextVersion () >= kCTVersionNumber10_9)
3465             values[num_values++] = CFArrayGetValueAtIndex (languages, 0);
3466           else
3467             {
3468               CFCharacterSetRef charset =
3469                 CFDictionaryGetValue (attributes, kCTFontCharacterSetAttribute);
3470
3471               result = mac_font_copy_default_name_for_charset_and_languages (charset, languages);
3472             }
3473         }
3474       if (result == NULL)
3475         {
3476           CFAttributedStringRef attr_string = NULL;
3477           CTLineRef ctline = NULL;
3478           CFDictionaryRef attrs
3479             = CFDictionaryCreate (NULL, (const void **) keys,
3480                                   (const void **) values, num_values,
3481                                   &kCFTypeDictionaryKeyCallBacks,
3482                                   &kCFTypeDictionaryValueCallBacks);
3483
3484           if (attrs)
3485             {
3486               attr_string = CFAttributedStringCreate (NULL, charset_string,
3487                                                       attrs);
3488               CFRelease (attrs);
3489             }
3490           if (attr_string)
3491             {
3492               ctline = CTLineCreateWithAttributedString (attr_string);
3493               CFRelease (attr_string);
3494             }
3495           if (ctline)
3496             {
3497               CFArrayRef runs = CTLineGetGlyphRuns (ctline);
3498               CFIndex i, nruns = CFArrayGetCount (runs);
3499               CTFontRef font;
3500
3501               for (i = 0; i < nruns; i++)
3502                 {
3503                   CTRunRef run = CFArrayGetValueAtIndex (runs, i);
3504                   CFDictionaryRef attributes = CTRunGetAttributes (run);
3505                   CTFontRef font_in_run;
3506
3507                   if (attributes == NULL)
3508                     break;
3509                   font_in_run =
3510                     CFDictionaryGetValue (attributes, kCTFontAttributeName);
3511                   if (font_in_run == NULL)
3512                     break;
3513                   if (i == 0)
3514                     font = font_in_run;
3515                   else if (!mac_font_equal_in_postscript_name (font,
3516                                                                font_in_run))
3517                     break;
3518                 }
3519               if (nruns > 0 && i == nruns)
3520                 result = CTFontCopyAttribute (font, kCTFontFamilyNameAttribute);
3521               CFRelease (ctline);
3522             }
3523         }
3524     }
3525
3526   return result;
3527 }
3528
3529 static inline double
3530 mac_font_get_advance_width_for_glyph (CTFontRef font, CGGlyph glyph)
3531 {
3532   return CTFontGetAdvancesForGlyphs (font, kCTFontOrientationDefault,
3533                                      &glyph, NULL, 1);
3534 }
3535
3536 static inline CGRect
3537 mac_font_get_bounding_rect_for_glyph (CTFontRef font, CGGlyph glyph)
3538 {
3539   return CTFontGetBoundingRectsForGlyphs (font, kCTFontOrientationDefault,
3540                                           &glyph, NULL, 1);
3541 }
3542
3543 static CFArrayRef
3544 mac_font_create_available_families (void)
3545 {
3546   CFMutableArrayRef families = NULL;
3547   CFArrayRef orig_families = CTFontManagerCopyAvailableFontFamilyNames ();
3548
3549   if (orig_families)
3550     {
3551       CFIndex i, count = CFArrayGetCount (orig_families);
3552
3553       families = CFArrayCreateMutable (NULL, count, &kCFTypeArrayCallBacks);
3554       if (families)
3555         for (i = 0; i < count; i++)
3556           {
3557             CFStringRef family = CFArrayGetValueAtIndex (orig_families, i);
3558
3559             if (!CFStringHasPrefix (family, CFSTR ("."))
3560                 && (CTFontManagerCompareFontFamilyNames (family,
3561                                                          CFSTR ("LastResort"),
3562                                                          NULL)
3563                     != kCFCompareEqualTo))
3564               CFArrayAppendValue (families, family);
3565           }
3566       CFRelease (orig_families);
3567     }
3568
3569   return families;
3570 }
3571
3572 static Boolean
3573 mac_font_equal_in_postscript_name (CTFontRef font1, CTFontRef font2)
3574 {
3575   Boolean result;
3576   CFStringRef name1, name2;
3577
3578   if (font1 == font2)
3579     return true;
3580
3581   result = false;
3582   name1 = CTFontCopyPostScriptName (font1);
3583   if (name1)
3584     {
3585       name2 = CTFontCopyPostScriptName (font2);
3586       if (name2)
3587         {
3588           result = CFEqual (name1, name2);
3589           CFRelease (name2);
3590         }
3591       CFRelease (name1);
3592     }
3593
3594   return result;
3595 }
3596
3597 static CTLineRef
3598 mac_font_create_line_with_string_and_font (CFStringRef string,
3599                                            CTFontRef macfont)
3600 {
3601   CFStringRef keys[] = {kCTFontAttributeName, kCTKernAttributeName};
3602   CFTypeRef values[] = {NULL, NULL};
3603   CFDictionaryRef attributes = NULL;
3604   CFAttributedStringRef attr_string = NULL;
3605   CTLineRef ctline = NULL;
3606   float float_zero = 0.0f;
3607
3608   values[0] = macfont;
3609   values[1] = CFNumberCreate (NULL, kCFNumberFloatType, &float_zero);
3610   if (values[1])
3611     {
3612       attributes = CFDictionaryCreate (NULL, (const void **) keys,
3613                                        (const void **) values,
3614                                        ARRAYELTS (keys),
3615                                        &kCFTypeDictionaryKeyCallBacks,
3616                                        &kCFTypeDictionaryValueCallBacks);
3617       CFRelease (values[1]);
3618     }
3619   if (attributes)
3620     {
3621       attr_string = CFAttributedStringCreate (NULL, string, attributes);
3622       CFRelease (attributes);
3623     }
3624   if (attr_string)
3625     {
3626       ctline = CTLineCreateWithAttributedString (attr_string);
3627       CFRelease (attr_string);
3628     }
3629   if (ctline)
3630     {
3631       /* Abandon if ctline contains some fonts other than the
3632          specified one.  */
3633       CFArrayRef runs = CTLineGetGlyphRuns (ctline);
3634       CFIndex i, nruns = CFArrayGetCount (runs);
3635
3636       for (i = 0; i < nruns; i++)
3637         {
3638           CTRunRef run = CFArrayGetValueAtIndex (runs, i);
3639           CFDictionaryRef attributes = CTRunGetAttributes (run);
3640           CTFontRef font_in_run;
3641
3642           if (attributes == NULL)
3643             break;
3644           font_in_run =
3645             CFDictionaryGetValue (attributes, kCTFontAttributeName);
3646           if (font_in_run == NULL)
3647             break;
3648           if (!mac_font_equal_in_postscript_name (macfont, font_in_run))
3649             break;
3650         }
3651       if (i < nruns)
3652         {
3653           CFRelease (ctline);
3654           ctline = NULL;
3655         }
3656     }
3657
3658   return ctline;
3659 }
3660
3661 static CFIndex
3662 mac_font_shape (CTFontRef font, CFStringRef string,
3663                 struct mac_glyph_layout *glyph_layouts, CFIndex glyph_len)
3664 {
3665   CFIndex used, result = 0;
3666   CTLineRef ctline = mac_font_create_line_with_string_and_font (string, font);
3667
3668   if (ctline == NULL)
3669     return 0;
3670
3671   used = CTLineGetGlyphCount (ctline);
3672   if (used <= glyph_len)
3673     {
3674       CFArrayRef ctruns = CTLineGetGlyphRuns (ctline);
3675       CFIndex k, ctrun_count = CFArrayGetCount (ctruns);
3676       CGFloat total_advance = 0;
3677       CFIndex total_glyph_count = 0;
3678
3679       for (k = 0; k < ctrun_count; k++)
3680         {
3681           CTRunRef ctrun = CFArrayGetValueAtIndex (ctruns, k);
3682           CFIndex i, min_location, glyph_count = CTRunGetGlyphCount (ctrun);
3683           struct mac_glyph_layout *glbuf = glyph_layouts + total_glyph_count;
3684           CFRange string_range, comp_range, range;
3685           CFIndex *permutation;
3686
3687           if (CTRunGetStatus (ctrun) & kCTRunStatusRightToLeft)
3688             permutation = xmalloc (sizeof (CFIndex) * glyph_count);
3689           else
3690             permutation = NULL;
3691
3692 #define RIGHT_TO_LEFT_P permutation
3693
3694           /* Now the `comp_range' member of struct mac_glyph_layout is
3695              temporarily used as a work area such that:
3696              glbuf[i].comp_range.location =
3697              min {compRange[i + 1].location, ...,
3698                      compRange[glyph_count - 1].location,
3699                      maxRange (stringRangeForCTRun)}
3700              glbuf[i].comp_range.length = maxRange (compRange[i])
3701              where compRange[i] is the range of composed characters
3702              containing i-th glyph.  */
3703           string_range = CTRunGetStringRange (ctrun);
3704           min_location = string_range.location + string_range.length;
3705           for (i = 0; i < glyph_count; i++)
3706             {
3707               struct mac_glyph_layout *gl = glbuf + glyph_count - i - 1;
3708               CFIndex glyph_index;
3709               CFRange rng;
3710
3711               if (!RIGHT_TO_LEFT_P)
3712                 glyph_index = glyph_count - i - 1;
3713               else
3714                 glyph_index = i;
3715               CTRunGetStringIndices (ctrun, CFRangeMake (glyph_index, 1),
3716                                      &gl->string_index);
3717               rng =
3718                 CFStringGetRangeOfComposedCharactersAtIndex (string,
3719                                                              gl->string_index);
3720               gl->comp_range.location = min_location;
3721               gl->comp_range.length = rng.location + rng.length;
3722               if (rng.location < min_location)
3723                 min_location = rng.location;
3724             }
3725
3726           /* Fill the `comp_range' member of struct mac_glyph_layout,
3727              and setup a permutation for right-to-left text.  */
3728           comp_range = CFRangeMake (string_range.location, 0);
3729           range = CFRangeMake (0, 0);
3730           while (1)
3731             {
3732               struct mac_glyph_layout *gl =
3733                 glbuf + range.location + range.length;
3734
3735               if (gl->comp_range.length
3736                   > comp_range.location + comp_range.length)
3737                 comp_range.length = gl->comp_range.length - comp_range.location;
3738               min_location = gl->comp_range.location;
3739               range.length++;
3740
3741               if (min_location >= comp_range.location + comp_range.length)
3742                 {
3743                   comp_range.length = min_location - comp_range.location;
3744                   for (i = 0; i < range.length; i++)
3745                     {
3746                       glbuf[range.location + i].comp_range = comp_range;
3747                       if (RIGHT_TO_LEFT_P)
3748                         permutation[range.location + i] =
3749                           range.location + range.length - i - 1;
3750                     }
3751
3752                   comp_range = CFRangeMake (min_location, 0);
3753                   range.location += range.length;
3754                   range.length = 0;
3755                   if (range.location == glyph_count)
3756                     break;
3757                 }
3758             }
3759
3760           /* Then fill the remaining members.  */
3761           for (range = CFRangeMake (0, 1); range.location < glyph_count;
3762                range.location++)
3763             {
3764               struct mac_glyph_layout *gl;
3765               CGPoint position;
3766               CGFloat max_x;
3767
3768               if (!RIGHT_TO_LEFT_P)
3769                 gl = glbuf + range.location;
3770               else
3771                 {
3772                   CFIndex src, dest;
3773
3774                   src = glyph_count - 1 - range.location;
3775                   dest = permutation[src];
3776                   gl = glbuf + dest;
3777                   if (src < dest)
3778                     {
3779                       CFIndex tmp = gl->string_index;
3780
3781                       gl->string_index = glbuf[src].string_index;
3782                       glbuf[src].string_index = tmp;
3783                     }
3784                 }
3785               CTRunGetGlyphs (ctrun, range, &gl->glyph_id);
3786
3787               CTRunGetPositions (ctrun, range, &position);
3788               max_x = position.x + CTRunGetTypographicBounds (ctrun, range,
3789                                                               NULL, NULL, NULL);
3790               max_x = max (max_x, total_advance);
3791               gl->advance_delta = position.x - total_advance;
3792               gl->baseline_delta = position.y;
3793               gl->advance = max_x - total_advance;
3794               total_advance = max_x;
3795             }
3796
3797           if (RIGHT_TO_LEFT_P)
3798             xfree (permutation);
3799
3800 #undef RIGHT_TO_LEFT_P
3801
3802           total_glyph_count += glyph_count;
3803         }
3804
3805       result = used;
3806     }
3807   CFRelease (ctline);
3808
3809   return result;
3810 }
3811
3812 /* The function below seems to cause a memory leak for the CFString
3813    created by CFStringCreateWithCharacters as of Mac OS X 10.5.8 and
3814    10.6.3.  For now, we use the NSGlyphInfo version instead.  */
3815 #if USE_CT_GLYPH_INFO
3816 static CGGlyph
3817 mac_ctfont_get_glyph_for_cid (CTFontRef font, CTCharacterCollection collection,
3818                               CGFontIndex cid)
3819 {
3820   CGGlyph result = kCGFontIndexInvalid;
3821   UniChar characters[] = {0xfffd};
3822   CFStringRef string;
3823   CFAttributedStringRef attr_string = NULL;
3824   CTLineRef ctline = NULL;
3825
3826   string = CFStringCreateWithCharacters (NULL, characters,
3827                                          ARRAYELTS (characters));
3828
3829   if (string)
3830     {
3831       CTGlyphInfoRef glyph_info =
3832         CTGlyphInfoCreateWithCharacterIdentifier (cid, collection, string);
3833       CFDictionaryRef attributes = NULL;
3834
3835       if (glyph_info)
3836         {
3837           CFStringRef keys[] = {kCTFontAttributeName,
3838                                 kCTGlyphInfoAttributeName};
3839           CFTypeRef values[] = {font, glyph_info};
3840
3841           attributes = CFDictionaryCreate (NULL, (const void **) keys,
3842                                            (const void **) values,
3843                                            ARRAYELTS (keys),
3844                                            &kCFTypeDictionaryKeyCallBacks,
3845                                            &kCFTypeDictionaryValueCallBacks);
3846           CFRelease (glyph_info);
3847         }
3848       if (attributes)
3849         {
3850           attr_string = CFAttributedStringCreate (NULL, string, attributes);
3851           CFRelease (attributes);
3852         }
3853       CFRelease (string);
3854     }
3855   if (attr_string)
3856     {
3857       ctline = CTLineCreateWithAttributedString (attr_string);
3858       CFRelease (attr_string);
3859     }
3860   if (ctline)
3861     {
3862       CFArrayRef runs = CTLineGetGlyphRuns (ctline);
3863
3864       if (CFArrayGetCount (runs) > 0)
3865         {
3866           CTRunRef run = CFArrayGetValueAtIndex (runs, 0);
3867           CFDictionaryRef attributes = CTRunGetAttributes (run);
3868
3869           if (attributes)
3870             {
3871               CTFontRef font_in_run =
3872                 CFDictionaryGetValue (attributes, kCTFontAttributeName);
3873
3874               if (font_in_run
3875                   && mac_font_equal_in_postscript_name (font_in_run, font))
3876                 {
3877                   CTRunGetGlyphs (run, CFRangeMake (0, 1), &result);
3878                   if (result >= CTFontGetGlyphCount (font))
3879                     result = kCGFontIndexInvalid;
3880                 }
3881             }
3882         }
3883       CFRelease (ctline);
3884     }
3885
3886   return result;
3887 }
3888 #endif
3889
3890 static CFArrayRef
3891 mac_font_copy_default_descriptors_for_language (CFStringRef language)
3892 {
3893   CFArrayRef result = NULL;
3894
3895 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1080
3896 #if MAC_OS_X_VERSION_MIN_REQUIRED < 1080
3897   if (CTFontCopyDefaultCascadeListForLanguages != NULL)
3898 #endif
3899     {
3900       CTFontRef user_font =
3901         CTFontCreateUIFontForLanguage (kCTFontUIFontUser, 0, language);
3902
3903       if (user_font)
3904         {
3905           CFArrayRef languages =
3906             CFArrayCreate (NULL, (const void **) &language, 1,
3907                            &kCFTypeArrayCallBacks);
3908
3909           if (languages)
3910             {
3911               result = CTFontCopyDefaultCascadeListForLanguages (user_font,
3912                                                                  languages);
3913               CFRelease (languages);
3914             }
3915           CFRelease (user_font);
3916         }
3917     }
3918 #if MAC_OS_X_VERSION_MIN_REQUIRED < 1080
3919   else          /* CTFontCopyDefaultCascadeListForLanguages == NULL */
3920 #endif
3921 #endif  /* MAC_OS_X_VERSION_MAX_ALLOWED >= 1080 */
3922 #if MAC_OS_X_VERSION_MIN_REQUIRED < 1080
3923     {
3924       CFIndex i;
3925
3926       for (i = 0; macfont_language_default_font_names[i].language; i++)
3927         {
3928           if (CFEqual (macfont_language_default_font_names[i].language,
3929                        language))
3930             {
3931               CFMutableArrayRef descriptors =
3932                 CFArrayCreateMutable (NULL, 0, &kCFTypeArrayCallBacks);
3933
3934               if (descriptors)
3935                 {
3936                   CFIndex j;
3937
3938                   for (j = 0;
3939                        macfont_language_default_font_names[i].font_names[j];
3940                        j++)
3941                     {
3942                       CFDictionaryRef attributes =
3943                         CFDictionaryCreate (NULL,
3944                                             ((const void **)
3945                                              &kCTFontNameAttribute),
3946                                             ((const void **)
3947                                              &macfont_language_default_font_names[i].font_names[j]),
3948                                             1, &kCFTypeDictionaryKeyCallBacks,
3949                                             &kCFTypeDictionaryValueCallBacks);
3950
3951                       if (attributes)
3952                         {
3953                           CTFontDescriptorRef pat_desc =
3954                             CTFontDescriptorCreateWithAttributes (attributes);
3955
3956                           if (pat_desc)
3957                             {
3958                               CTFontDescriptorRef descriptor =
3959                                 CTFontDescriptorCreateMatchingFontDescriptor (pat_desc, NULL);
3960
3961                               if (descriptor)
3962                                 {
3963                                   CFArrayAppendValue (descriptors, descriptor);
3964                                   CFRelease (descriptor);
3965                                 }
3966                               CFRelease (pat_desc);
3967                             }
3968                           CFRelease (attributes);
3969                         }
3970                     }
3971                   result = descriptors;
3972                 }
3973               break;
3974             }
3975         }
3976     }
3977 #endif
3978
3979   return result;
3980 }
3981
3982 static CFStringRef
3983 mac_font_copy_default_name_for_charset_and_languages (CFCharacterSetRef charset,
3984                                                       CFArrayRef languages)
3985 {
3986   CFStringRef result = NULL;
3987   CFStringRef language = CFArrayGetValueAtIndex (languages, 0);
3988   CFArrayRef descriptors =
3989     mac_font_copy_default_descriptors_for_language (language);
3990
3991   if (descriptors)
3992     {
3993       CFIndex i, count = CFArrayGetCount (descriptors);
3994
3995       for (i = 0; i < count; i++)
3996         {
3997           CTFontDescriptorRef descriptor =
3998             CFArrayGetValueAtIndex (descriptors, i);
3999
4000           if (macfont_supports_charset_and_languages_p (descriptor, charset,
4001                                                         Qnil, languages))
4002             {
4003               CFStringRef family =
4004                 CTFontDescriptorCopyAttribute (descriptor,
4005                                                kCTFontFamilyNameAttribute);
4006               if (family)
4007                 {
4008                   if (!CFStringHasPrefix (family, CFSTR ("."))
4009                       && !CFEqual (family, CFSTR ("LastResort")))
4010                     {
4011                       result = family;
4012                       break;
4013                     }
4014                   else
4015                     CFRelease (family);
4016                 }
4017             }
4018         }
4019       CFRelease (descriptors);
4020     }
4021
4022   return result;
4023 }
4024
4025 void *
4026 macfont_get_nsctfont (struct font *font)
4027 {
4028   struct macfont_info *macfont_info = (struct macfont_info *) font;
4029   CTFontRef macfont = macfont_info->macfont;
4030
4031   return (void *) macfont;
4032 }
4033
4034 void
4035 mac_register_font_driver (struct frame *f)
4036 {
4037   register_font_driver (&macfont_driver, f);
4038 }
4039
4040 \f
4041 void
4042 syms_of_macfont (void)
4043 {
4044   /* Core Text, for macOS.  */
4045   DEFSYM (Qmac_ct, "mac-ct");
4046   register_font_driver (&macfont_driver, NULL);
4047
4048   /* The font property key specifying the font design destination.  The
4049      value is an unsigned integer code: 0 for WYSIWYG, and 1 for Video
4050      text.  (See the documentation of X Logical Font Description
4051      Conventions.)  In the Mac font driver, 1 means the screen font is
4052      used for calculating some glyph metrics.  You can see the
4053      difference with Monaco 8pt or 9pt, for example.  */
4054   DEFSYM (QCdestination, ":destination");
4055
4056   /* The boolean-valued font property key specifying the use of leading.  */
4057   DEFSYM (QCminspace, ":minspace");
4058
4059   macfont_family_cache = Qnil;
4060   staticpro (&macfont_family_cache);
4061 }