WebSVN – Kolibri OS – Diff – /programs/develop/libraries/cairo/src/cairo-truetype-subset.c

  * http://www.microsoft.com/typography/specs/default.htm
  */
 #define _BSD_SOURCE /* for snprintf(), strdup() */
+#include "cairoint.h"
-#include "cairoint.h"
+#include "cairo-array-private.h"
 #include "cairo-error-private.h"
     cairo_array_t string_offsets;
     unsigned long last_offset;
     unsigned long last_boundary;
     int *parent_to_subset;
     cairo_status_t status;
+    cairo_bool_t is_pdf;
 };
 /*
  * Test that the structs we define for TrueType tables have the
 static cairo_status_t
 _cairo_truetype_font_set_error (cairo_truetype_font_t *font,
 			        cairo_status_t status)
+{
-{
+    if (status == CAIRO_STATUS_SUCCESS ||
-    if (status == CAIRO_STATUS_SUCCESS || status == CAIRO_INT_STATUS_UNSUPPORTED)
+	status == (int)CAIRO_INT_STATUS_UNSUPPORTED)
 	return status;
     _cairo_status_set_error (&font->status, status);
     return _cairo_error (status);
+}
 static cairo_status_t
-static cairo_status_t
+_cairo_truetype_font_create (cairo_scaled_font_subset_t  *scaled_font_subset,
-_cairo_truetype_font_create (cairo_scaled_font_subset_t  *scaled_font_subset,
+			     cairo_bool_t is_pdf,
 			     cairo_truetype_font_t      **font_return)
+     *
      *  if (cairo_font_options_get_vertical_layout (scaled_font_subset->scaled_font))
      *   return CAIRO_INT_STATUS_UNSUPPORTED;
      */
