From b6025e44a98b41dc132aa8deea732521b9364f03 Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Tue, 14 Jun 2011 20:29:15 +0200 Subject: [PATCH] gail: Copy gail-util functions into gail Otherwise we get a circular dependency if we move libgail into GTK: GTK depends on gail-util depends on gail (is part of GTK) --- gtk/a11y/Makefile.am | 7 +- gtk/a11y/gailbutton.h | 2 +- gtk/a11y/gailentry.h | 2 +- gtk/a11y/gailexpander.h | 2 +- gtk/a11y/gaillabel.h | 2 +- gtk/a11y/gailmenuitem.h | 2 +- gtk/a11y/gailmisc.c | 1082 +++++++++++++++++++++++++++++++++++ gtk/a11y/gailmisc.h | 78 +++ gtk/a11y/gailnotebookpage.h | 2 +- gtk/a11y/gailscale.h | 2 +- gtk/a11y/gailstatusbar.h | 2 +- gtk/a11y/gailtextcell.h | 2 +- gtk/a11y/gailtextutil.c | 786 +++++++++++++++++++++++++ gtk/a11y/gailtextutil.h | 87 +++ gtk/a11y/gailtextview.h | 2 +- 15 files changed, 2048 insertions(+), 12 deletions(-) create mode 100644 gtk/a11y/gailmisc.c create mode 100644 gtk/a11y/gailmisc.h create mode 100644 gtk/a11y/gailtextutil.c create mode 100644 gtk/a11y/gailtextutil.h diff --git a/gtk/a11y/Makefile.am b/gtk/a11y/Makefile.am index be4360a4b..427bf2cf8 100644 --- a/gtk/a11y/Makefile.am +++ b/gtk/a11y/Makefile.am @@ -32,6 +32,7 @@ gail_c_sources = \ gailimagecell.c \ gaillabel.c \ gaillinkbutton.c \ + gailmisc.c \ gailmenu.c \ gailmenushell.c \ gailmenuitem.c \ @@ -53,6 +54,7 @@ gail_c_sources = \ gailsubmenuitem.c \ gailstatusbar.c \ gailtextcell.c \ + gailtextutil.c \ gailtextview.c \ gailtogglebutton.c \ gailtoplevel.c \ @@ -86,6 +88,7 @@ gail_private_h_sources = \ gailimagecell.h \ gaillabel.h \ gaillinkbutton.h \ + gailmisc.h \ gailmenu.h \ gailmenushell.h \ gailmenuitem.h \ @@ -107,6 +110,7 @@ gail_private_h_sources = \ gailsubmenuitem.h \ gailstatusbar.h \ gailtextcell.h \ + gailtextutil.h \ gailtextview.h \ gailtogglebutton.h \ gailtoplevel.h \ @@ -143,8 +147,7 @@ libgail_la_CFLAGS = \ libgail_la_LIBADD = \ $(top_builddir)/gtk/libgtk-3.la \ - $(top_builddir)/gtk/a11y/libgail-util/libgailutil-3.la \ - $(GTK_DEP_LIBS) \ + $(GTK_DEP_LIBS) \ $(INTLLIBS) libgail_la_LDFLAGS = \ diff --git a/gtk/a11y/gailbutton.h b/gtk/a11y/gailbutton.h index e9c728889..cf8c65934 100644 --- a/gtk/a11y/gailbutton.h +++ b/gtk/a11y/gailbutton.h @@ -21,7 +21,7 @@ #define __GAIL_BUTTON_H__ #include "gailcontainer.h" -#include +#include "gailtextutil.h" G_BEGIN_DECLS diff --git a/gtk/a11y/gailentry.h b/gtk/a11y/gailentry.h index 8a1d6fd7c..d90d3bdb0 100644 --- a/gtk/a11y/gailentry.h +++ b/gtk/a11y/gailentry.h @@ -21,7 +21,7 @@ #define __GAIL_ENTRY_H__ #include "gailwidget.h" -#include +#include "gailtextutil.h" G_BEGIN_DECLS diff --git a/gtk/a11y/gailexpander.h b/gtk/a11y/gailexpander.h index 40664d406..f16b14dcf 100644 --- a/gtk/a11y/gailexpander.h +++ b/gtk/a11y/gailexpander.h @@ -21,7 +21,7 @@ #define __GAIL_EXPANDER_H__ #include "gailcontainer.h" -#include +#include "gailtextutil.h" G_BEGIN_DECLS diff --git a/gtk/a11y/gaillabel.h b/gtk/a11y/gaillabel.h index 1b247143b..fa4b657b6 100644 --- a/gtk/a11y/gaillabel.h +++ b/gtk/a11y/gaillabel.h @@ -21,7 +21,7 @@ #define __GAIL_LABEL_H__ #include "gailwidget.h" -#include +#include "gailtextutil.h" G_BEGIN_DECLS diff --git a/gtk/a11y/gailmenuitem.h b/gtk/a11y/gailmenuitem.h index 3dbe50939..13d9753c4 100644 --- a/gtk/a11y/gailmenuitem.h +++ b/gtk/a11y/gailmenuitem.h @@ -21,7 +21,7 @@ #define __GAIL_MENU_ITEM_H__ #include "gailcontainer.h" -#include +#include "gailtextutil.h" G_BEGIN_DECLS diff --git a/gtk/a11y/gailmisc.c b/gtk/a11y/gailmisc.c new file mode 100644 index 000000000..fd0917a6f --- /dev/null +++ b/gtk/a11y/gailmisc.c @@ -0,0 +1,1082 @@ +/* GAIL - The GNOME Accessibility Implementation Library + * Copyright 2001 Sun Microsystems Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#include "config.h" + +#include +#include +#include +#include "gailmisc.h" + +/* IMPORTANT!!! This source file does NOT contain the implementation + * code for AtkUtil - for that code, please see gail/gail.c. + */ + +/** + * SECTION:gailmisc + * @Short_description: GailMisc is a set of utility functions which may be + * useful to implementors of Atk interfaces for custom widgets. + * @Title: GailMisc + * + * GailMisc is a set of utility function which are used in the implemementation + * of Atk interfaces for GTK+ widgets. They may be useful to implementors of + * Atk interfaces for custom widgets. + */ + + +/** + * gail_misc_get_extents_from_pango_rectangle: + * @widget: The widget that contains the PangoLayout, that contains + * the PangoRectangle + * @char_rect: The #PangoRectangle from which to calculate extents + * @x_layout: The x-offset at which the widget displays the + * PangoLayout that contains the PangoRectangle, relative to @widget + * @y_layout: The y-offset at which the widget displays the + * PangoLayout that contains the PangoRectangle, relative to @widget + * @x: The x-position of the #PangoRectangle relative to @coords + * @y: The y-position of the #PangoRectangle relative to @coords + * @width: The width of the #PangoRectangle + * @height: The height of the #PangoRectangle + * @coords: An #AtkCoordType enumeration + * + * Gets the extents of @char_rect in device coordinates, + * relative to either top-level window or screen coordinates as + * specified by @coords. + **/ +void +gail_misc_get_extents_from_pango_rectangle (GtkWidget *widget, + PangoRectangle *char_rect, + gint x_layout, + gint y_layout, + gint *x, + gint *y, + gint *width, + gint *height, + AtkCoordType coords) +{ + gint x_window, y_window, x_toplevel, y_toplevel; + + gail_misc_get_origins (widget, &x_window, &y_window, + &x_toplevel, &y_toplevel); + + *x = (char_rect->x / PANGO_SCALE) + x_layout + x_window; + *y = (char_rect->y / PANGO_SCALE) + y_layout + y_window; + if (coords == ATK_XY_WINDOW) + { + *x -= x_toplevel; + *y -= y_toplevel; + } + else if (coords != ATK_XY_SCREEN) + { + *x = 0; + *y = 0; + *height = 0; + *width = 0; + return; + } + *height = char_rect->height / PANGO_SCALE; + *width = char_rect->width / PANGO_SCALE; + + return; +} + +/** + * gail_misc_get_index_at_point_in_layout: + * @widget: A #GtkWidget + * @layout: The #PangoLayout from which to get the index at the + * specified point. + * @x_layout: The x-offset at which the widget displays the + * #PangoLayout, relative to @widget + * @y_layout: The y-offset at which the widget displays the + * #PangoLayout, relative to @widget + * @x: The x-coordinate relative to @coords at which to + * calculate the index + * @y: The y-coordinate relative to @coords at which to + * calculate the index + * @coords: An #AtkCoordType enumeration + * + * Gets the byte offset at the specified @x and @y in a #PangoLayout. + * + * Returns: the byte offset at the specified @x and @y in a + * #PangoLayout + **/ +gint +gail_misc_get_index_at_point_in_layout (GtkWidget *widget, + PangoLayout *layout, + gint x_layout, + gint y_layout, + gint x, + gint y, + AtkCoordType coords) +{ + gint index, x_window, y_window, x_toplevel, y_toplevel; + gint x_temp, y_temp; + gboolean ret; + + gail_misc_get_origins (widget, &x_window, &y_window, + &x_toplevel, &y_toplevel); + x_temp = x - x_layout - x_window; + y_temp = y - y_layout - y_window; + if (coords == ATK_XY_WINDOW) + { + x_temp += x_toplevel; + y_temp += y_toplevel; + } + else if (coords != ATK_XY_SCREEN) + return -1; + + ret = pango_layout_xy_to_index (layout, + x_temp * PANGO_SCALE, + y_temp * PANGO_SCALE, + &index, NULL); + if (!ret) + { + if (x_temp < 0 || y_temp < 0) + index = 0; + else + index = -1; + } + return index; +} + +/** + * gail_misc_add_attribute: + * @attrib_set: The #AtkAttributeSet to add the attribute to + * @attr: The AtkTextAttrribute which identifies the attribute to be added + * @value: The attribute value + * + * Creates an #AtkAttribute from @attr and @value, and adds it + * to @attrib_set. + * + * Returns: A pointer to the new #AtkAttributeSet. + **/ +AtkAttributeSet* +gail_misc_add_attribute (AtkAttributeSet *attrib_set, + AtkTextAttribute attr, + gchar *value) +{ + AtkAttributeSet *return_set; + AtkAttribute *at = g_malloc (sizeof (AtkAttribute)); + at->name = g_strdup (atk_text_attribute_get_name (attr)); + at->value = value; + return_set = g_slist_prepend(attrib_set, at); + return return_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; +} + +/** + * gail_misc_get_default_attributes: + * @attrib_set: The #AtkAttributeSet to add the attribute to + * @layout: The PangoLayout from which the attributes will be obtained + * @widget: The GtkWidget for which the default attributes are required. + * + * Adds the default attributes to the specified attribute set. + * + * Returns: A pointer to the #AtkAttributeSet. + **/ +AtkAttributeSet* +gail_misc_get_default_attributes (AtkAttributeSet *attrib_set, + PangoLayout *layout, + GtkWidget *widget) +{ + PangoContext *context; + GtkStyleContext *style_context; + gint int_value; + PangoWrapMode mode; + GdkRGBA color; + gchar *value; + + attrib_set = gail_misc_add_attribute (attrib_set, + ATK_TEXT_ATTR_DIRECTION, + g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_DIRECTION, + gtk_widget_get_direction (widget)))); + + context = pango_layout_get_context (layout); + if (context) + { + PangoLanguage* language; + PangoFontDescription* font; + + language = pango_context_get_language (context); + if (language) + { + attrib_set = gail_misc_add_attribute (attrib_set, + ATK_TEXT_ATTR_LANGUAGE, + g_strdup (pango_language_to_string (language))); + } + font = pango_context_get_font_description (context); + if (font) + { + attrib_set = gail_misc_add_attribute (attrib_set, + ATK_TEXT_ATTR_STYLE, + g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_STYLE, + pango_font_description_get_style (font)))); + attrib_set = gail_misc_add_attribute (attrib_set, + ATK_TEXT_ATTR_VARIANT, + g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_VARIANT, + pango_font_description_get_variant (font)))); + attrib_set = gail_misc_add_attribute (attrib_set, + ATK_TEXT_ATTR_STRETCH, + g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_STRETCH, + pango_font_description_get_stretch (font)))); + attrib_set = gail_misc_add_attribute (attrib_set, + ATK_TEXT_ATTR_FAMILY_NAME, + g_strdup (pango_font_description_get_family (font))); + attrib_set = gail_misc_add_attribute (attrib_set, + ATK_TEXT_ATTR_WEIGHT, + g_strdup_printf ("%d", + pango_font_description_get_weight (font))); + attrib_set = gail_misc_add_attribute (attrib_set, + ATK_TEXT_ATTR_SIZE, + g_strdup_printf ("%i", + pango_font_description_get_size (font) / PANGO_SCALE)); + } + } + if (pango_layout_get_justify (layout)) + { + int_value = 3; + } + else + { + PangoAlignment align; + + align = pango_layout_get_alignment (layout); + if (align == PANGO_ALIGN_LEFT) + int_value = 0; + else if (align == PANGO_ALIGN_CENTER) + int_value = 2; + else /* if (align == PANGO_ALIGN_RIGHT) */ + int_value = 1; + } + attrib_set = gail_misc_add_attribute (attrib_set, + ATK_TEXT_ATTR_JUSTIFICATION, + g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_JUSTIFICATION, + int_value))); + mode = pango_layout_get_wrap (layout); + if (mode == PANGO_WRAP_WORD) + int_value = 2; + else /* if (mode == PANGO_WRAP_CHAR) */ + int_value = 1; + attrib_set = gail_misc_add_attribute (attrib_set, + ATK_TEXT_ATTR_WRAP_MODE, + g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_WRAP_MODE, + int_value))); + + style_context = gtk_widget_get_style_context (widget); + + gtk_style_context_get_background_color (style_context, 0, &color); + value = g_strdup_printf ("%u,%u,%u", + (guint) ceil (color.red * 65536 - color.red), + (guint) ceil (color.green * 65536 - color.green), + (guint) ceil (color.blue * 65536 - color.blue)); + attrib_set = gail_misc_add_attribute (attrib_set, + ATK_TEXT_ATTR_BG_COLOR, + value); + + gtk_style_context_get_color (style_context, 0, &color); + value = g_strdup_printf ("%u,%u,%u", + (guint) ceil (color.red * 65536 - color.red), + (guint) ceil (color.green * 65536 - color.green), + (guint) ceil (color.blue * 65536 - color.blue)); + attrib_set = gail_misc_add_attribute (attrib_set, + ATK_TEXT_ATTR_FG_COLOR, + value); + + attrib_set = gail_misc_add_attribute (attrib_set, + ATK_TEXT_ATTR_FG_STIPPLE, + g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_FG_STIPPLE, + 0))); + attrib_set = gail_misc_add_attribute (attrib_set, + ATK_TEXT_ATTR_BG_STIPPLE, + g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_BG_STIPPLE, + 0))); + attrib_set = gail_misc_add_attribute (attrib_set, + ATK_TEXT_ATTR_STRIKETHROUGH, + g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_STRIKETHROUGH, + 0))); + attrib_set = gail_misc_add_attribute (attrib_set, + ATK_TEXT_ATTR_UNDERLINE, + g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_UNDERLINE, + 0))); + attrib_set = gail_misc_add_attribute (attrib_set, + ATK_TEXT_ATTR_RISE, + g_strdup_printf ("%i", 0)); + attrib_set = gail_misc_add_attribute (attrib_set, + ATK_TEXT_ATTR_SCALE, + g_strdup_printf ("%g", 1.0)); + attrib_set = gail_misc_add_attribute (attrib_set, + ATK_TEXT_ATTR_BG_FULL_HEIGHT, + g_strdup_printf ("%i", 0)); + attrib_set = gail_misc_add_attribute (attrib_set, + ATK_TEXT_ATTR_PIXELS_INSIDE_WRAP, + g_strdup_printf ("%i", 0)); + attrib_set = gail_misc_add_attribute (attrib_set, + ATK_TEXT_ATTR_PIXELS_BELOW_LINES, + g_strdup_printf ("%i", 0)); + attrib_set = gail_misc_add_attribute (attrib_set, + ATK_TEXT_ATTR_PIXELS_ABOVE_LINES, + g_strdup_printf ("%i", 0)); + attrib_set = gail_misc_add_attribute (attrib_set, + ATK_TEXT_ATTR_EDITABLE, + g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_EDITABLE, + 0))); + attrib_set = gail_misc_add_attribute (attrib_set, + ATK_TEXT_ATTR_INVISIBLE, + g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_INVISIBLE, + 0))); + attrib_set = gail_misc_add_attribute (attrib_set, + ATK_TEXT_ATTR_INDENT, + g_strdup_printf ("%i", 0)); + attrib_set = gail_misc_add_attribute (attrib_set, + ATK_TEXT_ATTR_RIGHT_MARGIN, + g_strdup_printf ("%i", 0)); + attrib_set = gail_misc_add_attribute (attrib_set, + ATK_TEXT_ATTR_LEFT_MARGIN, + g_strdup_printf ("%i", 0)); + return attrib_set; +} + +/** + * gail_misc_get_origins: + * @widget: a #GtkWidget + * @x_window: the x-origin of the widget->window + * @y_window: the y-origin of the widget->window + * @x_toplevel: the x-origin of the toplevel window for widget->window + * @y_toplevel: the y-origin of the toplevel window for widget->window + * + * Gets the origin of the widget window, and the origin of the + * widgets top-level window. + **/ +void +gail_misc_get_origins (GtkWidget *widget, + gint *x_window, + gint *y_window, + gint *x_toplevel, + gint *y_toplevel) +{ + GdkWindow *window; + + if (GTK_IS_TREE_VIEW (widget)) + window = gtk_tree_view_get_bin_window (GTK_TREE_VIEW (widget)); + else + window = gtk_widget_get_window (widget); + + gdk_window_get_origin (window, x_window, y_window); + window = gdk_window_get_toplevel (gtk_widget_get_window (widget)); + gdk_window_get_origin (window, x_toplevel, y_toplevel); +} + +/** + * gail_misc_buffer_get_run_attributes: + * @buffer: The #GtkTextBuffer for which the attributes will be obtained + * @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 + * + * Creates an AtkAttributeSet which contains the attributes for the + * run starting at offset. + * + * Returns: A pointer to the #AtkAttributeSet. + **/ +AtkAttributeSet* +gail_misc_buffer_get_run_attributes (GtkTextBuffer *buffer, + gint offset, + gint *start_offset, + gint *end_offset) +{ + GtkTextIter iter; + AtkAttributeSet *attrib_set = NULL; + AtkAttribute *at; + GSList *tags, *temp_tags; + gdouble scale = 1; + gboolean val_set = FALSE; + + gtk_text_buffer_get_iter_at_offset (buffer, &iter, offset); + + gtk_text_iter_forward_to_tag_toggle (&iter, NULL); + *end_offset = gtk_text_iter_get_offset (&iter); + + gtk_text_iter_backward_to_tag_toggle (&iter, NULL); + *start_offset = gtk_text_iter_get_offset (&iter); + + gtk_text_buffer_get_iter_at_offset (buffer, &iter, offset); + + tags = gtk_text_iter_get_tags (&iter); + tags = g_slist_reverse (tags); + + temp_tags = tags; + while (temp_tags && !val_set) + { + GtkTextTag *tag = GTK_TEXT_TAG (temp_tags->data); + + g_object_get (tag, "style-set", &val_set, NULL); + if (val_set) + { + PangoStyle style; + gchar *value; + + g_object_get (tag, "style", &style, NULL); + value = g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_STYLE, style)); + attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_STYLE, value); + } + temp_tags = temp_tags->next; + } + val_set = FALSE; + + temp_tags = tags; + while (temp_tags && !val_set) + { + GtkTextTag *tag = GTK_TEXT_TAG (temp_tags->data); + + g_object_get (tag, "variant-set", &val_set, NULL); + if (val_set) + { + PangoVariant variant; + gchar *value; + + g_object_get (tag, "variant", &variant, NULL); + value = g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_VARIANT, variant)); + attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_VARIANT, value); + } + temp_tags = temp_tags->next; + } + val_set = FALSE; + + temp_tags = tags; + while (temp_tags && !val_set) + { + GtkTextTag *tag = GTK_TEXT_TAG (temp_tags->data); + + g_object_get (tag, "stretch-set", &val_set, NULL); + if (val_set) + { + PangoStretch stretch; + gchar *value; + + g_object_get (tag, "stretch", &stretch, NULL); + value = g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_STRETCH, stretch)); + attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_STRETCH, value); + } + temp_tags = temp_tags->next; + } + val_set = FALSE; + + temp_tags = tags; + while (temp_tags && !val_set) + { + GtkTextTag *tag = GTK_TEXT_TAG (temp_tags->data); + + g_object_get (tag, "justification-set", &val_set, NULL); + if (val_set) + { + GtkJustification justification; + gchar *value; + + g_object_get (tag, "justification", &justification, NULL); + value = g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_JUSTIFICATION, justification)); + attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_JUSTIFICATION, value); + } + temp_tags = temp_tags->next; + } + val_set = FALSE; + + temp_tags = tags; + while (temp_tags && !val_set) + { + GtkTextTag *tag = GTK_TEXT_TAG (temp_tags->data); + GtkTextDirection direction; + + g_object_get (tag, "direction", &direction, NULL); + + if (direction != GTK_TEXT_DIR_NONE) + { + gchar *value; + val_set = TRUE; + value = g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_DIRECTION, direction)); + attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_DIRECTION, value); + } + temp_tags = temp_tags->next; + } + val_set = FALSE; + + temp_tags = tags; + while (temp_tags && !val_set) + { + GtkTextTag *tag = GTK_TEXT_TAG (temp_tags->data); + + g_object_get (tag, "wrap-mode-set", &val_set, NULL); + if (val_set) + { + GtkWrapMode wrap_mode; + gchar *value; + + g_object_get (tag, "wrap-mode", &wrap_mode, NULL); + value = g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_WRAP_MODE, wrap_mode)); + attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_WRAP_MODE, value); + } + temp_tags = temp_tags->next; + } + val_set = FALSE; + + temp_tags = tags; + while (temp_tags && !val_set) + { + GtkTextTag *tag = GTK_TEXT_TAG (temp_tags->data); + + g_object_get (tag, "foreground-set", &val_set, NULL); + if (val_set) + { + GdkRGBA *rgba; + gchar *value; + + g_object_get (tag, "foreground-rgba", &rgba, NULL); + value = g_strdup_printf ("%u,%u,%u", + (guint) rgba->red * 65535, + (guint) rgba->green * 65535, + (guint) rgba->blue * 65535); + gdk_rgba_free (rgba); + attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_FG_COLOR, value); + } + temp_tags = temp_tags->next; + } + val_set = FALSE; + + temp_tags = tags; + while (temp_tags && !val_set) + { + GtkTextTag *tag = GTK_TEXT_TAG (temp_tags->data); + + g_object_get (tag, "background-set", &val_set, NULL); + if (val_set) + { + GdkRGBA *rgba; + gchar *value; + + g_object_get (tag, "background-rgba", &rgba, NULL); + value = g_strdup_printf ("%u,%u,%u", + (guint) rgba->red * 65535, + (guint) rgba->green * 65535, + (guint) rgba->blue * 65535); + gdk_rgba_free (rgba); + attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_BG_COLOR, value); + } + temp_tags = temp_tags->next; + } + val_set = FALSE; + + temp_tags = tags; + while (temp_tags && !val_set) + { + GtkTextTag *tag = GTK_TEXT_TAG (temp_tags->data); + + g_object_get (tag, "family-set", &val_set, NULL); + + if (val_set) + { + gchar *value; + g_object_get (tag, "family", &value, NULL); + attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_FAMILY_NAME, value); + } + temp_tags = temp_tags->next; + } + val_set = FALSE; + + temp_tags = tags; + while (temp_tags && !val_set) + { + GtkTextTag *tag = GTK_TEXT_TAG (temp_tags->data); + + g_object_get (tag, "language-set", &val_set, NULL); + + if (val_set) + { + gchar *value; + g_object_get (tag, "language", &value, NULL); + attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_LANGUAGE, value); + } + temp_tags = temp_tags->next; + } + val_set = FALSE; + + temp_tags = tags; + while (temp_tags && !val_set) + { + GtkTextTag *tag = GTK_TEXT_TAG (temp_tags->data); + + g_object_get (tag, "weight-set", &val_set, NULL); + + if (val_set) + { + gint weight; + gchar *value; + + g_object_get (tag, "weight", &weight, NULL); + value = g_strdup_printf ("%d", weight); + attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_WEIGHT, value); + } + temp_tags = temp_tags->next; + } + val_set = FALSE; + + + /* + * scale is special as the scale is the product of all scale values + * specified. + */ + temp_tags = tags; + while (temp_tags) + { + GtkTextTag *tag = GTK_TEXT_TAG (temp_tags->data); + gboolean scale_set; + + g_object_get (tag, "scale-set", &scale_set, NULL); + if (scale_set) + { + gdouble font_scale; + + g_object_get (tag, "scale", &font_scale, NULL); + val_set = TRUE; + scale *= font_scale; + } + temp_tags = temp_tags->next; + } + if (val_set) + { + at = g_malloc(sizeof(AtkAttribute)); + at->name = g_strdup(atk_text_attribute_get_name (ATK_TEXT_ATTR_SCALE)); + at->value = g_strdup_printf("%g", scale); + attrib_set = g_slist_prepend(attrib_set, at); + } + val_set = FALSE; + + temp_tags = tags; + while (temp_tags && !val_set) + { + GtkTextTag *tag = GTK_TEXT_TAG (temp_tags->data); + + g_object_get (tag, "size-set", &val_set, NULL); + if (val_set) + { + gint size; + gchar *value; + g_object_get (tag, "size", &size, NULL); + value = g_strdup_printf ("%i", size); + attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_SIZE, value); + } + temp_tags = temp_tags->next; + } + val_set = FALSE; + + temp_tags = tags; + while (temp_tags && !val_set) + { + GtkTextTag *tag = GTK_TEXT_TAG (temp_tags->data); + + g_object_get (tag, "strikethrough-set", &val_set, NULL); + if (val_set) + { + gboolean strikethrough; + gchar *value; + g_object_get (tag, "strikethrough", &strikethrough, NULL); + value = g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_STRIKETHROUGH, strikethrough)); + attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_STRIKETHROUGH, value); + } + temp_tags = temp_tags->next; + } + val_set = FALSE; + + temp_tags = tags; + while (temp_tags && !val_set) + { + GtkTextTag *tag = GTK_TEXT_TAG (temp_tags->data); + + g_object_get (tag, "underline-set", &val_set, NULL); + if (val_set) + { + PangoUnderline underline; + gchar *value; + g_object_get (tag, "underline", &underline, NULL); + value = g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_UNDERLINE, underline)); + attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_UNDERLINE, value); + } + temp_tags = temp_tags->next; + } + val_set = FALSE; + + temp_tags = tags; + while (temp_tags && !val_set) + { + GtkTextTag *tag = GTK_TEXT_TAG (temp_tags->data); + + g_object_get (tag, "rise-set", &val_set, NULL); + if (val_set) + { + gint rise; + gchar *value; + g_object_get (tag, "rise", &rise, NULL); + value = g_strdup_printf ("%i", rise); + attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_RISE, value); + } + temp_tags = temp_tags->next; + } + val_set = FALSE; + + temp_tags = tags; + while (temp_tags && !val_set) + { + GtkTextTag *tag = GTK_TEXT_TAG (temp_tags->data); + + g_object_get (tag, "background-full-height-set", &val_set, NULL); + if (val_set) + { + gboolean bg_full_height; + gchar *value; + g_object_get (tag, "background-full-height", &bg_full_height, NULL); + value = g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_BG_FULL_HEIGHT, bg_full_height)); + attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_BG_FULL_HEIGHT, value); + } + temp_tags = temp_tags->next; + } + val_set = FALSE; + + temp_tags = tags; + while (temp_tags && !val_set) + { + GtkTextTag *tag = GTK_TEXT_TAG (temp_tags->data); + + g_object_get (tag, "pixels-inside-wrap-set", &val_set, NULL); + if (val_set) + { + gint pixels; + gchar *value; + g_object_get (tag, "pixels-inside-wrap", &pixels, NULL); + value = g_strdup_printf ("%i", pixels); + attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_PIXELS_INSIDE_WRAP, value); + } + temp_tags = temp_tags->next; + } + val_set = FALSE; + + temp_tags = tags; + while (temp_tags && !val_set) + { + GtkTextTag *tag = GTK_TEXT_TAG (temp_tags->data); + + g_object_get (tag, "pixels-below-lines-set", &val_set, NULL); + if (val_set) + { + gint pixels; + gchar *value; + g_object_get (tag, "pixels-below-lines", &pixels, NULL); + value = g_strdup_printf ("%i", pixels); + attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_PIXELS_BELOW_LINES, value); + } + temp_tags = temp_tags->next; + } + val_set = FALSE; + + temp_tags = tags; + while (temp_tags && !val_set) + { + GtkTextTag *tag = GTK_TEXT_TAG (temp_tags->data); + + g_object_get (tag, "pixels-above-lines-set", &val_set, NULL); + if (val_set) + { + gint pixels; + gchar *value; + g_object_get (tag, "pixels-above-lines", &pixels, NULL); + value = g_strdup_printf ("%i", pixels); + attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_PIXELS_ABOVE_LINES, value); + } + temp_tags = temp_tags->next; + } + val_set = FALSE; + + temp_tags = tags; + while (temp_tags && !val_set) + { + GtkTextTag *tag = GTK_TEXT_TAG (temp_tags->data); + + g_object_get (tag, "editable-set", &val_set, NULL); + if (val_set) + { + gboolean editable; + gchar *value; + g_object_get (tag, "editable", &editable, NULL); + value = g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_EDITABLE, editable)); + attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_EDITABLE, value); + } + temp_tags = temp_tags->next; + } + val_set = FALSE; + + temp_tags = tags; + while (temp_tags && !val_set) + { + GtkTextTag *tag = GTK_TEXT_TAG (temp_tags->data); + + g_object_get (tag, "invisible-set", &val_set, NULL); + if (val_set) + { + gboolean invisible; + gchar *value; + g_object_get (tag, "invisible", &invisible, NULL); + value = g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_INVISIBLE, invisible)); + attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_INVISIBLE, value); + } + temp_tags = temp_tags->next; + } + val_set = FALSE; + + temp_tags = tags; + while (temp_tags && !val_set) + { + GtkTextTag *tag = GTK_TEXT_TAG (temp_tags->data); + + g_object_get (tag, "indent-set", &val_set, NULL); + if (val_set) + { + gint indent; + gchar *value; + g_object_get (tag, "indent", &indent, NULL); + value = g_strdup_printf ("%i", indent); + attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_INDENT, value); + } + temp_tags = temp_tags->next; + } + val_set = FALSE; + + temp_tags = tags; + while (temp_tags && !val_set) + { + GtkTextTag *tag = GTK_TEXT_TAG (temp_tags->data); + + g_object_get (tag, "right-margin-set", &val_set, NULL); + if (val_set) + { + gint margin; + gchar *value; + g_object_get (tag, "right-margin", &margin, NULL); + value = g_strdup_printf ("%i", margin); + attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_RIGHT_MARGIN, value); + } + temp_tags = temp_tags->next; + } + val_set = FALSE; + + temp_tags = tags; + while (temp_tags && !val_set) + { + GtkTextTag *tag = GTK_TEXT_TAG (temp_tags->data); + + g_object_get (tag, "left-margin-set", &val_set, NULL); + if (val_set) + { + gint margin; + gchar *value; + g_object_get (tag, "left-margin", &margin, NULL); + value = g_strdup_printf ("%i", margin); + attrib_set = gail_misc_add_attribute (attrib_set, ATK_TEXT_ATTR_LEFT_MARGIN, value); + } + temp_tags = temp_tags->next; + } + val_set = FALSE; + + g_slist_free (tags); + return attrib_set; +} diff --git a/gtk/a11y/gailmisc.h b/gtk/a11y/gailmisc.h new file mode 100644 index 000000000..9483755c7 --- /dev/null +++ b/gtk/a11y/gailmisc.h @@ -0,0 +1,78 @@ +/* GAIL - The GNOME Accessibility Implementation Library + * Copyright 2001 Sun Microsystems Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifndef __GAIL_MISC_H__ +#define __GAIL_MISC_H__ + +#include +#include +#include + +G_BEGIN_DECLS + +AtkAttributeSet* gail_misc_add_attribute (AtkAttributeSet *attrib_set, + AtkTextAttribute attr, + gchar *value); +AtkAttributeSet* gail_misc_layout_get_run_attributes + (AtkAttributeSet *attrib_set, + PangoLayout *layout, + const gchar *text, + gint offset, + gint *start_offset, + gint *end_offset); + +AtkAttributeSet* gail_misc_get_default_attributes (AtkAttributeSet *attrib_set, + PangoLayout *layout, + GtkWidget *widget); + +void gail_misc_get_extents_from_pango_rectangle + (GtkWidget *widget, + PangoRectangle *char_rect, + gint x_layout, + gint y_layout, + gint *x, + gint *y, + gint *width, + gint *height, + AtkCoordType coords); + +gint gail_misc_get_index_at_point_in_layout + (GtkWidget *widget, + PangoLayout *layout, + gint x_layout, + gint y_layout, + gint x, + gint y, + AtkCoordType coords); + +void gail_misc_get_origins (GtkWidget *widget, + gint *x_window, + gint *y_window, + gint *x_toplevel, + gint *y_toplevel); + +AtkAttributeSet* gail_misc_buffer_get_run_attributes + (GtkTextBuffer *buffer, + gint offset, + gint *start_offset, + gint *end_offset); + +G_END_DECLS + +#endif /*__GAIL_MISC_H__ */ diff --git a/gtk/a11y/gailnotebookpage.h b/gtk/a11y/gailnotebookpage.h index bcf26f283..a87e0722d 100644 --- a/gtk/a11y/gailnotebookpage.h +++ b/gtk/a11y/gailnotebookpage.h @@ -21,7 +21,7 @@ #define __GAIL_NOTEBOOK_PAGE_H__ #include "gailnotebook.h" -#include +#include "gailtextutil.h" G_BEGIN_DECLS diff --git a/gtk/a11y/gailscale.h b/gtk/a11y/gailscale.h index 20d88da67..d0c843fbb 100644 --- a/gtk/a11y/gailscale.h +++ b/gtk/a11y/gailscale.h @@ -21,7 +21,7 @@ #define __GAIL_SCALE_H__ #include "gailrange.h" -#include +#include "gailtextutil.h" G_BEGIN_DECLS diff --git a/gtk/a11y/gailstatusbar.h b/gtk/a11y/gailstatusbar.h index cb9ff0958..5e94649d7 100644 --- a/gtk/a11y/gailstatusbar.h +++ b/gtk/a11y/gailstatusbar.h @@ -21,7 +21,7 @@ #define __GAIL_STATUSBAR_H__ #include "gailcontainer.h" -#include +#include "gailtextutil.h" G_BEGIN_DECLS diff --git a/gtk/a11y/gailtextcell.h b/gtk/a11y/gailtextcell.h index 3ce742a16..b5f8adb4e 100644 --- a/gtk/a11y/gailtextcell.h +++ b/gtk/a11y/gailtextcell.h @@ -22,7 +22,7 @@ #include #include "gailrenderercell.h" -#include +#include "gailtextutil.h" G_BEGIN_DECLS diff --git a/gtk/a11y/gailtextutil.c b/gtk/a11y/gailtextutil.c new file mode 100644 index 000000000..ecfd8ef78 --- /dev/null +++ b/gtk/a11y/gailtextutil.c @@ -0,0 +1,786 @@ +/* GAIL - The GNOME Accessibility Implementation Library + * Copyright 2001 Sun Microsystems Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#include "config.h" + +#include +#include "gailtextutil.h" + +/** + * SECTION:gailtextutil + * @Short_description: GailTextUtil is a utility class which can be used to + * implement some of the #AtkText functions for accessible objects + * which implement #AtkText. + * @Title: GailTextUtil + * + * GailTextUtil is a utility class which can be used to implement the + * #AtkText functions which get text for accessible objects which implement + * #AtkText. + * + * In GAIL it is used by the accsesible objects for #GnomeCanvasText, #GtkEntry, + * #GtkLabel, #GtkCellRendererText and #GtkTextView. + */ + +static void gail_text_util_class_init (GailTextUtilClass *klass); + +static void gail_text_util_init (GailTextUtil *textutil); +static void gail_text_util_finalize (GObject *object); + + +static void get_pango_text_offsets (PangoLayout *layout, + GtkTextBuffer *buffer, + GailOffsetType function, + AtkTextBoundary boundary_type, + gint offset, + gint *start_offset, + gint *end_offset, + GtkTextIter *start_iter, + GtkTextIter *end_iter); +static GObjectClass *parent_class = NULL; + +GType +gail_text_util_get_type(void) +{ + static GType type = 0; + + if (!type) + { + const GTypeInfo tinfo = + { + sizeof (GailTextUtilClass), + (GBaseInitFunc) NULL, /* base init */ + (GBaseFinalizeFunc) NULL, /* base finalize */ + (GClassInitFunc) gail_text_util_class_init, + (GClassFinalizeFunc) NULL, /* class finalize */ + NULL, /* class data */ + sizeof(GailTextUtil), + 0, /* nb preallocs */ + (GInstanceInitFunc) gail_text_util_init, + NULL, /* value table */ + }; + + type = g_type_register_static (G_TYPE_OBJECT, "GailTextUtil", &tinfo, 0); + } + return type; +} + +/** + * gail_text_util_new: + * + * This function creates a new GailTextUtil object. + * + * Returns: the GailTextUtil object + **/ +GailTextUtil* +gail_text_util_new (void) +{ + return GAIL_TEXT_UTIL (g_object_new (GAIL_TYPE_TEXT_UTIL, NULL)); +} + +static void +gail_text_util_init (GailTextUtil *textutil) +{ + textutil->buffer = NULL; +} + +static void +gail_text_util_class_init (GailTextUtilClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + gobject_class->finalize = gail_text_util_finalize; +} + +static void +gail_text_util_finalize (GObject *object) +{ + GailTextUtil *textutil = GAIL_TEXT_UTIL (object); + + if (textutil->buffer) + g_object_unref (textutil->buffer); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +/** + * gail_text_util_text_setup: + * @textutil: The #GailTextUtil to be initialized. + * @text: A gchar* which points to the text to be stored in the GailTextUtil + * + * This function initializes the GailTextUtil with the specified character string, + **/ +void +gail_text_util_text_setup (GailTextUtil *textutil, + const gchar *text) +{ + g_return_if_fail (GAIL_IS_TEXT_UTIL (textutil)); + + if (textutil->buffer) + { + if (!text) + { + g_object_unref (textutil->buffer); + textutil->buffer = NULL; + return; + } + } + else + { + textutil->buffer = gtk_text_buffer_new (NULL); + } + + gtk_text_buffer_set_text (textutil->buffer, text, -1); +} + +/** + * gail_text_util_buffer_setup: + * @textutil: A #GailTextUtil to be initialized + * @buffer: The #GtkTextBuffer which identifies the text to be stored in the GailUtil. + * + * This function initializes the GailTextUtil with the specified GtkTextBuffer + **/ +void +gail_text_util_buffer_setup (GailTextUtil *textutil, + GtkTextBuffer *buffer) +{ + g_return_if_fail (GAIL_IS_TEXT_UTIL (textutil)); + + textutil->buffer = g_object_ref (buffer); +} + +/** + * gail_text_util_get_text: + * @textutil: A #GailTextUtil + * @layout: A gpointer which is a PangoLayout, a GtkTreeView of NULL + * @function: An enumeration specifying whether to return the text before, at, or + * after the offset. + * @boundary_type: The boundary type. + * @offset: The offset of the text in the GailTextUtil + * @start_offset: Address of location in which the start offset is returned + * @end_offset: Address of location in which the end offset is returned + * + * This function gets the requested substring from the text in the GtkTextUtil. + * The layout is used only for getting the text on a line. The value is NULL + * for a GtkTextView which is not wrapped, is a GtkTextView for a GtkTextView + * which is wrapped and is a PangoLayout otherwise. + * + * Returns: the substring requested + **/ +gchar* +gail_text_util_get_text (GailTextUtil *textutil, + gpointer layout, + GailOffsetType function, + AtkTextBoundary boundary_type, + gint offset, + gint *start_offset, + gint *end_offset) +{ + GtkTextIter start, end; + gint line_number; + GtkTextBuffer *buffer; + + g_return_val_if_fail (GAIL_IS_TEXT_UTIL (textutil), NULL); + + buffer = textutil->buffer; + if (buffer == NULL) + { + *start_offset = 0; + *end_offset = 0; + return NULL; + } + + if (!gtk_text_buffer_get_char_count (buffer)) + { + *start_offset = 0; + *end_offset = 0; + return g_strdup (""); + } + gtk_text_buffer_get_iter_at_offset (buffer, &start, offset); + + + end = start; + + switch (function) + { + case GAIL_BEFORE_OFFSET: + switch (boundary_type) + { + case ATK_TEXT_BOUNDARY_CHAR: + gtk_text_iter_backward_char(&start); + break; + case ATK_TEXT_BOUNDARY_WORD_START: + if (!gtk_text_iter_starts_word (&start)) + gtk_text_iter_backward_word_start (&start); + end = start; + gtk_text_iter_backward_word_start(&start); + break; + case ATK_TEXT_BOUNDARY_WORD_END: + if (gtk_text_iter_inside_word (&start) && + !gtk_text_iter_starts_word (&start)) + gtk_text_iter_backward_word_start (&start); + while (!gtk_text_iter_ends_word (&start)) + { + if (!gtk_text_iter_backward_char (&start)) + break; + } + end = start; + gtk_text_iter_backward_word_start(&start); + while (!gtk_text_iter_ends_word (&start)) + { + if (!gtk_text_iter_backward_char (&start)) + break; + } + break; + case ATK_TEXT_BOUNDARY_SENTENCE_START: + if (!gtk_text_iter_starts_sentence (&start)) + gtk_text_iter_backward_sentence_start (&start); + end = start; + gtk_text_iter_backward_sentence_start (&start); + break; + case ATK_TEXT_BOUNDARY_SENTENCE_END: + if (gtk_text_iter_inside_sentence (&start) && + !gtk_text_iter_starts_sentence (&start)) + gtk_text_iter_backward_sentence_start (&start); + while (!gtk_text_iter_ends_sentence (&start)) + { + if (!gtk_text_iter_backward_char (&start)) + break; + } + end = start; + gtk_text_iter_backward_sentence_start (&start); + while (!gtk_text_iter_ends_sentence (&start)) + { + if (!gtk_text_iter_backward_char (&start)) + break; + } + break; + case ATK_TEXT_BOUNDARY_LINE_START: + if (layout == NULL) + { + line_number = gtk_text_iter_get_line (&start); + if (line_number == 0) + { + gtk_text_buffer_get_iter_at_offset (buffer, + &start, 0); + } + else + { + gtk_text_iter_backward_line (&start); + gtk_text_iter_forward_line (&start); + } + end = start; + gtk_text_iter_backward_line (&start); + } + else if GTK_IS_TEXT_VIEW (layout) + { + GtkTextView *view = GTK_TEXT_VIEW (layout); + + gtk_text_view_backward_display_line_start (view, &start); + end = start; + gtk_text_view_backward_display_line (view, &start); + } + else if (PANGO_IS_LAYOUT (layout)) + get_pango_text_offsets (PANGO_LAYOUT (layout), + buffer, + function, + boundary_type, + offset, + start_offset, + end_offset, + &start, + &end); + break; + case ATK_TEXT_BOUNDARY_LINE_END: + if (layout == NULL) + { + line_number = gtk_text_iter_get_line (&start); + if (line_number == 0) + { + gtk_text_buffer_get_iter_at_offset (buffer, + &start, 0); + end = start; + } + else + { + gtk_text_iter_backward_line (&start); + end = start; + while (!gtk_text_iter_ends_line (&start)) + { + if (!gtk_text_iter_backward_char (&start)) + break; + } + gtk_text_iter_forward_to_line_end (&end); + } + } + else if GTK_IS_TEXT_VIEW (layout) + { + GtkTextView *view = GTK_TEXT_VIEW (layout); + + gtk_text_view_backward_display_line_start (view, &start); + if (!gtk_text_iter_is_start (&start)) + { + gtk_text_view_backward_display_line (view, &start); + end = start; + if (!gtk_text_iter_is_start (&start)) + { + gtk_text_view_backward_display_line (view, &start); + gtk_text_view_forward_display_line_end (view, &start); + } + gtk_text_view_forward_display_line_end (view, &end); + } + else + { + end = start; + } + } + else if (PANGO_IS_LAYOUT (layout)) + get_pango_text_offsets (PANGO_LAYOUT (layout), + buffer, + function, + boundary_type, + offset, + start_offset, + end_offset, + &start, + &end); + break; + } + break; + + case GAIL_AT_OFFSET: + switch (boundary_type) + { + case ATK_TEXT_BOUNDARY_CHAR: + gtk_text_iter_forward_char (&end); + break; + case ATK_TEXT_BOUNDARY_WORD_START: + if (!gtk_text_iter_starts_word (&start)) + gtk_text_iter_backward_word_start (&start); + if (gtk_text_iter_inside_word (&end)) + gtk_text_iter_forward_word_end (&end); + while (!gtk_text_iter_starts_word (&end)) + { + if (!gtk_text_iter_forward_char (&end)) + break; + } + break; + case ATK_TEXT_BOUNDARY_WORD_END: + if (gtk_text_iter_inside_word (&start) && + !gtk_text_iter_starts_word (&start)) + gtk_text_iter_backward_word_start (&start); + while (!gtk_text_iter_ends_word (&start)) + { + if (!gtk_text_iter_backward_char (&start)) + break; + } + gtk_text_iter_forward_word_end (&end); + break; + case ATK_TEXT_BOUNDARY_SENTENCE_START: + if (!gtk_text_iter_starts_sentence (&start)) + gtk_text_iter_backward_sentence_start (&start); + if (gtk_text_iter_inside_sentence (&end)) + gtk_text_iter_forward_sentence_end (&end); + while (!gtk_text_iter_starts_sentence (&end)) + { + if (!gtk_text_iter_forward_char (&end)) + break; + } + break; + case ATK_TEXT_BOUNDARY_SENTENCE_END: + if (gtk_text_iter_inside_sentence (&start) && + !gtk_text_iter_starts_sentence (&start)) + gtk_text_iter_backward_sentence_start (&start); + while (!gtk_text_iter_ends_sentence (&start)) + { + if (!gtk_text_iter_backward_char (&start)) + break; + } + gtk_text_iter_forward_sentence_end (&end); + break; + case ATK_TEXT_BOUNDARY_LINE_START: + if (layout == NULL) + { + line_number = gtk_text_iter_get_line (&start); + if (line_number == 0) + { + gtk_text_buffer_get_iter_at_offset (buffer, + &start, 0); + } + else + { + gtk_text_iter_backward_line (&start); + gtk_text_iter_forward_line (&start); + } + gtk_text_iter_forward_line (&end); + } + else if GTK_IS_TEXT_VIEW (layout) + { + GtkTextView *view = GTK_TEXT_VIEW (layout); + + gtk_text_view_backward_display_line_start (view, &start); + /* + * The call to gtk_text_iter_forward_to_end() is needed + * because of bug 81960 + */ + if (!gtk_text_view_forward_display_line (view, &end)) + gtk_text_iter_forward_to_end (&end); + } + else if PANGO_IS_LAYOUT (layout) + get_pango_text_offsets (PANGO_LAYOUT (layout), + buffer, + function, + boundary_type, + offset, + start_offset, + end_offset, + &start, + &end); + + break; + case ATK_TEXT_BOUNDARY_LINE_END: + if (layout == NULL) + { + line_number = gtk_text_iter_get_line (&start); + if (line_number == 0) + { + gtk_text_buffer_get_iter_at_offset (buffer, + &start, 0); + } + else + { + gtk_text_iter_backward_line (&start); + gtk_text_iter_forward_line (&start); + } + while (!gtk_text_iter_ends_line (&start)) + { + if (!gtk_text_iter_backward_char (&start)) + break; + } + gtk_text_iter_forward_to_line_end (&end); + } + else if GTK_IS_TEXT_VIEW (layout) + { + GtkTextView *view = GTK_TEXT_VIEW (layout); + + gtk_text_view_backward_display_line_start (view, &start); + if (!gtk_text_iter_is_start (&start)) + { + gtk_text_view_backward_display_line (view, &start); + gtk_text_view_forward_display_line_end (view, &start); + } + gtk_text_view_forward_display_line_end (view, &end); + } + else if PANGO_IS_LAYOUT (layout) + get_pango_text_offsets (PANGO_LAYOUT (layout), + buffer, + function, + boundary_type, + offset, + start_offset, + end_offset, + &start, + &end); + break; + } + break; + + case GAIL_AFTER_OFFSET: + switch (boundary_type) + { + case ATK_TEXT_BOUNDARY_CHAR: + gtk_text_iter_forward_char(&start); + gtk_text_iter_forward_chars(&end, 2); + break; + case ATK_TEXT_BOUNDARY_WORD_START: + if (gtk_text_iter_inside_word (&end)) + gtk_text_iter_forward_word_end (&end); + while (!gtk_text_iter_starts_word (&end)) + { + if (!gtk_text_iter_forward_char (&end)) + break; + } + start = end; + if (!gtk_text_iter_is_end (&end)) + { + gtk_text_iter_forward_word_end (&end); + while (!gtk_text_iter_starts_word (&end)) + { + if (!gtk_text_iter_forward_char (&end)) + break; + } + } + break; + case ATK_TEXT_BOUNDARY_WORD_END: + gtk_text_iter_forward_word_end (&end); + start = end; + if (!gtk_text_iter_is_end (&end)) + gtk_text_iter_forward_word_end (&end); + break; + case ATK_TEXT_BOUNDARY_SENTENCE_START: + if (gtk_text_iter_inside_sentence (&end)) + gtk_text_iter_forward_sentence_end (&end); + while (!gtk_text_iter_starts_sentence (&end)) + { + if (!gtk_text_iter_forward_char (&end)) + break; + } + start = end; + if (!gtk_text_iter_is_end (&end)) + { + gtk_text_iter_forward_sentence_end (&end); + while (!gtk_text_iter_starts_sentence (&end)) + { + if (!gtk_text_iter_forward_char (&end)) + break; + } + } + break; + case ATK_TEXT_BOUNDARY_SENTENCE_END: + gtk_text_iter_forward_sentence_end (&end); + start = end; + if (!gtk_text_iter_is_end (&end)) + gtk_text_iter_forward_sentence_end (&end); + break; + case ATK_TEXT_BOUNDARY_LINE_START: + if (layout == NULL) + { + gtk_text_iter_forward_line (&end); + start = end; + gtk_text_iter_forward_line (&end); + } + else if GTK_IS_TEXT_VIEW (layout) + { + GtkTextView *view = GTK_TEXT_VIEW (layout); + + gtk_text_view_forward_display_line (view, &end); + start = end; + gtk_text_view_forward_display_line (view, &end); + } + else if (PANGO_IS_LAYOUT (layout)) + get_pango_text_offsets (PANGO_LAYOUT (layout), + buffer, + function, + boundary_type, + offset, + start_offset, + end_offset, + &start, + &end); + break; + case ATK_TEXT_BOUNDARY_LINE_END: + if (layout == NULL) + { + gtk_text_iter_forward_line (&start); + end = start; + if (!gtk_text_iter_is_end (&start)) + { + while (!gtk_text_iter_ends_line (&start)) + { + if (!gtk_text_iter_backward_char (&start)) + break; + } + gtk_text_iter_forward_to_line_end (&end); + } + } + else if GTK_IS_TEXT_VIEW (layout) + { + GtkTextView *view = GTK_TEXT_VIEW (layout); + + gtk_text_view_forward_display_line_end (view, &end); + start = end; + gtk_text_view_forward_display_line (view, &end); + gtk_text_view_forward_display_line_end (view, &end); + } + else if (PANGO_IS_LAYOUT (layout)) + get_pango_text_offsets (PANGO_LAYOUT (layout), + buffer, + function, + boundary_type, + offset, + start_offset, + end_offset, + &start, + &end); + break; + } + break; + } + *start_offset = gtk_text_iter_get_offset (&start); + *end_offset = gtk_text_iter_get_offset (&end); + + return gtk_text_buffer_get_text (buffer, &start, &end, FALSE); +} + +/** + * gail_text_util_get_substring: + * @textutil: A #GailTextUtil + * @start_pos: The start position of the substring + * @end_pos: The end position of the substring. + * + * Gets the substring indicated by @start_pos and @end_pos + * + * Returns: the substring indicated by @start_pos and @end_pos + **/ +gchar* +gail_text_util_get_substring (GailTextUtil *textutil, + gint start_pos, + gint end_pos) +{ + GtkTextIter start, end; + GtkTextBuffer *buffer; + + g_return_val_if_fail(GAIL_IS_TEXT_UTIL (textutil), NULL); + + buffer = textutil->buffer; + if (buffer == NULL) + return NULL; + + gtk_text_buffer_get_iter_at_offset (buffer, &start, start_pos); + if (end_pos < 0) + gtk_text_buffer_get_end_iter (buffer, &end); + else + gtk_text_buffer_get_iter_at_offset (buffer, &end, end_pos); + + return gtk_text_buffer_get_text (buffer, &start, &end, FALSE); +} + +static void +get_pango_text_offsets (PangoLayout *layout, + GtkTextBuffer *buffer, + GailOffsetType function, + AtkTextBoundary boundary_type, + gint offset, + gint *start_offset, + gint *end_offset, + GtkTextIter *start_iter, + GtkTextIter *end_iter) +{ + PangoLayoutIter *iter; + PangoLayoutLine *line, *prev_line = NULL, *prev_prev_line = NULL; + gint index, start_index, end_index; + const gchar *text; + gboolean found = FALSE; + + text = pango_layout_get_text (layout); + index = g_utf8_offset_to_pointer (text, offset) - text; + iter = pango_layout_get_iter (layout); + do + { + line = pango_layout_iter_get_line (iter); + start_index = line->start_index; + end_index = start_index + line->length; + + if (index >= start_index && index <= end_index) + { + /* + * Found line for offset + */ + switch (function) + { + case GAIL_BEFORE_OFFSET: + /* + * We want the previous line + */ + if (prev_line) + { + switch (boundary_type) + { + case ATK_TEXT_BOUNDARY_LINE_START: + end_index = start_index; + start_index = prev_line->start_index; + break; + case ATK_TEXT_BOUNDARY_LINE_END: + if (prev_prev_line) + start_index = prev_prev_line->start_index + + prev_prev_line->length; + end_index = prev_line->start_index + prev_line->length; + break; + default: + g_assert_not_reached(); + } + } + else + start_index = end_index = 0; + break; + case GAIL_AT_OFFSET: + switch (boundary_type) + { + case ATK_TEXT_BOUNDARY_LINE_START: + if (pango_layout_iter_next_line (iter)) + end_index = pango_layout_iter_get_line (iter)->start_index; + break; + case ATK_TEXT_BOUNDARY_LINE_END: + if (prev_line) + start_index = prev_line->start_index + + prev_line->length; + break; + default: + g_assert_not_reached(); + } + break; + case GAIL_AFTER_OFFSET: + /* + * We want the next line + */ + if (pango_layout_iter_next_line (iter)) + { + line = pango_layout_iter_get_line (iter); + switch (boundary_type) + { + case ATK_TEXT_BOUNDARY_LINE_START: + start_index = line->start_index; + if (pango_layout_iter_next_line (iter)) + end_index = pango_layout_iter_get_line (iter)->start_index; + else + end_index = start_index + line->length; + break; + case ATK_TEXT_BOUNDARY_LINE_END: + start_index = end_index; + end_index = line->start_index + line->length; + break; + default: + g_assert_not_reached(); + } + } + else + start_index = end_index; + break; + } + found = TRUE; + break; + } + prev_prev_line = prev_line; + prev_line = line; + } + while (pango_layout_iter_next_line (iter)); + + if (!found) + { + start_index = prev_line->start_index + prev_line->length; + end_index = start_index; + } + pango_layout_iter_free (iter); + *start_offset = g_utf8_pointer_to_offset (text, text + start_index); + *end_offset = g_utf8_pointer_to_offset (text, text + end_index); + + gtk_text_buffer_get_iter_at_offset (buffer, start_iter, *start_offset); + gtk_text_buffer_get_iter_at_offset (buffer, end_iter, *end_offset); +} diff --git a/gtk/a11y/gailtextutil.h b/gtk/a11y/gailtextutil.h new file mode 100644 index 000000000..b8b916a16 --- /dev/null +++ b/gtk/a11y/gailtextutil.h @@ -0,0 +1,87 @@ +/* GAIL - The GNOME Accessibility Implementation Library + * Copyright 2001 Sun Microsystems Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifndef __GAIL_TEXT_UTIL_H__ +#define __GAIL_TEXT_UTIL_H__ + +#include +#include + +G_BEGIN_DECLS + +#define GAIL_TYPE_TEXT_UTIL (gail_text_util_get_type ()) +#define GAIL_TEXT_UTIL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GAIL_TYPE_TEXT_UTIL, GailTextUtil)) +#define GAIL_TEXT_UTIL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GAIL_TYPE_TEXT_UTIL, GailTextUtilClass)) +#define GAIL_IS_TEXT_UTIL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GAIL_TYPE_TEXT_UTIL)) +#define GAIL_IS_TEXT_UTIL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GAIL_TYPE_TEXT_UTIL)) +#define GAIL_TEXT_UTIL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GAIL_TYPE_TEXT_UTIL, GailTextUtilClass)) + +/** + *GailOffsetType: + *@GAIL_BEFORE_OFFSET: Text before offset is required. + *@GAIL_AT_OFFSET: Text at offset is required, + *@GAIL_AFTER_OFFSET: Text after offset is required. + * + * Specifies which of the functions atk_text_get_text_before_offset(), + * atk_text_get_text_at_offset(), atk_text_get_text_after_offset() the + * function gail_text_util_get_text() is being called for. + **/ +typedef enum +{ + GAIL_BEFORE_OFFSET, + GAIL_AT_OFFSET, + GAIL_AFTER_OFFSET +}GailOffsetType; + +typedef struct _GailTextUtil GailTextUtil; +typedef struct _GailTextUtilClass GailTextUtilClass; + +struct _GailTextUtil +{ + GObject parent; + + GtkTextBuffer *buffer; +}; + +struct _GailTextUtilClass +{ + GObjectClass parent_class; +}; + +GType gail_text_util_get_type (void); +GailTextUtil* gail_text_util_new (void); + +void gail_text_util_text_setup (GailTextUtil *textutil, + const gchar *text); +void gail_text_util_buffer_setup (GailTextUtil *textutil, + GtkTextBuffer *buffer); +gchar* gail_text_util_get_text (GailTextUtil *textutil, + gpointer layout, + GailOffsetType function, + AtkTextBoundary boundary_type, + gint offset, + gint *start_offset, + gint *end_offset); +gchar* gail_text_util_get_substring (GailTextUtil *textutil, + gint start_pos, + gint end_pos); + +G_END_DECLS + +#endif /*__GAIL_TEXT_UTIL_H__ */ diff --git a/gtk/a11y/gailtextview.h b/gtk/a11y/gailtextview.h index bb2d2334a..008785409 100644 --- a/gtk/a11y/gailtextview.h +++ b/gtk/a11y/gailtextview.h @@ -21,7 +21,7 @@ #define __GAIL_TEXT_VIEW_H__ #include "gailcontainer.h" -#include +#include "gailtextutil.h" G_BEGIN_DECLS -- 2.43.2