src/macfont.m

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