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  * GtkPixmap
1717  */
1718
1719 static void
1720 create_pixmap (void)
1721 {
1722   static GtkWidget *window = NULL;
1723   GtkWidget *box1;
1724   GtkWidget *box2;
1725   GtkWidget *box3;
1726   GtkWidget *button;
1727   GtkWidget *label;
1728   GtkWidget *separator;
1729   GtkWidget *pixmapwid;
1730   GdkPixmap *pixmap;
1731   GdkBitmap *mask;
1732   GtkStyle *style;
1733
1734   if (!window)
1735     {
1736       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1737
1738       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1739                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1740                           &window);
1741
1742       gtk_window_set_title (GTK_WINDOW (window), "GtkPixmap");
1743       gtk_container_border_width (GTK_CONTAINER (window), 0);
1744       gtk_widget_realize(window);
1745
1746       box1 = gtk_vbox_new (FALSE, 0);
1747       gtk_container_add (GTK_CONTAINER (window), box1);
1748
1749       box2 = gtk_vbox_new (FALSE, 10);
1750       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1751       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1752
1753       button = gtk_button_new ();
1754       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
1755
1756       style = gtk_widget_get_style(button);
1757
1758       pixmap = gdk_pixmap_create_from_xpm (window->window, &mask,
1759                                            &style->bg[GTK_STATE_NORMAL],
1760                                            "test.xpm");
1761       pixmapwid = gtk_pixmap_new (pixmap, mask);
1762
1763       label = gtk_label_new ("Pixmap\ntest");
1764       box3 = gtk_hbox_new (FALSE, 0);
1765       gtk_container_border_width (GTK_CONTAINER (box3), 2);
1766       gtk_container_add (GTK_CONTAINER (box3), pixmapwid);
1767       gtk_container_add (GTK_CONTAINER (box3), label);
1768       gtk_container_add (GTK_CONTAINER (button), box3);
1769
1770       separator = gtk_hseparator_new ();
1771       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1772
1773       box2 = gtk_vbox_new (FALSE, 10);
1774       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1775       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1776
1777       button = gtk_button_new_with_label ("close");
1778       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1779                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1780                                  GTK_OBJECT (window));
1781       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1782       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1783       gtk_widget_grab_default (button);
1784     }
1785
1786   if (!GTK_WIDGET_VISIBLE (window))
1787     gtk_widget_show_all (window);
1788   else
1789     gtk_widget_destroy (window);
1790 }
1791
1792 static void
1793 tips_query_widget_entered (GtkTipsQuery   *tips_query,
1794                            GtkWidget      *widget,
1795                            const gchar    *tip_text,
1796                            const gchar    *tip_private,
1797                            GtkWidget      *toggle)
1798 {
1799   if (GTK_TOGGLE_BUTTON (toggle)->active)
1800     {
1801       gtk_label_set (GTK_LABEL (tips_query), tip_text ? "There is a Tip!" : "There is no Tip!");
1802       /* don't let GtkTipsQuery reset it's label */
1803       gtk_signal_emit_stop_by_name (GTK_OBJECT (tips_query), "widget_entered");
1804     }
1805 }
1806
1807 static gint
1808 tips_query_widget_selected (GtkWidget      *tips_query,
1809                             GtkWidget      *widget,
1810                             const gchar    *tip_text,
1811                             const gchar    *tip_private,
1812                             GdkEventButton *event,
1813                             gpointer        func_data)
1814 {
1815   if (widget)
1816     g_print ("Help \"%s\" requested for <%s>\n",
1817              tip_private ? tip_private : "None",
1818              gtk_type_name (GTK_OBJECT_TYPE (widget)));
1819   return TRUE;
1820 }
1821
1822 static void
1823 create_tooltips (void)
1824 {
1825   static GtkWidget *window = NULL;
1826   GtkWidget *box1;
1827   GtkWidget *box2;
1828   GtkWidget *box3;
1829   GtkWidget *button;
1830   GtkWidget *toggle;
1831   GtkWidget *frame;
1832   GtkWidget *tips_query;
1833   GtkWidget *separator;
1834   GtkTooltips *tooltips;
1835
1836   if (!window)
1837     {
1838       window =
1839         gtk_widget_new (gtk_window_get_type (),
1840                         "GtkWindow::type", GTK_WINDOW_TOPLEVEL,
1841                         "GtkContainer::border_width", 0,
1842                         "GtkWindow::title", "Tooltips",
1843                         "GtkWindow::allow_shrink", TRUE,
1844                         "GtkWindow::allow_grow", FALSE,
1845                         "GtkWindow::auto_shrink", TRUE,
1846                         "GtkWidget::width", 200,
1847                         NULL);
1848
1849       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1850                           GTK_SIGNAL_FUNC (destroy_tooltips),
1851                           &window);
1852
1853       tooltips=gtk_tooltips_new();
1854       gtk_object_set_data (GTK_OBJECT (window), "tooltips", tooltips);
1855
1856       box1 = gtk_vbox_new (FALSE, 0);
1857       gtk_container_add (GTK_CONTAINER (window), box1);
1858
1859       box2 = gtk_vbox_new (FALSE, 10);
1860       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1861       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1862
1863       button = gtk_toggle_button_new_with_label ("button1");
1864       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1865
1866       gtk_tooltips_set_tip (tooltips,button,"This is button 1", "ContextHelp/buttons/1");
1867
1868       button = gtk_toggle_button_new_with_label ("button2");
1869       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1870
1871       gtk_tooltips_set_tip (tooltips,
1872                             button,
1873                             "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.",
1874                             "ContextHelp/buttons/2_long");
1875
1876       toggle = gtk_toggle_button_new_with_label ("Override TipsQuery Label");
1877       gtk_box_pack_start (GTK_BOX (box2), toggle, TRUE, TRUE, 0);
1878
1879       gtk_tooltips_set_tip (tooltips, toggle, "Toggle TipsQuery view.", "Hi msw! ;)");
1880
1881       box3 =
1882         gtk_widget_new (gtk_vbox_get_type (),
1883                         "GtkBox::homogeneous", FALSE,
1884                         "GtkBox::spacing", 5,
1885                         "GtkContainer::border_width", 5,
1886                         "GtkWidget::visible", TRUE,
1887                         NULL);
1888
1889       tips_query = gtk_tips_query_new ();
1890
1891       button =
1892         gtk_widget_new (gtk_button_get_type (),
1893                         "GtkButton::label", "[?]",
1894                         "GtkWidget::visible", TRUE,
1895                         "GtkWidget::parent", box3,
1896                         "GtkObject::object_signal::clicked", gtk_tips_query_start_query, tips_query,
1897                         NULL);
1898       gtk_box_set_child_packing (GTK_BOX (box3), button, FALSE, FALSE, 0, GTK_PACK_START);
1899       gtk_tooltips_set_tip (tooltips,
1900                             button,
1901                             "Start the Tooltips Inspector",
1902                             "ContextHelp/buttons/?");
1903
1904
1905       gtk_widget_set (tips_query,
1906                       "GtkWidget::visible", TRUE,
1907                       "GtkWidget::parent", box3,
1908                       "GtkTipsQuery::caller", button,
1909                       "GtkObject::signal::widget_entered", tips_query_widget_entered, toggle,
1910                       "GtkObject::signal::widget_selected", tips_query_widget_selected, NULL,
1911                       NULL);
1912
1913       frame =
1914         gtk_widget_new (gtk_frame_get_type (),
1915                         "GtkFrame::label", "ToolTips Inspector",
1916                         "GtkFrame::label_xalign", (double) 0.5,
1917                         "GtkContainer::border_width", 0,
1918                         "GtkWidget::visible", TRUE,
1919                         "GtkWidget::parent", box2,
1920                         "GtkContainer::child", box3,
1921                         NULL);
1922       gtk_box_set_child_packing (GTK_BOX (box2), frame, TRUE, TRUE, 10, GTK_PACK_START);
1923
1924       separator = gtk_hseparator_new ();
1925       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1926
1927       box2 = gtk_vbox_new (FALSE, 10);
1928       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1929       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1930
1931       button = gtk_button_new_with_label ("close");
1932       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1933                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1934                                  GTK_OBJECT (window));
1935       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1936       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1937       gtk_widget_grab_default (button);
1938
1939       gtk_tooltips_set_tip (tooltips, button, "Push this button to close window", "ContextHelp/buttons/Close");
1940     }
1941
1942   if (!GTK_WIDGET_VISIBLE (window))
1943     gtk_widget_show_all (window);
1944   else
1945     gtk_widget_destroy (window);
1946 }
1947
1948 /*
1949  * Menu demo
1950  */
1951
1952 static GtkWidget*
1953 create_menu (gint depth, gboolean tearoff)
1954 {
1955   GtkWidget *menu;
1956   GtkWidget *menuitem;
1957   GSList *group;
1958   char buf[32];
1959   int i, j;
1960
1961   if (depth < 1)
1962     return NULL;
1963
1964   menu = gtk_menu_new ();
1965   group = NULL;
1966
1967   if (tearoff)
1968     {
1969       menuitem = gtk_tearoff_menu_item_new ();
1970       gtk_menu_append (GTK_MENU (menu), menuitem);
1971       gtk_widget_show (menuitem);
1972     }
1973
1974   for (i = 0, j = 1; i < 5; i++, j++)
1975     {
1976       sprintf (buf, "item %2d - %d", depth, j);
1977       menuitem = gtk_radio_menu_item_new_with_label (group, buf);
1978       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
1979       if (depth % 2)
1980         gtk_check_menu_item_set_show_toggle (GTK_CHECK_MENU_ITEM (menuitem), TRUE);
1981       gtk_menu_append (GTK_MENU (menu), menuitem);
1982       gtk_widget_show (menuitem);
1983       if (i == 3)
1984         gtk_widget_set_sensitive (menuitem, FALSE);
1985
1986       gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (depth - 1, TRUE));
1987     }
1988
1989   return menu;
1990 }
1991
1992 static void
1993 create_menus (void)
1994 {
1995   static GtkWidget *window = NULL;
1996   GtkWidget *box1;
1997   GtkWidget *box2;
1998   GtkWidget *button;
1999   GtkWidget *optionmenu;
2000   GtkWidget *separator;
2001
2002   if (!window)
2003     {
2004       GtkWidget *menubar;
2005       GtkWidget *menu;
2006       GtkWidget *menuitem;
2007       GtkAccelGroup *accel_group;
2008
2009       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2010
2011       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2012                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2013                           &window);
2014       gtk_signal_connect (GTK_OBJECT (window), "delete-event",
2015                           GTK_SIGNAL_FUNC (gtk_true),
2016                           NULL);
2017
2018       accel_group = gtk_accel_group_new ();
2019       gtk_accel_group_attach (accel_group, GTK_OBJECT (window));
2020
2021       gtk_window_set_title (GTK_WINDOW (window), "menus");
2022       gtk_container_border_width (GTK_CONTAINER (window), 0);
2023
2024
2025       box1 = gtk_vbox_new (FALSE, 0);
2026       gtk_container_add (GTK_CONTAINER (window), box1);
2027       gtk_widget_show (box1);
2028
2029       menubar = gtk_menu_bar_new ();
2030       gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
2031       gtk_widget_show (menubar);
2032
2033       menu = create_menu (2, TRUE);
2034
2035       menuitem = gtk_menu_item_new_with_label ("test\nline2");
2036       gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
2037       gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2038       gtk_widget_show (menuitem);
2039
2040       menuitem = gtk_menu_item_new_with_label ("foo");
2041       gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (3, TRUE));
2042       gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2043       gtk_widget_show (menuitem);
2044
2045       menuitem = gtk_menu_item_new_with_label ("bar");
2046       gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4, TRUE));
2047       gtk_menu_item_right_justify (GTK_MENU_ITEM (menuitem));
2048       gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2049       gtk_widget_show (menuitem);
2050
2051       box2 = gtk_vbox_new (FALSE, 10);
2052       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2053       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2054       gtk_widget_show (box2);
2055
2056       menu = create_menu (1, FALSE);
2057       gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);
2058
2059       menuitem = gtk_check_menu_item_new_with_label ("Accelerate Me");
2060       gtk_menu_append (GTK_MENU (menu), menuitem);
2061       gtk_widget_show (menuitem);
2062       gtk_widget_add_accelerator (menuitem,
2063                                   "activate",
2064                                   accel_group,
2065                                   GDK_F1,
2066                                   0,
2067                                   GTK_ACCEL_VISIBLE | GTK_ACCEL_SIGNAL_VISIBLE);
2068       menuitem = gtk_check_menu_item_new_with_label ("Accelerator Locked");
2069       gtk_menu_append (GTK_MENU (menu), menuitem);
2070       gtk_widget_show (menuitem);
2071       gtk_widget_add_accelerator (menuitem,
2072                                   "activate",
2073                                   accel_group,
2074                                   GDK_F2,
2075                                   0,
2076                                   GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
2077       menuitem = gtk_check_menu_item_new_with_label ("Accelerators Frozen");
2078       gtk_menu_append (GTK_MENU (menu), menuitem);
2079       gtk_widget_show (menuitem);
2080       gtk_widget_add_accelerator (menuitem,
2081                                   "activate",
2082                                   accel_group,
2083                                   GDK_F2,
2084                                   0,
2085                                   GTK_ACCEL_VISIBLE);
2086       gtk_widget_add_accelerator (menuitem,
2087                                   "activate",
2088                                   accel_group,
2089                                   GDK_F3,
2090                                   0,
2091                                   GTK_ACCEL_VISIBLE);
2092       gtk_widget_freeze_accelerators (menuitem);
2093
2094       optionmenu = gtk_option_menu_new ();
2095       gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), menu);
2096       gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu), 3);
2097       gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0);
2098       gtk_widget_show (optionmenu);
2099
2100       separator = gtk_hseparator_new ();
2101       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2102       gtk_widget_show (separator);
2103
2104       box2 = gtk_vbox_new (FALSE, 10);
2105       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2106       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2107       gtk_widget_show (box2);
2108
2109       button = gtk_button_new_with_label ("close");
2110       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2111                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2112                                  GTK_OBJECT (window));
2113       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2114       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2115       gtk_widget_grab_default (button);
2116       gtk_widget_show (button);
2117     }
2118
2119   if (!GTK_WIDGET_VISIBLE (window))
2120     gtk_widget_show (window);
2121   else
2122     gtk_widget_destroy (window);
2123 }
2124
2125 static void
2126 gtk_ifactory_cb (gpointer             callback_data,
2127                  guint                callback_action,
2128                  GtkWidget           *widget)
2129 {
2130   g_message ("ItemFactory: activated \"%s\"", gtk_item_factory_path_from_widget (widget));
2131 }
2132
2133 static GtkItemFactoryEntry menu_items[] =
2134 {
2135   { "/_File",            NULL,         gtk_ifactory_cb,       0, "<Branch>" },
2136   { "/File/tearoff1",    NULL,         gtk_ifactory_cb,       0, "<Tearoff>" },
2137   { "/File/_New",        "<control>N", gtk_ifactory_cb,       0 },
2138   { "/File/_Open",       "<control>O", gtk_ifactory_cb,       0 },
2139   { "/File/_Save",       "<control>S", gtk_ifactory_cb,       0 },
2140   { "/File/Save _As...", NULL,         gtk_ifactory_cb,       0 },
2141   { "/File/sep1",        NULL,         gtk_ifactory_cb,       0, "<Separator>" },
2142   { "/File/_Quit",       "<control>Q", gtk_ifactory_cb,       0 },
2143
2144   { "/_Preferences",                    NULL, gtk_ifactory_cb, 0, "<Branch>" },
2145   { "/_Preferences/_Color",             NULL, gtk_ifactory_cb, 0, "<Branch>" },
2146   { "/_Preferences/Color/_Red",         NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2147   { "/_Preferences/Color/_Green",       NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2148   { "/_Preferences/Color/_Blue",        NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2149   { "/_Preferences/_Shape",             NULL, gtk_ifactory_cb, 0, "<Branch>" },
2150   { "/_Preferences/Shape/_Square",      NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2151   { "/_Preferences/Shape/_Rectangle",   NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2152   { "/_Preferences/Shape/_Oval",        NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2153
2154   { "/_Help",            NULL,         gtk_ifactory_cb,       0, "<LastBranch>" },
2155   { "/Help/_About",      NULL,         gtk_ifactory_cb,       0 },
2156 };
2157
2158 static int nmenu_items = sizeof (menu_items) / sizeof (menu_items[0]);
2159
2160 static void
2161 create_item_factory (void)
2162 {
2163   static GtkWidget *window = NULL;
2164
2165   if (!window)
2166     {
2167       GtkWidget *box1;
2168       GtkWidget *box2;
2169       GtkWidget *separator;
2170       GtkWidget *label;
2171       GtkWidget *button;
2172       GtkAccelGroup *accel_group;
2173       GtkItemFactory *item_factory;
2174
2175       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2176
2177       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2178                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2179                           &window);
2180       gtk_signal_connect (GTK_OBJECT (window), "delete-event",
2181                           GTK_SIGNAL_FUNC (gtk_true),
2182                           NULL);
2183
2184       accel_group = gtk_accel_group_new ();
2185       item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group);
2186       gtk_item_factory_create_items (item_factory, nmenu_items, menu_items, NULL);
2187       gtk_accel_group_attach (accel_group, GTK_OBJECT (window));
2188       gtk_window_set_title (GTK_WINDOW (window), "Item Factory");
2189       gtk_container_border_width (GTK_CONTAINER (window), 0);
2190
2191       box1 = gtk_vbox_new (FALSE, 0);
2192       gtk_container_add (GTK_CONTAINER (window), box1);
2193
2194       gtk_box_pack_start (GTK_BOX (box1),
2195                           gtk_item_factory_get_widget (item_factory, "<main>"),
2196                           FALSE, FALSE, 0);
2197
2198       label = gtk_label_new ("Type\n<alt>\nto start");
2199       gtk_widget_set_usize (label, 200, 200);
2200       gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5);
2201       gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
2202
2203
2204       separator = gtk_hseparator_new ();
2205       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2206
2207
2208       box2 = gtk_vbox_new (FALSE, 10);
2209       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2210       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2211
2212       button = gtk_button_new_with_label ("close");
2213       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2214                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2215                                  GTK_OBJECT (window));
2216       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2217       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2218       gtk_widget_grab_default (button);
2219
2220       gtk_widget_show_all (window);
2221     }
2222   else
2223     gtk_widget_destroy (window);
2224 }
2225
2226 /*
2227  * GtkScrolledWindow
2228  */
2229
2230 static void
2231 scrolled_windows_remove (GtkWidget *widget, GtkWidget *scrollwin)
2232 {
2233   static GtkWidget *parent = NULL;
2234   static GtkWidget *float_parent;
2235
2236   if (parent)
2237     {
2238       gtk_widget_reparent (scrollwin, parent);
2239       gtk_widget_destroy (float_parent);
2240       float_parent = NULL;
2241       parent = NULL;
2242     }
2243   else
2244     {
2245       parent = widget->parent;
2246       float_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2247       gtk_widget_reparent (scrollwin, float_parent);
2248       gtk_widget_show (float_parent);
2249     }
2250 }
2251
2252 /*
2253  create_modal_window
2254  */
2255
2256 static gboolean
2257 cmw_destroy_cb(GtkWidget *widget)
2258 {
2259   /* This is needed to get out of gtk_main */
2260   gtk_main_quit ();
2261
2262   return FALSE;
2263 }
2264
2265 static void
2266 cmw_color (GtkWidget *widget)
2267 {
2268     GtkWidget *csd;
2269
2270     csd=gtk_color_selection_dialog_new ("This is a modal color selection dialog");
2271
2272     /* Set as modal */
2273     gtk_window_set_modal (GTK_WINDOW(csd),TRUE);
2274
2275     gtk_signal_connect (GTK_OBJECT(csd), "destroy",
2276                         GTK_SIGNAL_FUNC(cmw_destroy_cb),NULL);
2277
2278     gtk_signal_connect_object (GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(csd)->ok_button),
2279                                "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
2280                                GTK_OBJECT (csd));
2281     gtk_signal_connect_object (GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(csd)->cancel_button),
2282                                "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
2283                                GTK_OBJECT (csd));
2284
2285     /* wait until destroy calls gtk_main_quit */
2286     gtk_widget_show (csd);
2287     gtk_main ();
2288 }
2289
2290 static void
2291 cmw_file (GtkWidget *widget)
2292 {
2293     GtkWidget *fs;
2294
2295     fs = gtk_file_selection_new("This is a modal file selection dialog");
2296
2297     /* Set as modal */
2298     gtk_window_set_modal (GTK_WINDOW(fs),TRUE);
2299
2300     gtk_signal_connect (GTK_OBJECT(fs), "destroy",
2301                         GTK_SIGNAL_FUNC(cmw_destroy_cb),NULL);
2302
2303     gtk_signal_connect_object (GTK_OBJECT(GTK_FILE_SELECTION(fs)->ok_button),
2304                                "clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy),
2305                                GTK_OBJECT (fs));
2306     gtk_signal_connect_object (GTK_OBJECT(GTK_FILE_SELECTION(fs)->cancel_button),
2307                                "clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy),
2308                                GTK_OBJECT (fs));
2309
2310     /* wait until destroy calls gtk_main_quit */
2311     gtk_widget_show (fs);
2312
2313     gtk_main();
2314 }
2315
2316
2317 static void
2318 create_modal_window (void)
2319 {
2320   GtkWidget *window = NULL;
2321   GtkWidget *box1,*box2;
2322   GtkWidget *frame1;
2323   GtkWidget *btnColor,*btnFile,*btnClose;
2324
2325   /* Create modal window (Here you can use any window descendent )*/
2326   window=gtk_window_new (GTK_WINDOW_TOPLEVEL);
2327   gtk_window_set_title (GTK_WINDOW(window),"This window is modal");
2328
2329   /* Set window as modal */
2330   gtk_window_set_modal (GTK_WINDOW(window),TRUE);
2331
2332   /* Create widgets */
2333   box1 = gtk_vbox_new (FALSE,5);
2334    frame1 = gtk_frame_new ("Standard dialogs in modal form");
2335     box2 = gtk_vbox_new (TRUE,5);
2336      btnColor = gtk_button_new_with_label ("Color");
2337      btnFile = gtk_button_new_with_label ("File Selection");
2338      btnClose = gtk_button_new_with_label ("Close");
2339
2340   /* Init widgets */
2341   gtk_container_border_width (GTK_CONTAINER(box1),3);
2342   gtk_container_border_width (GTK_CONTAINER(box2),3);
2343
2344   /* Pack widgets */
2345   gtk_container_add (GTK_CONTAINER (window), box1);
2346    gtk_box_pack_start (GTK_BOX (box1), frame1, TRUE, TRUE, 4);
2347     gtk_container_add (GTK_CONTAINER (frame1), box2);
2348      gtk_box_pack_start (GTK_BOX (box2), btnColor, FALSE, FALSE, 4);
2349      gtk_box_pack_start (GTK_BOX (box2), btnFile, FALSE, FALSE, 4);
2350    gtk_box_pack_start (GTK_BOX (box1), gtk_hseparator_new (), FALSE, FALSE, 4);
2351    gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4);
2352
2353   /* connect signals */
2354   gtk_signal_connect_object (GTK_OBJECT (btnClose), "clicked",
2355                              GTK_SIGNAL_FUNC (gtk_widget_destroy),
2356                              GTK_OBJECT (window));
2357
2358   gtk_signal_connect (GTK_OBJECT (window), "destroy",
2359                       GTK_SIGNAL_FUNC (cmw_destroy_cb),NULL);
2360
2361   gtk_signal_connect (GTK_OBJECT (btnColor), "clicked",
2362                       GTK_SIGNAL_FUNC (cmw_color),NULL);
2363   gtk_signal_connect (GTK_OBJECT (btnFile), "clicked",
2364                       GTK_SIGNAL_FUNC (cmw_file),NULL);
2365
2366   /* Show widgets */
2367   gtk_widget_show_all (window);
2368
2369   /* wait until dialog get destroyed */
2370   gtk_main();
2371 }
2372
2373 /*
2374  * GtkScrolledWindow
2375  */
2376
2377 static void
2378 create_scrolled_windows (void)
2379 {
2380   static GtkWidget *window;
2381   GtkWidget *scrolled_window;
2382   GtkWidget *table;
2383   GtkWidget *button;
2384   char buffer[32];
2385   int i, j;
2386
2387   if (!window)
2388     {
2389       window = gtk_dialog_new ();
2390
2391       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2392                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2393                           &window);
2394
2395       gtk_window_set_title (GTK_WINDOW (window), "dialog");
2396       gtk_container_border_width (GTK_CONTAINER (window), 0);
2397
2398
2399       scrolled_window = gtk_scrolled_window_new (NULL, NULL);
2400       gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
2401       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
2402                                       GTK_POLICY_AUTOMATIC,
2403                                       GTK_POLICY_AUTOMATIC);
2404       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
2405                           scrolled_window, TRUE, TRUE, 0);
2406       gtk_widget_show (scrolled_window);
2407
2408       table = gtk_table_new (20, 20, FALSE);
2409       gtk_table_set_row_spacings (GTK_TABLE (table), 10);
2410       gtk_table_set_col_spacings (GTK_TABLE (table), 10);
2411       gtk_container_add (GTK_CONTAINER (scrolled_window), table);
2412       gtk_container_set_focus_hadjustment (GTK_CONTAINER (table),
2413                                            gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
2414       gtk_container_set_focus_vadjustment (GTK_CONTAINER (table),
2415                                            gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
2416       gtk_widget_show (table);
2417
2418       for (i = 0; i < 20; i++)
2419         for (j = 0; j < 20; j++)
2420           {
2421             sprintf (buffer, "button (%d,%d)\n", i, j);
2422             button = gtk_toggle_button_new_with_label (buffer);
2423             gtk_table_attach_defaults (GTK_TABLE (table), button,
2424                                        i, i+1, j, j+1);
2425             gtk_widget_show (button);
2426           }
2427
2428
2429       button = gtk_button_new_with_label ("close");
2430       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2431                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2432                                  GTK_OBJECT (window));
2433       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2434       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
2435                           button, TRUE, TRUE, 0);
2436       gtk_widget_grab_default (button);
2437       gtk_widget_show (button);
2438
2439       button = gtk_button_new_with_label ("remove");
2440       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2441                                  GTK_SIGNAL_FUNC(scrolled_windows_remove),
2442                                  GTK_OBJECT (scrolled_window));
2443       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2444       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
2445                           button, TRUE, TRUE, 0);
2446       gtk_widget_grab_default (button);
2447       gtk_widget_show (button);
2448
2449     }
2450
2451   if (!GTK_WIDGET_VISIBLE (window))
2452     gtk_widget_show (window);
2453   else
2454     gtk_widget_destroy (window);
2455 }
2456
2457 /*
2458  * GtkEntry
2459  */
2460
2461 static void
2462 entry_toggle_editable (GtkWidget *checkbutton,
2463                        GtkWidget *entry)
2464 {
2465    gtk_entry_set_editable(GTK_ENTRY(entry),
2466                           GTK_TOGGLE_BUTTON(checkbutton)->active);
2467 }
2468
2469 static void
2470 entry_toggle_sensitive (GtkWidget *checkbutton,
2471                         GtkWidget *entry)
2472 {
2473    gtk_widget_set_sensitive (entry, GTK_TOGGLE_BUTTON(checkbutton)->active);
2474 }
2475
2476 static void
2477 entry_toggle_visibility (GtkWidget *checkbutton,
2478                         GtkWidget *entry)
2479 {
2480    gtk_entry_set_visibility(GTK_ENTRY(entry),
2481                          GTK_TOGGLE_BUTTON(checkbutton)->active);
2482 }
2483
2484 static void
2485 create_entry (void)
2486 {
2487   static GtkWidget *window = NULL;
2488   GtkWidget *box1;
2489   GtkWidget *box2;
2490   GtkWidget *editable_check;
2491   GtkWidget *sensitive_check;
2492   GtkWidget *entry, *cb;
2493   GtkWidget *button;
2494   GtkWidget *separator;
2495   GList *cbitems = NULL;
2496
2497   if (!window)
2498     {
2499       cbitems = g_list_append(cbitems, "item0");
2500       cbitems = g_list_append(cbitems, "item1 item1");
2501       cbitems = g_list_append(cbitems, "item2 item2 item2");
2502       cbitems = g_list_append(cbitems, "item3 item3 item3 item3");
2503       cbitems = g_list_append(cbitems, "item4 item4 item4 item4 item4");
2504       cbitems = g_list_append(cbitems, "item5 item5 item5 item5 item5 item5");
2505       cbitems = g_list_append(cbitems, "item6 item6 item6 item6 item6");
2506       cbitems = g_list_append(cbitems, "item7 item7 item7 item7");
2507       cbitems = g_list_append(cbitems, "item8 item8 item8");
2508       cbitems = g_list_append(cbitems, "item9 item9");
2509
2510       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2511
2512       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2513                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2514                           &window);
2515
2516       gtk_window_set_title (GTK_WINDOW (window), "entry");
2517       gtk_container_border_width (GTK_CONTAINER (window), 0);
2518
2519
2520       box1 = gtk_vbox_new (FALSE, 0);
2521       gtk_container_add (GTK_CONTAINER (window), box1);
2522       gtk_widget_show (box1);
2523
2524
2525       box2 = gtk_vbox_new (FALSE, 10);
2526       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2527       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2528       gtk_widget_show (box2);
2529
2530       entry = gtk_entry_new ();
2531       gtk_entry_set_text (GTK_ENTRY (entry), "hello world");
2532       gtk_editable_select_region (GTK_EDITABLE (entry), 0, 5);
2533       gtk_box_pack_start (GTK_BOX (box2), entry, TRUE, TRUE, 0);
2534       gtk_widget_show (entry);
2535
2536       cb = gtk_combo_new ();
2537       gtk_combo_set_popdown_strings (GTK_COMBO (cb), cbitems);
2538       gtk_entry_set_text (GTK_ENTRY (GTK_COMBO(cb)->entry), "hello world");
2539       gtk_editable_select_region (GTK_EDITABLE (GTK_COMBO(cb)->entry),
2540                                   0, -1);
2541       gtk_box_pack_start (GTK_BOX (box2), cb, TRUE, TRUE, 0);
2542       gtk_widget_show (cb);
2543
2544       editable_check = gtk_check_button_new_with_label("Editable");
2545       gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
2546       gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
2547                           GTK_SIGNAL_FUNC(entry_toggle_editable), entry);
2548       gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE);
2549       gtk_widget_show (editable_check);
2550
2551       editable_check = gtk_check_button_new_with_label("Visible");
2552       gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
2553       gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
2554                           GTK_SIGNAL_FUNC(entry_toggle_visibility), entry);
2555       gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE);
2556       gtk_widget_show (editable_check);
2557
2558       sensitive_check = gtk_check_button_new_with_label("Sensitive");
2559       gtk_box_pack_start (GTK_BOX (box2), sensitive_check, FALSE, TRUE, 0);
2560       gtk_signal_connect (GTK_OBJECT(sensitive_check), "toggled",
2561                           GTK_SIGNAL_FUNC(entry_toggle_sensitive), entry);
2562       gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(sensitive_check), TRUE);
2563       gtk_widget_show (sensitive_check);
2564
2565       separator = gtk_hseparator_new ();
2566       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2567       gtk_widget_show (separator);
2568
2569
2570       box2 = gtk_vbox_new (FALSE, 10);
2571       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2572       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2573       gtk_widget_show (box2);
2574
2575
2576       button = gtk_button_new_with_label ("close");
2577       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2578                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2579                                  GTK_OBJECT (window));
2580       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2581       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2582       gtk_widget_grab_default (button);
2583       gtk_widget_show (button);
2584     }
2585
2586   if (!GTK_WIDGET_VISIBLE (window))
2587     gtk_widget_show (window);
2588   else
2589     gtk_widget_destroy (window);
2590 }
2591
2592 /*
2593  * GtkSpinButton
2594  */
2595
2596 static GtkWidget *spinner1;
2597
2598 static void
2599 toggle_snap (GtkWidget *widget, GtkSpinButton *spin)
2600 {
2601   gtk_spin_button_set_snap_to_ticks (spin, GTK_TOGGLE_BUTTON (widget)->active);
2602 }
2603
2604 static void
2605 toggle_numeric (GtkWidget *widget, GtkSpinButton *spin)
2606 {
2607   gtk_spin_button_set_numeric (spin, GTK_TOGGLE_BUTTON (widget)->active);
2608 }
2609
2610 static void
2611 change_digits (GtkWidget *widget, GtkSpinButton *spin)
2612 {
2613   gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spinner1),
2614                               gtk_spin_button_get_value_as_int (spin));
2615 }
2616
2617 static void
2618 get_value (GtkWidget *widget, gpointer data)
2619 {
2620   gchar buf[32];
2621   GtkLabel *label;
2622   GtkSpinButton *spin;
2623
2624   spin = GTK_SPIN_BUTTON (spinner1);
2625   label = GTK_LABEL (gtk_object_get_user_data (GTK_OBJECT (widget)));
2626   if (GPOINTER_TO_INT (data) == 1)
2627     sprintf (buf, "%d", gtk_spin_button_get_value_as_int (spin));
2628   else
2629     sprintf (buf, "%0.*f", spin->digits,
2630              gtk_spin_button_get_value_as_float (spin));
2631   gtk_label_set (label, buf);
2632 }
2633
2634 static void
2635 create_spins (void)
2636 {
2637   static GtkWidget *window = NULL;
2638   GtkWidget *frame;
2639   GtkWidget *hbox;
2640   GtkWidget *main_vbox;
2641   GtkWidget *vbox;
2642   GtkWidget *vbox2;
2643   GtkWidget *spinner2;
2644   GtkWidget *spinner;
2645   GtkWidget *button;
2646   GtkWidget *label;
2647   GtkWidget *val_label;
2648   GtkAdjustment *adj;
2649
2650   if (!window)
2651     {
2652       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2653
2654       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2655                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
2656                           &window);
2657
2658       gtk_window_set_title (GTK_WINDOW (window), "GtkSpinButton");
2659
2660       main_vbox = gtk_vbox_new (FALSE, 5);
2661       gtk_container_border_width (GTK_CONTAINER (main_vbox), 10);
2662       gtk_container_add (GTK_CONTAINER (window), main_vbox);
2663
2664       frame = gtk_frame_new ("Not accelerated");
2665       gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
2666
2667       vbox = gtk_vbox_new (FALSE, 0);
2668       gtk_container_border_width (GTK_CONTAINER (vbox), 5);
2669       gtk_container_add (GTK_CONTAINER (frame), vbox);
2670
2671       /* Day, month, year spinners */
2672
2673       hbox = gtk_hbox_new (FALSE, 0);
2674       gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
2675
2676       vbox2 = gtk_vbox_new (FALSE, 0);
2677       gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2678
2679       label = gtk_label_new ("Day :");
2680       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2681       gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2682
2683       adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 31.0, 1.0,
2684                                                   5.0, 0.0);
2685       spinner = gtk_spin_button_new (adj, 0, 0);
2686       gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
2687       gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
2688                                        GTK_SHADOW_OUT);
2689       gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2690
2691       vbox2 = gtk_vbox_new (FALSE, 0);
2692       gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2693
2694       label = gtk_label_new ("Month :");
2695       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2696       gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2697
2698       adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 12.0, 1.0,
2699                                                   5.0, 0.0);
2700       spinner = gtk_spin_button_new (adj, 0, 0);
2701       gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
2702       gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
2703                                        GTK_SHADOW_ETCHED_IN);
2704       gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2705
2706       vbox2 = gtk_vbox_new (FALSE, 0);
2707       gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2708
2709       label = gtk_label_new ("Year :");
2710       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2711       gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2712
2713       adj = (GtkAdjustment *) gtk_adjustment_new (1998.0, 0.0, 2100.0,
2714                                                   1.0, 100.0, 0.0);
2715       spinner = gtk_spin_button_new (adj, 0, 0);
2716       gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
2717       gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
2718                                        GTK_SHADOW_IN);
2719       gtk_widget_set_usize (spinner, 55, 0);
2720       gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2721
2722       frame = gtk_frame_new ("Accelerated");
2723       gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
2724
2725       vbox = gtk_vbox_new (FALSE, 0);
2726       gtk_container_border_width (GTK_CONTAINER (vbox), 5);
2727       gtk_container_add (GTK_CONTAINER (frame), vbox);
2728
2729       hbox = gtk_hbox_new (FALSE, 0);
2730       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2731
2732       vbox2 = gtk_vbox_new (FALSE, 0);
2733       gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2734
2735       label = gtk_label_new ("Value :");
2736       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2737       gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2738
2739       adj = (GtkAdjustment *) gtk_adjustment_new (0.0, -10000.0, 10000.0,
2740                                                   0.5, 100.0, 0.0);
2741       spinner1 = gtk_spin_button_new (adj, 1.0, 2);
2742       gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner1), TRUE);
2743       gtk_widget_set_usize (spinner1, 100, 0);
2744       gtk_box_pack_start (GTK_BOX (vbox2), spinner1, FALSE, TRUE, 0);
2745
2746       vbox2 = gtk_vbox_new (FALSE, 0);
2747       gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2748
2749       label = gtk_label_new ("Digits :");
2750       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2751       gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2752
2753       adj = (GtkAdjustment *) gtk_adjustment_new (2, 1, 5, 1, 1, 0);
2754       spinner2 = gtk_spin_button_new (adj, 0.0, 0);
2755       gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner2), TRUE);
2756       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
2757                           GTK_SIGNAL_FUNC (change_digits),
2758                           (gpointer) spinner2);
2759       gtk_box_pack_start (GTK_BOX (vbox2), spinner2, FALSE, TRUE, 0);
2760
2761       hbox = gtk_hbox_new (FALSE, 0);
2762       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2763
2764       button = gtk_check_button_new_with_label ("Snap to 0.5-ticks");
2765       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2766                           GTK_SIGNAL_FUNC (toggle_snap),
2767                           spinner1);
2768       gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
2769       gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
2770
2771       button = gtk_check_button_new_with_label ("Numeric only input mode");
2772       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2773                           GTK_SIGNAL_FUNC (toggle_numeric),
2774                           spinner1);
2775       gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
2776       gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
2777
2778       val_label = gtk_label_new ("");
2779
2780       hbox = gtk_hbox_new (FALSE, 0);
2781       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2782
2783       button = gtk_button_new_with_label ("Value as Int");
2784       gtk_object_set_user_data (GTK_OBJECT (button), val_label);
2785       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2786                           GTK_SIGNAL_FUNC (get_value),
2787                           GINT_TO_POINTER (1));
2788       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2789
2790       button = gtk_button_new_with_label ("Value as Float");
2791       gtk_object_set_user_data (GTK_OBJECT (button), val_label);
2792       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2793                           GTK_SIGNAL_FUNC (get_value),
2794                           GINT_TO_POINTER (2));
2795       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2796
2797       gtk_box_pack_start (GTK_BOX (vbox), val_label, TRUE, TRUE, 0);
2798       gtk_label_set (GTK_LABEL (val_label), "0");
2799
2800       hbox = gtk_hbox_new (FALSE, 0);
2801       gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
2802
2803       button = gtk_button_new_with_label ("Close");
2804       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2805                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
2806                                  GTK_OBJECT (window));
2807       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2808     }
2809
2810   if (!GTK_WIDGET_VISIBLE (window))
2811     gtk_widget_show_all (window);
2812   else
2813     gtk_widget_destroy (window);
2814 }
2815
2816 /*
2817  * Cursors
2818  */
2819
2820 static gint
2821 cursor_expose_event (GtkWidget *widget,
2822                      GdkEvent  *event,
2823                      gpointer   user_data)
2824 {
2825   GtkDrawingArea *darea;
2826   GdkDrawable *drawable;
2827   GdkGC *black_gc;
2828   GdkGC *gray_gc;
2829   GdkGC *white_gc;
2830   guint max_width;
2831   guint max_height;
2832
2833   g_return_val_if_fail (widget != NULL, TRUE);
2834   g_return_val_if_fail (GTK_IS_DRAWING_AREA (widget), TRUE);
2835
2836   darea = GTK_DRAWING_AREA (widget);
2837   drawable = widget->window;
2838   white_gc = widget->style->white_gc;
2839   gray_gc = widget->style->bg_gc[GTK_STATE_NORMAL];
2840   black_gc = widget->style->black_gc;
2841   max_width = widget->allocation.width;
2842   max_height = widget->allocation.height;
2843
2844   gdk_draw_rectangle (drawable, white_gc,
2845                       TRUE,
2846                       0,
2847                       0,
2848                       max_width,
2849                       max_height / 2);
2850
2851   gdk_draw_rectangle (drawable, black_gc,
2852                       TRUE,
2853                       0,
2854                       max_height / 2,
2855                       max_width,
2856                       max_height / 2);
2857
2858   gdk_draw_rectangle (drawable, gray_gc,
2859                       TRUE,
2860                       max_width / 3,
2861                       max_height / 3,
2862                       max_width / 3,
2863                       max_height / 3);
2864
2865   return TRUE;
2866 }
2867
2868 static void
2869 set_cursor (GtkWidget *spinner,
2870             GtkWidget *widget)
2871 {
2872   guint c;
2873   GdkCursor *cursor;
2874   GtkWidget *label;
2875   GtkFlagValue *vals;
2876
2877   c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152);
2878   c &= 0xfe;
2879
2880   label = gtk_object_get_user_data (GTK_OBJECT (spinner));
2881   vals = gtk_type_enum_get_values (GTK_TYPE_GDK_CURSOR_TYPE);
2882   while (vals && vals->value != c)
2883     vals++;
2884   if (vals)
2885     gtk_label_set (GTK_LABEL (label), vals->value_nick);
2886   else
2887     gtk_label_set (GTK_LABEL (label), "<unknown>");
2888
2889   cursor = gdk_cursor_new (c);
2890   gdk_window_set_cursor (widget->window, cursor);
2891   gdk_cursor_destroy (cursor);
2892 }
2893
2894 static gint
2895 cursor_event (GtkWidget          *widget,
2896               GdkEvent           *event,
2897               GtkSpinButton      *spinner)
2898 {
2899   if ((event->type == GDK_BUTTON_PRESS) &&
2900       ((event->button.button == 1) ||
2901        (event->button.button == 3)))
2902     {
2903       gtk_spin_button_spin (spinner, event->button.button == 1 ?
2904                             GTK_SPIN_STEP_FORWARD : GTK_SPIN_STEP_BACKWARD, 0);
2905       return TRUE;
2906     }
2907
2908   return FALSE;
2909 }
2910
2911 static void
2912 create_cursors (void)
2913 {
2914   static GtkWidget *window = NULL;
2915   GtkWidget *frame;
2916   GtkWidget *hbox;
2917   GtkWidget *main_vbox;
2918   GtkWidget *vbox;
2919   GtkWidget *darea;
2920   GtkWidget *spinner;
2921   GtkWidget *button;
2922   GtkWidget *label;
2923   GtkWidget *any;
2924   GtkAdjustment *adj;
2925
2926   if (!window)
2927     {
2928       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2929
2930       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2931                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
2932                           &window);
2933
2934       gtk_window_set_title (GTK_WINDOW (window), "Cursors");
2935
2936       main_vbox = gtk_vbox_new (FALSE, 5);
2937       gtk_container_border_width (GTK_CONTAINER (main_vbox), 0);
2938       gtk_container_add (GTK_CONTAINER (window), main_vbox);
2939
2940       vbox =
2941         gtk_widget_new (gtk_vbox_get_type (),
2942                         "GtkBox::homogeneous", FALSE,
2943                         "GtkBox::spacing", 5,
2944                         "GtkContainer::border_width", 10,
2945                         "GtkWidget::parent", main_vbox,
2946                         "GtkWidget::visible", TRUE,
2947                         NULL);
2948
2949       hbox = gtk_hbox_new (FALSE, 0);
2950       gtk_container_border_width (GTK_CONTAINER (hbox), 5);
2951       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
2952
2953       label = gtk_label_new ("Cursor Value : ");
2954       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2955       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
2956
2957       adj = (GtkAdjustment *) gtk_adjustment_new (0,
2958                                                   0, 152,
2959                                                   2,
2960                                                   10, 0);
2961       spinner = gtk_spin_button_new (adj, 0, 0);
2962       gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 0);
2963
2964       frame =
2965         gtk_widget_new (gtk_frame_get_type (),
2966                         "GtkFrame::shadow", GTK_SHADOW_ETCHED_IN,
2967                         "GtkFrame::label_xalign", 0.5,
2968                         "GtkFrame::label", "Cursor Area",
2969                         "GtkContainer::border_width", 10,
2970                         "GtkWidget::parent", vbox,
2971                         "GtkWidget::visible", TRUE,
2972                         NULL);
2973
2974       darea = gtk_drawing_area_new ();
2975       gtk_widget_set_usize (darea, 80, 80);
2976       gtk_container_add (GTK_CONTAINER (frame), darea);
2977       gtk_signal_connect (GTK_OBJECT (darea),
2978                           "expose_event",
2979                           GTK_SIGNAL_FUNC (cursor_expose_event),
2980                           NULL);
2981       gtk_widget_set_events (darea, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
2982       gtk_signal_connect (GTK_OBJECT (darea),
2983                           "button_press_event",
2984                           GTK_SIGNAL_FUNC (cursor_event),
2985                           spinner);
2986       gtk_widget_show (darea);
2987
2988       gtk_signal_connect (GTK_OBJECT (spinner), "changed",
2989                           GTK_SIGNAL_FUNC (set_cursor),
2990                           darea);
2991
2992       label = gtk_widget_new (GTK_TYPE_LABEL,
2993                               "visible", TRUE,
2994                               "label", "XXX",
2995                               "parent", vbox,
2996                               NULL);
2997       gtk_container_child_set (GTK_CONTAINER (vbox), label,
2998                                "expand", FALSE,
2999                                NULL);
3000       gtk_object_set_user_data (GTK_OBJECT (spinner), label);
3001
3002       any =
3003         gtk_widget_new (gtk_hseparator_get_type (),
3004                         "GtkWidget::visible", TRUE,
3005                         NULL);
3006       gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
3007
3008       hbox = gtk_hbox_new (FALSE, 0);
3009       gtk_container_border_width (GTK_CONTAINER (hbox), 10);
3010       gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
3011
3012       button = gtk_button_new_with_label ("Close");
3013       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3014                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
3015                                  GTK_OBJECT (window));
3016       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
3017
3018       gtk_widget_show_all (window);
3019
3020       set_cursor (spinner, darea);
3021     }
3022   else
3023     gtk_widget_destroy (window);
3024 }
3025
3026 /*
3027  * GtkList
3028  */
3029
3030 static void
3031 list_add (GtkWidget *widget,
3032           GtkWidget *list)
3033 {
3034   static int i = 1;
3035   gchar buffer[64];
3036   GtkWidget *list_item;
3037   GtkContainer *container;
3038
3039   container = GTK_CONTAINER (list);
3040
3041   sprintf (buffer, "added item %d", i++);
3042   list_item = gtk_list_item_new_with_label (buffer);
3043   gtk_widget_show (list_item);
3044
3045   gtk_container_add (container, list_item);
3046 }
3047
3048 static void
3049 list_remove (GtkWidget *widget,
3050              GtkWidget *list)
3051 {
3052   GList *tmp_list;
3053   GList *clear_list;
3054
3055   tmp_list = GTK_LIST (list)->selection;
3056   clear_list = NULL;
3057
3058   while (tmp_list)
3059     {
3060       clear_list = g_list_prepend (clear_list, tmp_list->data);
3061       tmp_list = tmp_list->next;
3062     }
3063
3064   clear_list = g_list_reverse (clear_list);
3065
3066   gtk_list_remove_items (GTK_LIST (list), clear_list);
3067
3068   g_list_free (clear_list);
3069 }
3070
3071 static void
3072 list_clear (GtkWidget *widget,
3073             GtkWidget *list)
3074 {
3075   gtk_list_clear_items (GTK_LIST (list), 0, -1);
3076 }
3077
3078 static void
3079 list_undo_selection (GtkWidget *widget,
3080                      GtkWidget *list)
3081 {
3082   gtk_list_undo_selection (GTK_LIST (list));
3083 }
3084
3085 #define RADIOMENUTOGGLED(_rmi_, __i) { \
3086   GSList * __g; \
3087   __i = 0; \
3088   __g = gtk_radio_menu_item_group(_rmi_); \
3089   while( __g  && !((GtkCheckMenuItem *)(__g->data))->active) { \
3090     __g = __g->next; \
3091     __i++; \
3092   }\
3093 }
3094
3095 static GtkWidget *list_omenu;
3096
3097 static void
3098 list_toggle_sel_mode (GtkWidget *widget, GtkList *list)
3099 {
3100   gint i;
3101
3102   if (!GTK_WIDGET_MAPPED (widget))
3103     return;
3104
3105   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
3106                     (((GtkOptionMenu *)list_omenu)->menu_item), i);
3107
3108   gtk_list_set_selection_mode (list, (GtkSelectionMode) (3-i));
3109 }
3110
3111 static void
3112 create_list (void)
3113 {
3114   static GtkWidget *window = NULL;
3115   GtkWidget *box1;
3116   GtkWidget *box2;
3117   GtkWidget *hbox;
3118   GtkWidget *label;
3119   GtkWidget *scrolled_win;
3120   GtkWidget *list;
3121   GtkWidget *button;
3122   GtkWidget *separator;
3123   GtkWidget *menu;
3124   GtkWidget *menu_item;
3125   GSList *group;
3126   FILE *infile;
3127
3128   if (!window)
3129     {
3130       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3131
3132       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3133                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3134                           &window);
3135
3136       gtk_window_set_title (GTK_WINDOW (window), "list");
3137       gtk_container_border_width (GTK_CONTAINER (window), 0);
3138
3139       box1 = gtk_vbox_new (FALSE, 0);
3140       gtk_container_add (GTK_CONTAINER (window), box1);
3141
3142       box2 = gtk_vbox_new (FALSE, 10);
3143       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3144       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3145
3146       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
3147       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
3148                                       GTK_POLICY_AUTOMATIC,
3149                                       GTK_POLICY_AUTOMATIC);
3150       gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
3151       gtk_widget_set_usize (scrolled_win, -1, 300);
3152
3153       list = gtk_list_new ();
3154       gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_EXTENDED);
3155       gtk_container_add (GTK_CONTAINER (scrolled_win), list);
3156       gtk_container_set_focus_vadjustment
3157         (GTK_CONTAINER (list),
3158          gtk_scrolled_window_get_vadjustment
3159          (GTK_SCROLLED_WINDOW (scrolled_win)));
3160       gtk_container_set_focus_hadjustment
3161         (GTK_CONTAINER (list),
3162          gtk_scrolled_window_get_hadjustment
3163          (GTK_SCROLLED_WINDOW (scrolled_win)));
3164
3165       if ((infile = fopen("gtkenums.h", "r")))
3166         {
3167           char buffer[256];
3168           char *pos;
3169           GtkWidget *item;
3170
3171           while (fgets (buffer, 256, infile))
3172             {
3173               if ((pos = strchr (buffer, '\n')))
3174                 *pos = 0;
3175               item = gtk_list_item_new_with_label (buffer);
3176               gtk_container_add (GTK_CONTAINER (list), item);
3177             }
3178
3179           fclose (infile);
3180         }
3181
3182       hbox = gtk_hbox_new (TRUE, 10);
3183       gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, TRUE, 0);
3184
3185       button = gtk_button_new_with_label ("Undo Selection");
3186       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3187                           GTK_SIGNAL_FUNC(list_undo_selection),
3188                           list);
3189       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3190
3191       button = gtk_button_new_with_label ("Remove Selection");
3192       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3193                           GTK_SIGNAL_FUNC (list_remove),
3194                           list);
3195       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3196
3197       button = gtk_button_new_with_label ("Clear List");
3198       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3199                           GTK_SIGNAL_FUNC (list_clear),
3200                           list);
3201       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3202
3203       hbox = gtk_hbox_new (FALSE, 10);
3204       gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, TRUE, 0);
3205
3206       button = gtk_button_new_with_label ("Insert Row");
3207       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3208                           GTK_SIGNAL_FUNC (list_add),
3209                           list);
3210       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3211
3212       label = gtk_label_new ("Selection Mode :");
3213       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3214                           GTK_SIGNAL_FUNC(list_remove),
3215                           list);
3216       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
3217
3218       list_omenu = gtk_option_menu_new ();
3219       menu = gtk_menu_new ();
3220       group = NULL;
3221
3222       menu_item = gtk_radio_menu_item_new_with_label (group, "Single");
3223       gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
3224                           GTK_SIGNAL_FUNC (list_toggle_sel_mode), list);
3225       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
3226       gtk_menu_append (GTK_MENU (menu), menu_item);
3227       gtk_widget_show (menu_item);
3228
3229       menu_item = gtk_radio_menu_item_new_with_label (group, "Browse");
3230       gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
3231                           GTK_SIGNAL_FUNC (list_toggle_sel_mode), list);
3232       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
3233       gtk_menu_append (GTK_MENU (menu), menu_item);
3234       gtk_widget_show (menu_item);
3235
3236       menu_item = gtk_radio_menu_item_new_with_label (group, "Multiple");
3237       gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
3238                       GTK_SIGNAL_FUNC (list_toggle_sel_mode), list);
3239       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
3240       gtk_menu_append (GTK_MENU (menu), menu_item);
3241       gtk_widget_show (menu_item);
3242
3243       menu_item = gtk_radio_menu_item_new_with_label (group, "Extended");
3244       gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
3245                           GTK_SIGNAL_FUNC (list_toggle_sel_mode), list);
3246       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
3247       gtk_menu_append (GTK_MENU (menu), menu_item);
3248       gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
3249       gtk_widget_show (menu_item);
3250
3251       gtk_option_menu_set_menu (GTK_OPTION_MENU (list_omenu), menu);
3252       gtk_box_pack_start (GTK_BOX (hbox), list_omenu, FALSE, TRUE, 0);
3253
3254       gtk_option_menu_set_history (GTK_OPTION_MENU (list_omenu), 3);
3255
3256       separator = gtk_hseparator_new ();
3257       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3258
3259
3260       box2 = gtk_vbox_new (FALSE, 10);
3261       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3262       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3263
3264       button = gtk_button_new_with_label ("close");
3265       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3266                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
3267                                  GTK_OBJECT (window));
3268       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3269
3270       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3271       gtk_widget_grab_default (button);
3272     }
3273
3274   if (!GTK_WIDGET_VISIBLE (window))
3275     gtk_widget_show_all (window);
3276   else
3277     gtk_widget_destroy (window);
3278 }
3279
3280 /*
3281  * GtkCList
3282  */
3283
3284 static char * book_open_xpm[] = {
3285 "16 16 4 1",
3286 "       c None s None",
3287 ".      c black",
3288 "X      c #808080",
3289 "o      c white",
3290 "                ",
3291 "  ..            ",
3292 " .Xo.    ...    ",
3293 " .Xoo. ..oo.    ",
3294 " .Xooo.Xooo...  ",
3295 " .Xooo.oooo.X.  ",
3296 " .Xooo.Xooo.X.  ",
3297 " .Xooo.oooo.X.  ",
3298 " .Xooo.Xooo.X.  ",
3299 " .Xooo.oooo.X.  ",
3300 "  .Xoo.Xoo..X.  ",
3301 "   .Xo.o..ooX.  ",
3302 "    .X..XXXXX.  ",
3303 "    ..X.......  ",
3304 "     ..         ",
3305 "                "};
3306
3307 static char * book_closed_xpm[] = {
3308 "16 16 6 1",
3309 "       c None s None",
3310 ".      c black",
3311 "X      c red",
3312 "o      c yellow",
3313 "O      c #808080",
3314 "#      c white",
3315 "                ",
3316 "       ..       ",
3317 "     ..XX.      ",
3318 "   ..XXXXX.     ",
3319 " ..XXXXXXXX.    ",
3320 ".ooXXXXXXXXX.   ",
3321 "..ooXXXXXXXXX.  ",
3322 ".X.ooXXXXXXXXX. ",
3323 ".XX.ooXXXXXX..  ",
3324 " .XX.ooXXX..#O  ",
3325 "  .XX.oo..##OO. ",
3326 "   .XX..##OO..  ",
3327 "    .X.#OO..    ",
3328 "     ..O..      ",
3329 "      ..        ",
3330 "                "};
3331
3332 static char * mini_page_xpm[] = {
3333 "16 16 4 1",
3334 "       c None s None",
3335 ".      c black",
3336 "X      c white",
3337 "o      c #808080",
3338 "                ",
3339 "   .......      ",
3340 "   .XXXXX..     ",
3341 "   .XoooX.X.    ",
3342 "   .XXXXX....   ",
3343 "   .XooooXoo.o  ",
3344 "   .XXXXXXXX.o  ",
3345 "   .XooooooX.o  ",
3346 "   .XXXXXXXX.o  ",
3347 "   .XooooooX.o  ",
3348 "   .XXXXXXXX.o  ",
3349 "   .XooooooX.o  ",
3350 "   .XXXXXXXX.o  ",
3351 "   ..........o  ",
3352 "    oooooooooo  ",
3353 "                "};
3354
3355 #define TESTGTK_CLIST_COLUMNS 20
3356 static gint clist_rows = 0;
3357 static GtkWidget *clist_omenu;
3358
3359 static void
3360 add1000_clist (GtkWidget *widget, gpointer data)
3361 {
3362   gint i, row;
3363   char text[TESTGTK_CLIST_COLUMNS][50];
3364   char *texts[TESTGTK_CLIST_COLUMNS];
3365   GdkBitmap *mask;
3366   GdkPixmap *pixmap;
3367
3368   pixmap = gdk_pixmap_create_from_xpm_d (GTK_CLIST (data)->clist_window,
3369                                          &mask,
3370                                          &GTK_WIDGET (data)->style->white,
3371                                          mini_page_xpm);
3372
3373   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3374     {
3375       texts[i] = text[i];
3376       sprintf (text[i], "Column %d", i);
3377     }
3378
3379   texts[3] = NULL;
3380   sprintf (text[1], "Right");
3381   sprintf (text[2], "Center");
3382
3383   gtk_clist_freeze (GTK_CLIST (data));
3384   for (i = 0; i < 1000; i++)
3385     {
3386       sprintf (text[0], "Row %d", rand() % 10000 /*clist_rows++*/);
3387       row = gtk_clist_append (GTK_CLIST (data), texts);
3388       gtk_clist_set_pixtext (GTK_CLIST (data), row, 3, "Hello World", 5, pixmap, mask);
3389     }
3390
3391   gtk_clist_thaw (GTK_CLIST (data));
3392
3393   gdk_pixmap_unref (pixmap);
3394   gdk_bitmap_unref (mask);
3395 }
3396
3397 static void
3398 add10000_clist (GtkWidget *widget, gpointer data)
3399 {
3400   gint i;
3401   char text[TESTGTK_CLIST_COLUMNS][50];
3402   char *texts[TESTGTK_CLIST_COLUMNS];
3403
3404   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3405     {
3406       texts[i] = text[i];
3407       sprintf (text[i], "Column %d", i);
3408     }
3409
3410   sprintf (text[1], "Right");
3411   sprintf (text[2], "Center");
3412
3413   gtk_clist_freeze (GTK_CLIST (data));
3414   for (i = 0; i < 10000; i++)
3415     {
3416       sprintf (text[0], "Row %d", rand() % 10000 /*clist_rows++*/);
3417       gtk_clist_append (GTK_CLIST (data), texts);
3418     }
3419   gtk_clist_thaw (GTK_CLIST (data));
3420 }
3421
3422 void
3423 clear_clist (GtkWidget *widget, gpointer data)
3424 {
3425   gtk_clist_clear (GTK_CLIST (data));
3426   clist_rows = 0;
3427 }
3428
3429 void
3430 remove_row_clist (GtkWidget *widget, gpointer data)
3431 {
3432   gtk_clist_remove (GTK_CLIST (data), GTK_CLIST (data)->focus_row);
3433   clist_rows--;
3434 }
3435
3436 void
3437 show_titles_clist (GtkWidget *widget, gpointer data)
3438 {
3439   gtk_clist_column_titles_show (GTK_CLIST (data));
3440 }
3441
3442 void
3443 hide_titles_clist (GtkWidget *widget, gpointer data)
3444 {
3445   gtk_clist_column_titles_hide (GTK_CLIST (data));
3446 }
3447
3448 void
3449 select_clist (GtkWidget *widget,
3450               gint row,
3451               gint column,
3452               GdkEventButton * bevent,
3453               GtkWidget *button)
3454 {
3455   gint i;
3456   guint8 spacing;
3457   gchar *text;
3458   GdkPixmap *pixmap;
3459   GdkBitmap *mask;
3460   GList *list;
3461
3462   g_print ("GtkCList Selection: row %d column %d button %d\n",
3463            row, column, bevent ? bevent->button : 0);
3464
3465   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3466     {
3467       switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i))
3468         {
3469         case GTK_CELL_TEXT:
3470           g_print ("CELL %d GTK_CELL_TEXT\n", i);
3471           gtk_clist_get_text (GTK_CLIST (widget), row, i, &text);
3472           g_print ("TEXT: %s\n", text);
3473           break;
3474
3475         case GTK_CELL_PIXMAP:
3476           g_print ("CELL %d GTK_CELL_PIXMAP\n", i);
3477           gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask);
3478           g_print ("PIXMAP: %p\n", pixmap);
3479           g_print ("MASK: %p\n", mask);
3480           break;
3481
3482         case GTK_CELL_PIXTEXT:
3483           g_print ("CELL %d GTK_CELL_PIXTEXT\n", i);
3484           gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask);
3485           g_print ("TEXT: %s\n", text);
3486           g_print ("SPACING: %d\n", spacing);
3487           g_print ("PIXMAP: %p\n", pixmap);
3488           g_print ("MASK: %p\n", mask);
3489           break;
3490
3491         default:
3492           break;
3493         }
3494     }
3495
3496   /* print selections list */
3497   g_print ("\nSelected Rows:");
3498   list = GTK_CLIST (widget)->selection;
3499   while (list)
3500     {
3501       g_print (" %d ", GPOINTER_TO_INT (list->data));
3502       list = list->next;
3503     }
3504
3505   g_print ("\n\n\n");
3506 }
3507
3508 void
3509 unselect_clist (GtkWidget *widget,
3510                 gint row,
3511                 gint column,
3512                 GdkEventButton * bevent,
3513                 GtkWidget *button)
3514 {
3515   gint i;
3516   guint8 spacing;
3517   gchar *text;
3518   GdkPixmap *pixmap;
3519   GdkBitmap *mask;
3520   GList *list;
3521
3522   g_print ("GtkCList Unselection: row %d column %d button %d\n",
3523            row, column, bevent ? bevent->button : 0);
3524
3525   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3526     {
3527       switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i))
3528         {
3529         case GTK_CELL_TEXT:
3530           g_print ("CELL %d GTK_CELL_TEXT\n", i);
3531           gtk_clist_get_text (GTK_CLIST (widget), row, i, &text);
3532           g_print ("TEXT: %s\n", text);
3533           break;
3534
3535         case GTK_CELL_PIXMAP:
3536           g_print ("CELL %d GTK_CELL_PIXMAP\n", i);
3537           gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask);
3538           g_print ("PIXMAP: %p\n", pixmap);
3539           g_print ("MASK: %p\n", mask);
3540           break;
3541
3542         case GTK_CELL_PIXTEXT:
3543           g_print ("CELL %d GTK_CELL_PIXTEXT\n", i);
3544           gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask);
3545           g_print ("TEXT: %s\n", text);
3546           g_print ("SPACING: %d\n", spacing);
3547           g_print ("PIXMAP: %p\n", pixmap);
3548           g_print ("MASK: %p\n", mask);
3549           break;
3550
3551         default:
3552           break;
3553         }
3554     }
3555
3556   /* print selections list */
3557   g_print ("\nSelected Rows:");
3558   list = GTK_CLIST (widget)->selection;
3559   while (list)
3560     {
3561       g_print (" %d ", GPOINTER_TO_INT (list->data));
3562       list = list->next;
3563     }
3564
3565   g_print ("\n\n\n");
3566 }
3567
3568 static void
3569 insert_row_clist (GtkWidget *widget, gpointer data)
3570 {
3571   static char *text[] =
3572   {
3573     "This", "is", "a", "inserted", "row.",
3574     "This", "is", "a", "inserted", "row.",
3575     "This", "is", "a", "inserted", "row.",
3576     "This", "is", "a", "inserted", "row."
3577   };
3578
3579   if (GTK_CLIST (data)->focus_row >= 0)
3580     gtk_clist_insert (GTK_CLIST (data), GTK_CLIST (data)->focus_row, text);
3581   else
3582     gtk_clist_insert (GTK_CLIST (data), 0, text);
3583
3584   clist_rows++;
3585 }
3586
3587 static void
3588 clist_warning_test (GtkWidget *button,
3589                     GtkWidget *clist)
3590 {
3591   GtkWidget *child;
3592   static gboolean add_remove = FALSE;
3593
3594   add_remove = !add_remove;
3595
3596   child = gtk_label_new ("Test");
3597   gtk_widget_ref (child);
3598   gtk_object_sink (GTK_OBJECT (child));
3599
3600   if (add_remove)
3601     gtk_container_add (GTK_CONTAINER (clist), child);
3602   else
3603     {
3604       child->parent = clist;
3605       gtk_container_remove (GTK_CONTAINER (clist), child);
3606       child->parent = NULL;
3607     }
3608
3609   gtk_widget_destroy (child);
3610   gtk_widget_unref (child);
3611 }
3612
3613 static void
3614 undo_selection (GtkWidget *button, GtkCList *clist)
3615 {
3616   gtk_clist_undo_selection (clist);
3617 }
3618
3619 static void
3620 clist_toggle_sel_mode (GtkWidget *widget, GtkCList *clist)
3621 {
3622   gint i;
3623
3624   if (!GTK_WIDGET_MAPPED (widget))
3625     return;
3626
3627   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
3628                     (((GtkOptionMenu *)clist_omenu)->menu_item), i);
3629
3630   gtk_clist_set_selection_mode (clist, (GtkSelectionMode) (3-i));
3631 }
3632
3633 static void
3634 clist_click_column (GtkCList *clist, gint column, gpointer data)
3635 {
3636   if (column == clist->sort_column)
3637     {
3638       if (clist->sort_type == GTK_SORT_ASCENDING)
3639         clist->sort_type = GTK_SORT_DESCENDING;
3640       else
3641         clist->sort_type = GTK_SORT_ASCENDING;
3642     }
3643   else
3644     gtk_clist_set_sort_column (clist, column);
3645
3646   gtk_clist_sort (clist);
3647 }
3648
3649 static void
3650 create_clist (void)
3651 {
3652   gint i;
3653   static GtkWidget *window = NULL;
3654
3655   static char *titles[] =
3656   {
3657     "Title 0",  "Title 1",  "Title 2",  "Title 3",  "Title 4",
3658     "Title 5",  "Title 6",  "Title 7",  "Title 8",  "Title 9",
3659     "Title 10", "Title 11", "Title 12", "Title 13", "Title 14",
3660     "Title 15", "Title 16", "Title 17", "Title 18", "Title 19"
3661   };
3662
3663   static OptionMenuItem items[] =
3664   {
3665     { "Single",   clist_toggle_sel_mode },
3666     { "Browse",   clist_toggle_sel_mode },
3667     { "Multiple", clist_toggle_sel_mode },
3668     { "Extended", clist_toggle_sel_mode }
3669   };
3670
3671   char text[TESTGTK_CLIST_COLUMNS][50];
3672   char *texts[TESTGTK_CLIST_COLUMNS];
3673
3674   GtkWidget *box1;
3675   GtkWidget *box2;
3676   GtkWidget *clist;
3677   GtkWidget *button;
3678   GtkWidget *separator;
3679
3680   GtkWidget *undo_button;
3681   GtkWidget *label;
3682
3683   if (!window)
3684     {
3685       clist_rows = 0;
3686       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3687
3688       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3689                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3690                           &window);
3691
3692       gtk_window_set_title (GTK_WINDOW (window), "clist");
3693       gtk_container_border_width (GTK_CONTAINER (window), 0);
3694
3695       box1 = gtk_vbox_new (FALSE, 0);
3696       gtk_container_add (GTK_CONTAINER (window), box1);
3697
3698       box2 = gtk_hbox_new (FALSE, 10);
3699       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3700       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
3701
3702       /* create GtkCList here so we have a pointer to throw at the
3703        * button callbacks -- more is done with it later */
3704       clist = gtk_clist_new_with_titles (TESTGTK_CLIST_COLUMNS, titles);
3705       /*clist = gtk_clist_new (TESTGTK_CLIST_COLUMNS);*/
3706
3707       gtk_signal_connect (GTK_OBJECT (clist), "click_column",
3708                           (GtkSignalFunc) clist_click_column,
3709                           NULL);
3710
3711       /* control buttons */
3712       button = gtk_button_new_with_label ("Add 1,000 Rows With Pixmaps");
3713       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3714
3715       gtk_signal_connect (GTK_OBJECT (button),
3716                           "clicked",
3717                           (GtkSignalFunc) add1000_clist,
3718                           (gpointer) clist);
3719
3720       button = gtk_button_new_with_label ("Add 10,000 Rows");
3721       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3722
3723       gtk_signal_connect (GTK_OBJECT (button),
3724                           "clicked",
3725                           (GtkSignalFunc) add10000_clist,
3726                           (gpointer) clist);
3727
3728       button = gtk_button_new_with_label ("Clear List");
3729       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3730
3731       gtk_signal_connect (GTK_OBJECT (button),
3732                           "clicked",
3733                           (GtkSignalFunc) clear_clist,
3734                           (gpointer) clist);
3735
3736       button = gtk_button_new_with_label ("Remove Row");
3737       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3738
3739       gtk_signal_connect (GTK_OBJECT (button),
3740                           "clicked",
3741                           (GtkSignalFunc) remove_row_clist,
3742                           (gpointer) clist);
3743
3744       /* second layer of buttons */
3745       box2 = gtk_hbox_new (FALSE, 10);
3746       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3747       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
3748
3749       button = gtk_button_new_with_label ("Insert Row");
3750       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3751
3752       gtk_signal_connect (GTK_OBJECT (button),
3753                           "clicked",
3754                           (GtkSignalFunc) insert_row_clist,
3755                           (gpointer) clist);
3756
3757       button = gtk_button_new_with_label ("Show Title Buttons");
3758       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3759
3760       gtk_signal_connect (GTK_OBJECT (button),
3761                           "clicked",
3762                           (GtkSignalFunc) show_titles_clist,
3763                           (gpointer) clist);
3764
3765       button = gtk_button_new_with_label ("Hide Title Buttons");
3766       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3767
3768       gtk_signal_connect (GTK_OBJECT (button),
3769                           "clicked",
3770                           (GtkSignalFunc) hide_titles_clist,
3771                           (gpointer) clist);
3772
3773       button = gtk_button_new_with_label ("Warning Test");
3774       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3775
3776       gtk_signal_connect (GTK_OBJECT (button),
3777                           "clicked",
3778                           (GtkSignalFunc) clist_warning_test,
3779                           (gpointer) clist);
3780
3781       box2 = gtk_hbox_new (FALSE, 10);
3782       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3783       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
3784
3785       undo_button = gtk_button_new_with_label ("Undo last selection");
3786       gtk_box_pack_start (GTK_BOX (box2), undo_button, TRUE, TRUE, 0);
3787       gtk_signal_connect (GTK_OBJECT (undo_button),
3788                           "clicked",
3789                           (GtkSignalFunc) undo_selection,
3790                           (gpointer) clist);
3791
3792       label = gtk_label_new ("Selection Mode :");
3793       gtk_box_pack_start (GTK_BOX (box2), label, FALSE, TRUE, 0);
3794
3795       clist_omenu = build_option_menu (items, 4, 3, clist);
3796       gtk_box_pack_start (GTK_BOX (box2), clist_omenu, FALSE, TRUE, 0);
3797
3798       /* vbox for the list itself */
3799       box2 = gtk_vbox_new (FALSE, 10);
3800       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3801       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3802
3803       /*
3804        * the rest of the clist configuration
3805        */
3806
3807       /*
3808       gtk_signal_connect (GTK_OBJECT (clist),
3809                           "select_row",
3810                           (GtkSignalFunc) select_clist,
3811                           undo_button);
3812
3813       gtk_signal_connect (GTK_OBJECT (clist),
3814                           "unselect_row",
3815                           (GtkSignalFunc) unselect_clist,
3816                           undo_button);
3817       */
3818
3819       gtk_clist_set_row_height (GTK_CLIST (clist), 18);
3820       gtk_widget_set_usize (clist, -1, 300);
3821
3822       gtk_clist_set_column_width (GTK_CLIST (clist), 0, 100);
3823
3824       for (i = 1; i < TESTGTK_CLIST_COLUMNS; i++)
3825         gtk_clist_set_column_width (GTK_CLIST (clist), i, 80);
3826
3827       gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_EXTENDED);
3828       gtk_clist_set_policy (GTK_CLIST (clist), GTK_POLICY_AUTOMATIC,
3829                             GTK_POLICY_AUTOMATIC);
3830
3831       gtk_clist_set_column_justification (GTK_CLIST (clist), 1,
3832                                           GTK_JUSTIFY_RIGHT);
3833       gtk_clist_set_column_justification (GTK_CLIST (clist), 2,
3834                                           GTK_JUSTIFY_CENTER);
3835
3836       for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3837         {
3838           texts[i] = text[i];
3839           sprintf (text[i], "Column %d", i);
3840         }
3841
3842       sprintf (text[1], "Right");
3843       sprintf (text[2], "Center");
3844
3845       for (i = 0; i < 10; i++)
3846         {
3847           sprintf (text[0], "Row %d", clist_rows++);
3848           gtk_clist_append (GTK_CLIST (clist), texts);
3849         }
3850
3851       gtk_container_border_width (GTK_CONTAINER (clist), 5);
3852       gtk_box_pack_start (GTK_BOX (box2), clist, TRUE, TRUE, 0);
3853
3854       separator = gtk_hseparator_new ();
3855       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3856
3857       box2 = gtk_vbox_new (FALSE, 10);
3858       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3859       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3860
3861       button = gtk_button_new_with_label ("close");
3862       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3863                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
3864                                  GTK_OBJECT (window));
3865
3866       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3867       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3868       gtk_widget_grab_default (button);
3869     }
3870
3871   if (!GTK_WIDGET_VISIBLE (window))
3872     gtk_widget_show_all (window);
3873   else
3874     {
3875       clist_rows = 0;
3876       gtk_widget_destroy (window);
3877     }
3878 }
3879
3880 /*
3881  * GtkCTree
3882  */
3883
3884 GdkPixmap *pixmap1;
3885 GdkPixmap *pixmap2;
3886 GdkPixmap *pixmap3;
3887 GdkBitmap *mask1;
3888 GdkBitmap *mask2;
3889 GdkBitmap *mask3;
3890
3891 static gint books = 0;
3892 static gint pages = 0;
3893
3894 static GtkWidget *book_label;
3895 static GtkWidget *page_label;
3896 static GtkWidget *sel_label;
3897 static GtkWidget *vis_label;
3898 static GtkWidget *omenu1;
3899 static GtkWidget *omenu2;
3900 static GtkWidget *omenu3;
3901 static GtkWidget *spin1;
3902 static GtkWidget *spin2;
3903 static GtkWidget *spin3;
3904 static GdkColor  *col_bg;
3905
3906 void after_press (GtkCTree *ctree, gpointer data)
3907 {
3908   char buf[80];
3909
3910   sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection));
3911   gtk_label_set (GTK_LABEL (sel_label), buf);
3912
3913   sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list));
3914   gtk_label_set (GTK_LABEL (vis_label), buf);
3915
3916   sprintf (buf, "%d", books);
3917   gtk_label_set (GTK_LABEL (book_label), buf);
3918
3919   sprintf (buf, "%d", pages);
3920   gtk_label_set (GTK_LABEL (page_label), buf);
3921 }
3922
3923 void after_move (GtkCTree *ctree, GtkCTreeNode *child, GtkCTreeNode *parent,
3924                  GtkCTreeNode *sibling, gpointer data)
3925 {
3926   char *source;
3927   char *target1;
3928   char *target2;
3929
3930   gtk_ctree_get_node_info (ctree, child, &source,
3931                            NULL, NULL, NULL, NULL, NULL, NULL, NULL);
3932   if (parent)
3933     gtk_ctree_get_node_info (ctree, parent, &target1,
3934                              NULL, NULL, NULL, NULL, NULL, NULL, NULL);
3935   if (sibling)
3936     gtk_ctree_get_node_info (ctree, sibling, &target2,
3937                              NULL, NULL, NULL, NULL, NULL, NULL, NULL);
3938
3939   g_print ("Moving \"%s\" to \"%s\" with sibling \"%s\".\n", source,
3940            (parent) ? target1 : "nil", (sibling) ? target2 : "nil");
3941 }
3942
3943 gint button_press (GtkCTree *ctree, GdkEventButton *event, gpointer data)
3944 {
3945   gint row;
3946   gint column;
3947   GtkCTreeNode *work;
3948   gint res;
3949
3950   res = gtk_clist_get_selection_info (GTK_CLIST (ctree), event->x, event->y,
3951                                       &row, &column);
3952   if (!res && event->button != 3)
3953     return FALSE;
3954
3955   work = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list, row));
3956
3957   switch (event->button)
3958     {
3959     case 1:
3960       if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_MULTIPLE &&
3961           event->state & GDK_SHIFT_MASK)
3962         gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),"button_press_event");
3963       break;
3964     case  2:
3965       if (GTK_CTREE_ROW (work)->children &&
3966           gtk_ctree_is_hot_spot (ctree, event->x, event->y))
3967         {
3968           if (GTK_CTREE_ROW (work)->expanded)
3969             gtk_ctree_collapse_recursive (ctree, work);
3970           else
3971             gtk_ctree_expand_recursive (ctree, work);
3972           after_press (ctree, NULL);
3973           gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),
3974                                         "button_press_event");
3975         }
3976       break;
3977     default:
3978       break;
3979     }
3980   return FALSE;
3981 }
3982
3983 gint button_release (GtkCTree *ctree, GdkEventButton *event, gpointer data)
3984 {
3985   gint row;
3986   gint column;
3987   GtkCTreeNode *work;
3988   gint res;
3989
3990   res = gtk_clist_get_selection_info (GTK_CLIST (ctree), event->x, event->y,
3991                                       &row, &column);
3992   if (!res || event->button != 1)
3993     return FALSE;
3994
3995   work = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list, row));
3996
3997   if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_MULTIPLE &&
3998       event->state & GDK_SHIFT_MASK)
3999     {
4000       if (GTK_CTREE_ROW (work)->row.state == GTK_STATE_SELECTED)
4001             gtk_ctree_unselect_recursive (ctree, work);
4002       else
4003         gtk_ctree_select_recursive (ctree, work);
4004       after_press (ctree, NULL);
4005       gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),
4006                                     "button_release_event");
4007     }
4008   return FALSE;
4009 }
4010
4011 void count_items (GtkCTree *ctree, GtkCTreeNode *list)
4012 {
4013   if (GTK_CTREE_ROW (list)->is_leaf)
4014     pages--;
4015   else
4016     books--;
4017 }
4018
4019 void expand_all (GtkWidget *widget, GtkCTree *ctree)
4020 {
4021   gtk_ctree_expand_recursive (ctree, NULL);
4022   after_press (ctree, NULL);
4023 }
4024
4025 void collapse_all (GtkWidget *widget, GtkCTree *ctree)
4026 {
4027   gtk_ctree_collapse_recursive (ctree, NULL);
4028   after_press (ctree, NULL);
4029 }
4030
4031 void select_all (GtkWidget *widget, GtkCTree *ctree)
4032 {
4033   gtk_ctree_select_recursive (ctree, NULL);
4034   after_press (ctree, NULL);
4035 }
4036
4037 void unselect_all (GtkWidget *widget, GtkCTree *ctree)
4038 {
4039   gtk_ctree_unselect_recursive (ctree, NULL);
4040   after_press (ctree, NULL);
4041 }
4042
4043 void remove_selection (GtkWidget *widget, GtkCTree *ctree)
4044 {
4045   GtkCTreeNode *work;
4046   GtkCTreeNode *new_sel;
4047   GList *selection;
4048
4049   selection = GTK_CLIST (ctree)->selection;
4050   new_sel = NULL;
4051
4052   gtk_clist_freeze (GTK_CLIST (ctree));
4053
4054   while (selection)
4055     {
4056       work = selection->data;
4057       if (GTK_CTREE_ROW (work)->is_leaf)
4058         pages--;
4059       else
4060         gtk_ctree_post_recursive (ctree, work,
4061                                   (GtkCTreeFunc) count_items, NULL);
4062
4063       if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_BROWSE)
4064         {
4065           if (GTK_CTREE_ROW (work)->children)
4066             {
4067               new_sel = GTK_CTREE_ROW (work)->sibling;
4068               if (!new_sel)
4069                 new_sel = GTK_CTREE_NODE_NEXT (work);
4070             }
4071           else
4072             {
4073               if (GTK_CTREE_NODE_NEXT (work))
4074                 new_sel = GTK_CTREE_NODE_NEXT (work);
4075               else
4076                 new_sel = GTK_CTREE_NODE_PREV (work);
4077             }
4078         }
4079
4080       gtk_ctree_remove_node (ctree, work);
4081       selection = GTK_CLIST (ctree)->selection;
4082     }
4083
4084   if (new_sel)
4085     gtk_ctree_select (ctree, new_sel);
4086
4087   gtk_clist_thaw (GTK_CLIST (ctree));
4088   after_press (ctree, NULL);
4089 }
4090
4091 void sort_all (GtkWidget *widget, GtkCTree *ctree)
4092 {
4093   gtk_ctree_sort_recursive (ctree, NULL);
4094 }
4095
4096 struct _ExportStruct {
4097   gchar *tree;
4098   gchar *info;
4099   gboolean is_leaf;
4100 };
4101
4102 typedef struct _ExportStruct ExportStruct;
4103
4104 gboolean
4105 gnode2ctree (GtkCTree   *ctree,
4106              guint       depth,
4107              GNode        *gnode,
4108              GtkCTreeNode *cnode,
4109              gpointer    data)
4110 {
4111   ExportStruct *es;
4112   GdkPixmap *pixmap_closed;
4113   GdkBitmap *mask_closed;
4114   GdkPixmap *pixmap_opened;
4115   GdkBitmap *mask_opened;
4116
4117   if (!cnode || !gnode || (!(es = gnode->data)))
4118     return FALSE;
4119
4120   if (es->is_leaf)
4121     {
4122       pixmap_closed = pixmap3;
4123       mask_closed = mask3;
4124       pixmap_opened = NULL;
4125       mask_opened = NULL;
4126     }
4127   else
4128     {
4129       pixmap_closed = pixmap1;
4130       mask_closed = mask1;
4131       pixmap_opened = pixmap2;
4132       mask_opened = mask2;
4133     }
4134
4135   gtk_ctree_set_node_info (ctree, cnode, es->tree, 2, pixmap_closed,
4136                            mask_closed, pixmap_opened, mask_opened,
4137                            es->is_leaf, (depth < 3));
4138   gtk_ctree_node_set_text (ctree, cnode, 1, es->info);
4139   g_free (es);
4140   gnode->data = NULL;
4141
4142   return TRUE;
4143 }
4144
4145 gboolean
4146 ctree2gnode (GtkCTree   *ctree,
4147              guint       depth,
4148              GNode        *gnode,
4149              GtkCTreeNode *cnode,
4150              gpointer    data)
4151 {
4152   ExportStruct *es;
4153
4154   if (!cnode || !gnode)
4155     return FALSE;
4156
4157   es = g_new (ExportStruct, 1);
4158   gnode->data = es;
4159   es->is_leaf = GTK_CTREE_ROW (cnode)->is_leaf;
4160   es->tree = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[0])->text;
4161   es->info = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[1])->text;
4162   return TRUE;
4163 }
4164
4165 void export_ctree (GtkWidget *widget, GtkCTree *ctree)
4166 {
4167   char *title[] = { "Tree" , "Info" };
4168   static GtkWidget *export_window = NULL;
4169   static GtkCTree *export_ctree;
4170   GtkWidget *vbox;
4171   GtkWidget *button;
4172   GtkWidget *sep;
4173   GNode *gnode;
4174   GtkCTreeNode *node;
4175
4176   if (!export_window)
4177     {
4178       export_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4179
4180       gtk_signal_connect (GTK_OBJECT (export_window), "destroy",
4181                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
4182                           &export_window);
4183
4184       gtk_window_set_title (GTK_WINDOW (export_window), "exported ctree");
4185       gtk_container_border_width (GTK_CONTAINER (export_window), 5);
4186
4187       vbox = gtk_vbox_new (FALSE, 0);
4188       gtk_container_add (GTK_CONTAINER (export_window), vbox);
4189
4190       button = gtk_button_new_with_label ("Close");
4191       gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, TRUE, 0);
4192
4193       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4194                                  (GtkSignalFunc) gtk_widget_destroy,
4195                                  GTK_OBJECT(export_window));
4196
4197       sep = gtk_hseparator_new ();
4198       gtk_box_pack_end (GTK_BOX (vbox), sep, FALSE, TRUE, 10);
4199
4200       export_ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title));
4201       gtk_ctree_set_line_style (export_ctree, GTK_CTREE_LINES_DOTTED);
4202
4203       gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (export_ctree),
4204                           TRUE, TRUE, 0);
4205       gtk_clist_set_selection_mode (GTK_CLIST (export_ctree),
4206                                     GTK_SELECTION_EXTENDED);
4207       gtk_clist_set_policy (GTK_CLIST (export_ctree), GTK_POLICY_ALWAYS,
4208                             GTK_POLICY_AUTOMATIC);
4209       gtk_clist_set_column_width (GTK_CLIST (export_ctree), 0, 200);
4210       gtk_clist_set_column_width (GTK_CLIST (export_ctree), 1, 200);
4211       gtk_widget_set_usize (GTK_WIDGET (export_ctree), 300, 200);
4212     }
4213
4214   if (!GTK_WIDGET_VISIBLE (export_window))
4215     gtk_widget_show_all (export_window);
4216
4217   gtk_clist_clear (GTK_CLIST (export_ctree));
4218
4219   node = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list,
4220                                      GTK_CLIST (ctree)->focus_row));
4221   if (!node)
4222     return;
4223
4224   gnode = gtk_ctree_export_to_gnode (ctree, NULL, NULL, node,
4225                                      ctree2gnode, NULL);
4226   if (gnode)
4227     {
4228       gtk_ctree_insert_gnode (export_ctree, NULL, NULL, gnode,
4229                               gnode2ctree, NULL);
4230       g_node_destroy (gnode);
4231     }
4232 }
4233
4234 void change_indent (GtkWidget *widget, GtkCTree *ctree)
4235 {
4236   gtk_ctree_set_indent (ctree, GTK_ADJUSTMENT (widget)->value);
4237 }
4238
4239 void change_row_height (GtkWidget *widget, GtkCList *clist)
4240 {
4241   gtk_clist_set_row_height (clist, GTK_ADJUSTMENT (widget)->value);
4242 }
4243
4244 void toggle_reorderable (GtkWidget *widget, GtkCTree *ctree)
4245 {
4246   gtk_ctree_set_reorderable (ctree, GTK_TOGGLE_BUTTON (widget)->active);
4247 }
4248
4249 void set_background (GtkCTree *ctree, GtkCTreeNode *node, gpointer data)
4250 {
4251   if (!node)
4252     return;
4253
4254   if (ctree->line_style != GTK_CTREE_LINES_TABBED)
4255     {
4256       if (GTK_CTREE_ROW (node)->is_leaf)
4257         {
4258           if (GTK_CTREE_ROW (node)->parent)
4259             gtk_ctree_node_set_background
4260               (ctree, node,
4261                GTK_CTREE_ROW (GTK_CTREE_ROW (node)->parent)->row.data);
4262         }
4263       else
4264        gtk_ctree_node_set_background (ctree, node,
4265                                       GTK_CTREE_ROW (node)->row.data);
4266     }
4267   else
4268     gtk_ctree_node_set_background (ctree, node, NULL);
4269 }
4270
4271 void ctree_toggle_line_style (GtkWidget *widget, GtkCTree *ctree)
4272 {
4273   gint i;
4274
4275   if (!GTK_WIDGET_MAPPED (widget))
4276     return;
4277
4278   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4279                     (((GtkOptionMenu *)omenu1)->menu_item),i);
4280
4281   if ((ctree->line_style == GTK_CTREE_LINES_TABBED &&
4282        ((GtkCTreeLineStyle) (3-i)) != GTK_CTREE_LINES_TABBED) ||
4283       (ctree->line_style != GTK_CTREE_LINES_TABBED &&
4284        ((GtkCTreeLineStyle) (3-i)) == GTK_CTREE_LINES_TABBED))
4285     gtk_ctree_pre_recursive (ctree, NULL, set_background, NULL);
4286   gtk_ctree_set_line_style (ctree, (GtkCTreeLineStyle) (3-i));
4287 }
4288
4289 void ctree_toggle_justify (GtkWidget *widget, GtkCTree *ctree)
4290 {
4291   gint i;
4292
4293   if (!GTK_WIDGET_MAPPED (widget))
4294     return;
4295
4296   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4297                     (((GtkOptionMenu *)omenu2)->menu_item),i);
4298
4299   gtk_clist_set_column_justification (GTK_CLIST (ctree), ctree->tree_column,
4300                                       (GtkJustification) (1-i));
4301 }
4302
4303 void ctree_toggle_sel_mode (GtkWidget *widget, GtkCTree *ctree)
4304 {
4305   gint i;
4306
4307   if (!GTK_WIDGET_MAPPED (widget))
4308     return;
4309
4310   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4311                     (((GtkOptionMenu *)omenu3)->menu_item), i);
4312
4313   gtk_clist_set_selection_mode (GTK_CLIST (ctree), (GtkSelectionMode) (3-i));
4314   after_press (ctree, NULL);
4315 }
4316
4317 void build_recursive (GtkCTree *ctree, gint cur_depth, gint depth,
4318                       gint num_books, gint num_pages, GtkCTreeNode *parent)
4319 {
4320   gchar *text[2];
4321   gchar buf1[60];
4322   gchar buf2[60];
4323   GtkCTreeNode *sibling;
4324   gint i;
4325
4326   text[0] = buf1;
4327   text[1] = buf2;
4328   sibling = NULL;
4329
4330   for (i = num_pages + num_books; i > num_books; i--)
4331     {
4332       pages++;
4333       sprintf (buf1, "Page %02d", (gint) rand() % 100);
4334       sprintf (buf2, "Item %d-%d", cur_depth, i);
4335       sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
4336                                        pixmap3, mask3, NULL, NULL,
4337                                        TRUE, FALSE);
4338
4339       if (ctree->line_style == GTK_CTREE_LINES_TABBED)
4340         gtk_ctree_node_set_background (ctree, sibling, col_bg);
4341     }
4342
4343   if (cur_depth == depth)
4344     return;
4345
4346   for (i = num_books; i > 0; i--)
4347     {
4348       books++;
4349       sprintf (buf1, "Book %02d", (gint) rand() % 100);
4350       sprintf (buf2, "Item %d-%d", cur_depth, i);
4351       sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
4352                                        pixmap1, mask1, pixmap2, mask2,
4353                                        FALSE, FALSE);
4354
4355       col_bg = g_new (GdkColor, 1);
4356
4357       if (cur_depth % 3 == 0)
4358         {
4359           col_bg->red   = 10000 * (cur_depth % 6);
4360           col_bg->green = 0;
4361           col_bg->blue  = 65535 - ((i * 10000) % 65535);
4362         }
4363       else if (cur_depth % 3 == 1)
4364         {
4365           col_bg->red   = 10000 * (cur_depth % 6);
4366           col_bg->green = 65535 - ((i * 10000) % 65535);
4367           col_bg->blue  = 0;
4368         }
4369       else
4370         {
4371           col_bg->red   = 65535 - ((i * 10000) % 65535);
4372           col_bg->green = 0;
4373           col_bg->blue  = 10000 * (cur_depth % 6);
4374         }
4375
4376       gdk_color_alloc (gtk_widget_get_colormap (GTK_WIDGET (ctree)), col_bg);
4377       gtk_ctree_node_set_row_data_full (ctree, sibling, col_bg, g_free);
4378
4379       if (ctree->line_style == GTK_CTREE_LINES_TABBED)
4380         gtk_ctree_node_set_background (ctree, sibling, col_bg);
4381
4382       build_recursive (ctree, cur_depth + 1, depth, num_books, num_pages,
4383                        sibling);
4384     }
4385 }
4386
4387 void rebuild_tree (GtkWidget *widget, GtkCTree *ctree)
4388 {
4389   gchar *text [2];
4390   gchar label1[] = "Root";
4391   gchar label2[] = "";
4392   GtkCTreeNode *parent;
4393   guint b, d, p, n;
4394
4395   text[0] = label1;
4396   text[1] = label2;
4397
4398   d = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin1));
4399   b = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin2));
4400   p = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin3));
4401
4402   n = ((pow (b, d) - 1) / (b - 1)) * (p + 1);
4403
4404   if (n > 100000)
4405     {
4406       g_print ("%d total items? Try less\n",n);
4407       return;
4408     }
4409
4410   gtk_clist_freeze (GTK_CLIST (ctree));
4411   gtk_clist_clear (GTK_CLIST (ctree));
4412
4413   books = 1;
4414   pages = 0;
4415
4416   parent = gtk_ctree_insert_node (ctree, NULL, NULL, text, 5, pixmap1,
4417                                   mask1, pixmap2, mask2, FALSE, TRUE);
4418
4419   col_bg = g_new (GdkColor, 1);
4420   col_bg->red   = 0;
4421   col_bg->green = 45000;
4422   col_bg->blue  = 55000;
4423   gdk_color_alloc (gtk_widget_get_colormap (GTK_WIDGET (ctree)), col_bg);
4424   gtk_ctree_node_set_row_data_full (ctree, parent, col_bg, g_free);
4425   if (ctree->line_style == GTK_CTREE_LINES_TABBED)
4426     gtk_ctree_node_set_background (ctree, parent, col_bg);
4427
4428   build_recursive (ctree, 1, d, b, p, parent);
4429   gtk_clist_thaw (GTK_CLIST (ctree));
4430   after_press (ctree, NULL);
4431 }
4432
4433 static void
4434 ctree_click_column (GtkCTree *ctree, gint column, gpointer data)
4435 {
4436   GtkCList *clist;
4437
4438   clist = GTK_CLIST (ctree);
4439
4440   if (column == clist->sort_column)
4441     {
4442       if (clist->sort_type == GTK_SORT_ASCENDING)
4443         clist->sort_type = GTK_SORT_DESCENDING;
4444       else
4445         clist->sort_type = GTK_SORT_ASCENDING;
4446     }
4447   else
4448     gtk_clist_set_sort_column (clist, column);
4449
4450   gtk_ctree_sort_recursive (ctree, NULL);
4451 }
4452
4453 void create_ctree (void)
4454 {
4455   static GtkWidget *window = NULL;
4456   GtkTooltips *tooltips;
4457   GtkCTree *ctree;
4458   GtkWidget *vbox;
4459   GtkWidget *hbox;
4460   GtkWidget *hbox2;
4461   GtkWidget *frame;
4462   GtkWidget *label;
4463   GtkWidget *button;
4464   GtkWidget *check;
4465   GtkAdjustment *adj;
4466   GtkWidget *spinner;
4467   GdkColor transparent;
4468
4469   char *title[] = { "Tree" , "Info" };
4470   char buf[80];
4471
4472   static OptionMenuItem items1[] =
4473   {
4474     { "Solid",    ctree_toggle_line_style },
4475     { "Dotted",   ctree_toggle_line_style },
4476     { "Tabbed",   ctree_toggle_line_style },
4477     { "No lines", ctree_toggle_line_style }
4478   };
4479
4480   static OptionMenuItem items2[] =
4481   {
4482     { "Left",  ctree_toggle_justify },
4483     { "Right", ctree_toggle_justify }
4484   };
4485
4486   static OptionMenuItem items3[] =
4487   {
4488     { "Single",   ctree_toggle_sel_mode },
4489     { "Browse",   ctree_toggle_sel_mode },
4490     { "Multiple", ctree_toggle_sel_mode },
4491     { "Extended", ctree_toggle_sel_mode }
4492   };
4493
4494   if (!window)
4495     {
4496       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4497
4498       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4499                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
4500                           &window);
4501
4502       gtk_window_set_title (GTK_WINDOW (window), "GtkCTree");
4503       gtk_container_border_width (GTK_CONTAINER (window), 0);
4504
4505       tooltips = gtk_tooltips_new ();
4506       gtk_object_ref (GTK_OBJECT (tooltips));
4507       gtk_object_sink (GTK_OBJECT (tooltips));
4508
4509       gtk_object_set_data_full (GTK_OBJECT (window), "tooltips", tooltips,
4510                                 (GtkDestroyNotify) gtk_object_unref);
4511
4512       vbox = gtk_vbox_new (FALSE, 0);
4513       gtk_container_add (GTK_CONTAINER (window), vbox);
4514
4515       hbox = gtk_hbox_new (FALSE, 5);
4516       gtk_container_border_width (GTK_CONTAINER (hbox), 5);
4517       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4518
4519       label = gtk_label_new ("Depth :");
4520       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4521
4522       adj = (GtkAdjustment *) gtk_adjustment_new (4, 1, 10, 1, 5, 0);
4523       spin1 = gtk_spin_button_new (adj, 0, 0);
4524       gtk_box_pack_start (GTK_BOX (hbox), spin1, FALSE, TRUE, 5);
4525
4526       label = gtk_label_new ("Books :");
4527       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4528
4529       adj = (GtkAdjustment *) gtk_adjustment_new (3, 1, 20, 1, 5, 0);
4530       spin2 = gtk_spin_button_new (adj, 0, 0);
4531       gtk_box_pack_start (GTK_BOX (hbox), spin2, FALSE, TRUE, 5);
4532
4533       label = gtk_label_new ("Pages :");
4534       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4535
4536       adj = (GtkAdjustment *) gtk_adjustment_new (5, 1, 20, 1, 5, 0);
4537       spin3 = gtk_spin_button_new (adj, 0, 0);
4538       gtk_box_pack_start (GTK_BOX (hbox), spin3, FALSE, TRUE, 5);
4539
4540       button = gtk_button_new_with_label ("Close");
4541       gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4542
4543       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4544                                  (GtkSignalFunc) gtk_widget_destroy,
4545                                  GTK_OBJECT(window));
4546
4547       button = gtk_button_new_with_label ("Rebuild tree");
4548       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4549
4550       ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title));
4551       gtk_ctree_set_line_style (ctree, GTK_CTREE_LINES_DOTTED);
4552       gtk_ctree_set_reorderable (ctree, TRUE);
4553       gtk_signal_connect (GTK_OBJECT (ctree), "click_column",
4554                           (GtkSignalFunc) ctree_click_column,
4555                           NULL);
4556       gtk_signal_connect (GTK_OBJECT (ctree), "button_press_event",
4557                           GTK_SIGNAL_FUNC (button_press), NULL);
4558       gtk_signal_connect_after (GTK_OBJECT (ctree), "button_press_event",
4559                                 GTK_SIGNAL_FUNC (after_press), NULL);
4560       gtk_signal_connect (GTK_OBJECT (ctree), "button_release_event",
4561                           GTK_SIGNAL_FUNC (button_release), NULL);
4562       gtk_signal_connect_after (GTK_OBJECT (ctree), "button_release_event",
4563                                 GTK_SIGNAL_FUNC (after_press), NULL);
4564       gtk_signal_connect_after (GTK_OBJECT (ctree), "tree_move",
4565                                 GTK_SIGNAL_FUNC (after_move), NULL);
4566       gtk_signal_connect_after (GTK_OBJECT (ctree), "end_selection",
4567                                 GTK_SIGNAL_FUNC (after_press), NULL);
4568       gtk_signal_connect_after (GTK_OBJECT (ctree), "toggle_focus_row",
4569                                 GTK_SIGNAL_FUNC (after_press), NULL);
4570       gtk_signal_connect_after (GTK_OBJECT (ctree), "select_all",
4571                                 GTK_SIGNAL_FUNC (after_press), NULL);
4572       gtk_signal_connect_after (GTK_OBJECT (ctree), "unselect_all",
4573                                 GTK_SIGNAL_FUNC (after_press), NULL);
4574       gtk_signal_connect_after (GTK_OBJECT (ctree), "scroll_vertical",
4575                                 GTK_SIGNAL_FUNC (after_press), NULL);
4576
4577       gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (ctree), TRUE, TRUE, 0);
4578       gtk_clist_set_selection_mode (GTK_CLIST (ctree), GTK_SELECTION_EXTENDED);
4579       gtk_clist_set_policy (GTK_CLIST (ctree), GTK_POLICY_ALWAYS,
4580                             GTK_POLICY_AUTOMATIC);
4581       gtk_clist_set_column_width (GTK_CLIST (ctree), 0, 200);
4582       gtk_clist_set_column_width (GTK_CLIST (ctree), 1, 200);
4583
4584       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4585                           GTK_SIGNAL_FUNC (rebuild_tree), ctree);
4586
4587       hbox = gtk_hbox_new (FALSE, 5);
4588       gtk_container_border_width (GTK_CONTAINER (hbox), 5);
4589       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4590
4591       button = gtk_button_new_with_label ("Expand all");
4592       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4593                           GTK_SIGNAL_FUNC (expand_all), ctree);
4594       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4595
4596       button = gtk_button_new_with_label ("Collapse all");
4597       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4598                           GTK_SIGNAL_FUNC (collapse_all), ctree);
4599       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4600
4601       button = gtk_button_new_with_label ("Sort tree");
4602       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4603                           GTK_SIGNAL_FUNC (sort_all), ctree);
4604       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4605
4606       button = gtk_button_new_with_label ("Export tree");
4607       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4608                           GTK_SIGNAL_FUNC (export_ctree), ctree);
4609       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4610
4611       hbox = gtk_hbox_new (FALSE, 5);
4612       gtk_container_border_width (GTK_CONTAINER (hbox), 5);
4613       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4614
4615       label = gtk_label_new ("Row height :");
4616       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4617
4618       adj = (GtkAdjustment *) gtk_adjustment_new (20, 12, 100, 1, 10, 0);
4619       spinner = gtk_spin_button_new (adj, 0, 0);
4620       gtk_tooltips_set_tip (tooltips, spinner,
4621                             "Row height of list items", NULL);
4622       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
4623                           GTK_SIGNAL_FUNC (change_row_height), ctree);
4624       gtk_box_pack_start (GTK_BOX (hbox), spinner, FALSE, TRUE, 5);
4625       gtk_clist_set_row_height ( GTK_CLIST (ctree), adj->value);
4626
4627       button = gtk_button_new_with_label ("Select all");
4628       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4629                           GTK_SIGNAL_FUNC (select_all), ctree);
4630       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4631
4632       button = gtk_button_new_with_label ("Unselect all");
4633       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4634                           GTK_SIGNAL_FUNC (unselect_all), ctree);
4635       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4636
4637       button = gtk_button_new_with_label ("Remove selection");
4638       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4639                           GTK_SIGNAL_FUNC (remove_selection), ctree);
4640       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4641
4642       hbox = gtk_hbox_new (TRUE, 5);
4643       gtk_container_border_width (GTK_CONTAINER (hbox), 5);
4644       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4645
4646       hbox2 = gtk_hbox_new (FALSE, 0);
4647       gtk_box_pack_start (GTK_BOX (hbox), hbox2, FALSE, TRUE, 0);
4648
4649       label = gtk_label_new ("Indent :");
4650       gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
4651
4652       adj = (GtkAdjustment *) gtk_adjustment_new (20, 0, 60, 1, 10, 0);
4653       spinner = gtk_spin_button_new (adj, 0, 0);
4654       gtk_tooltips_set_tip (tooltips, spinner, "Tree indentation.", NULL);
4655       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
4656                           GTK_SIGNAL_FUNC (change_indent), ctree);
4657       gtk_box_pack_start (GTK_BOX (hbox2), spinner, FALSE, TRUE, 5);
4658
4659       check = gtk_check_button_new_with_label ("Reorderable");
4660       gtk_tooltips_set_tip (tooltips, check,
4661                             "Tree items can be reordered by dragging.", NULL);
4662       gtk_signal_connect (GTK_OBJECT (check), "clicked",
4663                           GTK_SIGNAL_FUNC (toggle_reorderable), ctree);
4664       gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
4665       gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (check), TRUE);
4666
4667       omenu1 = build_option_menu (items1, 4, 1, ctree);
4668       gtk_tooltips_set_tip (tooltips, omenu1, "The tree's line style.", NULL);
4669       gtk_box_pack_start (GTK_BOX (hbox), omenu1, FALSE, TRUE, 0);
4670
4671       omenu2 = build_option_menu (items2, 2, 0, ctree);
4672       gtk_tooltips_set_tip (tooltips, omenu2, "The tree's justification.",
4673                             NULL);
4674       gtk_box_pack_start (GTK_BOX (hbox), omenu2, FALSE, TRUE, 0);
4675
4676       omenu3 = build_option_menu (items3, 4, 3, ctree);
4677       gtk_tooltips_set_tip (tooltips, omenu3, "The list's selection mode.",
4678                             NULL);
4679       gtk_box_pack_start (GTK_BOX (hbox), omenu3, FALSE, TRUE, 0);
4680
4681       gtk_widget_realize (window);
4682
4683       pixmap1 = gdk_pixmap_create_from_xpm_d (window->window, &mask1,
4684                                               &transparent, book_closed_xpm);
4685       pixmap2 = gdk_pixmap_create_from_xpm_d (window->window, &mask2,
4686                                               &transparent, book_open_xpm);
4687       pixmap3 = gdk_pixmap_create_from_xpm_d (window->window, &mask3,
4688                                               &transparent, mini_page_xpm);
4689
4690       gtk_widget_set_usize (GTK_WIDGET (ctree), 0, 300);
4691
4692       frame = gtk_frame_new (NULL);
4693       gtk_container_border_width (GTK_CONTAINER (frame), 0);
4694       gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
4695       gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
4696
4697       hbox = gtk_hbox_new (TRUE, 2);
4698       gtk_container_border_width (GTK_CONTAINER (hbox), 2);
4699       gtk_container_add (GTK_CONTAINER (frame), hbox);
4700
4701       frame = gtk_frame_new (NULL);
4702       gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
4703       gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
4704
4705       hbox2 = gtk_hbox_new (FALSE, 0);
4706       gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
4707       gtk_container_add (GTK_CONTAINER (frame), hbox2);
4708
4709       label = gtk_label_new ("Books :");
4710       gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
4711
4712       sprintf (buf, "%d", books);
4713       book_label = gtk_label_new (buf);
4714       gtk_box_pack_end (GTK_BOX (hbox2), book_label, FALSE, TRUE, 5);
4715
4716       frame = gtk_frame_new (NULL);
4717       gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
4718       gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
4719
4720       hbox2 = gtk_hbox_new (FALSE, 0);
4721       gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
4722       gtk_container_add (GTK_CONTAINER (frame), hbox2);
4723
4724       label = gtk_label_new ("Pages :");
4725       gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
4726
4727       sprintf (buf, "%d", pages);
4728       page_label = gtk_label_new (buf);
4729       gtk_box_pack_end (GTK_BOX (hbox2), page_label, FALSE, TRUE, 5);
4730
4731       frame = gtk_frame_new (NULL);
4732       gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
4733       gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
4734
4735       hbox2 = gtk_hbox_new (FALSE, 0);
4736       gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
4737       gtk_container_add (GTK_CONTAINER (frame), hbox2);
4738
4739       label = gtk_label_new ("Selected :");
4740       gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
4741
4742       sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection));
4743       sel_label = gtk_label_new (buf);
4744       gtk_box_pack_end (GTK_BOX (hbox2), sel_label, FALSE, TRUE, 5);
4745
4746       frame = gtk_frame_new (NULL);
4747       gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
4748       gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
4749
4750       hbox2 = gtk_hbox_new (FALSE, 0);
4751       gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
4752       gtk_container_add (GTK_CONTAINER (frame), hbox2);
4753
4754       label = gtk_label_new ("Visible :");
4755       gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
4756
4757       sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list));
4758       vis_label = gtk_label_new (buf);
4759       gtk_box_pack_end (GTK_BOX (hbox2), vis_label, FALSE, TRUE, 5);
4760
4761       rebuild_tree (NULL, ctree);
4762     }
4763
4764   if (!GTK_WIDGET_VISIBLE (window))
4765     gtk_widget_show_all (window);
4766   else
4767     gtk_widget_destroy (window);
4768 }
4769
4770 /*
4771  * GtkColorSelection
4772  */
4773
4774 void
4775 color_selection_ok (GtkWidget               *w,
4776                     GtkColorSelectionDialog *cs)
4777 {
4778   GtkColorSelection *colorsel;
4779   gdouble color[4];
4780
4781   colorsel=GTK_COLOR_SELECTION(cs->colorsel);
4782
4783   gtk_color_selection_get_color(colorsel,color);
4784   gtk_color_selection_set_color(colorsel,color);
4785 }
4786
4787 void
4788 color_selection_changed (GtkWidget *w,
4789                          GtkColorSelectionDialog *cs)
4790 {
4791   GtkColorSelection *colorsel;
4792   gdouble color[4];
4793
4794   colorsel=GTK_COLOR_SELECTION(cs->colorsel);
4795   gtk_color_selection_get_color(colorsel,color);
4796 }
4797
4798 void
4799 create_color_selection (void)
4800 {
4801   static GtkWidget *window = NULL;
4802
4803   if (!window)
4804     {
4805       window = gtk_color_selection_dialog_new ("color selection dialog");
4806
4807       gtk_color_selection_set_opacity (
4808         GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
4809         TRUE);
4810
4811       gtk_color_selection_set_update_policy(
4812         GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
4813         GTK_UPDATE_CONTINUOUS);
4814
4815       gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
4816
4817       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4818                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4819                           &window);
4820
4821       gtk_signal_connect (
4822         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
4823         "color_changed",
4824         GTK_SIGNAL_FUNC(color_selection_changed),
4825         window);
4826
4827       gtk_signal_connect (
4828         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->ok_button),
4829         "clicked",
4830         GTK_SIGNAL_FUNC(color_selection_ok),
4831         window);
4832
4833       gtk_signal_connect_object (
4834         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->cancel_button),
4835         "clicked",
4836         GTK_SIGNAL_FUNC(gtk_widget_destroy),
4837         GTK_OBJECT (window));
4838     }
4839
4840   if (!GTK_WIDGET_VISIBLE (window))
4841     gtk_widget_show (window);
4842   else
4843     gtk_widget_destroy (window);
4844 }
4845
4846 /*
4847  * GtkFileSelection
4848  */
4849
4850 void
4851 file_selection_hide_fileops (GtkWidget *widget,
4852                              GtkFileSelection *fs)
4853 {
4854   gtk_file_selection_hide_fileop_buttons (fs);
4855 }
4856
4857 void
4858 file_selection_ok (GtkWidget        *w,
4859                    GtkFileSelection *fs)
4860 {
4861   g_print ("%s\n", gtk_file_selection_get_filename (fs));
4862   gtk_widget_destroy (GTK_WIDGET (fs));
4863 }
4864
4865 void
4866 create_file_selection (void)
4867 {
4868   static GtkWidget *window = NULL;
4869   GtkWidget *button;
4870
4871   if (!window)
4872     {
4873       window = gtk_file_selection_new ("file selection dialog");
4874
4875       gtk_file_selection_hide_fileop_buttons (GTK_FILE_SELECTION (window));
4876
4877       gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
4878
4879       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4880                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4881                           &window);
4882
4883       gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (window)->ok_button),
4884                           "clicked", GTK_SIGNAL_FUNC(file_selection_ok),
4885                           window);
4886       gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (window)->cancel_button),
4887                                  "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
4888                                  GTK_OBJECT (window));
4889
4890       button = gtk_button_new_with_label ("Hide Fileops");
4891       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4892                           (GtkSignalFunc) file_selection_hide_fileops,
4893                           (gpointer) window);
4894       gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
4895                           button, FALSE, FALSE, 0);
4896       gtk_widget_show (button);
4897
4898       button = gtk_button_new_with_label ("Show Fileops");
4899       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4900                                  (GtkSignalFunc) gtk_file_selection_show_fileop_buttons,
4901                                  (gpointer) window);
4902       gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
4903                           button, FALSE, FALSE, 0);
4904       gtk_widget_show (button);
4905     }
4906
4907   if (!GTK_WIDGET_VISIBLE (window))
4908     gtk_widget_show (window);
4909   else
4910     gtk_widget_destroy (window);
4911 }
4912
4913 /*
4914  * GtkFontSelection
4915  */
4916
4917 void
4918 font_selection_ok (GtkWidget              *w,
4919                    GtkFontSelectionDialog *fs)
4920 {
4921   g_print ("%s\n", gtk_font_selection_dialog_get_font_name (fs));
4922   gtk_widget_destroy (GTK_WIDGET (fs));
4923 }
4924
4925 void
4926 create_font_selection (void)
4927 {
4928   static GtkWidget *window = NULL;
4929
4930   if (!window)
4931     {
4932       window = gtk_font_selection_dialog_new ("Font Selection Dialog");
4933
4934       gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
4935
4936       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4937                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4938                           &window);
4939
4940       gtk_signal_connect (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->ok_button),
4941                           "clicked", GTK_SIGNAL_FUNC(font_selection_ok),
4942                           GTK_FONT_SELECTION_DIALOG (window));
4943       gtk_signal_connect_object (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->cancel_button),
4944                                  "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
4945                                  GTK_OBJECT (window));
4946     }
4947
4948   if (!GTK_WIDGET_VISIBLE (window))
4949     gtk_widget_show (window);
4950   else
4951     gtk_widget_destroy (window);
4952 }
4953
4954 /*
4955  * GtkDialog
4956  */
4957
4958 static GtkWidget *dialog_window = NULL;
4959
4960 void
4961 label_toggle (GtkWidget  *widget,
4962               GtkWidget **label)
4963 {
4964   if (!(*label))
4965     {
4966       *label = gtk_label_new ("Dialog Test");
4967       gtk_signal_connect (GTK_OBJECT (*label),
4968                           "destroy",
4969                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
4970                           label);
4971       gtk_misc_set_padding (GTK_MISC (*label), 10, 10);
4972       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
4973                           *label, TRUE, TRUE, 0);
4974       gtk_widget_show (*label);
4975     }
4976   else
4977     gtk_widget_destroy (*label);
4978 }
4979
4980 void
4981 create_dialog (void)
4982 {
4983   static GtkWidget *label;
4984   GtkWidget *button;
4985
4986   if (!dialog_window)
4987     {
4988       dialog_window = gtk_dialog_new ();
4989
4990       gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
4991                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4992                           &dialog_window);
4993
4994       gtk_window_set_title (GTK_WINDOW (dialog_window), "GtkDialog");
4995       gtk_container_border_width (GTK_CONTAINER (dialog_window), 0);
4996       gtk_widget_set_usize (dialog_window, 200, 110);
4997
4998       button = gtk_button_new_with_label ("OK");
4999       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5000       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
5001                           button, TRUE, TRUE, 0);
5002       gtk_widget_grab_default (button);
5003       gtk_widget_show (button);
5004
5005       button = gtk_button_new_with_label ("Toggle");
5006       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5007                           GTK_SIGNAL_FUNC (label_toggle),
5008                           &label);
5009       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5010       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
5011                           button, TRUE, TRUE, 0);
5012       gtk_widget_show (button);
5013
5014       label = NULL;
5015     }
5016
5017   if (!GTK_WIDGET_VISIBLE (dialog_window))
5018     gtk_widget_show (dialog_window);
5019   else
5020     gtk_widget_destroy (dialog_window);
5021 }
5022
5023 /*
5024  * GtkRange
5025  */
5026
5027 void
5028 create_range_controls (void)
5029 {
5030   static GtkWidget *window = NULL;
5031   GtkWidget *box1;
5032   GtkWidget *box2;
5033   GtkWidget *button;
5034   GtkWidget *scrollbar;
5035   GtkWidget *scale;
5036   GtkWidget *separator;
5037   GtkObject *adjustment;
5038
5039   if (!window)
5040     {
5041       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5042
5043       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5044                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5045                           &window);
5046
5047       gtk_window_set_title (GTK_WINDOW (window), "range controls");
5048       gtk_container_border_width (GTK_CONTAINER (window), 0);
5049
5050
5051       box1 = gtk_vbox_new (FALSE, 0);
5052       gtk_container_add (GTK_CONTAINER (window), box1);
5053       gtk_widget_show (box1);
5054
5055
5056       box2 = gtk_vbox_new (FALSE, 10);
5057       gtk_container_border_width (GTK_CONTAINER (box2), 10);
5058       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
5059       gtk_widget_show (box2);
5060
5061
5062       adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
5063
5064       scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
5065       gtk_widget_set_usize (GTK_WIDGET (scale), 150, 30);
5066       gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
5067       gtk_scale_set_digits (GTK_SCALE (scale), 1);
5068       gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5069       gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
5070       gtk_widget_show (scale);
5071
5072       scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adjustment));
5073       gtk_range_set_update_policy (GTK_RANGE (scrollbar),
5074                                    GTK_UPDATE_CONTINUOUS);
5075       gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0);
5076       gtk_widget_show (scrollbar);
5077
5078
5079       separator = gtk_hseparator_new ();
5080       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5081       gtk_widget_show (separator);
5082
5083
5084       box2 = gtk_vbox_new (FALSE, 10);
5085       gtk_container_border_width (GTK_CONTAINER (box2), 10);
5086       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5087       gtk_widget_show (box2);
5088
5089
5090       button = gtk_button_new_with_label ("close");
5091       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5092                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
5093                                  GTK_OBJECT (window));
5094       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5095       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5096       gtk_widget_grab_default (button);
5097       gtk_widget_show (button);
5098     }
5099
5100   if (!GTK_WIDGET_VISIBLE (window))
5101     gtk_widget_show (window);
5102   else
5103     gtk_widget_destroy (window);
5104 }
5105
5106 /*
5107  * GtkRulers
5108  */
5109
5110 void
5111 create_rulers (void)
5112 {
5113   static GtkWidget *window = NULL;
5114   GtkWidget *table;
5115   GtkWidget *ruler;
5116
5117   if (!window)
5118     {
5119       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5120       gtk_window_set_policy (GTK_WINDOW (window), TRUE, TRUE, FALSE);
5121
5122       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5123                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5124                           &window);
5125
5126       gtk_window_set_title (GTK_WINDOW (window), "rulers");
5127       gtk_widget_set_usize (window, 300, 300);
5128       gtk_widget_set_events (window,
5129                              GDK_POINTER_MOTION_MASK
5130                              | GDK_POINTER_MOTION_HINT_MASK);
5131       gtk_container_border_width (GTK_CONTAINER (window), 0);
5132
5133       table = gtk_table_new (2, 2, FALSE);
5134       gtk_container_add (GTK_CONTAINER (window), table);
5135       gtk_widget_show (table);
5136
5137       ruler = gtk_hruler_new ();
5138       gtk_ruler_set_metric (GTK_RULER (ruler), GTK_CENTIMETERS);
5139       gtk_ruler_set_range (GTK_RULER (ruler), 100, 0, 0, 20);
5140
5141       gtk_signal_connect_object (
5142         GTK_OBJECT (window),
5143         "motion_notify_event",
5144         GTK_SIGNAL_FUNC(
5145           GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
5146         GTK_OBJECT (ruler));
5147
5148       gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
5149                         GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
5150       gtk_widget_show (ruler);
5151
5152
5153       ruler = gtk_vruler_new ();
5154       gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
5155
5156       gtk_signal_connect_object (
5157         GTK_OBJECT (window),
5158         "motion_notify_event",
5159         GTK_SIGNAL_FUNC (GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
5160         GTK_OBJECT (ruler));
5161
5162       gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
5163                         GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
5164       gtk_widget_show (ruler);
5165     }
5166
5167   if (!GTK_WIDGET_VISIBLE (window))
5168     gtk_widget_show (window);
5169   else
5170     gtk_widget_destroy (window);
5171 }
5172
5173 static void
5174 text_toggle_editable (GtkWidget *checkbutton,
5175                        GtkWidget *text)
5176 {
5177    gtk_text_set_editable(GTK_TEXT(text),
5178                           GTK_TOGGLE_BUTTON(checkbutton)->active);
5179 }
5180
5181 static void
5182 text_toggle_word_wrap (GtkWidget *checkbutton,
5183                        GtkWidget *text)
5184 {
5185    gtk_text_set_word_wrap(GTK_TEXT(text),
5186                           GTK_TOGGLE_BUTTON(checkbutton)->active);
5187 }
5188
5189 /*
5190  * GtkText
5191  */
5192
5193 void
5194 create_text (void)
5195 {
5196   static GtkWidget *window = NULL;
5197   GtkWidget *box1;
5198   GtkWidget *box2;
5199   GtkWidget *hbox;
5200   GtkWidget *button;
5201   GtkWidget *check;
5202   GtkWidget *separator;
5203   GtkWidget *table;
5204   GtkWidget *hscrollbar;
5205   GtkWidget *vscrollbar;
5206   GtkWidget *text;
5207
5208   FILE *infile;
5209
5210   if (!window)
5211     {
5212       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5213       gtk_widget_set_name (window, "text window");
5214       gtk_widget_set_usize (window, 500, 500);
5215       gtk_window_set_policy (GTK_WINDOW(window), TRUE, TRUE, FALSE);
5216
5217       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5218                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5219                           &window);
5220
5221       gtk_window_set_title (GTK_WINDOW (window), "test");
5222       gtk_container_border_width (GTK_CONTAINER (window), 0);
5223
5224
5225       box1 = gtk_vbox_new (FALSE, 0);
5226       gtk_container_add (GTK_CONTAINER (window), box1);
5227       gtk_widget_show (box1);
5228
5229
5230       box2 = gtk_vbox_new (FALSE, 10);
5231       gtk_container_border_width (GTK_CONTAINER (box2), 10);
5232       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
5233       gtk_widget_show (box2);
5234
5235
5236       table = gtk_table_new (2, 2, FALSE);
5237       gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2);
5238       gtk_table_set_col_spacing (GTK_TABLE (table), 0, 2);
5239       gtk_box_pack_start (GTK_BOX (box2), table, TRUE, TRUE, 0);
5240       gtk_widget_show (table);
5241
5242       text = gtk_text_new (NULL, NULL);
5243       gtk_text_set_editable (GTK_TEXT (text), TRUE);
5244       gtk_table_attach (GTK_TABLE (table), text, 0, 1, 0, 1,
5245                         GTK_EXPAND | GTK_SHRINK | GTK_FILL,
5246                         GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
5247       gtk_widget_grab_focus (text);
5248       gtk_widget_show (text);
5249
5250       hscrollbar = gtk_hscrollbar_new (GTK_TEXT (text)->hadj);
5251       gtk_table_attach (GTK_TABLE (table), hscrollbar, 0, 1, 1, 2,
5252                         GTK_EXPAND | GTK_FILL | GTK_SHRINK, GTK_FILL, 0, 0);
5253       gtk_widget_show (hscrollbar);
5254
5255       vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
5256       gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 0, 1,
5257                         GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
5258       gtk_widget_show (vscrollbar);
5259
5260       gtk_text_freeze (GTK_TEXT (text));
5261
5262       gtk_widget_realize (text);
5263
5264       infile = fopen("testgtk.c", "r");
5265
5266       if (infile)
5267         {
5268           char buffer[1024];
5269           int nchars;
5270
5271           while (1)
5272             {
5273               nchars = fread(buffer, 1, 1024, infile);
5274               gtk_text_insert (GTK_TEXT (text), NULL, NULL,
5275                                NULL, buffer, nchars);
5276
5277               if (nchars < 1024)
5278                 break;
5279             }
5280
5281           fclose (infile);
5282         }
5283
5284       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
5285                        "And even ", -1);
5286       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->bg[GTK_STATE_NORMAL], NULL,
5287                        "colored", -1);
5288       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
5289                        "text", -1);
5290
5291       gtk_text_thaw (GTK_TEXT (text));
5292
5293       hbox = gtk_hbutton_box_new ();
5294       gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, FALSE, 0);
5295       gtk_widget_show (hbox);
5296
5297       check = gtk_check_button_new_with_label("Editable");
5298       gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, FALSE, 0);
5299       gtk_signal_connect (GTK_OBJECT(check), "toggled",
5300                           GTK_SIGNAL_FUNC(text_toggle_editable), text);
5301       gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), TRUE);
5302       gtk_widget_show (check);
5303
5304       check = gtk_check_button_new_with_label("Wrap Words");
5305       gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
5306       gtk_signal_connect (GTK_OBJECT(check), "toggled",
5307                           GTK_SIGNAL_FUNC(text_toggle_word_wrap), text);
5308       gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), FALSE);
5309       gtk_widget_show (check);
5310
5311       separator = gtk_hseparator_new ();
5312       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5313       gtk_widget_show (separator);
5314
5315
5316       box2 = gtk_vbox_new (FALSE, 10);
5317       gtk_container_border_width (GTK_CONTAINER (box2), 10);
5318       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5319       gtk_widget_show (box2);
5320
5321
5322       button = gtk_button_new_with_label ("close");
5323       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5324                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
5325                                  GTK_OBJECT (window));
5326       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5327       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5328       gtk_widget_grab_default (button);
5329       gtk_widget_show (button);
5330     }
5331
5332   if (!GTK_WIDGET_VISIBLE (window))
5333     gtk_widget_show (window);
5334   else
5335     gtk_widget_destroy (window);
5336 }
5337
5338 /*
5339  * GtkNotebook
5340  */
5341
5342 GdkPixmap *book_open;
5343 GdkPixmap *book_closed;
5344 GdkBitmap *book_open_mask;
5345 GdkBitmap *book_closed_mask;
5346
5347 static void
5348 page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num)
5349 {
5350   GtkNotebookPage *oldpage;
5351   GtkWidget *pixwid;
5352
5353   oldpage = GTK_NOTEBOOK (widget)->cur_page;
5354
5355   if (page == oldpage)
5356     return;
5357
5358   pixwid = ((GtkBoxChild*)(GTK_BOX (page->tab_label)->children->data))->widget;
5359   gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
5360   pixwid = ((GtkBoxChild*) (GTK_BOX (page->menu_label)->children->data))->widget;
5361   gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
5362
5363   if (oldpage)
5364     {
5365       pixwid = ((GtkBoxChild*) (GTK_BOX
5366                                 (oldpage->tab_label)->children->data))->widget;
5367       gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
5368       pixwid = ((GtkBoxChild*) (GTK_BOX (oldpage->menu_label)->children->data))->widget;
5369       gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
5370     }
5371 }
5372
5373 static void
5374 create_pages (GtkNotebook *notebook, gint start, gint end)
5375 {
5376   GtkWidget *child = NULL;
5377   GtkWidget *label;
5378   GtkWidget *entry;
5379   GtkWidget *box;
5380   GtkWidget *hbox;
5381   GtkWidget *label_box;
5382   GtkWidget *menu_box;
5383   GtkWidget *button;
5384   GtkWidget *pixwid;
5385   gint i;
5386   char buffer[32];
5387
5388   for (i = start; i <= end; i++)
5389     {
5390       sprintf (buffer, "Page %d", i);
5391
5392       switch (i % 4)
5393         {
5394         case 3:
5395           child = gtk_button_new_with_label (buffer);
5396           gtk_container_border_width (GTK_CONTAINER(child), 10);
5397           break;
5398         case 2:
5399           child = gtk_label_new (buffer);
5400           break;
5401         case 1:
5402           child = gtk_frame_new (buffer);
5403           gtk_container_border_width (GTK_CONTAINER (child), 10);
5404
5405           box = gtk_vbox_new (TRUE,0);
5406           gtk_container_border_width (GTK_CONTAINER (box), 10);
5407           gtk_container_add (GTK_CONTAINER (child), box);
5408
5409           label = gtk_label_new (buffer);
5410           gtk_box_pack_start (GTK_BOX(box), label, TRUE, TRUE, 5);
5411
5412           entry = gtk_entry_new ();
5413           gtk_box_pack_start (GTK_BOX(box), entry, TRUE, TRUE, 5);
5414
5415           hbox = gtk_hbox_new (TRUE,0);
5416           gtk_box_pack_start (GTK_BOX(box), hbox, TRUE, TRUE, 5);
5417
5418           button = gtk_button_new_with_label ("Ok");
5419           gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
5420
5421           button = gtk_button_new_with_label ("Cancel");
5422           gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
5423           break;
5424         case 0:
5425           child = gtk_frame_new (buffer);
5426           gtk_container_border_width (GTK_CONTAINER (child), 10);
5427
5428           label = gtk_label_new (buffer);
5429           gtk_container_add (GTK_CONTAINER (child), label);
5430           break;
5431         }
5432
5433       gtk_widget_show_all (child);
5434
5435       label_box = gtk_hbox_new (FALSE, 0);
5436       pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
5437       gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
5438       gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
5439       label = gtk_label_new (buffer);
5440       gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
5441       gtk_widget_show_all (label_box);
5442
5443       menu_box = gtk_hbox_new (FALSE, 0);
5444       pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
5445       gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
5446       gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
5447       label = gtk_label_new (buffer);
5448       gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0);
5449       gtk_widget_show_all (menu_box);
5450
5451       gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
5452     }
5453 }
5454
5455 static void
5456 rotate_notebook (GtkButton   *button,
5457                  GtkNotebook *notebook)
5458 {
5459   gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos + 1) % 4);
5460 }
5461
5462 static void
5463 standard_notebook (GtkButton   *button,
5464                    GtkNotebook *notebook)
5465 {
5466   gint i;
5467
5468   gtk_notebook_set_show_tabs (notebook, TRUE);
5469   gtk_notebook_set_scrollable (notebook, FALSE);
5470   if (g_list_length (notebook->children) == 15)
5471     for (i = 0; i < 10; i++)
5472       gtk_notebook_remove_page (notebook, 5);
5473 }
5474
5475 static void
5476 notabs_notebook (GtkButton   *button,
5477                  GtkNotebook *notebook)
5478 {
5479   gint i;
5480
5481   gtk_notebook_set_show_tabs (notebook, FALSE);
5482   if (g_list_length (notebook->children) == 15)
5483     for (i = 0; i < 10; i++)
5484       gtk_notebook_remove_page (notebook, 5);
5485 }
5486
5487 static void
5488 scrollable_notebook (GtkButton   *button,
5489                      GtkNotebook *notebook)
5490 {
5491   gtk_notebook_set_show_tabs (notebook, TRUE);
5492   gtk_notebook_set_scrollable (notebook, TRUE);
5493   if (g_list_length (notebook->children) == 5)
5494     create_pages (notebook, 6, 15);
5495 }
5496
5497 static void
5498 notebook_popup (GtkToggleButton *button,
5499                 GtkNotebook     *notebook)
5500 {
5501   if (button->active)
5502     gtk_notebook_popup_enable (notebook);
5503   else
5504     gtk_notebook_popup_disable (notebook);
5505 }
5506
5507 static void
5508 create_notebook (void)
5509 {
5510   static GtkWidget *window = NULL;
5511   GtkWidget *box1;
5512   GtkWidget *box2;
5513   GtkWidget *button;
5514   GtkWidget *separator;
5515   GtkWidget *notebook;
5516   GtkWidget *omenu;
5517   GdkColor *transparent = NULL;
5518
5519   static OptionMenuItem items[] =
5520   {
5521     { "Standard",   standard_notebook },
5522     { "No tabs",    notabs_notebook },
5523     { "Scrollable", scrollable_notebook }
5524   };
5525
5526   if (!window)
5527     {
5528       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5529
5530       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5531                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5532                           &window);
5533
5534       gtk_window_set_title (GTK_WINDOW (window), "notebook");
5535       gtk_container_border_width (GTK_CONTAINER (window), 0);
5536
5537       box1 = gtk_vbox_new (FALSE, 0);
5538       gtk_container_add (GTK_CONTAINER (window), box1);
5539
5540       notebook = gtk_notebook_new ();
5541       gtk_signal_connect (GTK_OBJECT (notebook), "switch_page",
5542                           GTK_SIGNAL_FUNC (page_switch), NULL);
5543       gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
5544       gtk_box_pack_start (GTK_BOX (box1), notebook, TRUE, TRUE, 0);
5545       gtk_container_border_width (GTK_CONTAINER (notebook), 10);
5546
5547       gtk_widget_realize (notebook);
5548       book_open = gdk_pixmap_create_from_xpm_d (notebook->window,
5549                                                 &book_open_mask,
5550                                                 transparent,
5551                                                 book_open_xpm);
5552       book_closed = gdk_pixmap_create_from_xpm_d (notebook->window,
5553                                                   &book_closed_mask,
5554                                                   transparent,
5555                                                   book_closed_xpm);
5556
5557       create_pages (GTK_NOTEBOOK (notebook), 1, 5);
5558
5559       separator = gtk_hseparator_new ();
5560       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10);
5561
5562       box2 = gtk_hbox_new (TRUE, 5);
5563       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5564
5565       omenu = build_option_menu (items, 3, 0, notebook);
5566       gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, FALSE, 0);
5567
5568       button = gtk_check_button_new_with_label ("enable popup menu");
5569       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
5570       gtk_signal_connect (GTK_OBJECT(button), "clicked",
5571                           GTK_SIGNAL_FUNC (notebook_popup),
5572                           GTK_OBJECT (notebook));
5573
5574       box2 = gtk_hbox_new (TRUE, 10);
5575       gtk_container_border_width (GTK_CONTAINER (box2), 10);
5576       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5577
5578       button = gtk_button_new_with_label ("close");
5579       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5580                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
5581                                  GTK_OBJECT (window));
5582       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5583       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5584       gtk_widget_grab_default (button);
5585
5586       button = gtk_button_new_with_label ("next");
5587       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5588                                  GTK_SIGNAL_FUNC (gtk_notebook_next_page),
5589                                  GTK_OBJECT (notebook));
5590       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5591       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5592
5593       button = gtk_button_new_with_label ("prev");
5594       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5595                                  GTK_SIGNAL_FUNC (gtk_notebook_prev_page),
5596                                  GTK_OBJECT (notebook));
5597       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5598       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5599
5600       button = gtk_button_new_with_label ("rotate");
5601       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5602                           GTK_SIGNAL_FUNC (rotate_notebook),
5603                           notebook);
5604       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5605       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5606     }
5607
5608   if (!GTK_WIDGET_VISIBLE (window))
5609     gtk_widget_show_all (window);
5610   else
5611     gtk_widget_destroy (window);
5612 }
5613
5614 /*
5615  * GtkPanes
5616  */
5617
5618 void
5619 create_panes (void)
5620 {
5621   static GtkWidget *window = NULL;
5622   GtkWidget *frame;
5623   GtkWidget *hpaned;
5624   GtkWidget *vpaned;
5625   GtkWidget *button;
5626
5627   if (!window)
5628     {
5629       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5630
5631       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5632                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5633                           &window);
5634
5635       gtk_window_set_title (GTK_WINDOW (window), "Panes");
5636       gtk_container_border_width (GTK_CONTAINER (window), 0);
5637
5638       vpaned = gtk_vpaned_new ();
5639       gtk_container_add (GTK_CONTAINER (window), vpaned);
5640       gtk_container_border_width (GTK_CONTAINER(vpaned), 5);
5641       gtk_widget_show (vpaned);
5642
5643       hpaned = gtk_hpaned_new ();
5644       gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
5645
5646       frame = gtk_frame_new (NULL);
5647       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
5648       gtk_widget_set_usize (frame, 60, 60);
5649       gtk_paned_add1 (GTK_PANED (hpaned), frame);
5650       gtk_widget_show (frame);
5651
5652       button = gtk_button_new_with_label ("Hi there");
5653       gtk_container_add (GTK_CONTAINER(frame), button);
5654       gtk_widget_show (button);
5655
5656       frame = gtk_frame_new (NULL);
5657       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
5658       gtk_widget_set_usize (frame, 80, 60);
5659       gtk_paned_add2 (GTK_PANED (hpaned), frame);
5660       gtk_widget_show (frame);
5661
5662       gtk_widget_show (hpaned);
5663
5664       frame = gtk_frame_new (NULL);
5665       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
5666       gtk_widget_set_usize (frame, 60, 80);
5667       gtk_paned_add2 (GTK_PANED (vpaned), frame);
5668       gtk_widget_show (frame);
5669     }
5670
5671   if (!GTK_WIDGET_VISIBLE (window))
5672     gtk_widget_show (window);
5673   else
5674     gtk_widget_destroy (window);
5675 }
5676
5677 /*
5678  * Drag -N- Drop
5679  */
5680
5681 gint
5682 dnd_drop_destroy_popup (GtkWidget *widget, GtkWindow **window)
5683 {
5684   if(GTK_IS_BUTTON(widget)) /* I.e. they clicked the close button */
5685     gtk_widget_destroy(GTK_WIDGET(*window));
5686   else {
5687     gtk_grab_remove(GTK_WIDGET(*window));
5688     *window = NULL;
5689   }
5690
5691   return FALSE;
5692 }
5693
5694 void
5695 dnd_drop (GtkWidget *button, GdkEvent *event)
5696 {
5697   static GtkWidget *window = NULL;
5698   GtkWidget *vbox, *lbl, *btn;
5699   gchar *msg;
5700
5701   /* DND doesn't obey gtk_grab's, so check if we're already displaying
5702    * drop modal dialog first
5703    */
5704   if (window)
5705     return;
5706
5707   window = gtk_window_new(GTK_WINDOW_DIALOG);
5708   gtk_container_border_width (GTK_CONTAINER(window), 10);
5709
5710   gtk_signal_connect (GTK_OBJECT (window), "destroy",
5711                       GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
5712                       &window);
5713   gtk_signal_connect (GTK_OBJECT (window), "delete-event",
5714                       GTK_SIGNAL_FUNC(gtk_false),
5715                       &window);
5716
5717   vbox = gtk_vbox_new(FALSE, 5);
5718
5719   /* Display message that we got from drop source */
5720   msg = g_malloc(strlen(event->dropdataavailable.data)
5721                  + strlen(event->dropdataavailable.data_type) + 100);
5722   sprintf(msg, "Drop data of type %s was:\n\n%s",
5723           event->dropdataavailable.data_type,
5724           (char *)event->dropdataavailable.data);
5725   lbl = gtk_label_new(msg);
5726   gtk_label_set_justify(GTK_LABEL(lbl), GTK_JUSTIFY_FILL);
5727   g_free(msg);
5728   gtk_widget_show(lbl);
5729   gtk_box_pack_start_defaults(GTK_BOX(vbox), lbl);
5730
5731   /* Provide an obvious way out of this heinousness */
5732   btn = gtk_button_new_with_label("Continue with life in\nspite of this oppression");
5733   gtk_signal_connect_object (GTK_OBJECT (btn), "clicked",
5734                              GTK_SIGNAL_FUNC(gtk_widget_destroy),
5735                              GTK_OBJECT (window));
5736   gtk_widget_show(btn);
5737   gtk_box_pack_start_defaults(GTK_BOX(vbox), btn);
5738
5739   gtk_container_add(GTK_CONTAINER(window), vbox);
5740
5741   gtk_widget_show(vbox);
5742   gtk_grab_add(window);
5743   gtk_widget_show(window);
5744 }
5745
5746 void
5747 dnd_drag_request (GtkWidget *button, GdkEvent *event)
5748 {
5749 #define DND_STRING "Bill Gates demands royalties for\nyour use of his innovation."
5750   gtk_widget_dnd_data_set (button, event, DND_STRING, strlen(DND_STRING) + 1);
5751 }
5752
5753 void
5754 create_dnd (void)
5755 {
5756   static GtkWidget *window = NULL;
5757   GtkWidget *box1;
5758   GtkWidget *box2;
5759   GtkWidget *box3;
5760   GtkWidget *frame;
5761   GtkWidget *button;
5762   GtkWidget *separator;
5763
5764   /* For clarity... */
5765   char *possible_drag_types[] = {"text/plain"};
5766   char *accepted_drop_types[] = {"text/plain"};
5767
5768   static GtkWidget *drag_icon = NULL;
5769   static GtkWidget *drop_icon = NULL;
5770
5771   if (!window)
5772     {
5773       GdkPoint hotspot = {5,5};
5774
5775       if (!drag_icon)
5776         {
5777           drag_icon = shape_create_icon ("Modeller.xpm",
5778                                          440, 140, 0,0, GTK_WINDOW_POPUP);
5779
5780           gtk_signal_connect (GTK_OBJECT (drag_icon), "destroy",
5781                               GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5782                               &drag_icon);
5783
5784           gtk_widget_hide (drag_icon);
5785         }
5786
5787       if (!drop_icon)
5788         {
5789           drop_icon = shape_create_icon ("3DRings.xpm",
5790                                          440, 140, 0,0, GTK_WINDOW_POPUP);
5791
5792           gtk_signal_connect (GTK_OBJECT (drop_icon), "destroy",
5793                               GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5794                               &drop_icon);
5795
5796           gtk_widget_hide (drop_icon);
5797         }
5798
5799       gdk_dnd_set_drag_shape(drag_icon->window,
5800                              &hotspot,
5801                              drop_icon->window,
5802                              &hotspot);
5803
5804       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5805
5806       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5807                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5808                           &window);
5809
5810       gtk_window_set_title (GTK_WINDOW (window), "Drag -N- Drop");
5811       gtk_container_border_width (GTK_CONTAINER (window), 0);
5812
5813       box1 = gtk_vbox_new (FALSE, 0);
5814       gtk_container_add (GTK_CONTAINER (window), box1);
5815       gtk_widget_show (box1);
5816
5817       box2 = gtk_hbox_new (FALSE, 5);
5818       gtk_container_border_width (GTK_CONTAINER (box2), 10);
5819       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
5820       gtk_widget_show (box2);
5821
5822       frame = gtk_frame_new ("Drag");
5823       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
5824       gtk_widget_show (frame);
5825
5826       box3 = gtk_vbox_new (FALSE, 5);
5827       gtk_container_border_width (GTK_CONTAINER (box3), 5);
5828       gtk_container_add (GTK_CONTAINER (frame), box3);
5829       gtk_widget_show (box3);
5830
5831       /*
5832        * FROM Button
5833        */
5834       button = gtk_button_new_with_label ("Drag me!");
5835       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
5836       gtk_widget_show (button);
5837
5838       /*
5839        * currently, the widget has to be realized to
5840        * set dnd on it, this needs to change
5841        */
5842       gtk_widget_realize (button);
5843       gtk_signal_connect (GTK_OBJECT (button),
5844                           "drag_request_event",
5845                           GTK_SIGNAL_FUNC(dnd_drag_request),
5846                           button);
5847
5848       gtk_widget_dnd_drag_set (button, TRUE, possible_drag_types, 1);
5849
5850
5851       frame = gtk_frame_new ("Drop");
5852       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
5853       gtk_widget_show (frame);
5854
5855       box3 = gtk_vbox_new (FALSE, 5);
5856       gtk_container_border_width (GTK_CONTAINER (box3), 5);
5857       gtk_container_add (GTK_CONTAINER (frame), box3);
5858       gtk_widget_show (box3);
5859
5860
5861       /*
5862        * TO Button
5863        */
5864       button = gtk_button_new_with_label ("To");
5865       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
5866       gtk_widget_show (button);
5867
5868       gtk_widget_realize (button);
5869       gtk_signal_connect (GTK_OBJECT (button),
5870                           "drop_data_available_event",
5871                           GTK_SIGNAL_FUNC(dnd_drop),
5872                           button);
5873
5874       gtk_widget_dnd_drop_set (button, TRUE, accepted_drop_types, 1, FALSE);
5875
5876
5877       separator = gtk_hseparator_new ();
5878       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5879       gtk_widget_show (separator);
5880
5881
5882       box2 = gtk_vbox_new (FALSE, 10);
5883       gtk_container_border_width (GTK_CONTAINER (box2), 10);
5884       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5885       gtk_widget_show (box2);
5886
5887
5888       button = gtk_button_new_with_label ("close");
5889
5890       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5891                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
5892                                  GTK_OBJECT (window));
5893
5894       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5895       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5896       gtk_widget_grab_default (button);
5897       gtk_widget_show (button);
5898     }
5899
5900   if (!GTK_WIDGET_VISIBLE (window))
5901     gtk_widget_show (window);
5902   else
5903     gtk_widget_destroy (window);
5904 }
5905
5906 /*
5907  * Shaped Windows
5908  */
5909
5910 static GdkWindow *root_win = NULL;
5911
5912 typedef struct _cursoroffset {gint x,y;} CursorOffset;
5913
5914 static void
5915 shape_pressed (GtkWidget *widget, GdkEventButton *event)
5916 {
5917   CursorOffset *p;
5918
5919   /* ignore double and triple click */
5920   if (event->type != GDK_BUTTON_PRESS)
5921     return;
5922
5923   p = gtk_object_get_user_data (GTK_OBJECT(widget));
5924   p->x = (int) event->x;
5925   p->y = (int) event->y;
5926
5927   gtk_grab_add (widget);
5928   gdk_pointer_grab (widget->window, TRUE,
5929                     GDK_BUTTON_RELEASE_MASK |
5930                     GDK_BUTTON_MOTION_MASK |
5931                     GDK_POINTER_MOTION_HINT_MASK,
5932                     NULL, NULL, 0);
5933 }
5934
5935 static void
5936 shape_released (GtkWidget *widget)
5937 {
5938   gtk_grab_remove (widget);
5939   gdk_pointer_ungrab (0);
5940 }
5941
5942 static void
5943 shape_motion (GtkWidget      *widget,
5944               GdkEventMotion *event)
5945 {
5946   gint xp, yp;
5947   CursorOffset * p;
5948   GdkModifierType mask;
5949
5950   p = gtk_object_get_user_data (GTK_OBJECT (widget));
5951
5952   /*
5953    * Can't use event->x / event->y here
5954    * because I need absolute coordinates.
5955    */
5956   gdk_window_get_pointer (root_win, &xp, &yp, &mask);
5957   gtk_widget_set_uposition (widget, xp  - p->x, yp  - p->y);
5958 }
5959
5960 GtkWidget *
5961 shape_create_icon (char     *xpm_file,
5962                    gint      x,
5963                    gint      y,
5964                    gint      px,
5965                    gint      py,
5966                    gint      window_type)
5967 {
5968   GtkWidget *window;
5969   GtkWidget *pixmap;
5970   GtkWidget *fixed;
5971   CursorOffset* icon_pos;
5972   GdkGC* gc;
5973   GdkBitmap *gdk_pixmap_mask;
5974   GdkPixmap *gdk_pixmap;
5975   GtkStyle *style;
5976
5977   style = gtk_widget_get_default_style ();
5978   gc = style->black_gc;
5979
5980   /*
5981    * GDK_WINDOW_TOPLEVEL works also, giving you a title border
5982    */
5983   window = gtk_window_new (window_type);
5984
5985   fixed = gtk_fixed_new ();
5986   gtk_widget_set_usize (fixed, 100,100);
5987   gtk_container_add (GTK_CONTAINER (window), fixed);
5988   gtk_widget_show (fixed);
5989
5990   gtk_widget_set_events (window,
5991                          gtk_widget_get_events (window) |
5992                          GDK_BUTTON_MOTION_MASK |
5993                          GDK_POINTER_MOTION_HINT_MASK |
5994                          GDK_BUTTON_PRESS_MASK);
5995
5996   gtk_widget_realize (window);
5997   gdk_pixmap = gdk_pixmap_create_from_xpm (window->window, &gdk_pixmap_mask,
5998                                            &style->bg[GTK_STATE_NORMAL],
5999                                            xpm_file);
6000
6001   pixmap = gtk_pixmap_new (gdk_pixmap, gdk_pixmap_mask);
6002   gtk_fixed_put (GTK_FIXED (fixed), pixmap, px,py);
6003   gtk_widget_show (pixmap);
6004
6005   gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px,py);
6006
6007
6008   gtk_signal_connect (GTK_OBJECT (window), "button_press_event",
6009                       GTK_SIGNAL_FUNC (shape_pressed),NULL);
6010   gtk_signal_connect (GTK_OBJECT (window), "button_release_event",
6011                       GTK_SIGNAL_FUNC (shape_released),NULL);
6012   gtk_signal_connect (GTK_OBJECT (window), "motion_notify_event",
6013                       GTK_SIGNAL_FUNC (shape_motion),NULL);
6014
6015   icon_pos = g_new (CursorOffset, 1);
6016   gtk_object_set_user_data(GTK_OBJECT(window), icon_pos);
6017
6018   gtk_widget_set_uposition (window, x, y);
6019   gtk_widget_show (window);
6020
6021   return window;
6022 }
6023
6024 void
6025 create_shapes (void)
6026 {
6027   /* Variables used by the Drag/Drop and Shape Window demos */
6028   static GtkWidget *modeller = NULL;
6029   static GtkWidget *sheets = NULL;
6030   static GtkWidget *rings = NULL;
6031
6032   root_win = gdk_window_foreign_new (GDK_ROOT_WINDOW ());
6033
6034   if (!modeller)
6035     {
6036       modeller = shape_create_icon ("Modeller.xpm",
6037                                     440, 140, 0,0, GTK_WINDOW_POPUP);
6038
6039       gtk_signal_connect (GTK_OBJECT (modeller), "destroy",
6040                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6041                           &modeller);
6042     }
6043   else
6044     gtk_widget_destroy (modeller);
6045
6046   if (!sheets)
6047     {
6048       sheets = shape_create_icon ("FilesQueue.xpm",
6049                                   580, 170, 0,0, GTK_WINDOW_POPUP);
6050
6051       gtk_signal_connect (GTK_OBJECT (sheets), "destroy",
6052                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6053                           &sheets);
6054
6055     }
6056   else
6057     gtk_widget_destroy (sheets);
6058
6059   if (!rings)
6060     {
6061       rings = shape_create_icon ("3DRings.xpm",
6062                                  460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
6063
6064       gtk_signal_connect (GTK_OBJECT (rings), "destroy",
6065                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6066                           &rings);
6067     }
6068   else
6069     gtk_widget_destroy (rings);
6070 }
6071
6072 /*
6073  * WM Hints demo
6074  */
6075
6076 void
6077 create_wmhints (void)
6078 {
6079   static GtkWidget *window = NULL;
6080   GtkWidget *label;
6081   GtkWidget *separator;
6082   GtkWidget *button;
6083   GtkWidget *box1;
6084   GtkWidget *box2;
6085
6086   GdkBitmap *circles;
6087
6088   if (!window)
6089     {
6090       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6091
6092       gtk_signal_connect (GTK_OBJECT (window), "destroy",
6093                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6094                           &window);
6095
6096       gtk_window_set_title (GTK_WINDOW (window), "WM Hints");
6097       gtk_container_border_width (GTK_CONTAINER (window), 0);
6098
6099       gtk_widget_realize (window);
6100
6101       circles = gdk_bitmap_create_from_data (window->window,
6102                                              circles_bits,
6103                                              circles_width,
6104                                              circles_height);
6105       gdk_window_set_icon (window->window, NULL,
6106                            circles, circles);
6107
6108       gdk_window_set_icon_name (window->window, "WMHints Test Icon");
6109
6110       gdk_window_set_decorations (window->window, GDK_DECOR_ALL | GDK_DECOR_MENU);
6111       gdk_window_set_functions (window->window, GDK_FUNC_ALL | GDK_FUNC_RESIZE);
6112
6113       box1 = gtk_vbox_new (FALSE, 0);
6114       gtk_container_add (GTK_CONTAINER (window), box1);
6115       gtk_widget_show (box1);
6116
6117       label = gtk_label_new ("Try iconizing me!");
6118       gtk_widget_set_usize (label, 150, 50);
6119       gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
6120       gtk_widget_show (label);
6121
6122
6123       separator = gtk_hseparator_new ();
6124       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
6125       gtk_widget_show (separator);
6126
6127
6128       box2 = gtk_vbox_new (FALSE, 10);
6129       gtk_container_border_width (GTK_CONTAINER (box2), 10);
6130       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6131       gtk_widget_show (box2);
6132
6133
6134       button = gtk_button_new_with_label ("close");
6135
6136       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6137                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
6138                                  GTK_OBJECT (window));
6139
6140       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6141       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6142       gtk_widget_grab_default (button);
6143       gtk_widget_show (button);
6144     }
6145
6146   if (!GTK_WIDGET_VISIBLE (window))
6147     gtk_widget_show (window);
6148   else
6149     gtk_widget_destroy (window);
6150 }
6151
6152 /*
6153  * GtkProgressBar
6154  */
6155
6156 typedef struct _ProgressData {
6157   GtkWidget *window;
6158   GtkWidget *pbar;
6159   GtkWidget *block_spin;
6160   GtkWidget *x_align_spin;
6161   GtkWidget *y_align_spin;
6162   GtkWidget *step_spin;
6163   GtkWidget *act_blocks_spin;
6164   GtkWidget *label;
6165   GtkWidget *omenu1;
6166   GtkWidget *omenu2;
6167   GtkWidget *entry;
6168   int timer;
6169 } ProgressData;
6170
6171 gint
6172 progress_timeout (gpointer data)
6173 {
6174   gfloat new_val;
6175   GtkAdjustment *adj;
6176
6177   adj = GTK_PROGRESS (data)->adjustment;
6178
6179   new_val = adj->value + 1;
6180   if (new_val > adj->upper)
6181     new_val = adj->lower;
6182
6183   gtk_progress_set_value (GTK_PROGRESS (data), new_val);
6184
6185   return TRUE;
6186 }
6187
6188 static void
6189 destroy_progress (GtkWidget     *widget,
6190                   ProgressData **pdata)
6191 {
6192   gtk_timeout_remove ((*pdata)->timer);
6193   (*pdata)->timer = 0;
6194   (*pdata)->window = NULL;
6195   g_free (*pdata);
6196   *pdata = NULL;
6197 }
6198
6199 static void
6200 progressbar_toggle_orientation (GtkWidget *widget, ProgressData *pdata)
6201 {
6202   gint i;
6203
6204   if (!GTK_WIDGET_MAPPED (widget))
6205     return;
6206
6207   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
6208                     (((GtkOptionMenu *)(pdata->omenu1))->menu_item), i);
6209
6210   gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (pdata->pbar),
6211                             (GtkProgressBarOrientation) (3-i));
6212 }
6213
6214 static void
6215 toggle_show_text (GtkWidget *widget, ProgressData *pdata)
6216 {
6217   gtk_progress_set_show_text (GTK_PROGRESS (pdata->pbar),
6218                               GTK_TOGGLE_BUTTON (widget)->active);
6219   gtk_widget_set_sensitive (pdata->entry, GTK_TOGGLE_BUTTON (widget)->active);
6220   gtk_widget_set_sensitive (pdata->x_align_spin,
6221                             GTK_TOGGLE_BUTTON (widget)->active);
6222   gtk_widget_set_sensitive (pdata->y_align_spin,
6223                             GTK_TOGGLE_BUTTON (widget)->active);
6224 }
6225
6226 static void
6227 progressbar_toggle_bar_style (GtkWidget *widget, ProgressData *pdata)
6228 {
6229   gint i;
6230
6231   if (!GTK_WIDGET_MAPPED (widget))
6232     return;
6233
6234   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
6235                     (((GtkOptionMenu *)(pdata->omenu2))->menu_item), i);
6236
6237   i = 1 - i;
6238
6239   if (i == 1)
6240     gtk_widget_set_sensitive (pdata->block_spin, TRUE);
6241   else
6242     gtk_widget_set_sensitive (pdata->block_spin, FALSE);
6243
6244   gtk_progress_bar_set_bar_style (GTK_PROGRESS_BAR (pdata->pbar),
6245                                   (GtkProgressBarStyle) i);
6246 }
6247
6248 static void
6249 progress_value_changed (GtkAdjustment *adj, ProgressData *pdata)
6250 {
6251   char buf[20];
6252
6253   if (GTK_PROGRESS (pdata->pbar)->activity_mode)
6254     sprintf (buf, "???");
6255   else
6256     sprintf (buf, "%.0f%%", 100 *
6257              gtk_progress_get_current_percentage (GTK_PROGRESS (pdata->pbar)));
6258   gtk_label_set (GTK_LABEL (pdata->label), buf);
6259 }
6260
6261 static void
6262 adjust_blocks (GtkAdjustment *adj, ProgressData *pdata)
6263 {
6264   gtk_progress_set_percentage (GTK_PROGRESS (pdata->pbar), 0);
6265   gtk_progress_bar_set_discrete_blocks (GTK_PROGRESS_BAR (pdata->pbar),
6266      gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pdata->block_spin)));
6267 }
6268
6269 static void
6270 adjust_step (GtkAdjustment *adj, ProgressData *pdata)
6271 {
6272   gtk_progress_bar_set_activity_step (GTK_PROGRESS_BAR (pdata->pbar),
6273      gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pdata->step_spin)));
6274 }
6275
6276 static void
6277 adjust_act_blocks (GtkAdjustment *adj, ProgressData *pdata)
6278 {
6279   gtk_progress_bar_set_activity_blocks (GTK_PROGRESS_BAR (pdata->pbar),
6280                gtk_spin_button_get_value_as_int
6281                       (GTK_SPIN_BUTTON (pdata->act_blocks_spin)));
6282 }
6283
6284 static void
6285 adjust_align (GtkAdjustment *adj, ProgressData *pdata)
6286 {
6287   gtk_progress_set_text_alignment (GTK_PROGRESS (pdata->pbar),
6288          gtk_spin_button_get_value_as_float
6289                                    (GTK_SPIN_BUTTON (pdata->x_align_spin)),
6290          gtk_spin_button_get_value_as_float
6291                                    (GTK_SPIN_BUTTON (pdata->y_align_spin)));
6292 }
6293
6294 static void
6295 toggle_activity_mode (GtkWidget *widget, ProgressData *pdata)
6296 {
6297   gtk_progress_set_activity_mode (GTK_PROGRESS (pdata->pbar),
6298                                   GTK_TOGGLE_BUTTON (widget)->active);
6299   gtk_widget_set_sensitive (pdata->step_spin,
6300                             GTK_TOGGLE_BUTTON (widget)->active);
6301   gtk_widget_set_sensitive (pdata->act_blocks_spin,
6302                             GTK_TOGGLE_BUTTON (widget)->active);
6303 }
6304
6305 static void
6306 entry_changed (GtkWidget *widget, ProgressData *pdata)
6307 {
6308   gtk_progress_set_format_string (GTK_PROGRESS (pdata->pbar),
6309                           gtk_entry_get_text (GTK_ENTRY (pdata->entry)));
6310 }
6311
6312 void
6313 create_progress_bar (void)
6314 {
6315   GtkWidget *button;
6316   GtkWidget *vbox;
6317   GtkWidget *vbox2;
6318   GtkWidget *hbox;
6319   GtkWidget *check;
6320   GtkWidget *frame;
6321   GtkWidget *tab;
6322   GtkWidget *label;
6323   GtkWidget *align;
6324   GtkAdjustment *adj;
6325   static ProgressData *pdata = NULL;
6326
6327   static OptionMenuItem items1[] =
6328   {
6329     { "Left-Right", progressbar_toggle_orientation },
6330     { "Right-Left", progressbar_toggle_orientation },
6331     { "Bottom-Top", progressbar_toggle_orientation },
6332     { "Top-Bottom", progressbar_toggle_orientation }
6333   };
6334
6335   static OptionMenuItem items2[] =
6336   {
6337     { "Continuous", progressbar_toggle_bar_style },
6338     { "Discrete",   progressbar_toggle_bar_style }
6339   };
6340
6341   if (!pdata)
6342     pdata = g_new0 (ProgressData, 1);
6343
6344   if (!pdata->window)
6345     {
6346       pdata->window = gtk_dialog_new ();
6347
6348       gtk_window_set_policy (GTK_WINDOW (pdata->window), FALSE, FALSE, TRUE);
6349
6350       gtk_signal_connect (GTK_OBJECT (pdata->window), "destroy",
6351                           GTK_SIGNAL_FUNC (destroy_progress),
6352                           &pdata);
6353
6354       pdata->timer = 0;
6355
6356       gtk_window_set_title (GTK_WINDOW (pdata->window), "GtkProgressBar");
6357       gtk_container_border_width (GTK_CONTAINER (pdata->window), 0);
6358
6359       vbox = gtk_vbox_new (FALSE, 5);
6360       gtk_container_border_width (GTK_CONTAINER (vbox), 10);
6361       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pdata->window)->vbox),
6362                           vbox, FALSE, TRUE, 0);
6363
6364       frame = gtk_frame_new ("Progress");
6365       gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
6366
6367       vbox2 = gtk_vbox_new (FALSE, 5);
6368       gtk_container_add (GTK_CONTAINER (frame), vbox2);
6369
6370       align = gtk_alignment_new (0.5, 0.5, 0, 0);
6371       gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
6372
6373       adj = (GtkAdjustment *) gtk_adjustment_new (0, 1, 300, 0, 0, 0);
6374       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6375                           GTK_SIGNAL_FUNC (progress_value_changed), pdata);
6376
6377       pdata->pbar = gtk_progress_bar_new_with_adjustment (adj);
6378       gtk_progress_set_format_string (GTK_PROGRESS (pdata->pbar),
6379                                       "%v from [%l,%u] (=%p%%)");
6380       gtk_container_add (GTK_CONTAINER (align), pdata->pbar);
6381       pdata->timer = gtk_timeout_add (100, progress_timeout, pdata->pbar);
6382
6383       align = gtk_alignment_new (0.5, 0.5, 0, 0);
6384       gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
6385
6386       hbox = gtk_hbox_new (FALSE, 5);
6387       gtk_container_add (GTK_CONTAINER (align), hbox);
6388       label = gtk_label_new ("Label updated by user :");
6389       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
6390       pdata->label = gtk_label_new ("");
6391       gtk_box_pack_start (GTK_BOX (hbox), pdata->label, FALSE, TRUE, 0);
6392
6393       frame = gtk_frame_new ("Options");
6394       gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
6395
6396       vbox2 = gtk_vbox_new (FALSE, 5);
6397       gtk_container_add (GTK_CONTAINER (frame), vbox2);
6398
6399       tab = gtk_table_new (7, 2, FALSE);
6400       gtk_box_pack_start (GTK_BOX (vbox2), tab, FALSE, TRUE, 0);
6401
6402       label = gtk_label_new ("Orientation :");
6403       gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 0, 1,
6404                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6405                         5, 5);
6406       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
6407
6408       pdata->omenu1 = build_option_menu (items1, 4, 0, pdata);
6409       hbox = gtk_hbox_new (FALSE, 0);
6410       gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 0, 1,
6411                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6412                         5, 5);
6413       gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu1, TRUE, TRUE, 0);
6414
6415       check = gtk_check_button_new_with_label ("Show text");
6416       gtk_signal_connect (GTK_OBJECT (check), "clicked",
6417                           GTK_SIGNAL_FUNC (toggle_show_text),
6418                           pdata);
6419       gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 1, 2,
6420                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6421                         5, 5);
6422
6423       hbox = gtk_hbox_new (FALSE, 0);
6424       gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 1, 2,
6425                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6426                         5, 5);
6427
6428       label = gtk_label_new ("Format : ");
6429       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
6430
6431       pdata->entry = gtk_entry_new ();
6432       gtk_signal_connect (GTK_OBJECT (pdata->entry), "changed",
6433                           GTK_SIGNAL_FUNC (entry_changed),
6434                           pdata);
6435       gtk_box_pack_start (GTK_BOX (hbox), pdata->entry, TRUE, TRUE, 0);
6436       gtk_entry_set_text (GTK_ENTRY (pdata->entry), "%v from [%l,%u] (=%p%%)");
6437       gtk_widget_set_usize (pdata->entry, 100, -1);
6438       gtk_widget_set_sensitive (pdata->entry, FALSE);
6439
6440       label = gtk_label_new ("Text align :");
6441       gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 2, 3,
6442                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6443                         5, 5);
6444       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
6445
6446       hbox = gtk_hbox_new (FALSE, 0);
6447       gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 2, 3,
6448                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6449                         5, 5);
6450
6451       label = gtk_label_new ("x :");
6452       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 5);
6453
6454       adj = (GtkAdjustment *) gtk_adjustment_new (0.5, 0, 1, 0.1, 0.1, 0);
6455       pdata->x_align_spin = gtk_spin_button_new (adj, 0, 1);
6456       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6457                           GTK_SIGNAL_FUNC (adjust_align), pdata);
6458       gtk_box_pack_start (GTK_BOX (hbox), pdata->x_align_spin, FALSE, TRUE, 0);
6459       gtk_widget_set_sensitive (pdata->x_align_spin, FALSE);
6460
6461       label = gtk_label_new ("y :");
6462       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 5);
6463
6464       adj = (GtkAdjustment *) gtk_adjustment_new (0.5, 0, 1, 0.1, 0.1, 0);
6465       pdata->y_align_spin = gtk_spin_button_new (adj, 0, 1);
6466       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6467                           GTK_SIGNAL_FUNC (adjust_align), pdata);
6468       gtk_box_pack_start (GTK_BOX (hbox), pdata->y_align_spin, FALSE, TRUE, 0);
6469       gtk_widget_set_sensitive (pdata->y_align_spin, FALSE);
6470
6471       label = gtk_label_new ("Bar Style :");
6472       gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 3, 4,
6473                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6474                         5, 5);
6475       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
6476
6477       pdata->omenu2 = build_option_menu (items2, 2, 0, pdata);
6478       hbox = gtk_hbox_new (FALSE, 0);
6479       gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 3, 4,
6480                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6481                         5, 5);
6482       gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu2, TRUE, TRUE, 0);
6483
6484       label = gtk_label_new ("Block count :");
6485       gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 4, 5,
6486                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6487                         5, 5);
6488       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
6489
6490       hbox = gtk_hbox_new (FALSE, 0);
6491       gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 4, 5,
6492                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6493                         5, 5);
6494       adj = (GtkAdjustment *) gtk_adjustment_new (10, 2, 20, 1, 5, 0);
6495       pdata->block_spin = gtk_spin_button_new (adj, 0, 0);
6496       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6497                           GTK_SIGNAL_FUNC (adjust_blocks), pdata);
6498       gtk_box_pack_start (GTK_BOX (hbox), pdata->block_spin, FALSE, TRUE, 0);
6499       gtk_widget_set_sensitive (pdata->block_spin, FALSE);
6500
6501       check = gtk_check_button_new_with_label ("Activity mode");
6502       gtk_signal_connect (GTK_OBJECT (check), "clicked",
6503                           GTK_SIGNAL_FUNC (toggle_activity_mode),
6504                           pdata);
6505       gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 5, 6,
6506                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6507                         5, 5);
6508
6509       hbox = gtk_hbox_new (FALSE, 0);
6510       gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 5, 6,
6511                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6512                         5, 5);
6513       label = gtk_label_new ("Step size : ");
6514       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
6515       adj = (GtkAdjustment *) gtk_adjustment_new (3, 1, 20, 1, 5, 0);
6516       pdata->step_spin = gtk_spin_button_new (adj, 0, 0);
6517       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6518                           GTK_SIGNAL_FUNC (adjust_step), pdata);
6519       gtk_box_pack_start (GTK_BOX (hbox), pdata->step_spin, FALSE, TRUE, 0);
6520       gtk_widget_set_sensitive (pdata->step_spin, FALSE);
6521
6522       hbox = gtk_hbox_new (FALSE, 0);
6523       gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 6, 7,
6524                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6525                         5, 5);
6526       label = gtk_label_new ("Blocks :     ");
6527       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
6528       adj = (GtkAdjustment *) gtk_adjustment_new (5, 2, 10, 1, 5, 0);
6529       pdata->act_blocks_spin = gtk_spin_button_new (adj, 0, 0);
6530       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6531                           GTK_SIGNAL_FUNC (adjust_act_blocks), pdata);
6532       gtk_box_pack_start (GTK_BOX (hbox), pdata->act_blocks_spin, FALSE, TRUE,
6533                           0);
6534       gtk_widget_set_sensitive (pdata->act_blocks_spin, FALSE);
6535
6536       button = gtk_button_new_with_label ("close");
6537       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6538                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
6539                                  GTK_OBJECT (pdata->window));
6540       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6541       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pdata->window)->action_area),
6542                           button, TRUE, TRUE, 0);
6543       gtk_widget_grab_default (button);
6544     }
6545
6546   if (!GTK_WIDGET_VISIBLE (pdata->window))
6547     gtk_widget_show_all (pdata->window);
6548   else
6549     gtk_widget_destroy (pdata->window);
6550 }
6551
6552 /*
6553  * Color Preview
6554  */
6555
6556 static int color_idle = 0;
6557
6558 gint
6559 color_idle_func (GtkWidget *preview)
6560 {
6561   static int count = 1;
6562   guchar buf[768];
6563   int i, j, k;
6564
6565   for (i = 0; i < 256; i++)
6566     {
6567       for (j = 0, k = 0; j < 256; j++)
6568         {
6569           buf[k+0] = i + count;
6570           buf[k+1] = 0;
6571           buf[k+2] = j + count;
6572           k += 3;
6573         }
6574
6575       gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
6576     }
6577
6578   count += 1;
6579
6580   gtk_widget_draw (preview, NULL);
6581
6582   return TRUE;
6583 }
6584
6585 static void
6586 color_preview_destroy (GtkWidget  *widget,
6587                        GtkWidget **window)
6588 {
6589   gtk_idle_remove (color_idle);
6590   color_idle = 0;
6591
6592   *window = NULL;
6593 }
6594
6595 void
6596 create_color_preview (void)
6597 {
6598   static GtkWidget *window = NULL;
6599   GtkWidget *preview;
6600   guchar buf[768];
6601   int i, j, k;
6602
6603   if (!window)
6604     {
6605       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6606
6607       gtk_signal_connect (GTK_OBJECT (window), "destroy",
6608                           GTK_SIGNAL_FUNC(color_preview_destroy),
6609                           &window);
6610
6611       gtk_window_set_title (GTK_WINDOW (window), "test");
6612       gtk_container_border_width (GTK_CONTAINER (window), 10);
6613
6614       preview = gtk_preview_new (GTK_PREVIEW_COLOR);
6615       gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
6616       gtk_container_add (GTK_CONTAINER (window), preview);
6617
6618       for (i = 0; i < 256; i++)
6619         {
6620           for (j = 0, k = 0; j < 256; j++)
6621             {
6622               buf[k+0] = i;
6623               buf[k+1] = 0;
6624               buf[k+2] = j;
6625               k += 3;
6626             }
6627
6628           gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
6629         }
6630
6631       color_idle = gtk_idle_add ((GtkFunction) color_idle_func, preview);
6632     }
6633
6634   if (!GTK_WIDGET_VISIBLE (window))
6635     gtk_widget_show_all (window);
6636   else
6637     gtk_widget_destroy (window);
6638 }
6639
6640 /*
6641  * Gray Preview
6642  */
6643
6644 static int gray_idle = 0;
6645
6646 gint
6647 gray_idle_func (GtkWidget *preview)
6648 {
6649   static int count = 1;
6650   guchar buf[256];
6651   int i, j;
6652
6653   for (i = 0; i < 256; i++)
6654     {
6655       for (j = 0; j < 256; j++)
6656         buf[j] = i + j + count;
6657
6658       gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
6659     }
6660
6661   count += 1;
6662
6663   gtk_widget_draw (preview, NULL);
6664
6665   return TRUE;
6666 }
6667
6668 static void
6669 gray_preview_destroy (GtkWidget  *widget,
6670                       GtkWidget **window)
6671 {
6672   gtk_idle_remove (gray_idle);
6673   gray_idle = 0;
6674
6675   *window = NULL;
6676 }
6677
6678 void
6679 create_gray_preview (void)
6680 {
6681   static GtkWidget *window = NULL;
6682   GtkWidget *preview;
6683   guchar buf[256];
6684   int i, j;
6685
6686   if (!window)
6687     {
6688       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6689
6690       gtk_signal_connect (GTK_OBJECT (window), "destroy",
6691                           GTK_SIGNAL_FUNC(gray_preview_destroy),
6692                           &window);
6693
6694       gtk_window_set_title (GTK_WINDOW (window), "test");
6695       gtk_container_border_width (GTK_CONTAINER (window), 10);
6696
6697       preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
6698       gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
6699       gtk_container_add (GTK_CONTAINER (window), preview);
6700
6701       for (i = 0; i < 256; i++)
6702         {
6703           for (j = 0; j < 256; j++)
6704             buf[j] = i + j;
6705
6706           gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
6707         }
6708
6709       gray_idle = gtk_idle_add ((GtkFunction) gray_idle_func, preview);
6710     }
6711
6712   if (!GTK_WIDGET_VISIBLE (window))
6713     gtk_widget_show_all (window);
6714   else
6715     gtk_widget_destroy (window);
6716 }
6717
6718
6719 /*
6720  * Selection Test
6721  */
6722
6723 void
6724 selection_test_received (GtkWidget *list, GtkSelectionData *data)
6725 {
6726   GdkAtom *atoms;
6727   GtkWidget *list_item;
6728   GList *item_list;
6729   int i, l;
6730
6731   if (data->length < 0)
6732     {
6733       g_print ("Selection retrieval failed\n");
6734       return;
6735     }
6736   if (data->type != GDK_SELECTION_TYPE_ATOM)
6737     {
6738       g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
6739       return;
6740     }
6741
6742   /* Clear out any current list items */
6743
6744   gtk_list_clear_items (GTK_LIST(list), 0, -1);
6745
6746   /* Add new items to list */
6747
6748   atoms = (GdkAtom *)data->data;
6749
6750   item_list = NULL;
6751   l = data->length / sizeof (GdkAtom);
6752   for (i = 0; i < l; i++)
6753     {
6754       char *name;
6755       name = gdk_atom_name (atoms[i]);
6756       if (name != NULL)
6757         {
6758           list_item = gtk_list_item_new_with_label (name);
6759           g_free (name);
6760         }
6761       else
6762         list_item = gtk_list_item_new_with_label ("(bad atom)");
6763
6764       gtk_widget_show (list_item);
6765       item_list = g_list_append (item_list, list_item);
6766     }
6767
6768   gtk_list_append_items (GTK_LIST (list), item_list);
6769
6770   return;
6771 }
6772
6773 void
6774 selection_test_get_targets (GtkWidget *widget, GtkWidget *list)
6775 {
6776   static GdkAtom targets_atom = GDK_NONE;
6777
6778   if (targets_atom == GDK_NONE)
6779     targets_atom = gdk_atom_intern ("TARGETS", FALSE);
6780
6781   gtk_selection_convert (list, GDK_SELECTION_PRIMARY, targets_atom,
6782                          GDK_CURRENT_TIME);
6783 }
6784
6785 void
6786 create_selection_test (void)
6787 {
6788   static GtkWidget *window = NULL;
6789   GtkWidget *button;
6790   GtkWidget *vbox;
6791   GtkWidget *scrolled_win;
6792   GtkWidget *list;
6793   GtkWidget *label;
6794
6795   if (!window)
6796     {
6797       window = gtk_dialog_new ();
6798
6799       gtk_signal_connect (GTK_OBJECT (window), "destroy",
6800                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6801                           &window);
6802
6803       gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
6804       gtk_container_border_width (GTK_CONTAINER (window), 0);
6805
6806       /* Create the list */
6807
6808       vbox = gtk_vbox_new (FALSE, 5);
6809       gtk_container_border_width (GTK_CONTAINER (vbox), 10);
6810       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox,
6811                           TRUE, TRUE, 0);
6812
6813       label = gtk_label_new ("Gets available targets for current selection");
6814       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
6815
6816       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
6817       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
6818                                       GTK_POLICY_AUTOMATIC,
6819                                       GTK_POLICY_AUTOMATIC);
6820       gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
6821       gtk_widget_set_usize (scrolled_win, 100, 200);
6822
6823       list = gtk_list_new ();
6824       gtk_container_add (GTK_CONTAINER (scrolled_win), list);
6825
6826       gtk_signal_connect (GTK_OBJECT(list), "selection_received",
6827                           GTK_SIGNAL_FUNC (selection_test_received), NULL);
6828
6829       /* .. And create some buttons */
6830       button = gtk_button_new_with_label ("Get Targets");
6831       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6832                           button, TRUE, TRUE, 0);
6833
6834       gtk_signal_connect (GTK_OBJECT (button), "clicked",
6835                           GTK_SIGNAL_FUNC (selection_test_get_targets), list);
6836
6837       button = gtk_button_new_with_label ("Quit");
6838       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6839                           button, TRUE, TRUE, 0);
6840
6841       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6842                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
6843                                  GTK_OBJECT (window));
6844     }
6845
6846   if (!GTK_WIDGET_VISIBLE (window))
6847     gtk_widget_show_all (window);
6848   else
6849     gtk_widget_destroy (window);
6850 }
6851
6852 /*
6853  * Gamma Curve
6854  */
6855
6856 void
6857 create_gamma_curve (void)
6858 {
6859   static GtkWidget *window = NULL, *curve;
6860   static int count = 0;
6861   gfloat vec[256];
6862   gint max;
6863   gint i;
6864
6865   if (!window)
6866     {
6867       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6868       gtk_window_set_title (GTK_WINDOW (window), "test");
6869       gtk_container_border_width (GTK_CONTAINER (window), 10);
6870
6871       gtk_signal_connect (GTK_OBJECT (window), "destroy",
6872                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6873                           &window);
6874
6875       curve = gtk_gamma_curve_new ();
6876       gtk_container_add (GTK_CONTAINER (window), curve);
6877       gtk_widget_show (curve);
6878     }
6879
6880   max = 127 + (count % 2)*128;
6881   gtk_curve_set_range (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
6882                        0, max, 0, max);
6883   for (i = 0; i < max; ++i)
6884     vec[i] = (127 / sqrt (max)) * sqrt (i);
6885   gtk_curve_set_vector (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
6886                         max, vec);
6887
6888   if (!GTK_WIDGET_VISIBLE (window))
6889     gtk_widget_show (window);
6890   else if (count % 4 == 3)
6891     {
6892       gtk_widget_destroy (window);
6893       window = NULL;
6894     }
6895
6896   ++count;
6897 }
6898
6899 /*
6900  * Test scrolling
6901  */
6902
6903 static int scroll_test_pos = 0.0;
6904 static GdkGC *scroll_test_gc = NULL;
6905
6906 static gint
6907 scroll_test_expose (GtkWidget *widget, GdkEventExpose *event,
6908                     GtkAdjustment *adj)
6909 {
6910   gint i,j;
6911   gint imin, imax, jmin, jmax;
6912
6913   imin = (event->area.x) / 10;
6914   imax = (event->area.x + event->area.width + 9) / 10;
6915
6916   jmin = ((int)adj->value + event->area.y) / 10;
6917   jmax = ((int)adj->value + event->area.y + event->area.height + 9) / 10;
6918
6919   gdk_window_clear_area (widget->window,
6920                          event->area.x, event->area.y,
6921                          event->area.width, event->area.height);
6922
6923   for (i=imin; i<imax; i++)
6924     for (j=jmin; j<jmax; j++)
6925       if ((i+j) % 2)
6926         gdk_draw_rectangle (widget->window,
6927                             widget->style->black_gc,
6928                             TRUE,
6929                             10*i, 10*j - (int)adj->value, 1+i%10, 1+j%10);
6930
6931   return TRUE;
6932 }
6933
6934 static void
6935 scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
6936                        GtkAdjustment *adj)
6937 {
6938   adj->page_increment = 0.9 * widget->allocation.height;
6939   adj->page_size = widget->allocation.height;
6940
6941   gtk_signal_emit_by_name (GTK_OBJECT (adj), "changed");
6942 }
6943
6944 static void
6945 scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
6946 {
6947   gint source_min = (int)adj->value - scroll_test_pos;
6948   gint source_max = source_min + widget->allocation.height;
6949   gint dest_min = 0;
6950   gint dest_max = widget->allocation.height;
6951   GdkRectangle rect;
6952   GdkEvent *event;
6953
6954   scroll_test_pos = adj->value;
6955
6956   if (!GTK_WIDGET_DRAWABLE (widget))
6957     return;
6958
6959   if (source_min < 0)
6960     {
6961       rect.x = 0;
6962       rect.y = 0;
6963       rect.width = widget->allocation.width;
6964       rect.height = -source_min;
6965       if (rect.height > widget->allocation.height)
6966         rect.height = widget->allocation.height;
6967
6968       source_min = 0;
6969       dest_min = rect.height;
6970     }
6971   else
6972     {
6973       rect.x = 0;
6974       rect.y = 2*widget->allocation.height - source_max;
6975       if (rect.y < 0)
6976         rect.y = 0;
6977       rect.width = widget->allocation.width;
6978       rect.height = widget->allocation.height - rect.y;
6979
6980       source_max = widget->allocation.height;
6981       dest_max = rect.y;
6982     }
6983
6984   if (source_min != source_max)
6985     {
6986       if (scroll_test_gc == NULL)
6987         {
6988           scroll_test_gc = gdk_gc_new (widget->window);
6989           gdk_gc_set_exposures (scroll_test_gc, TRUE);
6990         }
6991
6992       gdk_draw_pixmap (widget->window,
6993                        scroll_test_gc,
6994                        widget->window,
6995                        0, source_min,
6996                        0, dest_min,
6997                        widget->allocation.width,
6998                        source_max - source_min);
6999
7000       /* Make sure graphics expose events are processed before scrolling
7001        * again */
7002
7003       while ((event = gdk_event_get_graphics_expose (widget->window)) != NULL)
7004         {
7005           gtk_widget_event (widget, event);
7006           if (event->expose.count == 0)
7007             {
7008               gdk_event_free (event);
7009               break;
7010             }
7011           gdk_event_free (event);
7012         }
7013     }
7014
7015   if (rect.height != 0)
7016     gtk_widget_draw (widget, &rect);
7017 }
7018
7019
7020 void
7021 create_scroll_test (void)
7022 {
7023   static GtkWidget *window = NULL;
7024   GtkWidget *hbox;
7025   GtkWidget *drawing_area;
7026   GtkWidget *scrollbar;
7027   GtkWidget *button;
7028   GtkAdjustment *adj;
7029
7030   if (!window)
7031     {
7032       window = gtk_dialog_new ();
7033
7034       gtk_signal_connect (GTK_OBJECT (window), "destroy",
7035                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7036                           &window);
7037
7038       gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
7039       gtk_container_border_width (GTK_CONTAINER (window), 0);
7040
7041       hbox = gtk_hbox_new (FALSE, 0);
7042       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox,
7043                           TRUE, TRUE, 0);
7044       gtk_widget_show (hbox);
7045
7046       drawing_area = gtk_drawing_area_new ();
7047       gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 200, 200);
7048       gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
7049       gtk_widget_show (drawing_area);
7050
7051       gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK);
7052
7053       adj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0));
7054       scroll_test_pos = 0.0;
7055
7056       scrollbar = gtk_vscrollbar_new (adj);
7057       gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
7058       gtk_widget_show (scrollbar);
7059
7060       gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
7061                           GTK_SIGNAL_FUNC (scroll_test_expose), adj);
7062       gtk_signal_connect (GTK_OBJECT (drawing_area), "configure_event",
7063                           GTK_SIGNAL_FUNC (scroll_test_configure), adj);
7064
7065
7066       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7067                           GTK_SIGNAL_FUNC (scroll_test_adjustment_changed),
7068                           drawing_area);
7069
7070       /* .. And create some buttons */
7071
7072       button = gtk_button_new_with_label ("Quit");
7073       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7074                           button, TRUE, TRUE, 0);
7075
7076       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7077                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
7078                                  GTK_OBJECT (window));
7079       gtk_widget_show (button);
7080     }
7081
7082   if (!GTK_WIDGET_VISIBLE (window))
7083     gtk_widget_show (window);
7084   else
7085     gtk_widget_destroy (window);
7086 }
7087
7088 /*
7089  * Timeout Test
7090  */
7091
7092 static int timer = 0;
7093
7094 gint
7095 timeout_test (GtkWidget *label)
7096 {
7097   static int count = 0;
7098   static char buffer[32];
7099
7100   sprintf (buffer, "count: %d", ++count);
7101   gtk_label_set (GTK_LABEL (label), buffer);
7102
7103   return TRUE;
7104 }
7105
7106 void
7107 start_timeout_test (GtkWidget *widget,
7108                     GtkWidget *label)
7109 {
7110   if (!timer)
7111     {
7112       timer = gtk_timeout_add (100, (GtkFunction) timeout_test, label);
7113     }
7114 }
7115
7116 void
7117 stop_timeout_test (GtkWidget *widget,
7118                    gpointer   data)
7119 {
7120   if (timer)
7121     {
7122       gtk_timeout_remove (timer);
7123       timer = 0;
7124     }
7125 }
7126
7127 void
7128 destroy_timeout_test (GtkWidget  *widget,
7129                       GtkWidget **window)
7130 {
7131   stop_timeout_test (NULL, NULL);
7132
7133   *window = NULL;
7134 }
7135
7136 void
7137 create_timeout_test (void)
7138 {
7139   static GtkWidget *window = NULL;
7140   GtkWidget *button;
7141   GtkWidget *label;
7142
7143   if (!window)
7144     {
7145       window = gtk_dialog_new ();
7146
7147       gtk_signal_connect (GTK_OBJECT (window), "destroy",
7148                           GTK_SIGNAL_FUNC(destroy_timeout_test),
7149                           &window);
7150
7151       gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
7152       gtk_container_border_width (GTK_CONTAINER (window), 0);
7153
7154       label = gtk_label_new ("count: 0");
7155       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
7156       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
7157                           label, TRUE, TRUE, 0);
7158       gtk_widget_show (label);
7159
7160       button = gtk_button_new_with_label ("close");
7161       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7162                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
7163                                  GTK_OBJECT (window));
7164       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7165       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7166                           button, TRUE, TRUE, 0);
7167       gtk_widget_grab_default (button);
7168       gtk_widget_show (button);
7169
7170       button = gtk_button_new_with_label ("start");
7171       gtk_signal_connect (GTK_OBJECT (button), "clicked",
7172                           GTK_SIGNAL_FUNC(start_timeout_test),
7173                           label);
7174       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7175       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7176                           button, TRUE, TRUE, 0);
7177       gtk_widget_show (button);
7178
7179       button = gtk_button_new_with_label ("stop");
7180       gtk_signal_connect (GTK_OBJECT (button), "clicked",
7181                           GTK_SIGNAL_FUNC(stop_timeout_test),
7182                           NULL);
7183       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7184       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7185                           button, TRUE, TRUE, 0);
7186       gtk_widget_show (button);
7187     }
7188
7189   if (!GTK_WIDGET_VISIBLE (window))
7190     gtk_widget_show (window);
7191   else
7192     gtk_widget_destroy (window);
7193 }
7194
7195 /*
7196  * Idle Test
7197  */
7198
7199 static int idle = 0;
7200
7201 static gint
7202 idle_test (GtkWidget *label)
7203 {
7204   static int count = 0;
7205   static char buffer[32];
7206
7207   sprintf (buffer, "count: %d", ++count);
7208   gtk_label_set (GTK_LABEL (label), buffer);
7209
7210   return TRUE;
7211 }
7212
7213 static void
7214 start_idle_test (GtkWidget *widget,
7215                  GtkWidget *label)
7216 {
7217   if (!idle)
7218     {
7219       idle = gtk_idle_add ((GtkFunction) idle_test, label);
7220     }
7221 }
7222
7223 static void
7224 stop_idle_test (GtkWidget *widget,
7225                 gpointer   data)
7226 {
7227   if (idle)
7228     {
7229       gtk_idle_remove (idle);
7230       idle = 0;
7231     }
7232 }
7233
7234 static void
7235 destroy_idle_test (GtkWidget  *widget,
7236                    GtkWidget **window)
7237 {
7238   stop_idle_test (NULL, NULL);
7239
7240   *window = NULL;
7241 }
7242
7243 static void
7244 toggle_idle_container (GtkObject *button,
7245                        GtkContainer *container)
7246 {
7247   gtk_container_set_resize_mode (container, (guint) gtk_object_get_user_data (button));
7248 }
7249
7250 static void
7251 create_idle_test (void)
7252 {
7253   static GtkWidget *window = NULL;
7254   GtkWidget *button;
7255   GtkWidget *label;
7256   GtkWidget *container;
7257
7258   if (!window)
7259     {
7260       GtkWidget *frame;
7261       GtkWidget *box;
7262
7263       window = gtk_dialog_new ();
7264
7265       gtk_signal_connect (GTK_OBJECT (window), "destroy",
7266                           GTK_SIGNAL_FUNC(destroy_idle_test),
7267                           &window);
7268
7269       gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
7270       gtk_container_border_width (GTK_CONTAINER (window), 0);
7271
7272       label = gtk_label_new ("count: 0");
7273       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
7274       gtk_widget_show (label);
7275
7276       container =
7277         gtk_widget_new (GTK_TYPE_HBOX,
7278                         "GtkWidget::visible", TRUE,
7279                         /* "GtkContainer::child", gtk_widget_new (GTK_TYPE_HBOX,
7280                          * "GtkWidget::visible", TRUE,
7281                          */
7282                          "GtkContainer::child", label,
7283                         /* NULL), */
7284                         NULL);
7285       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
7286                           container, TRUE, TRUE, 0);
7287
7288       frame =
7289         gtk_widget_new (GTK_TYPE_FRAME,
7290                         "GtkContainer::border_width", 5,
7291                         "GtkFrame::label", "Label Container",
7292                         "GtkWidget::visible", TRUE,
7293                         "GtkWidget::parent", GTK_DIALOG (window)->vbox,
7294                         NULL);
7295       box =
7296         gtk_widget_new (GTK_TYPE_VBOX,
7297                         "GtkWidget::visible", TRUE,
7298                         "GtkWidget::parent", frame,
7299                         NULL);
7300       button =
7301         gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
7302                         "GtkButton::label", "Resize-Parent",
7303                         "GtkObject::user_data", (void*)GTK_RESIZE_PARENT,
7304                         "GtkObject::signal::clicked", toggle_idle_container, container,
7305                         "GtkWidget::visible", TRUE,
7306                         "GtkWidget::parent", box,
7307                         NULL);
7308       button =
7309         gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
7310                         "GtkButton::label", "Resize-Queue",
7311                         "GtkObject::user_data", (void*)GTK_RESIZE_QUEUE,
7312                         "GtkObject::signal::clicked", toggle_idle_container, container,
7313                         "GtkRadioButton::group", button,
7314                         "GtkWidget::visible", TRUE,
7315                         "GtkWidget::parent", box,
7316                         NULL);
7317       button =
7318         gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
7319                         "GtkButton::label", "Resize-Immediate",
7320                         "GtkObject::user_data", (void*)GTK_RESIZE_IMMEDIATE,
7321                         "GtkObject::signal::clicked", toggle_idle_container, container,
7322                         "GtkRadioButton::group", button,
7323                         "GtkWidget::visible", TRUE,
7324                         "GtkWidget::parent", box,
7325                         NULL);
7326
7327
7328       button = gtk_button_new_with_label ("close");
7329       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7330                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
7331                                  GTK_OBJECT (window));
7332       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7333       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7334                           button, TRUE, TRUE, 0);
7335       gtk_widget_grab_default (button);
7336       gtk_widget_show (button);
7337
7338       button = gtk_button_new_with_label ("start");
7339       gtk_signal_connect (GTK_OBJECT (button), "clicked",
7340                           GTK_SIGNAL_FUNC(start_idle_test),
7341                           label);
7342       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7343       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7344                           button, TRUE, TRUE, 0);
7345       gtk_widget_show (button);
7346
7347       button = gtk_button_new_with_label ("stop");
7348       gtk_signal_connect (GTK_OBJECT (button), "clicked",
7349                           GTK_SIGNAL_FUNC(stop_idle_test),
7350                           NULL);
7351       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7352       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7353                           button, TRUE, TRUE, 0);
7354       gtk_widget_show (button);
7355     }
7356
7357   if (!GTK_WIDGET_VISIBLE (window))
7358     gtk_widget_show (window);
7359   else
7360     gtk_widget_destroy (window);
7361 }
7362
7363 /*
7364  * rc file test
7365  */
7366
7367 void
7368 reload_rc_file (void)
7369 {
7370   GList *toplevels;
7371
7372   if (gtk_rc_reparse_all ())
7373     {
7374       toplevels = gdk_window_get_toplevels();
7375       while (toplevels)
7376         {
7377           GtkWidget *widget;
7378           gdk_window_get_user_data (toplevels->data, (gpointer *)&widget);
7379
7380           if (widget)
7381             gtk_widget_reset_rc_styles (widget);
7382
7383           toplevels = toplevels->next;
7384         }
7385       g_list_free (toplevels);
7386     }
7387 }
7388
7389 void
7390 reload_all_rc_files (void)
7391 {
7392   static GdkAtom atom_rcfiles = GDK_NONE;
7393
7394   GdkEventClient sev;
7395   int i;
7396
7397   if (!atom_rcfiles)
7398     atom_rcfiles = gdk_atom_intern("_GTK_READ_RCFILES", FALSE);
7399
7400   for(i = 0; i < 5; i++)
7401     sev.data.l[i] = 0;
7402   sev.data_format = 32;
7403   sev.message_type = atom_rcfiles;
7404   gdk_event_send_clientmessage_toall ((GdkEvent *) &sev);
7405 }
7406
7407 void
7408 create_rc_file (void)
7409 {
7410   static GtkWidget *window = NULL;
7411   GtkWidget *button;
7412
7413   if (!window)
7414     {
7415       window = gtk_dialog_new ();
7416
7417       gtk_signal_connect (GTK_OBJECT (window), "destroy",
7418                           GTK_SIGNAL_FUNC(destroy_idle_test),
7419                           &window);
7420
7421       gtk_window_set_title (GTK_WINDOW (window), "Reload Rc file");
7422       gtk_container_border_width (GTK_CONTAINER (window), 0);
7423
7424       button = gtk_button_new_with_label ("Reload");
7425       gtk_signal_connect (GTK_OBJECT (button), "clicked",
7426                           GTK_SIGNAL_FUNC(reload_rc_file), NULL);
7427       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7428       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7429                           button, TRUE, TRUE, 0);
7430       gtk_widget_grab_default (button);
7431       gtk_widget_show (button);
7432
7433       button = gtk_button_new_with_label ("Reload All");
7434       gtk_signal_connect (GTK_OBJECT (button), "clicked",
7435                           GTK_SIGNAL_FUNC(reload_all_rc_files), NULL);
7436       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7437       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7438                           button, TRUE, TRUE, 0);
7439       gtk_widget_show (button);
7440
7441       button = gtk_button_new_with_label ("Close");
7442       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7443                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
7444                                  GTK_OBJECT (window));
7445       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7446       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7447                           button, TRUE, TRUE, 0);
7448       gtk_widget_show (button);
7449
7450     }
7451
7452   if (!GTK_WIDGET_VISIBLE (window))
7453     gtk_widget_show (window);
7454   else
7455     gtk_widget_destroy (window);
7456 }
7457
7458 /*
7459  * Test of recursive mainloop
7460  */
7461
7462 void
7463 mainloop_destroyed (GtkWidget *w, GtkWidget **window)
7464 {
7465   *window = NULL;
7466   gtk_main_quit ();
7467 }
7468
7469 void
7470 create_mainloop (void)
7471 {
7472   static GtkWidget *window = NULL;
7473   GtkWidget *label;
7474   GtkWidget *button;
7475
7476   if (!window)
7477     {
7478       window = gtk_dialog_new ();
7479
7480       gtk_window_set_title (GTK_WINDOW (window), "Test Main Loop");
7481
7482       gtk_signal_connect (GTK_OBJECT (window), "destroy",
7483                           GTK_SIGNAL_FUNC(mainloop_destroyed),
7484                           &window);
7485
7486       label = gtk_label_new ("In recursive main loop...");
7487       gtk_misc_set_padding (GTK_MISC(label), 20, 20);
7488
7489       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), label,
7490                           TRUE, TRUE, 0);
7491       gtk_widget_show (label);
7492
7493       button = gtk_button_new_with_label ("Leave");
7494       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button,
7495                           FALSE, TRUE, 0);
7496
7497       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7498                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
7499                                  GTK_OBJECT (window));
7500
7501       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7502       gtk_widget_grab_default (button);
7503
7504       gtk_widget_show (button);
7505     }
7506
7507   if (!GTK_WIDGET_VISIBLE (window))
7508     {
7509       gtk_widget_show (window);
7510
7511       g_print ("create_mainloop: start\n");
7512       gtk_main ();
7513       g_print ("create_mainloop: done\n");
7514     }
7515   else
7516     gtk_widget_destroy (window);
7517 }
7518
7519 /*
7520  * Main Window and Exit
7521  */
7522
7523 void
7524 do_exit (GtkWidget *widget, GtkWidget *window)
7525 {
7526   gtk_widget_destroy (window);
7527   gtk_main_quit ();
7528 }
7529
7530 void
7531 create_main_window (void)
7532 {
7533   struct {
7534     char *label;
7535     void (*func) ();
7536   } buttons[] =
7537     {
7538       { "button box", create_button_box },
7539       { "buttons", create_buttons },
7540       { "check buttons", create_check_buttons },
7541       { "clist", create_clist},
7542       { "color selection", create_color_selection },
7543       { "ctree", create_ctree },
7544       { "cursors", create_cursors },
7545       { "dialog", create_dialog },
7546       { "dnd", create_dnd },
7547       { "entry", create_entry },
7548       { "file selection", create_file_selection },
7549       { "font selection", create_font_selection },
7550       { "gamma curve", create_gamma_curve },
7551       { "handle box", create_handle_box },
7552       { "item factory", create_item_factory },
7553       { "list", create_list },
7554       { "menus", create_menus },
7555       { "modal window", create_modal_window },
7556       { "notebook", create_notebook },
7557       { "panes", create_panes },
7558       { "pixmap", create_pixmap },
7559       { "preview color", create_color_preview },
7560       { "preview gray", create_gray_preview },
7561       { "progress bar", create_progress_bar },
7562       { "radio buttons", create_radio_buttons },
7563       { "range controls", create_range_controls },
7564       { "rc file", create_rc_file },
7565       { "reparent", create_reparent },
7566       { "rulers", create_rulers },
7567       { "scrolled windows", create_scrolled_windows },
7568       { "shapes", create_shapes },
7569       { "spinbutton", create_spins },
7570       { "statusbar", create_statusbar },
7571       { "test idle", create_idle_test },
7572       { "test mainloop", create_mainloop },
7573       { "test scrolling", create_scroll_test },
7574       { "test selection", create_selection_test },
7575       { "test timeout", create_timeout_test },
7576       { "text", create_text },
7577       { "toggle buttons", create_toggle_buttons },
7578       { "toolbar", create_toolbar },
7579       { "tooltips", create_tooltips },
7580       { "tree", create_tree_mode_window},
7581       { "WM hints", create_wmhints },
7582     };
7583   int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
7584   GtkWidget *window;
7585   GtkWidget *box1;
7586   GtkWidget *box2;
7587   GtkWidget *scrolled_window;
7588   GtkWidget *button;
7589   GtkWidget *label;
7590   gchar buffer[64];
7591   GtkWidget *separator;
7592   int i;
7593
7594   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7595   gtk_window_set_policy (GTK_WINDOW (window), FALSE, FALSE, FALSE);
7596   gtk_widget_set_name (window, "main window");
7597   gtk_widget_set_usize (window, 200, 400);
7598   gtk_widget_set_uposition (window, 20, 20);
7599
7600   gtk_signal_connect (GTK_OBJECT (window), "destroy",
7601                       GTK_SIGNAL_FUNC(gtk_main_quit),
7602                       NULL);
7603   gtk_signal_connect (GTK_OBJECT (window), "delete-event",
7604                       GTK_SIGNAL_FUNC (gtk_false),
7605                       NULL);
7606
7607   box1 = gtk_vbox_new (FALSE, 0);
7608   gtk_container_add (GTK_CONTAINER (window), box1);
7609
7610   if (gtk_micro_version > 0)
7611     sprintf (buffer,
7612              "Gtk+ v%d.%d.%d",
7613              gtk_major_version,
7614              gtk_minor_version,
7615              gtk_micro_version);
7616   else
7617     sprintf (buffer,
7618              "Gtk+ v%d.%d",
7619              gtk_major_version,
7620              gtk_minor_version);
7621
7622   label = gtk_label_new (buffer);
7623   gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
7624
7625   scrolled_window = gtk_scrolled_window_new (NULL, NULL);
7626   gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
7627   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
7628                                   GTK_POLICY_AUTOMATIC,
7629                                   GTK_POLICY_AUTOMATIC);
7630   GTK_WIDGET_UNSET_FLAGS (GTK_SCROLLED_WINDOW (scrolled_window)->vscrollbar, GTK_CAN_FOCUS);
7631   gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
7632
7633   box2 = gtk_vbox_new (FALSE, 0);
7634   gtk_container_border_width (GTK_CONTAINER (box2), 10);
7635   gtk_container_add (GTK_CONTAINER (scrolled_window), box2);
7636   gtk_container_set_focus_vadjustment (GTK_CONTAINER (box2),
7637                                        gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
7638   gtk_widget_show (box2);
7639
7640   for (i = 0; i < nbuttons; i++)
7641     {
7642       button = gtk_button_new_with_label (buttons[i].label);
7643       if (buttons[i].func)
7644         gtk_signal_connect (GTK_OBJECT (button),
7645                             "clicked",
7646                             GTK_SIGNAL_FUNC(buttons[i].func),
7647                             NULL);
7648       else
7649         gtk_widget_set_sensitive (button, FALSE);
7650       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
7651     }
7652
7653   separator = gtk_hseparator_new ();
7654   gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
7655
7656   box2 = gtk_vbox_new (FALSE, 10);
7657   gtk_container_border_width (GTK_CONTAINER (box2), 10);
7658   gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
7659
7660   button = gtk_button_new_with_label ("close");
7661   gtk_signal_connect (GTK_OBJECT (button), "clicked",
7662                       GTK_SIGNAL_FUNC (do_exit),
7663                       window);
7664   gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
7665   GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7666   gtk_widget_grab_default (button);
7667
7668   gtk_widget_show_all (window);
7669 }
7670
7671 int
7672 main (int argc, char *argv[])
7673 {
7674   GtkBindingSet *binding_set;
7675
7676   srand (time (NULL));
7677
7678   gtk_set_locale ();
7679
7680   gtk_init (&argc, &argv);
7681
7682   /* bindings test
7683    */
7684   binding_set = gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_WIDGET));
7685   gtk_binding_entry_add_signal (binding_set,
7686                                 '9', GDK_CONTROL_MASK | GDK_RELEASE_MASK,
7687                                 "debug_msg",
7688                                 1,
7689                                 GTK_TYPE_STRING, "GtkWidgetClass <ctrl><release>9 test");
7690
7691   gtk_rc_parse ("testgtkrc");
7692
7693   create_main_window ();
7694
7695   gtk_main ();
7696
7697   return 0;
7698 }