Pileus Git - ~andy/gtk/blob - tests/testtreechanging.c

   1 /* testtreeview.c
   2  * Copyright (C) 2011 Red Hat, Inc
   3  * Author: Benjamin Otte <otte@gnome.org>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include "prop-editor.h"
  22 #include <gtk/gtk.h>
  23
  24 #define MIN_ROWS 50
  25 #define MAX_ROWS 150
  26
  27 typedef void (* DoStuffFunc) (GtkTreeView *treeview);
  28
  29 static guint
  30 count_children (GtkTreeModel *model,
  31                 GtkTreeIter  *parent)
  32 {
  33   GtkTreeIter iter;
  34   guint count = 0;
  35   gboolean valid;
  36
  37   for (valid = gtk_tree_model_iter_children (model, &iter, parent);
  38        valid;
  39        valid = gtk_tree_model_iter_next (model, &iter))
  40     {
  41       count += count_children (model, &iter) + 1;
  42     }
  43
  44   return count;
  45 }
  46
  47 static void
  48 set_rows (GtkTreeView *treeview, guint i)
  49 {
  50   g_assert (i == count_children (gtk_tree_view_get_model (treeview), NULL));
  51   g_object_set_data (G_OBJECT (treeview), "rows", GUINT_TO_POINTER (i));
  52 }
  53
  54 static guint
  55 get_rows (GtkTreeView *treeview)
  56 {
  57   return GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (treeview), "rows"));
  58 }
  59
  60 static void
  61 log_operation_for_path (GtkTreePath *path,
  62                         const char  *operation_name)
  63 {
  64   char *path_string;
  65
  66   path_string = path ? gtk_tree_path_to_string (path) : g_strdup ("");
  67
  68   g_printerr ("%10s %s\n", operation_name, path_string);
  69
  70   g_free (path_string);
  71 }
  72
  73 static void
  74 log_operation (GtkTreeModel *model,
  75                GtkTreeIter  *iter,
  76                const char   *operation_name)
  77 {
  78   GtkTreePath *path;
  79
  80   path = gtk_tree_model_get_path (model, iter);
  81
  82   log_operation_for_path (path, operation_name);
  83
  84   gtk_tree_path_free (path);
  85 }
  86
  87 /* moves iter to the next iter in the model in the display order
  88  * inside a treeview. Returns FALSE if no more rows exist.
  89  */
  90 static gboolean
  91 tree_model_iter_step (GtkTreeModel *model,
  92                       GtkTreeIter *iter)
  93 {
  94   GtkTreeIter tmp;
  95
  96   if (gtk_tree_model_iter_children (model, &tmp, iter))
  97     {
  98       *iter = tmp;
  99       return TRUE;
 100     }
 101
 102   do {
 103     tmp = *iter;
 104
 105     if (gtk_tree_model_iter_next (model, iter))
 106       return TRUE;
 107     }
 108   while (gtk_tree_model_iter_parent (model, iter, &tmp));
 109
 110   return FALSE;
 111 }
 112
 113 /* NB: may include invisible iters (because they are collapsed) */
 114 static void
 115 tree_view_random_iter (GtkTreeView *treeview,
 116                        GtkTreeIter *iter)
 117 {
 118   guint n_rows = get_rows (treeview);
 119   guint i = g_random_int_range (0, n_rows);
 120   GtkTreeModel *model;
 121
 122   model = gtk_tree_view_get_model (treeview);
 123
 124   if (!gtk_tree_model_get_iter_first (model, iter))
 125     return;
 126
 127   while (i-- > 0)
 128     {
 129       if (!tree_model_iter_step (model, iter))
 130         {
 131           g_assert_not_reached ();
 132           return;
 133         }
 134     }
 135
 136   return;
 137 }
 138
 139 static void
 140 delete (GtkTreeView *treeview)
 141 {
 142   guint n_rows = get_rows (treeview);
 143   GtkTreeModel *model;
 144   GtkTreeIter iter;
 145
 146   model = gtk_tree_view_get_model (treeview);
 147
 148   tree_view_random_iter (treeview, &iter);
 149
 150   n_rows -= count_children (model, &iter) + 1;
 151   log_operation (model, &iter, "remove");
 152   gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
 153   set_rows (treeview, n_rows);
 154 }
 155
 156 static void
 157 add_one (GtkTreeModel *model,
 158          GtkTreeIter *iter)
 159 {
 160   guint n = gtk_tree_model_iter_n_children (model, iter);
 161   GtkTreeIter new_iter;
 162   static guint counter = 0;
 163
 164   if (n > 0 && g_random_boolean ())
 165     {
 166       GtkTreeIter child;
 167       gtk_tree_model_iter_nth_child (model, &child, iter, g_random_int_range (0, n));
 168       add_one (model, &child);
 169       return;
 170     }
 171
 172   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model),
 173                                      &new_iter,
 174                                      iter,
 175                                      g_random_int_range (-1, n),
 176                                      0, ++counter,
 177                                      -1);
 178   log_operation (model, &new_iter, "add");
 179 }
 180
 181 static void
 182 add (GtkTreeView *treeview)
 183 {
 184   GtkTreeModel *model;
 185
 186   model = gtk_tree_view_get_model (treeview);
 187   add_one (model, NULL);
 188
 189   set_rows (treeview, get_rows (treeview) + 1);
 190 }
 191
 192 static void
 193 add_or_delete (GtkTreeView *treeview)
 194 {
 195   guint n_rows = get_rows (treeview);
 196
 197   if (g_random_int_range (MIN_ROWS, MAX_ROWS) >= n_rows)
 198     add (treeview);
 199   else
 200     delete (treeview);
 201 }
 202
 203 /* XXX: We only expand/collapse from the top and not randomly */
 204 static void
 205 expand (GtkTreeView *treeview)
 206 {
 207   GtkTreeModel *model;
 208   GtkTreeIter iter;
 209   GtkTreePath *path;
 210   gboolean valid;
 211
 212   model = gtk_tree_view_get_model (treeview);
 213
 214   for (valid = gtk_tree_model_get_iter_first (model, &iter);
 215        valid;
 216        valid = tree_model_iter_step (model, &iter))
 217     {
 218       if (gtk_tree_model_iter_has_child (model, &iter))
 219         {
 220           path = gtk_tree_model_get_path (model, &iter);
 221           if (!gtk_tree_view_row_expanded (treeview, path))
 222             {
 223               log_operation (model, &iter, "expand");
 224               gtk_tree_view_expand_row (treeview, path, FALSE);
 225               gtk_tree_path_free (path);
 226               return;
 227             }
 228           gtk_tree_path_free (path);
 229         }
 230     }
 231 }
 232
 233 static void
 234 collapse (GtkTreeView *treeview)
 235 {
 236   GtkTreeModel *model;
 237   GtkTreeIter iter;
 238   GtkTreePath *last, *path;
 239   gboolean valid;
 240
 241   model = gtk_tree_view_get_model (treeview);
 242   last = NULL;
 243
 244   for (valid = gtk_tree_model_get_iter_first (model, &iter);
 245        valid;
 246        valid = tree_model_iter_step (model, &iter))
 247     {
 248       path = gtk_tree_model_get_path (model, &iter);
 249       if (gtk_tree_view_row_expanded (treeview, path))
 250         {
 251           if (last)
 252             gtk_tree_path_free (last);
 253           last = path;
 254         }
 255       else
 256         gtk_tree_path_free (path);
 257     }
 258
 259   if (last)
 260     {
 261       log_operation_for_path (last, "collapse");
 262       gtk_tree_view_collapse_row (treeview, last);
 263       gtk_tree_path_free (last);
 264     }
 265 }
 266
 267 static void
 268 select_ (GtkTreeView *treeview)
 269 {
 270   GtkTreeIter iter;
 271
 272   tree_view_random_iter (treeview, &iter);
 273
 274   log_operation (gtk_tree_view_get_model (treeview), &iter, "select");
 275   gtk_tree_selection_select_iter (gtk_tree_view_get_selection (treeview),
 276                                   &iter);
 277 }
 278
 279 static void
 280 unselect (GtkTreeView *treeview)
 281 {
 282   GtkTreeIter iter;
 283
 284   tree_view_random_iter (treeview, &iter);
 285
 286   log_operation (gtk_tree_view_get_model (treeview), &iter, "unselect");
 287   gtk_tree_selection_unselect_iter (gtk_tree_view_get_selection (treeview),
 288                                     &iter);
 289 }
 290
 291 static void
 292 reset_model (GtkTreeView *treeview)
 293 {
 294   GtkTreeSelection *selection;
 295   GtkTreeModel *model;
 296   GList *list, *selected;
 297   GtkTreePath *cursor;
 298
 299   selection = gtk_tree_view_get_selection (treeview);
 300   model = g_object_ref (gtk_tree_view_get_model (treeview));
 301
 302   log_operation_for_path (NULL, "reset");
 303
 304   selected = gtk_tree_selection_get_selected_rows (selection, NULL);
 305   gtk_tree_view_get_cursor (treeview, &cursor, NULL);
 306
 307   gtk_tree_view_set_model (treeview, NULL);
 308   gtk_tree_view_set_model (treeview, model);
 309
 310   if (cursor)
 311     {
 312       gtk_tree_view_set_cursor (treeview, cursor, NULL, FALSE);
 313       gtk_tree_path_free (cursor);
 314     }
 315   for (list = selected; list; list = list->next)
 316     {
 317       gtk_tree_selection_select_path (selection, list->data);
 318     }
 319   g_list_free_full (selected, (GDestroyNotify) gtk_tree_path_free);
 320
 321   g_object_unref (model);
 322 }
 323
 324 /* sanity checks */
 325
 326 static void
 327 assert_row_reference_is_path (GtkTreeRowReference *ref,
 328                               GtkTreePath *path)
 329 {
 330   GtkTreePath *expected;
 331
 332   if (ref == NULL)
 333     {
 334       g_assert (path == NULL);
 335       return;
 336     }
 337
 338   g_assert (path != NULL);
 339   g_assert (gtk_tree_row_reference_valid (ref));
 340
 341   expected = gtk_tree_row_reference_get_path (ref);
 342   g_assert (expected != NULL);
 343   g_assert (gtk_tree_path_compare (expected, path) == 0);
 344   gtk_tree_path_free (expected);
 345 }
 346
 347 static void
 348 check_cursor (GtkTreeView *treeview)
 349 {
 350   GtkTreeRowReference *ref = g_object_get_data (G_OBJECT (treeview), "cursor");
 351   GtkTreePath *cursor;
 352
 353   gtk_tree_view_get_cursor (treeview, &cursor, NULL);
 354   assert_row_reference_is_path (ref, cursor);
 355
 356   if (cursor)
 357     gtk_tree_path_free (cursor);
 358 }
 359
 360 static void
 361 check_selection_item (GtkTreeModel *model,
 362                       GtkTreePath  *path,
 363                       GtkTreeIter  *iter,
 364                       gpointer      listp)
 365 {
 366   GList **list = listp;
 367
 368   g_assert (*list);
 369   assert_row_reference_is_path ((*list)->data, path);
 370   *list = (*list)->next;
 371 }
 372
 373 static void
 374 check_selection (GtkTreeView *treeview)
 375 {
 376   GList *selection = g_object_get_data (G_OBJECT (treeview), "selection");
 377
 378   gtk_tree_selection_selected_foreach (gtk_tree_view_get_selection (treeview),
 379                                        check_selection_item,
 380                                        &selection);
 381 }
 382
 383 static void
 384 check_sanity (GtkTreeView *treeview)
 385 {
 386   check_cursor (treeview);
 387   check_selection (treeview);
 388 }
 389
 390 static gboolean
 391 dance (gpointer treeview)
 392 {
 393   static const DoStuffFunc funcs[] = {
 394     add_or_delete,
 395     add_or_delete,
 396     expand,
 397     collapse,
 398     select_,
 399     unselect,
 400     reset_model
 401   };
 402   guint i;
 403
 404   i = g_random_int_range (0, G_N_ELEMENTS(funcs));
 405
 406   funcs[i] (treeview);
 407
 408   check_sanity (treeview);
 409
 410   return G_SOURCE_CONTINUE;
 411 }
 412
 413 static void
 414 cursor_changed_cb (GtkTreeView *treeview,
 415                    gpointer     unused)
 416 {
 417   GtkTreePath *path;
 418   GtkTreeRowReference *ref;
 419
 420   gtk_tree_view_get_cursor (treeview, &path, NULL);
 421   if (path)
 422     {
 423       ref = gtk_tree_row_reference_new (gtk_tree_view_get_model (treeview),
 424                                         path);
 425       gtk_tree_path_free (path);
 426     }
 427   else
 428     ref = NULL;
 429   g_object_set_data_full (G_OBJECT (treeview), "cursor", ref, (GDestroyNotify) gtk_tree_row_reference_free);
 430 }
 431
 432 static void
 433 selection_list_free (gpointer list)
 434 {
 435   g_list_free_full (list, (GDestroyNotify) gtk_tree_row_reference_free);
 436 }
 437
 438 static void
 439 selection_changed_cb (GtkTreeSelection *tree_selection,
 440                       gpointer          unused)
 441 {
 442   GList *selected, *list;
 443   GtkTreeModel *model;
 444
 445   selected = gtk_tree_selection_get_selected_rows (tree_selection, &model);
 446
 447   for (list = selected; list; list = list->next)
 448     {
 449       GtkTreePath *path = list->data;
 450
 451       list->data = gtk_tree_row_reference_new (model, path);
 452       gtk_tree_path_free (path);
 453     }
 454
 455   g_object_set_data_full (G_OBJECT (gtk_tree_selection_get_tree_view (tree_selection)),
 456                           "selection",
 457                           selected,
 458                           selection_list_free);
 459 }
 460
 461 static void
 462 setup_sanity_checks (GtkTreeView *treeview)
 463 {
 464   g_signal_connect (treeview, "cursor-changed", G_CALLBACK (cursor_changed_cb), NULL);
 465   cursor_changed_cb (treeview, NULL);
 466   g_signal_connect (gtk_tree_view_get_selection (treeview), "changed", G_CALLBACK (selection_changed_cb), NULL);
 467   selection_changed_cb (gtk_tree_view_get_selection (treeview), NULL);
 468 }
 469
 470 int
 471 main (int    argc,
 472       char **argv)
 473 {
 474   GtkWidget *window;
 475   GtkWidget *sw;
 476   GtkWidget *treeview;
 477   GtkTreeModel *model;
 478   guint i;
 479
 480   gtk_init (&argc, &argv);
 481
 482   if (g_getenv ("RTL"))
 483     gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL);
 484
 485   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 486   g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
 487   gtk_window_set_default_size (GTK_WINDOW (window), 430, 400);
 488
 489   sw = gtk_scrolled_window_new (NULL, NULL);
 490   gtk_widget_set_hexpand (sw, TRUE);
 491   gtk_widget_set_vexpand (sw, TRUE);
 492   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
 493                                   GTK_POLICY_AUTOMATIC,
 494                                   GTK_POLICY_AUTOMATIC);
 495   gtk_container_add (GTK_CONTAINER (window), sw);
 496
 497   model = GTK_TREE_MODEL (gtk_tree_store_new (1, G_TYPE_UINT));
 498   treeview = gtk_tree_view_new_with_model (model);
 499   g_object_unref (model);
 500   setup_sanity_checks (GTK_TREE_VIEW (treeview));
 501   gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
 502                                                0,
 503                                                "Counter",
 504                                                gtk_cell_renderer_text_new (),
 505                                                "text", 0,
 506                                                NULL);
 507   for (i = 0; i < (MIN_ROWS + MAX_ROWS) / 2; i++)
 508     add (GTK_TREE_VIEW (treeview));
 509   gtk_container_add (GTK_CONTAINER (sw), treeview);
 510
 511   create_prop_editor (G_OBJECT (treeview), GTK_TYPE_TREE_VIEW);
 512   create_prop_editor (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview))), GTK_TYPE_TREE_SELECTION);
 513
 514   gtk_widget_show_all (window);
 515
 516   g_idle_add (dance, treeview);
 517
 518   gtk_main ();
 519
 520   return 0;
 521 }
 522