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