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

   1 /* GTK+ - accessibility implementations
   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 #ifdef GDK_WINDOWING_X11
  22 #include <gdk/x11/gdkx.h>
  23 #endif
  24
  25 #include "gtktreeprivate.h"
  26 #include "gtkwidgetprivate.h"
  27
  28 #include "gtktreeviewaccessibleprivate.h"
  29
  30 #include "gtkrenderercellaccessible.h"
  31 #include "gtkbooleancellaccessible.h"
  32 #include "gtkimagecellaccessible.h"
  33 #include "gtkcontainercellaccessible.h"
  34 #include "gtktextcellaccessible.h"
  35 #include "gtkcellaccessibleparent.h"
  36 #include "gtkcellaccessibleprivate.h"
  37
  38 struct _GtkTreeViewAccessiblePrivate
  39 {
  40   GHashTable *cell_infos;
  41 };
  42
  43 typedef struct _GtkTreeViewAccessibleCellInfo  GtkTreeViewAccessibleCellInfo;
  44 struct _GtkTreeViewAccessibleCellInfo
  45 {
  46   GtkCellAccessible *cell;
  47   GtkRBTree *tree;
  48   GtkRBNode *node;
  49   GtkTreeViewColumn *cell_col_ref;
  50   GtkTreeViewAccessible *view;
  51 };
  52
  53 /* Misc */
  54
  55 static int              cell_info_get_index             (GtkTreeView                     *tree_view,
  56                                                          GtkTreeViewAccessibleCellInfo   *info);
  57 static gboolean         is_cell_showing                 (GtkTreeView            *tree_view,
  58                                                          GdkRectangle           *cell_rect);
  59
  60 static void             cell_info_new                   (GtkTreeViewAccessible  *accessible,
  61                                                          GtkRBTree              *tree,
  62                                                          GtkRBNode              *node,
  63                                                          GtkTreeViewColumn      *tv_col,
  64                                                          GtkCellAccessible      *cell);
  65 static gint             get_column_number               (GtkTreeView            *tree_view,
  66                                                          GtkTreeViewColumn      *column);
  67
  68 static gboolean         get_rbtree_column_from_index    (GtkTreeView            *tree_view,
  69                                                          gint                   index,
  70                                                          GtkRBTree              **tree,
  71                                                          GtkRBNode              **node,
  72                                                          GtkTreeViewColumn      **column);
  73
  74 static GtkTreeViewAccessibleCellInfo* find_cell_info    (GtkTreeViewAccessible           *view,
  75                                                          GtkCellAccessible               *cell);
  76 static AtkObject *       get_header_from_column         (GtkTreeViewColumn      *tv_col);
  77
  78
  79 static void atk_table_interface_init                  (AtkTableIface                *iface);
  80 static void atk_selection_interface_init              (AtkSelectionIface            *iface);
  81 static void atk_component_interface_init              (AtkComponentIface            *iface);
  82 static void gtk_cell_accessible_parent_interface_init (GtkCellAccessibleParentIface *iface);
  83
  84 G_DEFINE_TYPE_WITH_CODE (GtkTreeViewAccessible, gtk_tree_view_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
  85                          G_IMPLEMENT_INTERFACE (ATK_TYPE_TABLE, atk_table_interface_init)
  86                          G_IMPLEMENT_INTERFACE (ATK_TYPE_SELECTION, atk_selection_interface_init)
  87                          G_IMPLEMENT_INTERFACE (ATK_TYPE_COMPONENT, atk_component_interface_init)
  88                          G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_ACCESSIBLE_PARENT, gtk_cell_accessible_parent_interface_init))
  89
  90
  91 static GQuark
  92 gtk_tree_view_accessible_get_data_quark (void)
  93 {
  94   static GQuark quark = 0;
  95
  96   if (G_UNLIKELY (quark == 0))
  97     quark = g_quark_from_static_string ("gtk-tree-view-accessible-data");
  98
  99   return quark;
 100 }
 101
 102 static void
 103 cell_info_free (GtkTreeViewAccessibleCellInfo *cell_info)
 104 {
 105   gtk_accessible_set_widget (GTK_ACCESSIBLE (cell_info->cell), NULL);
 106   g_object_unref (cell_info->cell);
 107
 108   g_free (cell_info);
 109 }
 110
 111 static GtkTreePath *
 112 cell_info_get_path (GtkTreeViewAccessibleCellInfo *cell_info)
 113 {
 114   return _gtk_tree_path_new_from_rbtree (cell_info->tree, cell_info->node);
 115 }
 116
 117 static guint
 118 cell_info_hash (gconstpointer info)
 119 {
 120   const GtkTreeViewAccessibleCellInfo *cell_info = info;
 121   guint node, col;
 122
 123   node = GPOINTER_TO_UINT (cell_info->node);
 124   col = GPOINTER_TO_UINT (cell_info->cell_col_ref);
 125
 126   return ((node << sizeof (guint) / 2) | (node >> sizeof (guint) / 2)) ^ col;
 127 }
 128
 129 static gboolean
 130 cell_info_equal (gconstpointer a, gconstpointer b)
 131 {
 132   const GtkTreeViewAccessibleCellInfo *cell_info_a = a;
 133   const GtkTreeViewAccessibleCellInfo *cell_info_b = b;
 134
 135   return cell_info_a->node == cell_info_b->node &&
 136          cell_info_a->cell_col_ref == cell_info_b->cell_col_ref;
 137 }
 138
 139 static void
 140 gtk_tree_view_accessible_initialize (AtkObject *obj,
 141                                      gpointer   data)
 142 {
 143   GtkTreeViewAccessible *accessible;
 144   GtkTreeView *tree_view;
 145   GtkTreeModel *tree_model;
 146   GtkWidget *widget;
 147
 148   ATK_OBJECT_CLASS (gtk_tree_view_accessible_parent_class)->initialize (obj, data);
 149
 150   accessible = GTK_TREE_VIEW_ACCESSIBLE (obj);
 151
 152   accessible->priv->cell_infos = g_hash_table_new_full (cell_info_hash,
 153       cell_info_equal, NULL, (GDestroyNotify) cell_info_free);
 154
 155   widget = GTK_WIDGET (data);
 156   tree_view = GTK_TREE_VIEW (widget);
 157   tree_model = gtk_tree_view_get_model (tree_view);
 158
 159   if (tree_model)
 160     {
 161       if (gtk_tree_model_get_flags (tree_model) & GTK_TREE_MODEL_LIST_ONLY)
 162         obj->role = ATK_ROLE_TABLE;
 163       else
 164         obj->role = ATK_ROLE_TREE_TABLE;
 165     }
 166 }
 167
 168 static void
 169 gtk_tree_view_accessible_finalize (GObject *object)
 170 {
 171   GtkTreeViewAccessible *accessible = GTK_TREE_VIEW_ACCESSIBLE (object);
 172
 173   if (accessible->priv->cell_infos)
 174     g_hash_table_destroy (accessible->priv->cell_infos);
 175
 176   G_OBJECT_CLASS (gtk_tree_view_accessible_parent_class)->finalize (object);
 177 }
 178
 179 static void
 180 gtk_tree_view_accessible_notify_gtk (GObject    *obj,
 181                                      GParamSpec *pspec)
 182 {
 183   GtkWidget *widget;
 184   GtkTreeView *tree_view;
 185   GtkTreeViewAccessible *accessible;
 186
 187   widget = GTK_WIDGET (obj);
 188   accessible = GTK_TREE_VIEW_ACCESSIBLE (gtk_widget_get_accessible (widget));
 189   tree_view = GTK_TREE_VIEW (widget);
 190
 191   if (g_strcmp0 (pspec->name, "model") == 0)
 192     {
 193       GtkTreeModel *tree_model;
 194       AtkRole role;
 195
 196       tree_model = gtk_tree_view_get_model (tree_view);
 197       g_hash_table_remove_all (accessible->priv->cell_infos);
 198
 199       if (tree_model)
 200         {
 201           if (gtk_tree_model_get_flags (tree_model) & GTK_TREE_MODEL_LIST_ONLY)
 202             role = ATK_ROLE_TABLE;
 203           else
 204             role = ATK_ROLE_TREE_TABLE;
 205         }
 206       else
 207         {
 208           role = ATK_ROLE_UNKNOWN;
 209         }
 210       atk_object_set_role (ATK_OBJECT (accessible), role);
 211       g_object_freeze_notify (G_OBJECT (accessible));
 212       g_signal_emit_by_name (accessible, "model-changed");
 213       g_signal_emit_by_name (accessible, "visible-data-changed");
 214       g_object_thaw_notify (G_OBJECT (accessible));
 215     }
 216   else
 217     GTK_WIDGET_ACCESSIBLE_CLASS (gtk_tree_view_accessible_parent_class)->notify_gtk (obj, pspec);
 218 }
 219
 220 static void
 221 gtk_tree_view_accessible_widget_unset (GtkAccessible *gtkaccessible)
 222 {
 223   GtkTreeViewAccessible *accessible = GTK_TREE_VIEW_ACCESSIBLE (gtkaccessible);
 224
 225   g_hash_table_remove_all (accessible->priv->cell_infos);
 226
 227   GTK_ACCESSIBLE_CLASS (gtk_tree_view_accessible_parent_class)->widget_unset (gtkaccessible);
 228 }
 229
 230 static gint
 231 get_n_rows (GtkTreeView *tree_view)
 232 {
 233   GtkRBTree *tree;
 234
 235   tree = _gtk_tree_view_get_rbtree (tree_view);
 236
 237   if (tree == NULL)
 238     return 0;
 239
 240   return tree->root->total_count;
 241 }
 242
 243 static gint
 244 get_n_columns (GtkTreeView *tree_view)
 245 {
 246   guint i, visible_columns;
 247
 248   visible_columns = 0;
 249
 250   for (i = 0; i < gtk_tree_view_get_n_columns (tree_view); i++)
 251     {
 252       GtkTreeViewColumn *column = gtk_tree_view_get_column (tree_view, i);
 253
 254       if (gtk_tree_view_column_get_visible (column))
 255         visible_columns++;
 256     }
 257
 258   return visible_columns;
 259 }
 260
 261 static gint
 262 gtk_tree_view_accessible_get_n_children (AtkObject *obj)
 263 {
 264   GtkWidget *widget;
 265   GtkTreeView *tree_view;
 266
 267   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
 268   if (widget == NULL)
 269     return 0;
 270
 271   tree_view = GTK_TREE_VIEW (widget);
 272   return (get_n_rows (tree_view) + 1) * get_n_columns (tree_view);
 273 }
 274
 275 static GtkTreeViewColumn *
 276 get_visible_column (GtkTreeView *tree_view,
 277                     guint        id)
 278 {
 279   guint i;
 280
 281   for (i = 0; i < gtk_tree_view_get_n_columns (tree_view); i++)
 282     {
 283       GtkTreeViewColumn *column = gtk_tree_view_get_column (tree_view, i);
 284
 285       if (!gtk_tree_view_column_get_visible (column))
 286         continue;
 287
 288       if (id == 0)
 289         return column;
 290
 291       id--;
 292     }
 293
 294   g_return_val_if_reached (NULL);
 295 }
 296
 297 static void
 298 set_cell_data (GtkTreeView           *treeview,
 299                GtkTreeViewAccessible *accessible,
 300                GtkCellAccessible     *cell)
 301 {
 302   GtkTreeViewAccessibleCellInfo *cell_info;
 303   gboolean is_expander, is_expanded;
 304   GtkTreeModel *model;
 305   GtkTreeIter iter;
 306   GtkTreePath *path;
 307
 308   cell_info = find_cell_info (accessible, cell);
 309   if (!cell_info)
 310     return;
 311
 312   model = gtk_tree_view_get_model (treeview);
 313
 314   if (GTK_RBNODE_FLAG_SET (cell_info->node, GTK_RBNODE_IS_PARENT) &&
 315       cell_info->cell_col_ref == gtk_tree_view_get_expander_column (treeview))
 316     {
 317       is_expander = TRUE;
 318       is_expanded = cell_info->node->children != NULL;
 319     }
 320   else
 321     {
 322       is_expander = FALSE;
 323       is_expanded = FALSE;
 324     }
 325
 326   path = cell_info_get_path (cell_info);
 327   if (path == NULL ||
 328       !gtk_tree_model_get_iter (model, &iter, path))
 329     {
 330       /* We only track valid cells, this should never happen */
 331       g_return_if_reached ();
 332     }
 333   gtk_tree_path_free (path);
 334
 335   gtk_tree_view_column_cell_set_cell_data (cell_info->cell_col_ref,
 336                                            model,
 337                                            &iter,
 338                                            is_expander,
 339                                            is_expanded);
 340 }
 341
 342 static GtkCellAccessible *
 343 peek_cell (GtkTreeViewAccessible *accessible,
 344            GtkRBTree             *tree,
 345            GtkRBNode             *node,
 346            GtkTreeViewColumn     *column)
 347 {
 348   GtkTreeViewAccessibleCellInfo lookup, *cell_info;
 349
 350   lookup.tree = tree;
 351   lookup.node = node;
 352   lookup.cell_col_ref = column;
 353
 354   cell_info = g_hash_table_lookup (accessible->priv->cell_infos, &lookup);
 355   if (cell_info == NULL)
 356     return NULL;
 357
 358   return cell_info->cell;
 359 }
 360
 361 static GtkCellAccessible *
 362 create_cell (GtkTreeView           *treeview,
 363              GtkTreeViewAccessible *accessible,
 364              GtkRBTree             *tree,
 365              GtkRBNode             *node,
 366              GtkTreeViewColumn     *column)
 367 {
 368   GtkCellRenderer *renderer;
 369   AtkObject *parent;
 370   GList *renderer_list;
 371   GList *l;
 372   GtkContainerCellAccessible *container = NULL;
 373   GtkCellAccessible *cell;
 374
 375   renderer_list = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (column));
 376
 377   /* If there is not exactly one renderer in the list,
 378    * make a container
 379    */
 380   if (renderer_list == NULL || renderer_list->next)
 381     {
 382       GtkCellAccessible *container_cell;
 383
 384       container = gtk_container_cell_accessible_new ();
 385
 386       container_cell = GTK_CELL_ACCESSIBLE (container);
 387       _gtk_cell_accessible_initialize (container_cell, GTK_WIDGET (treeview), ATK_OBJECT (accessible));
 388
 389       /* The GtkTreeViewAccessibleCellInfo structure for the container will
 390        * be before the ones for the cells so that the first one we find for
 391        * a position will be for the container
 392        */
 393       cell_info_new (accessible, tree, node, column, container_cell);
 394       parent = ATK_OBJECT (container);
 395     }
 396   else
 397     parent = ATK_OBJECT (accessible);
 398
 399   cell = NULL;
 400
 401   for (l = renderer_list; l; l = l->next)
 402     {
 403       renderer = GTK_CELL_RENDERER (l->data);
 404
 405       cell = GTK_CELL_ACCESSIBLE (gtk_renderer_cell_accessible_new (renderer));
 406
 407       /* Create the GtkTreeViewAccessibleCellInfo for this cell */
 408       if (parent == ATK_OBJECT (accessible))
 409         cell_info_new (accessible, tree, node, column, cell);
 410
 411       _gtk_cell_accessible_initialize (cell, GTK_WIDGET (treeview), parent);
 412
 413       if (container)
 414         gtk_container_cell_accessible_add_child (container, cell);
 415     }
 416   g_list_free (renderer_list);
 417   if (container)
 418     cell = GTK_CELL_ACCESSIBLE (container);
 419
 420   set_cell_data (treeview, accessible, cell);
 421   _gtk_cell_accessible_update_cache (cell);
 422
 423   if (gtk_tree_view_get_expander_column (treeview) == column)
 424     {
 425       AtkRelationSet *relation_set;
 426       AtkRelation* relation;
 427       AtkObject *parent_node;
 428
 429       relation_set = atk_object_ref_relation_set (ATK_OBJECT (cell));
 430
 431       if (tree->parent_tree)
 432         {
 433           parent_node = ATK_OBJECT (peek_cell (accessible, tree->parent_tree, tree->parent_node, column));
 434           if (parent_node == NULL)
 435             parent_node = ATK_OBJECT (create_cell (treeview, accessible, tree->parent_tree, tree->parent_node, column));
 436         }
 437       else
 438         parent_node = ATK_OBJECT (accessible);
 439       relation = atk_relation_new (&parent_node, 1, ATK_RELATION_NODE_CHILD_OF);
 440       atk_relation_set_add (relation_set, relation);
 441       atk_object_add_relationship (parent_node, ATK_RELATION_NODE_PARENT_OF, ATK_OBJECT (cell));
 442       g_object_unref (relation);
 443       g_object_unref (relation_set);
 444     }
 445
 446   return cell;
 447 }
 448
 449 static AtkObject *
 450 gtk_tree_view_accessible_ref_child (AtkObject *obj,
 451                                     gint       i)
 452 {
 453   GtkWidget *widget;
 454   GtkTreeViewAccessible *accessible;
 455   GtkCellAccessible *cell;
 456   GtkTreeView *tree_view;
 457   GtkTreeViewColumn *tv_col;
 458   GtkRBTree *tree;
 459   GtkRBNode *node;
 460   AtkObject *child;
 461
 462   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
 463   if (widget == NULL)
 464     return NULL;
 465
 466   if (i >= gtk_tree_view_accessible_get_n_children (obj))
 467     return NULL;
 468
 469   accessible = GTK_TREE_VIEW_ACCESSIBLE (obj);
 470   tree_view = GTK_TREE_VIEW (widget);
 471   if (i < get_n_columns (tree_view))
 472     {
 473       tv_col = get_visible_column (tree_view, i);
 474       child = get_header_from_column (tv_col);
 475       if (child)
 476         g_object_ref (child);
 477       return child;
 478     }
 479
 480   /* Find the RBTree and GtkTreeViewColumn for the index */
 481   if (!get_rbtree_column_from_index (tree_view, i, &tree, &node, &tv_col))
 482     return NULL;
 483
 484   cell = peek_cell (accessible, tree, node, tv_col);
 485   if (cell == NULL)
 486     cell = create_cell (tree_view, accessible, tree, node, tv_col);
 487
 488   return g_object_ref (cell);
 489 }
 490
 491 static AtkStateSet*
 492 gtk_tree_view_accessible_ref_state_set (AtkObject *obj)
 493 {
 494   AtkStateSet *state_set;
 495   GtkWidget *widget;
 496
 497   state_set = ATK_OBJECT_CLASS (gtk_tree_view_accessible_parent_class)->ref_state_set (obj);
 498   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
 499
 500   if (widget != NULL)
 501     atk_state_set_add_state (state_set, ATK_STATE_MANAGES_DESCENDANTS);
 502
 503   return state_set;
 504 }
 505
 506 static void
 507 gtk_tree_view_accessible_class_init (GtkTreeViewAccessibleClass *klass)
 508 {
 509   AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
 510   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 511   GtkAccessibleClass *accessible_class = (GtkAccessibleClass*)klass;
 512   GtkWidgetAccessibleClass *widget_class = (GtkWidgetAccessibleClass*)klass;
 513   GtkContainerAccessibleClass *container_class = (GtkContainerAccessibleClass*)klass;
 514
 515   class->get_n_children = gtk_tree_view_accessible_get_n_children;
 516   class->ref_child = gtk_tree_view_accessible_ref_child;
 517   class->ref_state_set = gtk_tree_view_accessible_ref_state_set;
 518   class->initialize = gtk_tree_view_accessible_initialize;
 519
 520   widget_class->notify_gtk = gtk_tree_view_accessible_notify_gtk;
 521
 522   accessible_class->widget_unset = gtk_tree_view_accessible_widget_unset;
 523
 524   /* The children of a GtkTreeView are the buttons at the top of the columns
 525    * we do not represent these as children so we do not want to report
 526    * children added or deleted when these changed.
 527    */
 528   container_class->add_gtk = NULL;
 529   container_class->remove_gtk = NULL;
 530
 531   gobject_class->finalize = gtk_tree_view_accessible_finalize;
 532
 533   g_type_class_add_private (klass, sizeof (GtkTreeViewAccessiblePrivate));
 534 }
 535
 536 static void
 537 gtk_tree_view_accessible_init (GtkTreeViewAccessible *view)
 538 {
 539   view->priv = G_TYPE_INSTANCE_GET_PRIVATE (view,
 540                                             GTK_TYPE_TREE_VIEW_ACCESSIBLE,
 541                                             GtkTreeViewAccessiblePrivate);
 542 }
 543
 544 /* atkcomponent.h */
 545
 546 static AtkObject *
 547 gtk_tree_view_accessible_ref_accessible_at_point (AtkComponent *component,
 548                                                   gint          x,
 549                                                   gint          y,
 550                                                   AtkCoordType  coord_type)
 551 {
 552   GtkWidget *widget;
 553   GtkTreeView *tree_view;
 554   GtkTreePath *path;
 555   GtkTreeViewColumn *column;
 556   gint x_pos, y_pos;
 557   gint bx, by;
 558   GtkCellAccessible *cell;
 559   GtkRBTree *tree;
 560   GtkRBNode *node;
 561
 562   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (component));
 563   if (widget == NULL)
 564     return NULL;
 565
 566   tree_view = GTK_TREE_VIEW (widget);
 567
 568   atk_component_get_extents (component, &x_pos, &y_pos, NULL, NULL, coord_type);
 569   gtk_tree_view_convert_widget_to_bin_window_coords (tree_view, x, y, &bx, &by);
 570   if (!gtk_tree_view_get_path_at_pos (tree_view,
 571                                       bx - x_pos, by - y_pos,
 572                                       &path, &column, NULL, NULL))
 573     return NULL;
 574
 575   if (_gtk_tree_view_find_node (tree_view, path, &tree, &node))
 576     {
 577       gtk_tree_path_free (path);
 578       return NULL;
 579     }
 580
 581   cell = peek_cell (GTK_TREE_VIEW_ACCESSIBLE (component), tree, node, column);
 582   if (cell == NULL)
 583     cell = create_cell (tree_view, GTK_TREE_VIEW_ACCESSIBLE (component), tree, node, column);
 584
 585   return g_object_ref (cell);
 586 }
 587
 588 static void
 589 atk_component_interface_init (AtkComponentIface *iface)
 590 {
 591   iface->ref_accessible_at_point = gtk_tree_view_accessible_ref_accessible_at_point;
 592 }
 593
 594 /* atktable.h */
 595
 596 static gint
 597 gtk_tree_view_accessible_get_index_at (AtkTable *table,
 598                                        gint      row,
 599                                        gint      column)
 600 {
 601   GtkWidget *widget;
 602   gint n_cols, n_rows;
 603
 604   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (table));
 605   if (widget == NULL)
 606     return -1;
 607
 608   n_cols = atk_table_get_n_columns (table);
 609   n_rows = atk_table_get_n_rows (table);
 610
 611   if (row >= n_rows || column >= n_cols)
 612     return -1;
 613
 614   return (row + 1) * n_cols + column;
 615 }
 616
 617 static gint
 618 gtk_tree_view_accessible_get_column_at_index (AtkTable *table,
 619                                               gint      index)
 620 {
 621   GtkWidget *widget;
 622   gint n_columns;
 623
 624   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (table));
 625   if (widget == NULL)
 626     return -1;
 627
 628   if (index >= gtk_tree_view_accessible_get_n_children (ATK_OBJECT (table)))
 629     return -1;
 630
 631   n_columns = get_n_columns (GTK_TREE_VIEW (widget));
 632
 633   /* checked by the n_children() check above */
 634   g_assert (n_columns > 0);
 635
 636   return index % n_columns;
 637 }
 638
 639 static gint
 640 gtk_tree_view_accessible_get_row_at_index (AtkTable *table,
 641                                            gint      index)
 642 {
 643   GtkWidget *widget;
 644   GtkTreeView *tree_view;
 645
 646   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (table));
 647   if (widget == NULL)
 648     return -1;
 649
 650   tree_view = GTK_TREE_VIEW (widget);
 651
 652   index /= get_n_columns (tree_view);
 653   index--;
 654   if (index >= get_n_rows (tree_view))
 655     return -1;
 656
 657   return index;
 658 }
 659
 660 static AtkObject *
 661 gtk_tree_view_accessible_table_ref_at (AtkTable *table,
 662                                        gint      row,
 663                                        gint      column)
 664 {
 665   gint index;
 666
 667   index = gtk_tree_view_accessible_get_index_at (table, row, column);
 668   if (index == -1)
 669     return NULL;
 670
 671   return gtk_tree_view_accessible_ref_child (ATK_OBJECT (table), index);
 672 }
 673
 674 static gint
 675 gtk_tree_view_accessible_get_n_rows (AtkTable *table)
 676 {
 677   GtkWidget *widget;
 678
 679   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (table));
 680   if (widget == NULL)
 681     return 0;
 682
 683   return get_n_rows (GTK_TREE_VIEW (widget));
 684 }
 685
 686 static gint
 687 gtk_tree_view_accessible_get_n_columns (AtkTable *table)
 688 {
 689   GtkWidget *widget;
 690
 691   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (table));
 692   if (widget == NULL)
 693     return 0;
 694
 695   return get_n_columns (GTK_TREE_VIEW (widget));
 696 }
 697
 698 static gboolean
 699 gtk_tree_view_accessible_is_row_selected (AtkTable *table,
 700                                           gint      row)
 701 {
 702   GtkWidget *widget;
 703   GtkRBTree *tree;
 704   GtkRBNode *node;
 705
 706   if (row < 0)
 707     return FALSE;
 708
 709   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (table));
 710   if (widget == NULL)
 711     return FALSE;
 712
 713   if (!_gtk_rbtree_find_index (_gtk_tree_view_get_rbtree (GTK_TREE_VIEW (widget)),
 714                                row,
 715                                &tree,
 716                                &node))
 717     return FALSE;
 718
 719   return GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
 720 }
 721
 722 static gboolean
 723 gtk_tree_view_accessible_is_selected (AtkTable *table,
 724                                       gint      row,
 725                                       gint      column)
 726 {
 727   return gtk_tree_view_accessible_is_row_selected (table, row);
 728 }
 729
 730 typedef struct {
 731   GArray *array;
 732   GtkTreeView *treeview;
 733 } SelectedRowsData;
 734
 735 static void
 736 get_selected_rows (GtkTreeModel *model,
 737                    GtkTreePath  *path,
 738                    GtkTreeIter  *iter,
 739                    gpointer      datap)
 740 {
 741   SelectedRowsData *data = datap;
 742   GtkRBTree *tree;
 743   GtkRBNode *node;
 744   int id;
 745
 746   if (_gtk_tree_view_find_node (data->treeview,
 747                                 path,
 748                                 &tree, &node))
 749     {
 750       g_assert_not_reached ();
 751     }
 752
 753   id = _gtk_rbtree_node_get_index (tree, node);
 754
 755   g_array_append_val (data->array, id);
 756 }
 757
 758 static gint
 759 gtk_tree_view_accessible_get_selected_rows (AtkTable  *table,
 760                                             gint     **rows_selected)
 761 {
 762   SelectedRowsData data;
 763   GtkWidget *widget;
 764   gint n_rows;
 765
 766   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (table));
 767   if (widget == NULL)
 768     return 0;
 769
 770   data.treeview = GTK_TREE_VIEW (widget);
 771   data.array = g_array_new (FALSE, FALSE, sizeof (gint));
 772
 773   gtk_tree_selection_selected_foreach (gtk_tree_view_get_selection (data.treeview),
 774                                        get_selected_rows,
 775                                        &data);
 776
 777   n_rows = data.array->len;
 778   if (rows_selected)
 779     *rows_selected = (gint *) g_array_free (data.array, FALSE);
 780   else
 781     g_array_free (data.array, TRUE);
 782
 783   return n_rows;
 784 }
 785
 786 static gboolean
 787 gtk_tree_view_accessible_add_row_selection (AtkTable *table,
 788                                             gint      row)
 789 {
 790   GtkTreeView *treeview;
 791   GtkTreePath *path;
 792   GtkRBTree *tree;
 793   GtkRBNode *node;
 794
 795   if (row < 0)
 796     return FALSE;
 797
 798   treeview = GTK_TREE_VIEW (gtk_accessible_get_widget (GTK_ACCESSIBLE (table)));
 799   if (treeview == NULL)
 800     return FALSE;
 801
 802   if (!_gtk_rbtree_find_index (_gtk_tree_view_get_rbtree (treeview),
 803                                row,
 804                                &tree,
 805                                &node))
 806     return FALSE;
 807
 808   if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
 809     return FALSE;
 810
 811   path = _gtk_tree_path_new_from_rbtree (tree, node);
 812   gtk_tree_selection_select_path (gtk_tree_view_get_selection (treeview), path);
 813   gtk_tree_path_free (path);
 814
 815   return TRUE;
 816 }
 817
 818 static gboolean
 819 gtk_tree_view_accessible_remove_row_selection (AtkTable *table,
 820                                                gint      row)
 821 {
 822   GtkTreeView *treeview;
 823   GtkTreePath *path;
 824   GtkRBTree *tree;
 825   GtkRBNode *node;
 826
 827   if (row < 0)
 828     return FALSE;
 829
 830   treeview = GTK_TREE_VIEW (gtk_accessible_get_widget (GTK_ACCESSIBLE (table)));
 831   if (treeview == NULL)
 832     return FALSE;
 833
 834   if (!_gtk_rbtree_find_index (_gtk_tree_view_get_rbtree (treeview),
 835                                row,
 836                                &tree,
 837                                &node))
 838     return FALSE;
 839
 840   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
 841     return FALSE;
 842
 843   path = _gtk_tree_path_new_from_rbtree (tree, node);
 844   gtk_tree_selection_unselect_path (gtk_tree_view_get_selection (treeview), path);
 845   gtk_tree_path_free (path);
 846
 847   return TRUE;
 848 }
 849
 850 static AtkObject *
 851 gtk_tree_view_accessible_get_column_header (AtkTable *table,
 852                                             gint      in_col)
 853 {
 854   GtkWidget *widget;
 855   GtkTreeView *tree_view;
 856   GtkTreeViewColumn *tv_col;
 857
 858   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (table));
 859   if (widget == NULL)
 860     return NULL;
 861
 862   tree_view = GTK_TREE_VIEW (widget);
 863   if (in_col < 0 || in_col >= get_n_columns (tree_view))
 864     return NULL;
 865
 866   tv_col = get_visible_column (tree_view, in_col);
 867   return get_header_from_column (tv_col);
 868 }
 869
 870 static const gchar *
 871 gtk_tree_view_accessible_get_column_description (AtkTable *table,
 872                                                  gint      in_col)
 873 {
 874   GtkWidget *widget;
 875   GtkTreeView *tree_view;
 876   GtkTreeViewColumn *tv_col;
 877
 878   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (table));
 879   if (widget == NULL)
 880     return NULL;
 881
 882   tree_view = GTK_TREE_VIEW (widget);
 883   if (in_col < 0 || in_col >= get_n_columns (tree_view))
 884     return NULL;
 885
 886   tv_col = get_visible_column (tree_view, in_col);
 887   return gtk_tree_view_column_get_title (tv_col);
 888 }
 889
 890 static void
 891 atk_table_interface_init (AtkTableIface *iface)
 892 {
 893   iface->ref_at = gtk_tree_view_accessible_table_ref_at;
 894   iface->get_n_rows = gtk_tree_view_accessible_get_n_rows;
 895   iface->get_n_columns = gtk_tree_view_accessible_get_n_columns;
 896   iface->get_index_at = gtk_tree_view_accessible_get_index_at;
 897   iface->get_column_at_index = gtk_tree_view_accessible_get_column_at_index;
 898   iface->get_row_at_index = gtk_tree_view_accessible_get_row_at_index;
 899   iface->is_row_selected = gtk_tree_view_accessible_is_row_selected;
 900   iface->is_selected = gtk_tree_view_accessible_is_selected;
 901   iface->get_selected_rows = gtk_tree_view_accessible_get_selected_rows;
 902   iface->add_row_selection = gtk_tree_view_accessible_add_row_selection;
 903   iface->remove_row_selection = gtk_tree_view_accessible_remove_row_selection;
 904   iface->get_column_extent_at = NULL;
 905   iface->get_row_extent_at = NULL;
 906   iface->get_column_header = gtk_tree_view_accessible_get_column_header;
 907   iface->get_column_description = gtk_tree_view_accessible_get_column_description;
 908 }
 909
 910 /* atkselection.h */
 911
 912 static gboolean
 913 gtk_tree_view_accessible_add_selection (AtkSelection *selection,
 914                                         gint          i)
 915 {
 916   AtkTable *table;
 917   gint n_columns;
 918   gint row;
 919
 920   table = ATK_TABLE (selection);
 921   n_columns = gtk_tree_view_accessible_get_n_columns (table);
 922   if (n_columns != 1)
 923     return FALSE;
 924
 925   row = gtk_tree_view_accessible_get_row_at_index (table, i);
 926   return gtk_tree_view_accessible_add_row_selection (table, row);
 927 }
 928
 929 static gboolean
 930 gtk_tree_view_accessible_clear_selection (AtkSelection *selection)
 931 {
 932   GtkWidget *widget;
 933   GtkTreeView *tree_view;
 934   GtkTreeSelection *tree_selection;
 935
 936   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
 937   if (widget == NULL)
 938     return FALSE;
 939
 940   tree_view = GTK_TREE_VIEW (widget);
 941   tree_selection = gtk_tree_view_get_selection (tree_view);
 942
 943   gtk_tree_selection_unselect_all (tree_selection);
 944   return TRUE;
 945 }
 946
 947 static AtkObject *
 948 gtk_tree_view_accessible_ref_selection (AtkSelection *selection,
 949                                         gint          i)
 950 {
 951   AtkTable *table;
 952   gint row;
 953   gint n_selected;
 954   gint n_columns;
 955   gint *selected;
 956
 957   table = ATK_TABLE (selection);
 958   n_columns = gtk_tree_view_accessible_get_n_columns (table);
 959   n_selected = gtk_tree_view_accessible_get_selected_rows (table, &selected);
 960   if (i >= n_columns * n_selected)
 961     return NULL;
 962
 963   row = selected[i / n_columns];
 964   g_free (selected);
 965
 966   return gtk_tree_view_accessible_table_ref_at (table, row, i % n_columns);
 967 }
 968
 969 static gint
 970 gtk_tree_view_accessible_get_selection_count (AtkSelection *selection)
 971 {
 972   AtkTable *table;
 973   gint n_selected;
 974
 975   table = ATK_TABLE (selection);
 976   n_selected = gtk_tree_view_accessible_get_selected_rows (table, NULL);
 977   if (n_selected > 0)
 978     n_selected *= gtk_tree_view_accessible_get_n_columns (table);
 979   return n_selected;
 980 }
 981
 982 static gboolean
 983 gtk_tree_view_accessible_is_child_selected (AtkSelection *selection,
 984                                             gint          i)
 985 {
 986   GtkWidget *widget;
 987   gint row;
 988
 989   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
 990   if (widget == NULL)
 991     return FALSE;
 992
 993   row = atk_table_get_row_at_index (ATK_TABLE (selection), i);
 994
 995   return gtk_tree_view_accessible_is_row_selected (ATK_TABLE (selection), row);
 996 }
 997
 998 static void atk_selection_interface_init (AtkSelectionIface *iface)
 999 {
1000   iface->add_selection = gtk_tree_view_accessible_add_selection;
1001   iface->clear_selection = gtk_tree_view_accessible_clear_selection;
1002   iface->ref_selection = gtk_tree_view_accessible_ref_selection;
1003   iface->get_selection_count = gtk_tree_view_accessible_get_selection_count;
1004   iface->is_child_selected = gtk_tree_view_accessible_is_child_selected;
1005 }
1006
1007 #define EXTRA_EXPANDER_PADDING 4
1008
1009 static void
1010 gtk_tree_view_accessible_get_cell_area (GtkCellAccessibleParent *parent,
1011                                         GtkCellAccessible       *cell,
1012                                         GdkRectangle            *cell_rect)
1013 {
1014   GtkWidget *widget;
1015   GtkTreeView *tree_view;
1016   GtkTreeViewColumn *tv_col;
1017   GtkTreePath *path;
1018   AtkObject *parent_cell;
1019   GtkTreeViewAccessibleCellInfo *cell_info;
1020   GtkCellAccessible *top_cell;
1021
1022   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (parent));
1023   if (widget == NULL)
1024     return;
1025
1026   tree_view = GTK_TREE_VIEW (widget);
1027   parent_cell = atk_object_get_parent (ATK_OBJECT (cell));
1028   if (parent_cell != ATK_OBJECT (parent))
1029     top_cell = GTK_CELL_ACCESSIBLE (parent_cell);
1030   else
1031     top_cell = cell;
1032   cell_info = find_cell_info (GTK_TREE_VIEW_ACCESSIBLE (parent), top_cell);
1033   if (!cell_info)
1034     return;
1035   path = cell_info_get_path (cell_info);
1036   tv_col = cell_info->cell_col_ref;
1037   if (path)
1038     {
1039       GtkTreeViewColumn *expander_column;
1040       gint focus_line_width;
1041
1042       gtk_tree_view_get_cell_area (tree_view, path, tv_col, cell_rect);
1043       expander_column = gtk_tree_view_get_expander_column (tree_view);
1044       if (expander_column == tv_col)
1045         {
1046           gint expander_size;
1047           gtk_widget_style_get (widget,
1048                                 "expander-size", &expander_size,
1049                                 NULL);
1050           cell_rect->x += expander_size + EXTRA_EXPANDER_PADDING;
1051           cell_rect->width -= expander_size + EXTRA_EXPANDER_PADDING;
1052         }
1053       gtk_widget_style_get (widget,
1054                             "focus-line-width", &focus_line_width,
1055                             NULL);
1056
1057       cell_rect->x += focus_line_width;
1058       cell_rect->width -= 2 * focus_line_width;
1059
1060       gtk_tree_path_free (path);
1061
1062       /* A column has more than one renderer so we find the position
1063        * and width of each
1064        */
1065       if (top_cell != cell)
1066         {
1067           gint cell_index;
1068           gboolean found;
1069           gint cell_start;
1070           gint cell_width;
1071           GList *renderers;
1072           GtkCellRenderer *renderer;
1073
1074           cell_index = atk_object_get_index_in_parent (ATK_OBJECT (cell));
1075           renderers = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (tv_col));
1076           renderer = g_list_nth_data (renderers, cell_index);
1077
1078           found = gtk_tree_view_column_cell_get_position (tv_col, renderer, &cell_start, &cell_width);
1079           if (found)
1080             {
1081               cell_rect->x += cell_start;
1082               cell_rect->width = cell_width;
1083             }
1084           g_list_free (renderers);
1085         }
1086
1087     }
1088 }
1089
1090 static void
1091 gtk_tree_view_accessible_get_cell_extents (GtkCellAccessibleParent *parent,
1092                                            GtkCellAccessible       *cell,
1093                                            gint                    *x,
1094                                            gint                    *y,
1095                                            gint                    *width,
1096                                            gint                    *height,
1097                                            AtkCoordType             coord_type)
1098 {
1099   GtkWidget *widget;
1100   GtkTreeView *tree_view;
1101   GdkWindow *bin_window;
1102   GdkRectangle cell_rect;
1103   gint w_x, w_y;
1104
1105   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (parent));
1106   if (widget == NULL)
1107     return;
1108
1109   tree_view = GTK_TREE_VIEW (widget);
1110   gtk_tree_view_accessible_get_cell_area (parent, cell, &cell_rect);
1111   bin_window = gtk_tree_view_get_bin_window (tree_view);
1112   gdk_window_get_origin (bin_window, &w_x, &w_y);
1113
1114   if (coord_type == ATK_XY_WINDOW)
1115     {
1116       GdkWindow *window;
1117       gint x_toplevel, y_toplevel;
1118
1119       window = gdk_window_get_toplevel (bin_window);
1120       gdk_window_get_origin (window, &x_toplevel, &y_toplevel);
1121
1122       w_x -= x_toplevel;
1123       w_y -= y_toplevel;
1124     }
1125
1126   *width = cell_rect.width;
1127   *height = cell_rect.height;
1128   if (is_cell_showing (tree_view, &cell_rect))
1129     {
1130       *x = cell_rect.x + w_x;
1131       *y = cell_rect.y + w_y;
1132     }
1133   else
1134     {
1135       *x = G_MININT;
1136       *y = G_MININT;
1137     }
1138 }
1139
1140 static gboolean
1141 gtk_tree_view_accessible_grab_cell_focus (GtkCellAccessibleParent *parent,
1142                                           GtkCellAccessible       *cell)
1143 {
1144   GtkWidget *widget;
1145   GtkTreeView *tree_view;
1146   GtkTreeViewColumn *tv_col;
1147   GtkTreePath *path;
1148   AtkObject *parent_cell;
1149   AtkObject *cell_object;
1150   GtkTreeViewAccessibleCellInfo *cell_info;
1151   GtkCellRenderer *renderer = NULL;
1152   GtkWidget *toplevel;
1153   gint index;
1154
1155   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (parent));
1156   if (widget == NULL)
1157     return FALSE;
1158
1159   tree_view = GTK_TREE_VIEW (widget);
1160
1161   cell_info = find_cell_info (GTK_TREE_VIEW_ACCESSIBLE (parent), cell);
1162   if (!cell_info)
1163     return FALSE;
1164   cell_object = ATK_OBJECT (cell);
1165   parent_cell = atk_object_get_parent (cell_object);
1166   tv_col = cell_info->cell_col_ref;
1167   if (parent_cell != ATK_OBJECT (parent))
1168     {
1169       /* GtkCellAccessible is in a GtkContainerCellAccessible.
1170        * The GtkTreeViewColumn has multiple renderers;
1171        * find the corresponding one.
1172        */
1173       GList *renderers;
1174
1175       renderers = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (tv_col));
1176       index = atk_object_get_index_in_parent (cell_object);
1177       renderer = g_list_nth_data (renderers, index);
1178       g_list_free (renderers);
1179     }
1180   path = cell_info_get_path (cell_info);
1181   if (path)
1182     {
1183       if (renderer)
1184         gtk_tree_view_set_cursor_on_cell (tree_view, path, tv_col, renderer, FALSE);
1185       else
1186         gtk_tree_view_set_cursor (tree_view, path, tv_col, FALSE);
1187
1188       gtk_tree_path_free (path);
1189       gtk_widget_grab_focus (widget);
1190       toplevel = gtk_widget_get_toplevel (widget);
1191       if (gtk_widget_is_toplevel (toplevel))
1192         {
1193 #ifdef GDK_WINDOWING_X11
1194           gtk_window_present_with_time (GTK_WINDOW (toplevel),
1195                                         gdk_x11_get_server_time (gtk_widget_get_window (widget)));
1196 #else
1197           gtk_window_present (GTK_WINDOW (toplevel));
1198 #endif
1199         }
1200
1201       return TRUE;
1202     }
1203   else
1204       return FALSE;
1205 }
1206
1207 static int
1208 gtk_tree_view_accessible_get_child_index (GtkCellAccessibleParent *parent,
1209                                           GtkCellAccessible       *cell)
1210 {
1211   GtkTreeViewAccessibleCellInfo *cell_info;
1212   GtkTreeView *tree_view;
1213
1214   cell_info = find_cell_info (GTK_TREE_VIEW_ACCESSIBLE (parent), cell);
1215   if (!cell_info)
1216     return -1;
1217
1218   tree_view = GTK_TREE_VIEW (gtk_accessible_get_widget (GTK_ACCESSIBLE (parent)));
1219
1220   return cell_info_get_index (tree_view, cell_info);
1221 }
1222
1223 static GtkCellRendererState
1224 gtk_tree_view_accessible_get_renderer_state (GtkCellAccessibleParent *parent,
1225                                              GtkCellAccessible       *cell)
1226 {
1227   GtkTreeViewAccessibleCellInfo *cell_info;
1228   GtkTreeView *treeview;
1229   GtkCellRendererState flags;
1230
1231   cell_info = find_cell_info (GTK_TREE_VIEW_ACCESSIBLE (parent), cell);
1232   if (!cell_info)
1233     return 0;
1234
1235   flags = 0;
1236
1237   if (GTK_RBNODE_FLAG_SET (cell_info->node, GTK_RBNODE_IS_SELECTED))
1238     flags |= GTK_CELL_RENDERER_SELECTED;
1239
1240   if (GTK_RBNODE_FLAG_SET (cell_info->node, GTK_RBNODE_IS_PRELIT))
1241     flags |= GTK_CELL_RENDERER_PRELIT;
1242
1243   if (gtk_tree_view_column_get_sort_indicator (cell_info->cell_col_ref))
1244     flags |= GTK_CELL_RENDERER_SORTED;
1245
1246   treeview = GTK_TREE_VIEW (gtk_accessible_get_widget (GTK_ACCESSIBLE (parent)));
1247
1248   if (cell_info->cell_col_ref == gtk_tree_view_get_expander_column (treeview))
1249     {
1250       if (GTK_RBNODE_FLAG_SET (cell_info->node, GTK_RBNODE_IS_PARENT))
1251         flags |= GTK_CELL_RENDERER_EXPANDABLE;
1252
1253       if (cell_info->node->children)
1254         flags |= GTK_CELL_RENDERER_EXPANDED;
1255     }
1256
1257   if (gtk_widget_has_focus (GTK_WIDGET (treeview)))
1258     {
1259       GtkTreeViewColumn *column;
1260       GtkTreePath *path;
1261       GtkRBTree *tree;
1262       GtkRBNode *node;
1263
1264       gtk_tree_view_get_cursor (treeview, &path, &column);
1265       if (path)
1266         {
1267           _gtk_tree_view_find_node (treeview, path, &tree, &node);
1268           gtk_tree_path_free (path);
1269         }
1270       else
1271         tree = NULL;
1272
1273       if (cell_info->cell_col_ref == column
1274           && cell_info->tree == tree
1275           && cell_info->node == node)
1276         flags |= GTK_CELL_RENDERER_FOCUSED;
1277     }
1278
1279   return flags;
1280 }
1281
1282 static void
1283 gtk_tree_view_accessible_expand_collapse (GtkCellAccessibleParent *parent,
1284                                           GtkCellAccessible       *cell)
1285 {
1286   GtkTreeViewAccessibleCellInfo *cell_info;
1287   GtkTreeView *treeview;
1288   GtkTreePath *path;
1289
1290   treeview = GTK_TREE_VIEW (gtk_accessible_get_widget (GTK_ACCESSIBLE (parent)));
1291
1292   cell_info = find_cell_info (GTK_TREE_VIEW_ACCESSIBLE (parent), cell);
1293   if (!cell_info ||
1294       cell_info->cell_col_ref != gtk_tree_view_get_expander_column (treeview))
1295     return;
1296
1297   path = cell_info_get_path (cell_info);
1298
1299   if (cell_info->node->children)
1300     gtk_tree_view_collapse_row (treeview, path);
1301   else
1302     gtk_tree_view_expand_row (treeview, path, FALSE);
1303
1304   gtk_tree_path_free (path);
1305 }
1306
1307 static void
1308 gtk_tree_view_accessible_activate (GtkCellAccessibleParent *parent,
1309                                    GtkCellAccessible       *cell)
1310 {
1311   GtkTreeViewAccessibleCellInfo *cell_info;
1312   GtkTreeView *treeview;
1313   GtkTreePath *path;
1314
1315   treeview = GTK_TREE_VIEW (gtk_accessible_get_widget (GTK_ACCESSIBLE (parent)));
1316
1317   cell_info = find_cell_info (GTK_TREE_VIEW_ACCESSIBLE (parent), cell);
1318   if (!cell_info)
1319     return;
1320
1321   path = cell_info_get_path (cell_info);
1322
1323   gtk_tree_view_row_activated (treeview, path, cell_info->cell_col_ref);
1324
1325   gtk_tree_path_free (path);
1326 }
1327
1328 static void
1329 gtk_tree_view_accessible_edit (GtkCellAccessibleParent *parent,
1330                                GtkCellAccessible       *cell)
1331 {
1332   GtkTreeView *treeview;
1333
1334   if (!gtk_tree_view_accessible_grab_cell_focus (parent, cell))
1335     return;
1336
1337   treeview = GTK_TREE_VIEW (gtk_accessible_get_widget (GTK_ACCESSIBLE (parent)));
1338
1339   g_signal_emit_by_name (treeview,
1340                          "real-select-cursor-row",
1341                          TRUE);
1342 }
1343
1344 static void
1345 gtk_cell_accessible_parent_interface_init (GtkCellAccessibleParentIface *iface)
1346 {
1347   iface->get_cell_extents = gtk_tree_view_accessible_get_cell_extents;
1348   iface->get_cell_area = gtk_tree_view_accessible_get_cell_area;
1349   iface->grab_focus = gtk_tree_view_accessible_grab_cell_focus;
1350   iface->get_child_index = gtk_tree_view_accessible_get_child_index;
1351   iface->get_renderer_state = gtk_tree_view_accessible_get_renderer_state;
1352   iface->expand_collapse = gtk_tree_view_accessible_expand_collapse;
1353   iface->activate = gtk_tree_view_accessible_activate;
1354   iface->edit = gtk_tree_view_accessible_edit;
1355 }
1356
1357 void
1358 _gtk_tree_view_accessible_reorder (GtkTreeView *treeview)
1359 {
1360   GtkTreeViewAccessible *accessible;
1361
1362   accessible = GTK_TREE_VIEW_ACCESSIBLE (_gtk_widget_peek_accessible (GTK_WIDGET (treeview)));
1363   if (accessible == NULL)
1364     return;
1365
1366   g_signal_emit_by_name (accessible, "row-reordered");
1367 }
1368
1369 static gboolean
1370 is_cell_showing (GtkTreeView  *tree_view,
1371                  GdkRectangle *cell_rect)
1372 {
1373   GdkRectangle rect, *visible_rect;
1374   GdkRectangle rect1, *tree_cell_rect;
1375   gint bx, by;
1376   gboolean is_showing;
1377
1378  /* A cell is considered "SHOWING" if any part of the cell is
1379   * in the visible area. Other ways we could do this is by a
1380   * cell's midpoint or if the cell is fully in the visible range.
1381   * Since we have the cell_rect x, y, width, height of the cell,
1382   * any of these is easy to compute.
1383   *
1384   * It is assumed that cell's rectangle is in widget coordinates
1385   * so we must transform to tree cordinates.
1386   */
1387   visible_rect = &rect;
1388   tree_cell_rect = &rect1;
1389   tree_cell_rect->x = cell_rect->x;
1390   tree_cell_rect->y = cell_rect->y;
1391   tree_cell_rect->width = cell_rect->width;
1392   tree_cell_rect->height = cell_rect->height;
1393
1394   gtk_tree_view_get_visible_rect (tree_view, visible_rect);
1395   gtk_tree_view_convert_tree_to_bin_window_coords (tree_view, visible_rect->x,
1396                                                    visible_rect->y, &bx, &by);
1397
1398   if (((tree_cell_rect->x + tree_cell_rect->width) < bx) ||
1399      ((tree_cell_rect->y + tree_cell_rect->height) < by) ||
1400      (tree_cell_rect->x > (bx + visible_rect->width)) ||
1401      (tree_cell_rect->y > (by + visible_rect->height)))
1402     is_showing =  FALSE;
1403   else
1404     is_showing = TRUE;
1405
1406   return is_showing;
1407 }
1408
1409 /* Misc Private */
1410
1411 static int
1412 cell_info_get_index (GtkTreeView                     *tree_view,
1413                      GtkTreeViewAccessibleCellInfo   *info)
1414 {
1415   int index;
1416
1417   index = _gtk_rbtree_node_get_index (info->tree, info->node) + 1;
1418   index *= get_n_columns (tree_view);
1419   index += get_column_number (tree_view, info->cell_col_ref);
1420
1421   return index;
1422 }
1423
1424 static void
1425 cell_info_new (GtkTreeViewAccessible *accessible,
1426                GtkRBTree             *tree,
1427                GtkRBNode             *node,
1428                GtkTreeViewColumn     *tv_col,
1429                GtkCellAccessible     *cell)
1430 {
1431   GtkTreeViewAccessibleCellInfo *cell_info;
1432
1433   cell_info = g_new (GtkTreeViewAccessibleCellInfo, 1);
1434
1435   cell_info->tree = tree;
1436   cell_info->node = node;
1437   cell_info->cell_col_ref = tv_col;
1438   cell_info->cell = g_object_ref (cell);
1439   cell_info->view = accessible;
1440
1441   g_object_set_qdata (G_OBJECT (cell),
1442                       gtk_tree_view_accessible_get_data_quark (),
1443                       cell_info);
1444
1445   g_hash_table_replace (accessible->priv->cell_infos, cell_info, cell_info);
1446 }
1447
1448 /* Returns the column number of the specified GtkTreeViewColumn
1449  * The column must be visible.
1450  */
1451 static gint
1452 get_column_number (GtkTreeView       *treeview,
1453                    GtkTreeViewColumn *column)
1454 {
1455   GtkTreeViewColumn *cur;
1456   guint i, number;
1457
1458   number = 0;
1459
1460   for (i = 0; i < gtk_tree_view_get_n_columns (treeview); i++)
1461     {
1462       cur = gtk_tree_view_get_column (treeview, i);
1463
1464       if (!gtk_tree_view_column_get_visible (cur))
1465         continue;
1466
1467       if (cur == column)
1468         break;
1469
1470       number++;
1471     }
1472
1473   g_return_val_if_fail (i < gtk_tree_view_get_n_columns (treeview), 0);
1474
1475   return number;
1476 }
1477
1478 static gboolean
1479 get_rbtree_column_from_index (GtkTreeView        *tree_view,
1480                               gint                index,
1481                               GtkRBTree         **tree,
1482                               GtkRBNode         **node,
1483                               GtkTreeViewColumn **column)
1484 {
1485   guint n_columns = get_n_columns (tree_view);
1486
1487   if (n_columns == 0)
1488     return FALSE;
1489   /* First row is the column headers */
1490   index -= n_columns;
1491   if (index < 0)
1492     return FALSE;
1493
1494   if (tree)
1495     {
1496       g_return_val_if_fail (node != NULL, FALSE);
1497
1498       if (!_gtk_rbtree_find_index (_gtk_tree_view_get_rbtree (tree_view),
1499                                    index / n_columns,
1500                                    tree,
1501                                    node))
1502         return FALSE;
1503     }
1504
1505   if (column)
1506     {
1507       *column = get_visible_column (tree_view, index % n_columns);
1508       if (*column == NULL)
1509         return FALSE;
1510   }
1511   return TRUE;
1512 }
1513
1514 static GtkTreeViewAccessibleCellInfo *
1515 find_cell_info (GtkTreeViewAccessible *accessible,
1516                 GtkCellAccessible     *cell)
1517 {
1518   AtkObject *parent;
1519
1520   parent = atk_object_get_parent (ATK_OBJECT (cell));
1521   while (parent != ATK_OBJECT (accessible))
1522     {
1523       cell = GTK_CELL_ACCESSIBLE (parent);
1524       parent = atk_object_get_parent (ATK_OBJECT (cell));
1525     }
1526
1527   return g_object_get_qdata (G_OBJECT (cell),
1528                              gtk_tree_view_accessible_get_data_quark ());
1529 }
1530
1531 static AtkObject *
1532 get_header_from_column (GtkTreeViewColumn *tv_col)
1533 {
1534   AtkObject *rc;
1535   GtkWidget *header_widget;
1536
1537   if (tv_col == NULL)
1538     return NULL;
1539
1540   header_widget = gtk_tree_view_column_get_button (tv_col);
1541
1542   if (header_widget)
1543     rc = gtk_widget_get_accessible (header_widget);
1544   else
1545     rc = NULL;
1546
1547   return rc;
1548 }
1549
1550 void
1551 _gtk_tree_view_accessible_add (GtkTreeView *treeview,
1552                                GtkRBTree   *tree,
1553                                GtkRBNode   *node)
1554 {
1555   GtkTreeViewAccessible *accessible;
1556   guint row, n_rows, n_cols, i;
1557
1558   accessible = GTK_TREE_VIEW_ACCESSIBLE (_gtk_widget_peek_accessible (GTK_WIDGET (treeview)));
1559   if (accessible == NULL)
1560     return;
1561
1562   if (node == NULL)
1563     {
1564       row = tree->parent_tree ? _gtk_rbtree_node_get_index (tree->parent_tree, tree->parent_node) : 0;
1565       n_rows = tree->root->total_count;
1566     }
1567   else
1568     {
1569       row = _gtk_rbtree_node_get_index (tree, node);
1570       n_rows = 1 + (node->children ? node->children->root->total_count : 0);
1571     }
1572
1573   g_signal_emit_by_name (accessible, "row-inserted", row, n_rows);
1574
1575   n_cols = get_n_columns (treeview);
1576   if (n_cols)
1577     {
1578       for (i = (row + 1) * n_cols; i < (row + n_rows + 1) * n_cols; i++)
1579         {
1580          /* Pass NULL as the child object, i.e. 4th argument */
1581           g_signal_emit_by_name (accessible, "children-changed::add", i, NULL, NULL);
1582         }
1583     }
1584 }
1585
1586 void
1587 _gtk_tree_view_accessible_remove (GtkTreeView *treeview,
1588                                   GtkRBTree   *tree,
1589                                   GtkRBNode   *node)
1590 {
1591   GtkTreeViewAccessibleCellInfo *cell_info;
1592   GHashTableIter iter;
1593   GtkTreeViewAccessible *accessible;
1594   guint row, n_rows, n_cols, i;
1595
1596   accessible = GTK_TREE_VIEW_ACCESSIBLE (_gtk_widget_peek_accessible (GTK_WIDGET (treeview)));
1597   if (accessible == NULL)
1598     return;
1599
1600   /* if this shows up in profiles, special-case node->children == NULL */
1601
1602   if (node == NULL)
1603     {
1604       row = tree->parent_tree ? _gtk_rbtree_node_get_index (tree->parent_tree, tree->parent_node) : 0;
1605       n_rows = tree->root->total_count + 1;
1606     }
1607   else
1608     {
1609       row = _gtk_rbtree_node_get_index (tree, node);
1610       n_rows = 1 + (node->children ? node->children->root->total_count : 0);
1611
1612       tree = node->children;
1613     }
1614
1615   g_signal_emit_by_name (accessible, "row-deleted", row, n_rows);
1616
1617   n_cols = get_n_columns (treeview);
1618   if (n_cols)
1619     {
1620       for (i = (n_rows + row + 1) * n_cols - 1; i >= (row + 1) * n_cols; i--)
1621         {
1622          /* Pass NULL as the child object, i.e. 4th argument */
1623           g_signal_emit_by_name (accessible, "children-changed::remove", i, NULL, NULL);
1624         }
1625
1626       g_hash_table_iter_init (&iter, accessible->priv->cell_infos);
1627       while (g_hash_table_iter_next (&iter, NULL, (gpointer *)&cell_info))
1628         {
1629           if (node == cell_info->node ||
1630               tree == cell_info->tree ||
1631               (tree && _gtk_rbtree_contains (tree, cell_info->tree)))
1632             g_hash_table_iter_remove (&iter);
1633         }
1634     }
1635 }
1636
1637 void
1638 _gtk_tree_view_accessible_changed (GtkTreeView *treeview,
1639                                    GtkRBTree   *tree,
1640                                    GtkRBNode   *node)
1641 {
1642   GtkTreeViewAccessible *accessible;
1643   guint i;
1644
1645   accessible = GTK_TREE_VIEW_ACCESSIBLE (gtk_widget_get_accessible (GTK_WIDGET (treeview)));
1646
1647   for (i = 0; i < gtk_tree_view_get_n_columns (treeview); i++)
1648     {
1649       GtkCellAccessible *cell = peek_cell (accessible,
1650                                            tree, node,
1651                                            gtk_tree_view_get_column (treeview, i));
1652
1653       if (cell == NULL)
1654         continue;
1655
1656       set_cell_data (treeview, accessible, cell);
1657       _gtk_cell_accessible_update_cache (cell);
1658     }
1659
1660   g_signal_emit_by_name (accessible, "visible-data-changed");
1661 }
1662
1663 /* NB: id is not checked, only columns < id are.
1664  * This is important so the function works for notification of removal of a column */
1665 static guint
1666 to_visible_column_id (GtkTreeView *treeview,
1667                       guint        id)
1668 {
1669   guint i;
1670   guint invisible;
1671
1672   invisible = 0;
1673
1674   for (i = 0; i < id; i++)
1675     {
1676       GtkTreeViewColumn *column = gtk_tree_view_get_column (treeview, i);
1677
1678       if (!gtk_tree_view_column_get_visible (column))
1679         invisible++;
1680     }
1681
1682   return id - invisible;
1683 }
1684
1685 static void
1686 gtk_tree_view_accessible_do_add_column (GtkTreeViewAccessible *accessible,
1687                                         GtkTreeView           *treeview,
1688                                         GtkTreeViewColumn     *column,
1689                                         guint                  id)
1690 {
1691   guint row, n_rows, n_cols;
1692
1693   /* Generate column-inserted signal */
1694   g_signal_emit_by_name (accessible, "column-inserted", id, 1);
1695
1696   n_rows = get_n_rows (treeview);
1697   n_cols = get_n_columns (treeview);
1698
1699   /* Generate children-changed signals */
1700   for (row = 0; row <= n_rows; row++)
1701     {
1702      /* Pass NULL as the child object, i.e. 4th argument */
1703       g_signal_emit_by_name (accessible, "children-changed::add",
1704                              (row * n_cols) + id, NULL, NULL);
1705     }
1706 }
1707
1708 void
1709 _gtk_tree_view_accessible_add_column (GtkTreeView       *treeview,
1710                                       GtkTreeViewColumn *column,
1711                                       guint              id)
1712 {
1713   AtkObject *obj;
1714
1715   if (!gtk_tree_view_column_get_visible (column))
1716     return;
1717
1718   obj = _gtk_widget_peek_accessible (GTK_WIDGET (treeview));
1719   if (obj == NULL)
1720     return;
1721
1722   gtk_tree_view_accessible_do_add_column (GTK_TREE_VIEW_ACCESSIBLE (obj),
1723                                           treeview,
1724                                           column,
1725                                           to_visible_column_id (treeview, id));
1726 }
1727
1728 static void
1729 gtk_tree_view_accessible_do_remove_column (GtkTreeViewAccessible *accessible,
1730                                            GtkTreeView           *treeview,
1731                                            GtkTreeViewColumn     *column,
1732                                            guint                  id)
1733 {
1734   GtkTreeViewAccessibleCellInfo *cell_info;
1735   GHashTableIter iter;
1736   gpointer value;
1737   guint row, n_rows, n_cols;
1738
1739   /* Clean column from cache */
1740   g_hash_table_iter_init (&iter, accessible->priv->cell_infos);
1741   while (g_hash_table_iter_next (&iter, NULL, &value))
1742     {
1743       cell_info = value;
1744       if (cell_info->cell_col_ref == column)
1745         g_hash_table_iter_remove (&iter);
1746     }
1747
1748   /* Generate column-deleted signal */
1749   g_signal_emit_by_name (accessible, "column-deleted", id, 1);
1750
1751   n_rows = get_n_rows (treeview);
1752   n_cols = get_n_columns (treeview);
1753
1754   /* Generate children-changed signals */
1755   for (row = 0; row <= n_rows; row++)
1756     {
1757       /* Pass NULL as the child object, 4th argument */
1758       g_signal_emit_by_name (accessible, "children-changed::remove",
1759                              (row * n_cols) + id, NULL, NULL);
1760     }
1761 }
1762
1763 void
1764 _gtk_tree_view_accessible_remove_column (GtkTreeView       *treeview,
1765                                          GtkTreeViewColumn *column,
1766                                          guint              id)
1767 {
1768   AtkObject *obj;
1769
1770   if (!gtk_tree_view_column_get_visible (column))
1771     return;
1772
1773   obj = _gtk_widget_peek_accessible (GTK_WIDGET (treeview));
1774   if (obj == NULL)
1775     return;
1776
1777   gtk_tree_view_accessible_do_remove_column (GTK_TREE_VIEW_ACCESSIBLE (obj),
1778                                              treeview,
1779                                              column,
1780                                              to_visible_column_id (treeview, id));
1781 }
1782
1783 void
1784 _gtk_tree_view_accessible_reorder_column (GtkTreeView       *treeview,
1785                                           GtkTreeViewColumn *column)
1786 {
1787   AtkObject *obj;
1788
1789   obj = _gtk_widget_peek_accessible (GTK_WIDGET (treeview));
1790   if (obj == NULL)
1791     return;
1792
1793   g_signal_emit_by_name (obj, "column-reordered");
1794 }
1795
1796 void
1797 _gtk_tree_view_accessible_toggle_visibility (GtkTreeView       *treeview,
1798                                              GtkTreeViewColumn *column)
1799 {
1800   AtkObject *obj;
1801   guint i, id;
1802
1803   obj = _gtk_widget_peek_accessible (GTK_WIDGET (treeview));
1804   if (obj == NULL)
1805     return;
1806
1807   if (gtk_tree_view_column_get_visible (column))
1808     {
1809       id = get_column_number (treeview, column);
1810
1811       gtk_tree_view_accessible_do_add_column (GTK_TREE_VIEW_ACCESSIBLE (obj),
1812                                               treeview,
1813                                               column,
1814                                               id);
1815     }
1816   else
1817     {
1818       id = 0;
1819
1820       for (i = 0; i < gtk_tree_view_get_n_columns (treeview); i++)
1821         {
1822           GtkTreeViewColumn *cur = gtk_tree_view_get_column (treeview, i);
1823
1824           if (gtk_tree_view_column_get_visible (cur))
1825             id++;
1826
1827           if (cur == column)
1828             break;
1829         }
1830
1831       gtk_tree_view_accessible_do_remove_column (GTK_TREE_VIEW_ACCESSIBLE (obj),
1832                                                  treeview,
1833                                                  column,
1834                                                  id);
1835     }
1836 }
1837
1838 static GtkTreeViewColumn *
1839 get_effective_focus_column (GtkTreeView       *treeview,
1840                             GtkTreeViewColumn *column)
1841 {
1842   if (column == NULL)
1843     column = get_visible_column (treeview, 0);
1844
1845   return column;
1846 }
1847
1848 void
1849 _gtk_tree_view_accessible_update_focus_column (GtkTreeView       *treeview,
1850                                                GtkTreeViewColumn *old_focus,
1851                                                GtkTreeViewColumn *new_focus)
1852 {
1853   GtkTreeViewAccessible *accessible;
1854   AtkObject *obj;
1855   GtkRBTree *cursor_tree;
1856   GtkRBNode *cursor_node;
1857   GtkCellAccessible *cell;
1858
1859   old_focus = get_effective_focus_column (treeview, old_focus);
1860   new_focus = get_effective_focus_column (treeview, new_focus);
1861   if (old_focus == new_focus)
1862     return;
1863
1864   obj = _gtk_widget_peek_accessible (GTK_WIDGET (treeview));
1865   if (obj == NULL)
1866     return;
1867
1868   accessible = GTK_TREE_VIEW_ACCESSIBLE (obj);
1869
1870   if (!_gtk_tree_view_get_cursor_node (treeview, &cursor_tree, &cursor_node))
1871     return;
1872
1873   if (old_focus)
1874     {
1875       cell = peek_cell (accessible, cursor_tree, cursor_node, old_focus);
1876       if (cell != NULL)
1877         _gtk_cell_accessible_state_changed (cell, GTK_CELL_RENDERER_FOCUSED, 0);
1878     }
1879
1880   if (new_focus)
1881     {
1882       cell = peek_cell (accessible, cursor_tree, cursor_node, new_focus);
1883       if (cell != NULL)
1884         _gtk_cell_accessible_state_changed (cell, 0, GTK_CELL_RENDERER_FOCUSED);
1885       else
1886         cell = create_cell (treeview, accessible, cursor_tree, cursor_node, new_focus);
1887
1888       g_signal_emit_by_name (accessible, "active-descendant-changed", cell);
1889     }
1890 }
1891
1892 void
1893 _gtk_tree_view_accessible_add_state (GtkTreeView          *treeview,
1894                                      GtkRBTree            *tree,
1895                                      GtkRBNode            *node,
1896                                      GtkCellRendererState  state)
1897 {
1898   GtkTreeViewAccessible *accessible;
1899   GtkTreeViewColumn *single_column;
1900   AtkObject *obj;
1901   guint i;
1902
1903   obj = _gtk_widget_peek_accessible (GTK_WIDGET (treeview));
1904   if (obj == NULL)
1905     return;
1906
1907   accessible = GTK_TREE_VIEW_ACCESSIBLE (obj);
1908
1909   if (state == GTK_CELL_RENDERER_FOCUSED)
1910     {
1911       single_column = get_effective_focus_column (treeview, _gtk_tree_view_get_focus_column (treeview));
1912     }
1913   else if (state == GTK_CELL_RENDERER_EXPANDED ||
1914            state == GTK_CELL_RENDERER_EXPANDABLE)
1915     {
1916       single_column = gtk_tree_view_get_expander_column (treeview);
1917     }
1918   else
1919     single_column = NULL;
1920
1921   if (single_column)
1922     {
1923       GtkCellAccessible *cell = peek_cell (accessible,
1924                                            tree, node,
1925                                            single_column);
1926
1927       if (cell != NULL)
1928         _gtk_cell_accessible_state_changed (cell, state, 0);
1929
1930       if (state == GTK_CELL_RENDERER_FOCUSED)
1931         {
1932           if (cell == NULL)
1933             cell = create_cell (treeview, accessible, tree, node, single_column);
1934
1935           g_signal_emit_by_name (accessible, "active-descendant-changed", cell);
1936         }
1937     }
1938   else
1939     {
1940       for (i = 0; i < gtk_tree_view_get_n_columns (treeview); i++)
1941         {
1942           GtkCellAccessible *cell = peek_cell (accessible,
1943                                                tree, node,
1944                                                gtk_tree_view_get_column (treeview, i));
1945
1946           if (cell == NULL)
1947             continue;
1948
1949           _gtk_cell_accessible_state_changed (cell, state, 0);
1950         }
1951     }
1952
1953   if (state == GTK_CELL_RENDERER_SELECTED)
1954     g_signal_emit_by_name (accessible, "selection-changed");
1955 }
1956
1957 void
1958 _gtk_tree_view_accessible_remove_state (GtkTreeView          *treeview,
1959                                         GtkRBTree            *tree,
1960                                         GtkRBNode            *node,
1961                                         GtkCellRendererState  state)
1962 {
1963   GtkTreeViewAccessible *accessible;
1964   GtkTreeViewColumn *single_column;
1965   AtkObject *obj;
1966   guint i;
1967
1968   obj = _gtk_widget_peek_accessible (GTK_WIDGET (treeview));
1969   if (obj == NULL)
1970     return;
1971
1972   accessible = GTK_TREE_VIEW_ACCESSIBLE (obj);
1973
1974   if (state == GTK_CELL_RENDERER_FOCUSED)
1975     {
1976       single_column = get_effective_focus_column (treeview, _gtk_tree_view_get_focus_column (treeview));
1977     }
1978   else if (state == GTK_CELL_RENDERER_EXPANDED ||
1979            state == GTK_CELL_RENDERER_EXPANDABLE)
1980     {
1981       single_column = gtk_tree_view_get_expander_column (treeview);
1982     }
1983   else
1984     single_column = NULL;
1985
1986   if (single_column)
1987     {
1988       GtkCellAccessible *cell = peek_cell (accessible,
1989                                            tree, node,
1990                                            single_column);
1991
1992       if (cell != NULL)
1993         _gtk_cell_accessible_state_changed (cell, 0, state);
1994     }
1995   else
1996     {
1997       for (i = 0; i < gtk_tree_view_get_n_columns (treeview); i++)
1998         {
1999           GtkCellAccessible *cell = peek_cell (accessible,
2000                                                tree, node,
2001                                                gtk_tree_view_get_column (treeview, i));
2002
2003           if (cell == NULL)
2004             continue;
2005
2006           _gtk_cell_accessible_state_changed (cell, 0, state);
2007         }
2008     }
2009
2010   if (state == GTK_CELL_RENDERER_SELECTED)
2011     g_signal_emit_by_name (accessible, "selection-changed");
2012 }