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

   1 /* testtreesort.c
   2  * Copyright (C) 2001 Red Hat, Inc
   3  * Author: Jonathan Blandford
   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 "config.h"
  20 #include <gtk/gtk.h>
  21
  22
  23 typedef struct _ListSort ListSort;
  24 struct _ListSort
  25 {
  26   const gchar *word_1;
  27   const gchar *word_2;
  28   const gchar *word_3;
  29   const gchar *word_4;
  30   gint number_1;
  31 };
  32
  33 static ListSort data[] =
  34 {
  35   { "Apples", "Transmogrify long word to demonstrate weirdness", "Exculpatory", "Gesundheit", 30 },
  36   { "Oranges", "Wicker", "Adamantine", "Convivial", 10 },
  37   { "Bovine Spongiform Encephilopathy", "Sleazebucket", "Mountaineer", "Pander", 40 },
  38   { "Foot and Mouth", "Lampshade", "Skim Milk\nFull Milk", "Viewless", 20 },
  39   { "Blood,\nsweat,\ntears", "The Man", "Horses", "Muckety-Muck", 435 },
  40   { "Rare Steak", "Siam", "Watchdog", "Xantippe" , 99999 },
  41   { "SIGINT", "Rabbit Breath", "Alligator", "Bloodstained", 4123 },
  42   { "Google", "Chrysanthemums", "Hobnob", "Leapfrog", 1 },
  43   { "Technology fibre optic", "Turtle", "Academe", "Lonely", 3 },
  44   { "Freon", "Harpes", "Quidditch", "Reagan", 6},
  45   { "Transposition", "Fruit Basket", "Monkey Wort", "Glogg", 54 },
  46   { "Fern", "Glasnost and Perestroika", "Latitude", "Bomberman!!!", 2 },
  47   {NULL, }
  48 };
  49
  50 static ListSort childdata[] =
  51 {
  52   { "Heineken", "Nederland", "Wanda de vis", "Electronische post", 2},
  53   { "Hottentottententententoonstelling", "Rotterdam", "Ionentransport", "Palm", 45},
  54   { "Fruitvlieg", "Eigenfrequentie", "Supernoodles", "Ramen", 2002},
  55   { "Gereedschapskist", "Stelsel van lineaire vergelijkingen", "Tulpen", "Badlaken", 1311},
  56   { "Stereoinstallatie", "Rood tapijt", "Het periodieke systeem der elementen", "Laaste woord", 200},
  57   {NULL, }
  58 };
  59
  60
  61 enum
  62 {
  63   WORD_COLUMN_1 = 0,
  64   WORD_COLUMN_2,
  65   WORD_COLUMN_3,
  66   WORD_COLUMN_4,
  67   NUMBER_COLUMN_1,
  68   NUM_COLUMNS
  69 };
  70
  71 gboolean
  72 select_func (GtkTreeSelection  *selection,
  73              GtkTreeModel      *model,
  74              GtkTreePath       *path,
  75              gboolean           path_currently_selected,
  76              gpointer           data)
  77 {
  78   if (gtk_tree_path_get_depth (path) > 1)
  79     return TRUE;
  80   return FALSE;
  81 }
  82
  83 static void
  84 switch_search_method (GtkWidget *button,
  85                       gpointer   tree_view)
  86 {
  87   if (!gtk_tree_view_get_search_entry (GTK_TREE_VIEW (tree_view)))
  88     {
  89       gpointer data = g_object_get_data (tree_view, "my-search-entry");
  90       gtk_tree_view_set_search_entry (GTK_TREE_VIEW (tree_view), GTK_ENTRY (data));
  91     }
  92   else
  93     gtk_tree_view_set_search_entry (GTK_TREE_VIEW (tree_view), NULL);
  94 }
  95
  96 int
  97 main (int argc, char *argv[])
  98 {
  99   GtkWidget *window;
 100   GtkWidget *vbox;
 101   GtkWidget *scrolled_window;
 102   GtkWidget *tree_view;
 103   GtkTreeStore *model;
 104   GtkTreeModel *smodel = NULL;
 105   GtkTreeModel *ssmodel = NULL;
 106   GtkCellRenderer *renderer;
 107   GtkTreeViewColumn *column;
 108   GtkTreeIter iter;
 109   gint i;
 110
 111   GtkWidget *entry, *button;
 112   GtkWidget *window2, *vbox2, *scrolled_window2, *tree_view2;
 113   GtkWidget *window3, *vbox3, *scrolled_window3, *tree_view3;
 114
 115   gtk_init (&argc, &argv);
 116
 117   /**
 118    * First window - Just a GtkTreeStore
 119    */
 120
 121   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 122   gtk_window_set_title (GTK_WINDOW (window), "Words, words, words - Window 1");
 123   g_signal_connect (window, "destroy", gtk_main_quit, NULL);
 124   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
 125   gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
 126   gtk_box_pack_start (GTK_BOX (vbox), gtk_label_new ("Jonathan and Kristian's list of cool words. (And Anders' cool list of numbers) \n\nThis is just a GtkTreeStore"), FALSE, FALSE, 0);
 127   gtk_container_add (GTK_CONTAINER (window), vbox);
 128
 129   entry = gtk_entry_new ();
 130   gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
 131
 132   button = gtk_button_new_with_label ("Switch search method");
 133   gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 134
 135   scrolled_window = gtk_scrolled_window_new (NULL, NULL);
 136   gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_ETCHED_IN);
 137   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 138   gtk_box_pack_start (GTK_BOX (vbox), scrolled_window, TRUE, TRUE, 0);
 139
 140   model = gtk_tree_store_new (NUM_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
 141
 142 /*
 143   smodel = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (model));
 144   ssmodel = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (smodel));
 145 */
 146   tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
 147
 148   gtk_tree_view_set_search_entry (GTK_TREE_VIEW (tree_view), GTK_ENTRY (entry));
 149   g_object_set_data (G_OBJECT (tree_view), "my-search-entry", entry);
 150   g_signal_connect (button, "clicked",
 151                     G_CALLBACK (switch_search_method), tree_view);
 152
 153  /* gtk_tree_selection_set_select_function (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)), select_func, NULL, NULL);*/
 154
 155   /* 12 iters now, 12 later... */
 156   for (i = 0; data[i].word_1 != NULL; i++)
 157     {
 158       gint k;
 159       GtkTreeIter child_iter;
 160
 161
 162       gtk_tree_store_prepend (GTK_TREE_STORE (model), &iter, NULL);
 163       gtk_tree_store_set (GTK_TREE_STORE (model), &iter,
 164                           WORD_COLUMN_1, data[i].word_1,
 165                           WORD_COLUMN_2, data[i].word_2,
 166                           WORD_COLUMN_3, data[i].word_3,
 167                           WORD_COLUMN_4, data[i].word_4,
 168                           NUMBER_COLUMN_1, data[i].number_1,
 169                           -1);
 170
 171       gtk_tree_store_append (GTK_TREE_STORE (model), &child_iter, &iter);
 172       gtk_tree_store_set (GTK_TREE_STORE (model), &child_iter,
 173                           WORD_COLUMN_1, data[i].word_1,
 174                           WORD_COLUMN_2, data[i].word_2,
 175                           WORD_COLUMN_3, data[i].word_3,
 176                           WORD_COLUMN_4, data[i].word_4,
 177                           NUMBER_COLUMN_1, data[i].number_1,
 178                           -1);
 179
 180       for (k = 0; childdata[k].word_1 != NULL; k++)
 181         {
 182           gtk_tree_store_append (GTK_TREE_STORE (model), &child_iter, &iter);
 183           gtk_tree_store_set (GTK_TREE_STORE (model), &child_iter,
 184                               WORD_COLUMN_1, childdata[k].word_1,
 185                               WORD_COLUMN_2, childdata[k].word_2,
 186                               WORD_COLUMN_3, childdata[k].word_3,
 187                               WORD_COLUMN_4, childdata[k].word_4,
 188                               NUMBER_COLUMN_1, childdata[k].number_1,
 189                               -1);
 190
 191         }
 192
 193     }
 194
 195   smodel = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (model));
 196   ssmodel = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (smodel));
 197   g_object_unref (model);
 198
 199   gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tree_view), TRUE);
 200
 201   renderer = gtk_cell_renderer_text_new ();
 202   column = gtk_tree_view_column_new_with_attributes ("First Word", renderer,
 203                                                      "text", WORD_COLUMN_1,
 204                                                      NULL);
 205   gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
 206   gtk_tree_view_column_set_sort_column_id (column, WORD_COLUMN_1);
 207
 208   renderer = gtk_cell_renderer_text_new ();
 209   column = gtk_tree_view_column_new_with_attributes ("Second Word", renderer,
 210                                                      "text", WORD_COLUMN_2,
 211                                                      NULL);
 212   gtk_tree_view_column_set_sort_column_id (column, WORD_COLUMN_2);
 213   gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
 214
 215   renderer = gtk_cell_renderer_text_new ();
 216   column = gtk_tree_view_column_new_with_attributes ("Third Word", renderer,
 217                                                      "text", WORD_COLUMN_3,
 218                                                      NULL);
 219   gtk_tree_view_column_set_sort_column_id (column, WORD_COLUMN_3);
 220   gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
 221
 222   renderer = gtk_cell_renderer_text_new ();
 223   column = gtk_tree_view_column_new_with_attributes ("Fourth Word", renderer,
 224                                                      "text", WORD_COLUMN_4,
 225                                                      NULL);
 226   gtk_tree_view_column_set_sort_column_id (column, WORD_COLUMN_4);
 227   gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
 228
 229   renderer = gtk_cell_renderer_text_new ();
 230   column = gtk_tree_view_column_new_with_attributes ("First Number", renderer,
 231                                                      "text", NUMBER_COLUMN_1,
 232                                                      NULL);
 233   gtk_tree_view_column_set_sort_column_id (column, NUMBER_COLUMN_1);
 234   gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
 235
 236   /*  gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (smodel),
 237                                         WORD_COLUMN_1,
 238                                         GTK_SORT_ASCENDING);*/
 239
 240   gtk_container_add (GTK_CONTAINER (scrolled_window), tree_view);
 241   gtk_window_set_default_size (GTK_WINDOW (window), 400, 400);
 242   gtk_widget_show_all (window);
 243
 244   /**
 245    * Second window - GtkTreeModelSort wrapping the GtkTreeStore
 246    */
 247
 248   if (smodel)
 249     {
 250       window2 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 251       gtk_window_set_title (GTK_WINDOW (window2),
 252                             "Words, words, words - window 2");
 253       g_signal_connect (window2, "destroy", gtk_main_quit, NULL);
 254       vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
 255       gtk_container_set_border_width (GTK_CONTAINER (vbox2), 8);
 256       gtk_box_pack_start (GTK_BOX (vbox2),
 257                           gtk_label_new ("Jonathan and Kristian's list of words.\n\nA GtkTreeModelSort wrapping the GtkTreeStore of window 1"),
 258                           FALSE, FALSE, 0);
 259       gtk_container_add (GTK_CONTAINER (window2), vbox2);
 260
 261       scrolled_window2 = gtk_scrolled_window_new (NULL, NULL);
 262       gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window2),
 263                                            GTK_SHADOW_ETCHED_IN);
 264       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window2),
 265                                       GTK_POLICY_AUTOMATIC,
 266                                       GTK_POLICY_AUTOMATIC);
 267       gtk_box_pack_start (GTK_BOX (vbox2), scrolled_window2, TRUE, TRUE, 0);
 268
 269
 270       tree_view2 = gtk_tree_view_new_with_model (smodel);
 271       gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tree_view2), TRUE);
 272
 273
 274       renderer = gtk_cell_renderer_text_new ();
 275       column = gtk_tree_view_column_new_with_attributes ("First Word", renderer,
 276                                                          "text", WORD_COLUMN_1,
 277                                                          NULL);
 278       gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view2), column);
 279       gtk_tree_view_column_set_sort_column_id (column, WORD_COLUMN_1);
 280
 281       renderer = gtk_cell_renderer_text_new ();
 282       column = gtk_tree_view_column_new_with_attributes ("Second Word", renderer,
 283                                                          "text", WORD_COLUMN_2,
 284                                                          NULL);
 285       gtk_tree_view_column_set_sort_column_id (column, WORD_COLUMN_2);
 286       gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view2), column);
 287
 288       renderer = gtk_cell_renderer_text_new ();
 289       column = gtk_tree_view_column_new_with_attributes ("Third Word", renderer,
 290                                                          "text", WORD_COLUMN_3,
 291                                                          NULL);
 292       gtk_tree_view_column_set_sort_column_id (column, WORD_COLUMN_3);
 293       gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view2), column);
 294
 295       renderer = gtk_cell_renderer_text_new ();
 296       column = gtk_tree_view_column_new_with_attributes ("Fourth Word", renderer,
 297                                                          "text", WORD_COLUMN_4,
 298                                                          NULL);
 299       gtk_tree_view_column_set_sort_column_id (column, WORD_COLUMN_4);
 300       gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view2), column);
 301
 302       /*      gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (smodel),
 303                                                (GtkTreeIterCompareFunc)gtk_tree_data_list_compare_func,
 304                                                NULL, NULL);
 305       gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (smodel),
 306                                             WORD_COLUMN_1,
 307                                             GTK_SORT_DESCENDING);*/
 308
 309
 310       gtk_container_add (GTK_CONTAINER (scrolled_window2), tree_view2);
 311       gtk_window_set_default_size (GTK_WINDOW (window2), 400, 400);
 312       gtk_widget_show_all (window2);
 313     }
 314
 315   /**
 316    * Third window - GtkTreeModelSort wrapping the GtkTreeModelSort which
 317    * is wrapping the GtkTreeStore.
 318    */
 319
 320   if (ssmodel)
 321     {
 322       window3 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 323       gtk_window_set_title (GTK_WINDOW (window3),
 324                             "Words, words, words - Window 3");
 325       g_signal_connect (window3, "destroy", gtk_main_quit, NULL);
 326       vbox3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
 327       gtk_container_set_border_width (GTK_CONTAINER (vbox3), 8);
 328       gtk_box_pack_start (GTK_BOX (vbox3),
 329                           gtk_label_new ("Jonathan and Kristian's list of words.\n\nA GtkTreeModelSort wrapping the GtkTreeModelSort of window 2"),
 330                           FALSE, FALSE, 0);
 331       gtk_container_add (GTK_CONTAINER (window3), vbox3);
 332
 333       scrolled_window3 = gtk_scrolled_window_new (NULL, NULL);
 334       gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window3),
 335                                            GTK_SHADOW_ETCHED_IN);
 336       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window3),
 337                                       GTK_POLICY_AUTOMATIC,
 338                                       GTK_POLICY_AUTOMATIC);
 339       gtk_box_pack_start (GTK_BOX (vbox3), scrolled_window3, TRUE, TRUE, 0);
 340
 341
 342       tree_view3 = gtk_tree_view_new_with_model (ssmodel);
 343       gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tree_view3), TRUE);
 344
 345       renderer = gtk_cell_renderer_text_new ();
 346       column = gtk_tree_view_column_new_with_attributes ("First Word", renderer,
 347                                                          "text", WORD_COLUMN_1,
 348                                                          NULL);
 349       gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view3), column);
 350       gtk_tree_view_column_set_sort_column_id (column, WORD_COLUMN_1);
 351
 352       renderer = gtk_cell_renderer_text_new ();
 353       column = gtk_tree_view_column_new_with_attributes ("Second Word", renderer,
 354                                                          "text", WORD_COLUMN_2,
 355                                                          NULL);
 356       gtk_tree_view_column_set_sort_column_id (column, WORD_COLUMN_2);
 357       gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view3), column);
 358
 359       renderer = gtk_cell_renderer_text_new ();
 360       column = gtk_tree_view_column_new_with_attributes ("Third Word", renderer,
 361                                                          "text", WORD_COLUMN_3,
 362                                                          NULL);
 363       gtk_tree_view_column_set_sort_column_id (column, WORD_COLUMN_3);
 364       gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view3), column);
 365
 366       renderer = gtk_cell_renderer_text_new ();
 367       column = gtk_tree_view_column_new_with_attributes ("Fourth Word", renderer,
 368                                                          "text", WORD_COLUMN_4,
 369                                                          NULL);
 370       gtk_tree_view_column_set_sort_column_id (column, WORD_COLUMN_4);
 371       gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view3), column);
 372
 373       /*      gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (ssmodel),
 374                                                (GtkTreeIterCompareFunc)gtk_tree_data_list_compare_func,
 375                                                NULL, NULL);
 376       gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (ssmodel),
 377                                             WORD_COLUMN_1,
 378                                             GTK_SORT_ASCENDING);*/
 379
 380       gtk_container_add (GTK_CONTAINER (scrolled_window3), tree_view3);
 381       gtk_window_set_default_size (GTK_WINDOW (window3), 400, 400);
 382       gtk_widget_show_all (window3);
 383     }
 384
 385   for (i = 0; data[i].word_1 != NULL; i++)
 386     {
 387       gint k;
 388
 389       gtk_tree_store_prepend (GTK_TREE_STORE (model), &iter, NULL);
 390       gtk_tree_store_set (GTK_TREE_STORE (model), &iter,
 391                           WORD_COLUMN_1, data[i].word_1,
 392                           WORD_COLUMN_2, data[i].word_2,
 393                           WORD_COLUMN_3, data[i].word_3,
 394                           WORD_COLUMN_4, data[i].word_4,
 395                           -1);
 396       for (k = 0; childdata[k].word_1 != NULL; k++)
 397         {
 398           GtkTreeIter child_iter;
 399
 400           gtk_tree_store_append (GTK_TREE_STORE (model), &child_iter, &iter);
 401           gtk_tree_store_set (GTK_TREE_STORE (model), &child_iter,
 402                               WORD_COLUMN_1, childdata[k].word_1,
 403                               WORD_COLUMN_2, childdata[k].word_2,
 404                               WORD_COLUMN_3, childdata[k].word_3,
 405                               WORD_COLUMN_4, childdata[k].word_4,
 406                               -1);
 407         }
 408     }
 409
 410   gtk_main ();
 411
 412   return 0;
 413 }