libegg/test-tree-utils.c

   1 #include <gtk/gtk.h>
   2 #include <stdio.h>
   3 #include "eggtreeviewstate.h"
   4 #include "eggcellrendererkeys.h"
   5
   6 #if 0
   7 #include "eggnodestate.h"
   8 #endif
   9
  10 typedef GtkWidget *(* CreateWindowFunc) (void);
  11
  12 const char state_string[] = ""
  13 "<treeview_state>"
  14 "  <treeview headers_visible=\"true\" search_column=\"0\">"
  15 "    <column title=\"Test first\" fixed_width=\"150\" resizable=\"true\" sizing=\"fixed\">"
  16 "      <cell text=\"Sliff sloff\" type=\"GtkCellRendererText\" />"
  17 "    </column>"
  18 "    <column title=\"Test\" reorderable=\"true\" sizing=\"autosize\">"
  19 "      <cell type=\"GtkCellRendererToggle\" expand=\"false\" active=\"model:1\"/>"
  20 "      <cell type=\"GtkCellRendererText\" text=\"model:0\"/>"
  21 "    </column>"
  22 "  </treeview>"
  23 "</treeview_state>";
  24
  25 static GtkWidget *
  26 state_test (void)
  27 {
  28   GtkWidget *window, *sw, *view;
  29   GtkListStore *store;
  30   GtkTreeIter iter;
  31   GError *error = NULL;
  32
  33   egg_tree_view_state_add_cell_renderer_type (GTK_TYPE_CELL_RENDERER_TOGGLE);
  34
  35   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  36
  37   store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);
  38
  39   gtk_list_store_append (store, &iter);
  40   gtk_list_store_set (store, &iter,
  41                       0, "Test string",
  42                       1, TRUE,
  43                       -1);
  44   gtk_list_store_append (store, &iter);
  45   gtk_list_store_set (store, &iter,
  46                       0, "Another string",
  47                       1, FALSE,
  48                       -1);
  49
  50   sw = gtk_scrolled_window_new (NULL, NULL);
  51   gtk_container_add (GTK_CONTAINER (window), sw);
  52   view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
  53
  54   if (!egg_tree_view_state_apply_from_string (GTK_TREE_VIEW (view), state_string, &error))
  55     {
  56       g_print ("error: %s\n", error->message);
  57     }
  58
  59   gtk_container_add (GTK_CONTAINER (sw), view);
  60
  61   return window;
  62 }
  63
  64 static GtkWidget *
  65 progress_bar_test (void)
  66 {
  67   GtkWidget *window;
  68
  69   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  70
  71   return window;
  72 }
  73
  74 #if 0
  75 static void
  76 node_state_save (GtkWidget *button, GtkTreeView *tree_view)
  77 {
  78         gboolean ret;
  79
  80         ret = egg_node_state_save_to_file (tree_view, "treeviewnodestate.xml");
  81 }
  82
  83 static void
  84 node_state_restore (GtkWidget *button, GtkTreeView *tree_view)
  85 {
  86         gboolean ret;
  87
  88         ret = egg_node_state_restore_from_file (tree_view,
  89                                                 "treeviewnodestate.xml");
  90 }
  91
  92 static GtkWidget *
  93 node_state_test (void)
  94 {
  95         GtkWidget *window, *sw, *tv, *hbox, *vbox, *button;
  96         GtkTreeStore *store;
  97         GtkTreeViewColumn *column;
  98         GtkCellRenderer *rend;
  99         gint i;
 100
 101         /* create window */
 102         window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 103
 104         vbox = gtk_vbox_new (FALSE, 3);
 105         gtk_container_add (GTK_CONTAINER (window), vbox);
 106
 107         sw = gtk_scrolled_window_new (NULL, NULL);
 108         gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
 109
 110         store = gtk_tree_store_new (1, G_TYPE_STRING);
 111         tv = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
 112
 113         column = gtk_tree_view_column_new ();
 114         rend = gtk_cell_renderer_text_new ();
 115         gtk_tree_view_column_pack_start (column, rend,
 116                                          TRUE);
 117         gtk_tree_view_column_set_attributes (column, rend,
 118                                              "text", 0,
 119                                              NULL);
 120         gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column);
 121
 122         gtk_container_add (GTK_CONTAINER (sw), tv);
 123
 124         hbox = gtk_hbox_new (TRUE, 2);
 125         gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
 126
 127         button = gtk_button_new_with_label ("Save");
 128         g_signal_connect (button, "clicked", G_CALLBACK (node_state_save), tv);
 129         gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
 130
 131         button = gtk_button_new_with_label ("Restore");
 132         g_signal_connect (button, "clicked", G_CALLBACK (node_state_restore),
 133                           tv);
 134         gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
 135
 136         /* fill the model */
 137         for (i = 0; i < 6; i++) {
 138                 GtkTreeIter iter;
 139                 gchar text[16];
 140                 gint j;
 141
 142                 sprintf (text, "%d", i);
 143
 144                 gtk_tree_store_append (store, &iter, NULL);
 145                 gtk_tree_store_set (store, &iter, 0, text, -1);
 146
 147                 for (j = 0; j < 3; j++) {
 148                         gint k;
 149                         GtkTreeIter iter2;
 150
 151                         sprintf (text, "%d:%d", i, j);
 152
 153                         gtk_tree_store_append (store, &iter2, &iter);
 154                         gtk_tree_store_set (store, &iter2, 0, text, -1);
 155
 156                         for (k = 0; k < 2; k++) {
 157                                 GtkTreeIter iter3;
 158
 159                                 sprintf (text, "%d:%d:%d", i, j, k);
 160
 161                                 gtk_tree_store_append (store, &iter3, &iter2);
 162                                 gtk_tree_store_set (store, &iter3,
 163                                                     0, text, -1);
 164                         }
 165                 }
 166         }
 167
 168         /* done */
 169
 170         return window;
 171 }
 172
 173 #endif
 174
 175
 176 static void
 177 accel_edited_callback (GtkCellRendererText *cell,
 178                        const char          *path_string,
 179                        guint                keyval,
 180                        GdkModifierType      mask,
 181                        guint                hardware_keycode,
 182                        gpointer             data)
 183 {
 184   GtkTreeModel *model = (GtkTreeModel *)data;
 185   GtkTreePath *path = gtk_tree_path_new_from_string (path_string);
 186   GtkTreeIter iter;
 187
 188   gtk_tree_model_get_iter (model, &iter, path);
 189
 190   g_print ("%u %d %u\n", keyval, mask, hardware_keycode);
 191
 192   gtk_list_store_set (GTK_LIST_STORE (model), &iter,
 193                       0, (gint)mask,
 194                       1, keyval,
 195                       -1);
 196   gtk_tree_path_free (path);
 197 }
 198
 199 static GtkWidget *
 200 key_test (void)
 201 {
 202         GtkWidget *window, *sw, *tv;
 203         GtkListStore *store;
 204         GtkTreeViewColumn *column;
 205         GtkCellRenderer *rend;
 206         gint i;
 207
 208         /* create window */
 209         window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 210
 211
 212         sw = gtk_scrolled_window_new (NULL, NULL);
 213         gtk_container_add (GTK_CONTAINER (window), sw);
 214
 215         store = gtk_list_store_new (2, G_TYPE_INT, G_TYPE_UINT);
 216         tv = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
 217         gtk_container_add (GTK_CONTAINER (sw), tv);
 218         column = gtk_tree_view_column_new ();
 219         rend = egg_cell_renderer_keys_new ();
 220         g_object_set (G_OBJECT (rend), "accel_mode", EGG_CELL_RENDERER_KEYS_MODE_X, NULL);
 221         g_signal_connect (G_OBJECT (rend),
 222                           "keys_edited",
 223                           G_CALLBACK (accel_edited_callback),
 224                           store);
 225
 226         g_object_set (G_OBJECT (rend), "editable", TRUE, NULL);
 227         gtk_tree_view_column_pack_start (column, rend,
 228                                          TRUE);
 229         gtk_tree_view_column_set_attributes (column, rend,
 230                                              "accel_mask", 0,
 231                                              "accel_key", 1,
 232                                              NULL);
 233         gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column);
 234
 235         for (i = 0; i < 10; i++) {
 236                 GtkTreeIter iter;
 237
 238                 gtk_list_store_append (store, &iter);
 239         }
 240
 241         /* done */
 242
 243         return window;
 244 }
 245
 246 struct
 247 {
 248   char *name;
 249   CreateWindowFunc create_func;
 250 } entries[] =
 251 {
 252   { "EggCellRendererKeys", key_test },
 253 #if 0
 254   { "EggNodeState", node_state_test },
 255 #endif
 256   { "Progress Bar Cell", progress_bar_test },
 257   { "Tree View State", state_test },
 258 };
 259
 260
 261 static void
 262 row_activated (GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *column)
 263 {
 264   GtkTreeIter iter;
 265   GtkTreeModel *model;
 266   CreateWindowFunc func;
 267   GtkWidget *window;
 268   char *str;
 269
 270   model = gtk_tree_view_get_model (tree_view);
 271
 272   gtk_tree_model_get_iter (model, &iter, path);
 273
 274   gtk_tree_model_get (model, &iter,
 275                       0, &str,
 276                       1, &func,
 277                       -1);
 278
 279
 280   window = (*func) ();
 281   gtk_window_set_title (GTK_WINDOW (window), str);
 282   gtk_window_set_default_size (GTK_WINDOW (window), 400, 300);
 283   g_free (str);
 284
 285   g_signal_connect (window, "delete_event",
 286                     G_CALLBACK (gtk_widget_destroy), NULL);
 287   gtk_widget_show_all (window);
 288 }
 289
 290 gint
 291 main (gint argc, gchar **argv)
 292 {
 293   GtkWidget *dialog, *sw, *tree_view;
 294   GtkListStore *model;
 295   int i;
 296   GtkTreeIter iter;
 297
 298   gtk_init (&argc, &argv);
 299
 300   dialog = gtk_dialog_new_with_buttons ("Egg test",
 301                                         NULL,
 302                                         0,
 303                                         GTK_STOCK_CLOSE, GTK_RESPONSE_OK,
 304                                         NULL);
 305   gtk_window_set_default_size (GTK_WINDOW (dialog), 200, 200);
 306   g_signal_connect (dialog, "response",
 307                     G_CALLBACK (gtk_main_quit), NULL);
 308   sw = gtk_scrolled_window_new (NULL, NULL);
 309   gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN);
 310   gtk_container_set_border_width (GTK_CONTAINER (sw), 8);
 311   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
 312                                   GTK_POLICY_AUTOMATIC,
 313                                   GTK_POLICY_AUTOMATIC);
 314   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), sw, TRUE, TRUE, 0);
 315
 316   model = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER);
 317
 318   for (i = 0; i < G_N_ELEMENTS (entries); i++)
 319     {
 320       gtk_list_store_append (model,
 321                              &iter);
 322       gtk_list_store_set (model,
 323                           &iter,
 324                           0, entries[i].name,
 325                           1, entries[i].create_func,
 326                           -1);
 327     }
 328
 329   tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
 330   g_signal_connect (tree_view, "row_activated",
 331                     G_CALLBACK (row_activated), NULL);
 332   gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), -1,
 333                                                "Tests", gtk_cell_renderer_text_new (),
 334                                                "text", 0,
 335                                                NULL);
 336   gtk_container_add (GTK_CONTAINER (sw), tree_view);
 337
 338   gtk_widget_show_all (dialog);
 339
 340   gtk_main ();
 341
 342   return 0;
 343 }