WebSVN – Kolibri OS – Diff – /programs/develop/libraries/cairo/src/cairo-scaled-font-subsets.c

     cairo_hash_entry_t base;
     cairo_bool_t is_scaled;
     cairo_bool_t is_composite;
+    cairo_bool_t is_user;
-    cairo_bool_t is_user;
+    cairo_bool_t use_latin_subset;
     cairo_scaled_font_subsets_t *parent;
     cairo_scaled_font_t *scaled_font;
     unsigned int font_id;
+    int current_subset;
-    int current_subset;
+    int num_glyphs_in_current_subset;
+    int num_glyphs_in_latin_subset;
-    int num_glyphs_in_current_subset;
+    int max_glyphs_per_subset;
-    int max_glyphs_per_subset;
+    char latin_char_map[256];
     cairo_hash_table_t *sub_font_glyphs;
     struct _cairo_sub_font *next;
+} cairo_sub_font_t;
 } cairo_sub_font_t;
 struct _cairo_scaled_font_subsets {
-struct _cairo_scaled_font_subsets {
+    cairo_subsets_type_t type;
-    cairo_subsets_type_t type;
+    cairo_bool_t use_latin_subset;
     unsigned int subset_id;
     unsigned int subset_glyph_index;
     double       x_advance;
     double       y_advance;
+    cairo_bool_t is_latin;
     int		 latin_character;
     cairo_bool_t is_mapped;
     uint32_t     unicode;
     char  	*utf8;
     int          utf8_len;
 } cairo_sub_font_glyph_t;
 typedef struct _cairo_sub_font_collection {
     unsigned long *glyphs; /* scaled_font_glyph_index */
+    char       **utf8;
+    unsigned int glyphs_size;
-    char       **utf8;
+    int           *to_latin_char;
-    unsigned int glyphs_size;
+    unsigned long *latin_to_subset_glyph_index;
     unsigned int max_glyph;
 				unsigned long		 scaled_font_glyph_index)
+{
     sub_font_glyph->base.hash = scaled_font_glyph_index;
+}
-static cairo_bool_t
-_cairo_sub_font_glyphs_equal (const void *key_a, const void *key_b)
-{
-    const cairo_sub_font_glyph_t *sub_font_glyph_a = key_a;
-    const cairo_sub_font_glyph_t *sub_font_glyph_b = key_b;
-    return sub_font_glyph_a->base.hash == sub_font_glyph_b->base.hash;
-}
 static cairo_sub_font_glyph_t *
 _cairo_sub_font_glyph_create (unsigned long	scaled_font_glyph_index,
 			      unsigned int	subset_id,
 			      unsigned int	subset_glyph_index,
                               double            x_advance,
+                              double            y_advance,
+			      int	        latin_character,
+			      uint32_t          unicode,
+			      char             *utf8,
-                              double            y_advance)
+			      int          	utf8_len)
+{
     cairo_sub_font_glyph_t *sub_font_glyph;
     _cairo_sub_font_glyph_init_key (sub_font_glyph, scaled_font_glyph_index);
     sub_font_glyph->subset_id = subset_id;
     sub_font_glyph->subset_glyph_index = subset_glyph_index;
     sub_font_glyph->x_advance = x_advance;
     sub_font_glyph->y_advance = y_advance;
+    sub_font_glyph->is_latin = (latin_character >= 0);
+    sub_font_glyph->latin_character = latin_character;
     sub_font_glyph->is_mapped = FALSE;
-    sub_font_glyph->unicode = -1;
+    sub_font_glyph->unicode = unicode;
-    sub_font_glyph->utf8 = NULL;
+    sub_font_glyph->utf8 = utf8;
-    sub_font_glyph->utf8_len = 0;
+    sub_font_glyph->utf8_len = utf8_len;
     return sub_font_glyph;
+}
 static void
-_cairo_sub_font_glyph_destroy (cairo_sub_font_glyph_t *sub_font_glyph)
 _cairo_sub_font_glyph_destroy (cairo_sub_font_glyph_t *sub_font_glyph)
     if (sub_font_glyph->utf8 != NULL)
-	free (sub_font_glyph->utf8);
+    free (sub_font_glyph->utf8);
     /* Ensure we don't exceed the allocated bounds. */
     assert (subset_glyph_index < collection->glyphs_size);
     collection->glyphs[subset_glyph_index] = scaled_font_glyph_index;
