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