static VALUE rg_range(VALUE self) { gint start = 0; gint end = 0; pango_attr_iterator_range(_SELF(self), &start, &end); return rb_ary_new3(2, INT2NUM(start), INT2NUM(end)); }
/* Updates the shaping of the ellipsis if necessary when we move the * position of the start of the gap. * * The shaping of the ellipsis is determined by two things: * * - The font attributes applied to the first character in the gap * - Whether the first character in the gap is wide or not. If the * first character is wide, then we assume that we are ellipsizing * East-Asian text, so prefer a mid-line ellipsizes to a baseline * ellipsis, since that's typical practice for Chinese/Japanese/Korean. */ static void update_ellipsis_shape (EllipsizeState *state) { gboolean recompute = FALSE; gunichar start_wc; gboolean is_cjk; /* Unfortunately, we can only advance PangoAttrIterator forward; so each * time we back up we need to go forward to find the new position. To make * this not utterly slow, we cache an iterator at the start of the line */ if (!state->line_start_attr) { state->line_start_attr = pango_attr_list_get_iterator (state->attrs); advance_iterator_to (state->line_start_attr, state->run_info[0].run->item->offset); } if (state->gap_start_attr) { /* See if the current attribute range contains the new start position */ int start, end; pango_attr_iterator_range (state->gap_start_attr, &start, &end); if (state->gap_start_iter.run_iter.start_index < start) { pango_attr_iterator_destroy (state->gap_start_attr); state->gap_start_attr = NULL; } } /* Check whether we need to recompute the ellipsis because of new font attributes */ if (!state->gap_start_attr) { state->gap_start_attr = pango_attr_iterator_copy (state->line_start_attr); advance_iterator_to (state->gap_start_attr, state->run_info[state->gap_start_iter.run_index].run->item->offset); recompute = TRUE; } /* Check whether we need to recompute the ellipsis because we switch from CJK to not * or vice-versa */ start_wc = g_utf8_get_char (state->layout->text + state->gap_start_iter.run_iter.start_index); is_cjk = g_unichar_iswide (start_wc); if (is_cjk != state->ellipsis_is_cjk) { state->ellipsis_is_cjk = is_cjk; recompute = TRUE; } if (recompute) shape_ellipsis (state); }
PangoAttrList * go_pango_translate_attributes (PangoAttrList *attrs) { PangoAttrList *n_attrs, *filtered; if (attrs == NULL) return NULL; n_attrs = pango_attr_list_copy (attrs); filtered = pango_attr_list_filter (n_attrs, filter_func, NULL); if (filtered == NULL) { pango_attr_list_unref (n_attrs); return attrs; } else { PangoAttrIterator *iter, *f_iter; f_iter = pango_attr_list_get_iterator (filtered); do { gint f_range_start, f_range_end; gint range_start, range_end; /* We need to restart everytime since we are changing n_attrs */ iter = pango_attr_list_get_iterator (n_attrs); pango_attr_iterator_range (f_iter, &f_range_start, &f_range_end); pango_attr_iterator_range (iter, &range_start, &range_end); while (range_end <= f_range_start) { if (!pango_attr_iterator_next (iter)) break; pango_attr_iterator_range (iter, &range_start, &range_end); } /* Now range_end > f_range_start >= range_start */ go_pango_translate_here (iter, f_iter, n_attrs); pango_attr_iterator_destroy (iter); } while (pango_attr_iterator_next (f_iter)); pango_attr_iterator_destroy (f_iter); } pango_attr_list_unref (filtered); return n_attrs; }
/* Helper function to advance a PangoAttrIterator to a particular * byte index. */ static void advance_iterator_to (PangoAttrIterator *iter, int new_index) { int start, end; do { pango_attr_iterator_range (iter, &start, &end); if (end > new_index) break; } while (pango_attr_iterator_next (iter)); }
static GSList * attrs_at_byte (PangoAttrList *alist, gint bytepos) { PangoAttrIterator *iter = pango_attr_list_get_iterator (alist); GSList *attrs = NULL; do { gint start, end; pango_attr_iterator_range (iter, &start, &end); if (start <= bytepos && bytepos < end) { attrs = pango_attr_iterator_get_attrs (iter); break; } } while (pango_attr_iterator_next (iter)); pango_attr_iterator_destroy (iter); return attrs; }
char * go_pango_attrs_to_markup (PangoAttrList *attrs, char const *text) { PangoAttrIterator * iter; int handled = 0; int from, to; int len; GString *gstr; if (text == NULL) return NULL; if (attrs == NULL || go_pango_attr_list_is_empty (attrs)) return g_strdup (text); len = strlen (text); gstr = g_string_sized_new (len + 1); iter = pango_attr_list_get_iterator (attrs); do { GSList *list, *l; int spans = 0; pango_attr_iterator_range (iter, &from, &to); to = (to > len) ? len : to; /* Since "to" can be really big! */ from = (from > len) ? len : from; /* Since "from" can also be really big! */ if (from > handled) g_string_append_len (gstr, text + handled, from - handled); list = pango_attr_iterator_get_attrs (iter); for (l = list; l != NULL; l = l->next) spans += go_pango_attr_as_markup_string (l->data, gstr); g_slist_free (list); if (to > from) g_string_append_len (gstr, text + from, to - from); while (spans-- > 0) g_string_append (gstr, "</span>"); handled = to; } while (pango_attr_iterator_next (iter)); pango_attr_iterator_destroy (iter); return g_string_free (gstr, FALSE); }
static void html_new_markup (GsfOutput *output, const PangoAttrList *markup, char const *text, html_version_t version) { int handled = 0; PangoAttrIterator * iter; int from, to; int len = strlen (text); GString *closure = g_string_new (""); iter = pango_attr_list_get_iterator ((PangoAttrList *) markup); do { GSList *list, *l; g_string_erase (closure, 0, -1); pango_attr_iterator_range (iter, &from, &to); from = (from > len) ? len : from; /* Since "from" can be really big! */ to = (to > len) ? len : to; /* Since "to" can be really big! */ if (from > handled) cb_html_add_chars (output, text + handled, from - handled); list = pango_attr_iterator_get_attrs (iter); for (l = list; l != NULL; l = l->next) { char const *result = cb_html_attrs_as_string (output, l->data, version); if (result != NULL) g_string_prepend (closure, result); } g_slist_free (list); if (to > from) cb_html_add_chars (output, text + from, to - from); gsf_output_puts (output, closure->str); handled = to; } while (pango_attr_iterator_next (iter)); g_string_free (closure, TRUE); pango_attr_iterator_destroy (iter); return; }
static void dump_attrs (PangoAttrList *attrs, GString *string) { PangoAttrIterator *iter; iter = pango_attr_list_get_iterator (attrs); do { gint start, end; GSList *list, *l; pango_attr_iterator_range (iter, &start, &end); g_string_append_printf (string, "range %d %d\n", start, end); list = pango_attr_iterator_get_attrs (iter); for (l = list; l; l = l->next) { PangoAttribute *attr = l->data; print_attr (attr, string); } g_slist_free_full (list, (GDestroyNotify)pango_attribute_destroy); } while (pango_attr_iterator_next (iter)); pango_attr_iterator_destroy (iter); }
static void go_pango_translate_here (PangoAttrIterator *state_iter, PangoAttrIterator *attr_iter, PangoAttrList *attrs) { double font_scale = 1.; double scale = 1.; int rise = 0; PangoAttribute *pa; PangoFontDescription *desc = pango_font_description_new (); GSList *the_attrs, *l; gint range_start, range_end; pango_attr_iterator_range (attr_iter, &range_start, &range_end); if (range_start == range_end) return; desc = pango_font_description_new (); pango_attr_iterator_get_font (state_iter, desc, NULL, NULL); font_scale = pango_font_description_get_size (desc)/ (double)PANGO_SCALE/10.; pango_font_description_free (desc); pa = pango_attr_iterator_get (state_iter, PANGO_ATTR_SCALE); if (pa) scale = ((PangoAttrFloat *)pa)->value; pa = pango_attr_iterator_get (state_iter, PANGO_ATTR_RISE); if (pa) rise = ((PangoAttrInt *)pa)->value; /* We should probably figured out the default font size used */ /* rather than assuming it is 10 pts * scale */ if (font_scale == 0) font_scale = scale; the_attrs = pango_attr_iterator_get_attrs (attr_iter); for (l = the_attrs; l != NULL; l = l->next) { PangoAttribute *attribute = l->data; PangoAttrType type = attribute->klass->type; if (type == go_pango_attr_superscript_get_attr_type ()) { GOPangoAttrSuperscript *attr = (GOPangoAttrSuperscript *)attribute; if (attr->val) { scale *= GO_SUPERSCRIPT_SCALE; rise += GO_SUPERSCRIPT_RISE * font_scale; font_scale *= GO_SUPERSCRIPT_SCALE; } } else { /* go_pango_attr_subscript_type */ GOPangoAttrSubscript *attr = (GOPangoAttrSubscript *)attribute; if (attr->val) { scale *= GO_SUBSCRIPT_SCALE; rise += GO_SUBSCRIPT_RISE * font_scale; font_scale *= GO_SUBSCRIPT_SCALE; } } } if (the_attrs != NULL) { PangoAttribute *attr = pango_attr_scale_new (scale); attr->start_index = range_start; attr->end_index = range_end; pango_attr_list_insert (attrs, attr); attr = pango_attr_rise_new (rise); attr->start_index = range_start; attr->end_index = range_end; pango_attr_list_insert (attrs, attr); } g_slist_free_full (the_attrs, (GDestroyNotify)pango_attribute_destroy); }
void go_load_pango_attributes_into_buffer (PangoAttrList *markup, GtkTextBuffer *buffer, gchar const *str) { PangoAttrIterator * iter; PangoAttrList *copied_markup; PangoAttrList *our_markup; if (markup == NULL) return; /* For some styles we create named tags. The names are taken from the Pango enums */ copied_markup = pango_attr_list_copy (markup); our_markup = pango_attr_list_filter (copied_markup, go_load_pango_attributes_into_buffer_named_filter, NULL); pango_attr_list_unref (copied_markup); if (our_markup != NULL) { iter = pango_attr_list_get_iterator (our_markup); do { GSList *attr = pango_attr_iterator_get_attrs (iter); if (attr != NULL) { GSList *ptr; gint start, end; GtkTextIter start_iter, end_iter; char const *name; pango_attr_iterator_range (iter, &start, &end); start = go_load_pango_byte_to_char (str, start); end = go_load_pango_byte_to_char (str, end); gtk_text_buffer_get_iter_at_offset (buffer, &start_iter, start); gtk_text_buffer_get_iter_at_offset (buffer, &end_iter, end); for (ptr = attr; ptr != NULL; ptr = ptr->next) { PangoAttribute *attribute = ptr->data; GtkTextTag *tag; int val; switch (attribute->klass->type) { case PANGO_ATTR_STYLE: name = (((PangoAttrInt *)attribute)->value == PANGO_STYLE_NORMAL) ? "PANGO_STYLE_NORMAL" : "PANGO_STYLE_ITALIC"; tag = gtk_text_tag_table_lookup (gtk_text_buffer_get_tag_table (buffer), name); gtk_text_buffer_apply_tag (buffer, tag, &start_iter, &end_iter); break; case PANGO_ATTR_STRIKETHROUGH: name = (((PangoAttrInt *)attribute)->value) ? "PANGO_STRIKETHROUGH_TRUE" : "PANGO_STRIKETHROUGH_FALSE"; tag = gtk_text_tag_table_lookup (gtk_text_buffer_get_tag_table (buffer), name); gtk_text_buffer_apply_tag (buffer, tag, &start_iter, &end_iter); break; case PANGO_ATTR_UNDERLINE: val = ((PangoAttrInt *)attribute)->value; if (val == PANGO_UNDERLINE_NONE) gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_UNDERLINE_NONE", &start_iter, &end_iter); else if (val == PANGO_UNDERLINE_SINGLE) gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_UNDERLINE_SINGLE", &start_iter, &end_iter); else if (val == PANGO_UNDERLINE_DOUBLE) gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_UNDERLINE_DOUBLE", &start_iter, &end_iter); else if (val == PANGO_UNDERLINE_LOW) gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_UNDERLINE_LOW", &start_iter, &end_iter); else if (val == PANGO_UNDERLINE_ERROR) gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_UNDERLINE_ERROR", &start_iter, &end_iter); break; case PANGO_ATTR_WEIGHT: val = ((PangoAttrInt *)attribute)->value; if (val < (PANGO_WEIGHT_THIN + PANGO_WEIGHT_ULTRALIGHT)/2) gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_THIN", &start_iter, &end_iter); else if (val < (PANGO_WEIGHT_ULTRALIGHT + PANGO_WEIGHT_LIGHT)/2) gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_ULTRALIGHT", &start_iter, &end_iter); else if (val < (PANGO_WEIGHT_LIGHT + PANGO_WEIGHT_BOOK)/2) gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_LIGHT", &start_iter, &end_iter); else if (val < (PANGO_WEIGHT_BOOK + PANGO_WEIGHT_NORMAL)/2) gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_BOOK", &start_iter, &end_iter); else if (val < (PANGO_WEIGHT_NORMAL + PANGO_WEIGHT_MEDIUM)/2) gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_NORMAL", &start_iter, &end_iter); else if (val < (PANGO_WEIGHT_MEDIUM + PANGO_WEIGHT_SEMIBOLD)/2) gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_MEDIUM", &start_iter, &end_iter); else if (val < (PANGO_WEIGHT_SEMIBOLD + PANGO_WEIGHT_BOLD)/2) gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_SEMIBOLD", &start_iter, &end_iter); else if (val < (PANGO_WEIGHT_BOLD + PANGO_WEIGHT_ULTRABOLD)/2) gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_BOLD", &start_iter, &end_iter); else if (val < (PANGO_WEIGHT_ULTRABOLD + PANGO_WEIGHT_HEAVY)/2) gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_ULTRABOLD", &start_iter, &end_iter); else if (val < (PANGO_WEIGHT_HEAVY + PANGO_WEIGHT_ULTRAHEAVY)/2) gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_HEAVY", &start_iter, &end_iter); else gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_ULTRAHEAVY", &start_iter, &end_iter); break; default: break; } } g_slist_free_full (attr, (GDestroyNotify)pango_attribute_destroy); } } while (pango_attr_iterator_next (iter)); pango_attr_iterator_destroy (iter); pango_attr_list_unref (our_markup); } /* For other styles (that are not at true/false type styles) we use unnamed styles */ copied_markup = pango_attr_list_copy (markup); our_markup = pango_attr_list_filter (copied_markup, go_load_pango_attributes_into_buffer_filter, NULL); pango_attr_list_unref (copied_markup); if (our_markup != NULL) { iter = pango_attr_list_get_iterator (our_markup); do { GSList *attr = pango_attr_iterator_get_attrs (iter); if (attr != NULL) { char *string; GSList *ptr; gint start, end; GtkTextIter start_iter, end_iter; GtkTextTag *tag = gtk_text_buffer_create_tag (buffer, NULL, NULL); for (ptr = attr; ptr != NULL; ptr = ptr->next) { PangoAttribute *attribute = ptr->data; switch (attribute->klass->type) { case PANGO_ATTR_FOREGROUND: string = pango_color_to_string (&((PangoAttrColor *)attribute)->color); g_object_set (G_OBJECT (tag), "foreground", string, "foreground-set", TRUE, NULL); g_free (string); break; case PANGO_ATTR_RISE: g_object_set (G_OBJECT (tag), "rise", ((PangoAttrInt *)attribute)->value, "rise-set", TRUE, NULL); break; default: break; } } pango_attr_iterator_range (iter, &start, &end); start = go_load_pango_byte_to_char (str, start); end = go_load_pango_byte_to_char (str, end); gtk_text_buffer_get_iter_at_offset (buffer, &start_iter, start); gtk_text_buffer_get_iter_at_offset (buffer, &end_iter, end); gtk_text_buffer_apply_tag (buffer, tag, &start_iter, &end_iter); g_slist_free_full (attr, (GDestroyNotify)pango_attribute_destroy); } } while (pango_attr_iterator_next (iter)); pango_attr_iterator_destroy (iter); pango_attr_list_unref (our_markup); } }
static AtkAttributeSet * get_run_attributes (PangoAttrList *attrs, const gchar *text, gint offset, gint *start_offset, gint *end_offset) { AtkAttributeSet *atk_attr_set = NULL; PangoAttrString *pango_string; PangoAttrInt *pango_int; PangoAttrColor *pango_color; PangoAttrIterator *iter; gint i, start, end; gboolean has_attrs = FALSE; glong text_length; gchar *attr_value; text_length = g_utf8_strlen (text, -1); if (offset < 0 || offset >= text_length) return NULL; /* Check if there are attributes for the offset, * and set the attributes range if positive */ iter = pango_attr_list_get_iterator (attrs); i = g_utf8_offset_to_pointer (text, offset) - text; do { pango_attr_iterator_range (iter, &start, &end); if (i >= start && i < end) { *start_offset = g_utf8_pointer_to_offset (text, text + start); if (end == G_MAXINT) /* Last iterator */ end = text_length; *end_offset = g_utf8_pointer_to_offset (text, text + end); has_attrs = TRUE; } } while (!has_attrs && pango_attr_iterator_next (iter)); if (!has_attrs) { pango_attr_iterator_destroy (iter); return NULL; } /* Create the AtkAttributeSet from the Pango attributes */ pango_string = (PangoAttrString *) pango_attr_iterator_get (iter, PANGO_ATTR_FAMILY); if (pango_string) { attr_value = g_strdup (pango_string->value); atk_attr_set = add_attribute (atk_attr_set, ATK_TEXT_ATTR_FAMILY_NAME, attr_value); } pango_int = (PangoAttrInt *) pango_attr_iterator_get (iter, PANGO_ATTR_SIZE); if (pango_int) { attr_value = g_strdup_printf ("%i", pango_int->value / PANGO_SCALE); atk_attr_set = add_attribute (atk_attr_set, ATK_TEXT_ATTR_SIZE, attr_value); } pango_int = (PangoAttrInt *) pango_attr_iterator_get (iter, PANGO_ATTR_UNDERLINE); if (pango_int) { atk_attr_set = add_attribute (atk_attr_set, ATK_TEXT_ATTR_UNDERLINE, g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_UNDERLINE, pango_int->value))); } pango_color = (PangoAttrColor *) pango_attr_iterator_get (iter, PANGO_ATTR_FOREGROUND); if (pango_color) { attr_value = g_strdup_printf ("%u,%u,%u", pango_color->color.red, pango_color->color.green, pango_color->color.blue); atk_attr_set = add_attribute (atk_attr_set, ATK_TEXT_ATTR_FG_COLOR, attr_value); } pango_attr_iterator_destroy (iter); return atk_attr_set; }
/** * gail_misc_layout_get_run_attributes: * @attrib_set: The #AtkAttributeSet to add the attribute to * @layout: The PangoLayout from which the attributes will be obtained * @text: The text * @offset: The offset at which the attributes are required * @start_offset: The start offset of the current run * @end_offset: The end offset of the current run * * Adds the attributes for the run starting at offset to the specified * attribute set. * * Returns: A pointer to the #AtkAttributeSet. **/ AtkAttributeSet* gail_misc_layout_get_run_attributes (AtkAttributeSet *attrib_set, PangoLayout *layout, const gchar *text, gint offset, gint *start_offset, gint *end_offset) { PangoAttrIterator *iter; PangoAttrList *attr; PangoAttrString *pango_string; PangoAttrInt *pango_int; PangoAttrColor *pango_color; PangoAttrLanguage *pango_lang; PangoAttrFloat *pango_float; gint index, start_index, end_index; gboolean is_next = TRUE; gchar *value = NULL; glong len; len = g_utf8_strlen (text, -1); /* Grab the attributes of the PangoLayout, if any */ if ((attr = pango_layout_get_attributes (layout)) == NULL) { *start_offset = 0; *end_offset = len; return attrib_set; } iter = pango_attr_list_get_iterator (attr); /* Get invariant range offsets */ /* If offset out of range, set offset in range */ if (offset > len) offset = len; else if (offset < 0) offset = 0; index = g_utf8_offset_to_pointer (text, offset) - text; pango_attr_iterator_range (iter, &start_index, &end_index); while (is_next) { if (index >= start_index && index < end_index) { *start_offset = g_utf8_pointer_to_offset (text, text + start_index); if (end_index == G_MAXINT) /* Last iterator */ end_index = len; *end_offset = g_utf8_pointer_to_offset (text, text + end_index); break; } is_next = pango_attr_iterator_next (iter); pango_attr_iterator_range (iter, &start_index, &end_index); } /* Get attributes */ if ((pango_string = (PangoAttrString*) pango_attr_iterator_get (iter, PANGO_ATTR_FAMILY)) != NULL) { value = g_strdup_printf("%s", pango_string->value); attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_FAMILY_NAME, value); } if ((pango_int = (PangoAttrInt*) pango_attr_iterator_get (iter, PANGO_ATTR_STYLE)) != NULL) { attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_STYLE, g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_STYLE, pango_int->value))); } if ((pango_int = (PangoAttrInt*) pango_attr_iterator_get (iter, PANGO_ATTR_WEIGHT)) != NULL) { value = g_strdup_printf("%i", pango_int->value); attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_WEIGHT, value); } if ((pango_int = (PangoAttrInt*) pango_attr_iterator_get (iter, PANGO_ATTR_VARIANT)) != NULL) { attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_VARIANT, g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_VARIANT, pango_int->value))); } if ((pango_int = (PangoAttrInt*) pango_attr_iterator_get (iter, PANGO_ATTR_STRETCH)) != NULL) { attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_STRETCH, g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_STRETCH, pango_int->value))); } if ((pango_int = (PangoAttrInt*) pango_attr_iterator_get (iter, PANGO_ATTR_SIZE)) != NULL) { value = g_strdup_printf("%i", pango_int->value / PANGO_SCALE); attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_SIZE, value); } if ((pango_int = (PangoAttrInt*) pango_attr_iterator_get (iter, PANGO_ATTR_UNDERLINE)) != NULL) { attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_UNDERLINE, g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_UNDERLINE, pango_int->value))); } if ((pango_int = (PangoAttrInt*) pango_attr_iterator_get (iter, PANGO_ATTR_STRIKETHROUGH)) != NULL) { attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_STRIKETHROUGH, g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_STRIKETHROUGH, pango_int->value))); } if ((pango_int = (PangoAttrInt*) pango_attr_iterator_get (iter, PANGO_ATTR_RISE)) != NULL) { value = g_strdup_printf("%i", pango_int->value); attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_RISE, value); } if ((pango_lang = (PangoAttrLanguage*) pango_attr_iterator_get (iter, PANGO_ATTR_LANGUAGE)) != NULL) { value = g_strdup( pango_language_to_string( pango_lang->value)); attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_LANGUAGE, value); } if ((pango_float = (PangoAttrFloat*) pango_attr_iterator_get (iter, PANGO_ATTR_SCALE)) != NULL) { value = g_strdup_printf("%g", pango_float->value); attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_SCALE, value); } if ((pango_color = (PangoAttrColor*) pango_attr_iterator_get (iter, PANGO_ATTR_FOREGROUND)) != NULL) { value = g_strdup_printf ("%u,%u,%u", pango_color->color.red, pango_color->color.green, pango_color->color.blue); attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_FG_COLOR, value); } if ((pango_color = (PangoAttrColor*) pango_attr_iterator_get (iter, PANGO_ATTR_BACKGROUND)) != NULL) { value = g_strdup_printf ("%u,%u,%u", pango_color->color.red, pango_color->color.green, pango_color->color.blue); attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_BG_COLOR, value); } pango_attr_iterator_destroy (iter); return attrib_set; }
static void gtk_text_buffer_insert_markup(GtkTextBuffer * buffer, GtkTextIter * iter, const gchar * markup) { PangoAttrIterator *paiter; PangoAttrList *attrlist; GtkTextMark *mark; GError *error = NULL; gchar *text; g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer)); g_return_if_fail(markup != NULL); if (*markup == '\000') return; /* invalid */ if (!pango_parse_markup(markup, -1, 0, &attrlist, &text, NULL, &error)) { g_warning("Invalid markup string: %s", error->message); g_error_free(error); return; } /* trivial, no markup */ if (attrlist == NULL) { gtk_text_buffer_insert(buffer, iter, text, -1); g_free(text); return; } /* create mark with right gravity */ mark = gtk_text_buffer_create_mark(buffer, NULL, iter, FALSE); paiter = pango_attr_list_get_iterator(attrlist); do { PangoAttribute *attr; GtkTextTag *tag; GtkTextTag *tag_para; gint start, end; pango_attr_iterator_range(paiter, &start, &end); if (end == G_MAXINT) /* last chunk */ end = start - 1; /* resulting in -1 to be passed to _insert */ tag = gtk_text_tag_new(NULL); if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_LANGUAGE))) g_object_set(tag, "language", pango_language_to_string(((PangoAttrLanguage *) attr)->value), NULL); if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_FAMILY))) g_object_set(tag, "family", ((PangoAttrString *) attr)->value, NULL); if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_STYLE))) g_object_set(tag, "style", ((PangoAttrInt *) attr)->value, NULL); if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_WEIGHT))) g_object_set(tag, "weight", ((PangoAttrInt *) attr)->value, NULL); if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_VARIANT))) g_object_set(tag, "variant", ((PangoAttrInt *) attr)->value, NULL); if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_STRETCH))) g_object_set(tag, "stretch", ((PangoAttrInt *) attr)->value, NULL); if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_SIZE))) g_object_set(tag, "size", ((PangoAttrInt *) attr)->value, NULL); if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_FONT_DESC))) g_object_set(tag, "font-desc", ((PangoAttrFontDesc *) attr)->desc, NULL); if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_FOREGROUND))) { GdkColor col = { 0, ((PangoAttrColor *) attr)->color.red, ((PangoAttrColor *) attr)->color.green, ((PangoAttrColor *) attr)->color.blue }; g_object_set(tag, "foreground-gdk", &col, NULL); } if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_BACKGROUND))) { GdkColor col = { 0, ((PangoAttrColor *) attr)->color.red, ((PangoAttrColor *) attr)->color.green, ((PangoAttrColor *) attr)->color.blue }; g_object_set(tag, "background-gdk", &col, NULL); } if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_UNDERLINE))) g_object_set(tag, "underline", ((PangoAttrInt *) attr)->value, NULL); if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_STRIKETHROUGH))) g_object_set(tag, "strikethrough", (gboolean) (((PangoAttrInt *) attr)->value != 0), NULL); if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_RISE))) g_object_set(tag, "rise", ((PangoAttrInt *) attr)->value, NULL); if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_SCALE))) g_object_set(tag, "scale", ((PangoAttrFloat *) attr)->value, NULL); gtk_text_tag_table_add(gtk_text_buffer_get_tag_table(buffer), tag); tag_para = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table (buffer), "para"); gtk_text_buffer_insert_with_tags(buffer, iter, text + start, end - start, tag, tag_para, NULL); /* mark had right gravity, so it should be * at the end of the inserted text now */ gtk_text_buffer_get_iter_at_mark(buffer, iter, mark); } while (pango_attr_iterator_next(paiter)); gtk_text_buffer_delete_mark(buffer, mark); pango_attr_iterator_destroy(paiter); pango_attr_list_unref(attrlist); g_free(text); }