+    collection->utf8[subset_glyph_index] = sub_font_glyph->utf8;
+    collection->to_latin_char[subset_glyph_index] = sub_font_glyph->latin_character;
+    if (sub_font_glyph->is_latin)
+	collection->latin_to_subset_glyph_index[sub_font_glyph->latin_character] = subset_glyph_index;
     collection->utf8[subset_glyph_index] = sub_font_glyph->utf8;
     if (subset_glyph_index > collection->max_glyph)
 	collection->max_glyph = subset_glyph_index;
                         cairo_bool_t                     is_scaled,
 			cairo_bool_t                     is_composite,
 			cairo_sub_font_t               **sub_font_out)
+{
     cairo_sub_font_t *sub_font;
-    cairo_status_t status;
+    int i;
-    cairo_scaled_font_subsets_glyph_t subset_glyph;
     sub_font = malloc (sizeof (cairo_sub_font_t));
     if (unlikely (sub_font == NULL))
     sub_font->parent = parent;
     sub_font->scaled_font = scaled_font;
+    sub_font->font_id = font_id;
+    sub_font->use_latin_subset = parent->use_latin_subset;
+    /* latin subsets of Type 3 and CID CFF fonts are not supported */
+    if (sub_font->is_user || sub_font->is_scaled ||
+	_cairo_cff_scaled_font_is_cid_cff (scaled_font) )
+    {
+	sub_font->use_latin_subset = FALSE;
+    }
+    if (sub_font->use_latin_subset)
-    sub_font->font_id = font_id;
+	sub_font->current_subset = 1; /* reserve subset 0 for latin glyphs */
+    else
 	sub_font->current_subset = 0;
-    sub_font->current_subset = 0;
+    sub_font->num_glyphs_in_current_subset = 0;
+    sub_font->num_glyphs_in_latin_subset = 0;
+    sub_font->max_glyphs_per_subset = max_glyphs_per_subset;
-    sub_font->num_glyphs_in_current_subset = 0;
+    for (i = 0; i < 256; i++)
-    sub_font->max_glyphs_per_subset = max_glyphs_per_subset;
+	sub_font->latin_char_map[i] = FALSE;
-    sub_font->sub_font_glyphs = _cairo_hash_table_create (_cairo_sub_font_glyphs_equal);
+    sub_font->sub_font_glyphs = _cairo_hash_table_create (NULL);
     if (unlikely (sub_font->sub_font_glyphs == NULL)) {
 	free (sub_font);
-	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
-    }
-    sub_font->next = NULL;
-    /* Reserve first glyph in subset for the .notdef glyph except for
-     * Type 3 fonts */
-    if (! is_scaled) {
-	status = _cairo_sub_font_map_glyph (sub_font, 0, NULL, -1, &subset_glyph);
-	if (unlikely (status)) {
-	    _cairo_hash_table_destroy (sub_font->sub_font_glyphs);
-	    free (sub_font);
-	    return status;
 	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
+    }
     sub_font->next = NULL;
     *sub_font_out = sub_font;
     _cairo_hash_table_remove (sub_fonts, &sub_font->base);
     _cairo_sub_font_destroy (sub_font);
+}
+/* Characters 0x80 to 0x9f in the winansi encoding.
+ * All other characters in the range 0x00 to 0xff map 1:1 to unicode */
+static unsigned int _winansi_0x80_to_0x9f[] = {
+x20ac, 0x0000, 0x201a, 0x0192, 0x201e, 0x2026, 0x2020, 0x2021,
+x02c6, 0x2030, 0x0160, 0x2039, 0x0152, 0x0000, 0x017d, 0x0000,
+x0000, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014,
+x02dc, 0x2122, 0x0161, 0x203a, 0x0153, 0x0000, 0x017e, 0x0178
+};
+int
+_cairo_unicode_to_winansi (unsigned long uni)
+{
+    int i;
+    /* exclude the extra "hyphen" at 0xad to avoid duplicate glyphnames */
+    if ((uni >= 0x20 && uni <= 0x7e) ||
+	(uni >= 0xa1 && uni <= 0xff && uni != 0xad) ||
+	uni == 0)
+        return uni;
+    for (i = 0; i < 32; i++)
+	if (_winansi_0x80_to_0x9f[i] == uni)
+	    return i + 0x80;
+    return -1;
+}
 static cairo_status_t
+_cairo_sub_font_glyph_lookup_unicode (cairo_scaled_font_t    *scaled_font,
+				      unsigned long	      scaled_font_glyph_index,
-_cairo_sub_font_glyph_lookup_unicode (cairo_sub_font_glyph_t *sub_font_glyph,
+				      uint32_t     	     *unicode_out,
-				      cairo_scaled_font_t    *scaled_font,
+				      char  		    **utf8_out,
-				      unsigned long	      scaled_font_glyph_index)
+				      int          	     *utf8_len_out)
+{
     uint32_t unicode;
     char buf[8];
 						      &unicode);
 	if (unlikely (status))
 	    return status;
+    }
-    sub_font_glyph->unicode = unicode;
+    *unicode_out = unicode;
-    sub_font_glyph->utf8 = NULL;
+    *utf8_out = NULL;
-    sub_font_glyph->utf8_len = 0;
+    *utf8_len_out = 0;
     if (unicode != (uint32_t) -1) {
 	len = _cairo_ucs4_to_utf8 (unicode, buf);
 	if (len > 0) {
-	    sub_font_glyph->utf8 = malloc (len + 1);
+	    *utf8_out = malloc (len + 1);
-	    if (unlikely (sub_font_glyph->utf8 == NULL))
+	    if (unlikely (*utf8_out == NULL))
 		return _cairo_error (CAIRO_STATUS_NO_MEMORY);
-	    memcpy (sub_font_glyph->utf8, buf, len);
+	    memcpy (*utf8_out, buf, len);
-	    sub_font_glyph->utf8[len] = 0;
+	    (*utf8_out)[len] = 0;
-	    sub_font_glyph->utf8_len = len;
+	    *utf8_len_out = len;
+	}
+    }
     sub_font_glyph = _cairo_hash_table_lookup (sub_font->sub_font_glyphs,
 					      &key.base);
     if (sub_font_glyph != NULL) {
         subset_glyph->font_id = sub_font->font_id;
         subset_glyph->subset_id = sub_font_glyph->subset_id;
+	if (sub_font_glyph->is_latin)
+	    subset_glyph->subset_glyph_index = sub_font_glyph->latin_character;
+	else
-        subset_glyph->subset_glyph_index = sub_font_glyph->subset_glyph_index;
+	    subset_glyph->subset_glyph_index = sub_font_glyph->subset_glyph_index;
         subset_glyph->is_scaled = sub_font->is_scaled;
         subset_glyph->is_composite = sub_font->is_composite;
+	subset_glyph->is_latin = sub_font_glyph->is_latin;
         subset_glyph->x_advance = sub_font_glyph->x_advance;
         subset_glyph->y_advance = sub_font_glyph->y_advance;
 	status = _cairo_sub_font_glyph_map_to_unicode (sub_font_glyph,
 						       utf8, utf8_len,
 						       &subset_glyph->utf8_is_mapped);
     return CAIRO_INT_STATUS_UNSUPPORTED;
+}
 static cairo_status_t
