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

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   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, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19 #undef  G_LOG_DOMAIN
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <math.h>
  25 #include <time.h>
  26 #include "gtk.h"
  27 #include "../gdk/gdk.h"
  28 #include "../gdk/gdkx.h"
  29 #include "../gdk/gdkkeysyms.h"
  30
  31 #include "circles.xbm"
  32
  33 typedef struct _OptionMenuItem
  34 {
  35   gchar        *name;
  36   GtkSignalFunc func;
  37 } OptionMenuItem;
  38
  39 GtkWidget *
  40 shape_create_icon (char     *xpm_file,
  41                    gint      x,
  42                    gint      y,
  43                    gint      px,
  44                    gint      py,
  45                    gint      window_type);
  46
  47 static GtkWidget *
  48 build_option_menu (OptionMenuItem items[],
  49                    gint           num_items,
  50                    gint           history,
  51                    gpointer       data);
  52
  53 /* macro, structure and variables used by tree window demos */
  54 #define DEFAULT_NUMBER_OF_ITEM  3
  55 #define DEFAULT_RECURSION_LEVEL 3
  56
  57 struct {
  58   GSList* selection_mode_group;
  59   GtkWidget* single_button;
  60   GtkWidget* browse_button;
  61   GtkWidget* multiple_button;
  62   GtkWidget* draw_line_button;
  63   GtkWidget* view_line_button;
  64   GtkWidget* no_root_item_button;
  65   GtkWidget* nb_item_spinner;
  66   GtkWidget* recursion_spinner;
  67 } sTreeSampleSelection;
  68
  69 typedef struct sTreeButtons {
  70   guint nb_item_add;
  71   GtkWidget* add_button;
  72   GtkWidget* remove_button;
  73   GtkWidget* subtree_button;
  74 } sTreeButtons;
  75 /* end of tree section */
  76
  77 static GtkWidget *
  78 build_option_menu (OptionMenuItem items[],
  79                    gint           num_items,
  80                    gint           history,
  81                    gpointer       data)
  82 {
  83   GtkWidget *omenu;
  84   GtkWidget *menu;
  85   GtkWidget *menu_item;
  86   GSList *group;
  87   gint i;
  88
  89   omenu = gtk_option_menu_new ();
  90
  91   menu = gtk_menu_new ();
  92   group = NULL;
  93
  94   for (i = 0; i < num_items; i++)
  95     {
  96       menu_item = gtk_radio_menu_item_new_with_label (group, items[i].name);
  97       gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
  98                           (GtkSignalFunc) items[i].func, data);
  99       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
 100       gtk_menu_append (GTK_MENU (menu), menu_item);
 101       if (i == history)
 102         gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
 103       gtk_widget_show (menu_item);
 104     }
 105
 106   gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
 107   gtk_option_menu_set_history (GTK_OPTION_MENU (omenu), history);
 108
 109   return omenu;
 110 }
 111
 112 static void
 113 destroy_tooltips (GtkWidget *widget, GtkWindow **window)
 114 {
 115   GtkTooltips *tt = gtk_object_get_data (GTK_OBJECT (*window), "tooltips");
 116   gtk_object_unref (GTK_OBJECT (tt));
 117   *window = NULL;
 118 }
 119
 120 /*
 121  * GtkButton
 122  */
 123
 124 static void
 125 button_window (GtkWidget *widget,
 126                GtkWidget *button)
 127 {
 128   if (!GTK_WIDGET_VISIBLE (button))
 129     gtk_widget_show (button);
 130   else
 131     gtk_widget_hide (button);
 132 }
 133
 134 static void
 135 create_buttons (void)
 136 {
 137   static GtkWidget *window = NULL;
 138   GtkWidget *box1;
 139   GtkWidget *box2;
 140   GtkWidget *table;
 141   GtkWidget *button[10];
 142   GtkWidget *separator;
 143
 144   if (!window)
 145     {
 146       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 147
 148       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 149                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
 150                           &window);
 151
 152       gtk_window_set_title (GTK_WINDOW (window), "GtkButton");
 153       gtk_container_border_width (GTK_CONTAINER (window), 0);
 154
 155       box1 = gtk_vbox_new (FALSE, 0);
 156       gtk_container_add (GTK_CONTAINER (window), box1);
 157
 158       table = gtk_table_new (3, 3, FALSE);
 159       gtk_table_set_row_spacings (GTK_TABLE (table), 5);
 160       gtk_table_set_col_spacings (GTK_TABLE (table), 5);
 161       gtk_container_border_width (GTK_CONTAINER (table), 10);
 162       gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
 163
 164       button[0] = gtk_button_new_with_label ("button1");
 165       button[1] = gtk_button_new_with_label ("button2");
 166       button[2] = gtk_button_new_with_label ("button3");
 167       button[3] = gtk_button_new_with_label ("button4");
 168       button[4] = gtk_button_new_with_label ("button5");
 169       button[5] = gtk_button_new_with_label ("button6");
 170       button[6] = gtk_button_new_with_label ("button7");
 171       button[7] = gtk_button_new_with_label ("button8");
 172       button[8] = gtk_button_new_with_label ("button9");
 173
 174       gtk_signal_connect (GTK_OBJECT (button[0]), "clicked",
 175                           GTK_SIGNAL_FUNC(button_window),
 176                           button[1]);
 177
 178       gtk_table_attach (GTK_TABLE (table), button[0], 0, 1, 0, 1,
 179                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 180
 181       gtk_signal_connect (GTK_OBJECT (button[1]), "clicked",
 182                           GTK_SIGNAL_FUNC(button_window),
 183                           button[2]);
 184
 185       gtk_table_attach (GTK_TABLE (table), button[1], 1, 2, 1, 2,
 186                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 187
 188       gtk_signal_connect (GTK_OBJECT (button[2]), "clicked",
 189                           GTK_SIGNAL_FUNC(button_window),
 190                           button[3]);
 191       gtk_table_attach (GTK_TABLE (table), button[2], 2, 3, 2, 3,
 192                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 193
 194       gtk_signal_connect (GTK_OBJECT (button[3]), "clicked",
 195                           GTK_SIGNAL_FUNC(button_window),
 196                           button[4]);
 197       gtk_table_attach (GTK_TABLE (table), button[3], 0, 1, 2, 3,
 198                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 199
 200       gtk_signal_connect (GTK_OBJECT (button[4]), "clicked",
 201                           GTK_SIGNAL_FUNC(button_window),
 202                           button[5]);
 203       gtk_table_attach (GTK_TABLE (table), button[4], 2, 3, 0, 1,
 204                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 205
 206       gtk_signal_connect (GTK_OBJECT (button[5]), "clicked",
 207                           GTK_SIGNAL_FUNC(button_window),
 208                           button[6]);
 209       gtk_table_attach (GTK_TABLE (table), button[5], 1, 2, 2, 3,
 210                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 211
 212       gtk_signal_connect (GTK_OBJECT (button[6]), "clicked",
 213                           GTK_SIGNAL_FUNC(button_window),
 214                           button[7]);
 215       gtk_table_attach (GTK_TABLE (table), button[6], 1, 2, 0, 1,
 216                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 217
 218       gtk_signal_connect (GTK_OBJECT (button[7]), "clicked",
 219                           GTK_SIGNAL_FUNC(button_window),
 220                           button[8]);
 221       gtk_table_attach (GTK_TABLE (table), button[7], 2, 3, 1, 2,
 222                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 223
 224       gtk_signal_connect (GTK_OBJECT (button[8]), "clicked",
 225                           GTK_SIGNAL_FUNC(button_window),
 226                           button[0]);
 227       gtk_table_attach (GTK_TABLE (table), button[8], 0, 1, 1, 2,
 228                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 229
 230       separator = gtk_hseparator_new ();
 231       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 232
 233       box2 = gtk_vbox_new (FALSE, 10);
 234       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 235       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 236
 237       button[9] = gtk_button_new_with_label ("close");
 238       gtk_signal_connect_object (GTK_OBJECT (button[9]), "clicked",
 239                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
 240                                  GTK_OBJECT (window));
 241       gtk_box_pack_start (GTK_BOX (box2), button[9], TRUE, TRUE, 0);
 242       GTK_WIDGET_SET_FLAGS (button[9], GTK_CAN_DEFAULT);
 243       gtk_widget_grab_default (button[9]);
 244     }
 245
 246   if (!GTK_WIDGET_VISIBLE (window))
 247     gtk_widget_show_all (window);
 248   else
 249     gtk_widget_destroy (window);
 250 }
 251
 252 /*
 253  * GtkToggleButton
 254  */
 255
 256 static void
 257 create_toggle_buttons (void)
 258 {
 259   static GtkWidget *window = NULL;
 260   GtkWidget *box1;
 261   GtkWidget *box2;
 262   GtkWidget *button;
 263   GtkWidget *separator;
 264
 265   if (!window)
 266     {
 267       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 268
 269       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 270                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
 271                           &window);
 272
 273       gtk_window_set_title (GTK_WINDOW (window), "GtkToggleButton");
 274       gtk_container_border_width (GTK_CONTAINER (window), 0);
 275
 276       box1 = gtk_vbox_new (FALSE, 0);
 277       gtk_container_add (GTK_CONTAINER (window), box1);
 278
 279       box2 = gtk_vbox_new (FALSE, 10);
 280       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 281       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
 282
 283       button = gtk_toggle_button_new_with_label ("button1");
 284       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 285
 286       button = gtk_toggle_button_new_with_label ("button2");
 287       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 288
 289       button = gtk_toggle_button_new_with_label ("button3");
 290       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 291
 292       separator = gtk_hseparator_new ();
 293       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 294
 295       box2 = gtk_vbox_new (FALSE, 10);
 296       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 297       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 298
 299       button = gtk_button_new_with_label ("close");
 300       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
 301                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
 302                                  GTK_OBJECT (window));
 303       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 304       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 305       gtk_widget_grab_default (button);
 306     }
 307
 308   if (!GTK_WIDGET_VISIBLE (window))
 309     gtk_widget_show_all (window);
 310   else
 311     gtk_widget_destroy (window);
 312 }
 313
 314 /*
 315  * GtkCheckButton
 316  */
 317
 318 static void
 319 create_check_buttons (void)
 320 {
 321   static GtkWidget *window = NULL;
 322   GtkWidget *box1;
 323   GtkWidget *box2;
 324   GtkWidget *button;
 325   GtkWidget *separator;
 326
 327   if (!window)
 328     {
 329       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 330
 331       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 332                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
 333                           &window);
 334
 335       gtk_window_set_title (GTK_WINDOW (window), "GtkCheckButton");
 336       gtk_container_border_width (GTK_CONTAINER (window), 0);
 337
 338       box1 = gtk_vbox_new (FALSE, 0);
 339       gtk_container_add (GTK_CONTAINER (window), box1);
 340
 341       box2 = gtk_vbox_new (FALSE, 10);
 342       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 343       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
 344
 345       button = gtk_check_button_new_with_label ("button1");
 346       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 347
 348       button = gtk_check_button_new_with_label ("button2");
 349       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 350
 351       button = gtk_check_button_new_with_label ("button3");
 352       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 353
 354       separator = gtk_hseparator_new ();
 355       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 356
 357       box2 = gtk_vbox_new (FALSE, 10);
 358       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 359       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 360
 361       button = gtk_button_new_with_label ("close");
 362       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
 363                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
 364                                  GTK_OBJECT (window));
 365       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 366       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 367       gtk_widget_grab_default (button);
 368     }
 369
 370   if (!GTK_WIDGET_VISIBLE (window))
 371     gtk_widget_show_all (window);
 372   else
 373     gtk_widget_destroy (window);
 374 }
 375
 376 /*
 377  * GtkRadioButton
 378  */
 379
 380 static void
 381 create_radio_buttons (void)
 382 {
 383   static GtkWidget *window = NULL;
 384   GtkWidget *box1;
 385   GtkWidget *box2;
 386   GtkWidget *button;
 387   GtkWidget *separator;
 388
 389   if (!window)
 390     {
 391       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 392
 393       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 394                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
 395                           &window);
 396
 397       gtk_window_set_title (GTK_WINDOW (window), "radio buttons");
 398       gtk_container_border_width (GTK_CONTAINER (window), 0);
 399
 400       box1 = gtk_vbox_new (FALSE, 0);
 401       gtk_container_add (GTK_CONTAINER (window), box1);
 402
 403       box2 = gtk_vbox_new (FALSE, 10);
 404       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 405       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
 406
 407       button = gtk_radio_button_new_with_label (NULL, "button1");
 408       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 409
 410       button = gtk_radio_button_new_with_label (
 411                  gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
 412                  "button2");
 413       gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
 414       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 415
 416       button = gtk_radio_button_new_with_label (
 417                  gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
 418                  "button3");
 419       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 420
 421       separator = gtk_hseparator_new ();
 422       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 423
 424       box2 = gtk_vbox_new (FALSE, 10);
 425       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 426       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 427
 428       button = gtk_button_new_with_label ("close");
 429       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
 430                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
 431                                  GTK_OBJECT (window));
 432       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 433       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 434       gtk_widget_grab_default (button);
 435     }
 436
 437   if (!GTK_WIDGET_VISIBLE (window))
 438     gtk_widget_show_all (window);
 439   else
 440     gtk_widget_destroy (window);
 441 }
 442
 443 /*
 444  * GtkButtonBox
 445  */
 446
 447 static GtkWidget *
 448 create_bbox (gint  horizontal,
 449              char* title,
 450              gint  spacing,
 451              gint  child_w,
 452              gint  child_h,
 453              gint  layout)
 454 {
 455   GtkWidget *frame;
 456   GtkWidget *bbox;
 457   GtkWidget *button;
 458
 459   frame = gtk_frame_new (title);
 460
 461   if (horizontal)
 462     bbox = gtk_hbutton_box_new ();
 463   else
 464     bbox = gtk_vbutton_box_new ();
 465
 466   gtk_container_border_width (GTK_CONTAINER (bbox), 5);
 467   gtk_container_add (GTK_CONTAINER (frame), bbox);
 468
 469   gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), layout);
 470   gtk_button_box_set_spacing (GTK_BUTTON_BOX (bbox), spacing);
 471   gtk_button_box_set_child_size (GTK_BUTTON_BOX (bbox), child_w, child_h);
 472
 473   button = gtk_button_new_with_label ("OK");
 474   gtk_container_add (GTK_CONTAINER (bbox), button);
 475
 476   button = gtk_button_new_with_label ("Cancel");
 477   gtk_container_add (GTK_CONTAINER (bbox), button);
 478
 479   button = gtk_button_new_with_label ("Help");
 480   gtk_container_add (GTK_CONTAINER (bbox), button);
 481
 482   return frame;
 483 }
 484
 485 static void
 486 create_button_box (void)
 487 {
 488   static GtkWidget* window = NULL;
 489   GtkWidget *main_vbox;
 490   GtkWidget *vbox;
 491   GtkWidget *hbox;
 492   GtkWidget *frame_horz;
 493   GtkWidget *frame_vert;
 494
 495   if (!window)
 496   {
 497     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 498     gtk_window_set_title (GTK_WINDOW (window), "Button Boxes");
 499
 500     gtk_signal_connect (GTK_OBJECT (window), "destroy",
 501                         GTK_SIGNAL_FUNC(gtk_widget_destroyed),
 502                         &window);
 503
 504     gtk_container_border_width (GTK_CONTAINER (window), 10);
 505
 506     main_vbox = gtk_vbox_new (FALSE, 0);
 507     gtk_container_add (GTK_CONTAINER (window), main_vbox);
 508
 509     frame_horz = gtk_frame_new ("Horizontal Button Boxes");
 510     gtk_box_pack_start (GTK_BOX (main_vbox), frame_horz, TRUE, TRUE, 10);
 511
 512     vbox = gtk_vbox_new (FALSE, 0);
 513     gtk_container_border_width (GTK_CONTAINER (vbox), 10);
 514     gtk_container_add (GTK_CONTAINER (frame_horz), vbox);
 515
 516     gtk_box_pack_start (GTK_BOX (vbox),
 517            create_bbox (TRUE, "Spread", 40, 85, 20, GTK_BUTTONBOX_SPREAD),
 518                         TRUE, TRUE, 0);
 519
 520     gtk_box_pack_start (GTK_BOX (vbox),
 521            create_bbox (TRUE, "Edge", 40, 85, 20, GTK_BUTTONBOX_EDGE),
 522                         TRUE, TRUE, 5);
 523
 524     gtk_box_pack_start (GTK_BOX (vbox),
 525            create_bbox (TRUE, "Start", 40, 85, 20, GTK_BUTTONBOX_START),
 526                         TRUE, TRUE, 5);
 527
 528     gtk_box_pack_start (GTK_BOX (vbox),
 529            create_bbox (TRUE, "End", 40, 85, 20, GTK_BUTTONBOX_END),
 530                         TRUE, TRUE, 5);
 531
 532     frame_vert = gtk_frame_new ("Vertical Button Boxes");
 533     gtk_box_pack_start (GTK_BOX (main_vbox), frame_vert, TRUE, TRUE, 10);
 534
 535     hbox = gtk_hbox_new (FALSE, 0);
 536     gtk_container_border_width (GTK_CONTAINER (hbox), 10);
 537     gtk_container_add (GTK_CONTAINER (frame_vert), hbox);
 538
 539     gtk_box_pack_start (GTK_BOX (hbox),
 540            create_bbox (FALSE, "Spread", 30, 85, 20, GTK_BUTTONBOX_SPREAD),
 541                         TRUE, TRUE, 0);
 542
 543     gtk_box_pack_start (GTK_BOX (hbox),
 544            create_bbox (FALSE, "Edge", 30, 85, 20, GTK_BUTTONBOX_EDGE),
 545                         TRUE, TRUE, 5);
 546
 547     gtk_box_pack_start (GTK_BOX (hbox),
 548            create_bbox (FALSE, "Start", 30, 85, 20, GTK_BUTTONBOX_START),
 549                         TRUE, TRUE, 5);
 550
 551     gtk_box_pack_start (GTK_BOX (hbox),
 552            create_bbox (FALSE, "End", 30, 85, 20, GTK_BUTTONBOX_END),
 553                         TRUE, TRUE, 5);
 554   }
 555
 556   if (!GTK_WIDGET_VISIBLE (window))
 557     gtk_widget_show_all (window);
 558   else
 559     gtk_widget_destroy (window);
 560 }
 561
 562 /*
 563  * GtkToolBar
 564  */
 565
 566 static GtkWidget*
 567 new_pixmap (char      *filename,
 568             GdkWindow *window,
 569             GdkColor  *background)
 570 {
 571   GtkWidget *wpixmap;
 572   GdkPixmap *pixmap;
 573   GdkBitmap *mask;
 574
 575   pixmap = gdk_pixmap_create_from_xpm (window, &mask,
 576                                        background,
 577                                        filename);
 578   wpixmap = gtk_pixmap_new (pixmap, mask);
 579
 580   return wpixmap;
 581 }
 582
 583 static void
 584 set_toolbar_horizontal (GtkWidget *widget,
 585                         gpointer   data)
 586 {
 587   gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_HORIZONTAL);
 588 }
 589
 590 static void
 591 set_toolbar_vertical (GtkWidget *widget,
 592                       gpointer   data)
 593 {
 594   gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_VERTICAL);
 595 }
 596
 597 static void
 598 set_toolbar_icons (GtkWidget *widget,
 599                    gpointer   data)
 600 {
 601   gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_ICONS);
 602 }
 603
 604 static void
 605 set_toolbar_text (GtkWidget *widget,
 606                   gpointer   data)
 607 {
 608   gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_TEXT);
 609 }
 610
 611 static void
 612 set_toolbar_both (GtkWidget *widget,
 613                   gpointer   data)
 614 {
 615   gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH);
 616 }
 617
 618 static void
 619 set_toolbar_small_space (GtkWidget *widget,
 620                          gpointer   data)
 621 {
 622   gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 5);
 623 }
 624
 625 static void
 626 set_toolbar_big_space (GtkWidget *widget,
 627                        gpointer   data)
 628 {
 629   gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 10);
 630 }
 631
 632 static void
 633 set_toolbar_enable (GtkWidget *widget,
 634                     gpointer   data)
 635 {
 636   gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), TRUE);
 637 }
 638
 639 static void
 640 set_toolbar_disable (GtkWidget *widget,
 641                      gpointer   data)
 642 {
 643   gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), FALSE);
 644 }
 645
 646 static void
 647 set_toolbar_borders (GtkWidget *widget,
 648                      gpointer   data)
 649 {
 650   gtk_toolbar_set_button_relief (GTK_TOOLBAR (data), GTK_RELIEF_NORMAL);
 651 }
 652
 653 static void
 654 set_toolbar_borderless (GtkWidget *widget,
 655                         gpointer   data)
 656 {
 657   gtk_toolbar_set_button_relief (GTK_TOOLBAR (data), GTK_RELIEF_NONE);
 658 }
 659
 660 static void
 661 create_toolbar (void)
 662 {
 663   static GtkWidget *window = NULL;
 664   GtkWidget *toolbar;
 665   GtkWidget *entry;
 666
 667   if (!window)
 668     {
 669       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 670       gtk_window_set_title (GTK_WINDOW (window), "Toolbar test");
 671       gtk_window_set_policy (GTK_WINDOW (window), FALSE, TRUE, TRUE);
 672
 673       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 674                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
 675                           &window);
 676
 677       gtk_container_border_width (GTK_CONTAINER (window), 0);
 678       gtk_widget_realize (window);
 679
 680       toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
 681       gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NONE);
 682
 683       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 684                                "Horizontal", "Horizontal toolbar layout", "Toolbar/Horizontal",
 685                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 686                                (GtkSignalFunc) set_toolbar_horizontal, toolbar);
 687       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 688                                "Vertical", "Vertical toolbar layout", "Toolbar/Vertical",
 689                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 690                                (GtkSignalFunc) set_toolbar_vertical, toolbar);
 691
 692       gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
 693
 694       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 695                                "Icons", "Only show toolbar icons", "Toolbar/IconsOnly",
 696                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 697                                (GtkSignalFunc) set_toolbar_icons, toolbar);
 698       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 699                                "Text", "Only show toolbar text", "Toolbar/TextOnly",
 700                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 701                                (GtkSignalFunc) set_toolbar_text, toolbar);
 702       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 703                                "Both", "Show toolbar icons and text", "Toolbar/Both",
 704                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 705                                (GtkSignalFunc) set_toolbar_both, toolbar);
 706
 707       gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 708
 709       entry = gtk_entry_new ();
 710
 711       gtk_toolbar_append_widget (GTK_TOOLBAR (toolbar), entry, "This is an unusable GtkEntry ;)", "Hey don't click me!!!");
 712
 713       gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 714
 715       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 716                                "Small", "Use small spaces", "Toolbar/Small",
 717                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 718                                (GtkSignalFunc) set_toolbar_small_space, toolbar);
 719       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 720                                "Big", "Use big spaces", "Toolbar/Big",
 721                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 722                                (GtkSignalFunc) set_toolbar_big_space, toolbar);
 723
 724       gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 725
 726       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 727                                "Enable", "Enable tooltips", NULL,
 728                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 729                                (GtkSignalFunc) set_toolbar_enable, toolbar);
 730       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 731                                "Disable", "Disable tooltips", NULL,
 732                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 733                                (GtkSignalFunc) set_toolbar_disable, toolbar);
 734
 735       gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 736
 737       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 738                                "Borders", "Show Borders", NULL,
 739                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 740                                (GtkSignalFunc) set_toolbar_borders, toolbar);
 741       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 742                                "Borderless", "Hide Borders", NULL,
 743                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 744                                (GtkSignalFunc) set_toolbar_borderless, toolbar);
 745
 746       gtk_container_add (GTK_CONTAINER (window), toolbar);
 747     }
 748
 749   if (!GTK_WIDGET_VISIBLE (window))
 750     gtk_widget_show_all (window);
 751   else
 752     gtk_widget_destroy (window);
 753 }
 754
 755 static GtkWidget*
 756 make_toolbar (GtkWidget *window)
 757 {
 758   GtkWidget *toolbar;
 759
 760   if (!GTK_WIDGET_REALIZED (window))
 761     gtk_widget_realize (window);
 762
 763   toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
 764   gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NONE);
 765
 766   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 767                            "Horizontal", "Horizontal toolbar layout", NULL,
 768                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 769                            (GtkSignalFunc) set_toolbar_horizontal, toolbar);
 770   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 771                            "Vertical", "Vertical toolbar layout", NULL,
 772                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 773                            (GtkSignalFunc) set_toolbar_vertical, toolbar);
 774
 775   gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
 776
 777   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 778                            "Icons", "Only show toolbar icons", NULL,
 779                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 780                            (GtkSignalFunc) set_toolbar_icons, toolbar);
 781   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 782                            "Text", "Only show toolbar text", NULL,
 783                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 784                            (GtkSignalFunc) set_toolbar_text, toolbar);
 785   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 786                            "Both", "Show toolbar icons and text", NULL,
 787                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 788                            (GtkSignalFunc) set_toolbar_both, toolbar);
 789
 790   gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 791
 792   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 793                            "Small", "Use small spaces", NULL,
 794                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 795                            (GtkSignalFunc) set_toolbar_small_space, toolbar);
 796   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 797                            "Big", "Use big spaces", "Toolbar/Big",
 798                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 799                            (GtkSignalFunc) set_toolbar_big_space, toolbar);
 800
 801   gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 802
 803   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 804                            "Enable", "Enable tooltips", NULL,
 805                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 806                            (GtkSignalFunc) set_toolbar_enable, toolbar);
 807   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 808                            "Disable", "Disable tooltips", NULL,
 809                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 810                            (GtkSignalFunc) set_toolbar_disable, toolbar);
 811
 812   gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 813
 814   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 815                            "Borders", "Show Borders", NULL,
 816                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 817                            (GtkSignalFunc) set_toolbar_borders, toolbar);
 818   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 819                            "Borderless", "Hide Borders", NULL,
 820                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 821                            (GtkSignalFunc) set_toolbar_borderless, toolbar);
 822
 823   return toolbar;
 824 }
 825
 826 /*
 827  * GtkStatusBar
 828  */
 829
 830 static guint statusbar_counter = 1;
 831
 832 static void
 833 statusbar_push (GtkWidget *button,
 834                 GtkStatusbar *statusbar)
 835 {
 836   gchar text[1024];
 837
 838   sprintf (text, "something %d", statusbar_counter++);
 839
 840   gtk_statusbar_push (statusbar, 1, text);
 841 }
 842
 843 static void
 844 statusbar_pop (GtkWidget *button,
 845                GtkStatusbar *statusbar)
 846 {
 847   gtk_statusbar_pop (statusbar, 1);
 848 }
 849
 850 static void
 851 statusbar_steal (GtkWidget *button,
 852                  GtkStatusbar *statusbar)
 853 {
 854   gtk_statusbar_remove (statusbar, 1, 4);
 855 }
 856
 857 static void
 858 statusbar_popped (GtkStatusbar  *statusbar,
 859                   guint          context_id,
 860                   const gchar   *text)
 861 {
 862   if (!statusbar->messages)
 863     statusbar_counter = 1;
 864 }
 865
 866 static void
 867 statusbar_contexts (GtkStatusbar *statusbar)
 868 {
 869   gchar *string;
 870
 871   string = "any context";
 872   g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
 873            string,
 874            gtk_statusbar_get_context_id (statusbar, string));
 875
 876   string = "idle messages";
 877   g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
 878            string,
 879            gtk_statusbar_get_context_id (statusbar, string));
 880
 881   string = "some text";
 882   g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
 883            string,
 884            gtk_statusbar_get_context_id (statusbar, string));
 885
 886   string = "hit the mouse";
 887   g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
 888            string,
 889            gtk_statusbar_get_context_id (statusbar, string));
 890
 891   string = "hit the mouse2";
 892   g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
 893            string,
 894            gtk_statusbar_get_context_id (statusbar, string));
 895 }
 896
 897 static void
 898 statusbar_dump_stack (GtkStatusbar *statusbar)
 899 {
 900   GSList *list;
 901
 902   for (list = statusbar->messages; list; list = list->next)
 903     {
 904       GtkStatusbarMsg *msg;
 905
 906       msg = list->data;
 907       g_print ("context_id: %d, message_id: %d, status_text: \"%s\"\n",
 908                msg->context_id,
 909                msg->message_id,
 910                msg->text);
 911     }
 912 }
 913
 914 static void
 915 create_statusbar (void)
 916 {
 917   static GtkWidget *window = NULL;
 918   GtkWidget *box1;
 919   GtkWidget *box2;
 920   GtkWidget *button;
 921   GtkWidget *separator;
 922   GtkWidget *statusbar;
 923
 924   if (!window)
 925     {
 926       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 927
 928       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 929                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
 930                           &window);
 931
 932       gtk_window_set_title (GTK_WINDOW (window), "statusbar");
 933       gtk_container_border_width (GTK_CONTAINER (window), 0);
 934
 935       box1 = gtk_vbox_new (FALSE, 0);
 936       gtk_container_add (GTK_CONTAINER (window), box1);
 937
 938       box2 = gtk_vbox_new (FALSE, 10);
 939       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 940       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
 941
 942       statusbar = gtk_statusbar_new ();
 943       gtk_box_pack_end (GTK_BOX (box1), statusbar, TRUE, TRUE, 0);
 944       gtk_signal_connect (GTK_OBJECT (statusbar),
 945                           "text_popped",
 946                           GTK_SIGNAL_FUNC (statusbar_popped),
 947                           NULL);
 948
 949       button = gtk_widget_new (gtk_button_get_type (),
 950                                "label", "push something",
 951                                "visible", TRUE,
 952                                "parent", box2,
 953                                "signal::clicked", statusbar_push, statusbar,
 954                                NULL);
 955
 956       button = gtk_widget_new (gtk_button_get_type (),
 957                                "label", "pop",
 958                                "visible", TRUE,
 959                                "parent", box2,
 960                                "signal_after::clicked", statusbar_pop, statusbar,
 961                                NULL);
 962
 963       button = gtk_widget_new (gtk_button_get_type (),
 964                                "label", "steal #4",
 965                                "visible", TRUE,
 966                                "parent", box2,
 967                                "signal_after::clicked", statusbar_steal, statusbar,
 968                                NULL);
 969
 970       button = gtk_widget_new (gtk_button_get_type (),
 971                                "label", "dump stack",
 972                                "visible", TRUE,
 973                                "parent", box2,
 974                                "object_signal::clicked", statusbar_dump_stack, statusbar,
 975                                NULL);
 976
 977       button = gtk_widget_new (gtk_button_get_type (),
 978                                "label", "test contexts",
 979                                "visible", TRUE,
 980                                "parent", box2,
 981                                "object_signal_after::clicked", statusbar_contexts, statusbar,
 982                                NULL);
 983
 984       separator = gtk_hseparator_new ();
 985       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 986
 987       box2 = gtk_vbox_new (FALSE, 10);
 988       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 989       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 990
 991       button = gtk_button_new_with_label ("close");
 992       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
 993                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
 994                                  GTK_OBJECT (window));
 995       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 996       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 997       gtk_widget_grab_default (button);
 998     }
 999
