?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
beta-0.89.2
[luatex.git] / source / libs / cairo / cairo-src / src / cairo-scaled-font-subsets.c
blob196fa999aa727352f50e1af669ac6894b3164faa
1 /* cairo - a vector graphics library with display and print output
2 *
3 * Copyright © 2003 University of Southern California
4 * Copyright © 2005 Red Hat, Inc
5 * Copyright © 2006 Keith Packard
6 * Copyright © 2006 Red Hat, Inc
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it either under the terms of the GNU Lesser General Public
10 * License version 2.1 as published by the Free Software Foundation
11 * (the "LGPL") or, at your option, under the terms of the Mozilla
12 * Public License Version 1.1 (the "MPL"). If you do not alter this
13 * notice, a recipient may use your version of this file under either
14 * the MPL or the LGPL.
15 *
16 * You should have received a copy of the LGPL along with this library
17 * in the file COPYING-LGPL-2.1; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
19 * You should have received a copy of the MPL along with this library
20 * in the file COPYING-MPL-1.1
21 *
22 * The contents of this file are subject to the Mozilla Public License
23 * Version 1.1 (the "License"); you may not use this file except in
24 * compliance with the License. You may obtain a copy of the License at
25 * http://www.mozilla.org/MPL/
26 *
27 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
28 * OF ANY KIND, either express or implied. See the LGPL or the MPL for
29 * the specific language governing rights and limitations.
30 *
31 * The Original Code is the cairo graphics library.
32 *
33 * The Initial Developer of the Original Code is University of Southern
34 * California.
35 *
36 * Contributor(s):
37 * Carl D. Worth <cworth@cworth.org>
38 * Kristian Høgsberg <krh@redhat.com>
39 * Keith Packard <keithp@keithp.com>
40 * Adrian Johnson <ajohnson@redneon.com>
41 */
42
43 #define _BSD_SOURCE /* for snprintf(), strdup() */
44 #include "cairoint.h"
45 #include "cairo-error-private.h"
46
47 #if CAIRO_HAS_FONT_SUBSET
48
49 #include "cairo-scaled-font-subsets-private.h"
50 #include "cairo-user-font-private.h"
51
52 #define MAX_GLYPHS_PER_SIMPLE_FONT 256
53 #define MAX_GLYPHS_PER_COMPOSITE_FONT 65536
54
55 typedef enum {
56 CAIRO_SUBSETS_SCALED,
57 CAIRO_SUBSETS_SIMPLE,
58 CAIRO_SUBSETS_COMPOSITE
59 } cairo_subsets_type_t;
60
61 typedef enum {
62 CAIRO_SUBSETS_FOREACH_UNSCALED,
63 CAIRO_SUBSETS_FOREACH_SCALED,
64 CAIRO_SUBSETS_FOREACH_USER
65 } cairo_subsets_foreach_type_t;
66
67 typedef struct _cairo_sub_font {
68 cairo_hash_entry_t base;
69
70 cairo_bool_t is_scaled;
71 cairo_bool_t is_composite;
72 cairo_bool_t is_user;
73 cairo_bool_t use_latin_subset;
74 cairo_scaled_font_subsets_t *parent;
75 cairo_scaled_font_t *scaled_font;
76 unsigned int font_id;
77
78 int current_subset;
79 int num_glyphs_in_current_subset;
80 int num_glyphs_in_latin_subset;
81 int max_glyphs_per_subset;
82 char latin_char_map[256];
83
84 cairo_hash_table_t *sub_font_glyphs;
85 struct _cairo_sub_font *next;
86 } cairo_sub_font_t;
87
88 struct _cairo_scaled_font_subsets {
89 cairo_subsets_type_t type;
90 cairo_bool_t use_latin_subset;
91
92 int max_glyphs_per_unscaled_subset_used;
93 cairo_hash_table_t *unscaled_sub_fonts;
94 cairo_sub_font_t *unscaled_sub_fonts_list;
95 cairo_sub_font_t *unscaled_sub_fonts_list_end;
96
97 int max_glyphs_per_scaled_subset_used;
98 cairo_hash_table_t *scaled_sub_fonts;
99 cairo_sub_font_t *scaled_sub_fonts_list;
100 cairo_sub_font_t *scaled_sub_fonts_list_end;
101
102 int num_sub_fonts;
103 };
104
105 typedef struct _cairo_sub_font_glyph {
106 cairo_hash_entry_t base;
107
108 unsigned int subset_id;
109 unsigned int subset_glyph_index;
110 double x_advance;
111 double y_advance;
112
113 cairo_bool_t is_latin;
114 int latin_character;
115 cairo_bool_t is_mapped;
116 uint32_t unicode;
117 char *utf8;
118 int utf8_len;
119 } cairo_sub_font_glyph_t;
120
121 typedef struct _cairo_sub_font_collection {
122 unsigned long *glyphs; /* scaled_font_glyph_index */
123 char **utf8;
124 unsigned int glyphs_size;
125 int *to_latin_char;
126 unsigned long *latin_to_subset_glyph_index;
127 unsigned int max_glyph;
128 unsigned int num_glyphs;
129
130 unsigned int subset_id;
131
132 cairo_status_t status;
133 cairo_scaled_font_subset_callback_func_t font_subset_callback;
134 void *font_subset_callback_closure;
135 } cairo_sub_font_collection_t;
136
137 typedef struct _cairo_string_entry {
138 cairo_hash_entry_t base;
139 char *string;
140 } cairo_string_entry_t;
141
142 static cairo_status_t
143 _cairo_sub_font_map_glyph (cairo_sub_font_t *sub_font,
144 unsigned long scaled_font_glyph_index,
145 const char * utf8,
146 int utf8_len,
147 cairo_scaled_font_subsets_glyph_t *subset_glyph);
148
149 static void
150 _cairo_sub_font_glyph_init_key (cairo_sub_font_glyph_t *sub_font_glyph,
151 unsigned long scaled_font_glyph_index)
152 {
153 sub_font_glyph->base.hash = scaled_font_glyph_index;
154 }
155
156 static cairo_sub_font_glyph_t *
157 _cairo_sub_font_glyph_create (unsigned long scaled_font_glyph_index,
158 unsigned int subset_id,
159 unsigned int subset_glyph_index,
160 double x_advance,
161 double y_advance,
162 int latin_character,
163 uint32_t unicode,
164 char *utf8,
165 int utf8_len)
166 {
167 cairo_sub_font_glyph_t *sub_font_glyph;
168
169 sub_font_glyph = malloc (sizeof (cairo_sub_font_glyph_t));
170 if (unlikely (sub_font_glyph == NULL)) {
171 _cairo_error_throw (CAIRO_STATUS_NO_MEMORY);
172 return NULL;
173 }
174
175 _cairo_sub_font_glyph_init_key (sub_font_glyph, scaled_font_glyph_index);
176 sub_font_glyph->subset_id = subset_id;
177 sub_font_glyph->subset_glyph_index = subset_glyph_index;
178 sub_font_glyph->x_advance = x_advance;
179 sub_font_glyph->y_advance = y_advance;
180 sub_font_glyph->is_latin = (latin_character >= 0);
181 sub_font_glyph->latin_character = latin_character;
182 sub_font_glyph->is_mapped = FALSE;
183 sub_font_glyph->unicode = unicode;
184 sub_font_glyph->utf8 = utf8;
185 sub_font_glyph->utf8_len = utf8_len;
186
187 return sub_font_glyph;
188 }
189
190 static void
191 _cairo_sub_font_glyph_destroy (cairo_sub_font_glyph_t *sub_font_glyph)
192 {
193 free (sub_font_glyph->utf8);
194
195 free (sub_font_glyph);
196 }
197
198 static void
199 _cairo_sub_font_glyph_pluck (void *entry, void *closure)
200 {
201 cairo_sub_font_glyph_t *sub_font_glyph = entry;
202 cairo_hash_table_t *sub_font_glyphs = closure;
203
204 _cairo_hash_table_remove (sub_font_glyphs, &sub_font_glyph->base);
205 _cairo_sub_font_glyph_destroy (sub_font_glyph);
206 }
207
208 static void
209 _cairo_sub_font_glyph_collect (void *entry, void *closure)
210 {
211 cairo_sub_font_glyph_t *sub_font_glyph = entry;
212 cairo_sub_font_collection_t *collection = closure;
213 unsigned long scaled_font_glyph_index;
214 unsigned int subset_glyph_index;
215
216 if (sub_font_glyph->subset_id != collection->subset_id)
217 return;
218
219 scaled_font_glyph_index = sub_font_glyph->base.hash;
220 subset_glyph_index = sub_font_glyph->subset_glyph_index;
221
222 /* Ensure we don't exceed the allocated bounds. */
223 assert (subset_glyph_index < collection->glyphs_size);
224
225 collection->glyphs[subset_glyph_index] = scaled_font_glyph_index;
226 collection->utf8[subset_glyph_index] = sub_font_glyph->utf8;
227 collection->to_latin_char[subset_glyph_index] = sub_font_glyph->latin_character;
228 if (sub_font_glyph->is_latin)
229 collection->latin_to_subset_glyph_index[sub_font_glyph->latin_character] = subset_glyph_index;
230
231 if (subset_glyph_index > collection->max_glyph)
232 collection->max_glyph = subset_glyph_index;
233
234 collection->num_glyphs++;
235 }
236
237 static cairo_bool_t
238 _cairo_sub_fonts_equal (const void *key_a, const void *key_b)
239 {
240 const cairo_sub_font_t *sub_font_a = key_a;
241 const cairo_sub_font_t *sub_font_b = key_b;
242 cairo_scaled_font_t *a = sub_font_a->scaled_font;
243 cairo_scaled_font_t *b = sub_font_b->scaled_font;
244
245 if (sub_font_a->is_scaled)
246 return a == b;
247 else
248 return a->font_face == b->font_face || a->original_font_face == b->original_font_face;
249 }
250
251 static void
252 _cairo_sub_font_init_key (cairo_sub_font_t *sub_font,
253 cairo_scaled_font_t *scaled_font)
254 {
255 if (sub_font->is_scaled)
256 {
257 sub_font->base.hash = (unsigned long) scaled_font;
258 sub_font->scaled_font = scaled_font;
259 }
260 else
261 {
262 sub_font->base.hash = (unsigned long) scaled_font->font_face;
263 sub_font->scaled_font = scaled_font;
264 }
265 }
266
267 static cairo_status_t
268 _cairo_sub_font_create (cairo_scaled_font_subsets_t *parent,
269 cairo_scaled_font_t *scaled_font,
270 unsigned int font_id,
271 int max_glyphs_per_subset,
272 cairo_bool_t is_scaled,
273 cairo_bool_t is_composite,
274 cairo_sub_font_t **sub_font_out)
275 {
276 cairo_sub_font_t *sub_font;
277 int i;
278
279 sub_font = malloc (sizeof (cairo_sub_font_t));
280 if (unlikely (sub_font == NULL))
281 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
282
283 sub_font->is_scaled = is_scaled;
284 sub_font->is_composite = is_composite;
285 sub_font->is_user = _cairo_font_face_is_user (scaled_font->font_face);
286 _cairo_sub_font_init_key (sub_font, scaled_font);
287
288 sub_font->parent = parent;
289 sub_font->scaled_font = scaled_font;
290 sub_font->font_id = font_id;
291
292 sub_font->use_latin_subset = parent->use_latin_subset;
293
294 /* latin subsets of Type 3 and CID CFF fonts are not supported */
295 if (sub_font->is_user || sub_font->is_scaled ||
296 _cairo_cff_scaled_font_is_cid_cff (scaled_font) )
297 {
298 sub_font->use_latin_subset = FALSE;
299 }
300
301 if (sub_font->use_latin_subset)
302 sub_font->current_subset = 1; /* reserve subset 0 for latin glyphs */
303 else
304 sub_font->current_subset = 0;
305
306 sub_font->num_glyphs_in_current_subset = 0;
307 sub_font->num_glyphs_in_latin_subset = 0;
308 sub_font->max_glyphs_per_subset = max_glyphs_per_subset;
309 for (i = 0; i < 256; i++)
310 sub_font->latin_char_map[i] = FALSE;
311
312 sub_font->sub_font_glyphs = _cairo_hash_table_create (NULL);
313 if (unlikely (sub_font->sub_font_glyphs == NULL)) {
314 free (sub_font);
315 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
316 }
317 sub_font->next = NULL;
318 *sub_font_out = sub_font;
319 return CAIRO_STATUS_SUCCESS;
320 }
321
322 static void
323 _cairo_sub_font_destroy (cairo_sub_font_t *sub_font)
324 {
325 _cairo_hash_table_foreach (sub_font->sub_font_glyphs,
326 _cairo_sub_font_glyph_pluck,
327 sub_font->sub_font_glyphs);
328 _cairo_hash_table_destroy (sub_font->sub_font_glyphs);
329 cairo_scaled_font_destroy (sub_font->scaled_font);
330 free (sub_font);
331 }
332
333 static void
334 _cairo_sub_font_pluck (void *entry, void *closure)
335 {
336 cairo_sub_font_t *sub_font = entry;
337 cairo_hash_table_t *sub_fonts = closure;
338
339 _cairo_hash_table_remove (sub_fonts, &sub_font->base);
340 _cairo_sub_font_destroy (sub_font);
341 }
342
343 /* Characters 0x80 to 0x9f in the winansi encoding.
344 * All other characters in the range 0x00 to 0xff map 1:1 to unicode */
345 static unsigned int _winansi_0x80_to_0x9f[] = {
346 0x20ac, 0x0000, 0x201a, 0x0192, 0x201e, 0x2026, 0x2020, 0x2021,
347 0x02c6, 0x2030, 0x0160, 0x2039, 0x0152, 0x0000, 0x017d, 0x0000,
348 0x0000, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014,
349 0x02dc, 0x2122, 0x0161, 0x203a, 0x0153, 0x0000, 0x017e, 0x0178
350 };
351
352 int
353 _cairo_unicode_to_winansi (unsigned long uni)
354 {
355 int i;
356
357 /* exclude the extra "hyphen" at 0xad to avoid duplicate glyphnames */
358 if ((uni >= 0x20 && uni <= 0x7e) ||
359 (uni >= 0xa1 && uni <= 0xff && uni != 0xad) ||
360 uni == 0)
361 return uni;
362
363 for (i = 0; i < 32; i++)
364 if (_winansi_0x80_to_0x9f[i] == uni)
365 return i + 0x80;
366
367 return -1;
368 }
369
370 static cairo_status_t
371 _cairo_sub_font_glyph_lookup_unicode (cairo_scaled_font_t *scaled_font,
372 unsigned long scaled_font_glyph_index,
373 uint32_t *unicode_out,
374 char **utf8_out,
375 int *utf8_len_out)
376 {
377 uint32_t unicode;
378 char buf[8];
379 int len;
380 cairo_status_t status;
381
382 /* Do a reverse lookup on the glyph index. unicode is -1 if the
383 * index could not be mapped to a unicode character. */
384 unicode = -1;
385 status = _cairo_truetype_index_to_ucs4 (scaled_font,
386 scaled_font_glyph_index,
387 &unicode);
388 if (_cairo_status_is_error (status))
389 return status;
390
391 if (unicode == (uint32_t)-1 && scaled_font->backend->index_to_ucs4) {
392 status = scaled_font->backend->index_to_ucs4 (scaled_font,
393 scaled_font_glyph_index,
394 &unicode);
395 if (unlikely (status))
396 return status;
397 }
398
399 *unicode_out = unicode;
400 *utf8_out = NULL;
401 *utf8_len_out = 0;
402 if (unicode != (uint32_t) -1) {
403 len = _cairo_ucs4_to_utf8 (unicode, buf);
404 if (len > 0) {
405 *utf8_out = malloc (len + 1);
406 if (unlikely (*utf8_out == NULL))
407 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
408
409 memcpy (*utf8_out, buf, len);
410 (*utf8_out)[len] = 0;
411 *utf8_len_out = len;
412 }
413 }
414
415 return CAIRO_STATUS_SUCCESS;
416 }
417
418 static cairo_status_t
419 _cairo_sub_font_glyph_map_to_unicode (cairo_sub_font_glyph_t *sub_font_glyph,
420 const char *utf8,
421 int utf8_len,
422 cairo_bool_t *is_mapped)
423 {
424 *is_mapped = FALSE;
425
426 if (utf8_len < 0)
427 return CAIRO_STATUS_SUCCESS;
428
429 if (utf8 != NULL && utf8_len != 0 && utf8[utf8_len - 1] == '\0')
430 utf8_len--;
431
432 if (utf8 != NULL && utf8_len != 0) {
433 if (sub_font_glyph->utf8 != NULL) {
434 if (utf8_len == sub_font_glyph->utf8_len &&
435 memcmp (utf8, sub_font_glyph->utf8, utf8_len) == 0)
436 {
437 /* Requested utf8 mapping matches the existing mapping */
438 *is_mapped = TRUE;
439 }
440 } else {
441 /* No existing mapping. Use the requested mapping */
442 sub_font_glyph->utf8 = malloc (utf8_len + 1);
443 if (unlikely (sub_font_glyph->utf8 == NULL))
444 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
445
446 memcpy (sub_font_glyph->utf8, utf8, utf8_len);
447 sub_font_glyph->utf8[utf8_len] = 0;
448 sub_font_glyph->utf8_len = utf8_len;
449 *is_mapped = TRUE;
450 }
451 }
452
453 return CAIRO_STATUS_SUCCESS;
454 }
455
456 static cairo_int_status_t
457 _cairo_sub_font_lookup_glyph (cairo_sub_font_t *sub_font,
458 unsigned long scaled_font_glyph_index,
459 const char *utf8,
460 int utf8_len,
461 cairo_scaled_font_subsets_glyph_t *subset_glyph)
462 {
463 cairo_sub_font_glyph_t key, *sub_font_glyph;
464 cairo_int_status_t status;
465
466 _cairo_sub_font_glyph_init_key (&key, scaled_font_glyph_index);
467 sub_font_glyph = _cairo_hash_table_lookup (sub_font->sub_font_glyphs,
468 &key.base);
469 if (sub_font_glyph != NULL) {
470 subset_glyph->font_id = sub_font->font_id;
471 subset_glyph->subset_id = sub_font_glyph->subset_id;
472 if (sub_font_glyph->is_latin)
473 subset_glyph->subset_glyph_index = sub_font_glyph->latin_character;
474 else
475 subset_glyph->subset_glyph_index = sub_font_glyph->subset_glyph_index;
476
477 subset_glyph->is_scaled = sub_font->is_scaled;
478 subset_glyph->is_composite = sub_font->is_composite;
479 subset_glyph->is_latin = sub_font_glyph->is_latin;
480 subset_glyph->x_advance = sub_font_glyph->x_advance;
481 subset_glyph->y_advance = sub_font_glyph->y_advance;
482 status = _cairo_sub_font_glyph_map_to_unicode (sub_font_glyph,
483 utf8, utf8_len,
484 &subset_glyph->utf8_is_mapped);
485 subset_glyph->unicode = sub_font_glyph->unicode;
486
487 return status;
488 }
489
490 return CAIRO_INT_STATUS_UNSUPPORTED;
491 }
492
493 static cairo_status_t
494 _cairo_sub_font_add_glyph (cairo_sub_font_t *sub_font,
495 unsigned long scaled_font_glyph_index,
496 cairo_bool_t is_latin,
497 int latin_character,
498 uint32_t unicode,
499 char *utf8,
500 int utf8_len,
501 cairo_sub_font_glyph_t **sub_font_glyph_out)
502 {
503 cairo_scaled_glyph_t *scaled_glyph;
504 cairo_sub_font_glyph_t *sub_font_glyph;
505 int *num_glyphs_in_subset_ptr;
506 double x_advance;
507 double y_advance;
508 cairo_int_status_t status;
509
510 _cairo_scaled_font_freeze_cache (sub_font->scaled_font);
511 status = _cairo_scaled_glyph_lookup (sub_font->scaled_font,
512 scaled_font_glyph_index,
513 CAIRO_SCALED_GLYPH_INFO_METRICS,
514 &scaled_glyph);
515 assert (status != CAIRO_INT_STATUS_UNSUPPORTED);
516 if (unlikely (status)) {
517 _cairo_scaled_font_thaw_cache (sub_font->scaled_font);
518 return status;
519 }
520
521 x_advance = scaled_glyph->metrics.x_advance;
522 y_advance = scaled_glyph->metrics.y_advance;
523 _cairo_scaled_font_thaw_cache (sub_font->scaled_font);
524
525 if (!is_latin && sub_font->num_glyphs_in_current_subset == sub_font->max_glyphs_per_subset)
526 {
527 sub_font->current_subset++;
528 sub_font->num_glyphs_in_current_subset = 0;
529 }
530
531 if (is_latin)
532 num_glyphs_in_subset_ptr = &sub_font->num_glyphs_in_latin_subset;
533 else
534 num_glyphs_in_subset_ptr = &sub_font->num_glyphs_in_current_subset;
535
536 /* Reserve first glyph in subset for the .notdef glyph except for
537 * Type 3 fonts */
538 if (*num_glyphs_in_subset_ptr == 0 &&
539 scaled_font_glyph_index != 0 &&
540 ! _cairo_font_face_is_user (sub_font->scaled_font->font_face))
541 {
542 status = _cairo_sub_font_add_glyph (sub_font,
543 0,
544 is_latin,
545 0,
546 0,
547 NULL,
548 -1,
549 &sub_font_glyph);
550 if (unlikely (status))
551 return status;
552 }
553
554 sub_font_glyph = _cairo_sub_font_glyph_create (scaled_font_glyph_index,
555 is_latin ? 0 : sub_font->current_subset,
556 *num_glyphs_in_subset_ptr,
557 x_advance,
558 y_advance,
559 is_latin ? latin_character : -1,
560 unicode,
561 utf8,
562 utf8_len);
563
564 if (unlikely (sub_font_glyph == NULL))
565 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
566
567 status = _cairo_hash_table_insert (sub_font->sub_font_glyphs, &sub_font_glyph->base);
568 if (unlikely (status)) {
569 _cairo_sub_font_glyph_destroy (sub_font_glyph);
570 return status;
571 }
572
573 (*num_glyphs_in_subset_ptr)++;
574 if (sub_font->is_scaled) {
575 if (*num_glyphs_in_subset_ptr > sub_font->parent->max_glyphs_per_scaled_subset_used)
576 sub_font->parent->max_glyphs_per_scaled_subset_used = *num_glyphs_in_subset_ptr;
577 } else {
578 if (*num_glyphs_in_subset_ptr > sub_font->parent->max_glyphs_per_unscaled_subset_used)
579 sub_font->parent->max_glyphs_per_unscaled_subset_used = *num_glyphs_in_subset_ptr;
580 }
581
582 *sub_font_glyph_out = sub_font_glyph;
583
584 return CAIRO_STATUS_SUCCESS;
585 }
586
587 static cairo_status_t
588 _cairo_sub_font_map_glyph (cairo_sub_font_t *sub_font,
589 unsigned long scaled_font_glyph_index,
590 const char *text_utf8,
591 int text_utf8_len,
592 cairo_scaled_font_subsets_glyph_t *subset_glyph)
593 {
594 cairo_sub_font_glyph_t key, *sub_font_glyph;
595 cairo_status_t status;
596
597 _cairo_sub_font_glyph_init_key (&key, scaled_font_glyph_index);
598 sub_font_glyph = _cairo_hash_table_lookup (sub_font->sub_font_glyphs,
599 &key.base);
600 if (sub_font_glyph == NULL) {
601 uint32_t font_unicode;
602 char *font_utf8;
603 int font_utf8_len;
604 cairo_bool_t is_latin;
605 int latin_character;
606
607 status = _cairo_sub_font_glyph_lookup_unicode (sub_font->scaled_font,
608 scaled_font_glyph_index,
609 &font_unicode,
610 &font_utf8,
611 &font_utf8_len);
612 if (unlikely(status))
613 return status;
614
615 /* If the supplied utf8 is a valid single character, use it
616 * instead of the font lookup */
617 if (text_utf8 != NULL && text_utf8_len > 0) {
618 uint32_t *ucs4;
619 int ucs4_len;
620
621 status = _cairo_utf8_to_ucs4 (text_utf8, text_utf8_len,
622 &ucs4, &ucs4_len);
623 if (status == CAIRO_STATUS_SUCCESS) {
624 if (ucs4_len == 1) {
625 font_unicode = ucs4[0];
626 free (font_utf8);
627 font_utf8 = malloc (text_utf8_len + 1);
628 if (font_utf8 == NULL) {
629 free (ucs4);
630 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
631 }
632 memcpy (font_utf8, text_utf8, text_utf8_len);
633 font_utf8[text_utf8_len] = 0;
634 font_utf8_len = text_utf8_len;
635 }
636 free (ucs4);
637 }
638 }
639
640 /* If glyph is in the winansi encoding and font is not a user
641 * font, put glyph in the latin subset. If glyph is .notdef
642 * the latin subset is preferred but only if the latin subset
643 * already contains at least one glyph. We don't want to
644 * create a separate subset just for the .notdef glyph.
645 */
646 is_latin = FALSE;
647 latin_character = -1;
648 if (sub_font->use_latin_subset &&
649 (! _cairo_font_face_is_user (sub_font->scaled_font->font_face)))
650 {
651 latin_character = _cairo_unicode_to_winansi (font_unicode);
652 if (latin_character > 0 ||
653 (latin_character == 0 && sub_font->num_glyphs_in_latin_subset > 0))
654 {
655 if (!sub_font->latin_char_map[latin_character]) {
656 sub_font->latin_char_map[latin_character] = TRUE;
657 is_latin = TRUE;
658 }
659 }
660 }
661
662 status = _cairo_sub_font_add_glyph (sub_font,
663 scaled_font_glyph_index,
664 is_latin,
665 latin_character,
666 font_unicode,
667 font_utf8,
668 font_utf8_len,
669 &sub_font_glyph);
670 if (unlikely(status))
671 return status;
672 }
673
674 subset_glyph->font_id = sub_font->font_id;
675 subset_glyph->subset_id = sub_font_glyph->subset_id;
676 if (sub_font_glyph->is_latin)
677 subset_glyph->subset_glyph_index = sub_font_glyph->latin_character;
678 else
679 subset_glyph->subset_glyph_index = sub_font_glyph->subset_glyph_index;
680
681 subset_glyph->is_scaled = sub_font->is_scaled;
682 subset_glyph->is_composite = sub_font->is_composite;
683 subset_glyph->is_latin = sub_font_glyph->is_latin;
684 subset_glyph->x_advance = sub_font_glyph->x_advance;
685 subset_glyph->y_advance = sub_font_glyph->y_advance;
686 status = _cairo_sub_font_glyph_map_to_unicode (sub_font_glyph,
687 text_utf8, text_utf8_len,
688 &subset_glyph->utf8_is_mapped);
689 subset_glyph->unicode = sub_font_glyph->unicode;
690
691 return status;
692 }
693
694 static void
695 _cairo_sub_font_collect (void *entry, void *closure)
696 {
697 cairo_sub_font_t *sub_font = entry;
698 cairo_sub_font_collection_t *collection = closure;
699 cairo_scaled_font_subset_t subset;
700 int i;
701 unsigned int j;
702
703 if (collection->status)
704 return;
705
706 collection->status = sub_font->scaled_font->status;
707 if (collection->status)
708 return;
709
710 for (i = 0; i <= sub_font->current_subset; i++) {
711 collection->subset_id = i;
712 collection->num_glyphs = 0;
713 collection->max_glyph = 0;
714 memset (collection->latin_to_subset_glyph_index, 0, 256*sizeof(unsigned long));
715
716 _cairo_hash_table_foreach (sub_font->sub_font_glyphs,
717 _cairo_sub_font_glyph_collect, collection);
718 if (collection->status)
719 break;
720 if (collection->num_glyphs == 0)
721 continue;
722
723 /* Ensure the resulting array has no uninitialized holes */
724 assert (collection->num_glyphs == collection->max_glyph + 1);
725
726 subset.scaled_font = sub_font->scaled_font;
727 subset.is_composite = sub_font->is_composite;
728 subset.is_scaled = sub_font->is_scaled;
729 subset.font_id = sub_font->font_id;
730 subset.subset_id = i;
731 subset.glyphs = collection->glyphs;
732 subset.utf8 = collection->utf8;
733 subset.num_glyphs = collection->num_glyphs;
734 subset.glyph_names = NULL;
735
736 subset.is_latin = FALSE;
737 if (sub_font->use_latin_subset && i == 0) {
738 subset.is_latin = TRUE;
739 subset.to_latin_char = collection->to_latin_char;
740 subset.latin_to_subset_glyph_index = collection->latin_to_subset_glyph_index;
741 } else {
742 subset.to_latin_char = NULL;
743 subset.latin_to_subset_glyph_index = NULL;
744 }
745
746 collection->status = (collection->font_subset_callback) (&subset,
747 collection->font_subset_callback_closure);
748
749 if (subset.glyph_names != NULL) {
750 for (j = 0; j < collection->num_glyphs; j++)
751 free (subset.glyph_names[j]);
752 free (subset.glyph_names);
753 }
754
755 if (collection->status)
756 break;
757 }
758 }
759
760 static cairo_scaled_font_subsets_t *
761 _cairo_scaled_font_subsets_create_internal (cairo_subsets_type_t type)
762 {
763 cairo_scaled_font_subsets_t *subsets;
764
765 subsets = malloc (sizeof (cairo_scaled_font_subsets_t));
766 if (unlikely (subsets == NULL)) {
767 _cairo_error_throw (CAIRO_STATUS_NO_MEMORY);
768 return NULL;
769 }
770
771 subsets->type = type;
772 subsets->use_latin_subset = FALSE;
773 subsets->max_glyphs_per_unscaled_subset_used = 0;
774 subsets->max_glyphs_per_scaled_subset_used = 0;
775 subsets->num_sub_fonts = 0;
776
777 subsets->unscaled_sub_fonts = _cairo_hash_table_create (_cairo_sub_fonts_equal);
778 if (! subsets->unscaled_sub_fonts) {
779 free (subsets);
780 return NULL;
781 }
782 subsets->unscaled_sub_fonts_list = NULL;
783 subsets->unscaled_sub_fonts_list_end = NULL;
784
785 subsets->scaled_sub_fonts = _cairo_hash_table_create (_cairo_sub_fonts_equal);
786 if (! subsets->scaled_sub_fonts) {
787 _cairo_hash_table_destroy (subsets->unscaled_sub_fonts);
788 free (subsets);
789 return NULL;
790 }
791 subsets->scaled_sub_fonts_list = NULL;
792 subsets->scaled_sub_fonts_list_end = NULL;
793
794 return subsets;
795 }
796
797 cairo_scaled_font_subsets_t *
798 _cairo_scaled_font_subsets_create_scaled (void)
799 {
800 return _cairo_scaled_font_subsets_create_internal (CAIRO_SUBSETS_SCALED);
801 }
802
803 cairo_scaled_font_subsets_t *
804 _cairo_scaled_font_subsets_create_simple (void)
805 {
806 return _cairo_scaled_font_subsets_create_internal (CAIRO_SUBSETS_SIMPLE);
807 }
808
809 cairo_scaled_font_subsets_t *
810 _cairo_scaled_font_subsets_create_composite (void)
811 {
812 return _cairo_scaled_font_subsets_create_internal (CAIRO_SUBSETS_COMPOSITE);
813 }
814
815 void
816 _cairo_scaled_font_subsets_destroy (cairo_scaled_font_subsets_t *subsets)
817 {
818 _cairo_hash_table_foreach (subsets->scaled_sub_fonts, _cairo_sub_font_pluck, subsets->scaled_sub_fonts);
819 _cairo_hash_table_destroy (subsets->scaled_sub_fonts);
820
821 _cairo_hash_table_foreach (subsets->unscaled_sub_fonts, _cairo_sub_font_pluck, subsets->unscaled_sub_fonts);
822 _cairo_hash_table_destroy (subsets->unscaled_sub_fonts);
823
824 free (subsets);
825 }
826
827 void
828 _cairo_scaled_font_subsets_enable_latin_subset (cairo_scaled_font_subsets_t *font_subsets,
829 cairo_bool_t use_latin)
830 {
831 font_subsets->use_latin_subset = use_latin;
832 }
833
834 cairo_status_t
835 _cairo_scaled_font_subsets_map_glyph (cairo_scaled_font_subsets_t *subsets,
836 cairo_scaled_font_t *scaled_font,
837 unsigned long scaled_font_glyph_index,
838 const char * utf8,
839 int utf8_len,
840 cairo_scaled_font_subsets_glyph_t *subset_glyph)
841 {
842 cairo_sub_font_t key, *sub_font;
843 cairo_scaled_glyph_t *scaled_glyph;
844 cairo_font_face_t *font_face;
845 cairo_matrix_t identity;
846 cairo_font_options_t font_options;
847 cairo_scaled_font_t *unscaled_font;
848 cairo_int_status_t status;
849 int max_glyphs;
850 cairo_bool_t type1_font;
851
852 /* Lookup glyph in unscaled subsets */
853 if (subsets->type != CAIRO_SUBSETS_SCALED) {
854 key.is_scaled = FALSE;
855 _cairo_sub_font_init_key (&key, scaled_font);
856 sub_font = _cairo_hash_table_lookup (subsets->unscaled_sub_fonts,
857 &key.base);
858 if (sub_font != NULL) {
859 status = _cairo_sub_font_lookup_glyph (sub_font,
860 scaled_font_glyph_index,
861 utf8, utf8_len,
862 subset_glyph);
863 if (status != CAIRO_INT_STATUS_UNSUPPORTED)
864 return status;
865 }
866 }
867
868 /* Lookup glyph in scaled subsets */
869 key.is_scaled = TRUE;
870 _cairo_sub_font_init_key (&key, scaled_font);
871 sub_font = _cairo_hash_table_lookup (subsets->scaled_sub_fonts,
872 &key.base);
873 if (sub_font != NULL) {
874 status = _cairo_sub_font_lookup_glyph (sub_font,
875 scaled_font_glyph_index,
876 utf8, utf8_len,
877 subset_glyph);
878 if (status != CAIRO_INT_STATUS_UNSUPPORTED)
879 return status;
880 }
881
882 /* Glyph not found. Determine whether the glyph is outline or
883 * bitmap and add to the appropriate subset.
884 *
885 * glyph_index 0 (the .notdef glyph) is a special case. Some fonts
886 * will return CAIRO_INT_STATUS_UNSUPPORTED when doing a
887 * _scaled_glyph_lookup(_GLYPH_INFO_PATH). Type1-fallback creates
888 * empty glyphs in this case so we can put the glyph in a unscaled
889 * subset. */
890 if (scaled_font_glyph_index == 0 ||
891 _cairo_font_face_is_user (scaled_font->font_face)) {
892 status = CAIRO_STATUS_SUCCESS;
893 } else {
894 _cairo_scaled_font_freeze_cache (scaled_font);
895 status = _cairo_scaled_glyph_lookup (scaled_font,
896 scaled_font_glyph_index,
897 CAIRO_SCALED_GLYPH_INFO_PATH,
898 &scaled_glyph);
899 _cairo_scaled_font_thaw_cache (scaled_font);
900 }
901 if (_cairo_int_status_is_error (status))
902 return status;
903
904 if (status == CAIRO_INT_STATUS_SUCCESS &&
905 subsets->type != CAIRO_SUBSETS_SCALED &&
906 ! _cairo_font_face_is_user (scaled_font->font_face))
907 {
908 /* Path available. Add to unscaled subset. */
909 key.is_scaled = FALSE;
910 _cairo_sub_font_init_key (&key, scaled_font);
911 sub_font = _cairo_hash_table_lookup (subsets->unscaled_sub_fonts,
912 &key.base);
913 if (sub_font == NULL) {
914 font_face = cairo_scaled_font_get_font_face (scaled_font);
915 cairo_matrix_init_identity (&identity);
916 _cairo_font_options_init_default (&font_options);
917 cairo_font_options_set_hint_style (&font_options, CAIRO_HINT_STYLE_NONE);
918 cairo_font_options_set_hint_metrics (&font_options, CAIRO_HINT_METRICS_OFF);
919 unscaled_font = cairo_scaled_font_create (font_face,
920 &identity,
921 &identity,
922 &font_options);
923 if (unlikely (unscaled_font->status))
924 return unscaled_font->status;
925
926 subset_glyph->is_scaled = FALSE;
927 type1_font = _cairo_type1_scaled_font_is_type1 (unscaled_font);
928 if (subsets->type == CAIRO_SUBSETS_COMPOSITE && !type1_font) {
929 max_glyphs = MAX_GLYPHS_PER_COMPOSITE_FONT;
930 subset_glyph->is_composite = TRUE;
931 } else {
932 max_glyphs = MAX_GLYPHS_PER_SIMPLE_FONT;
933 subset_glyph->is_composite = FALSE;
934 }
935
936 status = _cairo_sub_font_create (subsets,
937 unscaled_font,
938 subsets->num_sub_fonts,
939 max_glyphs,
940 subset_glyph->is_scaled,
941 subset_glyph->is_composite,
942 &sub_font);
943
944 if (unlikely (status)) {
945 cairo_scaled_font_destroy (unscaled_font);
946 return status;
947 }
948
949 status = _cairo_hash_table_insert (subsets->unscaled_sub_fonts,
950 &sub_font->base);
951
952 if (unlikely (status)) {
953 _cairo_sub_font_destroy (sub_font);
954 return status;
955 }
956 if (!subsets->unscaled_sub_fonts_list)
957 subsets->unscaled_sub_fonts_list = sub_font;
958 else
959 subsets->unscaled_sub_fonts_list_end->next = sub_font;
960 subsets->unscaled_sub_fonts_list_end = sub_font;
961 subsets->num_sub_fonts++;
962 }
963 } else {
964 /* No path available. Add to scaled subset. */
965 key.is_scaled = TRUE;
966 _cairo_sub_font_init_key (&key, scaled_font);
967 sub_font = _cairo_hash_table_lookup (subsets->scaled_sub_fonts,
968 &key.base);
969 if (sub_font == NULL) {
970 subset_glyph->is_scaled = TRUE;
971 subset_glyph->is_composite = FALSE;
972 if (subsets->type == CAIRO_SUBSETS_SCALED)
973 max_glyphs = INT_MAX;
974 else
975 max_glyphs = MAX_GLYPHS_PER_SIMPLE_FONT;
976
977 status = _cairo_sub_font_create (subsets,
978 cairo_scaled_font_reference (scaled_font),
979 subsets->num_sub_fonts,
980 max_glyphs,
981 subset_glyph->is_scaled,
982 subset_glyph->is_composite,
983 &sub_font);
984 if (unlikely (status)) {
985 cairo_scaled_font_destroy (scaled_font);
986 return status;
987 }
988
989 status = _cairo_hash_table_insert (subsets->scaled_sub_fonts,
990 &sub_font->base);
991 if (unlikely (status)) {
992 _cairo_sub_font_destroy (sub_font);
993 return status;
994 }
995 if (!subsets->scaled_sub_fonts_list)
996 subsets->scaled_sub_fonts_list = sub_font;
997 else
998 subsets->scaled_sub_fonts_list_end->next = sub_font;
999 subsets->scaled_sub_fonts_list_end = sub_font;
1000 subsets->num_sub_fonts++;
1001 }
1002 }
1003
1004 return _cairo_sub_font_map_glyph (sub_font,
1005 scaled_font_glyph_index,
1006 utf8, utf8_len,
1007 subset_glyph);
1008 }
1009
1010 static cairo_status_t
1011 _cairo_scaled_font_subsets_foreach_internal (cairo_scaled_font_subsets_t *font_subsets,
1012 cairo_scaled_font_subset_callback_func_t font_subset_callback,
1013 void *closure,
1014 cairo_subsets_foreach_type_t type)
1015 {
1016 cairo_sub_font_collection_t collection;
1017 cairo_sub_font_t *sub_font;
1018 cairo_bool_t is_scaled, is_user;
1019
1020 is_scaled = FALSE;
1021 is_user = FALSE;
1022
1023 if (type == CAIRO_SUBSETS_FOREACH_USER)
1024 is_user = TRUE;
1025
1026 if (type == CAIRO_SUBSETS_FOREACH_SCALED ||
1027 type == CAIRO_SUBSETS_FOREACH_USER)
1028 {
1029 is_scaled = TRUE;
1030 }
1031
1032 if (is_scaled)
1033 collection.glyphs_size = font_subsets->max_glyphs_per_scaled_subset_used;
1034 else
1035 collection.glyphs_size = font_subsets->max_glyphs_per_unscaled_subset_used;
1036
1037 if (! collection.glyphs_size)
1038 return CAIRO_STATUS_SUCCESS;
1039
1040 collection.glyphs = _cairo_malloc_ab (collection.glyphs_size, sizeof(unsigned long));
1041 collection.utf8 = _cairo_malloc_ab (collection.glyphs_size, sizeof(char *));
1042 collection.to_latin_char = _cairo_malloc_ab (collection.glyphs_size, sizeof(int));
1043 collection.latin_to_subset_glyph_index = _cairo_malloc_ab (256, sizeof(unsigned long));
1044 if (unlikely (collection.glyphs == NULL ||
1045 collection.utf8 == NULL ||
1046 collection.to_latin_char == NULL ||
1047 collection.latin_to_subset_glyph_index == NULL)) {
1048 free (collection.glyphs);
1049 free (collection.utf8);
1050 free (collection.to_latin_char);
1051 free (collection.latin_to_subset_glyph_index);
1052
1053 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
1054 }
1055
1056 collection.font_subset_callback = font_subset_callback;
1057 collection.font_subset_callback_closure = closure;
1058 collection.status = CAIRO_STATUS_SUCCESS;
1059
1060 if (is_scaled)
1061 sub_font = font_subsets->scaled_sub_fonts_list;
1062 else
1063 sub_font = font_subsets->unscaled_sub_fonts_list;
1064
1065 while (sub_font) {
1066 if (sub_font->is_user == is_user)
1067 _cairo_sub_font_collect (sub_font, &collection);
1068
1069 sub_font = sub_font->next;
1070 }
1071 free (collection.utf8);
1072 free (collection.glyphs);
1073 free (collection.to_latin_char);
1074 free (collection.latin_to_subset_glyph_index);
1075
1076 return collection.status;
1077 }
1078
1079 cairo_status_t
1080 _cairo_scaled_font_subsets_foreach_scaled (cairo_scaled_font_subsets_t *font_subsets,
1081 cairo_scaled_font_subset_callback_func_t font_subset_callback,
1082 void *closure)
1083 {
1084 return _cairo_scaled_font_subsets_foreach_internal (font_subsets,
1085 font_subset_callback,
1086 closure,
1087 CAIRO_SUBSETS_FOREACH_SCALED);
1088 }
1089
1090 cairo_status_t
1091 _cairo_scaled_font_subsets_foreach_unscaled (cairo_scaled_font_subsets_t *font_subsets,
1092 cairo_scaled_font_subset_callback_func_t font_subset_callback,
1093 void *closure)
1094 {
1095 return _cairo_scaled_font_subsets_foreach_internal (font_subsets,
1096 font_subset_callback,
1097 closure,
1098 CAIRO_SUBSETS_FOREACH_UNSCALED);
1099 }
1100
1101 cairo_status_t
1102 _cairo_scaled_font_subsets_foreach_user (cairo_scaled_font_subsets_t *font_subsets,
1103 cairo_scaled_font_subset_callback_func_t font_subset_callback,
1104 void *closure)
1105 {
1106 return _cairo_scaled_font_subsets_foreach_internal (font_subsets,
1107 font_subset_callback,
1108 closure,
1109 CAIRO_SUBSETS_FOREACH_USER);
1110 }
1111
1112 static cairo_bool_t
1113 _cairo_string_equal (const void *key_a, const void *key_b)
1114 {
1115 const cairo_string_entry_t *a = key_a;
1116 const cairo_string_entry_t *b = key_b;
1117
1118 if (strcmp (a->string, b->string) == 0)
1119 return TRUE;
1120 else
1121 return FALSE;
1122 }
1123
1124 static void
1125 _cairo_string_init_key (cairo_string_entry_t *key, char *s)
1126 {
1127 unsigned long sum = 0;
1128 unsigned int i;
1129
1130 for (i = 0; i < strlen(s); i++)
1131 sum += s[i];
1132 key->base.hash = sum;
1133 key->string = s;
1134 }
1135
1136 static cairo_status_t
1137 create_string_entry (char *s, cairo_string_entry_t **entry)
1138 {
1139 *entry = malloc (sizeof (cairo_string_entry_t));
1140 if (unlikely (*entry == NULL))
1141 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
1142
1143 _cairo_string_init_key (*entry, s);
1144
1145 return CAIRO_STATUS_SUCCESS;
1146 }
1147
1148 static void
1149 _pluck_entry (void *entry, void *closure)
1150 {
1151 _cairo_hash_table_remove (closure, entry);
1152 free (entry);
1153 }
1154
1155 cairo_int_status_t
1156 _cairo_scaled_font_subset_create_glyph_names (cairo_scaled_font_subset_t *subset)
1157 {
1158 unsigned int i;
1159 cairo_hash_table_t *names;
1160 cairo_string_entry_t key, *entry;
1161 char buf[30];
1162 char *utf8;
1163 uint16_t *utf16;
1164 int utf16_len;
1165 cairo_status_t status = CAIRO_STATUS_SUCCESS;
1166
1167 names = _cairo_hash_table_create (_cairo_string_equal);
1168 if (unlikely (names == NULL))
1169 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
1170
1171 subset->glyph_names = calloc (subset->num_glyphs, sizeof (char *));
1172 if (unlikely (subset->glyph_names == NULL)) {
1173 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
1174 goto CLEANUP_HASH;
1175 }
1176
1177 i = 0;
1178 if (! subset->is_scaled) {
1179 subset->glyph_names[0] = strdup (".notdef");
1180 if (unlikely (subset->glyph_names[0] == NULL)) {
1181 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
1182 goto CLEANUP_HASH;
1183 }
1184
1185 status = create_string_entry (subset->glyph_names[0], &entry);
1186 if (unlikely (status))
1187 goto CLEANUP_HASH;
1188
1189 status = _cairo_hash_table_insert (names, &entry->base);
1190 if (unlikely (status)) {
1191 free (entry);
1192 goto CLEANUP_HASH;
1193 }
1194 i++;
1195 }
1196
1197 for (; i < subset->num_glyphs; i++) {
1198 utf8 = subset->utf8[i];
1199 utf16 = NULL;
1200 utf16_len = 0;
1201 if (utf8 && *utf8) {
1202 status = _cairo_utf8_to_utf16 (utf8, -1, &utf16, &utf16_len);
1203 if (unlikely (status))
1204 goto CLEANUP_HASH;
1205 }
1206
1207 if (utf16_len == 1) {
1208 int ch = _cairo_unicode_to_winansi (utf16[0]);
1209 if (ch > 0 && _cairo_winansi_to_glyphname (ch)) {
1210 strncpy (buf, _cairo_winansi_to_glyphname (ch), sizeof (buf));
1211 buf[sizeof (buf)-1] = '\0';
1212 } else {
1213 snprintf (buf, sizeof (buf), "uni%04X", (int) utf16[0]);
1214 }
1215
1216 _cairo_string_init_key (&key, buf);
1217 entry = _cairo_hash_table_lookup (names, &key.base);
1218 if (entry != NULL)
1219 snprintf (buf, sizeof (buf), "g%d", i);
1220 } else {
1221 snprintf (buf, sizeof (buf), "g%d", i);
1222 }
1223 free (utf16);
1224
1225 subset->glyph_names[i] = strdup (buf);
1226 if (unlikely (subset->glyph_names[i] == NULL)) {
1227 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
1228 goto CLEANUP_HASH;
1229 }
1230
1231 status = create_string_entry (subset->glyph_names[i], &entry);
1232 if (unlikely (status))
1233 goto CLEANUP_HASH;
1234
1235 status = _cairo_hash_table_insert (names, &entry->base);
1236 if (unlikely (status)) {
1237 free (entry);
1238 goto CLEANUP_HASH;
1239 }
1240 }
1241
1242 CLEANUP_HASH:
1243 _cairo_hash_table_foreach (names, _pluck_entry, names);
1244 _cairo_hash_table_destroy (names);
1245
1246 if (likely (status == CAIRO_STATUS_SUCCESS))
1247 return CAIRO_STATUS_SUCCESS;
1248
1249 if (subset->glyph_names != NULL) {
1250 for (i = 0; i < subset->num_glyphs; i++) {
1251 free (subset->glyph_names[i]);
1252 }
1253
1254 free (subset->glyph_names);
1255 subset->glyph_names = NULL;
1256 }
1257
1258 return status;
1259 }
1260
1261 cairo_int_status_t
1262 _cairo_escape_ps_name (char **ps_name)
1263 {
1264 cairo_status_t status = CAIRO_STATUS_SUCCESS;
1265
1266 /* Ensure PS name is a valid PDF/PS name object. In PDF names are
1267 * treated as UTF8 and non ASCII bytes, ' ', and '#' are encoded
1268 * as '#' followed by 2 hex digits that encode the byte. By also
1269 * encoding the characters in the reserved string we ensure the
1270 * name is also PS compatible. */
1271 if (*ps_name) {
1272 static const char *reserved = "()<>[]{}/%#\\";
1273 char buf[128]; /* max name length is 127 bytes */
1274 char *src = *ps_name;
1275 char *dst = buf;
1276
1277 while (*src && dst < buf + 127) {
1278 unsigned char c = *src;
1279 if (c < 0x21 || c > 0x7e || strchr (reserved, c)) {
1280 if (dst + 4 > buf + 127)
1281 break;
1282
1283 snprintf (dst, 4, "#%02X", c);
1284 src++;
1285 dst += 3;
1286 } else {
1287 *dst++ = *src++;
1288 }
1289 }
1290 *dst = 0;
1291 free (*ps_name);
1292 *ps_name = strdup (buf);
1293 if (*ps_name == NULL) {
1294 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
1295 }
1296 }
1297
1298 return status;
1299 }
1300
1301 #endif /* CAIRO_HAS_FONT_SUBSET */
LuaTeX git mirror