+_cairo_sub_font_add_glyph (cairo_sub_font_t	   *sub_font,
+			   unsigned long	    scaled_font_glyph_index,
+			   cairo_bool_t		    is_latin,
-_cairo_sub_font_map_glyph (cairo_sub_font_t	*sub_font,
+			   int			    latin_character,
-			   unsigned long	 scaled_font_glyph_index,
+			   uint32_t 		    unicode,
-			   const char		*utf8,
+			   char 		   *utf8,
-			   int			 utf8_len,
+			   int 			    utf8_len,
-                           cairo_scaled_font_subsets_glyph_t *subset_glyph)
-{
-    cairo_sub_font_glyph_t key, *sub_font_glyph;
-    cairo_status_t status;
-    _cairo_sub_font_glyph_init_key (&key, scaled_font_glyph_index);
-    sub_font_glyph = _cairo_hash_table_lookup (sub_font->sub_font_glyphs,
-					       &key.base);
+			   cairo_sub_font_glyph_t **sub_font_glyph_out)
-    if (sub_font_glyph == NULL) {
-	cairo_scaled_glyph_t *scaled_glyph;
-	if (sub_font->num_glyphs_in_current_subset == sub_font->max_glyphs_per_subset)
+{
-	{
-	    cairo_scaled_font_subsets_glyph_t tmp_subset_glyph;
+    cairo_scaled_glyph_t *scaled_glyph;
-	    sub_font->current_subset++;
-	    sub_font->num_glyphs_in_current_subset = 0;
+    cairo_sub_font_glyph_t *sub_font_glyph;
-	    /* Reserve first glyph in subset for the .notdef glyph
-	     * except for Type 3 fonts */
-	    if (! _cairo_font_face_is_user (sub_font->scaled_font->font_face)) {
+    int *num_glyphs_in_subset_ptr;
-		status = _cairo_sub_font_map_glyph (sub_font, 0, NULL, -1, &tmp_subset_glyph);
+    double x_advance;
-		if (unlikely (status))
-		    return status;
     double y_advance;
     cairo_int_status_t status;
-	_cairo_scaled_font_freeze_cache (sub_font->scaled_font);
+    _cairo_scaled_font_freeze_cache (sub_font->scaled_font);
-	if (unlikely (status)) {
+    if (unlikely (status)) {
-	    _cairo_scaled_font_thaw_cache (sub_font->scaled_font);
+	_cairo_scaled_font_thaw_cache (sub_font->scaled_font);
-	    return status;
+	return status;
+    }
-        sub_font_glyph = _cairo_sub_font_glyph_create (scaled_font_glyph_index,
-						       sub_font->current_subset,
-						       sub_font->num_glyphs_in_current_subset,
-                                                       scaled_glyph->metrics.x_advance,
+    x_advance = scaled_glyph->metrics.x_advance;
-                                                       scaled_glyph->metrics.y_advance);
+    y_advance = scaled_glyph->metrics.y_advance;
+    _cairo_scaled_font_thaw_cache (sub_font->scaled_font);
-	_cairo_scaled_font_thaw_cache (sub_font->scaled_font);
+    if (!is_latin && sub_font->num_glyphs_in_current_subset == sub_font->max_glyphs_per_subset)
+    {
+	sub_font->current_subset++;
+	sub_font->num_glyphs_in_current_subset = 0;
+    }
+    if (is_latin)
+	num_glyphs_in_subset_ptr = &sub_font->num_glyphs_in_latin_subset;
+    else
+	num_glyphs_in_subset_ptr = &sub_font->num_glyphs_in_current_subset;
+    /* Reserve first glyph in subset for the .notdef glyph except for
+     * Type 3 fonts */
+    if (*num_glyphs_in_subset_ptr == 0 &&
-	if (unlikely (sub_font_glyph == NULL))
+	scaled_font_glyph_index != 0 &&
+	! _cairo_font_face_is_user (sub_font->scaled_font->font_face))
-	    return _cairo_error (CAIRO_STATUS_NO_MEMORY);
+    {
+	status = _cairo_sub_font_add_glyph (sub_font,
+,
+					    is_latin,
+,
+,
-	status = _cairo_sub_font_glyph_lookup_unicode (sub_font_glyph,
+					    NULL,
-						       sub_font->scaled_font,
-						       scaled_font_glyph_index);
+					    -1,
-	if (unlikely (status)) {
+					    &sub_font_glyph);
+	if (unlikely (status))
+	    return status;
+    }
+    sub_font_glyph = _cairo_sub_font_glyph_create (scaled_font_glyph_index,
+						   is_latin ? 0 : sub_font->current_subset,
+						   *num_glyphs_in_subset_ptr,
+						   x_advance,
+						   y_advance,
+						   is_latin ? latin_character : -1,
+						   unicode,
+						   utf8,
+						   utf8_len);
 	    _cairo_sub_font_glyph_destroy (sub_font_glyph);
-	    return status;
+    if (unlikely (sub_font_glyph == NULL))
 	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
-	status = _cairo_hash_table_insert (sub_font->sub_font_glyphs, &sub_font_glyph->base);
+    status = _cairo_hash_table_insert (sub_font->sub_font_glyphs, &sub_font_glyph->base);
-	if (unlikely (status)) {
+    if (unlikely (status)) {
-	    _cairo_sub_font_glyph_destroy (sub_font_glyph);
-	    return status;
+	_cairo_sub_font_glyph_destroy (sub_font_glyph);
-	}
+	return status;
+    }
 	sub_font->num_glyphs_in_current_subset++;
+    (*num_glyphs_in_subset_ptr)++;
-        if (sub_font->is_scaled) {
+    if (sub_font->is_scaled) {
-            if (sub_font->num_glyphs_in_current_subset > sub_font->parent->max_glyphs_per_scaled_subset_used)
+	if (*num_glyphs_in_subset_ptr > sub_font->parent->max_glyphs_per_scaled_subset_used)
+	    sub_font->parent->max_glyphs_per_scaled_subset_used = *num_glyphs_in_subset_ptr;
+    } else {
+	if (*num_glyphs_in_subset_ptr > sub_font->parent->max_glyphs_per_unscaled_subset_used)
+	    sub_font->parent->max_glyphs_per_unscaled_subset_used = *num_glyphs_in_subset_ptr;
+    }
+    *sub_font_glyph_out = sub_font_glyph;
+    return CAIRO_STATUS_SUCCESS;
+}
+static cairo_status_t
+_cairo_sub_font_map_glyph (cairo_sub_font_t	*sub_font,
+			   unsigned long	 scaled_font_glyph_index,
+			   const char		*text_utf8,
+			   int			 text_utf8_len,
+                           cairo_scaled_font_subsets_glyph_t *subset_glyph)
+{
+    cairo_sub_font_glyph_t key, *sub_font_glyph;
+    cairo_status_t status;
+    _cairo_sub_font_glyph_init_key (&key, scaled_font_glyph_index);
+    sub_font_glyph = _cairo_hash_table_lookup (sub_font->sub_font_glyphs,
+					       &key.base);
+    if (sub_font_glyph == NULL) {
+	uint32_t font_unicode;
+	char *font_utf8;
+	int font_utf8_len;
+	cairo_bool_t is_latin;
+	int latin_character;
+	status = _cairo_sub_font_glyph_lookup_unicode (sub_font->scaled_font,
+							   scaled_font_glyph_index,
+							   &font_unicode,
+							   &font_utf8,
+							   &font_utf8_len);
+	if (unlikely(status))
+	    return status;
+	/* If the supplied utf8 is a valid single character, use it
+	 * instead of the font lookup */
+	if (text_utf8 != NULL && text_utf8_len > 0) {
+	    uint32_t  *ucs4;
+	    int	ucs4_len;
+	    status = _cairo_utf8_to_ucs4 (text_utf8, text_utf8_len,
+					  &ucs4, &ucs4_len);
+	    if (status == CAIRO_STATUS_SUCCESS) {
+		if (ucs4_len == 1) {
+		    font_unicode = ucs4[0];
+		    free (font_utf8);
+		    font_utf8 = malloc (text_utf8_len + 1);
+		    if (font_utf8 == NULL) {
+			free (ucs4);
+			return _cairo_error (CAIRO_STATUS_NO_MEMORY);
+		    }
+		    memcpy (font_utf8, text_utf8, text_utf8_len);
+		    font_utf8[text_utf8_len] = 0;
+		    font_utf8_len = text_utf8_len;
+		}
+		free (ucs4);
+	    }
+	}
+	/* If glyph is in the winansi encoding and font is not a user
+	 * font, put glyph in the latin subset. If glyph is .notdef
+	 * the latin subset is preferred but only if the latin subset
+	 * already contains at least one glyph. We don't want to
+	 * create a separate subset just for the .notdef glyph.
+	 */
+	is_latin = FALSE;
+	latin_character = -1;
+	if (sub_font->use_latin_subset &&
+	    (! _cairo_font_face_is_user (sub_font->scaled_font->font_face)))
+	{
+	    latin_character = _cairo_unicode_to_winansi (font_unicode);
+	    if (latin_character > 0 ||
+		(latin_character == 0 && sub_font->num_glyphs_in_latin_subset > 0))
+	    {
+		if (!sub_font->latin_char_map[latin_character]) {
+		    sub_font->latin_char_map[latin_character] = TRUE;
+		    is_latin = TRUE;
+		}
+	    }
+	}
+	status = _cairo_sub_font_add_glyph (sub_font,
+					    scaled_font_glyph_index,
+					    is_latin,
+					    latin_character,
+					    font_unicode,
-                sub_font->parent->max_glyphs_per_scaled_subset_used = sub_font->num_glyphs_in_current_subset;
+					    font_utf8,
-        } else {
+					    font_utf8_len,
-            if (sub_font->num_glyphs_in_current_subset > sub_font->parent->max_glyphs_per_unscaled_subset_used)
+					    &sub_font_glyph);
+	if (unlikely(status))
+	    return status;
+    }
                 sub_font->parent->max_glyphs_per_unscaled_subset_used = sub_font->num_glyphs_in_current_subset;
+    subset_glyph->font_id = sub_font->font_id;
     subset_glyph->subset_id = sub_font_glyph->subset_id;
     if (sub_font_glyph->is_latin)
+	subset_glyph->subset_glyph_index = sub_font_glyph->latin_character;
     else
-    subset_glyph->font_id = sub_font->font_id;
+	subset_glyph->subset_glyph_index = sub_font_glyph->subset_glyph_index;
     subset_glyph->subset_id = sub_font_glyph->subset_id;
-    subset_glyph->subset_glyph_index = sub_font_glyph->subset_glyph_index;
+    subset_glyph->is_scaled = sub_font->is_scaled;
-    subset_glyph->is_scaled = sub_font->is_scaled;
+    subset_glyph->is_composite = sub_font->is_composite;
-    subset_glyph->is_composite = sub_font->is_composite;
+    subset_glyph->is_latin = sub_font_glyph->is_latin;
     subset_glyph->x_advance = sub_font_glyph->x_advance;
     subset_glyph->y_advance = sub_font_glyph->y_advance;
     for (i = 0; i <= sub_font->current_subset; i++) {
 	collection->subset_id = i;
 	collection->num_glyphs = 0;
+	collection->max_glyph = 0;
-	collection->max_glyph = 0;
+	memset (collection->latin_to_subset_glyph_index, 0, 256*sizeof(unsigned long));
 	_cairo_hash_table_foreach (sub_font->sub_font_glyphs,
 				   _cairo_sub_font_glyph_collect, collection);
 	subset.subset_id = i;
 	subset.glyphs = collection->glyphs;
 	subset.utf8 = collection->utf8;
 	subset.num_glyphs = collection->num_glyphs;
         subset.glyph_names = NULL;
-        /* No need to check for out of memory here. If to_unicode is NULL, the PDF
-         * surface does not emit an ToUnicode stream */
+	subset.is_latin = FALSE;
-        subset.to_unicode = _cairo_malloc_ab (collection->num_glyphs, sizeof (unsigned long));
+	if (sub_font->use_latin_subset && i == 0) {
-        if (subset.to_unicode) {
+	    subset.is_latin = TRUE;
-            for (j = 0; j < collection->num_glyphs; j++) {
+	    subset.to_latin_char = collection->to_latin_char;
-                /* default unicode character required when mapping fails */
+	    subset.latin_to_subset_glyph_index = collection->latin_to_subset_glyph_index;
+	} else {
-                subset.to_unicode[j] = 0xfffd;
+	    subset.to_latin_char = NULL;
-            }
+	    subset.latin_to_subset_glyph_index = NULL;
+	}
         collection->status = (collection->font_subset_callback) (&subset,
 					    collection->font_subset_callback_closure);
-        if (subset.to_unicode != NULL)
-            free (subset.to_unicode);
 	if (subset.glyph_names != NULL) {
             for (j = 0; j < collection->num_glyphs; j++)
 		free (subset.glyph_names[j]);
 	    free (subset.glyph_names);
 	_cairo_error_throw (CAIRO_STATUS_NO_MEMORY);
 	return NULL;
+    }
+    subsets->type = type;
-    subsets->type = type;
+    subsets->use_latin_subset = FALSE;
     subsets->max_glyphs_per_unscaled_subset_used = 0;
     subsets->max_glyphs_per_scaled_subset_used = 0;
     subsets->num_sub_fonts = 0;
     _cairo_hash_table_destroy (subsets->unscaled_sub_fonts);
     free (subsets);
+}
+void
+_cairo_scaled_font_subsets_enable_latin_subset (cairo_scaled_font_subsets_t *font_subsets,
+						cairo_bool_t                 use_latin)
+{
+    font_subsets->use_latin_subset = use_latin;
+}
 cairo_status_t
 _cairo_scaled_font_subsets_map_glyph (cairo_scaled_font_subsets_t	*subsets,
 				      cairo_scaled_font_t		*scaled_font,
     cairo_scaled_glyph_t *scaled_glyph;
     cairo_font_face_t *font_face;
     cairo_matrix_t identity;
     cairo_font_options_t font_options;
     cairo_scaled_font_t	*unscaled_font;
-    cairo_status_t status;
+    cairo_int_status_t status;
     int max_glyphs;
     cairo_bool_t type1_font;
     /* Lookup glyph in unscaled subsets */
 					     scaled_font_glyph_index,
 					     CAIRO_SCALED_GLYPH_INFO_PATH,
 					     &scaled_glyph);
 	_cairo_scaled_font_thaw_cache (scaled_font);
+    }
-    if (_cairo_status_is_error (status))
+    if (_cairo_int_status_is_error (status))
         return status;
-    if (status == CAIRO_STATUS_SUCCESS &&
+    if (status == CAIRO_INT_STATUS_SUCCESS &&
 	subsets->type != CAIRO_SUBSETS_SCALED &&
 	! _cairo_font_face_is_user (scaled_font->font_face))
+    {
         /* Path available. Add to unscaled subset. */
                                                       &font_options);
 	    if (unlikely (unscaled_font->status))
 		return unscaled_font->status;
-            subset_glyph->is_scaled = FALSE;
-            type1_font = FALSE;
-#if CAIRO_HAS_FT_FONT
+            subset_glyph->is_scaled = FALSE;
-            type1_font = _cairo_type1_scaled_font_is_type1 (unscaled_font);
-#endif
+            type1_font = _cairo_type1_scaled_font_is_type1 (unscaled_font);
             if (subsets->type == CAIRO_SUBSETS_COMPOSITE && !type1_font) {
                 max_glyphs = MAX_GLYPHS_PER_COMPOSITE_FONT;
                 subset_glyph->is_composite = TRUE;
             } else {
     if (! collection.glyphs_size)
 	return CAIRO_STATUS_SUCCESS;
     collection.glyphs = _cairo_malloc_ab (collection.glyphs_size, sizeof(unsigned long));
+    collection.utf8 = _cairo_malloc_ab (collection.glyphs_size, sizeof(char *));
+    collection.to_latin_char = _cairo_malloc_ab (collection.glyphs_size, sizeof(int));
-    collection.utf8 = _cairo_malloc_ab (collection.glyphs_size, sizeof(char *));
+    collection.latin_to_subset_glyph_index = _cairo_malloc_ab (256, sizeof(unsigned long));
-    if (unlikely (collection.glyphs == NULL || collection.utf8 == NULL)) {
+    if (unlikely (collection.glyphs == NULL ||
+		  collection.utf8 == NULL ||
+		  collection.to_latin_char == NULL ||
-	if (collection.glyphs != NULL)
+		  collection.latin_to_subset_glyph_index == NULL)) {
-	    free (collection.glyphs);
-	if (collection.utf8 != NULL)
+	free (collection.glyphs);
+	free (collection.utf8);
+	free (collection.to_latin_char);
-	    free (collection.utf8);
+	free (collection.latin_to_subset_glyph_index);
 	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
 	sub_font = sub_font->next;
+    }
     free (collection.utf8);
+    free (collection.glyphs);
+    free (collection.to_latin_char);
-    free (collection.glyphs);
+    free (collection.latin_to_subset_glyph_index);
     return collection.status;
 	    if (unlikely (status))
 		goto CLEANUP_HASH;
+	}
+	if (utf16_len == 1) {
+	    int ch = _cairo_unicode_to_winansi (utf16[0]);
+	    if (ch > 0 && _cairo_winansi_to_glyphname (ch))
+		strncpy (buf, _cairo_winansi_to_glyphname (ch), sizeof (buf));
-	if (utf16_len == 1) {
+	    else
+		snprintf (buf, sizeof (buf), "uni%04X", (int) utf16[0]);
 	    snprintf (buf, sizeof (buf), "uni%04X", (int) utf16[0]);
 	    _cairo_string_init_key (&key, buf);
 	    entry = _cairo_hash_table_lookup (names, &key.base);
 	    if (entry != NULL)
 		snprintf (buf, sizeof (buf), "g%d", i);
 	} else {
 	    snprintf (buf, sizeof (buf), "g%d", i);
-	}
 	if (utf16)
-	    free (utf16);
+	free (utf16);
 	subset->glyph_names[i] = strdup (buf);
     if (likely (status == CAIRO_STATUS_SUCCESS))
 	return CAIRO_STATUS_SUCCESS;
     if (subset->glyph_names != NULL) {
-	for (i = 0; i < subset->num_glyphs; i++) {
-	    if (subset->glyph_names[i] != NULL)
+	for (i = 0; i < subset->num_glyphs; i++) {
-		free (subset->glyph_names[i]);
+	    free (subset->glyph_names[i]);
+	}

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/cairo/src/cairo-scaled-font-subsets.c – Rev 1897 → 3959