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