1000   if (!GTK_WIDGET_VISIBLE (window))
1001     gtk_widget_show_all (window);
1002   else
1003     gtk_widget_destroy (window);
1004 }
1005
1006 /*
1007  * GtkTree
1008  */
1009
1010 static void
1011 cb_tree_destroy_event(GtkWidget* w)
1012 {
1013   sTreeButtons* tree_buttons;
1014
1015   /* free buttons structure associate at this tree */
1016   tree_buttons = gtk_object_get_user_data (GTK_OBJECT (w));
1017   g_free (tree_buttons);
1018 }
1019
1020 static void
1021 cb_add_new_item(GtkWidget* w, GtkTree* tree)
1022 {
1023   sTreeButtons* tree_buttons;
1024   GList* selected_list;
1025   GtkWidget* selected_item;
1026   GtkWidget* subtree;
1027   GtkWidget* item_new;
1028   char buffer[255];
1029
1030   tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree));
1031
1032   selected_list = GTK_TREE_SELECTION(tree);
1033
1034   if(selected_list == NULL)
1035     {
1036       /* there is no item in tree */
1037       subtree = GTK_WIDGET(tree);
1038     }
1039   else
1040     {
1041       /* list can have only one element */
1042       selected_item = GTK_WIDGET(selected_list->data);
1043
1044       subtree = GTK_TREE_ITEM_SUBTREE(selected_item);
1045
1046       if(subtree == NULL)
1047         {
1048           /* current selected item have not subtree ... create it */
1049           subtree = gtk_tree_new();
1050           gtk_tree_item_set_subtree(GTK_TREE_ITEM(selected_item),
1051                                     subtree);
1052         }
1053     }
1054
1055   /* at this point, we know which subtree will be used to add new item */
1056   /* create a new item */
1057   sprintf(buffer, "item add %d", tree_buttons->nb_item_add);
1058   item_new = gtk_tree_item_new_with_label(buffer);
1059   gtk_tree_append(GTK_TREE(subtree), item_new);
1060   gtk_widget_show(item_new);
1061
1062   tree_buttons->nb_item_add++;
1063 }
1064
1065 static void
1066 cb_remove_item(GtkWidget*w, GtkTree* tree)
1067 {
1068   GList* selected_list;
1069   GList* clear_list;
1070
1071   selected_list = GTK_TREE_SELECTION(tree);
1072
1073   clear_list = NULL;
1074
1075   while (selected_list)
1076     {
1077       clear_list = g_list_prepend (clear_list, selected_list->data);
1078       selected_list = selected_list->next;
1079     }
1080
1081   clear_list = g_list_reverse (clear_list);
1082   gtk_tree_remove_items(tree, clear_list);
1083
1084   g_list_free (clear_list);
1085 }
1086
1087 static void
1088 cb_remove_subtree(GtkWidget*w, GtkTree* tree)
1089 {
1090   GList* selected_list;
1091   GtkTreeItem *item;
1092
1093   selected_list = GTK_TREE_SELECTION(tree);
1094
1095   if (selected_list)
1096     {
1097       item = GTK_TREE_ITEM (selected_list->data);
1098       if (item->subtree)
1099         gtk_tree_item_remove_subtree (item);
1100     }
1101 }
1102
1103 static void
1104 cb_tree_changed(GtkTree* tree)
1105 {
1106   sTreeButtons* tree_buttons;
1107   GList* selected_list;
1108   guint nb_selected;
1109
1110   tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree));
1111
1112   selected_list = GTK_TREE_SELECTION(tree);
1113   nb_selected = g_list_length(selected_list);
1114
1115   if(nb_selected == 0)
1116     {
1117       if(tree->children == NULL)
1118         gtk_widget_set_sensitive(tree_buttons->add_button, TRUE);
1119       else
1120         gtk_widget_set_sensitive(tree_buttons->add_button, FALSE);
1121       gtk_widget_set_sensitive(tree_buttons->remove_button, FALSE);
1122       gtk_widget_set_sensitive(tree_buttons->subtree_button, FALSE);
1123     }
1124   else
1125     {
1126       gtk_widget_set_sensitive(tree_buttons->remove_button, TRUE);
1127       gtk_widget_set_sensitive(tree_buttons->add_button, (nb_selected == 1));
1128       gtk_widget_set_sensitive(tree_buttons->subtree_button, (nb_selected == 1));
1129     }
1130 }
1131
1132 static void
1133 create_subtree(GtkWidget* item, guint level, guint nb_item_max, guint recursion_level_max)
1134 {
1135   GtkWidget* item_subtree;
1136   GtkWidget* item_new;
1137   guint nb_item;
1138   char buffer[255];
1139   int no_root_item;
1140
1141   if(level == recursion_level_max) return;
1142
1143   if(level == -1)
1144     {
1145       /* query with no root item */
1146       level = 0;
1147       item_subtree = item;
1148       no_root_item = 1;
1149     }
1150   else
1151     {
1152       /* query with no root item */
1153       /* create subtree and associate it with current item */
1154       item_subtree = gtk_tree_new();
1155       no_root_item = 0;
1156     }
1157
1158   for(nb_item = 0; nb_item < nb_item_max; nb_item++)
1159     {
1160       sprintf(buffer, "item %d-%d", level, nb_item);
1161       item_new = gtk_tree_item_new_with_label(buffer);
1162       gtk_tree_append(GTK_TREE(item_subtree), item_new);
1163       create_subtree(item_new, level+1, nb_item_max, recursion_level_max);
1164       gtk_widget_show(item_new);
1165     }
1166
1167   if(!no_root_item)
1168     gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), item_subtree);
1169 }
1170
1171 static void
1172 create_tree_sample(guint selection_mode,
1173                    guint draw_line, guint view_line, guint no_root_item,
1174                    guint nb_item_max, guint recursion_level_max)
1175 {
1176   GtkWidget* window;
1177   GtkWidget* box1;
1178   GtkWidget* box2;
1179   GtkWidget* separator;
1180   GtkWidget* button;
1181   GtkWidget* scrolled_win;
1182   GtkWidget* root_tree;
1183   GtkWidget* root_item;
1184   sTreeButtons* tree_buttons;
1185
1186   /* create tree buttons struct */
1187   if ((tree_buttons = g_malloc (sizeof (sTreeButtons))) == NULL)
1188     {
1189       g_error("can't allocate memory for tree structure !\n");
1190       return;
1191     }
1192   tree_buttons->nb_item_add = 0;
1193
1194   /* create top level window */
1195   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1196   gtk_window_set_title(GTK_WINDOW(window), "Tree Sample");
1197   gtk_signal_connect(GTK_OBJECT(window), "destroy",
1198                      (GtkSignalFunc) cb_tree_destroy_event, NULL);
1199   gtk_object_set_user_data(GTK_OBJECT(window), tree_buttons);
1200
1201   box1 = gtk_vbox_new(FALSE, 0);
1202   gtk_container_add(GTK_CONTAINER(window), box1);
1203   gtk_widget_show(box1);
1204
1205   /* create tree box */
1206   box2 = gtk_vbox_new(FALSE, 0);
1207   gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);
1208   gtk_container_border_width(GTK_CONTAINER(box2), 5);
1209   gtk_widget_show(box2);
1210
1211   /* create scrolled window */
1212   scrolled_win = gtk_scrolled_window_new (NULL, NULL);
1213   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
1214                                   GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1215   gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
1216   gtk_widget_set_usize (scrolled_win, 200, 200);
1217   gtk_widget_show (scrolled_win);
1218
1219   /* create root tree widget */
1220   root_tree = gtk_tree_new();
1221   gtk_signal_connect(GTK_OBJECT(root_tree), "selection_changed",
1222                      (GtkSignalFunc)cb_tree_changed,
1223                      (gpointer)NULL);
1224   gtk_object_set_user_data(GTK_OBJECT(root_tree), tree_buttons);
1225   gtk_container_add(GTK_CONTAINER(scrolled_win), root_tree);
1226   gtk_tree_set_selection_mode(GTK_TREE(root_tree), selection_mode);
1227   gtk_tree_set_view_lines(GTK_TREE(root_tree), draw_line);
1228   gtk_tree_set_view_mode(GTK_TREE(root_tree), !view_line);
1229   gtk_widget_show(root_tree);
1230
1231   if ( no_root_item )
1232     {
1233       /* set root tree to subtree function with root item variable */
1234       root_item = GTK_WIDGET(root_tree);
1235     }
1236   else
1237     {
1238       /* create root tree item widget */
1239       root_item = gtk_tree_item_new_with_label("root item");
1240       gtk_tree_append(GTK_TREE(root_tree), root_item);
1241       gtk_widget_show(root_item);
1242      }
1243   create_subtree(root_item, -no_root_item, nb_item_max, recursion_level_max);
1244
1245   box2 = gtk_vbox_new(FALSE, 0);
1246   gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1247   gtk_container_border_width(GTK_CONTAINER(box2), 5);
1248   gtk_widget_show(box2);
1249
1250   button = gtk_button_new_with_label("Add Item");
1251   gtk_widget_set_sensitive(button, FALSE);
1252   gtk_signal_connect(GTK_OBJECT (button), "clicked",
1253                      (GtkSignalFunc) cb_add_new_item,
1254                      (gpointer)root_tree);
1255   gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1256   gtk_widget_show(button);
1257   tree_buttons->add_button = button;
1258
1259   button = gtk_button_new_with_label("Remove Item(s)");
1260   gtk_widget_set_sensitive(button, FALSE);
1261   gtk_signal_connect(GTK_OBJECT (button), "clicked",
1262                      (GtkSignalFunc) cb_remove_item,
1263                      (gpointer)root_tree);
1264   gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1265   gtk_widget_show(button);
1266   tree_buttons->remove_button = button;
1267
1268   button = gtk_button_new_with_label("Remove Subtree");
1269   gtk_widget_set_sensitive(button, FALSE);
1270   gtk_signal_connect(GTK_OBJECT (button), "clicked",
1271                      (GtkSignalFunc) cb_remove_subtree,
1272                      (gpointer)root_tree);
1273   gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1274   gtk_widget_show(button);
1275   tree_buttons->subtree_button = button;
1276
1277   /* create separator */
1278   separator = gtk_hseparator_new();
1279   gtk_box_pack_start(GTK_BOX(box1), separator, FALSE, FALSE, 0);
1280   gtk_widget_show(separator);
1281
1282   /* create button box */
1283   box2 = gtk_vbox_new(FALSE, 0);
1284   gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1285   gtk_container_border_width(GTK_CONTAINER(box2), 5);
1286   gtk_widget_show(box2);
1287
1288   button = gtk_button_new_with_label("Close");
1289   gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1290   gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
1291                             (GtkSignalFunc) gtk_widget_destroy,
1292                             GTK_OBJECT(window));
1293   gtk_widget_show(button);
1294
1295   gtk_widget_show(window);
1296 }
1297
1298 static void
1299 cb_create_tree(GtkWidget* w)
1300 {
1301   guint selection_mode = GTK_SELECTION_SINGLE;
1302   guint view_line;
1303   guint draw_line;
1304   guint no_root_item;
1305   guint nb_item;
1306   guint recursion_level;
1307
1308   /* get selection mode choice */
1309   if(GTK_TOGGLE_BUTTON(sTreeSampleSelection.single_button)->active)
1310     selection_mode = GTK_SELECTION_SINGLE;
1311   else
1312     if(GTK_TOGGLE_BUTTON(sTreeSampleSelection.browse_button)->active)
1313       selection_mode = GTK_SELECTION_BROWSE;
1314     else
1315       selection_mode = GTK_SELECTION_MULTIPLE;
1316
1317   /* get options choice */
1318   draw_line = GTK_TOGGLE_BUTTON(sTreeSampleSelection.draw_line_button)->active;
1319   view_line = GTK_TOGGLE_BUTTON(sTreeSampleSelection.view_line_button)->active;
1320   no_root_item = GTK_TOGGLE_BUTTON(sTreeSampleSelection.no_root_item_button)->active;
1321
1322   /* get levels */
1323   nb_item = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sTreeSampleSelection.nb_item_spinner));
1324   recursion_level = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sTreeSampleSelection.recursion_spinner));
1325
1326   if (pow (nb_item, recursion_level) > 10000)
1327     {
1328       g_print ("%g total items? That will take a very long time. Try less\n",
1329                pow (nb_item, recursion_level));
1330       return;
1331     }
1332
1333   create_tree_sample(selection_mode, draw_line, view_line, no_root_item, nb_item, recursion_level);
1334 }
1335
1336 void
1337 create_tree_mode_window(void)
1338 {
1339   static GtkWidget* window;
1340   GtkWidget* box1;
1341   GtkWidget* box2;
1342   GtkWidget* box3;
1343   GtkWidget* box4;
1344   GtkWidget* box5;
1345   GtkWidget* button;
1346   GtkWidget* frame;
1347   GtkWidget* separator;
1348   GtkWidget* label;
1349   GtkWidget* spinner;
1350   GtkAdjustment *adj;
1351
1352   if (!window)
1353     {
1354       /* create toplevel window  */
1355       window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1356       gtk_window_set_title(GTK_WINDOW(window), "Set Tree Parameters");
1357       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1358                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1359                           &window);
1360       box1 = gtk_vbox_new(FALSE, 0);
1361       gtk_container_add(GTK_CONTAINER(window), box1);
1362
1363       /* create upper box - selection box */
1364       box2 = gtk_vbox_new(FALSE, 5);
1365       gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);
1366       gtk_container_border_width(GTK_CONTAINER(box2), 5);
1367
1368       box3 = gtk_hbox_new(FALSE, 5);
1369       gtk_box_pack_start(GTK_BOX(box2), box3, TRUE, TRUE, 0);
1370
1371       /* create selection mode frame */
1372       frame = gtk_frame_new("Selection Mode");
1373       gtk_box_pack_start(GTK_BOX(box3), frame, TRUE, TRUE, 0);
1374
1375       box4 = gtk_vbox_new(FALSE, 0);
1376       gtk_container_add(GTK_CONTAINER(frame), box4);
1377       gtk_container_border_width(GTK_CONTAINER(box4), 5);
1378
1379       /* create radio button */
1380       button = gtk_radio_button_new_with_label(NULL, "SINGLE");
1381       gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1382       sTreeSampleSelection.single_button = button;
1383
1384       button = gtk_radio_button_new_with_label(gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
1385                                                "BROWSE");
1386       gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1387       sTreeSampleSelection.browse_button = button;
1388
1389       button = gtk_radio_button_new_with_label(gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
1390                                                "MULTIPLE");
1391       gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1392       sTreeSampleSelection.multiple_button = button;
1393
1394       sTreeSampleSelection.selection_mode_group = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
1395
1396       /* create option mode frame */
1397       frame = gtk_frame_new("Options");
1398       gtk_box_pack_start(GTK_BOX(box3), frame, TRUE, TRUE, 0);
1399
1400       box4 = gtk_vbox_new(FALSE, 0);
1401       gtk_container_add(GTK_CONTAINER(frame), box4);
1402       gtk_container_border_width(GTK_CONTAINER(box4), 5);
1403
1404       /* create check button */
1405       button = gtk_check_button_new_with_label("Draw line");
1406       gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1407       gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE);
1408       sTreeSampleSelection.draw_line_button = button;
1409
1410       button = gtk_check_button_new_with_label("View Line mode");
1411       gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1412       gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE);
1413       sTreeSampleSelection.view_line_button = button;
1414
1415       button = gtk_check_button_new_with_label("Without Root item");
1416       gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1417       sTreeSampleSelection.no_root_item_button = button;
1418
1419       /* create recursion parameter */
1420       frame = gtk_frame_new("Size Parameters");
1421       gtk_box_pack_start(GTK_BOX(box2), frame, TRUE, TRUE, 0);
1422
1423       box4 = gtk_hbox_new(FALSE, 5);
1424       gtk_container_add(GTK_CONTAINER(frame), box4);
1425       gtk_container_border_width(GTK_CONTAINER(box4), 5);
1426
1427       /* create number of item spin button */
1428       box5 = gtk_hbox_new(FALSE, 5);
1429       gtk_box_pack_start(GTK_BOX(box4), box5, FALSE, FALSE, 0);
1430
1431       label = gtk_label_new("Number of items : ");
1432       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1433       gtk_box_pack_start (GTK_BOX (box5), label, FALSE, TRUE, 0);
1434
1435       adj = (GtkAdjustment *) gtk_adjustment_new ((gfloat)DEFAULT_NUMBER_OF_ITEM, 1.0, 255.0, 1.0,
1436                                                   5.0, 0.0);
1437       spinner = gtk_spin_button_new (adj, 0, 0);
1438       gtk_box_pack_start (GTK_BOX (box5), spinner, FALSE, TRUE, 0);
1439       sTreeSampleSelection.nb_item_spinner = spinner;
1440
1441       /* create recursion level spin button */
1442       box5 = gtk_hbox_new(FALSE, 5);
1443       gtk_box_pack_start(GTK_BOX(box4), box5, FALSE, FALSE, 0);
1444
1445       label = gtk_label_new("Depth : ");
1446       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1447       gtk_box_pack_start (GTK_BOX (box5), label, FALSE, TRUE, 0);
1448
1449       adj = (GtkAdjustment *) gtk_adjustment_new ((gfloat)DEFAULT_RECURSION_LEVEL, 0.0, 255.0, 1.0,
1450                                                   5.0, 0.0);
1451       spinner = gtk_spin_button_new (adj, 0, 0);
1452       gtk_box_pack_start (GTK_BOX (box5), spinner, FALSE, TRUE, 0);
1453       sTreeSampleSelection.recursion_spinner = spinner;
1454
1455       /* create horizontal separator */
1456       separator = gtk_hseparator_new();
1457       gtk_box_pack_start(GTK_BOX(box1), separator, FALSE, FALSE, 0);
1458
1459       /* create bottom button box */
1460       box2 = gtk_hbox_new(TRUE, 10);
1461       gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1462       gtk_container_border_width(GTK_CONTAINER(box2), 5);
1463
1464       button = gtk_button_new_with_label("Create Tree");
1465       gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1466       gtk_signal_connect(GTK_OBJECT (button), "clicked",
1467                          (GtkSignalFunc) cb_create_tree, NULL);
1468
1469       button = gtk_button_new_with_label("Close");
1470       gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1471       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1472                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1473                                  GTK_OBJECT (window));
1474     }
1475   if (!GTK_WIDGET_VISIBLE (window))
1476     gtk_widget_show_all (window);
1477   else
1478     gtk_widget_destroy (window);
1479 }
1480
1481 /*
1482  * GtkHandleBox
1483  */
1484
1485 static void
1486 handle_box_child_signal (GtkHandleBox *hb,
1487                          GtkWidget    *child,
1488                          const gchar  *action)
1489 {
1490   printf ("%s: child <%s> %sed\n",
1491           gtk_type_name (GTK_OBJECT_TYPE (hb)),
1492           gtk_type_name (GTK_OBJECT_TYPE (child)),
1493           action);
1494 }
1495
1496 static void
1497 create_handle_box (void)
1498 {
1499   static GtkWidget* window = NULL;
1500   GtkWidget *handle_box;
1501   GtkWidget *handle_box2;
1502   GtkWidget *vbox;
1503   GtkWidget *hbox;
1504   GtkWidget *toolbar;
1505   GtkWidget *label;
1506   GtkWidget *separator;
1507
1508   if (!window)
1509   {
1510     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1511     gtk_window_set_title (GTK_WINDOW (window),
1512                           "Handle Box Test");
1513     gtk_window_set_policy (GTK_WINDOW (window),
1514                            TRUE,
1515                            TRUE,
1516                            FALSE);
1517
1518     gtk_signal_connect (GTK_OBJECT (window), "destroy",
1519                         GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1520                         &window);
1521
1522     gtk_container_border_width (GTK_CONTAINER (window), 20);
1523
1524     vbox = gtk_vbox_new (FALSE, 0);
1525     gtk_container_add (GTK_CONTAINER (window), vbox);
1526     gtk_widget_show (vbox);
1527
1528     label = gtk_label_new ("Above");
1529     gtk_container_add (GTK_CONTAINER (vbox), label);
1530     gtk_widget_show (label);
1531
1532     separator = gtk_hseparator_new ();
1533     gtk_container_add (GTK_CONTAINER (vbox), separator);
1534     gtk_widget_show (separator);
1535
1536     hbox = gtk_hbox_new (FALSE, 10);
1537     gtk_container_add (GTK_CONTAINER (vbox), hbox);
1538     gtk_widget_show (hbox);
1539
1540     separator = gtk_hseparator_new ();
1541     gtk_container_add (GTK_CONTAINER (vbox), separator);
1542     gtk_widget_show (separator);
1543
1544     label = gtk_label_new ("Below");
1545     gtk_container_add (GTK_CONTAINER (vbox), label);
1546     gtk_widget_show (label);
1547
1548     handle_box = gtk_handle_box_new ();
1549     gtk_container_add (GTK_CONTAINER (hbox), handle_box);
1550     gtk_signal_connect (GTK_OBJECT (handle_box),
1551                         "child_attached",
1552                         GTK_SIGNAL_FUNC (handle_box_child_signal),
1553                         "attached");
1554     gtk_signal_connect (GTK_OBJECT (handle_box),
1555                         "child_detached",
1556                         GTK_SIGNAL_FUNC (handle_box_child_signal),
1557                         "detached");
1558     gtk_widget_show (handle_box);
1559
1560     toolbar = make_toolbar (window);
1561     gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NORMAL);
1562     gtk_container_add (GTK_CONTAINER (handle_box), toolbar);
1563     gtk_widget_show (toolbar);
1564
1565     handle_box = gtk_handle_box_new ();
1566     gtk_container_add (GTK_CONTAINER (hbox), handle_box);
1567     gtk_signal_connect (GTK_OBJECT (handle_box),
1568                         "child_attached",
1569                         GTK_SIGNAL_FUNC (handle_box_child_signal),
1570                         "attached");
1571     gtk_signal_connect (GTK_OBJECT (handle_box),
1572                         "child_detached",
1573                         GTK_SIGNAL_FUNC (handle_box_child_signal),
1574                         "detached");
1575     gtk_widget_show (handle_box);
1576
1577     handle_box2 = gtk_handle_box_new ();
1578     gtk_container_add (GTK_CONTAINER (handle_box), handle_box2);
1579     gtk_signal_connect (GTK_OBJECT (handle_box2),
1580                         "child_attached",
1581                         GTK_SIGNAL_FUNC (handle_box_child_signal),
1582                         "attached");
1583     gtk_signal_connect (GTK_OBJECT (handle_box2),
1584                         "child_detached",
1585                         GTK_SIGNAL_FUNC (handle_box_child_signal),
1586                         "detached");
1587     gtk_widget_show (handle_box2);
1588
1589     label = gtk_label_new ("Fooo!");
1590     gtk_container_add (GTK_CONTAINER (handle_box2), label);
1591     gtk_widget_show (label);
1592   }
1593
1594   if (!GTK_WIDGET_VISIBLE (window))
1595     gtk_widget_show (window);
1596   else
1597     gtk_widget_destroy (window);
1598 }
1599
1600 /*
1601  * Reparent demo
1602  */
1603
1604 static void
1605 reparent_label (GtkWidget *widget,
1606                 GtkWidget *new_parent)
1607 {
1608   GtkWidget *label;
1609
1610   label = gtk_object_get_user_data (GTK_OBJECT (widget));
1611
1612   gtk_widget_reparent (label, new_parent);
1613 }
1614
1615 static void
1616 set_parent_signal (GtkWidget *child,
1617                    GtkWidget *old_parent,
1618                    gpointer   func_data)
1619 {
1620   g_print ("set_parent for \"%s\": new parent: \"%s\", old parent: \"%s\", data: %d\n",
1621            gtk_type_name (GTK_OBJECT_TYPE (child)),
1622            child->parent ? gtk_type_name (GTK_OBJECT_TYPE (child->parent)) : "NULL",
1623            old_parent ? gtk_type_name (GTK_OBJECT_TYPE (old_parent)) : "NULL",
1624            GPOINTER_TO_INT (func_data));
1625 }
1626
1627 static void
1628 create_reparent (void)
1629 {
1630   static GtkWidget *window = NULL;
1631   GtkWidget *box1;
1632   GtkWidget *box2;
1633   GtkWidget *box3;
1634   GtkWidget *frame;
1635   GtkWidget *button;
1636   GtkWidget *label;
1637   GtkWidget *separator;
1638
1639   if (!window)
1640     {
1641       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1642
1643       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1644                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1645                           &window);
1646
1647       gtk_window_set_title (GTK_WINDOW (window), "reparent");
1648       gtk_container_border_width (GTK_CONTAINER (window), 0);
1649
1650       box1 = gtk_vbox_new (FALSE, 0);
1651       gtk_container_add (GTK_CONTAINER (window), box1);
1652
1653       box2 = gtk_hbox_new (FALSE, 5);
1654       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1655       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1656
1657       label = gtk_label_new ("Hello World");
1658
1659       frame = gtk_frame_new ("Frame 1");
1660       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
1661
1662       box3 = gtk_vbox_new (FALSE, 5);
1663       gtk_container_border_width (GTK_CONTAINER (box3), 5);
1664       gtk_container_add (GTK_CONTAINER (frame), box3);
1665
1666       button = gtk_button_new_with_label ("switch");
1667       gtk_signal_connect (GTK_OBJECT (button), "clicked",
1668                           GTK_SIGNAL_FUNC(reparent_label),
1669                           box3);
1670       gtk_object_set_user_data (GTK_OBJECT (button), label);
1671       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
1672
1673       gtk_box_pack_start (GTK_BOX (box3), label, FALSE, TRUE, 0);
1674       gtk_signal_connect (GTK_OBJECT (label),
1675                           "parent_set",
1676                           GTK_SIGNAL_FUNC (set_parent_signal),
1677                           GINT_TO_POINTER (42));
1678
1679       frame = gtk_frame_new ("Frame 2");
1680       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
1681
1682       box3 = gtk_vbox_new (FALSE, 5);
1683       gtk_container_border_width (GTK_CONTAINER (box3), 5);
1684       gtk_container_add (GTK_CONTAINER (frame), box3);
1685
1686       button = gtk_button_new_with_label ("switch");
1687       gtk_signal_connect (GTK_OBJECT (button), "clicked",
1688                           GTK_SIGNAL_FUNC(reparent_label),
1689                           box3);
1690       gtk_object_set_user_data (GTK_OBJECT (button), label);
1691       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
1692
1693       separator = gtk_hseparator_new ();
1694       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1695
1696       box2 = gtk_vbox_new (FALSE, 10);
1697       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1698       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1699
1700       button = gtk_button_new_with_label ("close");
1701       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1702                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1703                                  GTK_OBJECT (window));
1704       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1705       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1706       gtk_widget_grab_default (button);
1707     }
1708
1709   if (!GTK_WIDGET_VISIBLE (window))
1710     gtk_widget_show_all (window);
1711   else
1712     gtk_widget_destroy (window);
1713 }
1714
1715 /*
1716  * Saved Position
1717  */
1718 gint upositionx = 0;
1719 gint upositiony = 0;
1720
1721 static gint
1722 uposition_configure (GtkWidget *window)
1723 {
1724   GtkLabel *lx;
1725   GtkLabel *ly;
1726   gchar buffer[64];
1727
1728   lx = gtk_object_get_data (GTK_OBJECT (window), "x");
1729   ly = gtk_object_get_data (GTK_OBJECT (window), "y");
1730
1731   gdk_window_get_root_origin (window->window, &upositionx, &upositiony);
1732   sprintf (buffer, "%d", upositionx);
1733   gtk_label_set (lx, buffer);
1734   sprintf (buffer, "%d", upositiony);
1735   gtk_label_set (ly, buffer);
1736
1737   return FALSE;
1738 }
1739
1740 static void
1741 create_saved_position (void)
1742 {
1743   static GtkWidget *window = NULL;
1744
1745   if (!window)
1746     {
1747       GtkWidget *hbox;
1748       GtkWidget *main_vbox;
1749       GtkWidget *vbox;
1750       GtkWidget *x_label;
1751       GtkWidget *y_label;
1752       GtkWidget *button;
1753       GtkWidget *label;
1754       GtkWidget *any;
1755
1756       window = gtk_widget_new (GTK_TYPE_WINDOW,
1757                                "type", GTK_WINDOW_TOPLEVEL,
1758                                "signal::configure_event", uposition_configure, NULL,
1759                                "x", upositionx,
1760                                "y", upositiony,
1761                                "title", "Saved Position",
1762                                NULL);
1763
1764       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1765                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
1766                           &window);
1767
1768       main_vbox = gtk_vbox_new (FALSE, 5);
1769       gtk_container_border_width (GTK_CONTAINER (main_vbox), 0);
1770       gtk_container_add (GTK_CONTAINER (window), main_vbox);
1771
1772       vbox =
1773         gtk_widget_new (gtk_vbox_get_type (),
1774                         "GtkBox::homogeneous", FALSE,
1775                         "GtkBox::spacing", 5,
1776                         "GtkContainer::border_width", 10,
1777                         "GtkWidget::parent", main_vbox,
1778                         "GtkWidget::visible", TRUE,
1779                         NULL);
1780
1781       hbox = gtk_hbox_new (FALSE, 0);
1782       gtk_container_border_width (GTK_CONTAINER (hbox), 5);
1783       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
1784
1785       label = gtk_label_new ("X Origin : ");
1786       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1787       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
1788
1789       x_label = gtk_label_new ("");
1790       gtk_box_pack_start (GTK_BOX (hbox), x_label, TRUE, TRUE, 0);
1791       gtk_object_set_data (GTK_OBJECT (window), "x", x_label);
1792
1793       hbox = gtk_hbox_new (FALSE, 0);
1794       gtk_container_border_width (GTK_CONTAINER (hbox), 5);
1795       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
1796
1797       label = gtk_label_new ("Y Origin : ");
1798       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1799       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
1800
1801       y_label = gtk_label_new ("");
1802       gtk_box_pack_start (GTK_BOX (hbox), y_label, TRUE, TRUE, 0);
1803       gtk_object_set_data (GTK_OBJECT (window), "y", y_label);
1804
1805       any =
1806         gtk_widget_new (gtk_hseparator_get_type (),
1807                         "GtkWidget::visible", TRUE,
1808                         NULL);
1809       gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
1810
1811       hbox = gtk_hbox_new (FALSE, 0);
1812       gtk_container_border_width (GTK_CONTAINER (hbox), 10);
1813       gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
1814
1815       button = gtk_button_new_with_label ("Close");
1816       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1817                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
1818                                  GTK_OBJECT (window));
1819       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
1820       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1821       gtk_widget_grab_default (button);
1822
1823       gtk_widget_show_all (window);
1824     }
1825   else
1826     gtk_widget_destroy (window);
1827 }
1828
1829 /*
1830  * GtkPixmap
1831  */
1832
1833 static void
1834 create_pixmap (void)
1835 {
1836   static GtkWidget *window = NULL;
1837   GtkWidget *box1;
1838   GtkWidget *box2;
1839   GtkWidget *box3;
1840   GtkWidget *button;
1841   GtkWidget *label;
1842   GtkWidget *separator;
1843   GtkWidget *pixmapwid;
1844   GdkPixmap *pixmap;
1845   GdkBitmap *mask;
1846   GtkStyle *style;
1847
1848   if (!window)
1849     {
1850       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1851
1852       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1853                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1854                           &window);
1855
1856       gtk_window_set_title (GTK_WINDOW (window), "GtkPixmap");
1857       gtk_container_border_width (GTK_CONTAINER (window), 0);
1858       gtk_widget_realize(window);
1859
1860       box1 = gtk_vbox_new (FALSE, 0);
1861       gtk_container_add (GTK_CONTAINER (window), box1);
1862
1863       box2 = gtk_vbox_new (FALSE, 10);
1864       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1865       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1866
1867       button = gtk_button_new ();
1868       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
1869
1870       style = gtk_widget_get_style(button);
1871
1872       pixmap = gdk_pixmap_create_from_xpm (window->window, &mask,
1873                                            &style->bg[GTK_STATE_NORMAL],
1874                                            "test.xpm");
1875       pixmapwid = gtk_pixmap_new (pixmap, mask);
1876       gdk_pixmap_unref (pixmap);
1877       gdk_pixmap_unref (mask);
1878
1879       label = gtk_label_new ("Pixmap\ntest");
1880       box3 = gtk_hbox_new (FALSE, 0);
1881       gtk_container_border_width (GTK_CONTAINER (box3), 2);
1882       gtk_container_add (GTK_CONTAINER (box3), pixmapwid);
1883       gtk_container_add (GTK_CONTAINER (box3), label);
1884       gtk_container_add (GTK_CONTAINER (button), box3);
1885
1886       separator = gtk_hseparator_new ();
1887       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1888
1889       box2 = gtk_vbox_new (FALSE, 10);
1890       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1891       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1892
1893       button = gtk_button_new_with_label ("close");
1894       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1895                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1896                                  GTK_OBJECT (window));
1897       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1898       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1899       gtk_widget_grab_default (button);
1900     }
1901
1902   if (!GTK_WIDGET_VISIBLE (window))
1903     gtk_widget_show_all (window);
1904   else
1905     gtk_widget_destroy (window);
1906 }
1907
1908 static void
1909 tips_query_widget_entered (GtkTipsQuery   *tips_query,
1910                            GtkWidget      *widget,
1911                            const gchar    *tip_text,
1912                            const gchar    *tip_private,
1913                            GtkWidget      *toggle)
1914 {
1915   if (GTK_TOGGLE_BUTTON (toggle)->active)
1916     {
1917       gtk_label_set (GTK_LABEL (tips_query), tip_text ? "There is a Tip!" : "There is no Tip!");
1918       /* don't let GtkTipsQuery reset it's label */
1919       gtk_signal_emit_stop_by_name (GTK_OBJECT (tips_query), "widget_entered");
1920     }
1921 }
1922
1923 static gint
1924 tips_query_widget_selected (GtkWidget      *tips_query,
1925                             GtkWidget      *widget,
1926                             const gchar    *tip_text,
1927                             const gchar    *tip_private,
1928                             GdkEventButton *event,
1929                             gpointer        func_data)
1930 {
1931   if (widget)
1932     g_print ("Help \"%s\" requested for <%s>\n",
1933              tip_private ? tip_private : "None",
1934              gtk_type_name (GTK_OBJECT_TYPE (widget)));
1935   return TRUE;
1936 }
1937
1938 static void
1939 create_tooltips (void)
1940 {
1941   static GtkWidget *window = NULL;
1942   GtkWidget *box1;
1943   GtkWidget *box2;
1944   GtkWidget *box3;
1945   GtkWidget *button;
1946   GtkWidget *toggle;
1947   GtkWidget *frame;
1948   GtkWidget *tips_query;
1949   GtkWidget *separator;
1950   GtkTooltips *tooltips;
1951
1952   if (!window)
1953     {
1954       window =
1955         gtk_widget_new (gtk_window_get_type (),
1956                         "GtkWindow::type", GTK_WINDOW_TOPLEVEL,
1957                         "GtkContainer::border_width", 0,
1958                         "GtkWindow::title", "Tooltips",
1959                         "GtkWindow::allow_shrink", TRUE,
1960                         "GtkWindow::allow_grow", FALSE,
1961                         "GtkWindow::auto_shrink", TRUE,
1962                         "GtkWidget::width", 200,
1963                         NULL);
1964
1965       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1966                           GTK_SIGNAL_FUNC (destroy_tooltips),
1967                           &window);
1968
1969       tooltips=gtk_tooltips_new();
1970       gtk_object_set_data (GTK_OBJECT (window), "tooltips", tooltips);
1971
1972       box1 = gtk_vbox_new (FALSE, 0);
1973       gtk_container_add (GTK_CONTAINER (window), box1);
1974
1975       box2 = gtk_vbox_new (FALSE, 10);
1976       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1977       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1978
1979       button = gtk_toggle_button_new_with_label ("button1");
1980       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1981
1982       gtk_tooltips_set_tip (tooltips,button,"This is button 1", "ContextHelp/buttons/1");
1983
1984       button = gtk_toggle_button_new_with_label ("button2");
1985       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1986
1987       gtk_tooltips_set_tip (tooltips,
1988                             button,
1989                             "This is button 2. This is also a really long tooltip which probably won't fit on a single line and will therefore need to be wrapped. Hopefully the wrapping will work correctly.",
1990                             "ContextHelp/buttons/2_long");
1991
1992       toggle = gtk_toggle_button_new_with_label ("Override TipsQuery Label");
1993       gtk_box_pack_start (GTK_BOX (box2), toggle, TRUE, TRUE, 0);
1994
1995       gtk_tooltips_set_tip (tooltips, toggle, "Toggle TipsQuery view.", "Hi msw! ;)");
1996
1997       box3 =
1998         gtk_widget_new (gtk_vbox_get_type (),
1999                         "GtkBox::homogeneous", FALSE,
2000                         "GtkBox::spacing", 5,
2001                         "GtkContainer::border_width", 5,
2002                         "GtkWidget::visible", TRUE,
2003                         NULL);
2004
2005       tips_query = gtk_tips_query_new ();
2006
2007       button =
2008         gtk_widget_new (gtk_button_get_type (),
2009                         "GtkButton::label", "[?]",
2010                         "GtkWidget::visible", TRUE,
2011                         "GtkWidget::parent", box3,
2012                         "GtkObject::object_signal::clicked", gtk_tips_query_start_query, tips_query,
2013                         NULL);
2014       gtk_box_set_child_packing (GTK_BOX (box3), button, FALSE, FALSE, 0, GTK_PACK_START);
2015       gtk_tooltips_set_tip (tooltips,
2016                             button,
2017                             "Start the Tooltips Inspector",
2018                             "ContextHelp/buttons/?");
2019
2020
2021       gtk_widget_set (tips_query,
2022                       "GtkWidget::visible", TRUE,
2023                       "GtkWidget::parent", box3,
2024                       "GtkTipsQuery::caller", button,
2025                       "GtkObject::signal::widget_entered", tips_query_widget_entered, toggle,
2026                       "GtkObject::signal::widget_selected", tips_query_widget_selected, NULL,
2027                       NULL);
2028
2029       frame =
2030         gtk_widget_new (gtk_frame_get_type (),
2031                         "GtkFrame::label", "ToolTips Inspector",
2032                         "GtkFrame::label_xalign", (double) 0.5,
2033                         "GtkContainer::border_width", 0,
2034                         "GtkWidget::visible", TRUE,
2035                         "GtkWidget::parent", box2,
2036                         "GtkContainer::child", box3,
2037                         NULL);
2038       gtk_box_set_child_packing (GTK_BOX (box2), frame, TRUE, TRUE, 10, GTK_PACK_START);
2039
2040       separator = gtk_hseparator_new ();
2041       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2042
2043       box2 = gtk_vbox_new (FALSE, 10);
2044       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2045       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2046
2047       button = gtk_button_new_with_label ("close");
2048       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2049                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2050                                  GTK_OBJECT (window));
2051       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2052       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2053       gtk_widget_grab_default (button);
2054
2055       gtk_tooltips_set_tip (tooltips, button, "Push this button to close window", "ContextHelp/buttons/Close");
2056     }
2057
2058   if (!GTK_WIDGET_VISIBLE (window))
2059     gtk_widget_show_all (window);
2060   else
2061     gtk_widget_destroy (window);
2062 }
2063
2064 /*
2065  * Menu demo
2066  */
2067
2068 static GtkWidget*
2069 create_menu (gint depth, gboolean tearoff)
2070 {
2071   GtkWidget *menu;
2072   GtkWidget *menuitem;
2073   GSList *group;
2074   char buf[32];
2075   int i, j;
2076
2077   if (depth < 1)
2078     return NULL;
2079
2080   menu = gtk_menu_new ();
2081   group = NULL;
2082
2083   if (tearoff)
2084     {
2085       menuitem = gtk_tearoff_menu_item_new ();
2086       gtk_menu_append (GTK_MENU (menu), menuitem);
2087       gtk_widget_show (menuitem);
2088     }
2089
2090   for (i = 0, j = 1; i < 5; i++, j++)
2091     {
2092       sprintf (buf, "item %2d - %d", depth, j);
2093       menuitem = gtk_radio_menu_item_new_with_label (group, buf);
2094       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
2095       if (depth % 2)
2096         gtk_check_menu_item_set_show_toggle (GTK_CHECK_MENU_ITEM (menuitem), TRUE);
2097       gtk_menu_append (GTK_MENU (menu), menuitem);
2098       gtk_widget_show (menuitem);
2099       if (i == 3)
2100         gtk_widget_set_sensitive (menuitem, FALSE);
2101
2102       gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (depth - 1, TRUE));
2103     }
2104
2105   return menu;
2106 }
2107
2108 static void
2109 create_menus (void)
2110 {
2111   static GtkWidget *window = NULL;
2112   GtkWidget *box1;
2113   GtkWidget *box2;
2114   GtkWidget *button;
2115   GtkWidget *optionmenu;
2116   GtkWidget *separator;
2117
2118   if (!window)
2119     {
2120       GtkWidget *menubar;
2121       GtkWidget *menu;
2122       GtkWidget *menuitem;
2123       GtkAccelGroup *accel_group;
2124
2125       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2126
2127       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2128                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2129                           &window);
2130       gtk_signal_connect (GTK_OBJECT (window), "delete-event",
2131                           GTK_SIGNAL_FUNC (gtk_true),
2132                           NULL);
2133
2134       accel_group = gtk_accel_group_new ();
2135       gtk_accel_group_attach (accel_group, GTK_OBJECT (window));
2136
2137       gtk_window_set_title (GTK_WINDOW (window), "menus");
2138       gtk_container_border_width (GTK_CONTAINER (window), 0);
2139
2140
2141       box1 = gtk_vbox_new (FALSE, 0);
2142       gtk_container_add (GTK_CONTAINER (window), box1);
2143       gtk_widget_show (box1);
2144
2145       menubar = gtk_menu_bar_new ();
2146       gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
2147       gtk_widget_show (menubar);
2148
2149       menu = create_menu (2, TRUE);
2150
2151       menuitem = gtk_menu_item_new_with_label ("test\nline2");
2152       gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
2153       gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2154       gtk_widget_show (menuitem);
2155
2156       menuitem = gtk_menu_item_new_with_label ("foo");
2157       gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (3, TRUE));
2158       gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2159       gtk_widget_show (menuitem);
2160
2161       menuitem = gtk_menu_item_new_with_label ("bar");
2162       gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4, TRUE));
2163       gtk_menu_item_right_justify (GTK_MENU_ITEM (menuitem));
2164       gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2165       gtk_widget_show (menuitem);
2166
2167       box2 = gtk_vbox_new (FALSE, 10);
2168       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2169       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2170       gtk_widget_show (box2);
2171
2172       menu = create_menu (1, FALSE);
2173       gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);
2174
2175       menuitem = gtk_check_menu_item_new_with_label ("Accelerate Me");
2176       gtk_menu_append (GTK_MENU (menu), menuitem);
2177       gtk_widget_show (menuitem);
2178       gtk_widget_add_accelerator (menuitem,
2179                                   "activate",
2180                                   accel_group,
2181                                   GDK_F1,
2182                                   0,
2183                                   GTK_ACCEL_VISIBLE | GTK_ACCEL_SIGNAL_VISIBLE);
2184       menuitem = gtk_check_menu_item_new_with_label ("Accelerator Locked");
2185       gtk_menu_append (GTK_MENU (menu), menuitem);
2186       gtk_widget_show (menuitem);
2187       gtk_widget_add_accelerator (menuitem,
2188                                   "activate",
2189                                   accel_group,
2190                                   GDK_F2,
2191                                   0,
2192                                   GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
2193       menuitem = gtk_check_menu_item_new_with_label ("Accelerators Frozen");
2194       gtk_menu_append (GTK_MENU (menu), menuitem);
2195       gtk_widget_show (menuitem);
2196       gtk_widget_add_accelerator (menuitem,
2197                                   "activate",
2198                                   accel_group,
2199                                   GDK_F2,
2200                                   0,
2201                                   GTK_ACCEL_VISIBLE);
2202       gtk_widget_add_accelerator (menuitem,
2203                                   "activate",
2204                                   accel_group,
2205                                   GDK_F3,
2206                                   0,
2207                                   GTK_ACCEL_VISIBLE);
2208       gtk_widget_freeze_accelerators (menuitem);
2209
2210       optionmenu = gtk_option_menu_new ();
2211       gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), menu);
2212       gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu), 3);
2213       gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0);
2214       gtk_widget_show (optionmenu);
2215
2216       separator = gtk_hseparator_new ();
2217       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2218       gtk_widget_show (separator);
2219
2220       box2 = gtk_vbox_new (FALSE, 10);
2221       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2222       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2223       gtk_widget_show (box2);
2224
2225       button = gtk_button_new_with_label ("close");
2226       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2227                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2228                                  GTK_OBJECT (window));
2229       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2230       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2231       gtk_widget_grab_default (button);
2232       gtk_widget_show (button);
2233     }
2234
2235   if (!GTK_WIDGET_VISIBLE (window))
2236     gtk_widget_show (window);
2237   else
2238     gtk_widget_destroy (window);
2239 }
2240
2241 static void
2242 gtk_ifactory_cb (gpointer             callback_data,
2243                  guint                callback_action,
2244                  GtkWidget           *widget)
2245 {
2246   g_message ("ItemFactory: activated \"%s\"", gtk_item_factory_path_from_widget (widget));
2247 }
2248
2249 static GtkItemFactoryEntry menu_items[] =
2250 {
2251   { "/_File",            NULL,         gtk_ifactory_cb,       0, "<Branch>" },
2252   { "/File/tearoff1",    NULL,         gtk_ifactory_cb,       0, "<Tearoff>" },
2253   { "/File/_New",        "<control>N", gtk_ifactory_cb,       0 },
2254   { "/File/_Open",       "<control>O", gtk_ifactory_cb,       0 },
2255   { "/File/_Save",       "<control>S", gtk_ifactory_cb,       0 },
2256   { "/File/Save _As...", NULL,         gtk_ifactory_cb,       0 },
2257   { "/File/sep1",        NULL,         gtk_ifactory_cb,       0, "<Separator>" },
2258   { "/File/_Quit",       "<control>Q", gtk_ifactory_cb,       0 },
2259
2260   { "/_Preferences",                    NULL, gtk_ifactory_cb, 0, "<Branch>" },
2261   { "/_Preferences/_Color",             NULL, gtk_ifactory_cb, 0, "<Branch>" },
2262   { "/_Preferences/Color/_Red",         NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2263   { "/_Preferences/Color/_Green",       NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2264   { "/_Preferences/Color/_Blue",        NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2265   { "/_Preferences/_Shape",             NULL, gtk_ifactory_cb, 0, "<Branch>" },
2266   { "/_Preferences/Shape/_Square",      NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2267   { "/_Preferences/Shape/_Rectangle",   NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2268   { "/_Preferences/Shape/_Oval",        NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2269
2270   { "/_Help",            NULL,         gtk_ifactory_cb,       0, "<LastBranch>" },
2271   { "/Help/_About",      NULL,         gtk_ifactory_cb,       0 },
2272 };
2273
2274 static int nmenu_items = sizeof (menu_items) / sizeof (menu_items[0]);
2275
2276 static void
2277 create_item_factory (void)
2278 {
2279   static GtkWidget *window = NULL;
2280
2281   if (!window)
2282     {
2283       GtkWidget *box1;
2284       GtkWidget *box2;
2285       GtkWidget *separator;
2286       GtkWidget *label;
2287       GtkWidget *button;
2288       GtkAccelGroup *accel_group;
2289       GtkItemFactory *item_factory;
2290
2291       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2292
2293       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2294                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2295                           &window);
2296       gtk_signal_connect (GTK_OBJECT (window), "delete-event",
2297                           GTK_SIGNAL_FUNC (gtk_true),
2298                           NULL);
2299
2300       accel_group = gtk_accel_group_new ();
2301       item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group);
2302       gtk_item_factory_create_items (item_factory, nmenu_items, menu_items, NULL);
2303       gtk_accel_group_attach (accel_group, GTK_OBJECT (window));
2304       gtk_window_set_title (GTK_WINDOW (window), "Item Factory");
2305       gtk_container_border_width (GTK_CONTAINER (window), 0);
2306
2307       box1 = gtk_vbox_new (FALSE, 0);
2308       gtk_container_add (GTK_CONTAINER (window), box1);
2309
2310       gtk_box_pack_start (GTK_BOX (box1),
2311                           gtk_item_factory_get_widget (item_factory, "<main>"),
2312                           FALSE, FALSE, 0);
2313
2314       label = gtk_label_new ("Type\n<alt>\nto start");
2315       gtk_widget_set_usize (label, 200, 200);
2316       gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5);
2317       gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
2318
2319
2320       separator = gtk_hseparator_new ();
2321       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2322
2323
2324       box2 = gtk_vbox_new (FALSE, 10);
2325       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2326       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2327
2328       button = gtk_button_new_with_label ("close");
2329       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2330                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2331                                  GTK_OBJECT (window));
2332       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2333       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2334       gtk_widget_grab_default (button);
2335
2336       gtk_widget_show_all (window);
2337     }
2338   else
2339     gtk_widget_destroy (window);
2340 }
2341
2342 /*
2343  * GtkScrolledWindow
2344  */
2345
2346 static void
2347 scrolled_windows_remove (GtkWidget *widget, GtkWidget *scrollwin)
2348 {
2349   static GtkWidget *parent = NULL;
2350   static GtkWidget *float_parent;
2351
2352   if (parent)
2353     {
2354       gtk_widget_reparent (scrollwin, parent);
2355       gtk_widget_destroy (float_parent);
2356       float_parent = NULL;
2357       parent = NULL;
2358     }
2359   else
2360     {
2361       parent = widget->parent;
2362       float_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2363       gtk_widget_reparent (scrollwin, float_parent);
2364       gtk_widget_show (float_parent);
2365     }
2366 }
2367
2368 /*
2369  create_modal_window
2370  */
2371
2372 static gboolean
2373 cmw_destroy_cb(GtkWidget *widget)
2374 {
2375   /* This is needed to get out of gtk_main */
2376   gtk_main_quit ();
2377
2378   return FALSE;
2379 }
2380
2381 static void
2382 cmw_color (GtkWidget *widget)
2383 {
2384     GtkWidget *csd;
2385
2386     csd=gtk_color_selection_dialog_new ("This is a modal color selection dialog");
2387
2388     /* Set as modal */
2389     gtk_window_set_modal (GTK_WINDOW(csd),TRUE);
2390
2391     gtk_signal_connect (GTK_OBJECT(csd), "destroy",
2392                         GTK_SIGNAL_FUNC(cmw_destroy_cb),NULL);
2393
2394     gtk_signal_connect_object (GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(csd)->ok_button),
2395                                "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
2396                                GTK_OBJECT (csd));
2397     gtk_signal_connect_object (GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(csd)->cancel_button),
2398                                "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
2399                                GTK_OBJECT (csd));
2400
2401     /* wait until destroy calls gtk_main_quit */
2402     gtk_widget_show (csd);
2403     gtk_main ();
2404 }
2405
2406 static void
2407 cmw_file (GtkWidget *widget)
2408 {
2409     GtkWidget *fs;
2410
2411     fs = gtk_file_selection_new("This is a modal file selection dialog");
2412
2413     /* Set as modal */
2414     gtk_window_set_modal (GTK_WINDOW(fs),TRUE);
2415
2416     gtk_signal_connect (GTK_OBJECT(fs), "destroy",
2417                         GTK_SIGNAL_FUNC(cmw_destroy_cb),NULL);
2418
2419     gtk_signal_connect_object (GTK_OBJECT(GTK_FILE_SELECTION(fs)->ok_button),
2420                                "clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy),
2421                                GTK_OBJECT (fs));
2422     gtk_signal_connect_object (GTK_OBJECT(GTK_FILE_SELECTION(fs)->cancel_button),
2423                                "clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy),
2424                                GTK_OBJECT (fs));
2425
2426     /* wait until destroy calls gtk_main_quit */
2427     gtk_widget_show (fs);
2428
2429     gtk_main();
2430 }
2431
2432
2433 static void
2434 create_modal_window (void)
2435 {
2436   GtkWidget *window = NULL;
2437   GtkWidget *box1,*box2;
2438   GtkWidget *frame1;
2439   GtkWidget *btnColor,*btnFile,*btnClose;
2440
2441   /* Create modal window (Here you can use any window descendent )*/
2442   window=gtk_window_new (GTK_WINDOW_TOPLEVEL);
2443   gtk_window_set_title (GTK_WINDOW(window),"This window is modal");
2444
2445   /* Set window as modal */
2446   gtk_window_set_modal (GTK_WINDOW(window),TRUE);
2447
2448   /* Create widgets */
2449   box1 = gtk_vbox_new (FALSE,5);
2450    frame1 = gtk_frame_new ("Standard dialogs in modal form");
2451     box2 = gtk_vbox_new (TRUE,5);
2452      btnColor = gtk_button_new_with_label ("Color");
2453      btnFile = gtk_button_new_with_label ("File Selection");
2454      btnClose = gtk_button_new_with_label ("Close");
2455
2456   /* Init widgets */
2457   gtk_container_border_width (GTK_CONTAINER(box1),3);
2458   gtk_container_border_width (GTK_CONTAINER(box2),3);
2459
2460   /* Pack widgets */
2461   gtk_container_add (GTK_CONTAINER (window), box1);
2462    gtk_box_pack_start (GTK_BOX (box1), frame1, TRUE, TRUE, 4);
2463     gtk_container_add (GTK_CONTAINER (frame1), box2);
2464      gtk_box_pack_start (GTK_BOX (box2), btnColor, FALSE, FALSE, 4);
2465      gtk_box_pack_start (GTK_BOX (box2), btnFile, FALSE, FALSE, 4);
2466    gtk_box_pack_start (GTK_BOX (box1), gtk_hseparator_new (), FALSE, FALSE, 4);
2467    gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4);
2468
2469   /* connect signals */
2470   gtk_signal_connect_object (GTK_OBJECT (btnClose), "clicked",
2471                              GTK_SIGNAL_FUNC (gtk_widget_destroy),
2472                              GTK_OBJECT (window));
2473
2474   gtk_signal_connect (GTK_OBJECT (window), "destroy",
2475                       GTK_SIGNAL_FUNC (cmw_destroy_cb),NULL);
2476
2477   gtk_signal_connect (GTK_OBJECT (btnColor), "clicked",
2478                       GTK_SIGNAL_FUNC (cmw_color),NULL);
2479   gtk_signal_connect (GTK_OBJECT (btnFile), "clicked",
2480                       GTK_SIGNAL_FUNC (cmw_file),NULL);
2481
2482   /* Show widgets */
2483   gtk_widget_show_all (window);
2484
2485   /* wait until dialog get destroyed */
2486   gtk_main();
2487 }
2488
2489 /*
2490  * GtkScrolledWindow
2491  */
2492
2493 static void
2494 create_scrolled_windows (void)
2495 {
2496   static GtkWidget *window;
2497   GtkWidget *scrolled_window;
2498   GtkWidget *table;
2499   GtkWidget *button;
2500   char buffer[32];
2501   int i, j;
2502
2503   if (!window)
2504     {
2505       window = gtk_dialog_new ();
2506
2507       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2508                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2509                           &window);
2510
2511       gtk_window_set_title (GTK_WINDOW (window), "dialog");
2512       gtk_container_border_width (GTK_CONTAINER (window), 0);
2513
2514
2515       scrolled_window = gtk_scrolled_window_new (NULL, NULL);
2516       gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
2517       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
2518                                       GTK_POLICY_AUTOMATIC,
2519                                       GTK_POLICY_AUTOMATIC);
2520       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
2521                           scrolled_window, TRUE, TRUE, 0);
2522       gtk_widget_show (scrolled_window);
2523
2524       table = gtk_table_new (20, 20, FALSE);
2525       gtk_table_set_row_spacings (GTK_TABLE (table), 10);
2526       gtk_table_set_col_spacings (GTK_TABLE (table), 10);
2527       gtk_container_add (GTK_CONTAINER (scrolled_window), table);
2528       gtk_container_set_focus_hadjustment (GTK_CONTAINER (table),
2529                                            gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
2530       gtk_container_set_focus_vadjustment (GTK_CONTAINER (table),
2531                                            gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
2532       gtk_widget_show (table);
2533
2534       for (i = 0; i < 20; i++)
2535         for (j = 0; j < 20; j++)
2536           {
2537             sprintf (buffer, "button (%d,%d)\n", i, j);
2538             button = gtk_toggle_button_new_with_label (buffer);
2539             gtk_table_attach_defaults (GTK_TABLE (table), button,
2540                                        i, i+1, j, j+1);
2541             gtk_widget_show (button);
2542           }
2543
2544
2545       button = gtk_button_new_with_label ("close");
2546       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2547                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2548                                  GTK_OBJECT (window));
2549       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2550       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
2551                           button, TRUE, TRUE, 0);
2552       gtk_widget_grab_default (button);
2553       gtk_widget_show (button);
2554
2555       button = gtk_button_new_with_label ("remove");
2556       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2557                                  GTK_SIGNAL_FUNC(scrolled_windows_remove),
2558                                  GTK_OBJECT (scrolled_window));
2559       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2560       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
2561                           button, TRUE, TRUE, 0);
2562       gtk_widget_grab_default (button);
2563       gtk_widget_show (button);
2564
2565     }
2566
2567   if (!GTK_WIDGET_VISIBLE (window))
2568     gtk_widget_show (window);
2569   else
2570     gtk_widget_destroy (window);
2571 }
2572
2573 /*
2574  * GtkEntry
2575  */
2576
2577 static void
2578 entry_toggle_editable (GtkWidget *checkbutton,
2579                        GtkWidget *entry)
2580 {
2581    gtk_entry_set_editable(GTK_ENTRY(entry),
2582                           GTK_TOGGLE_BUTTON(checkbutton)->active);
2583 }
2584
2585 static void
2586 entry_toggle_sensitive (GtkWidget *checkbutton,
2587                         GtkWidget *entry)
2588 {
2589    gtk_widget_set_sensitive (entry, GTK_TOGGLE_BUTTON(checkbutton)->active);
2590 }
2591
2592 static void
2593 entry_toggle_visibility (GtkWidget *checkbutton,
2594                         GtkWidget *entry)
2595 {
2596    gtk_entry_set_visibility(GTK_ENTRY(entry),
2597                          GTK_TOGGLE_BUTTON(checkbutton)->active);
2598 }
2599
2600 static void
2601 create_entry (void)
2602 {
2603   static GtkWidget *window = NULL;
2604   GtkWidget *box1;
2605   GtkWidget *box2;
2606   GtkWidget *editable_check;
2607   GtkWidget *sensitive_check;
2608   GtkWidget *entry, *cb;
2609   GtkWidget *button;
2610   GtkWidget *separator;
2611   GList *cbitems = NULL;
2612
2613   if (!window)
2614     {
2615       cbitems = g_list_append(cbitems, "item0");
2616       cbitems = g_list_append(cbitems, "item1 item1");
2617       cbitems = g_list_append(cbitems, "item2 item2 item2");
2618       cbitems = g_list_append(cbitems, "item3 item3 item3 item3");
2619       cbitems = g_list_append(cbitems, "item4 item4 item4 item4 item4");
2620       cbitems = g_list_append(cbitems, "item5 item5 item5 item5 item5 item5");
2621       cbitems = g_list_append(cbitems, "item6 item6 item6 item6 item6");
2622       cbitems = g_list_append(cbitems, "item7 item7 item7 item7");
2623       cbitems = g_list_append(cbitems, "item8 item8 item8");
2624       cbitems = g_list_append(cbitems, "item9 item9");
2625
2626       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2627
2628       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2629                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2630                           &window);
2631
2632       gtk_window_set_title (GTK_WINDOW (window), "entry");
2633       gtk_container_border_width (GTK_CONTAINER (window), 0);
2634
2635
2636       box1 = gtk_vbox_new (FALSE, 0);
2637       gtk_container_add (GTK_CONTAINER (window), box1);
2638       gtk_widget_show (box1);
2639
2640
2641       box2 = gtk_vbox_new (FALSE, 10);
2642       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2643       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2644       gtk_widget_show (box2);
2645
2646       entry = gtk_entry_new ();
2647       gtk_entry_set_text (GTK_ENTRY (entry), "hello world");
2648       gtk_editable_select_region (GTK_EDITABLE (entry), 0, 5);
2649       gtk_box_pack_start (GTK_BOX (box2), entry, TRUE, TRUE, 0);
2650       gtk_widget_show (entry);
2651
2652       cb = gtk_combo_new ();
2653       gtk_combo_set_popdown_strings (GTK_COMBO (cb), cbitems);
2654       gtk_entry_set_text (GTK_ENTRY (GTK_COMBO(cb)->entry), "hello world");
2655       gtk_editable_select_region (GTK_EDITABLE (GTK_COMBO(cb)->entry),
2656                                   0, -1);
2657       gtk_box_pack_start (GTK_BOX (box2), cb, TRUE, TRUE, 0);
2658       gtk_widget_show (cb);
2659
2660       editable_check = gtk_check_button_new_with_label("Editable");
2661       gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
2662       gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
2663                           GTK_SIGNAL_FUNC(entry_toggle_editable), entry);
2664       gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE);
2665       gtk_widget_show (editable_check);
2666
2667       editable_check = gtk_check_button_new_with_label("Visible");
2668       gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
2669       gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
2670                           GTK_SIGNAL_FUNC(entry_toggle_visibility), entry);
2671       gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE);
2672       gtk_widget_show (editable_check);
2673
2674       sensitive_check = gtk_check_button_new_with_label("Sensitive");
2675       gtk_box_pack_start (GTK_BOX (box2), sensitive_check, FALSE, TRUE, 0);
2676       gtk_signal_connect (GTK_OBJECT(sensitive_check), "toggled",
2677                           GTK_SIGNAL_FUNC(entry_toggle_sensitive), entry);
2678       gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(sensitive_check), TRUE);
2679       gtk_widget_show (sensitive_check);
2680
2681       separator = gtk_hseparator_new ();
2682       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2683       gtk_widget_show (separator);
2684
2685
2686       box2 = gtk_vbox_new (FALSE, 10);
2687       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2688       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2689       gtk_widget_show (box2);
2690
2691
2692       button = gtk_button_new_with_label ("close");
2693       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2694                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2695                                  GTK_OBJECT (window));
2696       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2697       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2698       gtk_widget_grab_default (button);
2699       gtk_widget_show (button);
2700     }
2701
2702   if (!GTK_WIDGET_VISIBLE (window))
2703     gtk_widget_show (window);
2704   else
2705     gtk_widget_destroy (window);
2706 }
2707
2708 /*
2709  * GtkSpinButton
2710  */
2711
2712 static GtkWidget *spinner1;
2713
2714 static void
2715 toggle_snap (GtkWidget *widget, GtkSpinButton *spin)
2716 {
2717   gtk_spin_button_set_snap_to_ticks (spin, GTK_TOGGLE_BUTTON (widget)->active);
2718 }
2719
2720 static void
2721 toggle_numeric (GtkWidget *widget, GtkSpinButton *spin)
2722 {
2723   gtk_spin_button_set_numeric (spin, GTK_TOGGLE_BUTTON (widget)->active);
2724 }
2725
2726 static void
2727 change_digits (GtkWidget *widget, GtkSpinButton *spin)
2728 {
2729   gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spinner1),
2730                               gtk_spin_button_get_value_as_int (spin));
2731 }
2732
2733 static void
2734 get_value (GtkWidget *widget, gpointer data)
2735 {
2736   gchar buf[32];
2737   GtkLabel *label;
2738   GtkSpinButton *spin;
2739
2740   spin = GTK_SPIN_BUTTON (spinner1);
2741   label = GTK_LABEL (gtk_object_get_user_data (GTK_OBJECT (widget)));
2742   if (GPOINTER_TO_INT (data) == 1)
2743     sprintf (buf, "%d", gtk_spin_button_get_value_as_int (spin));
2744   else
2745     sprintf (buf, "%0.*f", spin->digits,
2746              gtk_spin_button_get_value_as_float (spin));
2747   gtk_label_set (label, buf);
2748 }
2749
2750 static void
2751 create_spins (void)
2752 {
2753   static GtkWidget *window = NULL;
2754   GtkWidget *frame;
2755   GtkWidget *hbox;
2756   GtkWidget *main_vbox;
2757   GtkWidget *vbox;
2758   GtkWidget *vbox2;
2759   GtkWidget *spinner2;
2760   GtkWidget *spinner;
2761   GtkWidget *button;
2762   GtkWidget *label;
2763   GtkWidget *val_label;
2764   GtkAdjustment *adj;
2765
2766   if (!window)
2767     {
2768       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2769
2770       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2771                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
2772                           &window);
2773
2774       gtk_window_set_title (GTK_WINDOW (window), "GtkSpinButton");
2775
2776       main_vbox = gtk_vbox_new (FALSE, 5);
2777       gtk_container_border_width (GTK_CONTAINER (main_vbox), 10);
2778       gtk_container_add (GTK_CONTAINER (window), main_vbox);
2779
2780       frame = gtk_frame_new ("Not accelerated");
2781       gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
2782
2783       vbox = gtk_vbox_new (FALSE, 0);
2784       gtk_container_border_width (GTK_CONTAINER (vbox), 5);
2785       gtk_container_add (GTK_CONTAINER (frame), vbox);
2786
2787       /* Day, month, year spinners */
2788
2789       hbox = gtk_hbox_new (FALSE, 0);
2790       gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
2791
2792       vbox2 = gtk_vbox_new (FALSE, 0);
2793       gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2794
2795       label = gtk_label_new ("Day :");
2796       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2797       gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2798
2799       adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 31.0, 1.0,
2800                                                   5.0, 0.0);
2801       spinner = gtk_spin_button_new (adj, 0, 0);
2802       gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
2803       gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
2804                                        GTK_SHADOW_OUT);
2805       gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2806
2807       vbox2 = gtk_vbox_new (FALSE, 0);
2808       gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2809
2810       label = gtk_label_new ("Month :");
2811       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2812       gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2813
2814       adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 12.0, 1.0,
2815                                                   5.0, 0.0);
2816       spinner = gtk_spin_button_new (adj, 0, 0);
2817       gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
2818       gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
2819                                        GTK_SHADOW_ETCHED_IN);
2820       gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2821
2822       vbox2 = gtk_vbox_new (FALSE, 0);
2823       gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2824
2825       label = gtk_label_new ("Year :");
2826       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2827       gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2828
2829       adj = (GtkAdjustment *) gtk_adjustment_new (1998.0, 0.0, 2100.0,
2830                                                   1.0, 100.0, 0.0);
2831       spinner = gtk_spin_button_new (adj, 0, 0);
2832       gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
2833       gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
2834                                        GTK_SHADOW_IN);
2835       gtk_widget_set_usize (spinner, 55, 0);
2836       gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2837
2838       frame = gtk_frame_new ("Accelerated");
2839       gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
2840
2841       vbox = gtk_vbox_new (FALSE, 0);
2842       gtk_container_border_width (GTK_CONTAINER (vbox), 5);
2843       gtk_container_add (GTK_CONTAINER (frame), vbox);
2844
2845       hbox = gtk_hbox_new (FALSE, 0);
2846       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2847
2848       vbox2 = gtk_vbox_new (FALSE, 0);
2849       gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2850
2851       label = gtk_label_new ("Value :");
2852       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2853       gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2854
2855       adj = (GtkAdjustment *) gtk_adjustment_new (0.0, -10000.0, 10000.0,
2856                                                   0.5, 100.0, 0.0);
2857       spinner1 = gtk_spin_button_new (adj, 1.0, 2);
2858       gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner1), TRUE);
2859       gtk_widget_set_usize (spinner1, 100, 0);
2860       gtk_box_pack_start (GTK_BOX (vbox2), spinner1, FALSE, TRUE, 0);
2861
2862       vbox2 = gtk_vbox_new (FALSE, 0);
2863       gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2864
2865       label = gtk_label_new ("Digits :");
2866       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2867       gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2868
2869       adj = (GtkAdjustment *) gtk_adjustment_new (2, 1, 5, 1, 1, 0);
2870       spinner2 = gtk_spin_button_new (adj, 0.0, 0);
2871       gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner2), TRUE);
2872       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
2873                           GTK_SIGNAL_FUNC (change_digits),
2874                           (gpointer) spinner2);
2875       gtk_box_pack_start (GTK_BOX (vbox2), spinner2, FALSE, TRUE, 0);
2876
2877       hbox = gtk_hbox_new (FALSE, 0);
2878       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2879
2880       button = gtk_check_button_new_with_label ("Snap to 0.5-ticks");
2881       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2882                           GTK_SIGNAL_FUNC (toggle_snap),
2883                           spinner1);
2884       gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
2885       gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
2886
2887       button = gtk_check_button_new_with_label ("Numeric only input mode");
2888       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2889                           GTK_SIGNAL_FUNC (toggle_numeric),
2890                           spinner1);
2891       gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
2892       gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
2893
2894       val_label = gtk_label_new ("");
2895
2896       hbox = gtk_hbox_new (FALSE, 0);
2897       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2898
2899       button = gtk_button_new_with_label ("Value as Int");
2900       gtk_object_set_user_data (GTK_OBJECT (button), val_label);
2901       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2902                           GTK_SIGNAL_FUNC (get_value),
2903                           GINT_TO_POINTER (1));
2904       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2905
2906       button = gtk_button_new_with_label ("Value as Float");
2907       gtk_object_set_user_data (GTK_OBJECT (button), val_label);
2908       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2909                           GTK_SIGNAL_FUNC (get_value),
2910                           GINT_TO_POINTER (2));
2911       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2912
2913       gtk_box_pack_start (GTK_BOX (vbox), val_label, TRUE, TRUE, 0);
2914       gtk_label_set (GTK_LABEL (val_label), "0");
2915
2916       hbox = gtk_hbox_new (FALSE, 0);
2917       gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
2918
2919       button = gtk_button_new_with_label ("Close");
2920       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2921                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
2922                                  GTK_OBJECT (window));
2923       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2924     }
2925
2926   if (!GTK_WIDGET_VISIBLE (window))
2927     gtk_widget_show_all (window);
2928   else
2929     gtk_widget_destroy (window);
2930 }
2931
2932 /*
2933  * Cursors
2934  */
2935
2936 static gint
2937 cursor_expose_event (GtkWidget *widget,
2938                      GdkEvent  *event,
2939                      gpointer   user_data)
2940 {
2941   GtkDrawingArea *darea;
2942   GdkDrawable *drawable;
2943   GdkGC *black_gc;
2944   GdkGC *gray_gc;
2945   GdkGC *white_gc;
2946   guint max_width;
2947   guint max_height;
2948
2949   g_return_val_if_fail (widget != NULL, TRUE);
2950   g_return_val_if_fail (GTK_IS_DRAWING_AREA (widget), TRUE);
2951
2952   darea = GTK_DRAWING_AREA (widget);
2953   drawable = widget->window;
2954   white_gc = widget->style->white_gc;
2955   gray_gc = widget->style->bg_gc[GTK_STATE_NORMAL];
2956   black_gc = widget->style->black_gc;
2957   max_width = widget->allocation.width;
2958   max_height = widget->allocation.height;
2959
2960   gdk_draw_rectangle (drawable, white_gc,
2961                       TRUE,
2962                       0,
2963                       0,
2964                       max_width,
2965                       max_height / 2);
2966
2967   gdk_draw_rectangle (drawable, black_gc,
2968                       TRUE,
2969                       0,
2970                       max_height / 2,
2971                       max_width,
2972                       max_height / 2);
2973
2974   gdk_draw_rectangle (drawable, gray_gc,
2975                       TRUE,
2976                       max_width / 3,
2977                       max_height / 3,
2978                       max_width / 3,
2979                       max_height / 3);
2980
2981   return TRUE;
2982 }
2983
2984 static void
2985 set_cursor (GtkWidget *spinner,
2986             GtkWidget *widget)
2987 {
2988   guint c;
2989   GdkCursor *cursor;
2990   GtkWidget *label;
2991   GtkFlagValue *vals;
2992
2993   c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152);
2994   c &= 0xfe;
2995
2996   label = gtk_object_get_user_data (GTK_OBJECT (spinner));
2997   vals = gtk_type_enum_get_values (GTK_TYPE_GDK_CURSOR_TYPE);
2998   while (vals && vals->value != c)
2999     vals++;
3000   if (vals)
3001     gtk_label_set (GTK_LABEL (label), vals->value_nick);
3002   else
3003     gtk_label_set (GTK_LABEL (label), "<unknown>");
3004
3005   cursor = gdk_cursor_new (c);
3006   gdk_window_set_cursor (widget->window, cursor);
3007   gdk_cursor_destroy (cursor);
3008 }
3009
3010 static gint
3011 cursor_event (GtkWidget          *widget,
3012               GdkEvent           *event,
3013               GtkSpinButton      *spinner)
3014 {
3015   if ((event->type == GDK_BUTTON_PRESS) &&
3016       ((event->button.button == 1) ||
3017        (event->button.button == 3)))
3018     {
3019       gtk_spin_button_spin (spinner, event->button.button == 1 ?
3020                             GTK_SPIN_STEP_FORWARD : GTK_SPIN_STEP_BACKWARD, 0);
3021       return TRUE;
3022     }
3023
3024   return FALSE;
3025 }
3026
3027 static void
3028 create_cursors (void)
3029 {
3030   static GtkWidget *window = NULL;
3031   GtkWidget *frame;
3032   GtkWidget *hbox;
3033   GtkWidget *main_vbox;
3034   GtkWidget *vbox;
3035   GtkWidget *darea;
3036   GtkWidget *spinner;
3037   GtkWidget *button;
3038   GtkWidget *label;
3039   GtkWidget *any;
3040   GtkAdjustment *adj;
3041
3042   if (!window)
3043     {
3044       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3045
3046       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3047                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
3048                           &window);
3049
3050       gtk_window_set_title (GTK_WINDOW (window), "Cursors");
3051
3052       main_vbox = gtk_vbox_new (FALSE, 5);
3053       gtk_container_border_width (GTK_CONTAINER (main_vbox), 0);
3054       gtk_container_add (GTK_CONTAINER (window), main_vbox);
3055
3056       vbox =
3057         gtk_widget_new (gtk_vbox_get_type (),
3058                         "GtkBox::homogeneous", FALSE,
3059                         "GtkBox::spacing", 5,
3060                         "GtkContainer::border_width", 10,
3061                         "GtkWidget::parent", main_vbox,
3062                         "GtkWidget::visible", TRUE,
3063                         NULL);
3064
3065       hbox = gtk_hbox_new (FALSE, 0);
3066       gtk_container_border_width (GTK_CONTAINER (hbox), 5);
3067       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
3068
3069       label = gtk_label_new ("Cursor Value : ");
3070       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
3071       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
3072
3073       adj = (GtkAdjustment *) gtk_adjustment_new (0,
3074                                                   0, 152,
3075                                                   2,
3076                                                   10, 0);
3077       spinner = gtk_spin_button_new (adj, 0, 0);
3078       gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 0);
3079
3080       frame =
3081         gtk_widget_new (gtk_frame_get_type (),
3082                         "GtkFrame::shadow", GTK_SHADOW_ETCHED_IN,
3083                         "GtkFrame::label_xalign", 0.5,
3084                         "GtkFrame::label", "Cursor Area",
3085                         "GtkContainer::border_width", 10,
3086                         "GtkWidget::parent", vbox,
3087                         "GtkWidget::visible", TRUE,
3088                         NULL);
3089
3090       darea = gtk_drawing_area_new ();
3091       gtk_widget_set_usize (darea, 80, 80);
3092       gtk_container_add (GTK_CONTAINER (frame), darea);
3093       gtk_signal_connect (GTK_OBJECT (darea),
3094                           "expose_event",
3095                           GTK_SIGNAL_FUNC (cursor_expose_event),
3096                           NULL);
3097       gtk_widget_set_events (darea, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
3098       gtk_signal_connect (GTK_OBJECT (darea),
3099                           "button_press_event",
3100                           GTK_SIGNAL_FUNC (cursor_event),
3101                           spinner);
3102       gtk_widget_show (darea);
3103
3104       gtk_signal_connect (GTK_OBJECT (spinner), "changed",
3105                           GTK_SIGNAL_FUNC (set_cursor),
3106                           darea);
3107
3108       label = gtk_widget_new (GTK_TYPE_LABEL,
3109                               "visible", TRUE,
3110                               "label", "XXX",
3111                               "parent", vbox,
3112                               NULL);
3113       gtk_container_child_set (GTK_CONTAINER (vbox), label,
3114                                "expand", FALSE,
3115                                NULL);
3116       gtk_object_set_user_data (GTK_OBJECT (spinner), label);
3117
3118       any =
3119         gtk_widget_new (gtk_hseparator_get_type (),
3120                         "GtkWidget::visible", TRUE,
3121                         NULL);
3122       gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
3123
3124       hbox = gtk_hbox_new (FALSE, 0);
3125       gtk_container_border_width (GTK_CONTAINER (hbox), 10);
3126       gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
3127
3128       button = gtk_button_new_with_label ("Close");
3129       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3130                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
3131                                  GTK_OBJECT (window));
3132       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
3133
3134       gtk_widget_show_all (window);
3135
3136       set_cursor (spinner, darea);
3137     }
3138   else
3139     gtk_widget_destroy (window);
3140 }
3141
3142 /*
3143  * GtkList
3144  */
3145
3146 static void
3147 list_add (GtkWidget *widget,
3148           GtkWidget *list)
3149 {
3150   static int i = 1;
3151   gchar buffer[64];
3152   GtkWidget *list_item;
3153   GtkContainer *container;
3154
3155   container = GTK_CONTAINER (list);
3156
3157   sprintf (buffer, "added item %d", i++);
3158   list_item = gtk_list_item_new_with_label (buffer);
3159   gtk_widget_show (list_item);
3160
3161   gtk_container_add (container, list_item);
3162 }
3163
3164 static void
3165 list_remove (GtkWidget *widget,
3166              GtkWidget *list)
3167 {
3168   GList *tmp_list;
3169   GList *clear_list;
3170
3171   tmp_list = GTK_LIST (list)->selection;
3172   clear_list = NULL;
3173
3174   while (tmp_list)
3175     {
3176       clear_list = g_list_prepend (clear_list, tmp_list->data);
3177       tmp_list = tmp_list->next;
3178     }
3179
3180   clear_list = g_list_reverse (clear_list);
3181
3182   gtk_list_remove_items (GTK_LIST (list), clear_list);
3183
3184   g_list_free (clear_list);
3185 }
3186
3187 static void
3188 list_clear (GtkWidget *widget,
3189             GtkWidget *list)
3190 {
3191   gtk_list_clear_items (GTK_LIST (list), 0, -1);
3192 }
3193
3194 static void
3195 list_undo_selection (GtkWidget *widget,
3196                      GtkWidget *list)
3197 {
3198   gtk_list_undo_selection (GTK_LIST (list));
3199 }
3200
3201 #define RADIOMENUTOGGLED(_rmi_, __i) { \
3202   GSList * __g; \
3203   __i = 0; \
3204   __g = gtk_radio_menu_item_group(_rmi_); \
3205   while( __g  && !((GtkCheckMenuItem *)(__g->data))->active) { \
3206     __g = __g->next; \
3207     __i++; \
3208   }\
3209 }
3210
3211 static GtkWidget *list_omenu;
3212
3213 static void
3214 list_toggle_sel_mode (GtkWidget *widget, GtkList *list)
3215 {
3216   gint i;
3217
3218   if (!GTK_WIDGET_MAPPED (widget))
3219     return;
3220
3221   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
3222                     (((GtkOptionMenu *)list_omenu)->menu_item), i);
3223
3224   gtk_list_set_selection_mode (list, (GtkSelectionMode) (3-i));
3225 }
3226
3227 static void
3228 create_list (void)
3229 {
3230   static GtkWidget *window = NULL;
3231   GtkWidget *box1;
3232   GtkWidget *box2;
3233   GtkWidget *hbox;
3234   GtkWidget *label;
3235   GtkWidget *scrolled_win;
3236   GtkWidget *list;
3237   GtkWidget *button;
3238   GtkWidget *separator;
3239   GtkWidget *menu;
3240   GtkWidget *menu_item;
3241   GSList *group;
3242   FILE *infile;
3243
3244   if (!window)
3245     {
3246       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3247
3248       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3249                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3250                           &window);
3251
3252       gtk_window_set_title (GTK_WINDOW (window), "list");
3253       gtk_container_border_width (GTK_CONTAINER (window), 0);
3254
3255       box1 = gtk_vbox_new (FALSE, 0);
3256       gtk_container_add (GTK_CONTAINER (window), box1);
3257
3258       box2 = gtk_vbox_new (FALSE, 10);
3259       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3260       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3261
3262       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
3263       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
3264                                       GTK_POLICY_AUTOMATIC,
3265                                       GTK_POLICY_AUTOMATIC);
3266       gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
3267       gtk_widget_set_usize (scrolled_win, -1, 300);
3268
3269       list = gtk_list_new ();
3270       gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_EXTENDED);
3271       gtk_container_add (GTK_CONTAINER (scrolled_win), list);
3272       gtk_container_set_focus_vadjustment
3273         (GTK_CONTAINER (list),
3274          gtk_scrolled_window_get_vadjustment
3275          (GTK_SCROLLED_WINDOW (scrolled_win)));
3276       gtk_container_set_focus_hadjustment
3277         (GTK_CONTAINER (list),
3278          gtk_scrolled_window_get_hadjustment
3279          (GTK_SCROLLED_WINDOW (scrolled_win)));
3280
3281       if ((infile = fopen("gtkenums.h", "r")))
3282         {
3283           char buffer[256];
3284           char *pos;
3285           GtkWidget *item;
3286
3287           while (fgets (buffer, 256, infile))
3288             {
3289               if ((pos = strchr (buffer, '\n')))
3290                 *pos = 0;
3291               item = gtk_list_item_new_with_label (buffer);
3292               gtk_container_add (GTK_CONTAINER (list), item);
3293             }
3294
3295           fclose (infile);
3296         }
3297
3298       hbox = gtk_hbox_new (TRUE, 10);
3299       gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, TRUE, 0);
3300
3301       button = gtk_button_new_with_label ("Undo Selection");
3302       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3303                           GTK_SIGNAL_FUNC(list_undo_selection),
3304                           list);
3305       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3306
3307       button = gtk_button_new_with_label ("Remove Selection");
3308       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3309                           GTK_SIGNAL_FUNC (list_remove),
3310                           list);
3311       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3312
3313       button = gtk_button_new_with_label ("Clear List");
3314       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3315                           GTK_SIGNAL_FUNC (list_clear),
3316                           list);
3317       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3318
3319       hbox = gtk_hbox_new (FALSE, 10);
3320       gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, TRUE, 0);
3321
3322       button = gtk_button_new_with_label ("Insert Row");
3323       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3324                           GTK_SIGNAL_FUNC (list_add),
3325                           list);
3326       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3327
3328       label = gtk_label_new ("Selection Mode :");
3329       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3330                           GTK_SIGNAL_FUNC(list_remove),
3331                           list);
3332       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
3333
3334       list_omenu = gtk_option_menu_new ();
3335       menu = gtk_menu_new ();
3336       group = NULL;
3337
3338       menu_item = gtk_radio_menu_item_new_with_label (group, "Single");
3339       gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
3340                           GTK_SIGNAL_FUNC (list_toggle_sel_mode), list);
3341       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
3342       gtk_menu_append (GTK_MENU (menu), menu_item);
3343       gtk_widget_show (menu_item);
3344
3345       menu_item = gtk_radio_menu_item_new_with_label (group, "Browse");
3346       gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
3347                           GTK_SIGNAL_FUNC (list_toggle_sel_mode), list);
3348       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
3349       gtk_menu_append (GTK_MENU (menu), menu_item);
3350       gtk_widget_show (menu_item);
3351
3352       menu_item = gtk_radio_menu_item_new_with_label (group, "Multiple");
3353       gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
3354                       GTK_SIGNAL_FUNC (list_toggle_sel_mode), list);
3355       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
3356       gtk_menu_append (GTK_MENU (menu), menu_item);
3357       gtk_widget_show (menu_item);
3358
3359       menu_item = gtk_radio_menu_item_new_with_label (group, "Extended");
3360       gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
3361                           GTK_SIGNAL_FUNC (list_toggle_sel_mode), list);
3362       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
3363       gtk_menu_append (GTK_MENU (menu), menu_item);
3364       gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
3365       gtk_widget_show (menu_item);
3366
3367       gtk_option_menu_set_menu (GTK_OPTION_MENU (list_omenu), menu);
3368       gtk_box_pack_start (GTK_BOX (hbox), list_omenu, FALSE, TRUE, 0);
3369
3370       gtk_option_menu_set_history (GTK_OPTION_MENU (list_omenu), 3);
3371
3372       separator = gtk_hseparator_new ();
3373       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3374
3375
3376       box2 = gtk_vbox_new (FALSE, 10);
3377       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3378       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3379
3380       button = gtk_button_new_with_label ("close");
3381       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3382                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
3383                                  GTK_OBJECT (window));
3384       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3385
3386       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3387       gtk_widget_grab_default (button);
3388     }
3389
3390   if (!GTK_WIDGET_VISIBLE (window))
3391     gtk_widget_show_all (window);
3392   else
3393     gtk_widget_destroy (window);
3394 }
3395
3396 /*
3397  * GtkCList
3398  */
3399
3400 static char * book_open_xpm[] = {
3401 "16 16 4 1",
3402 "       c None s None",
3403 ".      c black",
3404 "X      c #808080",
3405 "o      c white",
3406 "                ",
3407 "  ..            ",
3408 " .Xo.    ...    ",
3409 " .Xoo. ..oo.    ",
3410 " .Xooo.Xooo...  ",
3411 " .Xooo.oooo.X.  ",
3412 " .Xooo.Xooo.X.  ",
3413 " .Xooo.oooo.X.  ",
3414 " .Xooo.Xooo.X.  ",
3415 " .Xooo.oooo.X.  ",
3416 "  .Xoo.Xoo..X.  ",
3417 "   .Xo.o..ooX.  ",
3418 "    .X..XXXXX.  ",
3419 "    ..X.......  ",
3420 "     ..         ",
3421 "                "};
3422
3423 static char * book_closed_xpm[] = {
3424 "16 16 6 1",
3425 "       c None s None",
3426 ".      c black",
3427 "X      c red",
3428 "o      c yellow",
3429 "O      c #808080",
3430 "#      c white",
3431 "                ",
3432 "       ..       ",
3433 "     ..XX.      ",
3434 "   ..XXXXX.     ",
3435 " ..XXXXXXXX.    ",
3436 ".ooXXXXXXXXX.   ",
3437 "..ooXXXXXXXXX.  ",
3438 ".X.ooXXXXXXXXX. ",
3439 ".XX.ooXXXXXX..  ",
3440 " .XX.ooXXX..#O  ",
3441 "  .XX.oo..##OO. ",
3442 "   .XX..##OO..  ",
3443 "    .X.#OO..    ",
3444 "     ..O..      ",
3445 "      ..        ",
3446 "                "};
3447
3448 static char * mini_page_xpm[] = {
3449 "16 16 4 1",
3450 "       c None s None",
3451 ".      c black",
3452 "X      c white",
3453 "o      c #808080",
3454 "                ",
3455 "   .......      ",
3456 "   .XXXXX..     ",
3457 "   .XoooX.X.    ",
3458 "   .XXXXX....   ",
3459 "   .XooooXoo.o  ",
3460 "   .XXXXXXXX.o  ",
3461 "   .XooooooX.o  ",
3462 "   .XXXXXXXX.o  ",
3463 "   .XooooooX.o  ",
3464 "   .XXXXXXXX.o  ",
3465 "   .XooooooX.o  ",
3466 "   .XXXXXXXX.o  ",
3467 "   ..........o  ",
3468 "    oooooooooo  ",
3469 "                "};
3470
3471 static char * gtk_mini_xpm[] = {
3472 "15 20 17 1",
3473 "       c None",
3474 ".      c #14121F",
3475 "+      c #278828",
3476 "@      c #9B3334",
3477 "#      c #284C72",
3478 "$      c #24692A",
3479 "%      c #69282E",
3480 "&      c #37C539",
3481 "*      c #1D2F4D",
3482 "=      c #6D7076",
3483 "-      c #7D8482",
3484 ";      c #E24A49",
3485 ">      c #515357",
3486 ",      c #9B9C9B",
3487 "'      c #2FA232",
3488 ")      c #3CE23D",
3489 "!      c #3B6CCB",
3490 "               ",
3491 "      ***>     ",
3492 "    >.*!!!*    ",
3493 "   ***....#*=  ",
3494 "  *!*.!!!**!!# ",
3495 " .!!#*!#*!!!!# ",
3496 " @%#!.##.*!!$& ",
3497 " @;%*!*.#!#')) ",
3498 " @;;@%!!*$&)'' ",
3499 " @%.%@%$'&)$+' ",
3500 " @;...@$'*'*)+ ",
3501 " @;%..@$+*.')$ ",
3502 " @;%%;;$+..$)# ",
3503 " @;%%;@$$$'.$# ",
3504 " %;@@;;$$+))&* ",
3505 "  %;;;@+$&)&*  ",
3506 "   %;;@'))+>   ",
3507 "    %;@'&#     ",
3508 "     >%$$      ",
3509 "      >=       "};
3510
3511 #define TESTGTK_CLIST_COLUMNS 20
3512 static gint clist_rows = 0;
3513 static GtkWidget *clist_omenu;
3514
3515 static void
3516 add1000_clist (GtkWidget *widget, gpointer data)
3517 {
3518   gint i, row;
3519   char text[TESTGTK_CLIST_COLUMNS][50];
3520   char *texts[TESTGTK_CLIST_COLUMNS];
3521   GdkBitmap *mask;
3522   GdkPixmap *pixmap;
3523   GtkCList  *clist;
3524
3525   clist = GTK_CLIST (data);
3526
3527   pixmap = gdk_pixmap_create_from_xpm_d (clist->clist_window,
3528                                          &mask,
3529                                          &GTK_WIDGET (data)->style->white,
3530                                          gtk_mini_xpm);
3531
3532   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3533     {
3534       texts[i] = text[i];
3535       sprintf (text[i], "Column %d", i);
3536     }
3537
3538   texts[3] = NULL;
3539   sprintf (text[1], "Right");
3540   sprintf (text[2], "Center");
3541
3542   gtk_clist_freeze (GTK_CLIST (data));
3543   for (i = 0; i < 1000; i++)
3544     {
3545       sprintf (text[0], "Row %d", rand() % 10000);
3546       row = gtk_clist_append (clist, texts);
3547       gtk_clist_set_pixtext (clist, row, 3, "gtk+", 5, pixmap, mask);
3548     }
3549
3550   gtk_clist_thaw (GTK_CLIST (data));
3551
3552   gdk_pixmap_unref (pixmap);
3553   gdk_bitmap_unref (mask);
3554 }
3555
3556 static void
3557 add10000_clist (GtkWidget *widget, gpointer data)
3558 {
3559   gint i;
3560   char text[TESTGTK_CLIST_COLUMNS][50];
3561   char *texts[TESTGTK_CLIST_COLUMNS];
3562
3563   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3564     {
3565       texts[i] = text[i];
3566       sprintf (text[i], "Column %d", i);
3567     }
3568
3569   sprintf (text[1], "Right");
3570   sprintf (text[2], "Center");
3571
3572   gtk_clist_freeze (GTK_CLIST (data));
3573   for (i = 0; i < 10000; i++)
3574     {
3575       sprintf (text[0], "Row %d", rand() % 10000 /*clist_rows++*/);
3576       gtk_clist_append (GTK_CLIST (data), texts);
3577     }
3578   gtk_clist_thaw (GTK_CLIST (data));
3579 }
3580
3581 void
3582 clear_clist (GtkWidget *widget, gpointer data)
3583 {
3584   gtk_clist_clear (GTK_CLIST (data));
3585   clist_rows = 0;
3586 }
3587
3588 void
3589 remove_row_clist (GtkWidget *widget, gpointer data)
3590 {
3591   gtk_clist_remove (GTK_CLIST (data), GTK_CLIST (data)->focus_row);
3592   clist_rows--;
3593 }
3594
3595 void
3596 show_titles_clist (GtkWidget *widget, gpointer data)
3597 {
3598   gtk_clist_column_titles_show (GTK_CLIST (data));
3599 }
3600
3601 void
3602 hide_titles_clist (GtkWidget *widget, gpointer data)
3603 {
3604   gtk_clist_column_titles_hide (GTK_CLIST (data));
3605 }
3606
3607 void
3608 select_clist (GtkWidget *widget,
3609               gint row,
3610               gint column,
3611               GdkEventButton * bevent,
3612               GtkWidget *button)
3613 {
3614   gint i;
3615   guint8 spacing;
3616   gchar *text;
3617   GdkPixmap *pixmap;
3618   GdkBitmap *mask;
3619   GList *list;
3620
3621   g_print ("GtkCList Selection: row %d column %d button %d\n",
3622            row, column, bevent ? bevent->button : 0);
3623
3624   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3625     {
3626       switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i))
3627         {
3628         case GTK_CELL_TEXT:
3629           g_print ("CELL %d GTK_CELL_TEXT\n", i);
3630           gtk_clist_get_text (GTK_CLIST (widget), row, i, &text);
3631           g_print ("TEXT: %s\n", text);
3632           break;
3633
3634         case GTK_CELL_PIXMAP:
3635           g_print ("CELL %d GTK_CELL_PIXMAP\n", i);
3636           gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask);
3637           g_print ("PIXMAP: %p\n", pixmap);
3638           g_print ("MASK: %p\n", mask);
3639           break;
3640
3641         case GTK_CELL_PIXTEXT:
3642           g_print ("CELL %d GTK_CELL_PIXTEXT\n", i);
3643           gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask);
3644           g_print ("TEXT: %s\n", text);
3645           g_print ("SPACING: %d\n", spacing);
3646           g_print ("PIXMAP: %p\n", pixmap);
3647           g_print ("MASK: %p\n", mask);
3648           break;
3649
3650         default:
3651           break;
3652         }
3653     }
3654
3655   /* print selections list */
3656   g_print ("\nSelected Rows:");
3657   list = GTK_CLIST (widget)->selection;
3658   while (list)
3659     {
3660       g_print (" %d ", GPOINTER_TO_INT (list->data));
3661       list = list->next;
3662     }
3663
3664   g_print ("\n\n\n");
3665 }
3666
3667 void
3668 unselect_clist (GtkWidget *widget,
3669                 gint row,
3670                 gint column,
3671                 GdkEventButton * bevent,
3672                 GtkWidget *button)
3673 {
3674   gint i;
3675   guint8 spacing;
3676   gchar *text;
3677   GdkPixmap *pixmap;
3678   GdkBitmap *mask;
3679   GList *list;
3680
3681   g_print ("GtkCList Unselection: row %d column %d button %d\n",
3682            row, column, bevent ? bevent->button : 0);
3683
3684   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3685     {
3686       switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i))
3687         {
3688         case GTK_CELL_TEXT:
3689           g_print ("CELL %d GTK_CELL_TEXT\n", i);
3690           gtk_clist_get_text (GTK_CLIST (widget), row, i, &text);
3691           g_print ("TEXT: %s\n", text);
3692           break;
3693
3694         case GTK_CELL_PIXMAP:
3695           g_print ("CELL %d GTK_CELL_PIXMAP\n", i);
3696           gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask);
3697           g_print ("PIXMAP: %p\n", pixmap);
3698           g_print ("MASK: %p\n", mask);
3699           break;
3700
3701         case GTK_CELL_PIXTEXT:
3702           g_print ("CELL %d GTK_CELL_PIXTEXT\n", i);
3703           gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask);
3704           g_print ("TEXT: %s\n", text);
3705           g_print ("SPACING: %d\n", spacing);
3706           g_print ("PIXMAP: %p\n", pixmap);
3707           g_print ("MASK: %p\n", mask);
3708           break;
3709
3710         default:
3711           break;
3712         }
3713     }
3714
3715   /* print selections list */
3716   g_print ("\nSelected Rows:");
3717   list = GTK_CLIST (widget)->selection;
3718   while (list)
3719     {
3720       g_print (" %d ", GPOINTER_TO_INT (list->data));
3721       list = list->next;
3722     }
3723
3724   g_print ("\n\n\n");
3725 }
3726
3727 static void
3728 insert_row_clist (GtkWidget *widget, gpointer data)
3729 {
3730   static char *text[] =
3731   {
3732     "This", "is", "a", "inserted", "row.",
3733     "This", "is", "a", "inserted", "row.",
3734     "This", "is", "a", "inserted", "row.",
3735     "This", "is", "a", "inserted", "row."
3736   };
3737
3738   static GtkStyle *style1 = NULL;
3739   static GtkStyle *style2 = NULL;
3740   static GtkStyle *style3 = NULL;
3741   gint row;
3742
3743   if (GTK_CLIST (data)->focus_row >= 0)
3744     row = gtk_clist_insert (GTK_CLIST (data), GTK_CLIST (data)->focus_row,
3745                             text);
3746   else
3747     row = gtk_clist_prepend (GTK_CLIST (data), text);
3748
3749   if (!style1)
3750     {
3751       GdkColor col1;
3752       GdkColor col2;
3753
3754       col1.red   = 0;
3755       col1.green = 56000;
3756       col1.blue  = 0;
3757       col2.red   = 32000;
3758       col2.green = 0;
3759       col2.blue  = 56000;
3760
3761       style1 = gtk_style_copy (GTK_WIDGET (data)->style);
3762       style1->bg[GTK_STATE_PRELIGHT] = col1;
3763       style1->bg[GTK_STATE_SELECTED] = col2;
3764
3765       style2 = gtk_style_copy (GTK_WIDGET (data)->style);
3766       style2->fg[GTK_STATE_PRELIGHT] = col1;
3767       style2->fg[GTK_STATE_SELECTED] = col2;
3768
3769       style3 = gtk_style_copy (GTK_WIDGET (data)->style);
3770       style3->fg[GTK_STATE_PRELIGHT] = col1;
3771       style3->bg[GTK_STATE_PRELIGHT] = col2;
3772       gdk_font_unref (style3->font);
3773       style3->font =
3774         gdk_font_load ("-*-courier-medium-*-*-*-*-120-*-*-*-*-*-*");
3775     }
3776
3777   gtk_clist_set_cell_style (GTK_CLIST (data), row, 3, style1);
3778   gtk_clist_set_cell_style (GTK_CLIST (data), row, 4, style2);
3779   gtk_clist_set_cell_style (GTK_CLIST (data), row, 0, style3);
3780
3781   clist_rows++;
3782 }
3783
3784 static void
3785 clist_warning_test (GtkWidget *button,
3786                     GtkWidget *clist)
3787 {
3788   GtkWidget *child;
3789   static gboolean add_remove = FALSE;
3790
3791   add_remove = !add_remove;
3792
3793   child = gtk_label_new ("Test");
3794   gtk_widget_ref (child);
3795   gtk_object_sink (GTK_OBJECT (child));
3796
3797   if (add_remove)
3798     gtk_container_add (GTK_CONTAINER (clist), child);
3799   else
3800     {
3801       child->parent = clist;
3802       gtk_container_remove (GTK_CONTAINER (clist), child);
3803       child->parent = NULL;
3804     }
3805
3806   gtk_widget_destroy (child);
3807   gtk_widget_unref (child);
3808 }
3809
3810 static void
3811 undo_selection (GtkWidget *button, GtkCList *clist)
3812 {
3813   gtk_clist_undo_selection (clist);
3814 }
3815
3816 static void
3817 clist_toggle_sel_mode (GtkWidget *widget, GtkCList *clist)
3818 {
3819   gint i;
3820
3821   if (!GTK_WIDGET_MAPPED (widget))
3822     return;
3823
3824   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
3825                     (((GtkOptionMenu *)clist_omenu)->menu_item), i);
3826
3827   gtk_clist_set_selection_mode (clist, (GtkSelectionMode) (3-i));
3828 }
3829
3830 static void
3831 clist_click_column (GtkCList *clist, gint column, gpointer data)
3832 {
3833   if (column == 5)
3834     gtk_clist_set_column_visibility (clist, column, FALSE);
3835   else if (column == clist->sort_column)
3836     {
3837       if (clist->sort_type == GTK_SORT_ASCENDING)
3838         clist->sort_type = GTK_SORT_DESCENDING;
3839       else
3840         clist->sort_type = GTK_SORT_ASCENDING;
3841     }
3842   else
3843     gtk_clist_set_sort_column (clist, column);
3844
3845   gtk_clist_sort (clist);
3846 }
3847
3848 static void
3849 create_clist (void)
3850 {
3851   gint i;
3852   static GtkWidget *window = NULL;
3853
3854   static char *titles[] =
3855   {
3856     "Title 0",  "Title 1",  "not resizeable", "max width 120",
3857     "min width 40", "hide column", "Title 6", "Title 7",
3858     "Title 8",  "Title 9",  "Title 10", "Title 11", "Title 12",
3859     "Title 13", "Title 14", "Title 15", "Title 16", "Title 17",
3860     "Title 18", "Title 19"
3861   };
3862
3863   static OptionMenuItem items[] =
3864   {
3865     { "Single",   clist_toggle_sel_mode },
3866     { "Browse",   clist_toggle_sel_mode },
3867     { "Multiple", clist_toggle_sel_mode },
3868     { "Extended", clist_toggle_sel_mode }
3869   };
3870
3871   char text[TESTGTK_CLIST_COLUMNS][50];
3872   char *texts[TESTGTK_CLIST_COLUMNS];
3873
3874   GtkWidget *box1;
3875   GtkWidget *box2;
3876   GtkWidget *clist;
3877   GtkWidget *button;
3878   GtkWidget *separator;
3879
3880   GtkWidget *undo_button;
3881   GtkWidget *label;
3882
3883   GtkStyle *style;
3884   GdkColor col1;
3885   GdkColor col2;
3886
3887   if (!window)
3888     {
3889       clist_rows = 0;
3890       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3891
3892       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3893                           GTK_SIGNAL_FUNC (gtk_widget_destroyed), &window);
3894
3895       gtk_window_set_title (GTK_WINDOW (window), "clist");
3896       gtk_container_border_width (GTK_CONTAINER (window), 0);
3897
3898       box1 = gtk_vbox_new (FALSE, 0);
3899       gtk_container_add (GTK_CONTAINER (window), box1);
3900
3901       box2 = gtk_hbox_new (FALSE, 10);
3902       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3903       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
3904
3905       /* create GtkCList here so we have a pointer to throw at the
3906        * button callbacks -- more is done with it later */
3907       clist = gtk_clist_new_with_titles (TESTGTK_CLIST_COLUMNS, titles);
3908       /*clist = gtk_clist_new (TESTGTK_CLIST_COLUMNS);*/
3909
3910       gtk_signal_connect (GTK_OBJECT (clist), "click_column",
3911                           (GtkSignalFunc) clist_click_column, NULL);
3912
3913       /* control buttons */
3914       button = gtk_button_new_with_label ("Add 1,000 Rows With Pixmaps");
3915       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3916
3917       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3918                           (GtkSignalFunc) add1000_clist, (gpointer) clist);
3919
3920       button = gtk_button_new_with_label ("Add 10,000 Rows");
3921       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3922
3923       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3924                           (GtkSignalFunc) add10000_clist, (gpointer) clist);
3925
3926       button = gtk_button_new_with_label ("Clear List");
3927       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3928
3929       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3930                           (GtkSignalFunc) clear_clist, (gpointer) clist);
3931
3932       button = gtk_button_new_with_label ("Remove Row");
3933       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3934
3935       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3936                           (GtkSignalFunc) remove_row_clist, (gpointer) clist);
3937
3938       /* second layer of buttons */
3939       box2 = gtk_hbox_new (FALSE, 10);
3940       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3941       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
3942
3943       button = gtk_button_new_with_label ("Insert Row");
3944       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3945
3946       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3947                           (GtkSignalFunc) insert_row_clist, (gpointer) clist);
3948
3949       button = gtk_button_new_with_label ("Show Title Buttons");
3950       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3951
3952       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3953                           (GtkSignalFunc) show_titles_clist, (gpointer) clist);
3954
3955       button = gtk_button_new_with_label ("Hide Title Buttons");
3956       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3957
3958       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3959                           (GtkSignalFunc) hide_titles_clist, (gpointer) clist);
3960
3961       button = gtk_button_new_with_label ("Warning Test");
3962       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3963
3964       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3965                           (GtkSignalFunc) clist_warning_test,(gpointer) clist);
3966
3967       box2 = gtk_hbox_new (FALSE, 10);
3968       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3969       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
3970
3971       undo_button = gtk_button_new_with_label ("Undo last selection");
3972       gtk_box_pack_start (GTK_BOX (box2), undo_button, TRUE, TRUE, 0);
3973       gtk_signal_connect (GTK_OBJECT (undo_button), "clicked",
3974                           (GtkSignalFunc) undo_selection, (gpointer) clist);
3975
3976       label = gtk_label_new ("Selection Mode :");
3977       gtk_box_pack_start (GTK_BOX (box2), label, FALSE, TRUE, 0);
3978
3979       clist_omenu = build_option_menu (items, 4, 3, clist);
3980       gtk_box_pack_start (GTK_BOX (box2), clist_omenu, FALSE, TRUE, 0);
3981
3982       /* vbox for the list itself */
3983       box2 = gtk_vbox_new (FALSE, 10);
3984       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3985       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3986
3987       /*
3988        * the rest of the clist configuration
3989        */
3990
3991       /*
3992       gtk_signal_connect (GTK_OBJECT (clist),
3993                           "select_row",
3994                           (GtkSignalFunc) select_clist,
3995                           undo_button);
3996
3997       gtk_signal_connect (GTK_OBJECT (clist),
3998                           "unselect_row",
3999                           (GtkSignalFunc) unselect_clist,
4000                           undo_button);
4001       */
4002
4003       gtk_clist_set_row_height (GTK_CLIST (clist), 18);
4004       gtk_widget_set_usize (clist, -1, 300);
4005
4006       gtk_clist_set_column_width (GTK_CLIST (clist), 0, 100);
4007
4008       for (i = 1; i < TESTGTK_CLIST_COLUMNS; i++)
4009         gtk_clist_set_column_width (GTK_CLIST (clist), i, 80);
4010
4011       gtk_clist_set_column_resizeable (GTK_CLIST (clist), 2, FALSE);
4012       gtk_clist_set_column_max_width (GTK_CLIST (clist), 3, 120);
4013       gtk_clist_set_column_min_width (GTK_CLIST (clist), 4, 40);
4014
4015       gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_EXTENDED);
4016       gtk_clist_set_policy (GTK_CLIST (clist), GTK_POLICY_AUTOMATIC,
4017                             GTK_POLICY_AUTOMATIC);
4018
4019       gtk_clist_set_column_justification (GTK_CLIST (clist), 1,
4020                                           GTK_JUSTIFY_RIGHT);
4021       gtk_clist_set_column_justification (GTK_CLIST (clist), 2,
4022                                           GTK_JUSTIFY_CENTER);
4023
4024       for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
4025         {
4026           texts[i] = text[i];
4027           sprintf (text[i], "Column %d", i);
4028         }
4029
4030       sprintf (text[1], "Right");
4031       sprintf (text[2], "Center");
4032
4033       col1.red   = 56000;
4034       col1.green = 0;
4035       col1.blue  = 0;
4036       col2.red   = 0;
4037       col2.green = 56000;
4038       col2.blue  = 32000;
4039
4040       style = gtk_style_new ();
4041       style->fg[GTK_STATE_PRELIGHT] = col1;
4042       style->bg[GTK_STATE_PRELIGHT] = col2;
4043
4044       gdk_font_unref (style->font);
4045       style->font =
4046         gdk_font_load ("-adobe-helvetica-bold-r-*-*-*-140-*-*-*-*-*-*");
4047
4048       for (i = 0; i < 10; i++)
4049         {
4050           sprintf (text[0], "Row %d", clist_rows++);
4051           gtk_clist_append (GTK_CLIST (clist), texts);
4052
4053           switch (i % 4)
4054             {
4055             case 2:
4056               gtk_clist_set_row_style (GTK_CLIST (clist), i, style);
4057               break;
4058             default:
4059               gtk_clist_set_cell_style (GTK_CLIST (clist), i, i % 4, style);
4060               break;
4061             }
4062         }
4063
4064       gtk_container_border_width (GTK_CONTAINER (clist), 5);
4065       gtk_box_pack_start (GTK_BOX (box2), clist, TRUE, TRUE, 0);
4066
4067       separator = gtk_hseparator_new ();
4068       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4069
4070       box2 = gtk_vbox_new (FALSE, 10);
4071       gtk_container_border_width (GTK_CONTAINER (box2), 10);
4072       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4073
4074       button = gtk_button_new_with_label ("close");
4075       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4076                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
4077                                  GTK_OBJECT (window));
4078
4079       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4080       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4081       gtk_widget_grab_default (button);
4082     }
4083
4084   if (!GTK_WIDGET_VISIBLE (window))
4085     gtk_widget_show_all (window);
4086   else
4087     {
4088       clist_rows = 0;
4089       gtk_widget_destroy (window);
4090     }
4091 }
4092
4093 /*
4094  * GtkCTree
4095  */
4096
4097 GdkPixmap *pixmap1;
4098 GdkPixmap *pixmap2;
4099 GdkPixmap *pixmap3;
4100 GdkBitmap *mask1;
4101 GdkBitmap *mask2;
4102 GdkBitmap *mask3;
4103
4104 static gint books = 0;
4105 static gint pages = 0;
4106
4107 static GtkWidget *book_label;
4108 static GtkWidget *page_label;
4109 static GtkWidget *sel_label;
4110 static GtkWidget *vis_label;
4111 static GtkWidget *omenu1;
4112 static GtkWidget *omenu2;
4113 static GtkWidget *omenu3;
4114 static GtkWidget *omenu4;
4115 static GtkWidget *spin1;
4116 static GtkWidget *spin2;
4117 static GtkWidget *spin3;
4118 static gint line_style;
4119
4120 void after_press (GtkCTree *ctree, gpointer data)
4121 {
4122   char buf[80];
4123
4124   sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection));
4125   gtk_label_set (GTK_LABEL (sel_label), buf);
4126
4127   sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list));
4128   gtk_label_set (GTK_LABEL (vis_label), buf);
4129
4130   sprintf (buf, "%d", books);
4131   gtk_label_set (GTK_LABEL (book_label), buf);
4132
4133   sprintf (buf, "%d", pages);
4134   gtk_label_set (GTK_LABEL (page_label), buf);
4135 }
4136
4137 void after_move (GtkCTree *ctree, GtkCTreeNode *child, GtkCTreeNode *parent,
4138                  GtkCTreeNode *sibling, gpointer data)
4139 {
4140   char *source;
4141   char *target1;
4142   char *target2;
4143
4144   gtk_ctree_get_node_info (ctree, child, &source,
4145                            NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4146   if (parent)
4147     gtk_ctree_get_node_info (ctree, parent, &target1,
4148                              NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4149   if (sibling)
4150     gtk_ctree_get_node_info (ctree, sibling, &target2,
4151                              NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4152
4153   g_print ("Moving \"%s\" to \"%s\" with sibling \"%s\".\n", source,
4154            (parent) ? target1 : "nil", (sibling) ? target2 : "nil");
4155 }
4156
4157 gint button_press (GtkCTree *ctree, GdkEventButton *event, gpointer data)
4158 {
4159   gint row;
4160   gint column;
4161   GtkCTreeNode *work;
4162   gint res;
4163
4164   res = gtk_clist_get_selection_info (GTK_CLIST (ctree), event->x, event->y,
4165                                       &row, &column);
4166   if (!res && event->button != 3)
4167     return FALSE;
4168
4169   work = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list, row));
4170
4171   switch (event->button)
4172     {
4173     case 1:
4174       if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_MULTIPLE &&
4175           event->state & GDK_SHIFT_MASK)
4176         gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),"button_press_event");
4177       break;
4178     case  2:
4179       if (GTK_CTREE_ROW (work)->children &&
4180           gtk_ctree_is_hot_spot (ctree, event->x, event->y))
4181         {
4182           if (GTK_CTREE_ROW (work)->expanded)
4183             gtk_ctree_collapse_recursive (ctree, work);
4184           else
4185             gtk_ctree_expand_recursive (ctree, work);
4186           after_press (ctree, NULL);
4187           gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),
4188                                         "button_press_event");
4189         }
4190       break;
4191     default:
4192       break;
4193     }
4194   return FALSE;
4195 }
4196
4197 gint button_release (GtkCTree *ctree, GdkEventButton *event, gpointer data)
4198 {
4199   gint row;
4200   gint column;
4201   GtkCTreeNode *work;
4202   gint res;
4203
4204   res = gtk_clist_get_selection_info (GTK_CLIST (ctree), event->x, event->y,
4205                                       &row, &column);
4206   if (!res || event->button != 1)
4207     return FALSE;
4208
4209   work = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list, row));
4210
4211   if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_MULTIPLE &&
4212       event->state & GDK_SHIFT_MASK)
4213     {
4214       if (GTK_CTREE_ROW (work)->row.state == GTK_STATE_SELECTED)
4215             gtk_ctree_unselect_recursive (ctree, work);
4216       else
4217         gtk_ctree_select_recursive (ctree, work);
4218       after_press (ctree, NULL);
4219       gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),
4220                                     "button_release_event");
4221     }
4222   return FALSE;
4223 }
4224
4225 void count_items (GtkCTree *ctree, GtkCTreeNode *list)
4226 {
4227   if (GTK_CTREE_ROW (list)->is_leaf)
4228     pages--;
4229   else
4230     books--;
4231 }
4232
4233 void expand_all (GtkWidget *widget, GtkCTree *ctree)
4234 {
4235   gtk_ctree_expand_recursive (ctree, NULL);
4236   after_press (ctree, NULL);
4237 }
4238
4239 void collapse_all (GtkWidget *widget, GtkCTree *ctree)
4240 {
4241   gtk_ctree_collapse_recursive (ctree, NULL);
4242   after_press (ctree, NULL);
4243 }
4244
4245 void select_all (GtkWidget *widget, GtkCTree *ctree)
4246 {
4247   gtk_ctree_select_recursive (ctree, NULL);
4248   after_press (ctree, NULL);
4249 }
4250
4251 void change_style (GtkWidget *widget, GtkCTree *ctree)
4252 {
4253   static GtkStyle *style1 = NULL;
4254   static GtkStyle *style2 = NULL;
4255
4256   GtkCTreeNode *node;
4257   GdkColor col1;
4258   GdkColor col2;
4259
4260   if (GTK_CLIST (ctree)->focus_row >= 0)
4261     node = GTK_CTREE_NODE
4262       (g_list_nth (GTK_CLIST (ctree)->row_list,GTK_CLIST (ctree)->focus_row));
4263   else
4264     node = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list);
4265
4266   if (!node)
4267     return;
4268
4269   if (!style1)
4270     {
4271       col1.red   = 0;
4272       col1.green = 56000;
4273       col1.blue  = 0;
4274       col2.red   = 32000;
4275       col2.green = 0;
4276       col2.blue  = 56000;
4277
4278       style1 = gtk_style_new ();
4279       style1->bg[GTK_STATE_PRELIGHT] = col1;
4280       style1->fg[GTK_STATE_SELECTED] = col2;
4281
4282       style2 = gtk_style_new ();
4283       style2->bg[GTK_STATE_SELECTED] = col2;
4284       style2->fg[GTK_STATE_PRELIGHT] = col1;
4285       style2->bg[GTK_STATE_PRELIGHT] = col2;
4286       gdk_font_unref (style2->font);
4287       style2->font =
4288         gdk_font_load ("-*-courier-medium-*-*-*-*-300-*-*-*-*-*-*");
4289     }
4290
4291   gtk_ctree_node_set_cell_style (ctree, node, 1, style1);
4292   gtk_ctree_node_set_cell_style (ctree, node, 0, style2);
4293
4294   if (GTK_CTREE_ROW (node)->children)
4295     gtk_ctree_node_set_row_style (ctree, GTK_CTREE_ROW (node)->children,
4296                                   style2);
4297
4298 }
4299
4300 void unselect_all (GtkWidget *widget, GtkCTree *ctree)
4301 {
4302   gtk_ctree_unselect_recursive (ctree, NULL);
4303   after_press (ctree, NULL);
4304 }
4305
4306 void remove_selection (GtkWidget *widget, GtkCTree *ctree)
4307 {
4308   GtkCTreeNode *work;
4309   GtkCTreeNode *new_sel;
4310   GList *selection;
4311
4312   selection = GTK_CLIST (ctree)->selection;
4313   new_sel = NULL;
4314
4315   gtk_clist_freeze (GTK_CLIST (ctree));
4316
4317   while (selection)
4318     {
4319       work = selection->data;
4320       if (GTK_CTREE_ROW (work)->is_leaf)
4321         pages--;
4322       else
4323         gtk_ctree_post_recursive (ctree, work,
4324                                   (GtkCTreeFunc) count_items, NULL);
4325
4326       if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_BROWSE)
4327         {
4328           if (GTK_CTREE_ROW (work)->children)
4329             {
4330               new_sel = GTK_CTREE_ROW (work)->sibling;
4331               if (!new_sel)
4332                 new_sel = GTK_CTREE_NODE_NEXT (work);
4333             }
4334           else
4335             {
4336               if (GTK_CTREE_NODE_NEXT (work))
4337                 new_sel = GTK_CTREE_NODE_NEXT (work);
4338               else
4339                 new_sel = GTK_CTREE_NODE_PREV (work);
4340             }
4341         }
4342
4343       gtk_ctree_remove_node (ctree, work);
4344       selection = GTK_CLIST (ctree)->selection;
4345     }
4346
4347   if (new_sel)
4348     gtk_ctree_select (ctree, new_sel);
4349
4350   gtk_clist_thaw (GTK_CLIST (ctree));
4351   after_press (ctree, NULL);
4352 }
4353
4354 struct _ExportStruct {
4355   gchar *tree;
4356   gchar *info;
4357   gboolean is_leaf;
4358 };
4359
4360 typedef struct _ExportStruct ExportStruct;
4361
4362 gboolean
4363 gnode2ctree (GtkCTree   *ctree,
4364              guint       depth,
4365              GNode        *gnode,
4366              GtkCTreeNode *cnode,
4367              gpointer    data)
4368 {
4369   ExportStruct *es;
4370   GdkPixmap *pixmap_closed;
4371   GdkBitmap *mask_closed;
4372   GdkPixmap *pixmap_opened;
4373   GdkBitmap *mask_opened;
4374
4375   if (!cnode || !gnode || (!(es = gnode->data)))
4376     return FALSE;
4377
4378   if (es->is_leaf)
4379     {
4380       pixmap_closed = pixmap3;
4381       mask_closed = mask3;
4382       pixmap_opened = NULL;
4383       mask_opened = NULL;
4384     }
4385   else
4386     {
4387       pixmap_closed = pixmap1;
4388       mask_closed = mask1;
4389       pixmap_opened = pixmap2;
4390       mask_opened = mask2;
4391     }
4392
4393   gtk_ctree_set_node_info (ctree, cnode, es->tree, 2, pixmap_closed,
4394                            mask_closed, pixmap_opened, mask_opened,
4395                            es->is_leaf, (depth < 3));
4396   gtk_ctree_node_set_text (ctree, cnode, 1, es->info);
4397   g_free (es);
4398   gnode->data = NULL;
4399
4400   return TRUE;
4401 }
4402
4403 gboolean
4404 ctree2gnode (GtkCTree   *ctree,
4405              guint       depth,
4406              GNode        *gnode,
4407              GtkCTreeNode *cnode,
4408              gpointer    data)
4409 {
4410   ExportStruct *es;
4411
4412   if (!cnode || !gnode)
4413     return FALSE;
4414
4415   es = g_new (ExportStruct, 1);
4416   gnode->data = es;
4417   es->is_leaf = GTK_CTREE_ROW (cnode)->is_leaf;
4418   es->tree = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[0])->text;
4419   es->info = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[1])->text;
4420   return TRUE;
4421 }
4422
4423 void export_ctree (GtkWidget *widget, GtkCTree *ctree)
4424 {
4425   char *title[] = { "Tree" , "Info" };
4426   static GtkWidget *export_window = NULL;
4427   static GtkCTree *export_ctree;
4428   GtkWidget *vbox;
4429   GtkWidget *button;
4430   GtkWidget *sep;
4431   GNode *gnode;
4432   GtkCTreeNode *node;
4433
4434   if (!export_window)
4435     {
4436       export_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4437
4438       gtk_signal_connect (GTK_OBJECT (export_window), "destroy",
4439                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
4440                           &export_window);
4441
4442       gtk_window_set_title (GTK_WINDOW (export_window), "exported ctree");
4443       gtk_container_border_width (GTK_CONTAINER (export_window), 5);
4444
4445       vbox = gtk_vbox_new (FALSE, 0);
4446       gtk_container_add (GTK_CONTAINER (export_window), vbox);
4447
4448       button = gtk_button_new_with_label ("Close");
4449       gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, TRUE, 0);
4450
4451       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4452                                  (GtkSignalFunc) gtk_widget_destroy,
4453                                  GTK_OBJECT(export_window));
4454
4455       sep = gtk_hseparator_new ();
4456       gtk_box_pack_end (GTK_BOX (vbox), sep, FALSE, TRUE, 10);
4457
4458       export_ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title));
4459       gtk_ctree_set_line_style (export_ctree, GTK_CTREE_LINES_DOTTED);
4460
4461       gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (export_ctree),
4462                           TRUE, TRUE, 0);
4463       gtk_clist_set_selection_mode (GTK_CLIST (export_ctree),
4464                                     GTK_SELECTION_EXTENDED);
4465       gtk_clist_set_policy (GTK_CLIST (export_ctree), GTK_POLICY_ALWAYS,
4466                             GTK_POLICY_AUTOMATIC);
4467       gtk_clist_set_column_width (GTK_CLIST (export_ctree), 0, 200);
4468       gtk_clist_set_column_width (GTK_CLIST (export_ctree), 1, 200);
4469       gtk_widget_set_usize (GTK_WIDGET (export_ctree), 300, 200);
4470     }
4471
4472   if (!GTK_WIDGET_VISIBLE (export_window))
4473     gtk_widget_show_all (export_window);
4474
4475   gtk_clist_clear (GTK_CLIST (export_ctree));
4476
4477   node = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list,
4478                                      GTK_CLIST (ctree)->focus_row));
4479   if (!node)
4480     return;
4481
4482   gnode = gtk_ctree_export_to_gnode (ctree, NULL, NULL, node,
4483                                      ctree2gnode, NULL);
4484   if (gnode)
4485     {
4486       gtk_ctree_insert_gnode (export_ctree, NULL, NULL, gnode,
4487                               gnode2ctree, NULL);
4488       g_node_destroy (gnode);
4489     }
4490 }
4491
4492 void change_indent (GtkWidget *widget, GtkCTree *ctree)
4493 {
4494   gtk_ctree_set_indent (ctree, GTK_ADJUSTMENT (widget)->value);
4495 }
4496
4497 void change_spacing (GtkWidget *widget, GtkCTree *ctree)
4498 {
4499   gtk_ctree_set_spacing (ctree, GTK_ADJUSTMENT (widget)->value);
4500 }
4501
4502 void change_row_height (GtkWidget *widget, GtkCList *clist)
4503 {
4504   gtk_clist_set_row_height (clist, GTK_ADJUSTMENT (widget)->value);
4505 }
4506
4507 void toggle_reorderable (GtkWidget *widget, GtkCTree *ctree)
4508 {
4509   gtk_ctree_set_reorderable (ctree, GTK_TOGGLE_BUTTON (widget)->active);
4510 }
4511
4512 void set_background (GtkCTree *ctree, GtkCTreeNode *node, gpointer data)
4513 {
4514   GtkStyle *style = NULL;
4515
4516   if (!node)
4517     return;
4518
4519   if (ctree->line_style != GTK_CTREE_LINES_TABBED)
4520     {
4521       if (!GTK_CTREE_ROW (node)->is_leaf)
4522         style = GTK_CTREE_ROW (node)->row.data;
4523       else if (GTK_CTREE_ROW (node)->parent)
4524         style = GTK_CTREE_ROW (GTK_CTREE_ROW (node)->parent)->row.data;
4525     }
4526
4527   gtk_ctree_node_set_row_style (ctree, node, style);
4528 }
4529
4530 void ctree_toggle_line_style (GtkWidget *widget, GtkCTree *ctree)
4531 {
4532   gint i;
4533
4534   if (!GTK_WIDGET_MAPPED (widget))
4535     return;
4536
4537   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4538                     (((GtkOptionMenu *)omenu1)->menu_item), i);
4539
4540   if ((ctree->line_style == GTK_CTREE_LINES_TABBED &&
4541        ((GtkCTreeLineStyle) (3 - i)) != GTK_CTREE_LINES_TABBED) ||
4542       (ctree->line_style != GTK_CTREE_LINES_TABBED &&
4543        ((GtkCTreeLineStyle) (3 - i)) == GTK_CTREE_LINES_TABBED))
4544     gtk_ctree_pre_recursive (ctree, NULL, set_background, NULL);
4545   gtk_ctree_set_line_style (ctree, 3 - i);
4546   line_style = 3 - i;
4547 }
4548
4549 void ctree_toggle_expander_style (GtkWidget *widget, GtkCTree *ctree)
4550 {
4551   gint i;
4552
4553   if (!GTK_WIDGET_MAPPED (widget))
4554     return;
4555
4556   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4557                     (((GtkOptionMenu *)omenu2)->menu_item), i);
4558
4559   gtk_ctree_set_expander_style (ctree, (GtkCTreeExpanderStyle) (3 - i));
4560 }
4561
4562 void ctree_toggle_justify (GtkWidget *widget, GtkCTree *ctree)
4563 {
4564   gint i;
4565
4566   if (!GTK_WIDGET_MAPPED (widget))
4567     return;
4568
4569   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4570                     (((GtkOptionMenu *)omenu3)->menu_item), i);
4571
4572   gtk_clist_set_column_justification (GTK_CLIST (ctree), ctree->tree_column,
4573                                       (GtkJustification) (1 - i));
4574 }
4575
4576 void ctree_toggle_sel_mode (GtkWidget *widget, GtkCTree *ctree)
4577 {
4578   gint i;
4579
4580   if (!GTK_WIDGET_MAPPED (widget))
4581     return;
4582
4583   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4584                     (((GtkOptionMenu *)omenu4)->menu_item), i);
4585
4586   gtk_clist_set_selection_mode (GTK_CLIST (ctree), (GtkSelectionMode) (3 - i));
4587   after_press (ctree, NULL);
4588 }
4589
4590 void build_recursive (GtkCTree *ctree, gint cur_depth, gint depth,
4591                       gint num_books, gint num_pages, GtkCTreeNode *parent)
4592 {
4593   gchar *text[2];
4594   gchar buf1[60];
4595   gchar buf2[60];
4596   GtkCTreeNode *sibling;
4597   gint i;
4598
4599   text[0] = buf1;
4600   text[1] = buf2;
4601   sibling = NULL;
4602
4603   for (i = num_pages + num_books; i > num_books; i--)
4604     {
4605       pages++;
4606       sprintf (buf1, "Page %02d", (gint) rand() % 100);
4607       sprintf (buf2, "Item %d-%d", cur_depth, i);
4608       sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
4609                                        pixmap3, mask3, NULL, NULL,
4610                                        TRUE, FALSE);
4611
4612       if (parent && ctree->line_style == GTK_CTREE_LINES_TABBED)
4613         gtk_ctree_node_set_row_style (ctree, sibling,
4614                                       GTK_CTREE_ROW (parent)->row.style);
4615     }
4616
4617   if (cur_depth == depth)
4618     return;
4619
4620   for (i = num_books; i > 0; i--)
4621     {
4622       GtkStyle *style;
4623
4624       books++;
4625       sprintf (buf1, "Book %02d", (gint) rand() % 100);
4626       sprintf (buf2, "Item %d-%d", cur_depth, i);
4627       sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
4628                                        pixmap1, mask1, pixmap2, mask2,
4629                                        FALSE, FALSE);
4630
4631       style = gtk_style_new();
4632       switch (cur_depth % 3)
4633         {
4634         case 0:
4635           style->bg[GTK_STATE_PRELIGHT].red   = 10000 * (cur_depth % 6);
4636           style->bg[GTK_STATE_PRELIGHT].green = 0;
4637           style->bg[GTK_STATE_PRELIGHT].blue  = 65535 - ((i * 10000) % 65535);
4638           break;
4639         case 1:
4640           style->bg[GTK_STATE_PRELIGHT].red   = 10000 * (cur_depth % 6);
4641           style->bg[GTK_STATE_PRELIGHT].green = 65535 - ((i * 10000) % 65535);
4642           style->bg[GTK_STATE_PRELIGHT].blue  = 0;
4643           break;
4644         default:
4645           style->bg[GTK_STATE_PRELIGHT].red   = 65535 - ((i * 10000) % 65535);
4646           style->bg[GTK_STATE_PRELIGHT].green = 0;
4647           style->bg[GTK_STATE_PRELIGHT].blue  = 10000 * (cur_depth % 6);
4648           break;
4649         }
4650       gtk_ctree_node_set_row_data_full (ctree, sibling, style,
4651                                         (GtkDestroyNotify) gtk_style_unref);
4652
4653       if (ctree->line_style == GTK_CTREE_LINES_TABBED)
4654         gtk_ctree_node_set_row_style (ctree, sibling, style);
4655
4656       build_recursive (ctree, cur_depth + 1, depth, num_books, num_pages,
4657                        sibling);
4658     }
4659 }
4660
4661 void rebuild_tree (GtkWidget *widget, GtkCTree *ctree)
4662 {
4663   gchar *text [2];
4664   gchar label1[] = "Root";
4665   gchar label2[] = "";
4666   GtkCTreeNode *parent;
4667   GtkStyle *style;
4668   guint b, d, p, n;
4669
4670   text[0] = label1;
4671   text[1] = label2;
4672
4673   d = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin1));
4674   b = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin2));
4675   p = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin3));
4676
4677   n = ((pow (b, d) - 1) / (b - 1)) * (p + 1);
4678
4679   if (n > 100000)
4680     {
4681       g_print ("%d total items? Try less\n",n);
4682       return;
4683     }
4684
4685   gtk_clist_freeze (GTK_CLIST (ctree));
4686   gtk_clist_clear (GTK_CLIST (ctree));
4687
4688   books = 1;
4689   pages = 0;
4690
4691   parent = gtk_ctree_insert_node (ctree, NULL, NULL, text, 5, pixmap1,
4692                                   mask1, pixmap2, mask2, FALSE, TRUE);
4693
4694   style = gtk_style_new ();
4695   style->bg[GTK_STATE_PRELIGHT].red   = 0;
4696   style->bg[GTK_STATE_PRELIGHT].green = 45000;
4697   style->bg[GTK_STATE_PRELIGHT].blue  = 55000;
4698   gtk_ctree_node_set_row_data_full (ctree, parent, style,
4699                                     (GtkDestroyNotify) gtk_style_unref);
4700
4701   if (ctree->line_style == GTK_CTREE_LINES_TABBED)
4702     gtk_ctree_node_set_row_style (ctree, parent, style);
4703
4704   build_recursive (ctree, 1, d, b, p, parent);
4705   gtk_clist_thaw (GTK_CLIST (ctree));
4706   after_press (ctree, NULL);
4707 }
4708
4709 static void
4710 ctree_click_column (GtkCTree *ctree, gint column, gpointer data)
4711 {
4712   GtkCList *clist;
4713
4714   clist = GTK_CLIST (ctree);
4715
4716   if (column == clist->sort_column)
4717     {
4718       if (clist->sort_type == GTK_SORT_ASCENDING)
4719         clist->sort_type = GTK_SORT_DESCENDING;
4720       else
4721         clist->sort_type = GTK_SORT_ASCENDING;
4722     }
4723   else
4724     gtk_clist_set_sort_column (clist, column);
4725
4726   gtk_ctree_sort_recursive (ctree, NULL);
4727 }
4728
4729 void create_ctree (void)
4730 {
4731   static GtkWidget *window = NULL;
4732   GtkTooltips *tooltips;
4733   GtkCTree *ctree;
4734   GtkWidget *vbox;
4735   GtkWidget *bbox;
4736   GtkWidget *mbox;
4737   GtkWidget *hbox;
4738   GtkWidget *hbox2;
4739   GtkWidget *frame;
4740   GtkWidget *label;
4741   GtkWidget *button;
4742   GtkWidget *check;
4743   GtkAdjustment *adj;
4744   GtkWidget *spinner;
4745   GdkColor transparent;
4746
4747   char *title[] = { "Tree" , "Info" };
4748   char buf[80];
4749
4750   static OptionMenuItem items1[] =
4751   {
4752     { "No lines", ctree_toggle_line_style },
4753     { "Solid",    ctree_toggle_line_style },
4754     { "Dotted",   ctree_toggle_line_style },
4755     { "Tabbed",   ctree_toggle_line_style }
4756   };
4757
4758   static OptionMenuItem items2[] =
4759   {
4760     { "None",     ctree_toggle_expander_style },
4761     { "Square",   ctree_toggle_expander_style },
4762     { "Triangle", ctree_toggle_expander_style },
4763     { "Circular", ctree_toggle_expander_style }
4764   };
4765
4766   static OptionMenuItem items3[] =
4767   {
4768     { "Left",  ctree_toggle_justify },
4769     { "Right", ctree_toggle_justify }
4770   };
4771
4772   static OptionMenuItem items4[] =
4773   {
4774     { "Single",   ctree_toggle_sel_mode },
4775     { "Browse",   ctree_toggle_sel_mode },
4776     { "Multiple", ctree_toggle_sel_mode },
4777     { "Extended", ctree_toggle_sel_mode }
4778   };
4779
4780   if (!window)
4781     {
4782       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4783
4784       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4785                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
4786                           &window);
4787
4788       gtk_window_set_title (GTK_WINDOW (window), "GtkCTree");
4789       gtk_container_border_width (GTK_CONTAINER (window), 0);
4790
4791       tooltips = gtk_tooltips_new ();
4792       gtk_object_ref (GTK_OBJECT (tooltips));
4793       gtk_object_sink (GTK_OBJECT (tooltips));
4794
4795       gtk_object_set_data_full (GTK_OBJECT (window), "tooltips", tooltips,
4796                                 (GtkDestroyNotify) gtk_object_unref);
4797
4798       vbox = gtk_vbox_new (FALSE, 0);
4799       gtk_container_add (GTK_CONTAINER (window), vbox);
4800
4801       hbox = gtk_hbox_new (FALSE, 5);
4802       gtk_container_border_width (GTK_CONTAINER (hbox), 5);
4803       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4804
4805       label = gtk_label_new ("Depth :");
4806       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4807
4808       adj = (GtkAdjustment *) gtk_adjustment_new (4, 1, 10, 1, 5, 0);
4809       spin1 = gtk_spin_button_new (adj, 0, 0);
4810       gtk_box_pack_start (GTK_BOX (hbox), spin1, FALSE, TRUE, 5);
4811
4812       label = gtk_label_new ("Books :");
4813       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4814
4815       adj = (GtkAdjustment *) gtk_adjustment_new (3, 1, 20, 1, 5, 0);
4816       spin2 = gtk_spin_button_new (adj, 0, 0);
4817       gtk_box_pack_start (GTK_BOX (hbox), spin2, FALSE, TRUE, 5);
4818
4819       label = gtk_label_new ("Pages :");
4820       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4821
4822       adj = (GtkAdjustment *) gtk_adjustment_new (5, 1, 20, 1, 5, 0);
4823       spin3 = gtk_spin_button_new (adj, 0, 0);
4824       gtk_box_pack_start (GTK_BOX (hbox), spin3, FALSE, TRUE, 5);
4825
4826       button = gtk_button_new_with_label ("Close");
4827       gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4828
4829       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4830                                  (GtkSignalFunc) gtk_widget_destroy,
4831                                  GTK_OBJECT(window));
4832
4833       button = gtk_button_new_with_label ("Rebuild tree");
4834       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4835
4836       ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title));
4837       gtk_ctree_set_line_style (ctree, GTK_CTREE_LINES_DOTTED);
4838       line_style = GTK_CTREE_LINES_DOTTED;
4839
4840       gtk_ctree_set_reorderable (ctree, TRUE);
4841       gtk_signal_connect (GTK_OBJECT (ctree), "click_column",
4842                           (GtkSignalFunc) ctree_click_column,
4843                           NULL);
4844       gtk_signal_connect (GTK_OBJECT (ctree), "button_press_event",
4845                           GTK_SIGNAL_FUNC (button_press), NULL);
4846       gtk_signal_connect_after (GTK_OBJECT (ctree), "button_press_event",
4847                                 GTK_SIGNAL_FUNC (after_press), NULL);
4848       gtk_signal_connect (GTK_OBJECT (ctree), "button_release_event",
4849                           GTK_SIGNAL_FUNC (button_release), NULL);
4850       gtk_signal_connect_after (GTK_OBJECT (ctree), "button_release_event",
4851                                 GTK_SIGNAL_FUNC (after_press), NULL);
4852       gtk_signal_connect_after (GTK_OBJECT (ctree), "tree_move",
4853                                 GTK_SIGNAL_FUNC (after_move), NULL);
4854       gtk_signal_connect_after (GTK_OBJECT (ctree), "end_selection",
4855                                 GTK_SIGNAL_FUNC (after_press), NULL);
4856       gtk_signal_connect_after (GTK_OBJECT (ctree), "toggle_focus_row",
4857                                 GTK_SIGNAL_FUNC (after_press), NULL);
4858       gtk_signal_connect_after (GTK_OBJECT (ctree), "select_all",
4859                                 GTK_SIGNAL_FUNC (after_press), NULL);
4860       gtk_signal_connect_after (GTK_OBJECT (ctree), "unselect_all",
4861                                 GTK_SIGNAL_FUNC (after_press), NULL);
4862       gtk_signal_connect_after (GTK_OBJECT (ctree), "scroll_vertical",
4863                                 GTK_SIGNAL_FUNC (after_press), NULL);
4864
4865       gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (ctree), TRUE, TRUE, 0);
4866       gtk_clist_set_selection_mode (GTK_CLIST (ctree), GTK_SELECTION_EXTENDED);
4867       gtk_clist_set_policy (GTK_CLIST (ctree), GTK_POLICY_ALWAYS,
4868                             GTK_POLICY_AUTOMATIC);
4869       gtk_clist_set_column_width (GTK_CLIST (ctree), 0, 200);
4870       gtk_clist_set_column_width (GTK_CLIST (ctree), 1, 200);
4871
4872       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4873                           GTK_SIGNAL_FUNC (rebuild_tree), ctree);
4874
4875       bbox = gtk_hbox_new (FALSE, 5);
4876       gtk_container_border_width (GTK_CONTAINER (bbox), 5);
4877       gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, TRUE, 0);
4878
4879       mbox = gtk_vbox_new (TRUE, 5);
4880       gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
4881
4882       label = gtk_label_new ("Row height :");
4883       gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
4884
4885       label = gtk_label_new ("Indent :");
4886       gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
4887
4888       label = gtk_label_new ("Spacing :");
4889       gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
4890
4891       mbox = gtk_vbox_new (TRUE, 5);
4892       gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
4893
4894       adj = (GtkAdjustment *) gtk_adjustment_new (20, 12, 100, 1, 10, 0);
4895       spinner = gtk_spin_button_new (adj, 0, 0);
4896       gtk_tooltips_set_tip (tooltips, spinner,
4897                             "Row height of list items", NULL);
4898       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
4899                           GTK_SIGNAL_FUNC (change_row_height), ctree);
4900       gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
4901       gtk_clist_set_row_height ( GTK_CLIST (ctree), adj->value);
4902
4903       adj = (GtkAdjustment *) gtk_adjustment_new (20, 0, 60, 1, 10, 0);
4904       spinner = gtk_spin_button_new (adj, 0, 0);
4905       gtk_tooltips_set_tip (tooltips, spinner, "Tree indentation.", NULL);
4906       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
4907                           GTK_SIGNAL_FUNC (change_indent), ctree);
4908       gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
4909
4910       adj = (GtkAdjustment *) gtk_adjustment_new (5, 0, 60, 1, 10, 0);
4911       spinner = gtk_spin_button_new (adj, 0, 0);
4912       gtk_tooltips_set_tip (tooltips, spinner, "Tree spacing.", NULL);
4913       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
4914                           GTK_SIGNAL_FUNC (change_spacing), ctree);
4915       gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
4916
4917       mbox = gtk_vbox_new (TRUE, 5);
4918       gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
4919
4920       hbox = gtk_hbox_new (FALSE, 5);
4921       gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
4922
4923       button = gtk_button_new_with_label ("Expand all");
4924       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4925                           GTK_SIGNAL_FUNC (expand_all), ctree);
4926       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4927
4928       button = gtk_button_new_with_label ("Collapse all");
4929       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4930                           GTK_SIGNAL_FUNC (collapse_all), ctree);
4931       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4932
4933       button = gtk_button_new_with_label ("Change Style");
4934       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4935                           GTK_SIGNAL_FUNC (change_style), ctree);
4936       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4937
4938       button = gtk_button_new_with_label ("Export tree");
4939       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4940                           GTK_SIGNAL_FUNC (export_ctree), ctree);
4941       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4942
4943       hbox = gtk_hbox_new (FALSE, 5);
4944       gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
4945
4946       button = gtk_button_new_with_label ("Select all");
4947       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4948                           GTK_SIGNAL_FUNC (select_all), ctree);
4949       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4950
4951       button = gtk_button_new_with_label ("Unselect all");
4952       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4953                           GTK_SIGNAL_FUNC (unselect_all), ctree);
4954       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4955
4956       button = gtk_button_new_with_label ("Remove selection");
4957       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4958                           GTK_SIGNAL_FUNC (remove_selection), ctree);
4959       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4960
4961       check = gtk_check_button_new_with_label ("Reorderable");
4962       gtk_tooltips_set_tip (tooltips, check,
4963                             "Tree items can be reordered by dragging.", NULL);
4964       gtk_signal_connect (GTK_OBJECT (check), "clicked",
4965                           GTK_SIGNAL_FUNC (toggle_reorderable), ctree);
4966       gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
4967       gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (check), TRUE);
4968
4969       hbox = gtk_hbox_new (TRUE, 5);
4970       gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
4971
4972       omenu1 = build_option_menu (items1, 4, 2, ctree);
4973       gtk_tooltips_set_tip (tooltips, omenu1, "The tree's line style.", NULL);
4974       gtk_box_pack_start (GTK_BOX (hbox), omenu1, FALSE, TRUE, 0);
4975
4976       omenu2 = build_option_menu (items2, 4, 1, ctree);
4977       gtk_tooltips_set_tip (tooltips, omenu2, "The tree's expander style.",
4978                             NULL);
4979       gtk_box_pack_start (GTK_BOX (hbox), omenu2, FALSE, TRUE, 0);
4980
4981       omenu3 = build_option_menu (items3, 2, 0, ctree);
4982       gtk_tooltips_set_tip (tooltips, omenu3, "The tree's justification.",
4983                             NULL);
4984       gtk_box_pack_start (GTK_BOX (hbox), omenu3, FALSE, TRUE, 0);
4985
4986       omenu4 = build_option_menu (items4, 4, 3, ctree);
4987       gtk_tooltips_set_tip (tooltips, omenu4, "The list's selection mode.",
4988                             NULL);
4989       gtk_box_pack_start (GTK_BOX (hbox), omenu4, FALSE, TRUE, 0);
4990
4991       gtk_widget_realize (window);
4992
4993       pixmap1 = gdk_pixmap_create_from_xpm_d (window->window, &mask1,
4994                                               &transparent, book_closed_xpm);
4995       pixmap2 = gdk_pixmap_create_from_xpm_d (window->window, &mask2,
4996                                               &transparent, book_open_xpm);
4997       pixmap3 = gdk_pixmap_create_from_xpm_d (window->window, &mask3,
4998                                               &transparent, mini_page_xpm);
4999
5000       gtk_widget_set_usize (GTK_WIDGET (ctree), 0, 300);
5001
5002       frame = gtk_frame_new (NULL);
5003       gtk_container_border_width (GTK_CONTAINER (frame), 0);
5004       gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
5005       gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
5006
5007       hbox = gtk_hbox_new (TRUE, 2);
5008       gtk_container_border_width (GTK_CONTAINER (hbox), 2);
5009       gtk_container_add (GTK_CONTAINER (frame), hbox);
5010
5011       frame = gtk_frame_new (NULL);
5012       gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
5013       gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
5014
5015       hbox2 = gtk_hbox_new (FALSE, 0);
5016       gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
5017       gtk_container_add (GTK_CONTAINER (frame), hbox2);
5018
5019       label = gtk_label_new ("Books :");
5020       gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
5021
5022       sprintf (buf, "%d", books);
5023       book_label = gtk_label_new (buf);
5024       gtk_box_pack_end (GTK_BOX (hbox2), book_label, FALSE, TRUE, 5);
5025
5026       frame = gtk_frame_new (NULL);
5027       gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
5028       gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
5029
5030       hbox2 = gtk_hbox_new (FALSE, 0);
5031       gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
5032       gtk_container_add (GTK_CONTAINER (frame), hbox2);
5033
5034       label = gtk_label_new ("Pages :");
5035       gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
5036
5037       sprintf (buf, "%d", pages);
5038       page_label = gtk_label_new (buf);
5039       gtk_box_pack_end (GTK_BOX (hbox2), page_label, FALSE, TRUE, 5);
5040
5041       frame = gtk_frame_new (NULL);
5042       gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
5043       gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
5044
5045       hbox2 = gtk_hbox_new (FALSE, 0);
5046       gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
5047       gtk_container_add (GTK_CONTAINER (frame), hbox2);
5048
5049       label = gtk_label_new ("Selected :");
5050       gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
5051
5052       sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection));
5053       sel_label = gtk_label_new (buf);
5054       gtk_box_pack_end (GTK_BOX (hbox2), sel_label, FALSE, TRUE, 5);
5055
5056       frame = gtk_frame_new (NULL);
5057       gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
5058       gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
5059
5060       hbox2 = gtk_hbox_new (FALSE, 0);
5061       gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
5062       gtk_container_add (GTK_CONTAINER (frame), hbox2);
5063
5064       label = gtk_label_new ("Visible :");
5065       gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
5066
5067       sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list));
5068       vis_label = gtk_label_new (buf);
5069       gtk_box_pack_end (GTK_BOX (hbox2), vis_label, FALSE, TRUE, 5);
5070
5071       rebuild_tree (NULL, ctree);
5072     }
5073
5074   if (!GTK_WIDGET_VISIBLE (window))
5075     gtk_widget_show_all (window);
5076   else
5077     gtk_widget_destroy (window);
5078 }
5079
5080 /*
5081  * GtkColorSelection
5082  */
5083
5084 void
5085 color_selection_ok (GtkWidget               *w,
5086                     GtkColorSelectionDialog *cs)
5087 {
5088   GtkColorSelection *colorsel;
5089   gdouble color[4];
5090
5091   colorsel=GTK_COLOR_SELECTION(cs->colorsel);
5092
5093   gtk_color_selection_get_color(colorsel,color);
5094   gtk_color_selection_set_color(colorsel,color);
5095 }
5096
5097 void
5098 color_selection_changed (GtkWidget *w,
5099                          GtkColorSelectionDialog *cs)
5100 {
5101   GtkColorSelection *colorsel;
5102   gdouble color[4];
5103
5104   colorsel=GTK_COLOR_SELECTION(cs->colorsel);
5105   gtk_color_selection_get_color(colorsel,color);
5106 }
5107
5108 void
5109 create_color_selection (void)
5110 {
5111   static GtkWidget *window = NULL;
5112
5113   if (!window)
5114     {
5115       window = gtk_color_selection_dialog_new ("color selection dialog");
5116
5117       gtk_color_selection_set_opacity (
5118         GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
5119         TRUE);
5120
5121       gtk_color_selection_set_update_policy(
5122         GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
5123         GTK_UPDATE_CONTINUOUS);
5124
5125       gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
5126
5127       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5128                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5129                           &window);
5130
5131       gtk_signal_connect (
5132         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
5133         "color_changed",
5134         GTK_SIGNAL_FUNC(color_selection_changed),
5135         window);
5136
5137       gtk_signal_connect (
5138         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->ok_button),
5139         "clicked",
5140         GTK_SIGNAL_FUNC(color_selection_ok),
5141         window);
5142
5143       gtk_signal_connect_object (
5144         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->cancel_button),
5145         "clicked",
5146         GTK_SIGNAL_FUNC(gtk_widget_destroy),
5147         GTK_OBJECT (window));
5148     }
5149
5150   if (!GTK_WIDGET_VISIBLE (window))
5151     gtk_widget_show (window);
5152   else
5153     gtk_widget_destroy (window);
5154 }
5155
5156 /*
5157  * GtkFileSelection
5158  */
5159
5160 void
5161 file_selection_hide_fileops (GtkWidget *widget,
5162                              GtkFileSelection *fs)
5163 {
5164   gtk_file_selection_hide_fileop_buttons (fs);
5165 }
5166
5167 void
5168 file_selection_ok (GtkWidget        *w,
5169                    GtkFileSelection *fs)
5170 {
5171   g_print ("%s\n", gtk_file_selection_get_filename (fs));
5172   gtk_widget_destroy (GTK_WIDGET (fs));
5173 }
5174
5175 void
5176 create_file_selection (void)
5177 {
5178   static GtkWidget *window = NULL;
5179   GtkWidget *button;
5180
5181   if (!window)
5182     {
5183       window = gtk_file_selection_new ("file selection dialog");
5184
5185       gtk_file_selection_hide_fileop_buttons (GTK_FILE_SELECTION (window));
5186
5187       gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
5188
5189       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5190                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5191                           &window);
5192
5193       gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (window)->ok_button),
5194                           "clicked", GTK_SIGNAL_FUNC(file_selection_ok),
5195                           window);
5196       gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (window)->cancel_button),
5197                                  "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
5198                                  GTK_OBJECT (window));
5199
5200       button = gtk_button_new_with_label ("Hide Fileops");
5201       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5202                           (GtkSignalFunc) file_selection_hide_fileops,
5203                           (gpointer) window);
5204       gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
5205                           button, FALSE, FALSE, 0);
5206       gtk_widget_show (button);
5207
5208       button = gtk_button_new_with_label ("Show Fileops");
5209       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5210                                  (GtkSignalFunc) gtk_file_selection_show_fileop_buttons,
5211                                  (gpointer) window);
5212       gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
5213                           button, FALSE, FALSE, 0);
5214       gtk_widget_show (button);
5215     }
5216
5217   if (!GTK_WIDGET_VISIBLE (window))
5218     gtk_widget_show (window);
5219   else
5220     gtk_widget_destroy (window);
5221 }
5222
5223 /*
5224  * GtkFontSelection
5225  */
5226
5227 void
5228 font_selection_ok (GtkWidget              *w,
5229                    GtkFontSelectionDialog *fs)
5230 {
5231   g_print ("%s\n", gtk_font_selection_dialog_get_font_name (fs));
5232   gtk_widget_destroy (GTK_WIDGET (fs));
5233 }
5234
5235 void
5236 create_font_selection (void)
5237 {
5238   static GtkWidget *window = NULL;
5239
5240   if (!window)
5241     {
5242       window = gtk_font_selection_dialog_new ("Font Selection Dialog");
5243
5244       gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
5245
5246       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5247                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5248                           &window);
5249
5250       gtk_signal_connect (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->ok_button),
5251                           "clicked", GTK_SIGNAL_FUNC(font_selection_ok),
5252                           GTK_FONT_SELECTION_DIALOG (window));
5253       gtk_signal_connect_object (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->cancel_button),
5254                                  "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
5255                                  GTK_OBJECT (window));
5256     }
5257
5258   if (!GTK_WIDGET_VISIBLE (window))
5259     gtk_widget_show (window);
5260   else
5261     gtk_widget_destroy (window);
5262 }
5263
5264 /*
5265  * GtkDialog
5266  */
5267
5268 static GtkWidget *dialog_window = NULL;
5269
5270 void
5271 label_toggle (GtkWidget  *widget,
5272               GtkWidget **label)
5273 {
5274   if (!(*label))
5275     {
5276       *label = gtk_label_new ("Dialog Test");
5277       gtk_signal_connect (GTK_OBJECT (*label),
5278                           "destroy",
5279                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
5280                           label);
5281       gtk_misc_set_padding (GTK_MISC (*label), 10, 10);
5282       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
5283                           *label, TRUE, TRUE, 0);
5284       gtk_widget_show (*label);
5285     }
5286   else
5287     gtk_widget_destroy (*label);
5288 }
5289
5290 void
5291 create_dialog (void)
5292 {
5293   static GtkWidget *label;
5294   GtkWidget *button;
5295
5296   if (!dialog_window)
5297     {
5298       dialog_window = gtk_dialog_new ();
5299
5300       gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
5301                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5302                           &dialog_window);
5303
5304       gtk_window_set_title (GTK_WINDOW (dialog_window), "GtkDialog");
5305       gtk_container_border_width (GTK_CONTAINER (dialog_window), 0);
5306       gtk_widget_set_usize (dialog_window, 200, 110);
5307
5308       button = gtk_button_new_with_label ("OK");
5309       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5310       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
5311                           button, TRUE, TRUE, 0);
5312       gtk_widget_grab_default (button);
5313       gtk_widget_show (button);
5314
5315       button = gtk_button_new_with_label ("Toggle");
5316       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5317                           GTK_SIGNAL_FUNC (label_toggle),
5318                           &label);
5319       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5320       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
5321                           button, TRUE, TRUE, 0);
5322       gtk_widget_show (button);
5323
5324       label = NULL;
5325     }
5326
5327   if (!GTK_WIDGET_VISIBLE (dialog_window))
5328     gtk_widget_show (dialog_window);
5329   else
5330     gtk_widget_destroy (dialog_window);
5331 }
5332
5333 /*
5334  * GtkRange
5335  */
5336
5337 void
5338 create_range_controls (void)
5339 {
5340   static GtkWidget *window = NULL;
5341   GtkWidget *box1;
5342   GtkWidget *box2;
5343   GtkWidget *button;
5344   GtkWidget *scrollbar;
5345   GtkWidget *scale;
5346   GtkWidget *separator;
5347   GtkObject *adjustment;
5348
5349   if (!window)
5350     {
5351       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5352
5353       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5354                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5355                           &window);
5356
5357       gtk_window_set_title (GTK_WINDOW (window), "range controls");
5358       gtk_container_border_width (GTK_CONTAINER (window), 0);
5359
5360
5361       box1 = gtk_vbox_new (FALSE, 0);
5362       gtk_container_add (GTK_CONTAINER (window), box1);
5363       gtk_widget_show (box1);
5364
5365
5366       box2 = gtk_vbox_new (FALSE, 10);
5367       gtk_container_border_width (GTK_CONTAINER (box2), 10);
5368       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
5369       gtk_widget_show (box2);
5370
5371
5372       adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
5373
5374       scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
5375       gtk_widget_set_usize (GTK_WIDGET (scale), 150, 30);
5376       gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
5377       gtk_scale_set_digits (GTK_SCALE (scale), 1);
5378       gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5379       gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
5380       gtk_widget_show (scale);
5381
5382       scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adjustment));
5383       gtk_range_set_update_policy (GTK_RANGE (scrollbar),
5384                                    GTK_UPDATE_CONTINUOUS);
5385       gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0);
5386       gtk_widget_show (scrollbar);
5387
5388
5389       separator = gtk_hseparator_new ();
5390       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5391       gtk_widget_show (separator);
5392
5393
5394       box2 = gtk_vbox_new (FALSE, 10);
5395       gtk_container_border_width (GTK_CONTAINER (box2), 10);
5396       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5397       gtk_widget_show (box2);
5398
5399
5400       button = gtk_button_new_with_label ("close");
5401       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5402                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
5403                                  GTK_OBJECT (window));
5404       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5405       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5406       gtk_widget_grab_default (button);
5407       gtk_widget_show (button);
5408     }
5409
5410   if (!GTK_WIDGET_VISIBLE (window))
5411     gtk_widget_show (window);
5412   else
5413     gtk_widget_destroy (window);
5414 }
5415
5416 /*
5417  * GtkRulers
5418  */
5419
5420 void
5421 create_rulers (void)
5422 {
5423   static GtkWidget *window = NULL;
5424   GtkWidget *table;
5425   GtkWidget *ruler;
5426
5427   if (!window)
5428     {
5429       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5430       gtk_window_set_policy (GTK_WINDOW (window), TRUE, TRUE, FALSE);
5431
5432       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5433                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5434                           &window);
5435
5436       gtk_window_set_title (GTK_WINDOW (window), "rulers");
5437       gtk_widget_set_usize (window, 300, 300);
5438       gtk_widget_set_events (window,
5439                              GDK_POINTER_MOTION_MASK
5440                              | GDK_POINTER_MOTION_HINT_MASK);
5441       gtk_container_border_width (GTK_CONTAINER (window), 0);
5442
5443       table = gtk_table_new (2, 2, FALSE);
5444       gtk_container_add (GTK_CONTAINER (window), table);
5445       gtk_widget_show (table);
5446
5447       ruler = gtk_hruler_new ();
5448       gtk_ruler_set_metric (GTK_RULER (ruler), GTK_CENTIMETERS);
5449       gtk_ruler_set_range (GTK_RULER (ruler), 100, 0, 0, 20);
5450
5451       gtk_signal_connect_object (
5452         GTK_OBJECT (window),
5453         "motion_notify_event",
5454         GTK_SIGNAL_FUNC(
5455           GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
5456         GTK_OBJECT (ruler));
5457
5458       gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
5459                         GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
5460       gtk_widget_show (ruler);
5461
5462
5463       ruler = gtk_vruler_new ();
5464       gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
5465
5466       gtk_signal_connect_object (
5467         GTK_OBJECT (window),
5468         "motion_notify_event",
5469         GTK_SIGNAL_FUNC (GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
5470         GTK_OBJECT (ruler));
5471
5472       gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
5473                         GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
5474       gtk_widget_show (ruler);
5475     }
5476
5477   if (!GTK_WIDGET_VISIBLE (window))
5478     gtk_widget_show (window);
5479   else
5480     gtk_widget_destroy (window);
5481 }
5482
5483 static void
5484 text_toggle_editable (GtkWidget *checkbutton,
5485                        GtkWidget *text)
5486 {
5487    gtk_text_set_editable(GTK_TEXT(text),
5488                           GTK_TOGGLE_BUTTON(checkbutton)->active);
5489 }
5490
5491 static void
5492 text_toggle_word_wrap (GtkWidget *checkbutton,
5493                        GtkWidget *text)
5494 {
5495    gtk_text_set_word_wrap(GTK_TEXT(text),
5496                           GTK_TOGGLE_BUTTON(checkbutton)->active);
5497 }
5498
5499 struct {
5500   GdkColor color;
5501   gchar *name;
5502 } text_colors[] = {
5503  { { 0, 0x0000, 0x0000, 0x0000 }, "black" },
5504  { { 0, 0xFFFF, 0xFFFF, 0xFFFF }, "white" },
5505  { { 0, 0xFFFF, 0x0000, 0x0000 }, "red" },
5506  { { 0, 0x0000, 0xFFFF, 0x0000 }, "green" },
5507  { { 0, 0x0000, 0x0000, 0xFFFF }, "blue" },
5508  { { 0, 0x0000, 0xFFFF, 0xFFFF }, "cyan" },
5509  { { 0, 0xFFFF, 0x0000, 0xFFFF }, "magenta" },
5510  { { 0, 0xFFFF, 0xFFFF, 0x0000 }, "yellow" }
5511 };
5512
5513 int ntext_colors = sizeof(text_colors) / sizeof(text_colors[0]);
5514
5515 /*
5516  * GtkText
5517  */
5518 void
5519 text_insert_random (GtkWidget *w, GtkText *text)
5520 {
5521   int i;
5522   char c;
5523    for (i=0; i<10; i++)
5524     {
5525       c = 'A' + rand() % ('Z' - 'A');
5526       gtk_text_set_point (text, rand() % gtk_text_get_length (text));
5527       gtk_text_insert (text, NULL, NULL, NULL, &c, 1);
5528     }
5529 }
5530
5531 void
5532 create_text (void)
5533 {
5534   int i, j;
5535
5536   static GtkWidget *window = NULL;
5537   GtkWidget *box1;
5538   GtkWidget *box2;
5539   GtkWidget *hbox;
5540   GtkWidget *button;
5541   GtkWidget *check;
5542   GtkWidget *separator;
5543   GtkWidget *table;
5544   GtkWidget *hscrollbar;
5545   GtkWidget *vscrollbar;
5546   GtkWidget *text;
5547   GdkFont *font;
5548
5549   FILE *infile;
5550
5551   if (!window)
5552     {
5553       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5554       gtk_widget_set_name (window, "text window");
5555       gtk_widget_set_usize (window, 500, 500);
5556       gtk_window_set_policy (GTK_WINDOW(window), TRUE, TRUE, FALSE);
5557
5558       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5559                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5560                           &window);
5561
5562       gtk_window_set_title (GTK_WINDOW (window), "test");
5563       gtk_container_border_width (GTK_CONTAINER (window), 0);
5564
5565
5566       box1 = gtk_vbox_new (FALSE, 0);
5567       gtk_container_add (GTK_CONTAINER (window), box1);
5568       gtk_widget_show (box1);
5569
5570
5571       box2 = gtk_vbox_new (FALSE, 10);
5572       gtk_container_border_width (GTK_CONTAINER (box2), 10);
5573       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
5574       gtk_widget_show (box2);
5575
5576
5577       table = gtk_table_new (2, 2, FALSE);
5578       gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2);
5579       gtk_table_set_col_spacing (GTK_TABLE (table), 0, 2);
5580       gtk_box_pack_start (GTK_BOX (box2), table, TRUE, TRUE, 0);
5581       gtk_widget_show (table);
5582
5583       text = gtk_text_new (NULL, NULL);
5584       gtk_text_set_editable (GTK_TEXT (text), TRUE);
5585       gtk_table_attach (GTK_TABLE (table), text, 0, 1, 0, 1,
5586                         GTK_EXPAND | GTK_SHRINK | GTK_FILL,
5587                         GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
5588       gtk_widget_grab_focus (text);
5589       gtk_widget_show (text);
5590
5591       hscrollbar = gtk_hscrollbar_new (GTK_TEXT (text)->hadj);
5592       gtk_table_attach (GTK_TABLE (table), hscrollbar, 0, 1, 1, 2,
5593                         GTK_EXPAND | GTK_FILL | GTK_SHRINK, GTK_FILL, 0, 0);
5594       gtk_widget_show (hscrollbar);
5595
5596       vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
5597       gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 0, 1,
5598                         GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
5599       gtk_widget_show (vscrollbar);
5600
5601       gtk_text_freeze (GTK_TEXT (text));
5602
5603       font = gdk_font_load ("-adobe-courier-medium-r-normal--*-120-*-*-*-*-*-*");
5604
5605       for (i=0; i<ntext_colors; i++)
5606         {
5607           gtk_text_insert (GTK_TEXT (text), font, NULL, NULL,
5608                            text_colors[i].name, -1);
5609           gtk_text_insert (GTK_TEXT (text), font, NULL, NULL, "\t", -1);
5610
5611           for (j=0; j<ntext_colors; j++)
5612             {
5613               gtk_text_insert (GTK_TEXT (text), font,
5614                                &text_colors[j].color, &text_colors[i].color,
5615                                "XYZ", -1);
5616             }
5617           gtk_text_insert (GTK_TEXT (text), NULL, NULL, NULL, "\n", -1);
5618         }
5619
5620       /* The Text widget will reference count the font, so we
5621        * unreference it here
5622        */
5623       gdk_font_unref (font);
5624
5625       infile = fopen("testgtk.c", "r");
5626
5627       if (infile)
5628         {
5629           char buffer[1024];
5630           int nchars;
5631
5632           while (1)
5633             {
5634               nchars = fread(buffer, 1, 1024, infile);
5635               gtk_text_insert (GTK_TEXT (text), NULL, NULL,
5636                                NULL, buffer, nchars);
5637
5638               if (nchars < 1024)
5639                 break;
5640             }
5641
5642           fclose (infile);
5643         }
5644
5645       gtk_text_thaw (GTK_TEXT (text));
5646
5647       hbox = gtk_hbutton_box_new ();
5648       gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, FALSE, 0);
5649       gtk_widget_show (hbox);
5650
5651       check = gtk_check_button_new_with_label("Editable");
5652       gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, FALSE, 0);
5653       gtk_signal_connect (GTK_OBJECT(check), "toggled",
5654                           GTK_SIGNAL_FUNC(text_toggle_editable), text);
5655       gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), TRUE);
5656       gtk_widget_show (check);
5657
5658       check = gtk_check_button_new_with_label("Wrap Words");
5659       gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
5660       gtk_signal_connect (GTK_OBJECT(check), "toggled",
5661                           GTK_SIGNAL_FUNC(text_toggle_word_wrap), text);
5662       gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), FALSE);
5663       gtk_widget_show (check);
5664
5665       separator = gtk_hseparator_new ();
5666       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5667       gtk_widget_show (separator);
5668
5669
5670       box2 = gtk_vbox_new (FALSE, 10);
5671       gtk_container_border_width (GTK_CONTAINER (box2), 10);
5672       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5673       gtk_widget_show (box2);
5674
5675
5676       button = gtk_button_new_with_label ("insert random");
5677       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5678                           GTK_SIGNAL_FUNC(text_insert_random),
5679                           GTK_TEXT (text));
5680       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5681       gtk_widget_show (button);
5682
5683       button = gtk_button_new_with_label ("close");
5684       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5685                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
5686                                  GTK_OBJECT (window));
5687       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5688       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5689       gtk_widget_grab_default (button);
5690       gtk_widget_show (button);
5691     }
5692
5693   if (!GTK_WIDGET_VISIBLE (window))
5694     gtk_widget_show (window);
5695   else
5696     gtk_widget_destroy (window);
5697 }
5698
5699 /*
5700  * GtkNotebook
5701  */
5702
5703 GdkPixmap *book_open;
5704 GdkPixmap *book_closed;
5705 GdkBitmap *book_open_mask;
5706 GdkBitmap *book_closed_mask;
5707
5708 static void
5709 page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num)
5710 {
5711   GtkNotebookPage *oldpage;
5712   GtkWidget *pixwid;
5713
5714   oldpage = GTK_NOTEBOOK (widget)->cur_page;
5715
5716   if (page == oldpage)
5717     return;
5718
5719   pixwid = ((GtkBoxChild*)(GTK_BOX (page->tab_label)->children->data))->widget;
5720   gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
5721   pixwid = ((GtkBoxChild*) (GTK_BOX (page->menu_label)->children->data))->widget;
5722   gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
5723
5724   if (oldpage)
5725     {
5726       pixwid = ((GtkBoxChild*) (GTK_BOX
5727                                 (oldpage->tab_label)->children->data))->widget;
5728       gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
5729       pixwid = ((GtkBoxChild*) (GTK_BOX (oldpage->menu_label)->children->data))->widget;
5730       gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
5731     }
5732 }
5733
5734 static void
5735 create_pages (GtkNotebook *notebook, gint start, gint end)
5736 {
5737   GtkWidget *child = NULL;
5738   GtkWidget *label;
5739   GtkWidget *entry;
5740   GtkWidget *box;
5741   GtkWidget *hbox;
5742   GtkWidget *label_box;
5743   GtkWidget *menu_box;
5744   GtkWidget *button;
5745   GtkWidget *pixwid;
5746   gint i;
5747   char buffer[32];
5748
5749   for (i = start; i <= end; i++)
5750     {
5751       sprintf (buffer, "Page %d", i);
5752
5753       switch (i % 4)
5754         {
5755         case 3:
5756           child = gtk_button_new_with_label (buffer);
5757           gtk_container_border_width (GTK_CONTAINER(child), 10);
5758           break;
5759         case 2:
5760           child = gtk_label_new (buffer);
5761           break;
5762         case 1:
5763           child = gtk_frame_new (buffer);
5764           gtk_container_border_width (GTK_CONTAINER (child), 10);
5765
5766           box = gtk_vbox_new (TRUE,0);
5767           gtk_container_border_width (GTK_CONTAINER (box), 10);
5768           gtk_container_add (GTK_CONTAINER (child), box);
5769
5770           label = gtk_label_new (buffer);
5771           gtk_box_pack_start (GTK_BOX(box), label, TRUE, TRUE, 5);
5772
5773           entry = gtk_entry_new ();
5774           gtk_box_pack_start (GTK_BOX(box), entry, TRUE, TRUE, 5);
5775
5776           hbox = gtk_hbox_new (TRUE,0);
5777           gtk_box_pack_start (GTK_BOX(box), hbox, TRUE, TRUE, 5);
5778
5779           button = gtk_button_new_with_label ("Ok");
5780           gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
5781
5782           button = gtk_button_new_with_label ("Cancel");
5783           gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
5784           break;
5785         case 0:
5786           child = gtk_frame_new (buffer);
5787           gtk_container_border_width (GTK_CONTAINER (child), 10);
5788
5789           label = gtk_label_new (buffer);
5790           gtk_container_add (GTK_CONTAINER (child), label);
5791           break;
5792         }
5793
5794       gtk_widget_show_all (child);
5795
5796       label_box = gtk_hbox_new (FALSE, 0);
5797       pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
5798       gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
5799       gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
5800       label = gtk_label_new (buffer);
5801       gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
5802       gtk_widget_show_all (label_box);
5803
5804       menu_box = gtk_hbox_new (FALSE, 0);
5805       pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
5806       gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
5807       gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
5808       label = gtk_label_new (buffer);
5809       gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0);
5810       gtk_widget_show_all (menu_box);
5811
5812       gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
5813     }
5814 }
5815
5816 static void
5817 rotate_notebook (GtkButton   *button,
5818                  GtkNotebook *notebook)
5819 {
5820   gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos + 1) % 4);
5821 }
5822
5823 static void
5824 standard_notebook (GtkButton   *button,
5825                    GtkNotebook *notebook)
5826 {
5827   gint i;
5828
5829   gtk_notebook_set_show_tabs (notebook, TRUE);
5830   gtk_notebook_set_scrollable (notebook, FALSE);
5831   if (g_list_length (notebook->children) == 15)
5832     for (i = 0; i < 10; i++)
5833       gtk_notebook_remove_page (notebook, 5);
5834 }
5835
5836 static void
5837 notabs_notebook (GtkButton   *button,
5838                  GtkNotebook *notebook)
5839 {
5840   gint i;
5841
5842   gtk_notebook_set_show_tabs (notebook, FALSE);
5843   if (g_list_length (notebook->children) == 15)
5844     for (i = 0; i < 10; i++)
5845       gtk_notebook_remove_page (notebook, 5);
5846 }
5847
5848 static void
5849 scrollable_notebook (GtkButton   *button,
5850                      GtkNotebook *notebook)
5851 {
5852   gtk_notebook_set_show_tabs (notebook, TRUE);
5853   gtk_notebook_set_scrollable (notebook, TRUE);
5854   if (g_list_length (notebook->children) == 5)
5855     create_pages (notebook, 6, 15);
5856 }
5857
5858 static void
5859 notebook_popup (GtkToggleButton *button,
5860                 GtkNotebook     *notebook)
5861 {
5862   if (button->active)
5863     gtk_notebook_popup_enable (notebook);
5864   else
5865     gtk_notebook_popup_disable (notebook);
5866 }
5867
5868 static void
5869 create_notebook (void)
5870 {
5871   static GtkWidget *window = NULL;
5872   GtkWidget *box1;
5873   GtkWidget *box2;
5874   GtkWidget *button;
5875   GtkWidget *separator;
5876   GtkWidget *notebook;
5877   GtkWidget *omenu;
5878   GdkColor *transparent = NULL;
5879
5880   static OptionMenuItem items[] =
5881   {
5882     { "Standard",   standard_notebook },
5883     { "No tabs",    notabs_notebook },
5884     { "Scrollable", scrollable_notebook }
5885   };
5886
5887   if (!window)
5888     {
5889       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5890
5891       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5892                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5893                           &window);
5894
5895       gtk_window_set_title (GTK_WINDOW (window), "notebook");
5896       gtk_container_border_width (GTK_CONTAINER (window), 0);
5897
5898       box1 = gtk_vbox_new (FALSE, 0);
5899       gtk_container_add (GTK_CONTAINER (window), box1);
5900
5901       notebook = gtk_notebook_new ();
5902       gtk_signal_connect (GTK_OBJECT (notebook), "switch_page",
5903                           GTK_SIGNAL_FUNC (page_switch), NULL);
5904       gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
5905       gtk_box_pack_start (GTK_BOX (box1), notebook, TRUE, TRUE, 0);
5906       gtk_container_border_width (GTK_CONTAINER (notebook), 10);
5907
5908       gtk_widget_realize (notebook);
5909       book_open = gdk_pixmap_create_from_xpm_d (notebook->window,
5910                                                 &book_open_mask,
5911                                                 transparent,
5912                                                 book_open_xpm);
5913       book_closed = gdk_pixmap_create_from_xpm_d (notebook->window,
5914                                                   &book_closed_mask,
5915                                                   transparent,
5916                                                   book_closed_xpm);
5917
5918       create_pages (GTK_NOTEBOOK (notebook), 1, 5);
5919
5920       separator = gtk_hseparator_new ();
5921       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10);
5922
5923       box2 = gtk_hbox_new (TRUE, 5);
5924       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5925
5926       omenu = build_option_menu (items, 3, 0, notebook);
5927       gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, FALSE, 0);
5928
5929       button = gtk_check_button_new_with_label ("enable popup menu");
5930       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
5931       gtk_signal_connect (GTK_OBJECT(button), "clicked",
5932                           GTK_SIGNAL_FUNC (notebook_popup),
5933                           GTK_OBJECT (notebook));
5934
5935       box2 = gtk_hbox_new (TRUE, 10);
5936       gtk_container_border_width (GTK_CONTAINER (box2), 10);
5937       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5938
5939       button = gtk_button_new_with_label ("close");
5940       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5941                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
5942                                  GTK_OBJECT (window));
5943       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5944       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5945       gtk_widget_grab_default (button);
5946
5947       button = gtk_button_new_with_label ("next");
5948       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5949                                  GTK_SIGNAL_FUNC (gtk_notebook_next_page),
5950                                  GTK_OBJECT (notebook));
5951       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5952       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5953
5954       button = gtk_button_new_with_label ("prev");
5955       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5956                                  GTK_SIGNAL_FUNC (gtk_notebook_prev_page),
5957                                  GTK_OBJECT (notebook));
5958       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5959       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5960
5961       button = gtk_button_new_with_label ("rotate");
5962       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5963                           GTK_SIGNAL_FUNC (rotate_notebook),
5964                           notebook);
5965       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5966       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5967     }
5968
5969   if (!GTK_WIDGET_VISIBLE (window))
5970     gtk_widget_show_all (window);
5971   else
5972     gtk_widget_destroy (window);
5973 }
5974
5975 /*
5976  * GtkPanes
5977  */
5978
5979 void
5980 create_panes (void)
5981 {
5982   static GtkWidget *window = NULL;
5983   GtkWidget *frame;
5984   GtkWidget *hpaned;
5985   GtkWidget *vpaned;
5986   GtkWidget *button;
5987
5988   if (!window)
5989     {
5990       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5991
5992       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5993                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5994                           &window);
5995
5996       gtk_window_set_title (GTK_WINDOW (window), "Panes");
5997       gtk_container_border_width (GTK_CONTAINER (window), 0);
5998
5999       vpaned = gtk_vpaned_new ();
6000       gtk_container_add (GTK_CONTAINER (window), vpaned);
6001       gtk_container_border_width (GTK_CONTAINER(vpaned), 5);
6002       gtk_widget_show (vpaned);
6003
6004       hpaned = gtk_hpaned_new ();
6005       gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
6006
6007       frame = gtk_frame_new (NULL);
6008       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6009       gtk_widget_set_usize (frame, 60, 60);
6010       gtk_paned_add1 (GTK_PANED (hpaned), frame);
6011       gtk_widget_show (frame);
6012
6013       button = gtk_button_new_with_label ("Hi there");
6014       gtk_container_add (GTK_CONTAINER(frame), button);
6015       gtk_widget_show (button);
6016
6017       frame = gtk_frame_new (NULL);
6018       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6019       gtk_widget_set_usize (frame, 80, 60);
6020       gtk_paned_add2 (GTK_PANED (hpaned), frame);
6021       gtk_widget_show (frame);
6022
6023       gtk_widget_show (hpaned);
6024
6025       frame = gtk_frame_new (NULL);
6026       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6027       gtk_widget_set_usize (frame, 60, 80);
6028       gtk_paned_add2 (GTK_PANED (vpaned), frame);
6029       gtk_widget_show (frame);
6030     }
6031
6032   if (!GTK_WIDGET_VISIBLE (window))
6033     gtk_widget_show (window);
6034   else
6035     gtk_widget_destroy (window);
6036 }
6037
6038 /*
6039  * Drag -N- Drop
6040  */
6041
6042 #if 0
6043 gint
6044 dnd_drop_destroy_popup (GtkWidget *widget, GtkWindow **window)
6045 {
6046   if(GTK_IS_BUTTON(widget)) /* I.e. they clicked the close button */
6047     gtk_widget_destroy(GTK_WIDGET(*window));
6048   else {
6049     gtk_grab_remove(GTK_WIDGET(*window));
6050     *window = NULL;
6051   }
6052
6053   return FALSE;
6054 }
6055
6056 void
6057 dnd_drop (GtkWidget *button, GdkEvent *event)
6058 {
6059   static GtkWidget *window = NULL;
6060   GtkWidget *vbox, *lbl, *btn;
6061   gchar *msg;
6062
6063   /* DND doesn't obey gtk_grab's, so check if we're already displaying
6064    * drop modal dialog first
6065    */
6066   if (window)
6067     return;
6068
6069   window = gtk_window_new(GTK_WINDOW_DIALOG);
6070   gtk_container_border_width (GTK_CONTAINER(window), 10);
6071
6072   gtk_signal_connect (GTK_OBJECT (window), "destroy",
6073                       GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
6074                       &window);
6075   gtk_signal_connect (GTK_OBJECT (window), "delete-event",
6076                       GTK_SIGNAL_FUNC(gtk_false),
6077                       &window);
6078
6079   vbox = gtk_vbox_new(FALSE, 5);
6080
6081   /* Display message that we got from drop source */
6082   msg = g_malloc(strlen(event->dropdataavailable.data)
6083                  + strlen(event->dropdataavailable.data_type) + 100);
6084   sprintf(msg, "Drop data of type %s was:\n\n%s",
6085           event->dropdataavailable.data_type,
6086           (char *)event->dropdataavailable.data);
6087   lbl = gtk_label_new(msg);
6088   gtk_label_set_justify(GTK_LABEL(lbl), GTK_JUSTIFY_FILL);
6089   g_free(msg);
6090   gtk_widget_show(lbl);
6091   gtk_box_pack_start_defaults(GTK_BOX(vbox), lbl);
6092
6093   /* Provide an obvious way out of this heinousness */
6094   btn = gtk_button_new_with_label("Continue with life in\nspite of this oppression");
6095   gtk_signal_connect_object (GTK_OBJECT (btn), "clicked",
6096                              GTK_SIGNAL_FUNC(gtk_widget_destroy),
6097                              GTK_OBJECT (window));
6098   gtk_widget_show(btn);
6099   gtk_box_pack_start_defaults(GTK_BOX(vbox), btn);
6100
6101   gtk_container_add(GTK_CONTAINER(window), vbox);
6102
6103   gtk_widget_show(vbox);
6104   gtk_grab_add(window);
6105   gtk_widget_show(window);
6106 }
6107
6108 void
6109 dnd_drag_request (GtkWidget *button, GdkEvent *event)
6110 {
6111 #define DND_STRING "Bill Gates demands royalties for\nyour use of his innovation."
6112   gtk_widget_dnd_data_set (button, event, DND_STRING, strlen(DND_STRING) + 1);
6113 }
6114
6115 void
6116 create_dnd (void)
6117 {
6118   static GtkWidget *window = NULL;
6119   GtkWidget *box1;
6120   GtkWidget *box2;
6121   GtkWidget *box3;
6122   GtkWidget *frame;
6123   GtkWidget *button;
6124   GtkWidget *separator;
6125
6126   /* For clarity... */
6127   char *possible_drag_types[] = {"text/plain"};
6128   char *accepted_drop_types[] = {"text/plain"};
6129
6130   static GtkWidget *drag_icon = NULL;
6131   static GtkWidget *drop_icon = NULL;
6132
6133   if (!window)
6134     {
6135       GdkPoint hotspot = {5,5};
6136
6137       if (!drag_icon)
6138         {
6139           drag_icon = shape_create_icon ("Modeller.xpm",
6140                                          440, 140, 0,0, GTK_WINDOW_POPUP);
6141
6142           gtk_signal_connect (GTK_OBJECT (drag_icon), "destroy",
6143                               GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6144                               &drag_icon);
6145
6146           gtk_widget_hide (drag_icon);
6147         }
6148
6149       if (!drop_icon)
6150         {
6151           drop_icon = shape_create_icon ("3DRings.xpm",
6152                                          440, 140, 0,0, GTK_WINDOW_POPUP);
6153
6154           gtk_signal_connect (GTK_OBJECT (drop_icon), "destroy",
6155                               GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6156                               &drop_icon);
6157
6158           gtk_widget_hide (drop_icon);
6159         }
6160
6161       gdk_dnd_set_drag_shape(drag_icon->window,
6162                              &hotspot,
6163                              drop_icon->window,
6164                              &hotspot);
6165
6166       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6167
6168       gtk_signal_connect (GTK_OBJECT (window), "destroy",
6169                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6170                           &window);
6171
6172       gtk_window_set_title (GTK_WINDOW (window), "Drag -N- Drop");
6173       gtk_container_border_width (GTK_CONTAINER (window), 0);
6174
6175       box1 = gtk_vbox_new (FALSE, 0);
6176       gtk_container_add (GTK_CONTAINER (window), box1);
6177       gtk_widget_show (box1);
6178
6179       box2 = gtk_hbox_new (FALSE, 5);
6180       gtk_container_border_width (GTK_CONTAINER (box2), 10);
6181       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
6182       gtk_widget_show (box2);
6183
6184       frame = gtk_frame_new ("Drag");
6185       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
6186       gtk_widget_show (frame);
6187
6188       box3 = gtk_vbox_new (FALSE, 5);
6189       gtk_container_border_width (GTK_CONTAINER (box3), 5);
6190       gtk_container_add (GTK_CONTAINER (frame), box3);
6191       gtk_widget_show (box3);
6192
6193       /*
6194        * FROM Button
6195        */
6196       button = gtk_button_new_with_label ("Drag me!");
6197       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
6198       gtk_widget_show (button);
6199
6200       /*
6201        * currently, the widget has to be realized to
6202        * set dnd on it, this needs to change
6203        */
6204       gtk_widget_realize (button);
6205       gtk_signal_connect (GTK_OBJECT (button),
6206                           "drag_request_event",
6207                           GTK_SIGNAL_FUNC(dnd_drag_request),
6208                           button);
6209
6210       gtk_widget_dnd_drag_set (button, TRUE, possible_drag_types, 1);
6211
6212
6213       frame = gtk_frame_new ("Drop");
6214       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
6215       gtk_widget_show (frame);
6216
6217       box3 = gtk_vbox_new (FALSE, 5);
6218       gtk_container_border_width (GTK_CONTAINER (box3), 5);
6219       gtk_container_add (GTK_CONTAINER (frame), box3);
6220       gtk_widget_show (box3);
6221
6222
6223       /*
6224        * TO Button
6225        */
6226       button = gtk_button_new_with_label ("To");
6227       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
6228       gtk_widget_show (button);
6229
6230       gtk_widget_realize (button);
6231       gtk_signal_connect (GTK_OBJECT (button),
6232                           "drop_data_available_event",
6233                           GTK_SIGNAL_FUNC(dnd_drop),
6234                           button);
6235
6236       gtk_widget_dnd_drop_set (button, TRUE, accepted_drop_types, 1, FALSE);
6237
6238
6239       separator = gtk_hseparator_new ();
6240       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
6241       gtk_widget_show (separator);
6242
6243
6244       box2 = gtk_vbox_new (FALSE, 10);
6245       gtk_container_border_width (GTK_CONTAINER (box2), 10);
6246       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6247       gtk_widget_show (box2);
6248
6249
6250       button = gtk_button_new_with_label ("close");
6251
6252       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6253                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
6254                                  GTK_OBJECT (window));
6255
6256       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6257       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6258       gtk_widget_grab_default (button);
6259       gtk_widget_show (button);
6260     }
6261
6262   if (!GTK_WIDGET_VISIBLE (window))
6263     gtk_widget_show (window);
6264   else
6265     gtk_widget_destroy (window);
6266 }
6267 #endif
6268
6269 /*
6270  * Shaped Windows
6271  */
6272
6273 static GdkWindow *root_win = NULL;
6274
6275 typedef struct _cursoroffset {gint x,y;} CursorOffset;
6276
6277 static void
6278 shape_pressed (GtkWidget *widget, GdkEventButton *event)
6279 {
6280   CursorOffset *p;
6281
6282   /* ignore double and triple click */
6283   if (event->type != GDK_BUTTON_PRESS)
6284     return;
6285
6286   p = gtk_object_get_user_data (GTK_OBJECT(widget));
6287   p->x = (int) event->x;
6288   p->y = (int) event->y;
6289
6290   gtk_grab_add (widget);
6291   gdk_pointer_grab (widget->window, TRUE,
6292                     GDK_BUTTON_RELEASE_MASK |
6293                     GDK_BUTTON_MOTION_MASK |
6294                     GDK_POINTER_MOTION_HINT_MASK,
6295                     NULL, NULL, 0);
6296 }
6297
6298 static void
6299 shape_released (GtkWidget *widget)
6300 {
6301   gtk_grab_remove (widget);
6302   gdk_pointer_ungrab (0);
6303 }
6304
6305 static void
6306 shape_motion (GtkWidget      *widget,
6307               GdkEventMotion *event)
6308 {
6309   gint xp, yp;
6310   CursorOffset * p;
6311   GdkModifierType mask;
6312
6313   p = gtk_object_get_user_data (GTK_OBJECT (widget));
6314
6315   /*
6316    * Can't use event->x / event->y here
6317    * because I need absolute coordinates.
6318    */
6319   gdk_window_get_pointer (root_win, &xp, &yp, &mask);
6320   gtk_widget_set_uposition (widget, xp  - p->x, yp  - p->y);
6321 }
6322
6323 GtkWidget *
6324 shape_create_icon (char     *xpm_file,
6325                    gint      x,
6326                    gint      y,
6327                    gint      px,
6328                    gint      py,
6329                    gint      window_type)
6330 {
6331   GtkWidget *window;
6332   GtkWidget *pixmap;
6333   GtkWidget *fixed;
6334   CursorOffset* icon_pos;
6335   GdkGC* gc;
6336   GdkBitmap *gdk_pixmap_mask;
6337   GdkPixmap *gdk_pixmap;
6338   GtkStyle *style;
6339
6340   style = gtk_widget_get_default_style ();
6341   gc = style->black_gc;
6342
6343   /*
6344    * GDK_WINDOW_TOPLEVEL works also, giving you a title border
6345    */
6346   window = gtk_window_new (window_type);
6347
6348   fixed = gtk_fixed_new ();
6349   gtk_widget_set_usize (fixed, 100,100);
6350   gtk_container_add (GTK_CONTAINER (window), fixed);
6351   gtk_widget_show (fixed);
6352
6353   gtk_widget_set_events (window,
6354                          gtk_widget_get_events (window) |
6355                          GDK_BUTTON_MOTION_MASK |
6356                          GDK_POINTER_MOTION_HINT_MASK |
6357                          GDK_BUTTON_PRESS_MASK);
6358
6359   gtk_widget_realize (window);
6360   gdk_pixmap = gdk_pixmap_create_from_xpm (window->window, &gdk_pixmap_mask,
6361                                            &style->bg[GTK_STATE_NORMAL],
6362                                            xpm_file);
6363
6364   pixmap = gtk_pixmap_new (gdk_pixmap, gdk_pixmap_mask);
6365   gtk_fixed_put (GTK_FIXED (fixed), pixmap, px,py);
6366   gtk_widget_show (pixmap);
6367
6368   gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px,py);
6369
6370
6371   gtk_signal_connect (GTK_OBJECT (window), "button_press_event",
6372                       GTK_SIGNAL_FUNC (shape_pressed),NULL);
6373   gtk_signal_connect (GTK_OBJECT (window), "button_release_event",
6374                       GTK_SIGNAL_FUNC (shape_released),NULL);
6375   gtk_signal_connect (GTK_OBJECT (window), "motion_notify_event",
6376                       GTK_SIGNAL_FUNC (shape_motion),NULL);
6377
6378   icon_pos = g_new (CursorOffset, 1);
6379   gtk_object_set_user_data(GTK_OBJECT(window), icon_pos);
6380
6381   gtk_widget_set_uposition (window, x, y);
6382   gtk_widget_show (window);
6383
6384   return window;
6385 }
6386
6387 void
6388 create_shapes (void)
6389 {
6390   /* Variables used by the Drag/Drop and Shape Window demos */
6391   static GtkWidget *modeller = NULL;
6392   static GtkWidget *sheets = NULL;
6393   static GtkWidget *rings = NULL;
6394
6395   root_win = gdk_window_foreign_new (GDK_ROOT_WINDOW ());
6396
6397   if (!modeller)
6398     {
6399       modeller = shape_create_icon ("Modeller.xpm",
6400                                     440, 140, 0,0, GTK_WINDOW_POPUP);
6401
6402       gtk_signal_connect (GTK_OBJECT (modeller), "destroy",
6403                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6404                           &modeller);
6405     }
6406   else
6407     gtk_widget_destroy (modeller);
6408
6409   if (!sheets)
6410     {
6411       sheets = shape_create_icon ("FilesQueue.xpm",
6412                                   580, 170, 0,0, GTK_WINDOW_POPUP);
6413
6414       gtk_signal_connect (GTK_OBJECT (sheets), "destroy",
6415                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6416                           &sheets);
6417
6418     }
6419   else
6420     gtk_widget_destroy (sheets);
6421
6422   if (!rings)
6423     {
6424       rings = shape_create_icon ("3DRings.xpm",
6425                                  460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
6426
6427       gtk_signal_connect (GTK_OBJECT (rings), "destroy",
6428                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6429                           &rings);
6430     }
6431   else
6432     gtk_widget_destroy (rings);
6433 }
6434
6435 /*
6436  * WM Hints demo
6437  */
6438
6439 void
6440 create_wmhints (void)
6441 {
6442   static GtkWidget *window = NULL;
6443   GtkWidget *label;
6444   GtkWidget *separator;
6445   GtkWidget *button;
6446   GtkWidget *box1;
6447   GtkWidget *box2;
6448
6449   GdkBitmap *circles;
6450
6451   if (!window)
6452     {
6453       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6454
6455       gtk_signal_connect (GTK_OBJECT (window), "destroy",
6456                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6457                           &window);
6458
6459       gtk_window_set_title (GTK_WINDOW (window), "WM Hints");
6460       gtk_container_border_width (GTK_CONTAINER (window), 0);
6461
6462       gtk_widget_realize (window);
6463
6464       circles = gdk_bitmap_create_from_data (window->window,
6465                                              circles_bits,
6466                                              circles_width,
6467                                              circles_height);
6468       gdk_window_set_icon (window->window, NULL,
6469                            circles, circles);
6470
6471       gdk_window_set_icon_name (window->window, "WMHints Test Icon");
6472
6473       gdk_window_set_decorations (window->window, GDK_DECOR_ALL | GDK_DECOR_MENU);
6474       gdk_window_set_functions (window->window, GDK_FUNC_ALL | GDK_FUNC_RESIZE);
6475
6476       box1 = gtk_vbox_new (FALSE, 0);
6477       gtk_container_add (GTK_CONTAINER (window), box1);
6478       gtk_widget_show (box1);
6479
6480       label = gtk_label_new ("Try iconizing me!");
6481       gtk_widget_set_usize (label, 150, 50);
6482       gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
6483       gtk_widget_show (label);
6484
6485
6486       separator = gtk_hseparator_new ();
6487       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
6488       gtk_widget_show (separator);
6489
6490
6491       box2 = gtk_vbox_new (FALSE, 10);
6492       gtk_container_border_width (GTK_CONTAINER (box2), 10);
6493       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6494       gtk_widget_show (box2);
6495
6496
6497       button = gtk_button_new_with_label ("close");
6498
6499       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6500                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
6501                                  GTK_OBJECT (window));
6502
6503       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6504       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6505       gtk_widget_grab_default (button);
6506       gtk_widget_show (button);
6507     }
6508
6509   if (!GTK_WIDGET_VISIBLE (window))
6510     gtk_widget_show (window);
6511   else
6512     gtk_widget_destroy (window);
6513 }
6514
6515 /*
6516  * GtkProgressBar
6517  */
6518
6519 typedef struct _ProgressData {
6520   GtkWidget *window;
6521   GtkWidget *pbar;
6522   GtkWidget *block_spin;
6523   GtkWidget *x_align_spin;
6524   GtkWidget *y_align_spin;
6525   GtkWidget *step_spin;
6526   GtkWidget *act_blocks_spin;
6527   GtkWidget *label;
6528   GtkWidget *omenu1;
6529   GtkWidget *omenu2;
6530   GtkWidget *entry;
6531   int timer;
6532 } ProgressData;
6533
6534 gint
6535 progress_timeout (gpointer data)
6536 {
6537   gfloat new_val;
6538   GtkAdjustment *adj;
6539
6540   adj = GTK_PROGRESS (data)->adjustment;
6541
6542   new_val = adj->value + 1;
6543   if (new_val > adj->upper)
6544     new_val = adj->lower;
6545
6546   gtk_progress_set_value (GTK_PROGRESS (data), new_val);
6547
6548   return TRUE;
6549 }
6550
6551 static void
6552 destroy_progress (GtkWidget     *widget,
6553                   ProgressData **pdata)
6554 {
6555   gtk_timeout_remove ((*pdata)->timer);
6556   (*pdata)->timer = 0;
6557   (*pdata)->window = NULL;
6558   g_free (*pdata);
6559   *pdata = NULL;
6560 }
6561
6562 static void
6563 progressbar_toggle_orientation (GtkWidget *widget, ProgressData *pdata)
6564 {
6565   gint i;
6566
6567   if (!GTK_WIDGET_MAPPED (widget))
6568     return;
6569
6570   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
6571                     (((GtkOptionMenu *)(pdata->omenu1))->menu_item), i);
6572
6573   gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (pdata->pbar),
6574                             (GtkProgressBarOrientation) (3-i));
6575 }
6576
6577 static void
6578 toggle_show_text (GtkWidget *widget, ProgressData *pdata)
6579 {
6580   gtk_progress_set_show_text (GTK_PROGRESS (pdata->pbar),
6581                               GTK_TOGGLE_BUTTON (widget)->active);
6582   gtk_widget_set_sensitive (pdata->entry, GTK_TOGGLE_BUTTON (widget)->active);
6583   gtk_widget_set_sensitive (pdata->x_align_spin,
6584                             GTK_TOGGLE_BUTTON (widget)->active);
6585   gtk_widget_set_sensitive (pdata->y_align_spin,
6586                             GTK_TOGGLE_BUTTON (widget)->active);
6587 }
6588
6589 static void
6590 progressbar_toggle_bar_style (GtkWidget *widget, ProgressData *pdata)
6591 {
6592   gint i;
6593
6594   if (!GTK_WIDGET_MAPPED (widget))
6595     return;
6596
6597   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
6598                     (((GtkOptionMenu *)(pdata->omenu2))->menu_item), i);
6599
6600   i = 1 - i;
6601
6602   if (i == 1)
6603     gtk_widget_set_sensitive (pdata->block_spin, TRUE);
6604   else
6605     gtk_widget_set_sensitive (pdata->block_spin, FALSE);
6606
6607   gtk_progress_bar_set_bar_style (GTK_PROGRESS_BAR (pdata->pbar),
6608                                   (GtkProgressBarStyle) i);
6609 }
6610
6611 static void
6612 progress_value_changed (GtkAdjustment *adj, ProgressData *pdata)
6613 {
6614   char buf[20];
6615
6616   if (GTK_PROGRESS (pdata->pbar)->activity_mode)
6617     sprintf (buf, "???");
6618   else
6619     sprintf (buf, "%.0f%%", 100 *
6620              gtk_progress_get_current_percentage (GTK_PROGRESS (pdata->pbar)));
6621   gtk_label_set (GTK_LABEL (pdata->label), buf);
6622 }
6623
6624 static void
6625 adjust_blocks (GtkAdjustment *adj, ProgressData *pdata)
6626 {
6627   gtk_progress_set_percentage (GTK_PROGRESS (pdata->pbar), 0);
6628   gtk_progress_bar_set_discrete_blocks (GTK_PROGRESS_BAR (pdata->pbar),
6629      gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pdata->block_spin)));
6630 }
6631
6632 static void
6633 adjust_step (GtkAdjustment *adj, ProgressData *pdata)
6634 {
6635   gtk_progress_bar_set_activity_step (GTK_PROGRESS_BAR (pdata->pbar),
6636      gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pdata->step_spin)));
6637 }
6638
6639 static void
6640 adjust_act_blocks (GtkAdjustment *adj, ProgressData *pdata)
6641 {
6642   gtk_progress_bar_set_activity_blocks (GTK_PROGRESS_BAR (pdata->pbar),
6643                gtk_spin_button_get_value_as_int
6644                       (GTK_SPIN_BUTTON (pdata->act_blocks_spin)));
6645 }
6646
6647 static void
6648 adjust_align (GtkAdjustment *adj, ProgressData *pdata)
6649 {
6650   gtk_progress_set_text_alignment (GTK_PROGRESS (pdata->pbar),
6651          gtk_spin_button_get_value_as_float
6652                                    (GTK_SPIN_BUTTON (pdata->x_align_spin)),
6653          gtk_spin_button_get_value_as_float
6654                                    (GTK_SPIN_BUTTON (pdata->y_align_spin)));
6655 }
6656
6657 static void
6658 toggle_activity_mode (GtkWidget *widget, ProgressData *pdata)
6659 {
6660   gtk_progress_set_activity_mode (GTK_PROGRESS (pdata->pbar),
6661                                   GTK_TOGGLE_BUTTON (widget)->active);
6662   gtk_widget_set_sensitive (pdata->step_spin,
6663                             GTK_TOGGLE_BUTTON (widget)->active);
6664   gtk_widget_set_sensitive (pdata->act_blocks_spin,
6665                             GTK_TOGGLE_BUTTON (widget)->active);
6666 }
6667
6668 static void
6669 entry_changed (GtkWidget *widget, ProgressData *pdata)
6670 {
6671   gtk_progress_set_format_string (GTK_PROGRESS (pdata->pbar),
6672                           gtk_entry_get_text (GTK_ENTRY (pdata->entry)));
6673 }
6674
6675 void
6676 create_progress_bar (void)
6677 {
6678   GtkWidget *button;
6679   GtkWidget *vbox;
6680   GtkWidget *vbox2;
6681   GtkWidget *hbox;
6682   GtkWidget *check;
6683   GtkWidget *frame;
6684   GtkWidget *tab;
6685   GtkWidget *label;
6686   GtkWidget *align;
6687   GtkAdjustment *adj;
6688   static ProgressData *pdata = NULL;
6689
6690   static OptionMenuItem items1[] =
6691   {
6692     { "Left-Right", progressbar_toggle_orientation },
6693     { "Right-Left", progressbar_toggle_orientation },
6694     { "Bottom-Top", progressbar_toggle_orientation },
6695     { "Top-Bottom", progressbar_toggle_orientation }
6696   };
6697
6698   static OptionMenuItem items2[] =
6699   {
6700     { "Continuous", progressbar_toggle_bar_style },
6701     { "Discrete",   progressbar_toggle_bar_style }
6702   };
6703
6704   if (!pdata)
6705     pdata = g_new0 (ProgressData, 1);
6706
6707   if (!pdata->window)
6708     {
6709       pdata->window = gtk_dialog_new ();
6710
6711       gtk_window_set_policy (GTK_WINDOW (pdata->window), FALSE, FALSE, TRUE);
6712
6713       gtk_signal_connect (GTK_OBJECT (pdata->window), "destroy",
6714                           GTK_SIGNAL_FUNC (destroy_progress),
6715                           &pdata);
6716
6717       pdata->timer = 0;
6718
6719       gtk_window_set_title (GTK_WINDOW (pdata->window), "GtkProgressBar");
6720       gtk_container_border_width (GTK_CONTAINER (pdata->window), 0);
6721
6722       vbox = gtk_vbox_new (FALSE, 5);
6723       gtk_container_border_width (GTK_CONTAINER (vbox), 10);
6724       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pdata->window)->vbox),
6725                           vbox, FALSE, TRUE, 0);
6726
6727       frame = gtk_frame_new ("Progress");
6728       gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
6729
6730       vbox2 = gtk_vbox_new (FALSE, 5);
6731       gtk_container_add (GTK_CONTAINER (frame), vbox2);
6732
6733       align = gtk_alignment_new (0.5, 0.5, 0, 0);
6734       gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
6735
6736       adj = (GtkAdjustment *) gtk_adjustment_new (0, 1, 300, 0, 0, 0);
6737       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6738                           GTK_SIGNAL_FUNC (progress_value_changed), pdata);
6739
6740       pdata->pbar = gtk_progress_bar_new_with_adjustment (adj);
6741       gtk_progress_set_format_string (GTK_PROGRESS (pdata->pbar),
6742                                       "%v from [%l,%u] (=%p%%)");
6743       gtk_container_add (GTK_CONTAINER (align), pdata->pbar);
6744       pdata->timer = gtk_timeout_add (100, progress_timeout, pdata->pbar);
6745
6746       align = gtk_alignment_new (0.5, 0.5, 0, 0);
6747       gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
6748
6749       hbox = gtk_hbox_new (FALSE, 5);
6750       gtk_container_add (GTK_CONTAINER (align), hbox);
6751       label = gtk_label_new ("Label updated by user :");
6752       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
6753       pdata->label = gtk_label_new ("");
6754       gtk_box_pack_start (GTK_BOX (hbox), pdata->label, FALSE, TRUE, 0);
6755
6756       frame = gtk_frame_new ("Options");
6757       gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
6758
6759       vbox2 = gtk_vbox_new (FALSE, 5);
6760       gtk_container_add (GTK_CONTAINER (frame), vbox2);
6761
6762       tab = gtk_table_new (7, 2, FALSE);
6763       gtk_box_pack_start (GTK_BOX (vbox2), tab, FALSE, TRUE, 0);
6764
6765       label = gtk_label_new ("Orientation :");
6766       gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 0, 1,
6767                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6768                         5, 5);
6769       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
6770
6771       pdata->omenu1 = build_option_menu (items1, 4, 0, pdata);
6772       hbox = gtk_hbox_new (FALSE, 0);
6773       gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 0, 1,
6774                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6775                         5, 5);
6776       gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu1, TRUE, TRUE, 0);
6777
6778       check = gtk_check_button_new_with_label ("Show text");
6779       gtk_signal_connect (GTK_OBJECT (check), "clicked",
6780                           GTK_SIGNAL_FUNC (toggle_show_text),
6781                           pdata);
6782       gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 1, 2,
6783                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6784                         5, 5);
6785
6786       hbox = gtk_hbox_new (FALSE, 0);
6787       gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 1, 2,
6788                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6789                         5, 5);
6790
6791       label = gtk_label_new ("Format : ");
6792       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
6793
6794       pdata->entry = gtk_entry_new ();
6795       gtk_signal_connect (GTK_OBJECT (pdata->entry), "changed",
6796                           GTK_SIGNAL_FUNC (entry_changed),
6797                           pdata);
6798       gtk_box_pack_start (GTK_BOX (hbox), pdata->entry, TRUE, TRUE, 0);
6799       gtk_entry_set_text (GTK_ENTRY (pdata->entry), "%v from [%l,%u] (=%p%%)");
6800       gtk_widget_set_usize (pdata->entry, 100, -1);
6801       gtk_widget_set_sensitive (pdata->entry, FALSE);
6802
6803       label = gtk_label_new ("Text align :");
6804       gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 2, 3,
6805                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6806                         5, 5);
6807       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
6808
6809       hbox = gtk_hbox_new (FALSE, 0);
6810       gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 2, 3,
6811                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6812                         5, 5);
6813
6814       label = gtk_label_new ("x :");
6815       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 5);
6816
6817       adj = (GtkAdjustment *) gtk_adjustment_new (0.5, 0, 1, 0.1, 0.1, 0);
6818       pdata->x_align_spin = gtk_spin_button_new (adj, 0, 1);
6819       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6820                           GTK_SIGNAL_FUNC (adjust_align), pdata);
6821       gtk_box_pack_start (GTK_BOX (hbox), pdata->x_align_spin, FALSE, TRUE, 0);
6822       gtk_widget_set_sensitive (pdata->x_align_spin, FALSE);
6823
6824       label = gtk_label_new ("y :");
6825       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 5);
6826
6827       adj = (GtkAdjustment *) gtk_adjustment_new (0.5, 0, 1, 0.1, 0.1, 0);
6828       pdata->y_align_spin = gtk_spin_button_new (adj, 0, 1);
6829       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6830                           GTK_SIGNAL_FUNC (adjust_align), pdata);
6831       gtk_box_pack_start (GTK_BOX (hbox), pdata->y_align_spin, FALSE, TRUE, 0);
6832       gtk_widget_set_sensitive (pdata->y_align_spin, FALSE);
6833
6834       label = gtk_label_new ("Bar Style :");
6835       gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 3, 4,
6836                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6837                         5, 5);
6838       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
6839
6840       pdata->omenu2 = build_option_menu (items2, 2, 0, pdata);
6841       hbox = gtk_hbox_new (FALSE, 0);
6842       gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 3, 4,
6843                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6844                         5, 5);
6845       gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu2, TRUE, TRUE, 0);
6846
6847       label = gtk_label_new ("Block count :");
6848       gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 4, 5,
6849                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6850                         5, 5);
6851       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
6852
6853       hbox = gtk_hbox_new (FALSE, 0);
6854       gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 4, 5,
6855                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6856                         5, 5);
6857       adj = (GtkAdjustment *) gtk_adjustment_new (10, 2, 20, 1, 5, 0);
6858       pdata->block_spin = gtk_spin_button_new (adj, 0, 0);
6859       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6860                           GTK_SIGNAL_FUNC (adjust_blocks), pdata);
6861       gtk_box_pack_start (GTK_BOX (hbox), pdata->block_spin, FALSE, TRUE, 0);
6862       gtk_widget_set_sensitive (pdata->block_spin, FALSE);
6863
6864       check = gtk_check_button_new_with_label ("Activity mode");
6865       gtk_signal_connect (GTK_OBJECT (check), "clicked",
6866                           GTK_SIGNAL_FUNC (toggle_activity_mode),
6867                           pdata);
6868       gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 5, 6,
6869                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6870                         5, 5);
6871
6872       hbox = gtk_hbox_new (FALSE, 0);
6873       gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 5, 6,
6874                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6875                         5, 5);
6876       label = gtk_label_new ("Step size : ");
6877       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
6878       adj = (GtkAdjustment *) gtk_adjustment_new (3, 1, 20, 1, 5, 0);
6879       pdata->step_spin = gtk_spin_button_new (adj, 0, 0);
6880       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6881                           GTK_SIGNAL_FUNC (adjust_step), pdata);
6882       gtk_box_pack_start (GTK_BOX (hbox), pdata->step_spin, FALSE, TRUE, 0);
6883       gtk_widget_set_sensitive (pdata->step_spin, FALSE);
6884
6885       hbox = gtk_hbox_new (FALSE, 0);
6886       gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 6, 7,
6887                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6888                         5, 5);
6889       label = gtk_label_new ("Blocks :     ");
6890       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
6891       adj = (GtkAdjustment *) gtk_adjustment_new (5, 2, 10, 1, 5, 0);
6892       pdata->act_blocks_spin = gtk_spin_button_new (adj, 0, 0);
6893       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6894                           GTK_SIGNAL_FUNC (adjust_act_blocks), pdata);
6895       gtk_box_pack_start (GTK_BOX (hbox), pdata->act_blocks_spin, FALSE, TRUE,
6896                           0);
6897       gtk_widget_set_sensitive (pdata->act_blocks_spin, FALSE);
6898
6899       button = gtk_button_new_with_label ("close");
6900       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6901                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
6902                                  GTK_OBJECT (pdata->window));
6903       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6904       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pdata->window)->action_area),
6905                           button, TRUE, TRUE, 0);
6906       gtk_widget_grab_default (button);
6907     }
6908
6909   if (!GTK_WIDGET_VISIBLE (pdata->window))
6910     gtk_widget_show_all (pdata->window);
6911   else
6912     gtk_widget_destroy (pdata->window);
6913 }
6914
6915 /*
6916  * Color Preview
6917  */
6918
6919 static int color_idle = 0;
6920
6921 gint
6922 color_idle_func (GtkWidget *preview)
6923 {
6924   static int count = 1;
6925   guchar buf[768];
6926   int i, j, k;
6927
6928   for (i = 0; i < 256; i++)
6929     {
6930       for (j = 0, k = 0; j < 256; j++)
6931         {
6932           buf[k+0] = i + count;
6933           buf[k+1] = 0;
6934           buf[k+2] = j + count;
6935           k += 3;
6936         }
6937
6938       gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
6939     }
6940
6941   count += 1;
6942
6943   gtk_widget_draw (preview, NULL);
6944
6945   return TRUE;
6946 }
6947
6948 static void
6949 color_preview_destroy (GtkWidget  *widget,
6950                        GtkWidget **window)
6951 {
6952   gtk_idle_remove (color_idle);
6953   color_idle = 0;
6954
6955   *window = NULL;
6956 }
6957
6958 void
6959 create_color_preview (void)
6960 {
6961   static GtkWidget *window = NULL;
6962   GtkWidget *preview;
6963   guchar buf[768];
6964   int i, j, k;
6965
6966   if (!window)
6967     {
6968       gtk_widget_push_visual (gdk_rgb_get_visual ());
6969       gtk_widget_push_colormap (gdk_rgb_get_cmap ());
6970       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6971       gtk_widget_pop_colormap ();
6972       gtk_widget_pop_visual ();
6973
6974       gtk_signal_connect (GTK_OBJECT (window), "destroy",
6975                           GTK_SIGNAL_FUNC(color_preview_destroy),
6976                           &window);
6977
6978       gtk_window_set_title (GTK_WINDOW (window), "test");
6979       gtk_container_border_width (GTK_CONTAINER (window), 10);
6980
6981       preview = gtk_preview_new (GTK_PREVIEW_COLOR);
6982       gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
6983       gtk_container_add (GTK_CONTAINER (window), preview);
6984
6985       for (i = 0; i < 256; i++)
6986         {
6987           for (j = 0, k = 0; j < 256; j++)
6988             {
6989               buf[k+0] = i;
6990               buf[k+1] = 0;
6991               buf[k+2] = j;
6992               k += 3;
6993             }
6994
6995           gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
6996         }
6997
6998       color_idle = gtk_idle_add ((GtkFunction) color_idle_func, preview);
6999     }
7000
7001   if (!GTK_WIDGET_VISIBLE (window))
7002     gtk_widget_show_all (window);
7003   else
7004     gtk_widget_destroy (window);
7005 }
7006
7007 /*
7008  * Gray Preview
7009  */
7010
7011 static int gray_idle = 0;
7012
7013 gint
7014 gray_idle_func (GtkWidget *preview)
7015 {
7016   static int count = 1;
7017   guchar buf[256];
7018   int i, j;
7019
7020   for (i = 0; i < 256; i++)
7021     {
7022       for (j = 0; j < 256; j++)
7023         buf[j] = i + j + count;
7024
7025       gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
7026     }
7027
7028   count += 1;
7029
7030   gtk_widget_draw (preview, NULL);
7031
7032   return TRUE;
7033 }
7034
7035 static void
7036 gray_preview_destroy (GtkWidget  *widget,
7037                       GtkWidget **window)
7038 {
7039   gtk_idle_remove (gray_idle);
7040   gray_idle = 0;
7041
7042   *window = NULL;
7043 }
7044
7045 void
7046 create_gray_preview (void)
7047 {
7048   static GtkWidget *window = NULL;
7049   GtkWidget *preview;
7050   guchar buf[256];
7051   int i, j;
7052
7053   if (!window)
7054     {
7055       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7056
7057       gtk_signal_connect (GTK_OBJECT (window), "destroy",
7058                           GTK_SIGNAL_FUNC(gray_preview_destroy),
7059                           &window);
7060
7061       gtk_window_set_title (GTK_WINDOW (window), "test");
7062       gtk_container_border_width (GTK_CONTAINER (window), 10);
7063
7064       preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
7065       gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
7066       gtk_container_add (GTK_CONTAINER (window), preview);
7067
7068       for (i = 0; i < 256; i++)
7069         {
7070           for (j = 0; j < 256; j++)
7071             buf[j] = i + j;
7072
7073           gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
7074         }
7075
7076       gray_idle = gtk_idle_add ((GtkFunction) gray_idle_func, preview);
7077     }
7078
7079   if (!GTK_WIDGET_VISIBLE (window))
7080     gtk_widget_show_all (window);
7081   else
7082     gtk_widget_destroy (window);
7083 }
7084
7085
7086 /*
7087  * Selection Test
7088  */
7089
7090 void
7091 selection_test_received (GtkWidget *list, GtkSelectionData *data)
7092 {
7093   GdkAtom *atoms;
7094   GtkWidget *list_item;
7095   GList *item_list;
7096   int i, l;
7097
7098   if (data->length < 0)
7099     {
7100       g_print ("Selection retrieval failed\n");
7101       return;
7102     }
7103   if (data->type != GDK_SELECTION_TYPE_ATOM)
7104     {
7105       g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
7106       return;
7107     }
7108
7109   /* Clear out any current list items */
7110
7111   gtk_list_clear_items (GTK_LIST(list), 0, -1);
7112
7113   /* Add new items to list */
7114
7115   atoms = (GdkAtom *)data->data;
7116
7117   item_list = NULL;
7118   l = data->length / sizeof (GdkAtom);
7119   for (i = 0; i < l; i++)
7120     {
7121       char *name;
7122       name = gdk_atom_name (atoms[i]);
7123       if (name != NULL)
7124         {
7125           list_item = gtk_list_item_new_with_label (name);
7126           g_free (name);
7127         }
7128       else
7129         list_item = gtk_list_item_new_with_label ("(bad atom)");
7130
7131       gtk_widget_show (list_item);
7132       item_list = g_list_append (item_list, list_item);
7133     }
7134
7135   gtk_list_append_items (GTK_LIST (list), item_list);
7136
7137   return;
7138 }
7139
7140 void
7141 selection_test_get_targets (GtkWidget *widget, GtkWidget *list)
7142 {
7143   static GdkAtom targets_atom = GDK_NONE;
7144
7145   if (targets_atom == GDK_NONE)
7146     targets_atom = gdk_atom_intern ("TARGETS", FALSE);
7147
7148   gtk_selection_convert (list, GDK_SELECTION_PRIMARY, targets_atom,
7149                          GDK_CURRENT_TIME);
7150 }
7151
7152 void
7153 create_selection_test (void)
7154 {
7155   static GtkWidget *window = NULL;
7156   GtkWidget *button;
7157   GtkWidget *vbox;
7158   GtkWidget *scrolled_win;
7159   GtkWidget *list;
7160   GtkWidget *label;
7161
7162   if (!window)
7163     {
7164       window = gtk_dialog_new ();
7165
7166       gtk_signal_connect (GTK_OBJECT (window), "destroy",
7167                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7168                           &window);
7169
7170       gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
7171       gtk_container_border_width (GTK_CONTAINER (window), 0);
7172
7173       /* Create the list */
7174
7175       vbox = gtk_vbox_new (FALSE, 5);
7176       gtk_container_border_width (GTK_CONTAINER (vbox), 10);
7177       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox,
7178                           TRUE, TRUE, 0);
7179
7180       label = gtk_label_new ("Gets available targets for current selection");
7181       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
7182
7183       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
7184       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
7185                                       GTK_POLICY_AUTOMATIC,
7186                                       GTK_POLICY_AUTOMATIC);
7187       gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
7188       gtk_widget_set_usize (scrolled_win, 100, 200);
7189
7190       list = gtk_list_new ();
7191       gtk_container_add (GTK_CONTAINER (scrolled_win), list);
7192
7193       gtk_signal_connect (GTK_OBJECT(list), "selection_received",
7194                           GTK_SIGNAL_FUNC (selection_test_received), NULL);
7195
7196       /* .. And create some buttons */
7197       button = gtk_button_new_with_label ("Get Targets");
7198       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7199                           button, TRUE, TRUE, 0);
7200
7201       gtk_signal_connect (GTK_OBJECT (button), "clicked",
7202                           GTK_SIGNAL_FUNC (selection_test_get_targets), list);
7203
7204       button = gtk_button_new_with_label ("Quit");
7205       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7206                           button, TRUE, TRUE, 0);
7207
7208       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7209                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
7210                                  GTK_OBJECT (window));
7211     }
7212
7213   if (!GTK_WIDGET_VISIBLE (window))
7214     gtk_widget_show_all (window);
7215   else
7216     gtk_widget_destroy (window);
7217 }
7218
7219 /*
7220  * Gamma Curve
7221  */
7222
7223 void
7224 create_gamma_curve (void)
7225 {
7226   static GtkWidget *window = NULL, *curve;
7227   static int count = 0;
7228   gfloat vec[256];
7229   gint max;
7230   gint i;
7231
7232   if (!window)
7233     {
7234       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7235       gtk_window_set_title (GTK_WINDOW (window), "test");
7236       gtk_container_border_width (GTK_CONTAINER (window), 10);
7237
7238       gtk_signal_connect (GTK_OBJECT (window), "destroy",
7239                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7240                           &window);
7241
7242       curve = gtk_gamma_curve_new ();
7243       gtk_container_add (GTK_CONTAINER (window), curve);
7244       gtk_widget_show (curve);
7245     }
7246
7247   max = 127 + (count % 2)*128;
7248   gtk_curve_set_range (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
7249                        0, max, 0, max);
7250   for (i = 0; i < max; ++i)
7251     vec[i] = (127 / sqrt (max)) * sqrt (i);
7252   gtk_curve_set_vector (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
7253                         max, vec);
7254
7255   if (!GTK_WIDGET_VISIBLE (window))
7256     gtk_widget_show (window);
7257   else if (count % 4 == 3)
7258     {
7259       gtk_widget_destroy (window);
7260       window = NULL;
7261     }
7262
7263   ++count;
7264 }
7265
7266 /*
7267  * Test scrolling
7268  */
7269
7270 static int scroll_test_pos = 0.0;
7271 static GdkGC *scroll_test_gc = NULL;
7272
7273 static gint
7274 scroll_test_expose (GtkWidget *widget, GdkEventExpose *event,
7275                     GtkAdjustment *adj)
7276 {
7277   gint i,j;
7278   gint imin, imax, jmin, jmax;
7279
7280   imin = (event->area.x) / 10;
7281   imax = (event->area.x + event->area.width + 9) / 10;
7282
7283   jmin = ((int)adj->value + event->area.y) / 10;
7284   jmax = ((int)adj->value + event->area.y + event->area.height + 9) / 10;
7285
7286   gdk_window_clear_area (widget->window,
7287                          event->area.x, event->area.y,
7288                          event->area.width, event->area.height);
7289
7290   for (i=imin; i<imax; i++)
7291     for (j=jmin; j<jmax; j++)
7292       if ((i+j) % 2)
7293         gdk_draw_rectangle (widget->window,
7294                             widget->style->black_gc,
7295                             TRUE,
7296                             10*i, 10*j - (int)adj->value, 1+i%10, 1+j%10);
7297
7298   return TRUE;
7299 }
7300
7301 static void
7302 scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
7303                        GtkAdjustment *adj)
7304 {
7305   adj->page_increment = 0.9 * widget->allocation.height;
7306   adj->page_size = widget->allocation.height;
7307
7308   gtk_signal_emit_by_name (GTK_OBJECT (adj), "changed");
7309 }
7310
7311 static void
7312 scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
7313 {
7314   gint source_min = (int)adj->value - scroll_test_pos;
7315   gint source_max = source_min + widget->allocation.height;
7316   gint dest_min = 0;
7317   gint dest_max = widget->allocation.height;
7318   GdkRectangle rect;
7319   GdkEvent *event;
7320
7321   scroll_test_pos = adj->value;
7322
7323   if (!GTK_WIDGET_DRAWABLE (widget))
7324     return;
7325
7326   if (source_min < 0)
7327     {
7328       rect.x = 0;
7329       rect.y = 0;
7330       rect.width = widget->allocation.width;
7331       rect.height = -source_min;
7332       if (rect.height > widget->allocation.height)
7333         rect.height = widget->allocation.height;
7334
7335       source_min = 0;
7336       dest_min = rect.height;
7337     }
7338   else
7339     {
7340       rect.x = 0;
7341       rect.y = 2*widget->allocation.height - source_max;
7342       if (rect.y < 0)
7343         rect.y = 0;
7344       rect.width = widget->allocation.width;
7345       rect.height = widget->allocation.height - rect.y;
7346
7347       source_max = widget->allocation.height;
7348       dest_max = rect.y;
7349     }
7350
7351   if (source_min != source_max)
7352     {
7353       if (scroll_test_gc == NULL)
7354         {
7355           scroll_test_gc = gdk_gc_new (widget->window);
7356           gdk_gc_set_exposures (scroll_test_gc, TRUE);
7357         }
7358
7359       gdk_draw_pixmap (widget->window,
7360                        scroll_test_gc,
7361                        widget->window,
7362                        0, source_min,
7363                        0, dest_min,
7364                        widget->allocation.width,
7365                        source_max - source_min);
7366
7367       /* Make sure graphics expose events are processed before scrolling
7368        * again */
7369
7370       while ((event = gdk_event_get_graphics_expose (widget->window)) != NULL)
7371         {
7372           gtk_widget_event (widget, event);
7373           if (event->expose.count == 0)
7374             {
7375               gdk_event_free (event);
7376               break;
7377             }
7378           gdk_event_free (event);
7379         }
7380     }
7381
7382   if (rect.height != 0)
7383     gtk_widget_draw (widget, &rect);
7384 }
7385
7386
7387 void
7388 create_scroll_test (void)
7389 {
7390   static GtkWidget *window = NULL;
7391   GtkWidget *hbox;
7392   GtkWidget *drawing_area;
7393   GtkWidget *scrollbar;
7394   GtkWidget *button;
7395   GtkAdjustment *adj;
7396
7397   if (!window)
7398     {
7399       window = gtk_dialog_new ();
7400
7401       gtk_signal_connect (GTK_OBJECT (window), "destroy",
7402                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7403                           &window);
7404
7405       gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
7406       gtk_container_border_width (GTK_CONTAINER (window), 0);
7407
7408       hbox = gtk_hbox_new (FALSE, 0);
7409       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox,
7410                           TRUE, TRUE, 0);
7411       gtk_widget_show (hbox);
7412
7413       drawing_area = gtk_drawing_area_new ();
7414       gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 200, 200);
7415       gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
7416       gtk_widget_show (drawing_area);
7417
7418       gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK);
7419
7420       adj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0));
7421       scroll_test_pos = 0.0;
7422
7423       scrollbar = gtk_vscrollbar_new (adj);
7424       gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
7425       gtk_widget_show (scrollbar);
7426
7427       gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
7428                           GTK_SIGNAL_FUNC (scroll_test_expose), adj);
7429       gtk_signal_connect (GTK_OBJECT (drawing_area), "configure_event",
7430                           GTK_SIGNAL_FUNC (scroll_test_configure), adj);
7431
7432
7433       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7434                           GTK_SIGNAL_FUNC (scroll_test_adjustment_changed),
7435                           drawing_area);
7436
7437       /* .. And create some buttons */
7438
7439       button = gtk_button_new_with_label ("Quit");
7440       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7441                           button, TRUE, TRUE, 0);
7442
7443       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7444                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
7445                                  GTK_OBJECT (window));
7446       gtk_widget_show (button);
7447     }
7448
7449   if (!GTK_WIDGET_VISIBLE (window))
7450     gtk_widget_show (window);
7451   else
7452     gtk_widget_destroy (window);
7453 }
7454
7455 /*
7456  * Timeout Test
7457  */
7458
7459 static int timer = 0;
7460
7461 gint
7462 timeout_test (GtkWidget *label)
7463 {
7464   static int count = 0;
7465   static char buffer[32];
7466
7467   sprintf (buffer, "count: %d", ++count);
7468   gtk_label_set (GTK_LABEL (label), buffer);
7469
7470   return TRUE;
7471 }
7472
7473 void
7474 start_timeout_test (GtkWidget *widget,
7475                     GtkWidget *label)
7476 {
7477   if (!timer)
7478     {
7479       timer = gtk_timeout_add (100, (GtkFunction) timeout_test, label);
7480     }
7481 }
7482
7483 void
7484 stop_timeout_test (GtkWidget *widget,
7485                    gpointer   data)
7486 {
7487   if (timer)
7488     {
7489       gtk_timeout_remove (timer);
7490       timer = 0;
7491     }
7492 }
7493
7494 void
7495 destroy_timeout_test (GtkWidget  *widget,
7496                       GtkWidget **window)
7497 {
7498   stop_timeout_test (NULL, NULL);
7499
7500   *window = NULL;
7501 }
7502
7503 void
7504 create_timeout_test (void)
7505 {
7506   static GtkWidget *window = NULL;
7507   GtkWidget *button;
7508   GtkWidget *label;
7509
7510   if (!window)
7511     {
7512       window = gtk_dialog_new ();
7513
7514       gtk_signal_connect (GTK_OBJECT (window), "destroy",
7515                           GTK_SIGNAL_FUNC(destroy_timeout_test),
7516                           &window);
7517
7518       gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
7519       gtk_container_border_width (GTK_CONTAINER (window), 0);
7520
7521       label = gtk_label_new ("count: 0");
7522       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
7523       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
7524                           label, TRUE, TRUE, 0);
7525       gtk_widget_show (label);
7526
7527       button = gtk_button_new_with_label ("close");
7528       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7529                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
7530                                  GTK_OBJECT (window));
7531       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7532       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7533                           button, TRUE, TRUE, 0);
7534       gtk_widget_grab_default (button);
7535       gtk_widget_show (button);
7536
7537       button = gtk_button_new_with_label ("start");
7538       gtk_signal_connect (GTK_OBJECT (button), "clicked",
7539                           GTK_SIGNAL_FUNC(start_timeout_test),
7540                           label);
7541       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7542       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7543                           button, TRUE, TRUE, 0);
7544       gtk_widget_show (button);
7545
7546       button = gtk_button_new_with_label ("stop");
7547       gtk_signal_connect (GTK_OBJECT (button), "clicked",
7548                           GTK_SIGNAL_FUNC(stop_timeout_test),
7549                           NULL);
7550       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7551       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7552                           button, TRUE, TRUE, 0);
7553       gtk_widget_show (button);
7554     }
7555
7556   if (!GTK_WIDGET_VISIBLE (window))
7557     gtk_widget_show (window);
7558   else
7559     gtk_widget_destroy (window);
7560 }
7561
7562 /*
7563  * Idle Test
7564  */
7565
7566 static int idle = 0;
7567
7568 static gint
7569 idle_test (GtkWidget *label)
7570 {
7571   static int count = 0;
7572   static char buffer[32];
7573
7574   sprintf (buffer, "count: %d", ++count);
7575   gtk_label_set (GTK_LABEL (label), buffer);
7576
7577   return TRUE;
7578 }
7579
7580 static void
7581 start_idle_test (GtkWidget *widget,
7582                  GtkWidget *label)
7583 {
7584   if (!idle)
7585     {
7586       idle = gtk_idle_add ((GtkFunction) idle_test, label);
7587     }
7588 }
7589
7590 static void
7591 stop_idle_test (GtkWidget *widget,
7592                 gpointer   data)
7593 {
7594   if (idle)
7595     {
7596       gtk_idle_remove (idle);
7597       idle = 0;
7598     }
7599 }
7600
7601 static void
7602 destroy_idle_test (GtkWidget  *widget,
7603                    GtkWidget **window)
7604 {
7605   stop_idle_test (NULL, NULL);
7606
7607   *window = NULL;
7608 }
7609
7610 static void
7611 toggle_idle_container (GtkObject *button,
7612                        GtkContainer *container)
7613 {
7614   gtk_container_set_resize_mode (container, (guint) gtk_object_get_user_data (button));
7615 }
7616
7617 static void
7618 create_idle_test (void)
7619 {
7620   static GtkWidget *window = NULL;
7621   GtkWidget *button;
7622   GtkWidget *label;
7623   GtkWidget *container;
7624
7625   if (!window)
7626     {
7627       GtkWidget *frame;
7628       GtkWidget *box;
7629
7630       window = gtk_dialog_new ();
7631
7632       gtk_signal_connect (GTK_OBJECT (window), "destroy",
7633                           GTK_SIGNAL_FUNC(destroy_idle_test),
7634                           &window);
7635
7636       gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
7637       gtk_container_border_width (GTK_CONTAINER (window), 0);
7638
7639       label = gtk_label_new ("count: 0");
7640       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
7641       gtk_widget_show (label);
7642
7643       container =
7644         gtk_widget_new (GTK_TYPE_HBOX,
7645                         "GtkWidget::visible", TRUE,
7646                         /* "GtkContainer::child", gtk_widget_new (GTK_TYPE_HBOX,
7647                          * "GtkWidget::visible", TRUE,
7648                          */
7649                          "GtkContainer::child", label,
7650                         /* NULL), */
7651                         NULL);
7652       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
7653                           container, TRUE, TRUE, 0);
7654
7655       frame =
7656         gtk_widget_new (GTK_TYPE_FRAME,
7657                         "GtkContainer::border_width", 5,
7658                         "GtkFrame::label", "Label Container",
7659                         "GtkWidget::visible", TRUE,
7660                         "GtkWidget::parent", GTK_DIALOG (window)->vbox,
7661                         NULL);
7662       box =
7663         gtk_widget_new (GTK_TYPE_VBOX,
7664                         "GtkWidget::visible", TRUE,
7665                         "GtkWidget::parent", frame,
7666                         NULL);
7667       button =
7668         gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
7669                         "GtkButton::label", "Resize-Parent",
7670                         "GtkObject::user_data", (void*)GTK_RESIZE_PARENT,
7671                         "GtkObject::signal::clicked", toggle_idle_container, container,
7672                         "GtkWidget::visible", TRUE,
7673                         "GtkWidget::parent", box,
7674                         NULL);
7675       button =
7676         gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
7677                         "GtkButton::label", "Resize-Queue",
7678                         "GtkObject::user_data", (void*)GTK_RESIZE_QUEUE,
7679                         "GtkObject::signal::clicked", toggle_idle_container, container,
7680                         "GtkRadioButton::group", button,
7681                         "GtkWidget::visible", TRUE,
7682                         "GtkWidget::parent", box,
7683                         NULL);
7684       button =
7685         gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
7686                         "GtkButton::label", "Resize-Immediate",
7687                         "GtkObject::user_data", (void*)GTK_RESIZE_IMMEDIATE,
7688                         "GtkObject::signal::clicked", toggle_idle_container, container,
7689                         "GtkRadioButton::group", button,
7690                         "GtkWidget::visible", TRUE,
7691                         "GtkWidget::parent", box,
7692                         NULL);
7693
7694
7695       button = gtk_button_new_with_label ("close");
7696       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7697                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
7698                                  GTK_OBJECT (window));
7699       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7700       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7701                           button, TRUE, TRUE, 0);
7702       gtk_widget_grab_default (button);
7703       gtk_widget_show (button);
7704
7705       button = gtk_button_new_with_label ("start");
7706       gtk_signal_connect (GTK_OBJECT (button), "clicked",
7707                           GTK_SIGNAL_FUNC(start_idle_test),
7708                           label);
7709       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7710       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7711                           button, TRUE, TRUE, 0);
7712       gtk_widget_show (button);
7713
7714       button = gtk_button_new_with_label ("stop");
7715       gtk_signal_connect (GTK_OBJECT (button), "clicked",
7716                           GTK_SIGNAL_FUNC(stop_idle_test),
7717                           NULL);
7718       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7719       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7720                           button, TRUE, TRUE, 0);
7721       gtk_widget_show (button);
7722     }
7723
7724   if (!GTK_WIDGET_VISIBLE (window))
7725     gtk_widget_show (window);
7726   else
7727     gtk_widget_destroy (window);
7728 }
7729
7730 /*
7731  * rc file test
7732  */
7733
7734 void
7735 reload_rc_file (void)
7736 {
7737   GList *toplevels;
7738
7739   if (gtk_rc_reparse_all ())
7740     {
7741       toplevels = gdk_window_get_toplevels();
7742       while (toplevels)
7743         {
7744           GtkWidget *widget;
7745           gdk_window_get_user_data (toplevels->data, (gpointer *)&widget);
7746
7747           if (widget)
7748             gtk_widget_reset_rc_styles (widget);
7749
7750           toplevels = toplevels->next;
7751         }
7752       g_list_free (toplevels);
7753     }
7754 }
7755
7756 void
7757 reload_all_rc_files (void)
7758 {
7759   static GdkAtom atom_rcfiles = GDK_NONE;
7760
7761   GdkEventClient sev;
7762   int i;
7763
7764   if (!atom_rcfiles)
7765     atom_rcfiles = gdk_atom_intern("_GTK_READ_RCFILES", FALSE);
7766
7767   for(i = 0; i < 5; i++)
7768     sev.data.l[i] = 0;
7769   sev.data_format = 32;
7770   sev.message_type = atom_rcfiles;
7771   gdk_event_send_clientmessage_toall ((GdkEvent *) &sev);
7772 }
7773
7774 void
7775 create_rc_file (void)
7776 {
7777   static GtkWidget *window = NULL;
7778   GtkWidget *button;
7779
7780   if (!window)
7781     {
7782       window = gtk_dialog_new ();
7783
7784       gtk_signal_connect (GTK_OBJECT (window), "destroy",
7785                           GTK_SIGNAL_FUNC(destroy_idle_test),
7786                           &window);
7787
7788       gtk_window_set_title (GTK_WINDOW (window), "Reload Rc file");
7789       gtk_container_border_width (GTK_CONTAINER (window), 0);
7790
7791       button = gtk_button_new_with_label ("Reload");
7792       gtk_signal_connect (GTK_OBJECT (button), "clicked",
7793                           GTK_SIGNAL_FUNC(reload_rc_file), NULL);
7794       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7795       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7796                           button, TRUE, TRUE, 0);
7797       gtk_widget_grab_default (button);
7798       gtk_widget_show (button);
7799
7800       button = gtk_button_new_with_label ("Reload All");
7801       gtk_signal_connect (GTK_OBJECT (button), "clicked",
7802                           GTK_SIGNAL_FUNC(reload_all_rc_files), NULL);
7803       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7804       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7805                           button, TRUE, TRUE, 0);
7806       gtk_widget_show (button);
7807
7808       button = gtk_button_new_with_label ("Close");
7809       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7810                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
7811                                  GTK_OBJECT (window));
7812       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7813       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7814                           button, TRUE, TRUE, 0);
7815       gtk_widget_show (button);
7816
7817     }
7818
7819   if (!GTK_WIDGET_VISIBLE (window))
7820     gtk_widget_show (window);
7821   else
7822     gtk_widget_destroy (window);
7823 }
7824
7825 /*
7826  * Test of recursive mainloop
7827  */
7828
7829 void
7830 mainloop_destroyed (GtkWidget *w, GtkWidget **window)
7831 {
7832   *window = NULL;
7833   gtk_main_quit ();
7834 }
7835
7836 void
7837 create_mainloop (void)
7838 {
7839   static GtkWidget *window = NULL;
7840   GtkWidget *label;
7841   GtkWidget *button;
7842
7843   if (!window)
7844     {
7845       window = gtk_dialog_new ();
7846
7847       gtk_window_set_title (GTK_WINDOW (window), "Test Main Loop");
7848
7849       gtk_signal_connect (GTK_OBJECT (window), "destroy",
7850                           GTK_SIGNAL_FUNC(mainloop_destroyed),
7851                           &window);
7852
7853       label = gtk_label_new ("In recursive main loop...");
7854       gtk_misc_set_padding (GTK_MISC(label), 20, 20);
7855
7856       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), label,
7857                           TRUE, TRUE, 0);
7858       gtk_widget_show (label);
7859
7860       button = gtk_button_new_with_label ("Leave");
7861       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button,
7862                           FALSE, TRUE, 0);
7863
7864       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7865                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
7866                                  GTK_OBJECT (window));
7867
7868       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7869       gtk_widget_grab_default (button);
7870
7871       gtk_widget_show (button);
7872     }
7873
7874   if (!GTK_WIDGET_VISIBLE (window))
7875     {
7876       gtk_widget_show (window);
7877
7878       g_print ("create_mainloop: start\n");
7879       gtk_main ();
7880       g_print ("create_mainloop: done\n");
7881     }
7882   else
7883     gtk_widget_destroy (window);
7884 }
7885
7886 /*
7887  * Main Window and Exit
7888  */
7889
7890 void
7891 do_exit (GtkWidget *widget, GtkWidget *window)
7892 {
7893   gtk_widget_destroy (window);
7894   gtk_main_quit ();
7895 }
7896
7897 void
7898 create_main_window (void)
7899 {
7900   struct {
7901     char *label;
7902     void (*func) ();
7903   } buttons[] =
7904     {
7905       { "button box", create_button_box },
7906       { "buttons", create_buttons },
7907       { "check buttons", create_check_buttons },
7908       { "clist", create_clist},
7909       { "color selection", create_color_selection },
7910       { "ctree", create_ctree },
7911       { "cursors", create_cursors },
7912       { "dialog", create_dialog },
7913       /*      { "dnd", create_dnd }, */
7914       { "entry", create_entry },
7915       { "file selection", create_file_selection },
7916       { "font selection", create_font_selection },
7917       { "gamma curve", create_gamma_curve },
7918       { "handle box", create_handle_box },
7919       { "item factory", create_item_factory },
7920       { "list", create_list },
7921       { "menus", create_menus },
7922       { "modal window", create_modal_window },
7923       { "notebook", create_notebook },
7924       { "panes", create_panes },
7925       { "pixmap", create_pixmap },
7926       { "preview color", create_color_preview },
7927       { "preview gray", create_gray_preview },
7928       { "progress bar", create_progress_bar },
7929       { "radio buttons", create_radio_buttons },
7930       { "range controls", create_range_controls },
7931       { "rc file", create_rc_file },
7932       { "reparent", create_reparent },
7933       { "rulers", create_rulers },
7934       { "saved position", create_saved_position },
7935       { "scrolled windows", create_scrolled_windows },
7936       { "shapes", create_shapes },
7937       { "spinbutton", create_spins },
7938       { "statusbar", create_statusbar },
7939       { "test idle", create_idle_test },
7940       { "test mainloop", create_mainloop },
7941       { "test scrolling", create_scroll_test },
7942       { "test selection", create_selection_test },
7943       { "test timeout", create_timeout_test },
7944       { "text", create_text },
7945       { "toggle buttons", create_toggle_buttons },
7946       { "toolbar", create_toolbar },
7947       { "tooltips", create_tooltips },
7948       { "tree", create_tree_mode_window},
7949       { "WM hints", create_wmhints },
7950     };
7951   int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
7952   GtkWidget *window;
7953   GtkWidget *box1;
7954   GtkWidget *box2;
7955   GtkWidget *scrolled_window;
7956   GtkWidget *button;
7957   GtkWidget *label;
7958   gchar buffer[64];
7959   GtkWidget *separator;
7960   int i;
7961
7962   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7963   gtk_window_set_policy (GTK_WINDOW (window), FALSE, FALSE, FALSE);
7964   gtk_widget_set_name (window, "main window");
7965   gtk_widget_set_usize (window, 200, 400);
7966   gtk_widget_set_uposition (window, 20, 20);
7967
7968   gtk_signal_connect (GTK_OBJECT (window), "destroy",
7969                       GTK_SIGNAL_FUNC(gtk_main_quit),
7970                       NULL);
7971   gtk_signal_connect (GTK_OBJECT (window), "delete-event",
7972                       GTK_SIGNAL_FUNC (gtk_false),
7973                       NULL);
7974
7975   box1 = gtk_vbox_new (FALSE, 0);
7976   gtk_container_add (GTK_CONTAINER (window), box1);
7977
7978   if (gtk_micro_version > 0)
7979     sprintf (buffer,
7980              "Gtk+ v%d.%d.%d",
7981              gtk_major_version,
7982              gtk_minor_version,
7983              gtk_micro_version);
7984   else
7985     sprintf (buffer,
7986              "Gtk+ v%d.%d",
7987              gtk_major_version,
7988              gtk_minor_version);
7989
7990   label = gtk_label_new (buffer);
7991   gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
7992
7993   scrolled_window = gtk_scrolled_window_new (NULL, NULL);
7994   gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
7995   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
7996                                   GTK_POLICY_AUTOMATIC,
7997                                   GTK_POLICY_AUTOMATIC);
7998   GTK_WIDGET_UNSET_FLAGS (GTK_SCROLLED_WINDOW (scrolled_window)->vscrollbar, GTK_CAN_FOCUS);
7999   gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
8000
8001   box2 = gtk_vbox_new (FALSE, 0);
8002   gtk_container_border_width (GTK_CONTAINER (box2), 10);
8003   gtk_container_add (GTK_CONTAINER (scrolled_window), box2);
8004   gtk_container_set_focus_vadjustment (GTK_CONTAINER (box2),
8005                                        gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
8006   gtk_widget_show (box2);
8007
8008   for (i = 0; i < nbuttons; i++)
8009     {
8010       button = gtk_button_new_with_label (buttons[i].label);
8011       if (buttons[i].func)
8012         gtk_signal_connect (GTK_OBJECT (button),
8013                             "clicked",
8014                             GTK_SIGNAL_FUNC(buttons[i].func),
8015                             NULL);
8016       else
8017         gtk_widget_set_sensitive (button, FALSE);
8018       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
8019     }
8020
8021   separator = gtk_hseparator_new ();
8022   gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
8023
8024   box2 = gtk_vbox_new (FALSE, 10);
8025   gtk_container_border_width (GTK_CONTAINER (box2), 10);
8026   gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
8027
8028   button = gtk_button_new_with_label ("close");
8029   gtk_signal_connect (GTK_OBJECT (button), "clicked",
8030                       GTK_SIGNAL_FUNC (do_exit),
8031                       window);
8032   gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
8033   GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8034   gtk_widget_grab_default (button);
8035
8036   gtk_widget_show_all (window);
8037 }
8038
8039 int
8040 main (int argc, char *argv[])
8041 {
8042   GtkBindingSet *binding_set;
8043
8044   srand (time (NULL));
8045
8046   gtk_set_locale ();
8047
8048   gtk_init (&argc, &argv);
8049
8050   gdk_rgb_init ();
8051
8052   /* bindings test
8053    */
8054   binding_set = gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_WIDGET));
8055   gtk_binding_entry_add_signal (binding_set,
8056                                 '9', GDK_CONTROL_MASK | GDK_RELEASE_MASK,
8057                                 "debug_msg",
8058                                 1,
8059                                 GTK_TYPE_STRING, "GtkWidgetClass <ctrl><release>9 test");
8060
8061   gtk_rc_parse ("testgtkrc");
8062
8063   create_main_window ();
8064
8065   gtk_main ();
8066
8067   return 0;
8068 }