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