+    /* We need to use a fallback font generated from the synthesized outlines. */
+    if (backend->is_synthetic && backend->is_synthetic (scaled_font_subset->scaled_font))
+       return CAIRO_INT_STATUS_UNSUPPORTED;
     size = sizeof (tt_head_t);
     status = backend->load_truetype_table (scaled_font_subset->scaled_font,
                                           TT_TAG_head, 0,
 					  (unsigned char *) &head,
     if (unlikely (font->parent_to_subset == NULL)) {
 	status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
 	goto fail2;
+    }
     font->is_pdf = is_pdf;
     font->base.num_glyphs = 0;
     font->base.x_min = (int16_t) be16_to_cpu (head.x_min);
     font->base.y_min = (int16_t) be16_to_cpu (head.y_min);
     font->base.x_max = (int16_t) be16_to_cpu (head.x_max);
     free (font->base.widths);
  fail4:
     free (font->base.ps_name);
  fail3:
     free (font->parent_to_subset);
-    if (font->base.font_name)
-	free (font->base.font_name);
+    free (font->base.font_name);
  fail2:
     free (font->glyphs);
  fail1:
     _cairo_array_fini (&font->output);
 cairo_truetype_font_destroy (cairo_truetype_font_t *font)
+{
     _cairo_array_fini (&font->string_offsets);
     free (font->base.widths);
     free (font->base.ps_name);
-    if (font->base.font_name)
-	free (font->base.font_name);
+    free (font->base.font_name);
     free (font->parent_to_subset);
     free (font->glyphs);
     _cairo_array_fini (&font->output);
     free (font);
     font->last_boundary = boundary;
     return CAIRO_STATUS_SUCCESS;
+}
+typedef struct _cmap_unicode_range {
+    unsigned int start;
+    unsigned int end;
+} cmap_unicode_range_t;
+static cmap_unicode_range_t winansi_unicode_ranges[] = {
+    { 0x0020, 0x007f },
+    { 0x00a0, 0x00ff },
+    { 0x0152, 0x0153 },
+    { 0x0160, 0x0161 },
+    { 0x0178, 0x0178 },
+    { 0x017d, 0x017e },
+    { 0x0192, 0x0192 },
+    { 0x02c6, 0x02c6 },
+    { 0x02dc, 0x02dc },
+    { 0x2013, 0x2026 },
+    { 0x2030, 0x2030 },
+    { 0x2039, 0x203a },
+    { 0x20ac, 0x20ac },
+    { 0x2122, 0x2122 },
 };
 static cairo_status_t
 cairo_truetype_font_write_cmap_table (cairo_truetype_font_t *font,
+				      unsigned long          tag)
-				      unsigned long          tag)
+{
+    int i;
+    unsigned int j;
+    int range_offset;
+    int num_ranges;
+    int entry_selector;
+    int length;
+    num_ranges = ARRAY_LENGTH (winansi_unicode_ranges);
+    length = 16 + (num_ranges + 1)*8;
+    for (i = 0; i < num_ranges; i++)
+	length += (winansi_unicode_ranges[i].end - winansi_unicode_ranges[i].start + 1)*2;
+    entry_selector = 0;
+    while ((1 << entry_selector) <= (num_ranges + 1))
+	entry_selector++;
-    unsigned int i;
+    entry_selector--;
     cairo_truetype_font_write_be16 (font, 0);  /* Table version */
-    cairo_truetype_font_write_be16 (font, 2);  /* Num tables */
+    cairo_truetype_font_write_be16 (font, 1);  /* Num tables */
-    cairo_truetype_font_write_be16 (font, 3);  /* Platform */
-    cairo_truetype_font_write_be16 (font, 0);  /* Encoding */
-    cairo_truetype_font_write_be32 (font, 20); /* Offset to start of table */
-    cairo_truetype_font_write_be16 (font, 1);  /* Platform */
+    cairo_truetype_font_write_be16 (font, 3);  /* Platform */
-    cairo_truetype_font_write_be16 (font, 0);  /* Encoding */
+    cairo_truetype_font_write_be16 (font, 1);  /* Encoding */
-    cairo_truetype_font_write_be32 (font, 52); /* Offset to start of table */
+    cairo_truetype_font_write_be32 (font, 12); /* Offset to start of table */
-    /* Output a format 4 encoding table. */
+    /* Output a format 4 encoding table for the winansi encoding */
     cairo_truetype_font_write_be16 (font, 4);  /* Format */
+    cairo_truetype_font_write_be16 (font, length); /* Length */
-    cairo_truetype_font_write_be16 (font, 32); /* Length */
+    cairo_truetype_font_write_be16 (font, 0);  /* Version */
-    cairo_truetype_font_write_be16 (font, 0);  /* Version */
+    cairo_truetype_font_write_be16 (font, num_ranges*2 + 2);  /* 2*segcount */
+    cairo_truetype_font_write_be16 (font, (1 << (entry_selector + 1)));  /* searchrange */
-    cairo_truetype_font_write_be16 (font, 4);  /* 2*segcount */
+    cairo_truetype_font_write_be16 (font, entry_selector);  /* entry selector */
+    cairo_truetype_font_write_be16 (font, num_ranges*2 + 2 - (1 << (entry_selector + 1)));  /* rangeshift */
+    for (i = 0; i < num_ranges; i++)
-    cairo_truetype_font_write_be16 (font, 4);  /* searchrange */
+	cairo_truetype_font_write_be16 (font, winansi_unicode_ranges[i].end); /* end count[] */
-    cairo_truetype_font_write_be16 (font, 1);  /* entry selector */
+    cairo_truetype_font_write_be16 (font, 0xffff);  /* end count[] */
+    cairo_truetype_font_write_be16 (font, 0);       /* reserved */
-    cairo_truetype_font_write_be16 (font, 0);  /* rangeshift */
-    cairo_truetype_font_write_be16 (font, 0xf000 + font->base.num_glyphs - 1); /* end count[0] */
+    for (i = 0; i < num_ranges; i++)
+	cairo_truetype_font_write_be16 (font, winansi_unicode_ranges[i].start);  /* startCode[] */
+    cairo_truetype_font_write_be16 (font, 0xffff);  /* startCode[] */
-    cairo_truetype_font_write_be16 (font, 0xffff);  /* end count[1] */
+    for (i = 0; i < num_ranges; i++)
+	cairo_truetype_font_write_be16 (font, 0x0000);  /* delta[] */
+    cairo_truetype_font_write_be16 (font, 1);       /* delta[] */
-    cairo_truetype_font_write_be16 (font, 0);       /* reserved */
-    cairo_truetype_font_write_be16 (font, 0xf000);  /* startCode[0] */
+    range_offset = num_ranges*2 + 2;
+    for (i = 0; i < num_ranges; i++) {
+	cairo_truetype_font_write_be16 (font, range_offset);       /* rangeOffset[] */
-    cairo_truetype_font_write_be16 (font, 0xffff);  /* startCode[1] */
+	range_offset += (winansi_unicode_ranges[i].end - winansi_unicode_ranges[i].start + 1)*2 - 2;
+    }
-    cairo_truetype_font_write_be16 (font, 0x1000);  /* delta[0] */
+    cairo_truetype_font_write_be16 (font, 0);       /* rangeOffset[] */
-    cairo_truetype_font_write_be16 (font, 1);       /* delta[1] */
-    cairo_truetype_font_write_be16 (font, 0);       /* rangeOffset[0] */
+    for (i = 0; i < num_ranges; i++) {
-    cairo_truetype_font_write_be16 (font, 0);       /* rangeOffset[1] */
+	for (j = winansi_unicode_ranges[i].start; j < winansi_unicode_ranges[i].end + 1; j++) {
-    /* Output a format 6 encoding table. */
+	    int ch = _cairo_unicode_to_winansi (j);
-    cairo_truetype_font_write_be16 (font, 6);
+	    int glyph;
+	    if (ch > 0)
-    cairo_truetype_font_write_be16 (font, 10 + 2 * font->base.num_glyphs);
+		glyph = font->scaled_font_subset->latin_to_subset_glyph_index[ch];
-    cairo_truetype_font_write_be16 (font, 0);
+	    else
-    cairo_truetype_font_write_be16 (font, 0); /* First character */
+		glyph = 0;
  * in which the callback functions will be called.
+ *
  * The tables in the table directory must be listed in alphabetical
  * order.  The "cvt", "fpgm", and "prep" are optional tables. They
  * will only be embedded in the subset if they exist in the source
- * font. The pos parameter of cairo_truetype_font_add_truetype_table()
+ * font. "cmap" is only embedded for latin fonts. The pos parameter of
+ * cairo_truetype_font_add_truetype_table() specifies the position of
- * specifies the position of the table in the table directory.
+ * the table in the table directory.
  */
 static void
 cairo_truetype_font_create_truetype_table_list (cairo_truetype_font_t *font)
+{
     cairo_bool_t has_cvt = FALSE;
     int pos;
     size = 0;
     if (font->backend->load_truetype_table (font->scaled_font_subset->scaled_font,
                                       TT_TAG_cvt, 0, NULL,
-                                      &size) == CAIRO_STATUS_SUCCESS)
+                                      &size) == CAIRO_INT_STATUS_SUCCESS)
         has_cvt = TRUE;
     size = 0;
     if (font->backend->load_truetype_table (font->scaled_font_subset->scaled_font,
                                       TT_TAG_fpgm, 0, NULL,
-                                      &size) == CAIRO_STATUS_SUCCESS)
+                                      &size) == CAIRO_INT_STATUS_SUCCESS)
         has_fpgm = TRUE;
     size = 0;
     if (font->backend->load_truetype_table (font->scaled_font_subset->scaled_font,
                                       TT_TAG_prep, 0, NULL,
-                                      &size) == CAIRO_STATUS_SUCCESS)
+                                      &size) == CAIRO_INT_STATUS_SUCCESS)
+        has_prep = TRUE;
-        has_prep = TRUE;
+    font->num_tables = 0;
     pos = 0;
