| blob | 4f29d1d54a9ca2110426b8e55c15c168d0ecf4dc |
1 /* Font back-end driver for the NeXT/Open/GNUstep and MacOSX window system.
2 See font.h
3 Copyright (C) 2006-2012 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
20 Author: Adrian Robert (arobert@cogsci.ucsd.edu)
21 */
23 /* This should be the first include, as it may set up #defines affecting
24 interpretation of even the system includes. */
25 #include <config.h>
27 #include "lisp.h"
28 #include "dispextern.h"
29 #include "composite.h"
30 #include "blockinput.h"
31 #include "charset.h"
32 #include "frame.h"
33 #include "window.h"
34 #include "fontset.h"
35 #include "nsterm.h"
36 #include "frame.h"
37 #include "character.h"
38 #include "font.h"
39 #include "termchar.h"
41 /* TODO: Drop once we can assume gnustep-gui 0.17.1. */
42 #ifdef NS_IMPL_GNUSTEP
43 #import <AppKit/NSFontDescriptor.h>
44 #endif
46 #define NSFONT_TRACE 0
48 extern Lisp_Object Qns;
49 extern Lisp_Object Qnormal, Qbold, Qitalic, Qcondensed, Qexpanded;
50 static Lisp_Object Qapple, Qroman, Qmedium;
51 extern Lisp_Object Qappend;
52 extern float ns_antialias_threshold;
53 extern int ns_tmp_flags;
54 extern struct nsfont_info *ns_tmp_font;
57 /* font glyph and metrics caching functions, implemented at end */
58 static void ns_uni_to_glyphs (struct nsfont_info *font_info,
59 unsigned char block);
60 static void ns_glyph_metrics (struct nsfont_info *font_info,
61 unsigned char block);
64 /* ==========================================================================
66 Utilities
68 ========================================================================== */
71 /* Replace spaces w/another character so emacs core font parsing routines
72 aren't thrown off. */
73 static void
74 ns_escape_name (char *name)
75 {
76 int i =0, len =strlen (name);
77 for ( ; i<len; i++)
78 if (name[i] == ' ')
79 name[i] = '_';
80 }
83 /* Reconstruct spaces in a font family name passed through emacs. */
84 static void
85 ns_unescape_name (char *name)
86 {
87 int i =0, len =strlen (name);
88 for ( ; i<len; i++)
89 if (name[i] == '_')
90 name[i] = ' ';
91 }
94 /* Extract family name from a font spec. */
95 static NSString *
96 ns_get_family (Lisp_Object font_spec)
97 {
98 Lisp_Object tem = AREF (font_spec, FONT_FAMILY_INDEX);
99 if (NILP (tem))
100 return nil;
101 else
102 {
103 char *tmp = xstrdup (SSDATA (SYMBOL_NAME (tem)));
104 NSString *family;
105 ns_unescape_name (tmp);
106 family = [NSString stringWithUTF8String: tmp];
107 xfree (tmp);
108 return family;
109 }
110 }
113 /* Return 0 if attr not set, else value (which might also be 0).
114 On Leopard 0 gets returned even on descriptors where the attribute
115 was never set, so there's no way to distinguish between unspecified
116 and set to not have. Callers should assume 0 means unspecified. */
117 static float
118 ns_attribute_fvalue (NSFontDescriptor *fdesc, NSString *trait)
119 {
120 NSDictionary *tdict = [fdesc objectForKey: NSFontTraitsAttribute];
121 NSNumber *val = [tdict objectForKey: trait];
122 return val == nil ? 0.0 : [val floatValue];
123 }
126 /* Converts FONT_WEIGHT, FONT_SLANT, FONT_WIDTH, plus family and script/lang
127 to NSFont descriptor. Information under extra only needed for matching. */
128 #define STYLE_REF 100
129 static NSFontDescriptor *
130 ns_spec_to_descriptor (Lisp_Object font_spec)
131 {
132 NSFontDescriptor *fdesc;
133 NSMutableDictionary *fdAttrs = [NSMutableDictionary new];
134 NSMutableDictionary *tdict = [NSMutableDictionary new];
135 NSString *family = ns_get_family (font_spec);
136 float n;
138 /* add each attr in font_spec to fdAttrs.. */
139 n = min (FONT_WEIGHT_NUMERIC (font_spec), 200);
140 if (n != -1 && n != STYLE_REF)
141 [tdict setObject: [NSNumber numberWithFloat: (n - 100.0) / 100.0]
142 forKey: NSFontWeightTrait];
143 n = min (FONT_SLANT_NUMERIC (font_spec), 200);
144 if (n != -1 && n != STYLE_REF)
145 [tdict setObject: [NSNumber numberWithFloat: (n - 100.0) / 100.0]
146 forKey: NSFontSlantTrait];
147 n = min (FONT_WIDTH_NUMERIC (font_spec), 200);
148 if (n > -1 && (n > STYLE_REF + 10 || n < STYLE_REF - 10))
149 [tdict setObject: [NSNumber numberWithFloat: (n - 100.0) / 100.0]
150 forKey: NSFontWidthTrait];
151 if ([tdict count] > 0)
152 [fdAttrs setObject: tdict forKey: NSFontTraitsAttribute];
154 fdesc = [NSFontDescriptor fontDescriptorWithFontAttributes: fdAttrs];
155 if (family != nil)
156 {
157 fdesc = [fdesc fontDescriptorWithFamily: family];
158 }
160 [fdAttrs release];
161 [tdict release];
162 return fdesc;
163 }
166 /* Converts NSFont descriptor to FONT_WEIGHT, FONT_SLANT, FONT_WIDTH, etc.. */
167 static Lisp_Object
168 ns_descriptor_to_entity (NSFontDescriptor *desc,
169 Lisp_Object extra,
170 const char *style)
171 {
172 Lisp_Object font_entity = font_make_entity ();
173 /* NSString *psName = [desc postscriptName]; */
174 NSString *family = [desc objectForKey: NSFontFamilyAttribute];
175 unsigned int traits = [desc symbolicTraits];
176 char *escapedFamily;
178 /* Shouldn't happen, but on Tiger fallback desc gets name but no family. */
179 if (family == nil)
180 family = [desc objectForKey: NSFontNameAttribute];
181 if (family == nil)
182 family = [[NSFont userFixedPitchFontOfSize: 0] familyName];
184 escapedFamily = xstrdup ([family UTF8String]);
185 ns_escape_name (escapedFamily);
187 ASET (font_entity, FONT_TYPE_INDEX, Qns);
188 ASET (font_entity, FONT_FOUNDRY_INDEX, Qapple);
189 ASET (font_entity, FONT_FAMILY_INDEX, intern (escapedFamily));
190 ASET (font_entity, FONT_ADSTYLE_INDEX, style ? intern (style) : Qnil);
191 ASET (font_entity, FONT_REGISTRY_INDEX, Qiso10646_1);
193 FONT_SET_STYLE (font_entity, FONT_WEIGHT_INDEX,
194 traits & NSFontBoldTrait ? Qbold : Qmedium);
195 /* FONT_SET_STYLE (font_entity, FONT_WEIGHT_INDEX,
196 make_number (100 + 100
197 * ns_attribute_fvalue (desc, NSFontWeightTrait)));*/
198 FONT_SET_STYLE (font_entity, FONT_SLANT_INDEX,
199 traits & NSFontItalicTrait ? Qitalic : Qnormal);
200 /* FONT_SET_STYLE (font_entity, FONT_SLANT_INDEX,
201 make_number (100 + 100
202 * ns_attribute_fvalue (desc, NSFontSlantTrait)));*/
203 FONT_SET_STYLE (font_entity, FONT_WIDTH_INDEX,
204 traits & NSFontCondensedTrait ? Qcondensed :
205 traits & NSFontExpandedTrait ? Qexpanded : Qnormal);
206 /* FONT_SET_STYLE (font_entity, FONT_WIDTH_INDEX,
207 make_number (100 + 100
208 * ns_attribute_fvalue (desc, NSFontWidthTrait)));*/
210 ASET (font_entity, FONT_SIZE_INDEX, make_number (0));
211 ASET (font_entity, FONT_AVGWIDTH_INDEX, make_number (0));
212 ASET (font_entity, FONT_SPACING_INDEX,
213 make_number([desc symbolicTraits] & NSFontMonoSpaceTrait
214 ? FONT_SPACING_MONO : FONT_SPACING_PROPORTIONAL));
216 ASET (font_entity, FONT_EXTRA_INDEX, extra);
217 ASET (font_entity, FONT_OBJLIST_INDEX, Qnil);
219 if (NSFONT_TRACE)
220 {
221 fprintf (stderr, "created font_entity:\n ");
222 debug_print (font_entity);
223 }
225 xfree (escapedFamily);
226 return font_entity;
227 }
230 /* Default font entity. */
231 static Lisp_Object
232 ns_fallback_entity (void)
233 {
234 return ns_descriptor_to_entity ([[NSFont userFixedPitchFontOfSize: 0]
235 fontDescriptor], Qnil, NULL);
236 }
239 /* Utility: get width of a char c in screen font SFONT */
240 static float
241 ns_char_width (NSFont *sfont, int c)
242 {
243 float w = -1.0;
244 NSString *cstr = [NSString stringWithFormat: @"%c", c];
246 #ifdef NS_IMPL_COCOA
247 NSGlyph glyph = [sfont glyphWithName: cstr];
248 if (glyph)
249 w = [sfont advancementForGlyph: glyph].width;
250 #endif
252 if (w < 0.0)
253 {
254 NSDictionary *attrsDictionary =
255 [NSDictionary dictionaryWithObject: sfont forKey: NSFontAttributeName];
256 w = [cstr sizeWithAttributes: attrsDictionary].width;
257 }
259 return max (w, 1.0);
260 }
262 /* Return average width over ASCII printable characters for SFONT. */
264 static NSString *ascii_printable;
266 static int
267 ns_ascii_average_width (NSFont *sfont)
268 {
269 float w = -1.0;
271 if (!ascii_printable)
272 {
273 char chars[96];
274 int ch;
275 for (ch = 0; ch < 95; ch++)
276 chars[ch] = ' ' + ch;
277 chars[95] = '\0';
279 ascii_printable = [[NSString alloc] initWithFormat: @"%s", chars];
280 }
282 #ifdef NS_IMPL_COCOA
283 NSGlyph glyph = [sfont glyphWithName: ascii_printable];
284 if (glyph)
285 w = [sfont advancementForGlyph: glyph].width;
286 #endif
288 if (w < 0.0)
289 {
290 NSDictionary *attrsDictionary =
291 [NSDictionary dictionaryWithObject: sfont forKey: NSFontAttributeName];
292 w = [ascii_printable sizeWithAttributes: attrsDictionary].width;
293 }
295 return lrint (w / 95.0);
296 }
299 /* Return whether set1 covers set2 to a reasonable extent given by pct.
300 We check, out of each 16 Unicode char range containing chars in set2,
301 whether at least one character is present in set1.
302 This must be true for pct of the pairs to consider it covering. */
303 static BOOL
304 ns_charset_covers(NSCharacterSet *set1, NSCharacterSet *set2, float pct)
305 {
306 const unsigned short *bytes1 = [[set1 bitmapRepresentation] bytes];
307 const unsigned short *bytes2 = [[set2 bitmapRepresentation] bytes];
308 int i, off = 0, tot = 0;
310 /* Work around what appears to be a GNUstep bug.
311 See <http://bugs.gnu.org/11853>. */
312 if (! (bytes1 && bytes2))
313 return NO;
315 for (i=0; i<4096; i++, bytes1++, bytes2++)
316 if (*bytes2)
317 {
318 tot++;
319 if (*bytes1 == 0) // *bytes1 & *bytes2 != *bytes2
320 off++;
321 }
322 //fprintf(stderr, "off = %d\ttot = %d\n", off,tot);
323 return (float)off / tot < 1.0 - pct;
324 }
327 /* Convert :lang property to a script. Use of :lang property by font backend
328 seems to be limited for now (2009/05) to ja, zh, and ko. */
329 static NSString
330 *ns_lang_to_script (Lisp_Object lang)
331 {
332 if (!strcmp (SSDATA (SYMBOL_NAME (lang)), "ja"))
333 return @"han";
334 /* NOTE: ja given for any hanzi that's also a kanji, but Chinese fonts
335 have more characters. */
336 else if (!strcmp (SSDATA (SYMBOL_NAME (lang)), "zh"))
337 return @"han";
338 else if (!strcmp (SSDATA (SYMBOL_NAME (lang)), "ko"))
339 return @"hangul";
340 else
341 return @"";
342 }
345 /* Convert OTF 4-letter script code to emacs script name. (Why can't
346 everyone just use some standard Unicode names for these?) */
347 static NSString
348 *ns_otf_to_script (Lisp_Object otf)
349 {
350 Lisp_Object script = assq_no_quit (XCAR (otf), Votf_script_alist);
351 return CONSP (script)
352 ? [NSString stringWithUTF8String: SSDATA (SYMBOL_NAME (XCDR ((script))))]
353 : @"";
354 }
357 /* Convert a font registry, such as */
358 static NSString
359 *ns_registry_to_script (char *reg)
360 {
361 Lisp_Object script, r, rts = Vns_reg_to_script;
362 while CONSP (rts)
363 {
364 r = XCAR (XCAR (rts));
365 if (!strncmp(SSDATA(r), reg, strlen(SSDATA(r))))
366 {
367 script = XCDR (XCAR (rts));
368 return [NSString stringWithUTF8String: SSDATA (SYMBOL_NAME (script))];
369 }
370 rts = XCDR (rts);
371 }
372 return @"";
373 }
376 /* Searches the :script, :lang, and :otf extra-bundle properties of the spec,
377 plus registry regular property, for something that can be mapped to a
378 Unicode script. Empty string returned if no script spec found. */
379 static NSString
380 *ns_get_req_script (Lisp_Object font_spec)
381 {
382 Lisp_Object reg = AREF (font_spec, FONT_REGISTRY_INDEX);
383 Lisp_Object extra = AREF (font_spec, FONT_EXTRA_INDEX);
385 /* The extra-bundle properties have priority. */
386 for ( ; CONSP (extra); extra = XCDR (extra))
387 {
388 Lisp_Object tmp = XCAR (extra);
389 if (CONSP (tmp))
390 {
391 Lisp_Object key = XCAR (tmp), val = XCDR (tmp);
392 if (EQ (key, QCscript) && SYMBOLP (val))
393 return [NSString stringWithUTF8String:
394 SSDATA (SYMBOL_NAME (val))];
395 if (EQ (key, QClang) && SYMBOLP (val))
396 return ns_lang_to_script (val);
397 if (EQ (key, QCotf) && CONSP (val) && SYMBOLP (XCAR (val)))
398 return ns_otf_to_script (val);
399 }
400 }
402 /* If we get here, check the charset portion of the registry. */
403 if (! NILP (reg))
404 {
405 /* XXX: iso10646 is passed in for non-ascii latin-1 characters
406 (which causes box rendering if we don't treat it like iso8858-1)
407 but also for ascii (which causes unnecessary font substitution). */
408 #if 0
409 if (EQ (reg, Qiso10646_1))
410 reg = Qiso8859_1;
411 #endif
412 return ns_registry_to_script (SSDATA (SYMBOL_NAME (reg)));
413 }
415 return @"";
416 }
419 /* This small function is static in fontset.c. If it can be made public for
420 all ports, remove this, but otherwise it doesn't seem worth the ifdefs. */
421 static void
422 accumulate_script_ranges (Lisp_Object arg, Lisp_Object range, Lisp_Object val)
423 {
424 if (EQ (XCAR (arg), val))
425 {
426 if (CONSP (range))
427 XSETCDR (arg, Fcons (Fcons (XCAR (range), XCDR (range)), XCDR (arg)));
428 else
429 XSETCDR (arg, Fcons (Fcons (range, range), XCDR (arg)));
430 }
431 }
434 /* Use the Unicode range information in Vchar_script_table to convert a script
435 name into an NSCharacterSet. */
436 static NSCharacterSet
437 *ns_script_to_charset (NSString *scriptName)
438 {
439 NSMutableCharacterSet *charset = [NSMutableCharacterSet new];
440 Lisp_Object script = intern ([scriptName UTF8String]);
441 Lisp_Object script_list = XCHAR_TABLE (Vchar_script_table)->extras[0];
443 if (! NILP (Fmemq (script, script_list)))
444 {
445 Lisp_Object ranges, range_list;
447 ranges = Fcons (script, Qnil);
448 map_char_table (accumulate_script_ranges, Qnil, Vchar_script_table,
449 ranges);
450 range_list = Fnreverse (XCDR (ranges));
451 if (! NILP (range_list))
452 {
453 for (; CONSP (range_list); range_list = XCDR (range_list))
454 {
455 int start = XINT (XCAR (XCAR (range_list)));
456 int end = XINT (XCDR (XCAR (range_list)));
457 if (NSFONT_TRACE)
458 debug_print (XCAR (range_list));
459 if (end < 0x10000)
460 [charset addCharactersInRange:
461 NSMakeRange (start, end-start)];
462 }
463 }
464 }
465 return charset;
466 }
469 /* Return an array of font families containing characters for the given
470 script, for the given coverage criterion, including at least LastResort.
471 Results are cached by script for faster access.
472 If none are found, we reduce the percentage and try again, until 5%.
473 This provides a font with at least some characters if such can be found.
474 We don't use isSupersetOfSet: because (a) it doesn't work on Tiger, and
475 (b) need approximate match as fonts covering full Unicode ranges are rare. */
476 static NSSet
477 *ns_get_covering_families (NSString *script, float pct)
478 {
479 static NSMutableDictionary *scriptToFamilies = nil;
480 NSMutableSet *families;
482 if (NSFONT_TRACE)
483 NSLog(@"Request covering families for script: '%@'", script);
485 if (scriptToFamilies == nil)
486 scriptToFamilies = [[NSMutableDictionary alloc] init];
488 if ((families = [scriptToFamilies objectForKey: script]) == nil)
489 {
490 NSFontManager *fontMgr = [NSFontManager sharedFontManager];
491 NSArray *allFamilies = [fontMgr availableFontFamilies];
493 if ([script length] == 0)
494 families = [NSMutableSet setWithArray: allFamilies];
495 else
496 {
497 NSCharacterSet *charset = ns_script_to_charset (script);
498 NSString *family;
499 families = [NSMutableSet setWithCapacity: 10];
500 while (1)
501 {
502 NSEnumerator *allFamiliesEnum = [allFamilies objectEnumerator];
503 while ((family = [allFamiliesEnum nextObject]))
504 {
505 NSCharacterSet *fset = [[fontMgr fontWithFamily: family
506 traits: 0 weight: 5 size: 12.0] coveredCharacterSet];
507 /* Some fonts on OS X, maybe many on GNUstep, return nil. */
508 if (fset == nil)
509 fset = [NSCharacterSet characterSetWithRange:
510 NSMakeRange (0, 127)];
511 if (ns_charset_covers(fset, charset, pct))
512 [families addObject: family];
513 }
514 pct -= 0.2;
515 if ([families count] > 0 || pct < 0.05)
516 break;
517 }
518 [charset release];
519 }
520 #ifdef NS_IMPL_COCOA
521 if ([families count] == 0)
522 [families addObject: @"LastResort"];
523 #endif
524 [scriptToFamilies setObject: families forKey: script];
525 }
527 if (NSFONT_TRACE)
528 NSLog(@" returning %d families", [families count]);
529 return families;
530 }
533 /* Implementation for list() and match(). List() can return nil, match()
534 must return something. Strategy is to drop family name from attribute
535 matching set for match. */
536 static Lisp_Object
537 ns_findfonts (Lisp_Object font_spec, BOOL isMatch)
538 {
539 Lisp_Object tem, list = Qnil;
540 NSFontDescriptor *fdesc, *desc;
541 NSMutableSet *fkeys;
542 NSArray *matchingDescs;
543 NSEnumerator *dEnum;
544 NSString *family;
545 NSSet *cFamilies;
546 BOOL foundItal = NO;
548 if (NSFONT_TRACE)
549 {
550 fprintf (stderr, "nsfont: %s for fontspec:\n ",
551 (isMatch ? "match" : "list"));
552 debug_print (font_spec);
553 }
555 cFamilies = ns_get_covering_families (ns_get_req_script (font_spec), 0.90);
557 fdesc = ns_spec_to_descriptor (font_spec);
558 fkeys = [NSMutableSet setWithArray: [[fdesc fontAttributes] allKeys]];
559 if (isMatch)
560 [fkeys removeObject: NSFontFamilyAttribute];
562 matchingDescs = [fdesc matchingFontDescriptorsWithMandatoryKeys: fkeys];
563 if (NSFONT_TRACE)
564 NSLog(@"Got desc %@ and found %d matching fonts from it: ", fdesc,
565 [matchingDescs count]);
567 for (dEnum = [matchingDescs objectEnumerator]; (desc = [dEnum nextObject]);)
568 {
569 if (![cFamilies containsObject:
570 [desc objectForKey: NSFontFamilyAttribute]])
571 continue;
572 tem = ns_descriptor_to_entity (desc,
573 AREF (font_spec, FONT_EXTRA_INDEX),
574 NULL);
575 if (isMatch)
576 return tem;
577 list = Fcons (tem, list);
578 if (fabs (ns_attribute_fvalue (desc, NSFontSlantTrait)) > 0.05)
579 foundItal = YES;
580 }
582 /* Add synthItal member if needed. */
583 family = [fdesc objectForKey: NSFontFamilyAttribute];
584 if (family != nil && !foundItal && XINT (Flength (list)) > 0)
585 {
586 NSFontDescriptor *s1 = [NSFontDescriptor new];
587 NSFontDescriptor *sDesc
588 = [[s1 fontDescriptorWithSymbolicTraits: NSFontItalicTrait]
589 fontDescriptorWithFamily: family];
590 list = Fcons (ns_descriptor_to_entity (sDesc,
591 AREF (font_spec, FONT_EXTRA_INDEX),
592 "synthItal"), list);
593 [s1 release];
594 }
596 /* Return something if was a match and nothing found. */
597 if (isMatch)
598 return ns_fallback_entity ();
600 if (NSFONT_TRACE)
601 fprintf (stderr, " Returning %"pI"d entities.\n",
602 XINT (Flength (list)));
604 return list;
605 }
609 /* ==========================================================================
611 Font driver implementation
613 ========================================================================== */
616 static Lisp_Object nsfont_get_cache (FRAME_PTR frame);
617 static Lisp_Object nsfont_list (Lisp_Object frame, Lisp_Object font_spec);
618 static Lisp_Object nsfont_match (Lisp_Object frame, Lisp_Object font_spec);
619 static Lisp_Object nsfont_list_family (Lisp_Object frame);
620 static Lisp_Object nsfont_open (FRAME_PTR f, Lisp_Object font_entity,
621 int pixel_size);
622 static void nsfont_close (FRAME_PTR f, struct font *font);
623 static int nsfont_has_char (Lisp_Object entity, int c);
624 static unsigned int nsfont_encode_char (struct font *font, int c);
625 static int nsfont_text_extents (struct font *font, unsigned int *code,
626 int nglyphs, struct font_metrics *metrics);
627 static int nsfont_draw (struct glyph_string *s, int from, int to, int x, int y,
628 bool with_background);
630 struct font_driver nsfont_driver =
631 {
632 0, /* Qns */
633 1, /* case sensitive */
634 nsfont_get_cache,
635 nsfont_list,
636 nsfont_match,
637 nsfont_list_family,
638 NULL, /*free_entity */
639 nsfont_open,
640 nsfont_close,
641 NULL, /* prepare_face */
642 NULL, /* done_face */
643 nsfont_has_char,
644 nsfont_encode_char,
645 nsfont_text_extents,
646 nsfont_draw,
647 /* excluded: get_bitmap, free_bitmap, get_outline, free_outline,
648 anchor_point, otf_capability, otf_driver,
649 start_for_frame, end_for_frame, shape */
650 };
653 /* Return a cache of font-entities on FRAME. The cache must be a
654 cons whose cdr part is the actual cache area. */
655 static Lisp_Object
656 nsfont_get_cache (FRAME_PTR frame)
657 {
658 Display_Info *dpyinfo = FRAME_NS_DISPLAY_INFO (frame);
659 return (dpyinfo->name_list_element);
660 }
663 /* List fonts exactly matching with FONT_SPEC on FRAME. The value is a
664 **list** of font-entities. This and match () are sole APIs that allocate
665 font-entities. Properties to be considered (2009/05/19) are:
666 regular: foundry, family, adstyle, registry
667 extended: script, lang, otf
668 "Extended" properties are not part of the vector but get stored as
669 lisp properties under FONT_EXTRA_INDEX.
671 The returned entities should have type set (to 'ns), plus the following:
672 foundry, family, adstyle, registry,
673 weight, slant, width, size (0 if scalable),
674 dpi, spacing, avgwidth (0 if scalable) */
675 static Lisp_Object
676 nsfont_list (Lisp_Object frame, Lisp_Object font_spec)
677 {
678 return ns_findfonts (font_spec, NO);
679 }
682 /* Return a font entity most closely matching with FONT_SPEC on
683 FRAME. The closeness is determined by the font backend, thus
684 `face-font-selection-order' is ignored here.
685 Properties to be considered are same as for list(). */
686 static Lisp_Object
687 nsfont_match (Lisp_Object frame, Lisp_Object font_spec)
688 {
689 return ns_findfonts(font_spec, YES);
690 }
693 /* List available families. The value is a list of family names
694 (symbols). */
695 static Lisp_Object
696 nsfont_list_family (Lisp_Object frame)
697 {
698 Lisp_Object list = Qnil;
699 NSEnumerator *families =
700 [[[NSFontManager sharedFontManager] availableFontFamilies]
701 objectEnumerator];
702 NSString *family;
703 while ((family = [families nextObject]))
704 list = Fcons (intern ([family UTF8String]), list);
705 /* FIXME: escape the name? */
707 if (NSFONT_TRACE)
708 fprintf (stderr, "nsfont: list families returning %"pI"d entries\n",
709 XINT (Flength (list)));
711 return list;
712 }
715 /* Open a font specified by FONT_ENTITY on frame F. If the font is
716 scalable, open it with PIXEL_SIZE. */
717 static Lisp_Object
718 nsfont_open (FRAME_PTR f, Lisp_Object font_entity, int pixel_size)
719 {
720 BOOL synthItal;
721 unsigned int traits = 0;
722 struct nsfont_info *font_info;
723 struct font *font;
724 NSFontDescriptor *fontDesc = ns_spec_to_descriptor (font_entity);
725 NSFontManager *fontMgr = [NSFontManager sharedFontManager];
726 NSString *family;
727 NSFont *nsfont, *sfont;
728 Lisp_Object tem;
729 NSRect brect;
730 Lisp_Object font_object;
731 int fixLeopardBug;
733 if (NSFONT_TRACE)
734 {
735 fprintf (stderr, "nsfont: open size %d of fontentity:\n ", pixel_size);
736 debug_print (font_entity);
737 }
739 if (pixel_size <= 0)
740 {
741 /* try to get it out of frame params */
742 Lisp_Object tem = get_frame_param (f, Qfontsize);
743 pixel_size = NILP (tem) ? 0 : XFASTINT (tem);
744 }
746 tem = AREF (font_entity, FONT_ADSTYLE_INDEX);
747 synthItal = !NILP (tem) && !strncmp ("synthItal", SSDATA (SYMBOL_NAME (tem)),
748 9);
749 family = ns_get_family (font_entity);
750 if (family == nil)
751 family = [[NSFont userFixedPitchFontOfSize: 0] familyName];
752 /* Should be > 0.23 as some font descriptors (e.g. Terminus) set to that
753 when setting family in ns_spec_to_descriptor(). */
754 if (ns_attribute_fvalue (fontDesc, NSFontWeightTrait) > 0.50)
755 traits |= NSBoldFontMask;
756 if (fabs (ns_attribute_fvalue (fontDesc, NSFontSlantTrait) > 0.05))
757 traits |= NSItalicFontMask;
759 /* see http://cocoadev.com/forums/comments.php?DiscussionID=74 */
760 fixLeopardBug = traits & NSBoldFontMask ? 10 : 5;
761 nsfont = [fontMgr fontWithFamily: family
762 traits: traits weight: fixLeopardBug
763 size: pixel_size];
764 /* if didn't find, try synthetic italic */
765 if (nsfont == nil && synthItal)
766 {
767 nsfont = [fontMgr fontWithFamily: family
768 traits: traits & ~NSItalicFontMask
769 weight: fixLeopardBug size: pixel_size];
770 }
771 #ifdef NS_IMPL_COCOA
772 /* LastResort not really a family */
773 if (nsfont == nil && [@"LastResort" isEqualToString: family])
774 nsfont = [NSFont fontWithName: @"LastResort" size: pixel_size];
775 #endif
777 if (nsfont == nil)
778 {
779 message_with_string ("*** Warning: font in family '%s' not found",
780 build_string ([family UTF8String]), 1);
781 nsfont = [NSFont userFixedPitchFontOfSize: pixel_size];
782 }
784 if (NSFONT_TRACE)
785 NSLog (@"%@\n", nsfont);
787 font_object = font_make_object (VECSIZE (struct nsfont_info),
788 font_entity, pixel_size);
789 font_info = (struct nsfont_info *) XFONT_OBJECT (font_object);
790 font = (struct font *) font_info;
791 if (!font)
792 return Qnil; /* FIXME: other terms do, but return Qnil causes segfault */
794 font_info->glyphs = xzalloc (0x100 * sizeof *font_info->glyphs);
795 font_info->metrics = xzalloc (0x100 * sizeof *font_info->metrics);
797 block_input ();
799 /* for metrics */
800 #ifdef NS_IMPL_COCOA
801 sfont = [nsfont screenFontWithRenderingMode:
802 NSFontAntialiasedIntegerAdvancementsRenderingMode];
803 #else
804 sfont = [nsfont screenFont];
805 #endif
807 if (sfont == nil)
808 sfont = nsfont;
810 /* non-metric backend font struct fields */
811 font = (struct font *) font_info;
812 font->pixel_size = [sfont pointSize];
813 font->driver = &nsfont_driver;
814 font->encoding_charset = -1;
815 font->repertory_charset = -1;
816 font->default_ascent = 0;
817 font->vertical_centering = 0;
818 font->baseline_offset = 0;
819 font->relative_compose = 0;
820 font->font_encoder = NULL;
822 font->props[FONT_FORMAT_INDEX] = Qns;
823 font->props[FONT_FILE_INDEX] = Qnil;
825 {
826 const char *fontName = [[nsfont fontName] UTF8String];
828 /* The values specified by fonts are not always exact. For
829 * example, a 6x8 font could specify that the descender is
830 * -2.00000405... (represented by 0xc000000220000000). Without
831 * adjustment, the code below would round the descender to -3,
832 * resulting in a font that would be one pixel higher than
833 * intended. */
834 CGFloat adjusted_descender = [sfont descender] + 0.0001;
836 #ifdef NS_IMPL_GNUSTEP
837 font_info->nsfont = sfont;
838 #else
839 font_info->nsfont = nsfont;
840 #endif
841 [font_info->nsfont retain];
843 /* set up ns_font (defined in nsgui.h) */
844 font_info->name = xstrdup (fontName);
845 font_info->bold = [fontMgr traitsOfFont: nsfont] & NSBoldFontMask;
846 font_info->ital =
847 synthItal || ([fontMgr traitsOfFont: nsfont] & NSItalicFontMask);
849 /* Metrics etc.; some fonts return an unusually large max advance, so we
850 only use it for fonts that have wide characters. */
851 font_info->width = ([sfont numberOfGlyphs] > 2000) ?
852 [sfont maximumAdvancement].width : ns_char_width (sfont, '0');
854 brect = [sfont boundingRectForFont];
856 font_info->underpos = [sfont underlinePosition];
857 font_info->underwidth = [sfont underlineThickness];
858 font_info->size = font->pixel_size;
860 /* max bounds */
861 font_info->max_bounds.ascent = lrint ([sfont ascender]);
862 /* Descender is usually negative. Use floor to avoid
863 clipping descenders. */
864 font_info->max_bounds.descent = -lrint (floor(adjusted_descender));
865 font_info->height =
866 font_info->max_bounds.ascent + font_info->max_bounds.descent;
867 font_info->max_bounds.width = lrint (font_info->width);
868 font_info->max_bounds.lbearing = lrint (brect.origin.x);
869 font_info->max_bounds.rbearing =
870 lrint (brect.size.width - font_info->width);
872 #ifdef NS_IMPL_COCOA
873 /* set up synthItal and the CG font */
874 font_info->synthItal = synthItal;
875 {
876 ATSFontRef atsFont = ATSFontFindFromPostScriptName
877 ((CFStringRef)[nsfont fontName], kATSOptionFlagsDefault);
879 if (atsFont == kATSFontRefUnspecified)
880 {
881 /* see if we can get it by dropping italic (then synthesizing) */
882 atsFont = ATSFontFindFromPostScriptName ((CFStringRef)
883 [[fontMgr convertFont: nsfont toNotHaveTrait: NSItalicFontMask]
884 fontName], kATSOptionFlagsDefault);
885 if (atsFont != kATSFontRefUnspecified)
886 font_info->synthItal = YES;
887 else
888 {
889 /* last resort fallback */
890 atsFont = ATSFontFindFromPostScriptName
891 ((CFStringRef)@"Monaco", kATSOptionFlagsDefault);
892 }
893 }
894 font_info->cgfont = CGFontCreateWithPlatformFont ((void*)&atsFont);
895 }
896 #endif
898 /* set up metrics portion of font struct */
899 font->ascent = lrint([sfont ascender]);
900 font->descent = -lrint(floor(adjusted_descender));
901 font->space_width = lrint (ns_char_width (sfont, ' '));
902 font->max_width = lrint (font_info->max_bounds.width);
903 font->min_width = font->space_width; /* Approximate. */
904 font->average_width = ns_ascii_average_width (sfont);
906 font->height = lrint (font_info->height);
907 font->underline_position = lrint (font_info->underpos);
908 font->underline_thickness = lrint (font_info->underwidth);
910 font->props[FONT_NAME_INDEX] = Ffont_xlfd_name (font_object, Qnil);
911 font->props[FONT_FULLNAME_INDEX] =
912 make_unibyte_string (font_info->name, strlen (font_info->name));
913 }
914 unblock_input ();
916 return font_object;
917 }
920 /* Close FONT on frame F. */
921 static void
922 nsfont_close (FRAME_PTR f, struct font *font)
923 {
924 struct nsfont_info *font_info = (struct nsfont_info *)font;
925 int i;
927 /* FIXME: this occurs apparently due to same failure to detect same font
928 that causes need for cache in nsfont_open () */
929 if (!font_info)
930 return;
932 for (i =0; i<0x100; i++)
933 {
934 xfree (font_info->glyphs[i]);
935 xfree (font_info->metrics[i]);
936 }
937 [font_info->nsfont release];
938 #ifdef NS_IMPL_COCOA
939 CGFontRelease (font_info->cgfont);
940 #endif
941 xfree (font_info->name);
942 xfree (font_info);
943 }
946 /* If FONT_ENTITY has a glyph for character C (Unicode code point),
947 return 1. If not, return 0. If a font must be opened to check
948 it, return -1. */
949 static int
950 nsfont_has_char (Lisp_Object entity, int c)
951 {
952 return -1;
953 }
956 /* Return a glyph code of FONT for character C (Unicode code point).
957 If FONT doesn't have such a glyph, return FONT_INVALID_CODE. */
958 static unsigned int
959 nsfont_encode_char (struct font *font, int c)
960 {
961 struct nsfont_info *font_info = (struct nsfont_info *)font;
962 unsigned char high = (c & 0xff00) >> 8, low = c & 0x00ff;
963 unsigned short g;
965 if (c > 0xFFFF)
966 return FONT_INVALID_CODE;
968 /* did we already cache this block? */
969 if (!font_info->glyphs[high])
970 ns_uni_to_glyphs (font_info, high);
972 g = font_info->glyphs[high][low];
973 return g == 0xFFFF ? FONT_INVALID_CODE : g;
974 }
977 /* Perform the size computation of glyphs of FONT and fill in members
978 of METRICS. The glyphs are specified by their glyph codes in
979 CODE (length NGLYPHS). */
980 static int
981 nsfont_text_extents (struct font *font, unsigned int *code, int nglyphs,
982 struct font_metrics *metrics)
983 {
984 struct nsfont_info *font_info = (struct nsfont_info *)font;
985 struct font_metrics *pcm;
986 unsigned char high, low;
987 int totalWidth = 0;
988 int i;
990 memset (metrics, 0, sizeof (struct font_metrics));
992 for (i =0; i<nglyphs; i++)
993 {
994 /* get metrics for this glyph, filling cache if need be */
995 /* TODO: get metrics for whole string from an NSLayoutManager
996 (if not too slow) */
997 high = (code[i] & 0xFF00) >> 8;
998 low = code[i] & 0x00FF;
999 if (!font_info->metrics[high])
1000 ns_glyph_metrics (font_info, high);
1001 pcm = &(font_info->metrics[high][low]);
1003 if (metrics->lbearing > totalWidth + pcm->lbearing)
1004 metrics->lbearing = totalWidth + pcm->lbearing;
1005 if (metrics->rbearing < totalWidth + pcm->rbearing)
1006 metrics->rbearing = totalWidth + pcm->rbearing;
1007 if (metrics->ascent < pcm->ascent)
1008 metrics->ascent = pcm->ascent;
1009 if (metrics->descent < pcm->descent)
1010 metrics->descent = pcm->descent;
1012 totalWidth += pcm->width;
1013 }
1015 metrics->width = totalWidth;
1017 return totalWidth; /* not specified in doc, but xfont.c does it */
1018 }
1021 /* Draw glyphs between FROM and TO of S->char2b at (X Y) pixel
1022 position of frame F with S->FACE and S->GC. If WITH_BACKGROUND,
1023 fill the background in advance. It is assured that WITH_BACKGROUND
1024 is false when (FROM > 0 || TO < S->nchars). */
1025 static int
1026 nsfont_draw (struct glyph_string *s, int from, int to, int x, int y,
1027 bool with_background)
1028 /* NOTE: focus and clip must be set
1029 also, currently assumed (true in nsterm.m call) from ==0, to ==nchars */
1030 {
1031 static char cbuf[1024];
1032 char *c = cbuf;
1033 #ifdef NS_IMPL_GNUSTEP
1034 static float advances[1024];
1035 float *adv = advances;
1036 #else
1037 static CGSize advances[1024];
1038 CGSize *adv = advances;
1039 #endif
1040 struct face *face;
1041 NSRect r;
1042 struct nsfont_info *font = ns_tmp_font;
1043 NSColor *col, *bgCol;
1044 unsigned short *t = s->char2b;
1045 int i, len;
1046 char isComposite = s->first_glyph->type == COMPOSITE_GLYPH;
1047 int end = isComposite ? s->cmp_to : s->nchars;
1049 /* Select face based on input flags */
1050 switch (ns_tmp_flags)
1051 {
1052 case NS_DUMPGLYPH_CURSOR:
1053 face = s->face;
1054 break;
1055 case NS_DUMPGLYPH_MOUSEFACE:
1056 face = FACE_FROM_ID (s->f, MOUSE_HL_INFO (s->f)->mouse_face_face_id);
1057 if (!face)
1058 face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
1059 break;
1060 default:
1061 face = s->face;
1062 }
1064 r.origin.x = s->x;
1065 if (s->face->box != FACE_NO_BOX && s->first_glyph->left_box_line_p)
1066 r.origin.x += abs (s->face->box_line_width);
1068 r.origin.y = s->y;
1069 r.size.height = FONT_HEIGHT (font);
1071 /* Convert UTF-16 (?) to UTF-8 and determine advances. Note if we just ask
1072 NS to render the string, it will come out differently from the individual
1073 character widths added up because of layout processing. */
1074 {
1075 int cwidth, twidth = 0;
1076 int hi, lo;
1077 /* FIXME: composition: no vertical displacement is considered. */
1078 t += s->cmp_from; /* advance into composition */
1079 for (i = s->cmp_from; i < end; i++, t++)
1080 {
1081 hi = (*t & 0xFF00) >> 8;
1082 lo = *t & 0x00FF;
1083 if (isComposite)
1084 {
1085 if (!s->first_glyph->u.cmp.automatic)
1086 cwidth = s->cmp->offsets[i * 2] /* (H offset) */ - twidth;
1087 else
1088 {
1089 Lisp_Object gstring = composition_gstring_from_id (s->cmp_id);
1090 Lisp_Object glyph = LGSTRING_GLYPH (gstring, i);
1091 if (NILP (LGLYPH_ADJUSTMENT (glyph)))
1092 cwidth = LGLYPH_WIDTH (glyph);
1093 else
1094 {
1095 cwidth = LGLYPH_WADJUST (glyph);
1096 #ifdef NS_IMPL_GNUSTEP
1097 *(adv-1) += LGLYPH_XOFF (glyph);
1098 #else
1099 (*(adv-1)).width += LGLYPH_XOFF (glyph);
1100 #endif
1101 }
1102 }
1103 }
1104 else
1105 {
1106 if (!font->metrics[hi]) /* FIXME: why/how can we need this now? */
1107 ns_glyph_metrics (font, hi);
1108 cwidth = font->metrics[hi][lo].width;
1109 }
1110 twidth += cwidth;
1111 #ifdef NS_IMPL_GNUSTEP
1112 *adv++ = cwidth;
1113 CHAR_STRING_ADVANCE (*t, c); /* this converts the char to UTF-8 */
1114 #else
1115 (*adv++).width = cwidth;
1116 #endif
1117 }
1118 len = adv - advances;
1119 r.size.width = twidth;
1120 *c = 0;
1121 }
1123 /* fill background if requested */
1124 if (with_background && !isComposite)
1125 {
1126 NSRect br = r;
1127 int fibw = FRAME_INTERNAL_BORDER_WIDTH (s->f);
1128 int mbox_line_width = max (s->face->box_line_width, 0);
1130 if (s->row->full_width_p)
1131 {
1132 if (br.origin.x <= fibw + 1 + mbox_line_width)
1133 {
1134 br.size.width += br.origin.x - mbox_line_width;
1135 br.origin.x = mbox_line_width;
1136 }
1137 if (FRAME_PIXEL_WIDTH (s->f) - (br.origin.x + br.size.width)
1138 <= fibw+1)
1139 br.size.width += fibw;
1140 }
1141 if (s->face->box == FACE_NO_BOX)
1142 {
1143 /* expand unboxed top row over internal border */
1144 if (br.origin.y <= fibw + 1 + mbox_line_width)
1145 {
1146 br.size.height += br.origin.y;
1147 br.origin.y = 0;
1148 }
1149 }
1150 else
1151 {
1152 int correction = abs (s->face->box_line_width)+1;
1153 br.origin.y += correction;
1154 br.size.height -= 2*correction;
1155 br.origin.x += correction;
1156 br.size.width -= 2*correction;
1157 }
1159 if (!s->face->stipple)
1160 [(NS_FACE_BACKGROUND (face) != 0
1161 ? ns_lookup_indexed_color (NS_FACE_BACKGROUND (face), s->f)
1162 : FRAME_BACKGROUND_COLOR (s->f)) set];
1163 else
1164 {
1165 struct ns_display_info *dpyinfo = FRAME_NS_DISPLAY_INFO (s->f);
1166 [[dpyinfo->bitmaps[face->stipple-1].img stippleMask] set];
1167 }
1168 NSRectFill (br);
1169 }
1172 /* set up for character rendering */
1173 r.origin.y = s->ybase;
1175 col = (NS_FACE_FOREGROUND (face) != 0
1176 ? ns_lookup_indexed_color (NS_FACE_FOREGROUND (face), s->f)
1177 : FRAME_FOREGROUND_COLOR (s->f));
1178 /* FIXME: find another way to pass this */
1179 bgCol = (ns_tmp_flags != NS_DUMPGLYPH_FOREGROUND ? nil
1180 : (NS_FACE_BACKGROUND (face) != 0
1181 ? ns_lookup_indexed_color (NS_FACE_BACKGROUND (face), s->f)
1182 : FRAME_BACKGROUND_COLOR (s->f)));
1184 /* render under GNUstep using DPS */
1185 #ifdef NS_IMPL_GNUSTEP
1186 {
1187 NSGraphicsContext *context = GSCurrentContext ();
1189 DPSgsave (context);
1190 [font->nsfont set];
1192 /* do erase if "foreground" mode */
1193 if (bgCol != nil)
1194 {
1195 [bgCol set];
1196 DPSmoveto (context, r.origin.x, r.origin.y);
1197 /*[context GSSetTextDrawingMode: GSTextFillStroke]; /// not implemented yet */
1198 DPSxshow (context, cbuf, advances, len);
1199 DPSstroke (context);
1200 [col set];
1201 /*[context GSSetTextDrawingMode: GSTextFill]; /// not implemented yet */
1202 }
1204 [col set];
1206 /* draw with DPSxshow () */
1207 DPSmoveto (context, r.origin.x, r.origin.y);
1208 DPSxshow (context, cbuf, advances, len);
1209 DPSstroke (context);
1211 DPSgrestore (context);
1212 }
1214 #else /* NS_IMPL_COCOA */
1215 {
1216 CGContextRef gcontext =
1217 [[NSGraphicsContext currentContext] graphicsPort];
1218 static CGAffineTransform fliptf;
1219 static BOOL firstTime = YES;
1221 if (firstTime)
1222 {
1223 firstTime = NO;
1224 fliptf = CGAffineTransformMakeScale (1.0, -1.0);
1225 }
1227 CGContextSaveGState (gcontext);
1229 fliptf.c = font->synthItal ? Fix2X (kATSItalicQDSkew) : 0.0;
1231 CGContextSetFont (gcontext, font->cgfont);
1232 CGContextSetFontSize (gcontext, font->size);
1233 if (NILP (ns_antialias_text) || font->size <= ns_antialias_threshold)
1234 CGContextSetShouldAntialias (gcontext, 0);
1235 else
1236 CGContextSetShouldAntialias (gcontext, 1);
1238 CGContextSetShouldSmoothFonts (gcontext, NO);
1239 CGContextSetTextMatrix (gcontext, fliptf);
1241 if (bgCol != nil)
1242 {
1243 /* foreground drawing; erase first to avoid overstrike */
1244 [bgCol set];
1245 CGContextSetTextDrawingMode (gcontext, kCGTextFillStroke);
1246 CGContextSetTextPosition (gcontext, r.origin.x, r.origin.y);
1247 CGContextShowGlyphsWithAdvances (gcontext, s->char2b, advances, len);
1248 CGContextSetTextDrawingMode (gcontext, kCGTextFill);
1249 }
1251 [col set];
1253 CGContextSetTextPosition (gcontext, r.origin.x, r.origin.y);
1254 CGContextShowGlyphsWithAdvances (gcontext, s->char2b + s->cmp_from,
1255 advances, len);
1257 if (face->overstrike)
1258 {
1259 CGContextSetTextPosition (gcontext, r.origin.x+0.5, r.origin.y);
1260 CGContextShowGlyphsWithAdvances (gcontext, s->char2b + s->cmp_from,
1261 advances, len);
1262 }
1264 CGContextRestoreGState (gcontext);
1265 }
1266 #endif /* NS_IMPL_COCOA */
1268 /* Draw underline, overline, strike-through. */
1269 ns_draw_text_decoration (s, face, col, r.size.width, r.origin.x);
1271 return to-from;
1272 }
1276 /* ==========================================================================
1278 Font glyph and metrics caching functions
1280 ========================================================================== */
1282 /* Find and cache corresponding glyph codes for unicode values in given
1283 hi-byte block of 256. */
1284 static void
1285 ns_uni_to_glyphs (struct nsfont_info *font_info, unsigned char block)
1286 {
1287 #ifdef NS_IMPL_COCOA
1288 static EmacsGlyphStorage *glyphStorage;
1289 static char firstTime = 1;
1290 #endif
1291 unichar *unichars = xmalloc (0x101 * sizeof (unichar));
1292 unsigned int i, g, idx;
1293 unsigned short *glyphs;
1295 if (NSFONT_TRACE)
1296 fprintf (stderr, "%p\tFinding glyphs for glyphs in block %d\n",
1297 font_info, block);
1299 block_input ();
1301 #ifdef NS_IMPL_COCOA
1302 if (firstTime)
1303 {
1304 firstTime = 0;
1305 glyphStorage = [[EmacsGlyphStorage alloc] initWithCapacity: 0x100];
1306 }
1307 #endif
1309 font_info->glyphs[block] = xmalloc (0x100 * sizeof (unsigned short));
1310 if (!unichars || !(font_info->glyphs[block]))
1311 emacs_abort ();
1313 /* create a string containing all Unicode characters in this block */
1314 for (idx = block<<8, i = 0; i < 0x100; idx++, i++)
1315 if (idx < 0xD800 || idx > 0xDFFF)
1316 unichars[i] = idx;
1317 else
1318 unichars[i] = 0xFEFF;
1319 unichars[0x100] = 0;
1321 {
1322 #ifdef NS_IMPL_COCOA
1323 NSString *allChars = [[NSString alloc]
1324 initWithCharactersNoCopy: unichars
1325 length: 0x100
1326 freeWhenDone: NO];
1327 NSGlyphGenerator *glyphGenerator = [NSGlyphGenerator sharedGlyphGenerator];
1328 /*NSCharacterSet *coveredChars = [nsfont coveredCharacterSet]; */
1329 unsigned int numGlyphs = [font_info->nsfont numberOfGlyphs];
1330 NSUInteger gInd = 0, cInd = 0;
1332 [glyphStorage setString: allChars font: font_info->nsfont];
1333 [glyphGenerator generateGlyphsForGlyphStorage: glyphStorage
1334 desiredNumberOfCharacters: glyphStorage->maxChar
1335 glyphIndex: &gInd characterIndex: &cInd];
1336 #endif
1337 glyphs = font_info->glyphs[block];
1338 for (i = 0; i < 0x100; i++, glyphs++)
1339 {
1340 #ifdef NS_IMPL_GNUSTEP
1341 g = unichars[i];
1342 #else
1343 g = glyphStorage->cglyphs[i];
1344 /* TODO: is this a good check? maybe need to use coveredChars.. */
1345 if (g > numGlyphs)
1346 g = 0xFFFF; /* hopefully unused... */
1347 #endif
1348 *glyphs = g;
1349 }
1351 #ifdef NS_IMPL_COCOA
1352 [allChars release];
1353 #endif
1354 }
1356 unblock_input ();
1357 xfree (unichars);
1358 }
1361 /* Determine and cache metrics for corresponding glyph codes in given
1362 hi-byte block of 256. */
1363 static void
1364 ns_glyph_metrics (struct nsfont_info *font_info, unsigned char block)
1365 {
1366 unsigned int i, g;
1367 unsigned int numGlyphs = [font_info->nsfont numberOfGlyphs];
1368 NSFont *sfont;
1369 struct font_metrics *metrics;
1371 if (NSFONT_TRACE)
1372 fprintf (stderr, "%p\tComputing metrics for glyphs in block %d\n",
1373 font_info, block);
1375 #ifdef NS_IMPL_GNUSTEP
1376 /* not implemented yet (as of startup 0.18), so punt */
1377 if (numGlyphs == 0)
1378 numGlyphs = 0x10000;
1379 #endif
1381 block_input ();
1382 #ifdef NS_IMPL_COCOA
1383 sfont = [font_info->nsfont screenFontWithRenderingMode:
1384 NSFontAntialiasedIntegerAdvancementsRenderingMode];
1385 #else
1386 sfont = [font_info->nsfont screenFont];
1387 #endif
1389 font_info->metrics[block] = xzalloc (0x100 * sizeof (struct font_metrics));
1390 if (!(font_info->metrics[block]))
1391 emacs_abort ();
1393 metrics = font_info->metrics[block];
1394 for (g = block<<8, i =0; i<0x100 && g < numGlyphs; g++, i++, metrics++)
1395 {
1396 float w, lb, rb;
1397 NSRect r = [sfont boundingRectForGlyph: g];
1399 w = max ([sfont advancementForGlyph: g].width, 2.0);
1400 metrics->width = lrint (w);
1402 lb = r.origin.x;
1403 rb = r.size.width - w;
1404 if (lb < 0)
1405 metrics->lbearing = round (lb);
1406 if (font_info->ital)
1407 rb += 0.22 * font_info->height;
1408 metrics->rbearing = lrint (w + rb);
1410 metrics->descent = r.origin.y < 0 ? -r.origin.y : 0;
1411 /*lrint (hshrink * [sfont ascender] + expand * hd/2); */
1412 metrics->ascent = r.size.height - metrics->descent;
1413 /*-lrint (hshrink* [sfont descender] - expand * hd/2); */
1414 }
1415 unblock_input ();
1416 }
1419 #ifdef NS_IMPL_COCOA
1420 /* helper for font glyph setup */
1421 @implementation EmacsGlyphStorage
1423 - init
1424 {
1425 return [self initWithCapacity: 1024];
1426 }
1428 - initWithCapacity: (unsigned long) c
1429 {
1430 self = [super init];
1431 maxChar = 0;
1432 maxGlyph = 0;
1433 dict = [NSMutableDictionary new];
1434 cglyphs = xmalloc (c * sizeof (CGGlyph));
1435 return self;
1436 }
1438 - (void) dealloc
1439 {
1440 if (attrStr != nil)
1441 [attrStr release];
1442 [dict release];
1443 xfree (cglyphs);
1444 [super dealloc];
1445 }
1447 - (void) setString: (NSString *)str font: (NSFont *)font
1448 {
1449 [dict setObject: font forKey: NSFontAttributeName];
1450 if (attrStr != nil)
1451 [attrStr release];
1452 attrStr = [[NSAttributedString alloc] initWithString: str attributes: dict];
1453 maxChar = [str length];
1454 maxGlyph = 0;
1455 }
1457 /* NSGlyphStorage protocol */
1458 - (NSUInteger)layoutOptions
1459 {
1460 return 0;
1461 }
1463 - (NSAttributedString *)attributedString
1464 {
1465 return attrStr;
1466 }
1468 - (void)insertGlyphs: (const NSGlyph *)glyphs length: (NSUInteger)length
1469 forStartingGlyphAtIndex: (NSUInteger)glyphIndex
1470 characterIndex: (NSUInteger)charIndex
1471 {
1472 len = glyphIndex+length;
1473 for (i =glyphIndex; i<len; i++)
1474 cglyphs[i] = glyphs[i-glyphIndex];
1475 if (len > maxGlyph)
1476 maxGlyph = len;
1477 }
1479 - (void)setIntAttribute: (NSInteger)attributeTag value: (NSInteger)val
1480 forGlyphAtIndex: (NSUInteger)glyphIndex
1481 {
1482 return;
1483 }
1485 @end
1486 #endif /* NS_IMPL_COCOA */
1489 /* Debugging */
1490 void
1491 ns_dump_glyphstring (struct glyph_string *s)
1492 {
1493 int i;
1495 fprintf (stderr, "Glyph string len = %d at (%d, %d) overhang (%d, %d),"
1496 "overlap = %d, bg_filled = %d:",
1497 s->nchars, s->x, s->y, s->left_overhang, s->right_overhang,
1498 s->row->overlapping_p, s->background_filled_p);
1499 for (i =0; i<s->nchars; i++)
1500 fprintf (stderr, "%c", s->first_glyph[i].u.ch);
1501 fprintf (stderr, "\n");
1502 }
1505 void
1506 syms_of_nsfont (void)
1507 {
1508 nsfont_driver.type = Qns;
1509 register_font_driver (&nsfont_driver, NULL);
1510 DEFSYM (Qapple, "apple");
1511 DEFSYM (Qroman, "roman");
1512 DEFSYM (Qmedium, "medium");
1513 DEFVAR_LISP ("ns-reg-to-script", Vns_reg_to_script,
1514 doc: /* Internal use: maps font registry to Unicode script. */);
1516 ascii_printable = NULL;
1517 }