Pileus Git - ~andy/gtk/blob - gtk/a11y/gtklabelaccessible.c

   1 /* GAIL - The GNOME Accessibility Enabling Library
   2  * Copyright 2001, 2002, 2003 Sun Microsystems Inc.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include "config.h"
  21
  22 #include <gtk/gtk.h>
  23 #include <gtk/gtkpango.h>
  24 #include "gtklabelaccessible.h"
  25
  26
  27 static void atk_text_interface_init (AtkTextIface *iface);
  28
  29 G_DEFINE_TYPE_WITH_CODE (GtkLabelAccessible, _gtk_label_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
  30                          G_IMPLEMENT_INTERFACE (ATK_TYPE_TEXT, atk_text_interface_init))
  31
  32 static void
  33 _gtk_label_accessible_init (GtkLabelAccessible *label)
  34 {
  35 }
  36
  37 static void
  38 gtk_label_accessible_initialize (AtkObject *obj,
  39                                  gpointer   data)
  40 {
  41   GtkWidget  *widget;
  42   GtkLabelAccessible *accessible;
  43
  44   ATK_OBJECT_CLASS (_gtk_label_accessible_parent_class)->initialize (obj, data);
  45
  46   accessible = GTK_LABEL_ACCESSIBLE (obj);
  47
  48   widget = GTK_WIDGET (data);
  49
  50   accessible->text = g_strdup (gtk_label_get_text (GTK_LABEL (widget)));
  51
  52   /*
  53    * Check whether ancestor of GtkLabel is a GtkButton and if so
  54    * set accessible parent for GtkLabelAccessible
  55    */
  56   while (widget != NULL)
  57     {
  58       widget = gtk_widget_get_parent (widget);
  59       if (GTK_IS_BUTTON (widget))
  60         {
  61           atk_object_set_parent (obj, gtk_widget_get_accessible (widget));
  62           break;
  63         }
  64     }
  65
  66   if (GTK_IS_ACCEL_LABEL (widget))
  67     obj->role = ATK_ROLE_ACCEL_LABEL;
  68   else
  69     obj->role = ATK_ROLE_LABEL;
  70 }
  71
  72 static gboolean
  73 check_for_selection_change (GtkLabelAccessible *accessible,
  74                             GtkLabel           *label)
  75 {
  76   gboolean ret_val = FALSE;
  77   gint start, end;
  78
  79   if (gtk_label_get_selection_bounds (label, &start, &end))
  80     {
  81       if (end != accessible->cursor_position ||
  82           start != accessible->selection_bound)
  83         ret_val = TRUE;
  84     }
  85   else
  86     {
  87       ret_val = (accessible->cursor_position != accessible->selection_bound);
  88     }
  89
  90   accessible->cursor_position = end;
  91   accessible->selection_bound = start;
  92
  93   return ret_val;
  94 }
  95
  96
  97 static void
  98 gtk_label_accessible_notify_gtk (GObject    *obj,
  99                                  GParamSpec *pspec)
 100 {
 101   GtkWidget *widget = GTK_WIDGET (obj);
 102   AtkObject* atk_obj = gtk_widget_get_accessible (widget);
 103   GtkLabelAccessible *accessible;
 104   gint length;
 105
 106   accessible = GTK_LABEL_ACCESSIBLE (atk_obj);
 107
 108   if (g_strcmp0 (pspec->name, "label") == 0)
 109     {
 110       const gchar *text;
 111
 112       text = gtk_label_get_text (GTK_LABEL (widget));
 113       if (g_strcmp0 (accessible->text, text) == 0)
 114         return;
 115
 116       /* Create a delete text and an insert text signal */
 117       length = g_utf8_strlen (accessible->text, -1);
 118       if (length > 0)
 119         g_signal_emit_by_name (atk_obj, "text-changed::delete", 0, length);
 120
 121       g_free (accessible->text);
 122       accessible->text = g_strdup (text);
 123
 124       length = g_utf8_strlen (accessible->text, -1);
 125       if (length > 0)
 126         g_signal_emit_by_name (atk_obj, "text-changed::insert", 0, length);
 127
 128       if (atk_obj->name == NULL)
 129         /* The label has changed so notify a change in accessible-name */
 130         g_object_notify (G_OBJECT (atk_obj), "accessible-name");
 131
 132       g_signal_emit_by_name (atk_obj, "visible-data-changed");
 133     }
 134   else if (g_strcmp0 (pspec->name, "cursor-position") == 0)
 135     {
 136       g_signal_emit_by_name (atk_obj, "text-caret-moved",
 137                              _gtk_label_get_cursor_position (GTK_LABEL (widget)));
 138       if (check_for_selection_change (accessible, GTK_LABEL (widget)))
 139         g_signal_emit_by_name (atk_obj, "text-selection-changed");
 140     }
 141   else if (g_strcmp0 (pspec->name, "selection-bound") == 0)
 142     {
 143       if (check_for_selection_change (accessible, GTK_LABEL (widget)))
 144         g_signal_emit_by_name (atk_obj, "text-selection-changed");
 145     }
 146   else
 147     GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_label_accessible_parent_class)->notify_gtk (obj, pspec);
 148 }
 149
 150 static void
 151 gtk_label_accessible_finalize (GObject *object)
 152 {
 153   GtkLabelAccessible *accessible = GTK_LABEL_ACCESSIBLE (object);
 154
 155   g_free (accessible->text);
 156
 157   G_OBJECT_CLASS (_gtk_label_accessible_parent_class)->finalize (object);
 158 }
 159
 160
 161 /* atkobject.h */
 162
 163 static AtkStateSet *
 164 gtk_label_accessible_ref_state_set (AtkObject *accessible)
 165 {
 166   AtkStateSet *state_set;
 167   GtkWidget *widget;
 168
 169   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
 170   if (widget == NULL)
 171     return NULL;
 172
 173   state_set = ATK_OBJECT_CLASS (_gtk_label_accessible_parent_class)->ref_state_set (accessible);
 174   atk_state_set_add_state (state_set, ATK_STATE_MULTI_LINE);
 175
 176   return state_set;
 177 }
 178
 179 static AtkRelationSet *
 180 gtk_label_accessible_ref_relation_set (AtkObject *obj)
 181 {
 182   GtkWidget *widget;
 183   AtkRelationSet *relation_set;
 184
 185   g_return_val_if_fail (GTK_IS_LABEL_ACCESSIBLE (obj), NULL);
 186
 187   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
 188   if (widget == NULL)
 189     return NULL;
 190
 191   relation_set = ATK_OBJECT_CLASS (_gtk_label_accessible_parent_class)->ref_relation_set (obj);
 192
 193   if (!atk_relation_set_contains (relation_set, ATK_RELATION_LABEL_FOR))
 194     {
 195       /* Get the mnemonic widget.
 196        * The relation set is not updated if the mnemonic widget is changed
 197        */
 198       GtkWidget *mnemonic_widget;
 199
 200       mnemonic_widget = gtk_label_get_mnemonic_widget (GTK_LABEL (widget));
 201
 202       if (mnemonic_widget)
 203         {
 204           AtkObject *accessible_array[1];
 205           AtkRelation* relation;
 206
 207           if (!gtk_widget_get_can_focus (mnemonic_widget))
 208             {
 209             /*
 210              * Handle the case where a GtkFileChooserButton is specified
 211              * as the mnemonic widget. use the combobox which is a child of the
 212              * GtkFileChooserButton as the mnemonic widget. See bug #359843.
 213              */
 214              if (GTK_IS_BOX (mnemonic_widget))
 215                {
 216                   GList *list, *tmpl;
 217
 218                   list = gtk_container_get_children (GTK_CONTAINER (mnemonic_widget));
 219                   if (g_list_length (list) == 2)
 220                     {
 221                       tmpl = g_list_last (list);
 222                       if (GTK_IS_COMBO_BOX(tmpl->data))
 223                         {
 224                           mnemonic_widget = GTK_WIDGET(tmpl->data);
 225                         }
 226                     }
 227                   g_list_free (list);
 228                 }
 229             }
 230           accessible_array[0] = gtk_widget_get_accessible (mnemonic_widget);
 231           relation = atk_relation_new (accessible_array, 1,
 232                                        ATK_RELATION_LABEL_FOR);
 233           atk_relation_set_add (relation_set, relation);
 234           /*
 235            * Unref the relation so that it is not leaked.
 236            */
 237           g_object_unref (relation);
 238         }
 239     }
 240   return relation_set;
 241 }
 242
 243 static const gchar*
 244 gtk_label_accessible_get_name (AtkObject *accessible)
 245 {
 246   const gchar *name;
 247
 248   g_return_val_if_fail (GTK_IS_LABEL_ACCESSIBLE (accessible), NULL);
 249
 250   name = ATK_OBJECT_CLASS (_gtk_label_accessible_parent_class)->get_name (accessible);
 251   if (name != NULL)
 252     return name;
 253   else
 254     {
 255       /*
 256        * Get the text on the label
 257        */
 258       GtkWidget *widget;
 259
 260       widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
 261       if (widget == NULL)
 262         return NULL;
 263
 264       g_return_val_if_fail (GTK_IS_LABEL (widget), NULL);
 265
 266       return gtk_label_get_text (GTK_LABEL (widget));
 267     }
 268 }
 269
 270 static void
 271 _gtk_label_accessible_class_init (GtkLabelAccessibleClass *klass)
 272 {
 273   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 274   AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
 275   GtkWidgetAccessibleClass *widget_class = (GtkWidgetAccessibleClass*)klass;
 276
 277   gobject_class->finalize = gtk_label_accessible_finalize;
 278
 279   widget_class->notify_gtk = gtk_label_accessible_notify_gtk;
 280
 281   class->get_name = gtk_label_accessible_get_name;
 282   class->ref_state_set = gtk_label_accessible_ref_state_set;
 283   class->ref_relation_set = gtk_label_accessible_ref_relation_set;
 284   class->initialize = gtk_label_accessible_initialize;
 285 }
 286
 287 /* atktext.h */
 288
 289 static gchar*
 290 gtk_label_accessible_get_text (AtkText *atk_text,
 291                                gint     start_pos,
 292                                gint     end_pos)
 293 {
 294   GtkWidget *widget;
 295   const gchar *text;
 296
 297   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (atk_text));
 298   if (widget == NULL)
 299     return NULL;
 300
 301   text = gtk_label_get_text (GTK_LABEL (widget));
 302
 303   if (text)
 304     return g_utf8_substring (text, start_pos, end_pos > -1 ? end_pos : g_utf8_strlen (text, -1));
 305
 306   return NULL;
 307 }
 308
 309 static gchar *
 310 gtk_label_accessible_get_text_before_offset (AtkText         *text,
 311                                              gint             offset,
 312                                              AtkTextBoundary  boundary_type,
 313                                              gint            *start_offset,
 314                                              gint            *end_offset)
 315 {
 316   GtkWidget *widget;
 317
 318   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
 319   if (widget == NULL)
 320     return NULL;
 321
 322   return _gtk_pango_get_text_before (gtk_label_get_layout (GTK_LABEL (widget)),
 323                                      boundary_type, offset,
 324                                      start_offset, end_offset);
 325 }
 326
 327 static gchar*
 328 gtk_label_accessible_get_text_at_offset (AtkText         *text,
 329                                          gint             offset,
 330                                          AtkTextBoundary  boundary_type,
 331                                          gint            *start_offset,
 332                                          gint            *end_offset)
 333 {
 334   GtkWidget *widget;
 335
 336   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
 337   if (widget == NULL)
 338     return NULL;
 339
 340   return _gtk_pango_get_text_at (gtk_label_get_layout (GTK_LABEL (widget)),
 341                                  boundary_type, offset,
 342                                  start_offset, end_offset);
 343 }
 344
 345 static gchar*
 346 gtk_label_accessible_get_text_after_offset (AtkText         *text,
 347                                             gint             offset,
 348                                             AtkTextBoundary  boundary_type,
 349                                             gint            *start_offset,
 350                                             gint            *end_offset)
 351 {
 352   GtkWidget *widget;
 353
 354   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
 355   if (widget == NULL)
 356     return NULL;
 357
 358   return _gtk_pango_get_text_after (gtk_label_get_layout (GTK_LABEL (widget)),
 359                                     boundary_type, offset,
 360                                     start_offset, end_offset);
 361 }
 362
 363 static gint
 364 gtk_label_accessible_get_character_count (AtkText *atk_text)
 365 {
 366   GtkWidget *widget;
 367   const gchar *text;
 368
 369   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (atk_text));
 370   if (widget == NULL)
 371     return 0;
 372
 373   text = gtk_label_get_text (GTK_LABEL (widget));
 374
 375   if (text)
 376     return g_utf8_strlen (text, -1);
 377
 378   return 0;
 379 }
 380
 381 static gint
 382 gtk_label_accessible_get_caret_offset (AtkText *text)
 383 {
 384   GtkWidget *widget;
 385
 386   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
 387   if (widget == NULL)
 388     return 0;
 389
 390   return _gtk_label_get_cursor_position (GTK_LABEL (widget));
 391 }
 392
 393 static gboolean
 394 gtk_label_accessible_set_caret_offset (AtkText *text,
 395                                        gint     offset)
 396 {
 397   GtkWidget *widget;
 398   GtkLabel *label;
 399
 400   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
 401   if (widget == NULL)
 402     return FALSE;
 403
 404   label = GTK_LABEL (widget);
 405
 406   if (!gtk_label_get_selectable (label))
 407     return FALSE;
 408
 409   gtk_label_select_region (label, offset, offset);
 410
 411   return TRUE;
 412 }
 413
 414 static gint
 415 gtk_label_accessible_get_n_selections (AtkText *text)
 416 {
 417   GtkWidget *widget;
 418
 419   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
 420   if (widget == NULL)
 421     return 0;
 422
 423   if (gtk_label_get_selection_bounds (GTK_LABEL (widget), NULL, NULL))
 424     return 1;
 425
 426   return 0;
 427 }
 428
 429 static gchar *
 430 gtk_label_accessible_get_selection (AtkText *atk_text,
 431                                     gint     selection_num,
 432                                     gint    *start_pos,
 433                                     gint    *end_pos)
 434 {
 435   GtkWidget *widget;
 436   GtkLabel  *label;
 437
 438   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (atk_text));
 439   if (widget == NULL)
 440     return NULL;
 441
 442   if (selection_num != 0)
 443     return NULL;
 444
 445   label = GTK_LABEL (widget);
 446
 447   if (gtk_label_get_selection_bounds (label, start_pos, end_pos))
 448     {
 449       const gchar *text;
 450
 451       text = gtk_label_get_text (label);
 452
 453       if (text)
 454         return g_utf8_substring (text, *start_pos, *end_pos);
 455     }
 456
 457   return NULL;
 458 }
 459
 460 static gboolean
 461 gtk_label_accessible_add_selection (AtkText *text,
 462                                     gint     start_pos,
 463                                     gint     end_pos)
 464 {
 465   GtkWidget *widget;
 466   GtkLabel  *label;
 467   gint start, end;
 468
 469   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
 470   if (widget == NULL)
 471     return FALSE;
 472
 473   label = GTK_LABEL (widget);
 474
 475   if (!gtk_label_get_selectable (label))
 476     return FALSE;
 477
 478   if (!gtk_label_get_selection_bounds (label, &start, &end))
 479     {
 480       gtk_label_select_region (label, start_pos, end_pos);
 481       return TRUE;
 482     }
 483   else
 484     return FALSE;
 485 }
 486
 487 static gboolean
 488 gtk_label_accessible_remove_selection (AtkText *text,
 489                                        gint     selection_num)
 490 {
 491   GtkWidget *widget;
 492   GtkLabel  *label;
 493   gint start, end;
 494
 495   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
 496   if (widget == NULL)
 497     return FALSE;
 498
 499   if (selection_num != 0)
 500      return FALSE;
 501
 502   label = GTK_LABEL (widget);
 503
 504   if (!gtk_label_get_selectable (label))
 505      return FALSE;
 506
 507   if (gtk_label_get_selection_bounds (label, &start, &end))
 508     {
 509       gtk_label_select_region (label, end, end);
 510       return TRUE;
 511     }
 512   else
 513     return FALSE;
 514 }
 515
 516 static gboolean
 517 gtk_label_accessible_set_selection (AtkText *text,
 518                                     gint     selection_num,
 519                                     gint     start_pos,
 520                                     gint     end_pos)
 521 {
 522   GtkWidget *widget;
 523   GtkLabel  *label;
 524   gint start, end;
 525
 526   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
 527   if (widget == NULL)
 528     return FALSE;
 529
 530   if (selection_num != 0)
 531     return FALSE;
 532
 533   label = GTK_LABEL (widget);
 534
 535   if (!gtk_label_get_selectable (label))
 536     return FALSE;
 537
 538   if (gtk_label_get_selection_bounds (label, &start, &end))
 539     {
 540       gtk_label_select_region (label, start_pos, end_pos);
 541       return TRUE;
 542     }
 543   else
 544     return FALSE;
 545 }
 546
 547 static void
 548 gtk_label_accessible_get_character_extents (AtkText      *text,
 549                                             gint          offset,
 550                                             gint         *x,
 551                                             gint         *y,
 552                                             gint         *width,
 553                                             gint         *height,
 554                                             AtkCoordType  coords)
 555 {
 556   GtkWidget *widget;
 557   GtkLabel *label;
 558   PangoRectangle char_rect;
 559   const gchar *label_text;
 560   gint index, x_layout, y_layout;
 561   GdkWindow *window;
 562   gint x_window, y_window;
 563
 564   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
 565   if (widget == NULL)
 566     return;
 567
 568   label = GTK_LABEL (widget);
 569
 570   gtk_label_get_layout_offsets (label, &x_layout, &y_layout);
 571   label_text = gtk_label_get_text (label);
 572   index = g_utf8_offset_to_pointer (label_text, offset) - label_text;
 573   pango_layout_index_to_pos (gtk_label_get_layout (label), index, &char_rect);
 574   pango_extents_to_pixels (&char_rect, NULL);
 575
 576   window = gtk_widget_get_window (widget);
 577   gdk_window_get_origin (window, &x_window, &y_window);
 578
 579   *x = x_window + x_layout + char_rect.x;
 580   *y = x_window + y_layout + char_rect.y;
 581   *width = char_rect.width;
 582   *height = char_rect.height;
 583
 584   if (coords == ATK_XY_WINDOW)
 585     {
 586       window = gdk_window_get_toplevel (window);
 587       gdk_window_get_origin (window, &x_window, &y_window);
 588
 589       *x -= x_window;
 590       *y -= y_window;
 591     }
 592 }
 593
 594 static gint
 595 gtk_label_accessible_get_offset_at_point (AtkText      *atk_text,
 596                                           gint          x,
 597                                           gint          y,
 598                                           AtkCoordType  coords)
 599 {
 600   GtkWidget *widget;
 601   GtkLabel *label;
 602   const gchar *text;
 603   gint index, x_layout, y_layout;
 604   gint x_window, y_window;
 605   gint x_local, y_local;
 606   GdkWindow *window;
 607
 608   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (atk_text));
 609   if (widget == NULL)
 610     return -1;
 611
 612   label = GTK_LABEL (widget);
 613
 614   gtk_label_get_layout_offsets (label, &x_layout, &y_layout);
 615
 616   window = gtk_widget_get_window (widget);
 617   gdk_window_get_origin (window, &x_window, &y_window);
 618
 619   x_local = x - x_layout - x_window;
 620   y_local = y - y_layout - y_window;
 621
 622   if (coords == ATK_XY_WINDOW)
 623     {
 624       window = gdk_window_get_toplevel (window);
 625       gdk_window_get_origin (window, &x_window, &y_window);
 626
 627       x_local += x_window;
 628       y_local += y_window;
 629     }
 630
 631   if (!pango_layout_xy_to_index (gtk_label_get_layout (label),
 632                                  x_local * PANGO_SCALE,
 633                                  y_local * PANGO_SCALE,
 634                                  &index, NULL))
 635     {
 636       if (x_local < 0 || y_local < 0)
 637         index = 0;
 638       else
 639         index = -1;
 640     }
 641
 642   if (index != -1)
 643     {
 644       text = gtk_label_get_text (label);
 645       return g_utf8_pointer_to_offset (text, text + index);
 646     }
 647
 648   return -1;
 649 }
 650
 651 static AtkAttributeSet *
 652 add_attribute (AtkAttributeSet  *attributes,
 653                AtkTextAttribute  attr,
 654                const gchar      *value)
 655 {
 656   AtkAttribute *at;
 657
 658   at = g_new (AtkAttribute, 1);
 659   at->name = g_strdup (atk_text_attribute_get_name (attr));
 660   at->value = g_strdup (value);
 661
 662   return g_slist_prepend (attributes, at);
 663 }
 664
 665 static AtkAttributeSet*
 666 gtk_label_accessible_get_run_attributes (AtkText *text,
 667                                          gint     offset,
 668                                          gint    *start_offset,
 669                                          gint    *end_offset)
 670 {
 671   GtkWidget *widget;
 672   AtkAttributeSet *attributes;
 673
 674   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
 675   if (widget == NULL)
 676     return NULL;
 677
 678   attributes = NULL;
 679   attributes = add_attribute (attributes, ATK_TEXT_ATTR_DIRECTION,
 680                    atk_text_attribute_get_value (ATK_TEXT_ATTR_DIRECTION,
 681                                                  gtk_widget_get_direction (widget)));
 682   attributes = _gtk_pango_get_run_attributes (attributes,
 683                                               gtk_label_get_layout (GTK_LABEL (widget)),
 684                                               offset,
 685                                               start_offset,
 686                                               end_offset);
 687
 688   return attributes;
 689 }
 690
 691 static AtkAttributeSet *
 692 gtk_label_accessible_get_default_attributes (AtkText *text)
 693 {
 694   GtkWidget *widget;
 695   AtkAttributeSet *attributes;
 696
 697   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
 698   if (widget == NULL)
 699     return NULL;
 700
 701   attributes = NULL;
 702   attributes = add_attribute (attributes, ATK_TEXT_ATTR_DIRECTION,
 703                    atk_text_attribute_get_value (ATK_TEXT_ATTR_DIRECTION,
 704                                                  gtk_widget_get_direction (widget)));
 705   attributes = _gtk_pango_get_default_attributes (attributes,
 706                                                   gtk_label_get_layout (GTK_LABEL (widget)));
 707   attributes = _gtk_style_context_get_attributes (attributes,
 708                                                   gtk_widget_get_style_context (widget),
 709                                                   gtk_widget_get_state_flags (widget));
 710
 711   return attributes;
 712 }
 713
 714 static gunichar
 715 gtk_label_accessible_get_character_at_offset (AtkText *atk_text,
 716                                               gint     offset)
 717 {
 718   GtkWidget *widget;
 719   const gchar *text;
 720   gchar *index;
 721
 722   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (atk_text));
 723   if (widget == NULL)
 724     return '\0';
 725
 726   text = gtk_label_get_text (GTK_LABEL (widget));
 727   if (offset >= g_utf8_strlen (text, -1))
 728     return '\0';
 729
 730   index = g_utf8_offset_to_pointer (text, offset);
 731
 732   return g_utf8_get_char (index);
 733 }
 734
 735 static void
 736 atk_text_interface_init (AtkTextIface *iface)
 737 {
 738   iface->get_text = gtk_label_accessible_get_text;
 739   iface->get_character_at_offset = gtk_label_accessible_get_character_at_offset;
 740   iface->get_text_before_offset = gtk_label_accessible_get_text_before_offset;
 741   iface->get_text_at_offset = gtk_label_accessible_get_text_at_offset;
 742   iface->get_text_after_offset = gtk_label_accessible_get_text_after_offset;
 743   iface->get_character_count = gtk_label_accessible_get_character_count;
 744   iface->get_caret_offset = gtk_label_accessible_get_caret_offset;
 745   iface->set_caret_offset = gtk_label_accessible_set_caret_offset;
 746   iface->get_n_selections = gtk_label_accessible_get_n_selections;
 747   iface->get_selection = gtk_label_accessible_get_selection;
 748   iface->add_selection = gtk_label_accessible_add_selection;
 749   iface->remove_selection = gtk_label_accessible_remove_selection;
 750   iface->set_selection = gtk_label_accessible_set_selection;
 751   iface->get_character_extents = gtk_label_accessible_get_character_extents;
 752   iface->get_offset_at_point = gtk_label_accessible_get_offset_at_point;
 753   iface->get_run_attributes = gtk_label_accessible_get_run_attributes;
 754   iface->get_default_attributes = gtk_label_accessible_get_default_attributes;
 755 }
 756