-    font->num_tables = 0;
+    if (font->is_pdf && font->scaled_font_subset->is_latin)
-    pos = 1;
+	pos++;
     if (has_cvt)
         pos++;
+    if (has_fpgm)
-    if (has_fpgm)
+        pos++;
-        pos++;
+    cairo_truetype_font_add_truetype_table (font, TT_TAG_glyf, cairo_truetype_font_write_glyf_table, pos);
     cairo_truetype_font_add_truetype_table (font, TT_TAG_glyf, cairo_truetype_font_write_glyf_table, pos);
     pos = 0;
-    pos = 0;
+    if (font->is_pdf && font->scaled_font_subset->is_latin)
     cairo_truetype_font_add_truetype_table (font, TT_TAG_maxp, cairo_truetype_font_write_maxp_table, pos++);
     if (has_prep)
         cairo_truetype_font_add_truetype_table (font, TT_TAG_prep, cairo_truetype_font_write_generic_table, pos);
+}
-cairo_status_t
+static cairo_status_t
-_cairo_truetype_subset_init (cairo_truetype_subset_t    *truetype_subset,
+cairo_truetype_subset_init_internal (cairo_truetype_subset_t     *truetype_subset,
+				      cairo_scaled_font_subset_t *font_subset,
-			     cairo_scaled_font_subset_t	*font_subset)
+				      cairo_bool_t                is_pdf)
+{
     cairo_truetype_font_t *font = NULL;
     cairo_status_t status;
     const char *data = NULL; /* squelch bogus compiler warning */
     unsigned long length = 0; /* squelch bogus compiler warning */
     unsigned long offsets_length;
     unsigned int i;
     const unsigned long *string_offsets = NULL;
     unsigned long num_strings = 0;
-    status = _cairo_truetype_font_create (font_subset, &font);
+    status = _cairo_truetype_font_create (font_subset, is_pdf, &font);
     if (unlikely (status))
 	return status;
 	status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
 	goto fail1;
+    }
     if (font->base.font_name != NULL) {
-	truetype_subset->font_name = strdup (font->base.font_name);
+	truetype_subset->family_name_utf8 = strdup (font->base.font_name);
-	if (unlikely (truetype_subset->font_name == NULL)) {
+	if (unlikely (truetype_subset->family_name_utf8 == NULL)) {
 	    status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
 	    goto fail2;
+	}
     } else {
-	truetype_subset->font_name = NULL;
+	truetype_subset->family_name_utf8 = NULL;
+    }
     /* The widths array returned must contain only widths for the
  fail5:
     free (truetype_subset->data);
  fail4:
     free (truetype_subset->widths);
  fail3:
-    if (truetype_subset->font_name)
-	free (truetype_subset->font_name);
+    free (truetype_subset->family_name_utf8);
  fail2:
     free (truetype_subset->ps_name);
  fail1:
     cairo_truetype_font_destroy (font);
     return status;
+}
+cairo_status_t
+_cairo_truetype_subset_init_ps (cairo_truetype_subset_t    *truetype_subset,
+				cairo_scaled_font_subset_t	*font_subset)
+{
+    return cairo_truetype_subset_init_internal (truetype_subset, font_subset, FALSE);
+}
+cairo_status_t
+_cairo_truetype_subset_init_pdf (cairo_truetype_subset_t    *truetype_subset,
+				cairo_scaled_font_subset_t	*font_subset)
+{
+    return cairo_truetype_subset_init_internal (truetype_subset, font_subset, TRUE);
+}
 void
 _cairo_truetype_subset_fini (cairo_truetype_subset_t *subset)
-{
-    free (subset->ps_name);
+{
-    if (subset->font_name)
+    free (subset->ps_name);
-	free (subset->font_name);
+    free (subset->family_name_utf8);
     free (subset->widths);
     free (subset->data);
     unsigned long size;
     uint16_t *start_code;
     uint16_t *end_code;
     uint16_t *delta;
     uint16_t *range_offset;
-    uint16_t *glyph_array;
     uint16_t  c;
     backend = scaled_font->backend;
     size = 4;
     end_code = map->endCount;
     start_code = &(end_code[num_segments + 1]);
     delta = &(start_code[num_segments]);
-    range_offset = &(delta[num_segments]);
-    glyph_array = &(range_offset[num_segments]);
+    range_offset = &(delta[num_segments]);
     /* search for glyph in segments with rangeOffset=0 */
     for (i = 0; i < num_segments; i++) {
 cairo_int_status_t
 _cairo_truetype_index_to_ucs4 (cairo_scaled_font_t *scaled_font,
                                unsigned long        index,
                                uint32_t            *ucs4)
+{
-    cairo_status_t status = CAIRO_INT_STATUS_UNSUPPORTED;
+    cairo_int_status_t status = CAIRO_INT_STATUS_UNSUPPORTED;
     const cairo_scaled_font_backend_t *backend;
     tt_cmap_t *cmap;
     char buf[4];
     int num_tables, i;
     unsigned long size;
     free (cmap);
     return status;
+}
+static cairo_status_t
+find_name (tt_name_t *name, int name_id, int platform, int encoding, int language, char **str_out)
+{
+    tt_name_record_t *record;
+    int i, len;
+    char *str;
+    char *p;
+    cairo_bool_t has_tag;
+    cairo_status_t status;
+    str = NULL;
+    for (i = 0; i < be16_to_cpu (name->num_records); i++) {
+        record = &(name->records[i]);
+	if (be16_to_cpu (record->name) == name_id &&
+	    be16_to_cpu (record->platform) == platform &&
+            be16_to_cpu (record->encoding) == encoding &&
+	    (language == -1 || be16_to_cpu (record->language) == language)) {
+	    str = malloc (be16_to_cpu (record->length) + 1);
+	    if (str == NULL)
+		return _cairo_error (CAIRO_STATUS_NO_MEMORY);
+	    len = be16_to_cpu (record->length);
+	    memcpy (str,
+		    ((char*)name) + be16_to_cpu (name->strings_offset) + be16_to_cpu (record->offset),
+		    len);
+	    str[be16_to_cpu (record->length)] = 0;
+	    break;
+	}
+    }
+    if (str == NULL) {
+	*str_out = NULL;
+	return CAIRO_STATUS_SUCCESS;
+    }
+    if (platform == 3) { /* Win platform, unicode encoding */
+	/* convert to utf8 */
+	int size = 0;
+	char *utf8;
+	uint16_t *u = (uint16_t *) str;
+	int u_len = len/2;
+	for (i = 0; i < u_len; i++)
+	    size += _cairo_ucs4_to_utf8 (be16_to_cpu(u[i]), NULL);
+	utf8 = malloc (size + 1);
+	if (utf8 == NULL) {
+	    status =_cairo_error (CAIRO_STATUS_NO_MEMORY);
+	    goto fail;
+	}
+	p = utf8;
+	for (i = 0; i < u_len; i++)
+	    p += _cairo_ucs4_to_utf8 (be16_to_cpu(u[i]), p);
+	*p = 0;
+	free (str);
+	str = utf8;
+    } else if (platform == 1) { /* Mac platform, Mac Roman encoding */
+	/* Replace characters above 127 with underscores. We could use
+	 * a lookup table to convert to unicode but since most fonts
+	 * include a unicode name this is just a rarely used fallback. */
+	for (i = 0; i < len; i++) {
+	    if ((unsigned char)str[i] > 127)
+		str[i] = '_';
+	}
+    }
+    /* If font name is prefixed with a PDF subset tag, strip it off. */
+    p = str;
+    len = strlen (str);
+    has_tag = FALSE;
+    if (len > 7 && p[6] == '+') {
+	has_tag = TRUE;
+	for (i = 0; i < 6; i++) {
+	    if (p[i] < 'A' || p[i] > 'Z') {
+		has_tag = FALSE;
+		break;
+	    }
+	}
+    }
+    if (has_tag) {
+	p = malloc (len - 6);
+	if (unlikely (p == NULL)) {
+	    status =_cairo_error (CAIRO_STATUS_NO_MEMORY);
+	    goto fail;
+	}
+	memcpy (p, str + 7, len - 7);
+	p[len-7] = 0;
+	free (str);
+	str = p;
+    }
+    *str_out = str;
+    return CAIRO_STATUS_SUCCESS;
+  fail:
+    free (str);
+    return status;
+}
 cairo_int_status_t
 _cairo_truetype_read_font_name (cairo_scaled_font_t  	 *scaled_font,
 				char 	       		**ps_name_out,
 				char 	       		**font_name_out)
+{
     cairo_status_t status;
-    const cairo_scaled_font_backend_t *backend;
-    tt_name_t *name;
+    const cairo_scaled_font_backend_t *backend;
-    tt_name_record_t *record;
-    unsigned long size;
+    tt_name_t *name;
-    int i, j;
+    unsigned long size;
     char *ps_name = NULL;
-    char *font_name = NULL;
+    char *family_name = NULL;
 					   (unsigned char *) name,
 					   &size);
     if (status)
 	goto fail;
-    /* Extract the font name and PS name from the name table. At
+    /* Find PS Name (name_id = 6). OT spec says PS name must be one of
-     * present this just looks for the Mac platform/Roman encoded font
+     * the following two encodings */
-     * name. It should be extended to use any suitable font name in
+    status = find_name (name, 6, 3, 1, 0x409, &ps_name); /* win, unicode, english-us */
-     * the name table.
+    if (unlikely(status))
-     */
-    for (i = 0; i < be16_to_cpu(name->num_records); i++) {
-        record = &(name->records[i]);
-        if ((be16_to_cpu (record->platform) == 1) &&
-            (be16_to_cpu (record->encoding) == 0)) {
+	goto fail;
-	    if (be16_to_cpu (record->name) == 4) {
+    if (!ps_name) {
-		font_name = malloc (be16_to_cpu(record->length) + 1);
-		if (font_name == NULL) {
+	status = find_name (name, 6, 1, 0, 0, &ps_name); /* mac, roman, english */
-		    status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
+	if (unlikely(status))
-		    goto fail;
-		}
-		strncpy(font_name,
-			((char*)name) + be16_to_cpu (name->strings_offset) + be16_to_cpu (record->offset),
-			be16_to_cpu (record->length));
-		font_name[be16_to_cpu (record->length)] = 0;
+	    goto fail;
-	    }
+    }
+    /* Find Family name (name_id = 1) */
+    status = find_name (name, 1, 3, 1, 0x409, &family_name); /* win, unicode, english-us */
+    if (unlikely(status))
-	    if (be16_to_cpu (record->name) == 6) {
+	goto fail;
-		ps_name = malloc (be16_to_cpu(record->length) + 1);
+    if (!family_name) {
-		if (ps_name == NULL) {
-		    status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
-		    goto fail;
-		}
-		strncpy(ps_name,
-			((char*)name) + be16_to_cpu (name->strings_offset) + be16_to_cpu (record->offset),
+	status = find_name (name, 1, 3, 0, 0x409, &family_name); /* win, symbol, english-us */
-			be16_to_cpu (record->length));
+	if (unlikely(status))
+	    goto fail;
+    }
-		ps_name[be16_to_cpu (record->length)] = 0;
     if (!family_name) {
+	status = find_name (name, 1, 1, 0, 0, &family_name); /* mac, roman, english */
+	if (unlikely(status))
+	    goto fail;
+    }
     if (!family_name) {
-	    if (font_name && ps_name)
+	status = find_name (name, 1, 3, 1, -1, &family_name); /* win, unicode, any language */
-		break;
+	if (unlikely(status))
+	    goto fail;
+    }
+    free (name);
+    /* Ensure PS name is a valid PDF/PS name object. In PDF names are
+     * treated as UTF8 and non ASCII bytes, ' ', and '#' are encoded
+     * as '#' followed by 2 hex digits that encode the byte. By also
+     * encoding the characters in the reserved string we ensure the
+     * name is also PS compatible. */
-    }
+    if (ps_name) {
+	static const char *reserved = "()<>[]{}/%#\\";
+	char buf[128]; /* max name length is 127 bytes */
+	char *src = ps_name;
+	char *dst = buf;
+	while (*src && dst < buf + 127) {
+	    unsigned char c = *src;
-    free (name);
+	    if (c < 0x21 || c > 0x7e || strchr (reserved, c)) {
+		if (dst + 4 > buf + 127)
+		    break;
+		snprintf (dst, 4, "#%02X", c);
+		src++;
+		dst += 3;
+	    } else {
+		*dst++ = *src++;
+	    }
+	}
-    /* Ensure PS name does not contain any spaces */
+	*dst = 0;
-    if (ps_name) {
-	for (i = 0, j = 0; ps_name[j]; j++) {
+	free (ps_name);
-	    if (ps_name[j] == ' ')
+	ps_name = strdup (buf);
-		continue;
+	if (ps_name == NULL) {
-	    ps_name[i++] = ps_name[j];
+	    status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
 	    goto fail;
 	ps_name[i] = '\0';
-    }
     *ps_name_out = ps_name;
-    *font_name_out = font_name;
-    return CAIRO_STATUS_SUCCESS;
-fail:
+    *ps_name_out = ps_name;
-    free (name);
+    *font_name_out = family_name;
-    if (ps_name != NULL)
+    return CAIRO_STATUS_SUCCESS;
+fail:
+    free (name);
+    free (ps_name);
+    free (family_name);
+    *ps_name_out = NULL;
+    *font_name_out = NULL;
+    return status;
+}
+cairo_int_status_t
+_cairo_truetype_get_style (cairo_scaled_font_t  	 *scaled_font,
+			   int				 *weight,
+			   cairo_bool_t			 *bold,
+			   cairo_bool_t			 *italic)
+{
+    cairo_status_t status;
+    const cairo_scaled_font_backend_t *backend;
+    tt_os2_t os2;
+    unsigned long size;
+    uint16_t selection;
+    backend = scaled_font->backend;
+    if (!backend->load_truetype_table)
+	return CAIRO_INT_STATUS_UNSUPPORTED;
+    size = 0;
+    status = backend->load_truetype_table (scaled_font,
+					   TT_TAG_OS2, 0,
+					   NULL,
+					   &size);
+    if (status)
+	return status;
+    if (size < sizeof(os2))
+	return CAIRO_INT_STATUS_UNSUPPORTED;
+    size = sizeof (os2);
+    status = backend->load_truetype_table (scaled_font,
+					   TT_TAG_OS2, 0,
+					   (unsigned char *) &os2,
+					   &size);
-	free (ps_name);
+    if (status)

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/cairo/src/cairo-truetype-subset.c – Rev 1897 → 3959