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

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