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