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

   1 /* testiconview.c
   2  * Copyright (C) 2002  Anders Carlsson <andersca@gnu.org>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library 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  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library. If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include <gtk/gtk.h>
  19 #include <sys/types.h>
  20 #include <string.h>
  21 #include "prop-editor.h"
  22
  23 #define NUMBER_OF_ITEMS   10
  24 #define SOME_ITEMS       100
  25 #define MANY_ITEMS     10000
  26
  27 static void
  28 fill_model (GtkTreeModel *model)
  29 {
  30   GdkPixbuf *pixbuf;
  31   int i;
  32   char *str, *str2;
  33   GtkTreeIter iter;
  34   GtkListStore *store = GTK_LIST_STORE (model);
  35   gint32 size;
  36
  37   pixbuf = gdk_pixbuf_new_from_file ("gnome-textfile.png", NULL);
  38
  39   i = 0;
  40
  41   gtk_list_store_prepend (store, &iter);
  42
  43   gtk_list_store_set (store, &iter,
  44                       0, pixbuf,
  45                       1, "Really really\nreally really loooooooooong item name",
  46                       2, 0,
  47                       3, "This is a <b>Test</b> of <i>markup</i>",
  48                       4, TRUE,
  49                       -1);
  50
  51   while (i < NUMBER_OF_ITEMS - 1)
  52     {
  53       GdkPixbuf *pb;
  54       size = g_random_int_range (20, 70);
  55       pb = gdk_pixbuf_scale_simple (pixbuf, size, size, GDK_INTERP_NEAREST);
  56
  57       str = g_strdup_printf ("Icon %d", i);
  58       str2 = g_strdup_printf ("Icon <b>%d</b>", i);
  59       gtk_list_store_prepend (store, &iter);
  60       gtk_list_store_set (store, &iter,
  61                           0, pb,
  62                           1, str,
  63                           2, i,
  64                           3, str2,
  65                           4, TRUE,
  66                           -1);
  67       g_free (str);
  68       g_free (str2);
  69       i++;
  70     }
  71
  72   //  gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store), 2, GTK_SORT_ASCENDING);
  73 }
  74
  75 static GtkTreeModel *
  76 create_model (void)
  77 {
  78   GtkListStore *store;
  79
  80   store = gtk_list_store_new (5, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING, G_TYPE_BOOLEAN);
  81
  82   return GTK_TREE_MODEL (store);
  83 }
  84
  85
  86 static void
  87 foreach_selected_remove (GtkWidget *button, GtkIconView *icon_list)
  88 {
  89   GtkTreeIter iter;
  90   GtkTreeModel *model;
  91
  92   GList *list, *selected;
  93
  94   selected = gtk_icon_view_get_selected_items (icon_list);
  95   model = gtk_icon_view_get_model (icon_list);
  96
  97   for (list = selected; list; list = list->next)
  98     {
  99       GtkTreePath *path = list->data;
 100
 101       gtk_tree_model_get_iter (model, &iter, path);
 102       gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
 103
 104       gtk_tree_path_free (path);
 105     }
 106
 107   g_list_free (selected);
 108 }
 109
 110
 111 static void
 112 swap_rows (GtkWidget *button, GtkIconView *icon_list)
 113 {
 114   GtkTreeIter iter, iter2;
 115   GtkTreeModel *model;
 116
 117   model = gtk_icon_view_get_model (icon_list);
 118   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model), -2, GTK_SORT_ASCENDING);
 119
 120   gtk_tree_model_get_iter_first (model, &iter);
 121   iter2 = iter;
 122   gtk_tree_model_iter_next (model, &iter2);
 123   gtk_list_store_swap (GTK_LIST_STORE (model), &iter, &iter2);
 124 }
 125
 126 static void
 127 add_n_items (GtkIconView *icon_list, gint n)
 128 {
 129   static gint count = NUMBER_OF_ITEMS;
 130
 131   GtkTreeIter iter;
 132   GtkListStore *store;
 133   GdkPixbuf *pixbuf;
 134   gchar *str, *str2;
 135   gint i;
 136
 137   store = GTK_LIST_STORE (gtk_icon_view_get_model (icon_list));
 138   pixbuf = gdk_pixbuf_new_from_file ("gnome-textfile.png", NULL);
 139
 140
 141   for (i = 0; i < n; i++)
 142     {
 143       str = g_strdup_printf ("Icon %d", count);
 144       str2 = g_strdup_printf ("Icon <b>%d</b>", count);
 145       gtk_list_store_prepend (store, &iter);
 146       gtk_list_store_set (store, &iter,
 147                           0, pixbuf,
 148                           1, str,
 149                           2, i,
 150                           3, str2,
 151                           -1);
 152       g_free (str);
 153       g_free (str2);
 154       count++;
 155     }
 156 }
 157
 158 static void
 159 add_some (GtkWidget *button, GtkIconView *icon_list)
 160 {
 161   add_n_items (icon_list, SOME_ITEMS);
 162 }
 163
 164 static void
 165 add_many (GtkWidget *button, GtkIconView *icon_list)
 166 {
 167   add_n_items (icon_list, MANY_ITEMS);
 168 }
 169
 170 static void
 171 add_large (GtkWidget *button, GtkIconView *icon_list)
 172 {
 173   GtkListStore *store;
 174   GtkTreeIter iter;
 175
 176   GdkPixbuf *pixbuf, *pb;
 177   gchar *str;
 178
 179   store = GTK_LIST_STORE (gtk_icon_view_get_model (icon_list));
 180   pixbuf = gdk_pixbuf_new_from_file ("gnome-textfile.png", NULL);
 181
 182   pb = gdk_pixbuf_scale_simple (pixbuf,
 183                                 2 * gdk_pixbuf_get_width (pixbuf),
 184                                 2 * gdk_pixbuf_get_height (pixbuf),
 185                                 GDK_INTERP_BILINEAR);
 186
 187   str = g_strdup_printf ("Some really long text");
 188   gtk_list_store_append (store, &iter);
 189   gtk_list_store_set (store, &iter,
 190                       0, pb,
 191                       1, str,
 192                       2, 0,
 193                       3, str,
 194                       -1);
 195   g_object_unref (pb);
 196   g_free (str);
 197
 198   pb = gdk_pixbuf_scale_simple (pixbuf,
 199                                 3 * gdk_pixbuf_get_width (pixbuf),
 200                                 3 * gdk_pixbuf_get_height (pixbuf),
 201                                 GDK_INTERP_BILINEAR);
 202
 203   str = g_strdup ("see how long text behaves when placed underneath "
 204                   "an oversized icon which would allow for long lines");
 205   gtk_list_store_append (store, &iter);
 206   gtk_list_store_set (store, &iter,
 207                       0, pb,
 208                       1, str,
 209                       2, 1,
 210                       3, str,
 211                       -1);
 212   g_object_unref (pb);
 213   g_free (str);
 214
 215   pb = gdk_pixbuf_scale_simple (pixbuf,
 216                                 3 * gdk_pixbuf_get_width (pixbuf),
 217                                 3 * gdk_pixbuf_get_height (pixbuf),
 218                                 GDK_INTERP_BILINEAR);
 219
 220   str = g_strdup ("short text");
 221   gtk_list_store_append (store, &iter);
 222   gtk_list_store_set (store, &iter,
 223                       0, pb,
 224                       1, str,
 225                       2, 2,
 226                       3, str,
 227                       -1);
 228   g_object_unref (pb);
 229   g_free (str);
 230
 231   g_object_unref (pixbuf);
 232 }
 233
 234 static void
 235 select_all (GtkWidget *button, GtkIconView *icon_list)
 236 {
 237   gtk_icon_view_select_all (icon_list);
 238 }
 239
 240 static void
 241 select_nonexisting (GtkWidget *button, GtkIconView *icon_list)
 242 {
 243   GtkTreePath *path = gtk_tree_path_new_from_indices (999999, -1);
 244   gtk_icon_view_select_path (icon_list, path);
 245   gtk_tree_path_free (path);
 246 }
 247
 248 static void
 249 unselect_all (GtkWidget *button, GtkIconView *icon_list)
 250 {
 251   gtk_icon_view_unselect_all (icon_list);
 252 }
 253
 254 static void
 255 selection_changed (GtkIconView *icon_list)
 256 {
 257   g_print ("Selection changed!\n");
 258 }
 259
 260 typedef struct {
 261   GtkIconView     *icon_list;
 262   GtkTreePath     *path;
 263 } ItemData;
 264
 265 static void
 266 free_item_data (ItemData *data)
 267 {
 268   gtk_tree_path_free (data->path);
 269   g_free (data);
 270 }
 271
 272 static void
 273 item_activated (GtkIconView *icon_view,
 274                 GtkTreePath *path)
 275 {
 276   GtkTreeIter iter;
 277   GtkTreeModel *model;
 278   gchar *text;
 279
 280   model = gtk_icon_view_get_model (icon_view);
 281   gtk_tree_model_get_iter (model, &iter, path);
 282
 283   gtk_tree_model_get (model, &iter, 1, &text, -1);
 284   g_print ("Item activated, text is %s\n", text);
 285   g_free (text);
 286
 287 }
 288
 289 static void
 290 toggled (GtkCellRendererToggle *cell,
 291          gchar                 *path_string,
 292          gpointer               data)
 293 {
 294   GtkTreeModel *model = GTK_TREE_MODEL (data);
 295   GtkTreeIter iter;
 296   GtkTreePath *path = gtk_tree_path_new_from_string (path_string);
 297   gboolean value;
 298
 299   gtk_tree_model_get_iter (model, &iter, path);
 300   gtk_tree_model_get (model, &iter, 4, &value, -1);
 301
 302   value = !value;
 303   gtk_list_store_set (GTK_LIST_STORE (model), &iter, 4, value, -1);
 304
 305   gtk_tree_path_free (path);
 306 }
 307
 308 static void
 309 edited (GtkCellRendererText *cell,
 310         gchar               *path_string,
 311         gchar               *new_text,
 312         gpointer             data)
 313 {
 314   GtkTreeModel *model = GTK_TREE_MODEL (data);
 315   GtkTreeIter iter;
 316   GtkTreePath *path = gtk_tree_path_new_from_string (path_string);
 317
 318   gtk_tree_model_get_iter (model, &iter, path);
 319   gtk_list_store_set (GTK_LIST_STORE (model), &iter, 1, new_text, -1);
 320
 321   gtk_tree_path_free (path);
 322 }
 323
 324 static void
 325 item_cb (GtkWidget *menuitem,
 326          ItemData  *data)
 327 {
 328   item_activated (data->icon_list, data->path);
 329 }
 330
 331 static void
 332 do_popup_menu (GtkWidget      *icon_list,
 333                GdkEventButton *event)
 334 {
 335   GtkIconView *icon_view = GTK_ICON_VIEW (icon_list);
 336   GtkWidget *menu;
 337   GtkWidget *menuitem;
 338   GtkTreePath *path = NULL;
 339   int button, event_time;
 340   ItemData *data;
 341   GList *list;
 342
 343   if (event)
 344     path = gtk_icon_view_get_path_at_pos (icon_view, event->x, event->y);
 345   else
 346     {
 347       list = gtk_icon_view_get_selected_items (icon_view);
 348
 349       if (list)
 350         {
 351           path = (GtkTreePath*)list->data;
 352           g_list_free_full (list, (GDestroyNotify) gtk_tree_path_free);
 353         }
 354     }
 355
 356   if (!path)
 357     return;
 358
 359   menu = gtk_menu_new ();
 360
 361   data = g_new0 (ItemData, 1);
 362   data->icon_list = icon_view;
 363   data->path = path;
 364   g_object_set_data_full (G_OBJECT (menu), "item-path", data, (GDestroyNotify)free_item_data);
 365
 366   menuitem = gtk_menu_item_new_with_label ("Activate");
 367   gtk_widget_show (menuitem);
 368   gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
 369   g_signal_connect (menuitem, "activate", G_CALLBACK (item_cb), data);
 370
 371   if (event)
 372     {
 373       button = event->button;
 374       event_time = event->time;
 375     }
 376   else
 377     {
 378       button = 0;
 379       event_time = gtk_get_current_event_time ();
 380     }
 381
 382   gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
 383                   button, event_time);
 384 }
 385
 386
 387 static gboolean
 388 button_press_event_handler (GtkWidget      *widget,
 389                             GdkEventButton *event)
 390 {
 391   /* Ignore double-clicks and triple-clicks */
 392   if (gdk_event_triggers_context_menu ((GdkEvent *) event) &&
 393       event->type == GDK_BUTTON_PRESS)
 394     {
 395       do_popup_menu (widget, event);
 396       return TRUE;
 397     }
 398
 399   return FALSE;
 400 }
 401
 402 static gboolean
 403 popup_menu_handler (GtkWidget *widget)
 404 {
 405   do_popup_menu (widget, NULL);
 406   return TRUE;
 407 }
 408
 409 static const GtkTargetEntry item_targets[] = {
 410   { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_APP, 0 }
 411 };
 412
 413 gint
 414 main (gint argc, gchar **argv)
 415 {
 416   GtkWidget *paned, *tv;
 417   GtkWidget *window, *icon_list, *scrolled_window;
 418   GtkWidget *vbox, *bbox;
 419   GtkWidget *button;
 420   GtkWidget *prop_editor;
 421   GtkTreeModel *model;
 422   GtkCellRenderer *cell;
 423   GtkTreeViewColumn *tvc;
 424
 425   gtk_init (&argc, &argv);
 426
 427   /* to test rtl layout, set RTL=1 in the environment */
 428   if (g_getenv ("RTL"))
 429     gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL);
 430
 431   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 432   gtk_window_set_default_size (GTK_WINDOW (window), 700, 400);
 433
 434   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
 435   gtk_container_add (GTK_CONTAINER (window), vbox);
 436
 437   paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
 438   gtk_box_pack_start (GTK_BOX (vbox), paned, TRUE, TRUE, 0);
 439
 440   icon_list = gtk_icon_view_new ();
 441   gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (icon_list), GTK_SELECTION_MULTIPLE);
 442
 443   tv = gtk_tree_view_new ();
 444   tvc = gtk_tree_view_column_new ();
 445   gtk_tree_view_append_column (GTK_TREE_VIEW (tv), tvc);
 446
 447   g_signal_connect_after (icon_list, "button_press_event",
 448                           G_CALLBACK (button_press_event_handler), NULL);
 449   g_signal_connect (icon_list, "selection_changed",
 450                     G_CALLBACK (selection_changed), NULL);
 451   g_signal_connect (icon_list, "popup_menu",
 452                     G_CALLBACK (popup_menu_handler), NULL);
 453
 454   g_signal_connect (icon_list, "item_activated",
 455                     G_CALLBACK (item_activated), NULL);
 456
 457   model = create_model ();
 458   gtk_icon_view_set_model (GTK_ICON_VIEW (icon_list), model);
 459   gtk_tree_view_set_model (GTK_TREE_VIEW (tv), model);
 460   fill_model (model);
 461
 462 #if 0
 463
 464   gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW (icon_list), 0);
 465   gtk_icon_view_set_text_column (GTK_ICON_VIEW (icon_list), 1);
 466
 467 #else
 468
 469   cell = gtk_cell_renderer_toggle_new ();
 470   gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (icon_list), cell, FALSE);
 471   g_object_set (cell, "activatable", TRUE, NULL);
 472   gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (icon_list),
 473                                   cell, "active", 4, NULL);
 474   g_signal_connect (cell, "toggled", G_CALLBACK (toggled), model);
 475
 476   cell = gtk_cell_renderer_pixbuf_new ();
 477   gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (icon_list), cell, FALSE);
 478   g_object_set (cell,
 479                 "follow-state", TRUE,
 480                 NULL);
 481   gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (icon_list),
 482                                   cell, "pixbuf", 0, NULL);
 483
 484   cell = gtk_cell_renderer_text_new ();
 485   gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (icon_list), cell, FALSE);
 486   g_object_set (cell,
 487                 "editable", TRUE,
 488                 "xalign", 0.5,
 489                 "wrap-mode", PANGO_WRAP_WORD_CHAR,
 490                 "wrap-width", 100,
 491                 NULL);
 492   gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (icon_list),
 493                                   cell, "text", 1, NULL);
 494   g_signal_connect (cell, "edited", G_CALLBACK (edited), model);
 495
 496   /* now the tree view... */
 497   cell = gtk_cell_renderer_toggle_new ();
 498   gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (tvc), cell, FALSE);
 499   g_object_set (cell, "activatable", TRUE, NULL);
 500   gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (tvc),
 501                                   cell, "active", 4, NULL);
 502   g_signal_connect (cell, "toggled", G_CALLBACK (toggled), model);
 503
 504   cell = gtk_cell_renderer_pixbuf_new ();
 505   gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (tvc), cell, FALSE);
 506   g_object_set (cell,
 507                 "follow-state", TRUE,
 508                 NULL);
 509   gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (tvc),
 510                                   cell, "pixbuf", 0, NULL);
 511
 512   cell = gtk_cell_renderer_text_new ();
 513   gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (tvc), cell, FALSE);
 514   g_object_set (cell, "editable", TRUE, NULL);
 515   gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (tvc),
 516                                   cell, "text", 1, NULL);
 517   g_signal_connect (cell, "edited", G_CALLBACK (edited), model);
 518 #endif
 519   /* Allow DND between the icon view and the tree view */
 520
 521   gtk_icon_view_enable_model_drag_source (GTK_ICON_VIEW (icon_list),
 522                                           GDK_BUTTON1_MASK,
 523                                           item_targets,
 524                                           G_N_ELEMENTS (item_targets),
 525                                           GDK_ACTION_MOVE);
 526   gtk_icon_view_enable_model_drag_dest (GTK_ICON_VIEW (icon_list),
 527                                         item_targets,
 528                                         G_N_ELEMENTS (item_targets),
 529                                         GDK_ACTION_MOVE);
 530
 531   gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (tv),
 532                                           GDK_BUTTON1_MASK,
 533                                           item_targets,
 534                                           G_N_ELEMENTS (item_targets),
 535                                           GDK_ACTION_MOVE);
 536   gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (tv),
 537                                         item_targets,
 538                                         G_N_ELEMENTS (item_targets),
 539                                         GDK_ACTION_MOVE);
 540
 541
 542   prop_editor = create_prop_editor (G_OBJECT (icon_list), 0);
 543   gtk_widget_show_all (prop_editor);
 544
 545   scrolled_window = gtk_scrolled_window_new (NULL, NULL);
 546   gtk_container_add (GTK_CONTAINER (scrolled_window), icon_list);
 547   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
 548                                   GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 549
 550   gtk_paned_add1 (GTK_PANED (paned), scrolled_window);
 551
 552   scrolled_window = gtk_scrolled_window_new (NULL, NULL);
 553   gtk_container_add (GTK_CONTAINER (scrolled_window), tv);
 554   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
 555                                   GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 556
 557   gtk_paned_add2 (GTK_PANED (paned), scrolled_window);
 558
 559   bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
 560   gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_START);
 561   gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, FALSE, 0);
 562
 563   button = gtk_button_new_with_label ("Add some");
 564   g_signal_connect (button, "clicked", G_CALLBACK (add_some), icon_list);
 565   gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
 566
 567   button = gtk_button_new_with_label ("Add many");
 568   g_signal_connect (button, "clicked", G_CALLBACK (add_many), icon_list);
 569   gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
 570
 571   button = gtk_button_new_with_label ("Add large");
 572   g_signal_connect (button, "clicked", G_CALLBACK (add_large), icon_list);
 573   gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
 574
 575   button = gtk_button_new_with_label ("Remove selected");
 576   g_signal_connect (button, "clicked", G_CALLBACK (foreach_selected_remove), icon_list);
 577   gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
 578
 579   button = gtk_button_new_with_label ("Swap");
 580   g_signal_connect (button, "clicked", G_CALLBACK (swap_rows), icon_list);
 581   gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
 582
 583   bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
 584   gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_START);
 585   gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, FALSE, 0);
 586
 587   button = gtk_button_new_with_label ("Select all");
 588   g_signal_connect (button, "clicked", G_CALLBACK (select_all), icon_list);
 589   gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
 590
 591   button = gtk_button_new_with_label ("Unselect all");
 592   g_signal_connect (button, "clicked", G_CALLBACK (unselect_all), icon_list);
 593   gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
 594
 595   button = gtk_button_new_with_label ("Select nonexisting");
 596   g_signal_connect (button, "clicked", G_CALLBACK (select_nonexisting), icon_list);
 597   gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
 598
 599   icon_list = gtk_icon_view_new ();
 600
 601   scrolled_window = gtk_scrolled_window_new (NULL, NULL);
 602   gtk_container_add (GTK_CONTAINER (scrolled_window), icon_list);
 603   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
 604                                   GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 605   gtk_paned_add2 (GTK_PANED (paned), scrolled_window);
 606
 607   gtk_widget_show_all (window);
 608
 609   gtk_main ();
 610
 611   return 0;
 612 }