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