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 Free
  16  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include "gtk.h"
  21 #include "../gdk/gdk.h"
  22 #include "../gdk/gdkx.h"
  23
  24 #include "circles.xbm"
  25
  26 GtkWidget *shape_create_icon (char     *xpm_file,
  27                               gint      x,
  28                               gint      y,
  29                               gint      px,
  30                               gint      py,
  31                               gint      window_type);
  32
  33 /* macro, structure and variables used by tree window demos */
  34 #define DEFAULT_NUMBER_OF_ITEM  3
  35 #define DEFAULT_RECURSION_LEVEL 3
  36
  37 struct {
  38   GSList* selection_mode_group;
  39   GtkWidget* single_button;
  40   GtkWidget* browse_button;
  41   GtkWidget* multiple_button;
  42   GtkWidget* draw_line_button;
  43   GtkWidget* view_line_button;
  44   GtkWidget* no_root_item_button;
  45   GtkWidget* nb_item_spinner;
  46   GtkWidget* recursion_spinner;
  47 } sTreeSampleSelection;
  48
  49 typedef struct sTreeButtons {
  50   guint nb_item_add;
  51   GtkWidget* add_button;
  52   GtkWidget* remove_button;
  53 } sTreeButtons;
  54 /* end of tree section */
  55
  56 static void
  57 destroy_tooltips (GtkWidget *widget, GtkWindow **window)
  58 {
  59   GtkTooltips *tt = gtk_object_get_data (GTK_OBJECT (*window), "tooltips");
  60   gtk_object_unref (GTK_OBJECT (tt));
  61
  62   *window = NULL;
  63 }
  64
  65 static void
  66 button_window (GtkWidget *widget,
  67                GtkWidget *button)
  68 {
  69   if (!GTK_WIDGET_VISIBLE (button))
  70     gtk_widget_show (button);
  71   else
  72     gtk_widget_hide (button);
  73 }
  74
  75 static void
  76 create_buttons ()
  77 {
  78   static GtkWidget *window = NULL;
  79   GtkWidget *box1;
  80   GtkWidget *box2;
  81   GtkWidget *table;
  82   GtkWidget *button[10];
  83   GtkWidget *separator;
  84
  85   if (!window)
  86     {
  87       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  88
  89       gtk_signal_connect (GTK_OBJECT (window), "destroy",
  90                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
  91                           &window);
  92
  93       gtk_window_set_title (GTK_WINDOW (window), "buttons");
  94       gtk_container_border_width (GTK_CONTAINER (window), 0);
  95
  96       box1 = gtk_vbox_new (FALSE, 0);
  97       gtk_container_add (GTK_CONTAINER (window), box1);
  98       gtk_widget_show (box1);
  99
 100
 101       table = gtk_table_new (3, 3, FALSE);
 102       gtk_table_set_row_spacings (GTK_TABLE (table), 5);
 103       gtk_table_set_col_spacings (GTK_TABLE (table), 5);
 104       gtk_container_border_width (GTK_CONTAINER (table), 10);
 105       gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
 106       gtk_widget_show (table);
 107
 108
 109       button[0] = gtk_button_new_with_label ("button1");
 110       button[1] = gtk_button_new_with_label ("button2");
 111       button[2] = gtk_button_new_with_label ("button3");
 112       button[3] = gtk_button_new_with_label ("button4");
 113       button[4] = gtk_button_new_with_label ("button5");
 114       button[5] = gtk_button_new_with_label ("button6");
 115       button[6] = gtk_button_new_with_label ("button7");
 116       button[7] = gtk_button_new_with_label ("button8");
 117       button[8] = gtk_button_new_with_label ("button9");
 118
 119       gtk_signal_connect (GTK_OBJECT (button[0]), "clicked",
 120                           GTK_SIGNAL_FUNC(button_window),
 121                           button[1]);
 122
 123       gtk_table_attach (GTK_TABLE (table), button[0], 0, 1, 0, 1,
 124                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 125       gtk_widget_show (button[0]);
 126
 127       gtk_signal_connect (GTK_OBJECT (button[1]), "clicked",
 128                           GTK_SIGNAL_FUNC(button_window),
 129                           button[2]);
 130
 131       gtk_table_attach (GTK_TABLE (table), button[1], 1, 2, 1, 2,
 132                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 133       gtk_widget_show (button[1]);
 134
 135       gtk_signal_connect (GTK_OBJECT (button[2]), "clicked",
 136                           GTK_SIGNAL_FUNC(button_window),
 137                           button[3]);
 138       gtk_table_attach (GTK_TABLE (table), button[2], 2, 3, 2, 3,
 139                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 140       gtk_widget_show (button[2]);
 141
 142       gtk_signal_connect (GTK_OBJECT (button[3]), "clicked",
 143                           GTK_SIGNAL_FUNC(button_window),
 144                           button[4]);
 145       gtk_table_attach (GTK_TABLE (table), button[3], 0, 1, 2, 3,
 146                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 147       gtk_widget_show (button[3]);
 148
 149       gtk_signal_connect (GTK_OBJECT (button[4]), "clicked",
 150                           GTK_SIGNAL_FUNC(button_window),
 151                           button[5]);
 152       gtk_table_attach (GTK_TABLE (table), button[4], 2, 3, 0, 1,
 153                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 154       gtk_widget_show (button[4]);
 155
 156       gtk_signal_connect (GTK_OBJECT (button[5]), "clicked",
 157                           GTK_SIGNAL_FUNC(button_window),
 158                           button[6]);
 159       gtk_table_attach (GTK_TABLE (table), button[5], 1, 2, 2, 3,
 160                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 161       gtk_widget_show (button[5]);
 162
 163       gtk_signal_connect (GTK_OBJECT (button[6]), "clicked",
 164                           GTK_SIGNAL_FUNC(button_window),
 165                           button[7]);
 166       gtk_table_attach (GTK_TABLE (table), button[6], 1, 2, 0, 1,
 167                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 168       gtk_widget_show (button[6]);
 169
 170       gtk_signal_connect (GTK_OBJECT (button[7]), "clicked",
 171                           GTK_SIGNAL_FUNC(button_window),
 172                           button[8]);
 173       gtk_table_attach (GTK_TABLE (table), button[7], 2, 3, 1, 2,
 174                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 175       gtk_widget_show (button[7]);
 176
 177       gtk_signal_connect (GTK_OBJECT (button[8]), "clicked",
 178                           GTK_SIGNAL_FUNC(button_window),
 179                           button[0]);
 180       gtk_table_attach (GTK_TABLE (table), button[8], 0, 1, 1, 2,
 181                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 182       gtk_widget_show (button[8]);
 183
 184
 185       separator = gtk_hseparator_new ();
 186       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 187       gtk_widget_show (separator);
 188
 189
 190       box2 = gtk_vbox_new (FALSE, 10);
 191       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 192       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 193       gtk_widget_show (box2);
 194
 195
 196       button[9] = gtk_button_new_with_label ("close");
 197       gtk_signal_connect_object (GTK_OBJECT (button[9]), "clicked",
 198                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
 199                                  GTK_OBJECT (window));
 200       gtk_box_pack_start (GTK_BOX (box2), button[9], TRUE, TRUE, 0);
 201       GTK_WIDGET_SET_FLAGS (button[9], GTK_CAN_DEFAULT);
 202       gtk_widget_grab_default (button[9]);
 203       gtk_widget_show (button[9]);
 204     }
 205
 206   if (!GTK_WIDGET_VISIBLE (window))
 207     gtk_widget_show (window);
 208   else
 209     gtk_widget_destroy (window);
 210 }
 211
 212 static void
 213 create_toggle_buttons ()
 214 {
 215   static GtkWidget *window = NULL;
 216   GtkWidget *box1;
 217   GtkWidget *box2;
 218   GtkWidget *button;
 219   GtkWidget *separator;
 220
 221   if (!window)
 222     {
 223       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 224
 225       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 226                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
 227                           &window);
 228
 229       gtk_window_set_title (GTK_WINDOW (window), "toggle buttons");
 230       gtk_container_border_width (GTK_CONTAINER (window), 0);
 231
 232
 233       box1 = gtk_vbox_new (FALSE, 0);
 234       gtk_container_add (GTK_CONTAINER (window), box1);
 235       gtk_widget_show (box1);
 236
 237
 238       box2 = gtk_vbox_new (FALSE, 10);
 239       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 240       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
 241       gtk_widget_show (box2);
 242
 243
 244       button = gtk_toggle_button_new_with_label ("button1");
 245       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 246       gtk_widget_show (button);
 247
 248       button = gtk_toggle_button_new_with_label ("button2");
 249       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 250       gtk_widget_show (button);
 251
 252       button = gtk_toggle_button_new_with_label ("button3");
 253       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 254       gtk_widget_show (button);
 255
 256
 257       separator = gtk_hseparator_new ();
 258       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 259       gtk_widget_show (separator);
 260
 261
 262       box2 = gtk_vbox_new (FALSE, 10);
 263       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 264       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 265       gtk_widget_show (box2);
 266
 267
 268       button = gtk_button_new_with_label ("close");
 269       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
 270                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
 271                                  GTK_OBJECT (window));
 272       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 273       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 274       gtk_widget_grab_default (button);
 275       gtk_widget_show (button);
 276     }
 277
 278   if (!GTK_WIDGET_VISIBLE (window))
 279     gtk_widget_show (window);
 280   else
 281     gtk_widget_destroy (window);
 282 }
 283
 284 static void
 285 create_check_buttons ()
 286 {
 287   static GtkWidget *window = NULL;
 288   GtkWidget *box1;
 289   GtkWidget *box2;
 290   GtkWidget *button;
 291   GtkWidget *separator;
 292
 293   if (!window)
 294     {
 295       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 296
 297       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 298                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
 299                           &window);
 300
 301       gtk_window_set_title (GTK_WINDOW (window), "check buttons");
 302       gtk_container_border_width (GTK_CONTAINER (window), 0);
 303
 304
 305       box1 = gtk_vbox_new (FALSE, 0);
 306       gtk_container_add (GTK_CONTAINER (window), box1);
 307       gtk_widget_show (box1);
 308
 309
 310       box2 = gtk_vbox_new (FALSE, 10);
 311       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 312       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
 313       gtk_widget_show (box2);
 314
 315
 316       button = gtk_check_button_new_with_label ("button1");
 317       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 318       gtk_widget_show (button);
 319
 320       button = gtk_check_button_new_with_label ("button2");
 321       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 322       gtk_widget_show (button);
 323
 324       button = gtk_check_button_new_with_label ("button3");
 325       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 326       gtk_widget_show (button);
 327
 328
 329       separator = gtk_hseparator_new ();
 330       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 331       gtk_widget_show (separator);
 332
 333
 334       box2 = gtk_vbox_new (FALSE, 10);
 335       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 336       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 337       gtk_widget_show (box2);
 338
 339
 340       button = gtk_button_new_with_label ("close");
 341       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
 342                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
 343                                  GTK_OBJECT (window));
 344       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 345       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 346       gtk_widget_grab_default (button);
 347       gtk_widget_show (button);
 348     }
 349
 350   if (!GTK_WIDGET_VISIBLE (window))
 351     gtk_widget_show (window);
 352   else
 353     gtk_widget_destroy (window);
 354 }
 355
 356 static void
 357 create_radio_buttons ()
 358 {
 359   static GtkWidget *window = NULL;
 360   GtkWidget *box1;
 361   GtkWidget *box2;
 362   GtkWidget *button;
 363   GtkWidget *separator;
 364
 365   if (!window)
 366     {
 367       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 368
 369       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 370                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
 371                           &window);
 372
 373       gtk_window_set_title (GTK_WINDOW (window), "radio buttons");
 374       gtk_container_border_width (GTK_CONTAINER (window), 0);
 375
 376
 377       box1 = gtk_vbox_new (FALSE, 0);
 378       gtk_container_add (GTK_CONTAINER (window), box1);
 379       gtk_widget_show (box1);
 380
 381
 382       box2 = gtk_vbox_new (FALSE, 10);
 383       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 384       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
 385       gtk_widget_show (box2);
 386
 387
 388       button = gtk_radio_button_new_with_label (NULL, "button1");
 389       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 390       gtk_widget_show (button);
 391
 392       button = gtk_radio_button_new_with_label (
 393                  gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
 394                  "button2");
 395       gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
 396       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 397       gtk_widget_show (button);
 398
 399       button = gtk_radio_button_new_with_label (
 400                  gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
 401                  "button3");
 402       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 403       gtk_widget_show (button);
 404
 405
 406       separator = gtk_hseparator_new ();
 407       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 408       gtk_widget_show (separator);
 409
 410
 411       box2 = gtk_vbox_new (FALSE, 10);
 412       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 413       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 414       gtk_widget_show (box2);
 415
 416
 417       button = gtk_button_new_with_label ("close");
 418       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
 419                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
 420                                  GTK_OBJECT (window));
 421       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 422       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 423       gtk_widget_grab_default (button);
 424       gtk_widget_show (button);
 425     }
 426
 427   if (!GTK_WIDGET_VISIBLE (window))
 428     gtk_widget_show (window);
 429   else
 430     gtk_widget_destroy (window);
 431 }
 432
 433 static void
 434 bbox_widget_destroy (GtkWidget* widget, GtkWidget* todestroy)
 435 {
 436 }
 437
 438 static void
 439 create_bbox_window (gint  horizontal,
 440                     char* title,
 441                     gint  pos,
 442                     gint  spacing,
 443                     gint  child_w,
 444                     gint  child_h,
 445                     gint  layout)
 446 {
 447   GtkWidget* window;
 448   GtkWidget* box1;
 449   GtkWidget* bbox;
 450   GtkWidget* button;
 451
 452   /* create a new window */
 453   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 454   gtk_window_set_title (GTK_WINDOW (window), title);
 455
 456   gtk_signal_connect (GTK_OBJECT (window), "destroy",
 457                       GTK_SIGNAL_FUNC(bbox_widget_destroy), window);
 458
 459   if (horizontal)
 460   {
 461     gtk_widget_set_usize (window, 550, 60);
 462     gtk_widget_set_uposition (window, 150, pos);
 463     box1 = gtk_vbox_new (FALSE, 0);
 464   }
 465   else
 466   {
 467     gtk_widget_set_usize (window, 150, 400);
 468     gtk_widget_set_uposition (window, pos, 200);
 469     box1 = gtk_vbox_new (FALSE, 0);
 470   }
 471
 472   gtk_container_add (GTK_CONTAINER (window), box1);
 473   gtk_widget_show (box1);
 474
 475   if (horizontal)
 476     bbox = gtk_hbutton_box_new();
 477   else
 478     bbox = gtk_vbutton_box_new();
 479   gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), layout);
 480   gtk_button_box_set_spacing (GTK_BUTTON_BOX (bbox), spacing);
 481   gtk_button_box_set_child_size (GTK_BUTTON_BOX (bbox), child_w, child_h);
 482   gtk_widget_show (bbox);
 483
 484   gtk_container_border_width (GTK_CONTAINER(box1), 25);
 485   gtk_box_pack_start (GTK_BOX (box1), bbox, TRUE, TRUE, 0);
 486
 487   button = gtk_button_new_with_label ("OK");
 488   gtk_container_add (GTK_CONTAINER(bbox), button);
 489
 490   gtk_signal_connect (GTK_OBJECT (button), "clicked",
 491                       GTK_SIGNAL_FUNC(bbox_widget_destroy), window);
 492
 493   gtk_widget_show (button);
 494
 495   button = gtk_button_new_with_label ("Cancel");
 496   gtk_container_add (GTK_CONTAINER(bbox), button);
 497   gtk_widget_show (button);
 498
 499   button = gtk_button_new_with_label ("Help");
 500   gtk_container_add (GTK_CONTAINER(bbox), button);
 501   gtk_widget_show (button);
 502
 503   gtk_widget_show (window);
 504 }
 505
 506 static void
 507 test_hbbox ()
 508 {
 509   create_bbox_window (TRUE, "Spread", 50, 40, 85, 28, GTK_BUTTONBOX_SPREAD);
 510   create_bbox_window (TRUE, "Edge", 200, 40, 85, 25, GTK_BUTTONBOX_EDGE);
 511   create_bbox_window (TRUE, "Start", 350, 40, 85, 25, GTK_BUTTONBOX_START);
 512   create_bbox_window (TRUE, "End", 500, 15, 30, 25, GTK_BUTTONBOX_END);
 513 }
 514
 515 static void
 516 test_vbbox ()
 517 {
 518   create_bbox_window (FALSE, "Spread", 50, 40, 85, 25, GTK_BUTTONBOX_SPREAD);
 519   create_bbox_window (FALSE, "Edge", 250, 40, 85, 28, GTK_BUTTONBOX_EDGE);
 520   create_bbox_window (FALSE, "Start", 450, 40, 85, 25, GTK_BUTTONBOX_START);
 521   create_bbox_window (FALSE, "End", 650, 15, 30, 25, GTK_BUTTONBOX_END);
 522 }
 523
 524 static void
 525 create_button_box ()
 526 {
 527   static GtkWidget* window = NULL;
 528   GtkWidget* bbox;
 529   GtkWidget* button;
 530
 531   if (!window)
 532   {
 533     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 534     gtk_window_set_title (GTK_WINDOW (window),
 535                           "Button Box Test");
 536
 537     gtk_signal_connect (GTK_OBJECT (window), "destroy",
 538                         GTK_SIGNAL_FUNC(gtk_widget_destroyed),
 539                         &window);
 540
 541     gtk_container_border_width (GTK_CONTAINER (window), 20);
 542
 543     /*
 544      *these 15 lines are a nice and easy example for GtkHButtonBox
 545      */
 546     bbox = gtk_hbutton_box_new ();
 547     gtk_container_add (GTK_CONTAINER (window), bbox);
 548     gtk_widget_show (bbox);
 549
 550     button = gtk_button_new_with_label ("Horizontal");
 551     gtk_signal_connect (GTK_OBJECT (button), "clicked",
 552                         GTK_SIGNAL_FUNC(test_hbbox), 0);
 553     gtk_container_add (GTK_CONTAINER (bbox), button);
 554     gtk_widget_show (button);
 555
 556     button = gtk_button_new_with_label ("Vertical");
 557     gtk_signal_connect (GTK_OBJECT (button), "clicked",
 558                         GTK_SIGNAL_FUNC(test_vbbox), 0);
 559     gtk_container_add (GTK_CONTAINER (bbox), button);
 560     gtk_widget_show (button);
 561   }
 562
 563   if (!GTK_WIDGET_VISIBLE (window))
 564     gtk_widget_show (window);
 565   else
 566     gtk_widget_destroy (window);
 567 }
 568
 569 static GtkWidget*
 570 new_pixmap (char      *filename,
 571             GdkWindow *window,
 572             GdkColor  *background)
 573 {
 574   GtkWidget *wpixmap;
 575   GdkPixmap *pixmap;
 576   GdkBitmap *mask;
 577
 578   pixmap = gdk_pixmap_create_from_xpm (window, &mask,
 579                                        background,
 580                                        filename);
 581   wpixmap = gtk_pixmap_new (pixmap, mask);
 582
 583   return wpixmap;
 584 }
 585
 586 static void
 587 set_toolbar_horizontal (GtkWidget *widget,
 588                         gpointer   data)
 589 {
 590   gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_HORIZONTAL);
 591 }
 592
 593 static void
 594 set_toolbar_vertical (GtkWidget *widget,
 595                       gpointer   data)
 596 {
 597   gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_VERTICAL);
 598 }
 599
 600 static void
 601 set_toolbar_icons (GtkWidget *widget,
 602                    gpointer   data)
 603 {
 604   gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_ICONS);
 605 }
 606
 607 static void
 608 set_toolbar_text (GtkWidget *widget,
 609                   gpointer   data)
 610 {
 611   gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_TEXT);
 612 }
 613
 614 static void
 615 set_toolbar_both (GtkWidget *widget,
 616                   gpointer   data)
 617 {
 618   gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH);
 619 }
 620
 621 static void
 622 set_toolbar_small_space (GtkWidget *widget,
 623                          gpointer   data)
 624 {
 625   gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 5);
 626 }
 627
 628 static void
 629 set_toolbar_big_space (GtkWidget *widget,
 630                        gpointer   data)
 631 {
 632   gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 10);
 633 }
 634
 635 static void
 636 set_toolbar_enable (GtkWidget *widget,
 637                     gpointer   data)
 638 {
 639   gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), TRUE);
 640 }
 641
 642 static void
 643 set_toolbar_disable (GtkWidget *widget,
 644                      gpointer   data)
 645 {
 646   gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), FALSE);
 647 }
 648
 649 static void
 650 create_toolbar (void)
 651 {
 652   static GtkWidget *window = NULL;
 653   GtkWidget *toolbar;
 654   GtkWidget *entry;
 655
 656   if (!window)
 657     {
 658       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 659       gtk_window_set_title (GTK_WINDOW (window), "Toolbar test");
 660       gtk_window_set_policy (GTK_WINDOW (window), FALSE, TRUE, TRUE);
 661
 662       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 663                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
 664                           &window);
 665
 666       gtk_container_border_width (GTK_CONTAINER (window), 0);
 667       gtk_widget_realize (window);
 668
 669       toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
 670
 671       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 672                                "Horizontal", "Horizontal toolbar layout", "Toolbar/Horizontal",
 673                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 674                                (GtkSignalFunc) set_toolbar_horizontal, toolbar);
 675       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 676                                "Vertical", "Vertical toolbar layout", "Toolbar/Vertical",
 677                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 678                                (GtkSignalFunc) set_toolbar_vertical, toolbar);
 679
 680       gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
 681
 682       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 683                                "Icons", "Only show toolbar icons", "Toolbar/IconsOnly",
 684                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 685                                (GtkSignalFunc) set_toolbar_icons, toolbar);
 686       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 687                                "Text", "Only show toolbar text", "Toolbar/TextOnly",
 688                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 689                                (GtkSignalFunc) set_toolbar_text, toolbar);
 690       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 691                                "Both", "Show toolbar icons and text", "Toolbar/Both",
 692                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 693                                (GtkSignalFunc) set_toolbar_both, toolbar);
 694
 695       gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 696
 697       entry = gtk_entry_new ();
 698       gtk_widget_show(entry);
 699       gtk_toolbar_append_widget (GTK_TOOLBAR (toolbar), entry, "This is an unusable GtkEntry ;)", "Hey don't click me!!!");
 700
 701       gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 702
 703       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 704                                "Small", "Use small spaces", "Toolbar/Small",
 705                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 706                                (GtkSignalFunc) set_toolbar_small_space, toolbar);
 707       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 708                                "Big", "Use big spaces", "Toolbar/Big",
 709                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 710                                (GtkSignalFunc) set_toolbar_big_space, toolbar);
 711
 712       gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 713
 714       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 715                                "Enable", "Enable tooltips", NULL,
 716                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 717                                (GtkSignalFunc) set_toolbar_enable, toolbar);
 718       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 719                                "Disable", "Disable tooltips", NULL,
 720                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 721                                (GtkSignalFunc) set_toolbar_disable, toolbar);
 722
 723       gtk_container_add (GTK_CONTAINER (window), toolbar);
 724       gtk_widget_show (toolbar);
 725     }
 726
 727   if (!GTK_WIDGET_VISIBLE (window))
 728     gtk_widget_show (window);
 729   else
 730     gtk_widget_destroy (window);
 731 }
 732
 733 static GtkWidget*
 734 make_toolbar (GtkWidget *window)
 735 {
 736   GtkWidget *toolbar;
 737
 738   if (!GTK_WIDGET_REALIZED (window))
 739     gtk_widget_realize (window);
 740
 741   toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
 742
 743   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 744                            "Horizontal", "Horizontal toolbar layout", NULL,
 745                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 746                            (GtkSignalFunc) set_toolbar_horizontal, toolbar);
 747   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 748                            "Vertical", "Vertical toolbar layout", NULL,
 749                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 750                            (GtkSignalFunc) set_toolbar_vertical, toolbar);
 751
 752   gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
 753
 754   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 755                            "Icons", "Only show toolbar icons", NULL,
 756                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 757                            (GtkSignalFunc) set_toolbar_icons, toolbar);
 758   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 759                            "Text", "Only show toolbar text", NULL,
 760                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 761                            (GtkSignalFunc) set_toolbar_text, toolbar);
 762   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 763                            "Both", "Show toolbar icons and text", NULL,
 764                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 765                            (GtkSignalFunc) set_toolbar_both, toolbar);
 766
 767   gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 768
 769   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 770                            "Small", "Use small spaces", NULL,
 771                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 772                            (GtkSignalFunc) set_toolbar_small_space, toolbar);
 773   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 774                            "Big", "Use big spaces", "Toolbar/Big",
 775                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 776                            (GtkSignalFunc) set_toolbar_big_space, toolbar);
 777
 778   gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 779
 780   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 781                            "Enable", "Enable tooltips", NULL,
 782                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 783                            (GtkSignalFunc) set_toolbar_enable, toolbar);
 784   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 785                            "Disable", "Disable tooltips", NULL,
 786                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 787                            (GtkSignalFunc) set_toolbar_disable, toolbar);
 788
 789   return toolbar;
 790 }
 791
 792 static guint statusbar_counter = 1;
 793
 794 static void
 795 statusbar_push (GtkWidget *button,
 796                 GtkStatusbar *statusbar)
 797 {
 798   gchar text[1024];
 799
 800   sprintf (text, "something %d", statusbar_counter++);
 801
 802   gtk_statusbar_push (statusbar, 1, text);
 803 }
 804
 805 static void
 806 statusbar_pop (GtkWidget *button,
 807                GtkStatusbar *statusbar)
 808 {
 809   gtk_statusbar_pop (statusbar, 1);
 810 }
 811
 812 static void
 813 statusbar_steal (GtkWidget *button,
 814                  GtkStatusbar *statusbar)
 815 {
 816   gtk_statusbar_remove (statusbar, 1, 4);
 817 }
 818
 819 static void
 820 statusbar_popped (GtkStatusbar  *statusbar,
 821                   guint          context_id,
 822                   const gchar   *text)
 823 {
 824   if (!statusbar->messages)
 825     statusbar_counter = 1;
 826 }
 827
 828 static void
 829 statusbar_contexts (GtkWidget *button,
 830                     GtkStatusbar *statusbar)
 831 {
 832   gchar *string;
 833
 834   string = "any context";
 835   g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
 836            string,
 837            gtk_statusbar_get_context_id (statusbar, string));
 838
 839   string = "idle messages";
 840   g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
 841            string,
 842            gtk_statusbar_get_context_id (statusbar, string));
 843
 844   string = "some text";
 845   g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
 846            string,
 847            gtk_statusbar_get_context_id (statusbar, string));
 848
 849   string = "hit the mouse";
 850   g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
 851            string,
 852            gtk_statusbar_get_context_id (statusbar, string));
 853
 854   string = "hit the mouse2";
 855   g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
 856            string,
 857            gtk_statusbar_get_context_id (statusbar, string));
 858 }
 859
 860 static void
 861 statusbar_dump_stack (GtkWidget *button,
 862                       GtkStatusbar *statusbar)
 863 {
 864   GSList *list;
 865
 866   for (list = statusbar->messages; list; list = list->next)
 867     {
 868       GtkStatusbarMsg *msg;
 869
 870       msg = list->data;
 871       g_print ("context_id: %d, message_id: %d, status_text: \"%s\"\n",
 872                msg->context_id,
 873                msg->message_id,
 874                msg->text);
 875     }
 876 }
 877
 878 static void
 879 create_statusbar ()
 880 {
 881   static GtkWidget *window = NULL;
 882   GtkWidget *box1;
 883   GtkWidget *box2;
 884   GtkWidget *button;
 885   GtkWidget *separator;
 886   GtkWidget *statusbar;
 887
 888   if (!window)
 889     {
 890       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 891
 892       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 893                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
 894                           &window);
 895
 896       gtk_window_set_title (GTK_WINDOW (window), "statusbar");
 897       gtk_container_border_width (GTK_CONTAINER (window), 0);
 898
 899
 900       box1 = gtk_vbox_new (FALSE, 0);
 901       gtk_container_add (GTK_CONTAINER (window), box1);
 902       gtk_widget_show (box1);
 903
 904
 905       box2 = gtk_vbox_new (FALSE, 10);
 906       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 907       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
 908       gtk_widget_show (box2);
 909
 910       statusbar = gtk_statusbar_new ();
 911       gtk_box_pack_end (GTK_BOX (box1), statusbar, TRUE, TRUE, 0);
 912       gtk_widget_show (statusbar);
 913       gtk_signal_connect (GTK_OBJECT (statusbar),
 914                           "text_popped",
 915                           GTK_SIGNAL_FUNC (statusbar_popped),
 916                           NULL);
 917
 918       button = gtk_widget_new (gtk_button_get_type (),
 919                                "GtkButton::label", "push something",
 920                                "GtkWidget::visible", TRUE,
 921                                "GtkWidget::parent", box2,
 922                                "GtkObject::signal::clicked", statusbar_push, statusbar,
 923                                NULL);
 924
 925       button = gtk_widget_new (gtk_button_get_type (),
 926                                "GtkButton::label", "pop",
 927                                "GtkWidget::visible", TRUE,
 928                                "GtkWidget::parent", box2,
 929                                "GtkObject::signal::clicked", statusbar_pop, statusbar,
 930                                NULL);
 931
 932       button = gtk_widget_new (gtk_button_get_type (),
 933                                "GtkButton::label", "steal #4",
 934                                "GtkWidget::visible", TRUE,
 935                                "GtkWidget::parent", box2,
 936                                "GtkObject::signal::clicked", statusbar_steal, statusbar,
 937                                NULL);
 938
 939       button = gtk_widget_new (gtk_button_get_type (),
 940                                "GtkButton::label", "dump stack",
 941                                "GtkWidget::visible", TRUE,
 942                                "GtkWidget::parent", box2,
 943                                "GtkObject::signal::clicked", statusbar_dump_stack, statusbar,
 944                                NULL);
 945
 946       button = gtk_widget_new (gtk_button_get_type (),
 947                                "GtkButton::label", "test contexts",
 948                                "GtkWidget::visible", TRUE,
 949                                "GtkWidget::parent", box2,
 950                                "GtkObject::signal::clicked", statusbar_contexts, statusbar,
 951                                NULL);
 952
 953       separator = gtk_hseparator_new ();
 954       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 955       gtk_widget_show (separator);
 956
 957
 958       box2 = gtk_vbox_new (FALSE, 10);
 959       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 960       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 961       gtk_widget_show (box2);
 962
 963
 964       button = gtk_button_new_with_label ("close");
 965       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
 966                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
 967                                  GTK_OBJECT (window));
 968       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 969       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 970       gtk_widget_grab_default (button);
 971       gtk_widget_show (button);
 972     }
 973
 974   if (!GTK_WIDGET_VISIBLE (window))
 975     gtk_widget_show (window);
 976   else
 977     gtk_widget_destroy (window);
 978 }
 979
 980 static void
 981 handle_box_child_signal (GtkHandleBox *hb,
 982                          GtkWidget    *child,
 983                          const gchar  *action)
 984 {
 985   printf ("%s: child <%s> %sed\n",
 986           gtk_type_name (GTK_OBJECT_TYPE (hb)),
 987           gtk_type_name (GTK_OBJECT_TYPE (child)),
 988           action);
 989 }
 990
 991 static void
 992 cb_tree_destroy_event(GtkWidget* w)
 993 {
 994   sTreeButtons* tree_buttons;
 995
 996   /* free buttons structure associate at this tree */
 997   tree_buttons = gtk_object_get_user_data(GTK_OBJECT(w));
 998   free(tree_buttons);
 999 }
1000 static void
1001 cb_add_new_item(GtkWidget* w, GtkTree* tree)
1002 {
1003   sTreeButtons* tree_buttons;
1004   GList* selected_list;
1005   GtkWidget* selected_item;
1006   GtkWidget* subtree;
1007   GtkWidget* item_new;
1008   char buffer[255];
1009
1010   tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree));
1011
1012   selected_list = GTK_TREE_SELECTION(tree);
1013
1014   if(selected_list == NULL)
1015     {
1016       /* there is no item in tree */
1017       subtree = GTK_WIDGET(tree);
1018     }
1019   else
1020     {
1021       /* list can have only one element */
1022       selected_item = GTK_WIDGET(selected_list->data);
1023
1024       subtree = GTK_TREE_ITEM_SUBTREE(selected_item);
1025
1026       if(subtree == NULL)
1027         {
1028           /* current selected item have not subtree ... create it */
1029           subtree = gtk_tree_new();
1030           gtk_tree_item_set_subtree(GTK_TREE_ITEM(selected_item),
1031                                     subtree);
1032         }
1033     }
1034
1035   /* at this point, we know which subtree will be used to add new item */
1036   /* create a new item */
1037   sprintf(buffer, "item add %d", tree_buttons->nb_item_add);
1038   item_new = gtk_tree_item_new_with_label(buffer);
1039   gtk_tree_append(GTK_TREE(subtree), item_new);
1040   gtk_widget_show(item_new);
1041
1042   tree_buttons->nb_item_add++;
1043 }
1044
1045 static void
1046 cb_remove_item(GtkWidget*w, GtkTree* tree)
1047 {
1048   GList* selected_list;
1049   GList* clear_list;
1050
1051   selected_list = GTK_TREE_SELECTION(tree);
1052
1053   clear_list = NULL;
1054
1055   while (selected_list)
1056     {
1057       clear_list = g_list_prepend (clear_list, selected_list->data);
1058       selected_list = selected_list->next;
1059     }
1060
1061   clear_list = g_list_reverse (clear_list);
1062   gtk_tree_remove_items(tree, clear_list);
1063
1064   g_list_free (clear_list);
1065 }
1066
1067 static void
1068 cb_tree_changed(GtkTree* tree)
1069 {
1070   sTreeButtons* tree_buttons;
1071   GList* selected_list;
1072   guint nb_selected;
1073
1074   tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree));
1075
1076   selected_list = GTK_TREE_SELECTION(tree);
1077   nb_selected = g_list_length(selected_list);
1078
1079   if(nb_selected == 0)
1080     {
1081       if(tree->children == NULL)
1082         gtk_widget_set_sensitive(tree_buttons->add_button, TRUE);
1083       else
1084         gtk_widget_set_sensitive(tree_buttons->add_button, FALSE);
1085       gtk_widget_set_sensitive(tree_buttons->remove_button, FALSE);
1086     }
1087   else
1088     {
1089       gtk_widget_set_sensitive(tree_buttons->remove_button, TRUE);
1090       gtk_widget_set_sensitive(tree_buttons->add_button, (nb_selected == 1));
1091     }
1092 }
1093
1094 static void
1095 create_subtree(GtkWidget* item, guint level, guint nb_item_max, guint recursion_level_max)
1096 {
1097   GtkWidget* item_subtree;
1098   GtkWidget* item_new;
1099   guint nb_item;
1100   char buffer[255];
1101   int no_root_item;
1102
1103   if(level == recursion_level_max) return;
1104
1105   if(level == -1)
1106     {
1107       /* query with no root item */
1108       level = 0;
1109       item_subtree = item;
1110       no_root_item = 1;
1111     }
1112   else
1113     {
1114       /* query with no root item */
1115       /* create subtree and associate it with current item */
1116       item_subtree = gtk_tree_new();
1117       no_root_item = 0;
1118     }
1119
1120   for(nb_item = 0; nb_item < nb_item_max; nb_item++)
1121     {
1122       sprintf(buffer, "item %d-%d", level, nb_item);
1123       item_new = gtk_tree_item_new_with_label(buffer);
1124       gtk_tree_append(GTK_TREE(item_subtree), item_new);
1125       create_subtree(item_new, level+1, nb_item_max, recursion_level_max);
1126       gtk_widget_show(item_new);
1127     }
1128
1129   if(!no_root_item)
1130     gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), item_subtree);
1131 }
1132
1133 static void
1134 create_tree_sample(guint selection_mode,
1135                    guint draw_line, guint view_line, guint no_root_item,
1136                    guint nb_item_max, guint recursion_level_max)
1137 {
1138   GtkWidget* window;
1139   GtkWidget* box1;
1140   GtkWidget* box2;
1141   GtkWidget* separator;
1142   GtkWidget* button;
1143   GtkWidget* scrolled_win;
1144   GtkWidget* root_tree;
1145   GtkWidget* root_item;
1146   sTreeButtons* tree_buttons;
1147
1148   /* create tree buttons struct */
1149   if((tree_buttons = g_malloc(sizeof(sTreeButtons))) == NULL)
1150     {
1151       g_error("can't allocate memory for tree structure !\n");
1152       return;
1153     }
1154   tree_buttons->nb_item_add = 0;
1155
1156   /* create top level window */
1157   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1158   gtk_window_set_title(GTK_WINDOW(window), "Tree Sample");
1159   gtk_signal_connect(GTK_OBJECT(window), "destroy",
1160                      (GtkSignalFunc) cb_tree_destroy_event, NULL);
1161   gtk_object_set_user_data(GTK_OBJECT(window), tree_buttons);
1162
1163   box1 = gtk_vbox_new(FALSE, 0);
1164   gtk_container_add(GTK_CONTAINER(window), box1);
1165   gtk_widget_show(box1);
1166
1167   /* create tree box */
1168   box2 = gtk_vbox_new(FALSE, 0);
1169   gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);
1170   gtk_container_border_width(GTK_CONTAINER(box2), 5);
1171   gtk_widget_show(box2);
1172
1173   /* create scrolled window */
1174   scrolled_win = gtk_scrolled_window_new (NULL, NULL);
1175   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
1176                                   GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1177   gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
1178   gtk_widget_set_usize (scrolled_win, 200, 200);
1179   gtk_widget_show (scrolled_win);
1180
1181   /* create root tree widget */
1182   root_tree = gtk_tree_new();
1183   gtk_signal_connect(GTK_OBJECT(root_tree), "selection_changed",
1184                      (GtkSignalFunc)cb_tree_changed,
1185                      (gpointer)NULL);
1186   gtk_object_set_user_data(GTK_OBJECT(root_tree), tree_buttons);
1187   gtk_container_add(GTK_CONTAINER(scrolled_win), root_tree);
1188   gtk_tree_set_selection_mode(GTK_TREE(root_tree), selection_mode);
1189   gtk_tree_set_view_lines(GTK_TREE(root_tree), draw_line);
1190   gtk_tree_set_view_mode(GTK_TREE(root_tree), !view_line);
1191   gtk_widget_show(root_tree);
1192
1193   if ( no_root_item )
1194     {
1195       /* set root tree to subtree function with root item variable */
1196       root_item = GTK_WIDGET(root_tree);
1197     }
1198   else
1199     {
1200       /* create root tree item widget */
1201       root_item = gtk_tree_item_new_with_label("root item");
1202       gtk_tree_append(GTK_TREE(root_tree), root_item);
1203       gtk_widget_show(root_item);
1204      }
1205   create_subtree(root_item, -no_root_item, nb_item_max, recursion_level_max);
1206
1207   box2 = gtk_vbox_new(FALSE, 0);
1208   gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1209   gtk_container_border_width(GTK_CONTAINER(box2), 5);
1210   gtk_widget_show(box2);
1211
1212   button = gtk_button_new_with_label("Add Item");
1213   gtk_widget_set_sensitive(button, FALSE);
1214   gtk_signal_connect(GTK_OBJECT (button), "clicked",
1215                      (GtkSignalFunc) cb_add_new_item,
1216                      (gpointer)root_tree);
1217   gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1218   gtk_widget_show(button);
1219   tree_buttons->add_button = button;
1220
1221   button = gtk_button_new_with_label("Remove Item(s)");
1222   gtk_widget_set_sensitive(button, FALSE);
1223   gtk_signal_connect(GTK_OBJECT (button), "clicked",
1224                      (GtkSignalFunc) cb_remove_item,
1225                      (gpointer)root_tree);
1226   gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1227   gtk_widget_show(button);
1228   tree_buttons->remove_button = button;
1229
1230   /* create separator */
1231   separator = gtk_hseparator_new();
1232   gtk_box_pack_start(GTK_BOX(box1), separator, FALSE, FALSE, 0);
1233   gtk_widget_show(separator);
1234
1235   /* create button box */
1236   box2 = gtk_vbox_new(FALSE, 0);
1237   gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1238   gtk_container_border_width(GTK_CONTAINER(box2), 5);
1239   gtk_widget_show(box2);
1240
1241   button = gtk_button_new_with_label("Close");
1242   gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1243   gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
1244                             (GtkSignalFunc) gtk_widget_destroy,
1245                             GTK_OBJECT(window));
1246   gtk_widget_show(button);
1247
1248   gtk_widget_show(window);
1249 }
1250
1251 static void
1252 cb_create_tree(GtkWidget* w)
1253 {
1254   guint selection_mode = GTK_SELECTION_SINGLE;
1255   guint view_line;
1256   guint draw_line;
1257   guint no_root_item;
1258   guint nb_item;
1259   guint recursion_level;
1260
1261   /* get selection mode choice */
1262   if(GTK_TOGGLE_BUTTON(sTreeSampleSelection.single_button)->active)
1263     selection_mode = GTK_SELECTION_SINGLE;
1264   else
1265     if(GTK_TOGGLE_BUTTON(sTreeSampleSelection.browse_button)->active)
1266       selection_mode = GTK_SELECTION_BROWSE;
1267     else
1268       selection_mode = GTK_SELECTION_MULTIPLE;
1269
1270   /* get options choice */
1271   draw_line = GTK_TOGGLE_BUTTON(sTreeSampleSelection.draw_line_button)->active;
1272   view_line = GTK_TOGGLE_BUTTON(sTreeSampleSelection.view_line_button)->active;
1273   no_root_item = GTK_TOGGLE_BUTTON(sTreeSampleSelection.no_root_item_button)->active;
1274
1275   /* get levels */
1276   nb_item = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sTreeSampleSelection.nb_item_spinner));
1277   recursion_level = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sTreeSampleSelection.recursion_spinner));
1278
1279   if (pow (nb_item, recursion_level) > 10000)
1280     {
1281       g_print ("%g total items? That will take a very long time. Try less\n",
1282                pow (nb_item, recursion_level));
1283       return;
1284     }
1285
1286   create_tree_sample(selection_mode, draw_line, view_line, no_root_item, nb_item, recursion_level);
1287 }
1288
1289 void
1290 create_tree_mode_window(void)
1291 {
1292   static GtkWidget* window;
1293   GtkWidget* box1;
1294   GtkWidget* box2;
1295   GtkWidget* box3;
1296   GtkWidget* box4;
1297   GtkWidget* box5;
1298   GtkWidget* button;
1299   GtkWidget* frame;
1300   GtkWidget* separator;
1301   GtkWidget* label;
1302   GtkWidget* spinner;
1303   GtkAdjustment *adj;
1304
1305   if (!window)
1306     {
1307       /* create toplevel window  */
1308       window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1309       gtk_window_set_title(GTK_WINDOW(window), "Tree Mode Selection Window");
1310       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1311                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1312                           &window);
1313       box1 = gtk_vbox_new(FALSE, 0);
1314       gtk_container_add(GTK_CONTAINER(window), box1);
1315       gtk_widget_show(box1);
1316
1317   /* create upper box - selection box */
1318       box2 = gtk_vbox_new(FALSE, 5);
1319       gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);
1320       gtk_container_border_width(GTK_CONTAINER(box2), 5);
1321       gtk_widget_show(box2);
1322
1323       box3 = gtk_hbox_new(FALSE, 5);
1324       gtk_box_pack_start(GTK_BOX(box2), box3, TRUE, TRUE, 0);
1325       gtk_widget_show(box3);
1326
1327       /* create selection mode frame */
1328       frame = gtk_frame_new("Selection Mode");
1329       gtk_box_pack_start(GTK_BOX(box3), frame, TRUE, TRUE, 0);
1330       gtk_widget_show(frame);
1331
1332       box4 = gtk_vbox_new(FALSE, 0);
1333       gtk_container_add(GTK_CONTAINER(frame), box4);
1334       gtk_container_border_width(GTK_CONTAINER(box4), 5);
1335       gtk_widget_show(box4);
1336
1337       /* create radio button */
1338       button = gtk_radio_button_new_with_label(NULL, "SINGLE");
1339       gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1340       gtk_widget_show(button);
1341       sTreeSampleSelection.single_button = button;
1342
1343       button = gtk_radio_button_new_with_label(gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
1344                                                "BROWSE");
1345       gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1346       gtk_widget_show(button);
1347       sTreeSampleSelection.browse_button = button;
1348
1349       button = gtk_radio_button_new_with_label(gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
1350                                                "MULTIPLE");
1351       gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1352       gtk_widget_show(button);
1353       sTreeSampleSelection.multiple_button = button;
1354
1355       sTreeSampleSelection.selection_mode_group = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
1356
1357       /* create option mode frame */
1358       frame = gtk_frame_new("Options");
1359       gtk_box_pack_start(GTK_BOX(box3), frame, TRUE, TRUE, 0);
1360       gtk_widget_show(frame);
1361
1362       box4 = gtk_vbox_new(FALSE, 0);
1363       gtk_container_add(GTK_CONTAINER(frame), box4);
1364       gtk_container_border_width(GTK_CONTAINER(box4), 5);
1365       gtk_widget_show(box4);
1366
1367       /* create check button */
1368       button = gtk_check_button_new_with_label("Draw line");
1369       gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1370       gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE);
1371       gtk_widget_show(button);
1372       sTreeSampleSelection.draw_line_button = button;
1373
1374       button = gtk_check_button_new_with_label("View Line mode");
1375       gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1376       gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE);
1377       gtk_widget_show(button);
1378       sTreeSampleSelection.view_line_button = button;
1379
1380       button = gtk_check_button_new_with_label("Without Root item");
1381       gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1382       gtk_widget_show(button);
1383       sTreeSampleSelection.no_root_item_button = button;
1384
1385       /* create recursion parameter */
1386       frame = gtk_frame_new("Size Parameters");
1387       gtk_box_pack_start(GTK_BOX(box2), frame, TRUE, TRUE, 0);
1388       gtk_widget_show(frame);
1389
1390       box4 = gtk_hbox_new(FALSE, 5);
1391       gtk_container_add(GTK_CONTAINER(frame), box4);
1392       gtk_container_border_width(GTK_CONTAINER(box4), 5);
1393       gtk_widget_show(box4);
1394
1395       /* create number of item spin button */
1396       box5 = gtk_hbox_new(FALSE, 5);
1397       gtk_box_pack_start(GTK_BOX(box4), box5, FALSE, FALSE, 0);
1398       gtk_widget_show(box5);
1399
1400       label = gtk_label_new("Number of Item");
1401       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1402       gtk_box_pack_start (GTK_BOX (box5), label, FALSE, TRUE, 0);
1403       gtk_widget_show(label);
1404
1405       adj = (GtkAdjustment *) gtk_adjustment_new ((gfloat)DEFAULT_NUMBER_OF_ITEM, 1.0, 255.0, 1.0,
1406                                                   5.0, 0.0);
1407       spinner = gtk_spin_button_new (adj, 0, 0);
1408       gtk_box_pack_start (GTK_BOX (box5), spinner, FALSE, TRUE, 0);
1409       gtk_widget_show(spinner);
1410       sTreeSampleSelection.nb_item_spinner = spinner;
1411
1412       /* create recursion level spin button */
1413       box5 = gtk_hbox_new(FALSE, 5);
1414       gtk_box_pack_start(GTK_BOX(box4), box5, FALSE, FALSE, 0);
1415       gtk_widget_show(box5);
1416
1417       label = gtk_label_new("Depth Level");
1418       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1419       gtk_box_pack_start (GTK_BOX (box5), label, FALSE, TRUE, 0);
1420       gtk_widget_show(label);
1421
1422       adj = (GtkAdjustment *) gtk_adjustment_new ((gfloat)DEFAULT_RECURSION_LEVEL, 0.0, 255.0, 1.0,
1423                                                   5.0, 0.0);
1424       spinner = gtk_spin_button_new (adj, 0, 0);
1425       gtk_box_pack_start (GTK_BOX (box5), spinner, FALSE, TRUE, 0);
1426       gtk_widget_show(spinner);
1427       sTreeSampleSelection.recursion_spinner = spinner;
1428
1429       /* create horizontal separator */
1430       separator = gtk_hseparator_new();
1431       gtk_box_pack_start(GTK_BOX(box1), separator, FALSE, FALSE, 0);
1432       gtk_widget_show(separator);
1433
1434       /* create bottom button box */
1435       box2 = gtk_hbox_new(FALSE, 0);
1436       gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1437       gtk_container_border_width(GTK_CONTAINER(box2), 5);
1438       gtk_widget_show(box2);
1439
1440       button = gtk_button_new_with_label("Create Tree Sample");
1441       gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1442       gtk_signal_connect(GTK_OBJECT (button), "clicked",
1443                          (GtkSignalFunc) cb_create_tree, NULL);
1444       gtk_widget_show(button);
1445
1446       button = gtk_button_new_with_label("Close");
1447       gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1448       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1449                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1450                                  GTK_OBJECT (window));
1451       gtk_widget_show(button);
1452
1453     }
1454   if (!GTK_WIDGET_VISIBLE (window))
1455     gtk_widget_show (window);
1456   else
1457     gtk_widget_destroy (window);
1458 }
1459
1460 /* end of function used by tree demos */
1461
1462 static void
1463 create_handle_box ()
1464 {
1465   static GtkWidget* window = NULL;
1466   GtkWidget *handle_box;
1467   GtkWidget *handle_box2;
1468   GtkWidget *vbox;
1469   GtkWidget *hbox;
1470   GtkWidget *toolbar;
1471   GtkWidget *label;
1472   GtkWidget *separator;
1473
1474   if (!window)
1475   {
1476     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1477     gtk_window_set_title (GTK_WINDOW (window),
1478                           "Handle Box Test");
1479     gtk_window_set_policy (GTK_WINDOW (window),
1480                            TRUE,
1481                            TRUE,
1482                            FALSE);
1483
1484     gtk_signal_connect (GTK_OBJECT (window), "destroy",
1485                         GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1486                         &window);
1487
1488     gtk_container_border_width (GTK_CONTAINER (window), 20);
1489
1490     vbox = gtk_vbox_new (FALSE, 0);
1491     gtk_container_add (GTK_CONTAINER (window), vbox);
1492     gtk_widget_show (vbox);
1493
1494     label = gtk_label_new ("Above");
1495     gtk_container_add (GTK_CONTAINER (vbox), label);
1496     gtk_widget_show (label);
1497
1498     separator = gtk_hseparator_new ();
1499     gtk_container_add (GTK_CONTAINER (vbox), separator);
1500     gtk_widget_show (separator);
1501
1502     hbox = gtk_hbox_new (FALSE, 10);
1503     gtk_container_add (GTK_CONTAINER (vbox), hbox);
1504     gtk_widget_show (hbox);
1505
1506     separator = gtk_hseparator_new ();
1507     gtk_container_add (GTK_CONTAINER (vbox), separator);
1508     gtk_widget_show (separator);
1509
1510     label = gtk_label_new ("Below");
1511     gtk_container_add (GTK_CONTAINER (vbox), label);
1512     gtk_widget_show (label);
1513
1514     handle_box = gtk_handle_box_new ();
1515     gtk_container_add (GTK_CONTAINER (hbox), handle_box);
1516     gtk_signal_connect (GTK_OBJECT (handle_box),
1517                         "child_attached",
1518                         GTK_SIGNAL_FUNC (handle_box_child_signal),
1519                         "attached");
1520     gtk_signal_connect (GTK_OBJECT (handle_box),
1521                         "child_detached",
1522                         GTK_SIGNAL_FUNC (handle_box_child_signal),
1523                         "detached");
1524     gtk_widget_show (handle_box);
1525
1526     toolbar = make_toolbar (window);
1527     gtk_container_add (GTK_CONTAINER (handle_box), toolbar);
1528     gtk_widget_show (toolbar);
1529
1530     handle_box = gtk_handle_box_new ();
1531     gtk_container_add (GTK_CONTAINER (hbox), handle_box);
1532     gtk_signal_connect (GTK_OBJECT (handle_box),
1533                         "child_attached",
1534                         GTK_SIGNAL_FUNC (handle_box_child_signal),
1535                         "attached");
1536     gtk_signal_connect (GTK_OBJECT (handle_box),
1537                         "child_detached",
1538                         GTK_SIGNAL_FUNC (handle_box_child_signal),
1539                         "detached");
1540     gtk_widget_show (handle_box);
1541
1542     handle_box2 = gtk_handle_box_new ();
1543     gtk_container_add (GTK_CONTAINER (handle_box), handle_box2);
1544     gtk_signal_connect (GTK_OBJECT (handle_box2),
1545                         "child_attached",
1546                         GTK_SIGNAL_FUNC (handle_box_child_signal),
1547                         "attached");
1548     gtk_signal_connect (GTK_OBJECT (handle_box2),
1549                         "child_detached",
1550                         GTK_SIGNAL_FUNC (handle_box_child_signal),
1551                         "detached");
1552     gtk_widget_show (handle_box2);
1553
1554     label = gtk_label_new ("Fooo!");
1555     gtk_container_add (GTK_CONTAINER (handle_box2), label);
1556     gtk_widget_show (label);
1557   }
1558
1559   if (!GTK_WIDGET_VISIBLE (window))
1560     gtk_widget_show (window);
1561   else
1562     gtk_widget_destroy (window);
1563 }
1564
1565
1566 static void
1567 reparent_label (GtkWidget *widget,
1568                 GtkWidget *new_parent)
1569 {
1570   GtkWidget *label;
1571
1572   label = gtk_object_get_user_data (GTK_OBJECT (widget));
1573
1574   gtk_widget_reparent (label, new_parent);
1575 }
1576
1577 static void
1578 set_parent_signal (GtkWidget *child,
1579                    GtkWidget *old_parent,
1580                    gpointer   func_data)
1581 {
1582   g_print ("set_parent for \"%s\": new parent: \"%s\", old parent: \"%s\", data: %d\n",
1583            gtk_type_name (GTK_OBJECT_TYPE (child)),
1584            child->parent ? gtk_type_name (GTK_OBJECT_TYPE (child->parent)) : "NULL",
1585            old_parent ? gtk_type_name (GTK_OBJECT_TYPE (old_parent)) : "NULL",
1586            (gint) func_data);
1587 }
1588
1589 static void
1590 create_reparent ()
1591 {
1592   static GtkWidget *window = NULL;
1593   GtkWidget *box1;
1594   GtkWidget *box2;
1595   GtkWidget *box3;
1596   GtkWidget *frame;
1597   GtkWidget *button;
1598   GtkWidget *label;
1599   GtkWidget *separator;
1600
1601   if (!window)
1602     {
1603       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1604
1605       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1606                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1607                           &window);
1608
1609       gtk_window_set_title (GTK_WINDOW (window), "buttons");
1610       gtk_container_border_width (GTK_CONTAINER (window), 0);
1611
1612
1613       box1 = gtk_vbox_new (FALSE, 0);
1614       gtk_container_add (GTK_CONTAINER (window), box1);
1615       gtk_widget_show (box1);
1616
1617
1618       box2 = gtk_hbox_new (FALSE, 5);
1619       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1620       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1621       gtk_widget_show (box2);
1622
1623
1624       label = gtk_label_new ("Hello World");
1625
1626       frame = gtk_frame_new ("Frame 1");
1627       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
1628       gtk_widget_show (frame);
1629
1630       box3 = gtk_vbox_new (FALSE, 5);
1631       gtk_container_border_width (GTK_CONTAINER (box3), 5);
1632       gtk_container_add (GTK_CONTAINER (frame), box3);
1633       gtk_widget_show (box3);
1634
1635       button = gtk_button_new_with_label ("switch");
1636       gtk_signal_connect (GTK_OBJECT (button), "clicked",
1637                           GTK_SIGNAL_FUNC(reparent_label),
1638                           box3);
1639       gtk_object_set_user_data (GTK_OBJECT (button), label);
1640       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
1641       gtk_widget_show (button);
1642
1643       gtk_box_pack_start (GTK_BOX (box3), label, FALSE, TRUE, 0);
1644       gtk_signal_connect (GTK_OBJECT (label),
1645                           "parent_set",
1646                           GTK_SIGNAL_FUNC (set_parent_signal),
1647                           (GtkObject*) 42);
1648       gtk_widget_show (label);
1649
1650
1651       frame = gtk_frame_new ("Frame 2");
1652       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
1653       gtk_widget_show (frame);
1654
1655       box3 = gtk_vbox_new (FALSE, 5);
1656       gtk_container_border_width (GTK_CONTAINER (box3), 5);
1657       gtk_container_add (GTK_CONTAINER (frame), box3);
1658       gtk_widget_show (box3);
1659
1660       button = gtk_button_new_with_label ("switch");
1661       gtk_signal_connect (GTK_OBJECT (button), "clicked",
1662                           GTK_SIGNAL_FUNC(reparent_label),
1663                           box3);
1664       gtk_object_set_user_data (GTK_OBJECT (button), label);
1665       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
1666       gtk_widget_show (button);
1667
1668
1669       separator = gtk_hseparator_new ();
1670       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1671       gtk_widget_show (separator);
1672
1673
1674       box2 = gtk_vbox_new (FALSE, 10);
1675       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1676       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1677       gtk_widget_show (box2);
1678
1679
1680       button = gtk_button_new_with_label ("close");
1681       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1682                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1683                                  GTK_OBJECT (window));
1684       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1685       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1686       gtk_widget_grab_default (button);
1687       gtk_widget_show (button);
1688     }
1689
1690   if (!GTK_WIDGET_VISIBLE (window))
1691     gtk_widget_show (window);
1692   else
1693     gtk_widget_destroy (window);
1694 }
1695
1696 static void
1697 create_pixmap ()
1698 {
1699   static GtkWidget *window = NULL;
1700   GtkWidget *box1;
1701   GtkWidget *box2;
1702   GtkWidget *box3;
1703   GtkWidget *button;
1704   GtkWidget *label;
1705   GtkWidget *separator;
1706   GtkWidget *pixmapwid;
1707   GdkPixmap *pixmap;
1708   GdkBitmap *mask;
1709   GtkStyle *style;
1710
1711   if (!window)
1712     {
1713       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1714
1715       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1716                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1717                           &window);
1718
1719       gtk_window_set_title (GTK_WINDOW (window), "pixmap");
1720       gtk_container_border_width (GTK_CONTAINER (window), 0);
1721       gtk_widget_realize(window);
1722
1723       box1 = gtk_vbox_new (FALSE, 0);
1724       gtk_container_add (GTK_CONTAINER (window), box1);
1725       gtk_widget_show (box1);
1726
1727       box2 = gtk_vbox_new (FALSE, 10);
1728       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1729       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1730       gtk_widget_show (box2);
1731
1732       button = gtk_button_new ();
1733       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
1734       gtk_widget_show (button);
1735
1736       style=gtk_widget_get_style(button);
1737
1738       pixmap = gdk_pixmap_create_from_xpm (window->window, &mask,
1739                                            &style->bg[GTK_STATE_NORMAL],
1740                                            "test.xpm");
1741       pixmapwid = gtk_pixmap_new (pixmap, mask);
1742
1743       label = gtk_label_new ("Pixmap\ntest");
1744       box3 = gtk_hbox_new (FALSE, 0);
1745       gtk_container_border_width (GTK_CONTAINER (box3), 2);
1746       gtk_container_add (GTK_CONTAINER (box3), pixmapwid);
1747       gtk_container_add (GTK_CONTAINER (box3), label);
1748       gtk_container_add (GTK_CONTAINER (button), box3);
1749       gtk_widget_show (pixmapwid);
1750       gtk_widget_show (label);
1751       gtk_widget_show (box3);
1752
1753       separator = gtk_hseparator_new ();
1754       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1755       gtk_widget_show (separator);
1756
1757
1758       box2 = gtk_vbox_new (FALSE, 10);
1759       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1760       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1761       gtk_widget_show (box2);
1762
1763
1764       button = gtk_button_new_with_label ("close");
1765       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1766                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1767                                  GTK_OBJECT (window));
1768       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1769       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1770       gtk_widget_grab_default (button);
1771       gtk_widget_show (button);
1772     }
1773
1774   if (!GTK_WIDGET_VISIBLE (window))
1775     gtk_widget_show (window);
1776   else
1777     gtk_widget_destroy (window);
1778 }
1779
1780 static void
1781 tips_query_widget_entered (GtkTipsQuery   *tips_query,
1782                            GtkWidget      *widget,
1783                            const gchar    *tip_text,
1784                            const gchar    *tip_private,
1785                            GtkWidget      *toggle)
1786 {
1787   if (GTK_TOGGLE_BUTTON (toggle)->active)
1788     {
1789       gtk_label_set (GTK_LABEL (tips_query), tip_text ? "There is a Tip!" : "There is no Tip!");
1790       /* don't let GtkTipsQuery reset it's label */
1791       gtk_signal_emit_stop_by_name (GTK_OBJECT (tips_query), "widget_entered");
1792     }
1793 }
1794
1795 static gint
1796 tips_query_widget_selected (GtkWidget      *tips_query,
1797                             GtkWidget      *widget,
1798                             const gchar    *tip_text,
1799                             const gchar    *tip_private,
1800                             GdkEventButton *event,
1801                             gpointer        func_data)
1802 {
1803   if (widget)
1804     g_print ("Help \"%s\" requested for <%s>\n",
1805              tip_private ? tip_private : "None",
1806              gtk_type_name (GTK_OBJECT_TYPE (widget)));
1807
1808   return TRUE;
1809 }
1810
1811 static void
1812 create_tooltips ()
1813 {
1814   static GtkWidget *window = NULL;
1815   GtkWidget *box1;
1816   GtkWidget *box2;
1817   GtkWidget *box3;
1818   GtkWidget *button;
1819   GtkWidget *toggle;
1820   GtkWidget *frame;
1821   GtkWidget *tips_query;
1822   GtkWidget *separator;
1823   GtkTooltips *tooltips;
1824
1825   if (!window)
1826     {
1827       window =
1828         gtk_widget_new (gtk_window_get_type (),
1829                         "GtkWindow::type", GTK_WINDOW_TOPLEVEL,
1830                         "GtkContainer::border_width", 0,
1831                         "GtkWindow::title", "Tooltips",
1832                         "GtkWindow::allow_shrink", TRUE,
1833                         "GtkWindow::allow_grow", FALSE,
1834                         "GtkWindow::auto_shrink", TRUE,
1835                         "GtkWidget::width", 200,
1836                         NULL);
1837
1838       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1839                           GTK_SIGNAL_FUNC (destroy_tooltips),
1840                           &window);
1841
1842       tooltips=gtk_tooltips_new();
1843       gtk_object_set_data (GTK_OBJECT (window), "tooltips", tooltips);
1844
1845       box1 = gtk_vbox_new (FALSE, 0);
1846       gtk_container_add (GTK_CONTAINER (window), box1);
1847       gtk_widget_show (box1);
1848
1849
1850       box2 = gtk_vbox_new (FALSE, 10);
1851       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1852       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1853       gtk_widget_show (box2);
1854
1855
1856       button = gtk_toggle_button_new_with_label ("button1");
1857       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1858       gtk_widget_show (button);
1859
1860       gtk_tooltips_set_tip (tooltips,button,"This is button 1", "ContextHelp/buttons/1");
1861
1862       button = gtk_toggle_button_new_with_label ("button2");
1863       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1864       gtk_widget_show (button);
1865
1866       gtk_tooltips_set_tip (tooltips,
1867                             button,
1868                             "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.",
1869                             "ContextHelp/buttons/2_long");
1870
1871       toggle = gtk_toggle_button_new_with_label ("Override TipsQuery Label");
1872       gtk_box_pack_start (GTK_BOX (box2), toggle, TRUE, TRUE, 0);
1873       gtk_widget_show (toggle);
1874
1875       gtk_tooltips_set_tip (tooltips, toggle, "Toggle TipsQuery view.", "Hi msw! ;)");
1876
1877       box3 =
1878         gtk_widget_new (gtk_vbox_get_type (),
1879                         "GtkBox::homogeneous", FALSE,
1880                         "GtkBox::spacing", 5,
1881                         "GtkContainer::border_width", 5,
1882                         "GtkWidget::visible", TRUE,
1883                         NULL);
1884
1885       tips_query = gtk_tips_query_new ();
1886
1887       button =
1888         gtk_widget_new (gtk_button_get_type (),
1889                         "GtkButton::label", "[?]",
1890                         "GtkWidget::visible", TRUE,
1891                         "GtkWidget::parent", box3,
1892                         "GtkObject::object_signal::clicked", gtk_tips_query_start_query, tips_query,
1893                         NULL);
1894       gtk_box_set_child_packing (GTK_BOX (box3), button, FALSE, FALSE, 0, GTK_PACK_START);
1895       gtk_tooltips_set_tip (tooltips,
1896                             button,
1897                             "Start the Tooltips Inspector",
1898                             "ContextHelp/buttons/?");
1899
1900
1901       gtk_widget_set (tips_query,
1902                       "GtkWidget::visible", TRUE,
1903                       "GtkWidget::parent", box3,
1904                       "GtkTipsQuery::caller", button,
1905                       "GtkObject::signal::widget_entered", tips_query_widget_entered, toggle,
1906                       "GtkObject::signal::widget_selected", tips_query_widget_selected, NULL,
1907                       NULL);
1908
1909       frame =
1910         gtk_widget_new (gtk_frame_get_type (),
1911                         "GtkFrame::label", "ToolTips Inspector",
1912                         "GtkFrame::label_xalign", (double) 0.5,
1913                         "GtkContainer::border_width", 0,
1914                         "GtkWidget::visible", TRUE,
1915                         "GtkWidget::parent", box2,
1916                         "GtkContainer::child", box3,
1917                         NULL);
1918       gtk_box_set_child_packing (GTK_BOX (box2), frame, TRUE, TRUE, 10, GTK_PACK_START);
1919
1920       separator = gtk_hseparator_new ();
1921       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1922       gtk_widget_show (separator);
1923
1924
1925       box2 = gtk_vbox_new (FALSE, 10);
1926       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1927       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1928       gtk_widget_show (box2);
1929
1930
1931       button = gtk_button_new_with_label ("close");
1932       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1933                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1934                                  GTK_OBJECT (window));
1935       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1936       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1937       gtk_widget_grab_default (button);
1938       gtk_widget_show (button);
1939
1940       gtk_tooltips_set_tip (tooltips, button, "Push this button to close window", "ContextHelp/buttons/Close");
1941     }
1942
1943   if (!GTK_WIDGET_VISIBLE (window))
1944     gtk_widget_show (window);
1945   else
1946     gtk_widget_destroy (window);
1947 }
1948
1949 static GtkWidget*
1950 create_menu (int depth)
1951 {
1952   GtkWidget *menu;
1953   GtkWidget *menuitem;
1954   GSList *group;
1955   char buf[32];
1956   int i, j;
1957
1958   if (depth < 1)
1959     return NULL;
1960
1961   menu = gtk_menu_new ();
1962   group = NULL;
1963
1964   for (i = 0, j = 1; i < 5; i++, j++)
1965     {
1966       sprintf (buf, "item %2d - %d", depth, j);
1967       menuitem = gtk_radio_menu_item_new_with_label (group, buf);
1968       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
1969       if (depth % 2)
1970         gtk_check_menu_item_set_show_toggle (GTK_CHECK_MENU_ITEM (menuitem), TRUE);
1971       gtk_menu_append (GTK_MENU (menu), menuitem);
1972       gtk_widget_show (menuitem);
1973       if (i == 3)
1974         gtk_widget_set_sensitive (menuitem, FALSE);
1975
1976       gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (depth - 1));
1977     }
1978
1979   return menu;
1980 }
1981
1982 static void
1983 create_menus ()
1984 {
1985   static GtkWidget *window = NULL;
1986   GtkWidget *box1;
1987   GtkWidget *box2;
1988   GtkWidget *button;
1989   GtkWidget *menu;
1990   GtkWidget *menubar;
1991   GtkWidget *menuitem;
1992   GtkWidget *optionmenu;
1993   GtkWidget *separator;
1994
1995   if (!window)
1996     {
1997       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1998
1999       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2000                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2001                           &window);
2002       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2003                           GTK_SIGNAL_FUNC (gtk_true),
2004                           NULL);
2005
2006       gtk_window_set_title (GTK_WINDOW (window), "menus");
2007       gtk_container_border_width (GTK_CONTAINER (window), 0);
2008
2009
2010       box1 = gtk_vbox_new (FALSE, 0);
2011       gtk_container_add (GTK_CONTAINER (window), box1);
2012       gtk_widget_show (box1);
2013
2014
2015       menubar = gtk_menu_bar_new ();
2016       gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
2017       gtk_widget_show (menubar);
2018
2019       menu = create_menu (2);
2020
2021       menuitem = gtk_menu_item_new_with_label ("test\nline2");
2022       gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
2023       gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2024       gtk_widget_show (menuitem);
2025
2026       menuitem = gtk_menu_item_new_with_label ("foo");
2027       gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (3));
2028       gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2029       gtk_widget_show (menuitem);
2030
2031       menuitem = gtk_menu_item_new_with_label ("bar");
2032       gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4));
2033       gtk_menu_item_right_justify (GTK_MENU_ITEM (menuitem));
2034       gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2035       gtk_widget_show (menuitem);
2036
2037
2038       box2 = gtk_vbox_new (FALSE, 10);
2039       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2040       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2041       gtk_widget_show (box2);
2042
2043
2044       optionmenu = gtk_option_menu_new ();
2045       gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), create_menu (1));
2046       gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu), 4);
2047       gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0);
2048       gtk_widget_show (optionmenu);
2049
2050
2051       separator = gtk_hseparator_new ();
2052       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2053       gtk_widget_show (separator);
2054
2055
2056       box2 = gtk_vbox_new (FALSE, 10);
2057       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2058       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2059       gtk_widget_show (box2);
2060
2061
2062       button = gtk_button_new_with_label ("close");
2063       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2064                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2065                                  GTK_OBJECT (window));
2066       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2067       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2068       gtk_widget_grab_default (button);
2069       gtk_widget_show (button);
2070     }
2071
2072   if (!GTK_WIDGET_VISIBLE (window))
2073     gtk_widget_show (window);
2074   else
2075     gtk_widget_destroy (window);
2076 }
2077
2078 /*
2079  * GtkScrolledWindow
2080  */
2081 static void
2082 create_scrolled_windows ()
2083 {
2084   static GtkWidget *window;
2085   GtkWidget *scrolled_window;
2086   GtkWidget *table;
2087   GtkWidget *button;
2088   char buffer[32];
2089   int i, j;
2090
2091   if (!window)
2092     {
2093       window = gtk_dialog_new ();
2094
2095       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2096                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2097                           &window);
2098
2099       gtk_window_set_title (GTK_WINDOW (window), "dialog");
2100       gtk_container_border_width (GTK_CONTAINER (window), 0);
2101
2102
2103       scrolled_window = gtk_scrolled_window_new (NULL, NULL);
2104       gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
2105       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
2106                                       GTK_POLICY_AUTOMATIC,
2107                                       GTK_POLICY_AUTOMATIC);
2108       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
2109                           scrolled_window, TRUE, TRUE, 0);
2110       gtk_widget_show (scrolled_window);
2111
2112       table = gtk_table_new (20, 20, FALSE);
2113       gtk_table_set_row_spacings (GTK_TABLE (table), 10);
2114       gtk_table_set_col_spacings (GTK_TABLE (table), 10);
2115       gtk_container_add (GTK_CONTAINER (scrolled_window), table);
2116       gtk_widget_show (table);
2117
2118       for (i = 0; i < 20; i++)
2119         for (j = 0; j < 20; j++)
2120           {
2121             sprintf (buffer, "button (%d,%d)\n", i, j);
2122             button = gtk_toggle_button_new_with_label (buffer);
2123             gtk_table_attach_defaults (GTK_TABLE (table), button,
2124                                        i, i+1, j, j+1);
2125             gtk_widget_show (button);
2126           }
2127
2128
2129       button = gtk_button_new_with_label ("close");
2130       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2131                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2132                                  GTK_OBJECT (window));
2133       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2134       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
2135                           button, TRUE, TRUE, 0);
2136       gtk_widget_grab_default (button);
2137       gtk_widget_show (button);
2138     }
2139
2140   if (!GTK_WIDGET_VISIBLE (window))
2141     gtk_widget_show (window);
2142   else
2143     gtk_widget_destroy (window);
2144 }
2145
2146 /*
2147  * GtkEntry
2148  */
2149
2150 static void
2151 entry_toggle_editable (GtkWidget *checkbutton,
2152                        GtkWidget *entry)
2153 {
2154    gtk_entry_set_editable(GTK_ENTRY(entry),
2155                           GTK_TOGGLE_BUTTON(checkbutton)->active);
2156 }
2157
2158 static void
2159 create_entry ()
2160 {
2161   static GtkWidget *window = NULL;
2162   GtkWidget *box1;
2163   GtkWidget *box2;
2164   GtkWidget *editable_check;
2165   GtkWidget *entry, *cb;
2166   GtkWidget *button;
2167   GtkWidget *separator;
2168   GList *cbitems = NULL;
2169
2170   if (!window)
2171     {
2172       cbitems = g_list_append(cbitems, "item0");
2173       cbitems = g_list_append(cbitems, "item1 item1");
2174       cbitems = g_list_append(cbitems, "item2 item2 item2");
2175       cbitems = g_list_append(cbitems, "item3 item3 item3 item3");
2176       cbitems = g_list_append(cbitems, "item4 item4 item4 item4 item4");
2177       cbitems = g_list_append(cbitems, "item5 item5 item5 item5 item5 item5");
2178       cbitems = g_list_append(cbitems, "item6 item6 item6 item6 item6");
2179       cbitems = g_list_append(cbitems, "item7 item7 item7 item7");
2180       cbitems = g_list_append(cbitems, "item8 item8 item8");
2181       cbitems = g_list_append(cbitems, "item9 item9");
2182
2183       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2184
2185       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2186                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2187                           &window);
2188
2189       gtk_window_set_title (GTK_WINDOW (window), "entry");
2190       gtk_container_border_width (GTK_CONTAINER (window), 0);
2191
2192
2193       box1 = gtk_vbox_new (FALSE, 0);
2194       gtk_container_add (GTK_CONTAINER (window), box1);
2195       gtk_widget_show (box1);
2196
2197
2198       box2 = gtk_vbox_new (FALSE, 10);
2199       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2200       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2201       gtk_widget_show (box2);
2202
2203       entry = gtk_entry_new ();
2204       gtk_entry_set_text (GTK_ENTRY (entry), "hello world");
2205       gtk_editable_select_region (GTK_EDITABLE (entry), 0, -1);
2206       gtk_box_pack_start (GTK_BOX (box2), entry, TRUE, TRUE, 0);
2207       gtk_widget_show (entry);
2208
2209       cb = gtk_combo_new ();
2210       gtk_combo_set_popdown_strings (GTK_COMBO (cb), cbitems);
2211       gtk_entry_set_text (GTK_ENTRY (GTK_COMBO(cb)->entry), "hello world");
2212       gtk_editable_select_region (GTK_EDITABLE (GTK_COMBO(cb)->entry),
2213                                   0, -1);
2214       gtk_box_pack_start (GTK_BOX (box2), cb, TRUE, TRUE, 0);
2215       gtk_widget_show (cb);
2216
2217       editable_check = gtk_check_button_new_with_label("Editable");
2218       gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
2219       gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
2220                           GTK_SIGNAL_FUNC(entry_toggle_editable), entry);
2221       gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE);
2222       gtk_widget_show (editable_check);
2223
2224       separator = gtk_hseparator_new ();
2225       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2226       gtk_widget_show (separator);
2227
2228
2229       box2 = gtk_vbox_new (FALSE, 10);
2230       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2231       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2232       gtk_widget_show (box2);
2233
2234
2235       button = gtk_button_new_with_label ("close");
2236       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2237                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2238                                  GTK_OBJECT (window));
2239       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2240       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2241       gtk_widget_grab_default (button);
2242       gtk_widget_show (button);
2243     }
2244
2245   if (!GTK_WIDGET_VISIBLE (window))
2246     gtk_widget_show (window);
2247   else
2248     gtk_widget_destroy (window);
2249 }
2250
2251 /*
2252  * GtkSpinButton
2253  */
2254
2255 static GtkWidget *spinner1;
2256
2257 static void
2258 toggle_snap (GtkWidget *widget, GtkSpinButton *spin)
2259 {
2260   if (GTK_TOGGLE_BUTTON (widget)->active)
2261     gtk_spin_button_set_update_policy (spin, GTK_UPDATE_ALWAYS
2262                                        | GTK_UPDATE_SNAP_TO_TICKS);
2263   else
2264     gtk_spin_button_set_update_policy (spin, GTK_UPDATE_ALWAYS);
2265 }
2266
2267 static void
2268 toggle_numeric (GtkWidget *widget, GtkSpinButton *spin)
2269 {
2270   gtk_spin_button_set_numeric (spin, GTK_TOGGLE_BUTTON (widget)->active);
2271 }
2272
2273 static void
2274 change_digits (GtkWidget *widget, GtkSpinButton *spin)
2275 {
2276   gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spinner1),
2277                               gtk_spin_button_get_value_as_int (spin));
2278 }
2279
2280 static void
2281 get_value (GtkWidget *widget, gint data)
2282 {
2283   gchar buf[32];
2284   GtkLabel *label;
2285   GtkSpinButton *spin;
2286
2287   spin = GTK_SPIN_BUTTON (spinner1);
2288   label = GTK_LABEL (gtk_object_get_user_data (GTK_OBJECT (widget)));
2289   if (data == 1)
2290     sprintf (buf, "%d", gtk_spin_button_get_value_as_int (spin));
2291   else
2292     sprintf (buf, "%0.*f", spin->digits,
2293              gtk_spin_button_get_value_as_float (spin));
2294   gtk_label_set (label, buf);
2295 }
2296
2297 static void
2298 create_spins ()
2299 {
2300   static GtkWidget *window = NULL;
2301   GtkWidget *frame;
2302   GtkWidget *hbox;
2303   GtkWidget *main_vbox;
2304   GtkWidget *vbox;
2305   GtkWidget *vbox2;
2306   GtkWidget *spinner2;
2307   GtkWidget *spinner;
2308   GtkWidget *button;
2309   GtkWidget *label;
2310   GtkWidget *val_label;
2311   GtkAdjustment *adj;
2312
2313   if (!window)
2314     {
2315       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2316
2317       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2318                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
2319                           &window);
2320
2321       gtk_window_set_title (GTK_WINDOW (window), "GtkSpinButton");
2322
2323       main_vbox = gtk_vbox_new (FALSE, 5);
2324       gtk_container_border_width (GTK_CONTAINER (main_vbox), 10);
2325       gtk_container_add (GTK_CONTAINER (window), main_vbox);
2326
2327       frame = gtk_frame_new ("Not accelerated");
2328       gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
2329
2330       vbox = gtk_vbox_new (FALSE, 0);
2331       gtk_container_border_width (GTK_CONTAINER (vbox), 5);
2332       gtk_container_add (GTK_CONTAINER (frame), vbox);
2333
2334       /* Day, month, year spinners */
2335
2336       hbox = gtk_hbox_new (FALSE, 0);
2337       gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
2338
2339       vbox2 = gtk_vbox_new (FALSE, 0);
2340       gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2341
2342       label = gtk_label_new ("Day :");
2343       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2344       gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2345
2346       adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 31.0, 1.0,
2347                                                   5.0, 0.0);
2348       spinner = gtk_spin_button_new (adj, 0, 0);
2349       gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
2350       gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2351
2352       vbox2 = gtk_vbox_new (FALSE, 0);
2353       gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2354
2355       label = gtk_label_new ("Month :");
2356       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2357       gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2358
2359       adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 12.0, 1.0,
2360                                                   5.0, 0.0);
2361       spinner = gtk_spin_button_new (adj, 0, 0);
2362       gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
2363       gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2364
2365       vbox2 = gtk_vbox_new (FALSE, 0);
2366       gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2367
2368       label = gtk_label_new ("Year :");
2369       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2370       gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2371
2372       adj = (GtkAdjustment *) gtk_adjustment_new (1998.0, 0.0, 2100.0,
2373                                                   1.0, 100.0, 0.0);
2374       spinner = gtk_spin_button_new (adj, 0, 0);
2375       gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
2376       gtk_widget_set_usize (spinner, 55, 0);
2377       gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2378
2379       frame = gtk_frame_new ("Accelerated");
2380       gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
2381
2382       vbox = gtk_vbox_new (FALSE, 0);
2383       gtk_container_border_width (GTK_CONTAINER (vbox), 5);
2384       gtk_container_add (GTK_CONTAINER (frame), vbox);
2385
2386       hbox = gtk_hbox_new (FALSE, 0);
2387       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2388
2389       vbox2 = gtk_vbox_new (FALSE, 0);
2390       gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2391
2392       label = gtk_label_new ("Value :");
2393       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2394       gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2395
2396       adj = (GtkAdjustment *) gtk_adjustment_new (0.0, -10000.0, 10000.0,
2397                                                   0.5, 100.0, 0.0);
2398       spinner1 = gtk_spin_button_new (adj, 1.0, 2);
2399       gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner1), TRUE);
2400       gtk_widget_set_usize (spinner1, 100, 0);
2401       gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (spinner1),
2402                                          GTK_UPDATE_ALWAYS);
2403       gtk_box_pack_start (GTK_BOX (vbox2), spinner1, FALSE, TRUE, 0);
2404
2405       vbox2 = gtk_vbox_new (FALSE, 0);
2406       gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2407
2408       label = gtk_label_new ("Digits :");
2409       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2410       gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2411
2412       adj = (GtkAdjustment *) gtk_adjustment_new (2, 1, 5, 1, 1, 0);
2413       spinner2 = gtk_spin_button_new (adj, 0.0, 0);
2414       gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner2), TRUE);
2415       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
2416                           GTK_SIGNAL_FUNC (change_digits),
2417                           (gpointer) spinner2);
2418       gtk_box_pack_start (GTK_BOX (vbox2), spinner2, FALSE, TRUE, 0);
2419
2420       hbox = gtk_hbox_new (FALSE, 0);
2421       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2422
2423       button = gtk_check_button_new_with_label ("Snap to 0.5-ticks");
2424       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2425                           GTK_SIGNAL_FUNC (toggle_snap),
2426                           spinner1);
2427       gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
2428       gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
2429
2430       button = gtk_check_button_new_with_label ("Numeric only input mode");
2431       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2432                           GTK_SIGNAL_FUNC (toggle_numeric),
2433                           spinner1);
2434       gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
2435       gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
2436
2437       val_label = gtk_label_new ("");
2438
2439       hbox = gtk_hbox_new (FALSE, 0);
2440       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2441
2442       button = gtk_button_new_with_label ("Value as Int");
2443       gtk_object_set_user_data (GTK_OBJECT (button), val_label);
2444       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2445                           GTK_SIGNAL_FUNC (get_value),
2446                           (gpointer) 1);
2447       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2448
2449       button = gtk_button_new_with_label ("Value as Float");
2450       gtk_object_set_user_data (GTK_OBJECT (button), val_label);
2451       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2452                           GTK_SIGNAL_FUNC (get_value),
2453                           (gpointer) 2);
2454       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2455
2456       gtk_box_pack_start (GTK_BOX (vbox), val_label, TRUE, TRUE, 0);
2457       gtk_label_set (GTK_LABEL (val_label), "0");
2458
2459       hbox = gtk_hbox_new (FALSE, 0);
2460       gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
2461
2462       button = gtk_button_new_with_label ("Close");
2463       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2464                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
2465                                  GTK_OBJECT (window));
2466       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2467     }
2468
2469   if (!GTK_WIDGET_VISIBLE (window))
2470     gtk_widget_show_all (window);
2471   else
2472     gtk_widget_destroy (window);
2473 }
2474
2475 /*
2476  * Cursors
2477  */
2478
2479 static gint
2480 cursor_expose_event (GtkWidget *widget,
2481                      GdkEvent  *event,
2482                      gpointer   user_data)
2483 {
2484   GtkDrawingArea *darea;
2485   GdkDrawable *drawable;
2486   GdkGC *black_gc;
2487   GdkGC *gray_gc;
2488   GdkGC *white_gc;
2489   guint max_width;
2490   guint max_height;
2491
2492   g_return_val_if_fail (widget != NULL, TRUE);
2493   g_return_val_if_fail (GTK_IS_DRAWING_AREA (widget), TRUE);
2494
2495   darea = GTK_DRAWING_AREA (widget);
2496   drawable = widget->window;
2497   white_gc = widget->style->white_gc;
2498   gray_gc = widget->style->bg_gc[GTK_STATE_NORMAL];
2499   black_gc = widget->style->black_gc;
2500   max_width = widget->allocation.width;
2501   max_height = widget->allocation.height;
2502
2503   gdk_draw_rectangle (drawable, white_gc,
2504                       TRUE,
2505                       0,
2506                       0,
2507                       max_width,
2508                       max_height / 2);
2509
2510   gdk_draw_rectangle (drawable, black_gc,
2511                       TRUE,
2512                       0,
2513                       max_height / 2,
2514                       max_width,
2515                       max_height / 2);
2516
2517   gdk_draw_rectangle (drawable, gray_gc,
2518                       TRUE,
2519                       max_width / 3,
2520                       max_height / 3,
2521                       max_width / 3,
2522                       max_height / 3);
2523
2524   return TRUE;
2525 }
2526
2527 static void
2528 set_cursor (GtkWidget *spinner,
2529             GtkWidget *widget)
2530 {
2531   guint c;
2532   GdkCursor *cursor;
2533
2534   c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152);
2535   c &= 0xfe;
2536
2537   cursor = gdk_cursor_new (c);
2538   gdk_window_set_cursor (widget->window, cursor);
2539   gdk_cursor_destroy (cursor);
2540 }
2541
2542 static gint
2543 cursor_event (GtkWidget          *widget,
2544               GdkEvent           *event,
2545               GtkSpinButton      *spinner)
2546 {
2547   if ((event->type == GDK_BUTTON_PRESS) &&
2548       ((event->button.button == 1) ||
2549        (event->button.button == 3)))
2550     {
2551       gtk_spin_button_spin (spinner,
2552                             event->button.button == 1 ? GTK_ARROW_UP : GTK_ARROW_DOWN,
2553                             spinner->adjustment->step_increment);
2554       return TRUE;
2555     }
2556
2557   return FALSE;
2558 }
2559
2560 static void
2561 create_cursors ()
2562 {
2563   static GtkWidget *window = NULL;
2564   GtkWidget *frame;
2565   GtkWidget *hbox;
2566   GtkWidget *main_vbox;
2567   GtkWidget *vbox;
2568   GtkWidget *darea;
2569   GtkWidget *spinner;
2570   GtkWidget *button;
2571   GtkWidget *label;
2572   GtkWidget *any;
2573   GtkAdjustment *adj;
2574
2575   if (!window)
2576     {
2577       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2578
2579       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2580                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
2581                           &window);
2582
2583       gtk_window_set_title (GTK_WINDOW (window), "Cursors");
2584
2585       main_vbox = gtk_vbox_new (FALSE, 5);
2586       gtk_container_border_width (GTK_CONTAINER (main_vbox), 0);
2587       gtk_container_add (GTK_CONTAINER (window), main_vbox);
2588
2589       vbox =
2590         gtk_widget_new (gtk_vbox_get_type (),
2591                         "GtkBox::homogeneous", FALSE,
2592                         "GtkBox::spacing", 5,
2593                         "GtkContainer::border_width", 10,
2594                         "GtkWidget::parent", main_vbox,
2595                         "GtkWidget::visible", TRUE,
2596                         NULL);
2597
2598       hbox = gtk_hbox_new (FALSE, 0);
2599       gtk_container_border_width (GTK_CONTAINER (hbox), 5);
2600       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
2601
2602       label = gtk_label_new ("Cursor Value:");
2603       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2604       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
2605
2606       adj = (GtkAdjustment *) gtk_adjustment_new (0,
2607                                                   0, 152,
2608                                                   2,
2609                                                   10, 0);
2610       spinner = gtk_spin_button_new (adj, 0, 0);
2611       gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 0);
2612
2613       frame =
2614         gtk_widget_new (gtk_frame_get_type (),
2615                         "GtkFrame::shadow", GTK_SHADOW_ETCHED_IN,
2616                         "GtkFrame::label_xalign", 0.5,
2617                         "GtkFrame::label", "Cursor Area",
2618                         "GtkContainer::border_width", 10,
2619                         "GtkWidget::parent", vbox,
2620                         "GtkWidget::visible", TRUE,
2621                         NULL);
2622
2623       darea = gtk_drawing_area_new ();
2624       gtk_widget_set_usize (darea, 80, 80);
2625       gtk_container_add (GTK_CONTAINER (frame), darea);
2626       gtk_signal_connect (GTK_OBJECT (darea),
2627                           "expose_event",
2628                           GTK_SIGNAL_FUNC (cursor_expose_event),
2629                           NULL);
2630       gtk_widget_set_events (darea, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
2631       gtk_signal_connect (GTK_OBJECT (darea),
2632                           "button_press_event",
2633                           GTK_SIGNAL_FUNC (cursor_event),
2634                           spinner);
2635       gtk_widget_show (darea);
2636
2637       gtk_signal_connect (GTK_OBJECT (spinner), "changed",
2638                           GTK_SIGNAL_FUNC (set_cursor),
2639                           darea);
2640
2641       any =
2642         gtk_widget_new (gtk_hseparator_get_type (),
2643                         "GtkWidget::visible", TRUE,
2644                         NULL);
2645       gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
2646
2647       hbox = gtk_hbox_new (FALSE, 0);
2648       gtk_container_border_width (GTK_CONTAINER (hbox), 10);
2649       gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
2650
2651       button = gtk_button_new_with_label ("Close");
2652       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2653                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
2654                                  GTK_OBJECT (window));
2655       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2656
2657       gtk_widget_show_all (window);
2658
2659       set_cursor (spinner, darea);
2660     }
2661   else
2662     gtk_widget_destroy (window);
2663 }
2664
2665 /*
2666  * GtkList
2667  */
2668 static void
2669 list_add (GtkWidget *widget,
2670           GtkWidget *list)
2671 {
2672   static int i = 1;
2673   gchar buffer[64];
2674   GtkWidget *list_item;
2675
2676   sprintf (buffer, "added item %d", i++);
2677   list_item = gtk_list_item_new_with_label (buffer);
2678   gtk_widget_show (list_item);
2679   gtk_container_add (GTK_CONTAINER (list), list_item);
2680 }
2681
2682 static void
2683 list_remove (GtkWidget *widget,
2684              GtkWidget *list)
2685 {
2686   GList *tmp_list;
2687   GList *clear_list;
2688
2689   tmp_list = GTK_LIST (list)->selection;
2690   clear_list = NULL;
2691
2692   while (tmp_list)
2693     {
2694       clear_list = g_list_prepend (clear_list, tmp_list->data);
2695       tmp_list = tmp_list->next;
2696     }
2697
2698   clear_list = g_list_reverse (clear_list);
2699
2700   gtk_list_remove_items (GTK_LIST (list), clear_list);
2701
2702   g_list_free (clear_list);
2703 }
2704
2705 static void
2706 list_clear (GtkWidget *widget,
2707             GtkWidget *list)
2708 {
2709   gtk_list_clear_items (GTK_LIST (list), 3 - 1, 5 - 1);
2710 }
2711
2712 static void
2713 create_list ()
2714 {
2715   static GtkWidget *window = NULL;
2716   static char *list_items[] =
2717   {
2718     "hello",
2719     "world",
2720     "blah",
2721     "foo",
2722     "bar",
2723     "argh",
2724     "spencer",
2725     "is a",
2726     "wussy",
2727     "programmer",
2728   };
2729   static int nlist_items = sizeof (list_items) / sizeof (list_items[0]);
2730
2731   GtkWidget *box1;
2732   GtkWidget *box2;
2733   GtkWidget *scrolled_win;
2734   GtkWidget *list;
2735   GtkWidget *list_item;
2736   GtkWidget *button;
2737   GtkWidget *separator;
2738   int i;
2739
2740   if (!window)
2741     {
2742       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2743
2744       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2745                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2746                           &window);
2747
2748       gtk_window_set_title (GTK_WINDOW (window), "list");
2749       gtk_container_border_width (GTK_CONTAINER (window), 0);
2750
2751
2752       box1 = gtk_vbox_new (FALSE, 0);
2753       gtk_container_add (GTK_CONTAINER (window), box1);
2754       gtk_widget_show (box1);
2755
2756
2757       box2 = gtk_vbox_new (FALSE, 10);
2758       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2759       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2760       gtk_widget_show (box2);
2761
2762
2763       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
2764       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
2765                                       GTK_POLICY_AUTOMATIC,
2766                                       GTK_POLICY_AUTOMATIC);
2767       gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
2768       gtk_widget_show (scrolled_win);
2769
2770       list = gtk_list_new ();
2771       gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_MULTIPLE);
2772       gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_BROWSE);
2773       gtk_container_add (GTK_CONTAINER (scrolled_win), list);
2774       gtk_widget_show (list);
2775
2776       for (i = 0; i < nlist_items; i++)
2777         {
2778           list_item = gtk_list_item_new_with_label (list_items[i]);
2779           gtk_container_add (GTK_CONTAINER (list), list_item);
2780           gtk_widget_show (list_item);
2781         }
2782
2783       button = gtk_button_new_with_label ("add");
2784       GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
2785       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2786                           GTK_SIGNAL_FUNC(list_add),
2787                           list);
2788       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
2789       gtk_widget_show (button);
2790
2791       button = gtk_button_new_with_label ("clear items 3 - 5");
2792       GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
2793       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2794                           GTK_SIGNAL_FUNC(list_clear),
2795                           list);
2796       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
2797       gtk_widget_show (button);
2798
2799       button = gtk_button_new_with_label ("remove");
2800       GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
2801       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2802                           GTK_SIGNAL_FUNC(list_remove),
2803                           list);
2804       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
2805       gtk_widget_show (button);
2806
2807
2808       separator = gtk_hseparator_new ();
2809       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2810       gtk_widget_show (separator);
2811
2812
2813       box2 = gtk_vbox_new (FALSE, 10);
2814       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2815       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2816       gtk_widget_show (box2);
2817
2818
2819       button = gtk_button_new_with_label ("close");
2820       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2821                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2822                                  GTK_OBJECT (window));
2823       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2824       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2825       gtk_widget_grab_default (button);
2826       gtk_widget_show (button);
2827     }
2828
2829   if (!GTK_WIDGET_VISIBLE (window))
2830     gtk_widget_show (window);
2831   else
2832     gtk_widget_destroy (window);
2833 }
2834
2835 /*
2836  * GtkCList
2837  */
2838 #define TESTGTK_CLIST_COLUMNS 7
2839 static gint clist_rows = 0;
2840 static gint clist_selected_row = 0;
2841
2842 static void
2843 add1000_clist (GtkWidget *widget, gpointer data)
2844 {
2845   gint i, row;
2846   char text[TESTGTK_CLIST_COLUMNS][50];
2847   char *texts[TESTGTK_CLIST_COLUMNS];
2848   GdkBitmap *mask;
2849   GdkPixmap *pixmap;
2850
2851   pixmap = gdk_pixmap_create_from_xpm (GTK_CLIST (data)->clist_window,
2852                                        &mask,
2853                                        &GTK_WIDGET (data)->style->white,
2854                                        "test.xpm");
2855
2856   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
2857     {
2858       texts[i] = text[i];
2859       sprintf (text[i], "Column %d", i);
2860     }
2861
2862   texts[3] = NULL;
2863   sprintf (text[1], "Right");
2864   sprintf (text[2], "Center");
2865
2866   gtk_clist_freeze (GTK_CLIST (data));
2867   for (i = 0; i < 1000; i++)
2868     {
2869       sprintf (text[0], "Row %d", clist_rows++);
2870       row = gtk_clist_append (GTK_CLIST (data), texts);
2871       gtk_clist_set_pixtext (GTK_CLIST (data), row, 3, "Testing", 5, pixmap, mask);
2872     }
2873   gtk_clist_thaw (GTK_CLIST (data));
2874
2875   gdk_pixmap_unref (pixmap);
2876   gdk_bitmap_unref (mask);
2877 }
2878
2879 static void
2880 add10000_clist (GtkWidget *widget, gpointer data)
2881 {
2882   gint i;
2883   char text[TESTGTK_CLIST_COLUMNS][50];
2884   char *texts[TESTGTK_CLIST_COLUMNS];
2885
2886   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
2887     {
2888       texts[i] = text[i];
2889       sprintf (text[i], "Column %d", i);
2890     }
2891
2892   sprintf (text[1], "Right");
2893   sprintf (text[2], "Center");
2894
2895   gtk_clist_freeze (GTK_CLIST (data));
2896   for (i = 0; i < 10000; i++)
2897     {
2898       sprintf (text[0], "Row %d", clist_rows++);
2899       gtk_clist_append (GTK_CLIST (data), texts);
2900     }
2901   gtk_clist_thaw (GTK_CLIST (data));
2902
2903 }
2904
2905 void
2906 clear_clist (GtkWidget *widget, gpointer data)
2907 {
2908   gtk_clist_clear (GTK_CLIST (data));
2909   clist_rows = 0;
2910 }
2911
2912 void
2913 remove_row_clist (GtkWidget *widget, gpointer data)
2914 {
2915   gtk_clist_remove (GTK_CLIST (data), clist_selected_row);
2916   clist_rows--;
2917 }
2918
2919 void
2920 show_titles_clist (GtkWidget *widget, gpointer data)
2921 {
2922   gtk_clist_column_titles_show (GTK_CLIST (data));
2923 }
2924
2925 void
2926 hide_titles_clist (GtkWidget *widget, gpointer data)
2927 {
2928   gtk_clist_column_titles_hide (GTK_CLIST (data));
2929 }
2930
2931 void
2932 select_clist (GtkWidget *widget,
2933               gint row,
2934               gint column,
2935               GdkEventButton * bevent)
2936 {
2937   gint i;
2938   guint8 spacing;
2939   gchar *text;
2940   GdkPixmap *pixmap;
2941   GdkBitmap *mask;
2942   GList *list;
2943
2944   g_print ("GtkCList Selection: row %d column %d button %d\n",
2945            row, column, bevent ? bevent->button : 0);
2946
2947   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
2948     {
2949       switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i))
2950         {
2951         case GTK_CELL_TEXT:
2952           g_print ("CELL %d GTK_CELL_TEXT\n", i);
2953           gtk_clist_get_text (GTK_CLIST (widget), row, i, &text);
2954           g_print ("TEXT: %s\n", text);
2955           break;
2956
2957         case GTK_CELL_PIXMAP:
2958           g_print ("CELL %d GTK_CELL_PIXMAP\n", i);
2959           gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask);
2960           g_print ("PIXMAP: %d\n", (int) pixmap);
2961           g_print ("MASK: %d\n", (int) mask);
2962           break;
2963
2964         case GTK_CELL_PIXTEXT:
2965           g_print ("CELL %d GTK_CELL_PIXTEXT\n", i);
2966           gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask);
2967           g_print ("TEXT: %s\n", text);
2968           g_print ("SPACING: %d\n", spacing);
2969           g_print ("PIXMAP: %d\n", (int) pixmap);
2970           g_print ("MASK: %d\n", (int) mask);
2971           break;
2972
2973         default:
2974           break;
2975         }
2976     }
2977
2978   /* print selections list */
2979   g_print ("\nSelected Rows:");
2980   list = GTK_CLIST (widget)->selection;
2981   while (list)
2982     {
2983       g_print (" %d ", (gint) list->data);
2984       list = list->next;
2985     }
2986
2987   g_print ("\n\n\n");
2988
2989   clist_selected_row = row;
2990 }
2991
2992 void
2993 unselect_clist (GtkWidget *widget,
2994                 gint row,
2995                 gint column,
2996                 GdkEventButton * bevent)
2997 {
2998   gint i;
2999   guint8 spacing;
3000   gchar *text;
3001   GdkPixmap *pixmap;
3002   GdkBitmap *mask;
3003   GList *list;
3004
3005   g_print ("GtkCList Unselection: row %d column %d button %d\n",
3006            row, column, bevent ? bevent->button : 0);
3007
3008   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3009     {
3010       switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i))
3011         {
3012         case GTK_CELL_TEXT:
3013           g_print ("CELL %d GTK_CELL_TEXT\n", i);
3014           gtk_clist_get_text (GTK_CLIST (widget), row, i, &text);
3015           g_print ("TEXT: %s\n", text);
3016           break;
3017
3018         case GTK_CELL_PIXMAP:
3019           g_print ("CELL %d GTK_CELL_PIXMAP\n", i);
3020           gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask);
3021           g_print ("PIXMAP: %d\n", (int) pixmap);
3022           g_print ("MASK: %d\n", (int) mask);
3023           break;
3024
3025         case GTK_CELL_PIXTEXT:
3026           g_print ("CELL %d GTK_CELL_PIXTEXT\n", i);
3027           gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask);
3028           g_print ("TEXT: %s\n", text);
3029           g_print ("SPACING: %d\n", spacing);
3030           g_print ("PIXMAP: %d\n", (int) pixmap);
3031           g_print ("MASK: %d\n", (int) mask);
3032           break;
3033
3034         default:
3035           break;
3036         }
3037     }
3038
3039   /* print selections list */
3040   g_print ("\nSelected Rows:");
3041   list = GTK_CLIST (widget)->selection;
3042   while (list)
3043     {
3044       g_print (" %d ", (gint) list->data);
3045       list = list->next;
3046     }
3047
3048   g_print ("\n\n\n");
3049
3050   clist_selected_row = row;
3051 }
3052
3053 static void
3054 insert_row_clist (GtkWidget *widget, gpointer data)
3055 {
3056   static char *text[] =
3057   {
3058     "This",
3059     "is",
3060     "a",
3061     "inserted",
3062     "row",
3063     "la la la la la",
3064     "la la la la"
3065   };
3066
3067   gtk_clist_insert (GTK_CLIST (data), clist_selected_row, text);
3068   clist_rows++;
3069 }
3070
3071 static void
3072 clist_warning_test (GtkWidget *button,
3073                     GtkWidget *clist)
3074 {
3075   GtkWidget *child;
3076   static gboolean add_remove = FALSE;
3077
3078   add_remove = !add_remove;
3079
3080   child = gtk_label_new ("Test");
3081   gtk_widget_ref (child);
3082   gtk_object_sink (GTK_OBJECT (child));
3083
3084   if (add_remove)
3085     gtk_container_add (GTK_CONTAINER (clist), child);
3086   else
3087     {
3088       child->parent = clist;
3089       gtk_container_remove (GTK_CONTAINER (clist), child);
3090       child->parent = NULL;
3091     }
3092
3093   gtk_widget_destroy (child);
3094   gtk_widget_unref (child);
3095 }
3096
3097 static void
3098 create_clist ()
3099 {
3100   gint i;
3101   static GtkWidget *window = NULL;
3102
3103   static char *titles[] =
3104   {
3105     "Title 0",
3106     "Title 1",
3107     "Title 2",
3108     "Title 3",
3109     "Title 4",
3110     "Title 5",
3111     "Title 6"
3112   };
3113
3114   char text[TESTGTK_CLIST_COLUMNS][50];
3115   char *texts[TESTGTK_CLIST_COLUMNS];
3116
3117   GtkWidget *box1;
3118   GtkWidget *box2;
3119   GtkWidget *clist;
3120   GtkWidget *button;
3121   GtkWidget *separator;
3122
3123
3124   if (!window)
3125     {
3126       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3127
3128       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3129                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3130                           &window);
3131
3132       gtk_window_set_title (GTK_WINDOW (window), "clist");
3133       gtk_container_border_width (GTK_CONTAINER (window), 0);
3134
3135
3136       box1 = gtk_vbox_new (FALSE, 0);
3137       gtk_container_add (GTK_CONTAINER (window), box1);
3138       gtk_widget_show (box1);
3139
3140
3141       box2 = gtk_hbox_new (FALSE, 10);
3142       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3143       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
3144       gtk_widget_show (box2);
3145
3146       /* create GtkCList here so we have a pointer to throw at the
3147        * button callbacks -- more is done with it later */
3148       clist = gtk_clist_new_with_titles (TESTGTK_CLIST_COLUMNS, titles);
3149       /*clist = gtk_clist_new (TESTGTK_CLIST_COLUMNS);*/
3150
3151       /* control buttons */
3152       button = gtk_button_new_with_label ("Add 1,000 Rows With Pixmaps");
3153       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3154
3155       gtk_signal_connect (GTK_OBJECT (button),
3156                           "clicked",
3157                           (GtkSignalFunc) add1000_clist,
3158                           (gpointer) clist);
3159
3160       gtk_widget_show (button);
3161
3162
3163       button = gtk_button_new_with_label ("Add 10,000 Rows");
3164       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3165
3166       gtk_signal_connect (GTK_OBJECT (button),
3167                           "clicked",
3168                           (GtkSignalFunc) add10000_clist,
3169                           (gpointer) clist);
3170
3171       gtk_widget_show (button);
3172
3173       button = gtk_button_new_with_label ("Clear List");
3174       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3175
3176       gtk_signal_connect (GTK_OBJECT (button),
3177                           "clicked",
3178                           (GtkSignalFunc) clear_clist,
3179                           (gpointer) clist);
3180
3181       gtk_widget_show (button);
3182
3183       button = gtk_button_new_with_label ("Remove Row");
3184       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3185
3186       gtk_signal_connect (GTK_OBJECT (button),
3187                           "clicked",
3188                           (GtkSignalFunc) remove_row_clist,
3189                           (gpointer) clist);
3190
3191       gtk_widget_show (button);
3192
3193       /* second layer of buttons */
3194       box2 = gtk_hbox_new (FALSE, 10);
3195       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3196       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
3197       gtk_widget_show (box2);
3198
3199       button = gtk_button_new_with_label ("Insert Row");
3200       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3201
3202       gtk_signal_connect (GTK_OBJECT (button),
3203                           "clicked",
3204                           (GtkSignalFunc) insert_row_clist,
3205                           (gpointer) clist);
3206
3207       gtk_widget_show (button);
3208
3209       button = gtk_button_new_with_label ("Show Title Buttons");
3210       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3211
3212       gtk_signal_connect (GTK_OBJECT (button),
3213                           "clicked",
3214                           (GtkSignalFunc) show_titles_clist,
3215                           (gpointer) clist);
3216
3217       gtk_widget_show (button);
3218
3219       button = gtk_button_new_with_label ("Hide Title Buttons");
3220       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3221
3222       gtk_signal_connect (GTK_OBJECT (button),
3223                           "clicked",
3224                           (GtkSignalFunc) hide_titles_clist,
3225                           (gpointer) clist);
3226
3227       gtk_widget_show (button);
3228
3229       button = gtk_button_new_with_label ("Warning Test");
3230       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3231
3232       gtk_signal_connect (GTK_OBJECT (button),
3233                           "clicked",
3234                           (GtkSignalFunc) clist_warning_test,
3235                           (gpointer) clist);
3236
3237       gtk_widget_show (button);
3238
3239       /* vbox for the list itself */
3240       box2 = gtk_vbox_new (FALSE, 10);
3241       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3242       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3243       gtk_widget_show (box2);
3244
3245       /*
3246        * the rest of the clist configuration
3247        */
3248       gtk_clist_set_row_height (GTK_CLIST (clist), 20);
3249
3250       gtk_signal_connect (GTK_OBJECT (clist),
3251                           "select_row",
3252                           (GtkSignalFunc) select_clist,
3253                           NULL);
3254
3255       gtk_signal_connect (GTK_OBJECT (clist),
3256                           "unselect_row",
3257                           (GtkSignalFunc) unselect_clist,
3258                           NULL);
3259
3260       gtk_clist_set_column_width (GTK_CLIST (clist), 0, 100);
3261
3262       for (i = 1; i < TESTGTK_CLIST_COLUMNS; i++)
3263         gtk_clist_set_column_width (GTK_CLIST (clist), i, 80);
3264
3265       gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_BROWSE);
3266       gtk_clist_set_policy (GTK_CLIST (clist),
3267                             GTK_POLICY_AUTOMATIC,
3268                             GTK_POLICY_AUTOMATIC);
3269
3270       gtk_clist_set_policy (GTK_CLIST (clist), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
3271
3272       gtk_clist_set_column_justification (GTK_CLIST (clist), 1, GTK_JUSTIFY_RIGHT);
3273       gtk_clist_set_column_justification (GTK_CLIST (clist), 2, GTK_JUSTIFY_CENTER);
3274
3275       for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3276         {
3277           texts[i] = text[i];
3278           sprintf (text[i], "Column %d", i);
3279         }
3280
3281       sprintf (text[1], "Right");
3282       sprintf (text[2], "Center");
3283
3284       for (i = 0; i < 100; i++)
3285         {
3286           sprintf (text[0], "Row %d", clist_rows++);
3287           gtk_clist_append (GTK_CLIST (clist), texts);
3288         }
3289
3290       gtk_container_border_width (GTK_CONTAINER (clist), 5);
3291       gtk_box_pack_start (GTK_BOX (box2), clist, TRUE, TRUE, 0);
3292       gtk_widget_show (clist);
3293
3294
3295       separator = gtk_hseparator_new ();
3296       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3297       gtk_widget_show (separator);
3298
3299       box2 = gtk_vbox_new (FALSE, 10);
3300       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3301       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3302       gtk_widget_show (box2);
3303
3304       button = gtk_button_new_with_label ("close");
3305       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3306                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
3307                                  GTK_OBJECT (window));
3308
3309       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3310       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3311       gtk_widget_grab_default (button);
3312
3313       gtk_widget_show (button);
3314     }
3315
3316   if (!GTK_WIDGET_VISIBLE (window))
3317     gtk_widget_show (window);
3318   else
3319     {
3320       clist_rows = 0;
3321       gtk_widget_destroy (window);
3322     }
3323
3324 }
3325
3326 /*
3327  * GtkColorSelect
3328  */
3329 void
3330 color_selection_ok (GtkWidget               *w,
3331                     GtkColorSelectionDialog *cs)
3332 {
3333   GtkColorSelection *colorsel;
3334   gdouble color[4];
3335
3336   colorsel=GTK_COLOR_SELECTION(cs->colorsel);
3337
3338   gtk_color_selection_get_color(colorsel,color);
3339   gtk_color_selection_set_color(colorsel,color);
3340 }
3341
3342 void
3343 color_selection_changed (GtkWidget *w,
3344                          GtkColorSelectionDialog *cs)
3345 {
3346   GtkColorSelection *colorsel;
3347   gdouble color[4];
3348
3349   colorsel=GTK_COLOR_SELECTION(cs->colorsel);
3350   gtk_color_selection_get_color(colorsel,color);
3351 }
3352
3353 void
3354 create_color_selection ()
3355 {
3356   static GtkWidget *window = NULL;
3357
3358   if (!window)
3359     {
3360       gtk_preview_set_install_cmap (TRUE);
3361       gtk_widget_push_visual (gtk_preview_get_visual ());
3362       gtk_widget_push_colormap (gtk_preview_get_cmap ());
3363
3364       window = gtk_color_selection_dialog_new ("color selection dialog");
3365
3366       gtk_color_selection_set_opacity (
3367         GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
3368         TRUE);
3369
3370       gtk_color_selection_set_update_policy(
3371         GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
3372         GTK_UPDATE_CONTINUOUS);
3373
3374       gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
3375
3376       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3377                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3378                           &window);
3379
3380       gtk_signal_connect (
3381         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
3382         "color_changed",
3383         GTK_SIGNAL_FUNC(color_selection_changed),
3384         window);
3385
3386       gtk_signal_connect (
3387         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->ok_button),
3388         "clicked",
3389         GTK_SIGNAL_FUNC(color_selection_ok),
3390         window);
3391
3392       gtk_signal_connect_object (
3393         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->cancel_button),
3394         "clicked",
3395         GTK_SIGNAL_FUNC(gtk_widget_destroy),
3396         GTK_OBJECT (window));
3397
3398       gtk_widget_pop_colormap ();
3399       gtk_widget_pop_visual ();
3400     }
3401
3402   if (!GTK_WIDGET_VISIBLE (window))
3403     gtk_widget_show (window);
3404   else
3405     gtk_widget_destroy (window);
3406 }
3407
3408 void
3409 file_selection_hide_fileops (GtkWidget *widget,
3410                              GtkFileSelection *fs)
3411 {
3412   gtk_file_selection_hide_fileop_buttons (fs);
3413 }
3414
3415 void
3416 file_selection_ok (GtkWidget        *w,
3417                    GtkFileSelection *fs)
3418 {
3419   g_print ("%s\n", gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs)));
3420   gtk_widget_destroy (GTK_WIDGET (fs));
3421 }
3422
3423 void
3424 create_file_selection ()
3425 {
3426   static GtkWidget *window = NULL;
3427   GtkWidget *button;
3428
3429   if (!window)
3430     {
3431       window = gtk_file_selection_new ("file selection dialog");
3432
3433       gtk_file_selection_hide_fileop_buttons (GTK_FILE_SELECTION (window));
3434
3435       gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
3436
3437       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3438                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3439                           &window);
3440
3441       gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (window)->ok_button),
3442                           "clicked", GTK_SIGNAL_FUNC(file_selection_ok),
3443                           window);
3444       gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (window)->cancel_button),
3445                                  "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
3446                                  GTK_OBJECT (window));
3447
3448       button = gtk_button_new_with_label ("Hide Fileops");
3449       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3450                           (GtkSignalFunc) file_selection_hide_fileops,
3451                           (gpointer) window);
3452       gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
3453                           button, FALSE, FALSE, 0);
3454       gtk_widget_show (button);
3455
3456       button = gtk_button_new_with_label ("Show Fileops");
3457       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3458                                  (GtkSignalFunc) gtk_file_selection_show_fileop_buttons,
3459                                  (gpointer) window);
3460       gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
3461                           button, FALSE, FALSE, 0);
3462       gtk_widget_show (button);
3463
3464
3465
3466     }
3467
3468   if (!GTK_WIDGET_VISIBLE (window))
3469     gtk_widget_show (window);
3470   else
3471     gtk_widget_destroy (window);
3472 }
3473
3474
3475 /*
3476  * GtkDialog
3477  */
3478 static GtkWidget *dialog_window = NULL;
3479
3480 void
3481 label_toggle (GtkWidget  *widget,
3482               GtkWidget **label)
3483 {
3484   if (!(*label))
3485     {
3486       *label = gtk_label_new ("Dialog Test");
3487       gtk_signal_connect (GTK_OBJECT (*label),
3488                           "destroy",
3489                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
3490                           label);
3491       gtk_misc_set_padding (GTK_MISC (*label), 10, 10);
3492       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
3493                           *label, TRUE, TRUE, 0);
3494       gtk_widget_show (*label);
3495     }
3496   else
3497     gtk_widget_destroy (*label);
3498 }
3499
3500 void
3501 create_dialog ()
3502 {
3503   static GtkWidget *label;
3504   GtkWidget *button;
3505
3506   if (!dialog_window)
3507     {
3508       dialog_window = gtk_dialog_new ();
3509
3510       gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
3511                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3512                           &dialog_window);
3513
3514       gtk_window_set_title (GTK_WINDOW (dialog_window), "dialog");
3515       gtk_container_border_width (GTK_CONTAINER (dialog_window), 0);
3516
3517       button = gtk_button_new_with_label ("OK");
3518       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3519       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
3520                           button, TRUE, TRUE, 0);
3521       gtk_widget_grab_default (button);
3522       gtk_widget_show (button);
3523
3524       button = gtk_button_new_with_label ("Toggle");
3525       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3526                           GTK_SIGNAL_FUNC (label_toggle),
3527                           &label);
3528       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3529       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
3530                           button, TRUE, TRUE, 0);
3531       gtk_widget_show (button);
3532
3533       label = NULL;
3534     }
3535
3536   if (!GTK_WIDGET_VISIBLE (dialog_window))
3537     gtk_widget_show (dialog_window);
3538   else
3539     gtk_widget_destroy (dialog_window);
3540 }
3541
3542
3543 /*
3544  * GtkRange
3545  */
3546 void
3547 create_range_controls ()
3548 {
3549   static GtkWidget *window = NULL;
3550   GtkWidget *box1;
3551   GtkWidget *box2;
3552   GtkWidget *button;
3553   GtkWidget *scrollbar;
3554   GtkWidget *scale;
3555   GtkWidget *separator;
3556   GtkObject *adjustment;
3557
3558   if (!window)
3559     {
3560       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3561
3562       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3563                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3564                           &window);
3565
3566       gtk_window_set_title (GTK_WINDOW (window), "range controls");
3567       gtk_container_border_width (GTK_CONTAINER (window), 0);
3568
3569
3570       box1 = gtk_vbox_new (FALSE, 0);
3571       gtk_container_add (GTK_CONTAINER (window), box1);
3572       gtk_widget_show (box1);
3573
3574
3575       box2 = gtk_vbox_new (FALSE, 10);
3576       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3577       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3578       gtk_widget_show (box2);
3579
3580
3581       adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
3582
3583       scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
3584       gtk_widget_set_usize (GTK_WIDGET (scale), 150, 30);
3585       gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
3586       gtk_scale_set_digits (GTK_SCALE (scale), 1);
3587       gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
3588       gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
3589       gtk_widget_show (scale);
3590
3591       scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adjustment));
3592       gtk_range_set_update_policy (GTK_RANGE (scrollbar),
3593                                    GTK_UPDATE_CONTINUOUS);
3594       gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0);
3595       gtk_widget_show (scrollbar);
3596
3597
3598       separator = gtk_hseparator_new ();
3599       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3600       gtk_widget_show (separator);
3601
3602
3603       box2 = gtk_vbox_new (FALSE, 10);
3604       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3605       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3606       gtk_widget_show (box2);
3607
3608
3609       button = gtk_button_new_with_label ("close");
3610       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3611                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
3612                                  GTK_OBJECT (window));
3613       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3614       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3615       gtk_widget_grab_default (button);
3616       gtk_widget_show (button);
3617     }
3618
3619   if (!GTK_WIDGET_VISIBLE (window))
3620     gtk_widget_show (window);
3621   else
3622     gtk_widget_destroy (window);
3623 }
3624
3625
3626 /*
3627  * GtkRulers
3628  */
3629 void
3630 create_rulers ()
3631 {
3632   static GtkWidget *window = NULL;
3633   GtkWidget *table;
3634   GtkWidget *ruler;
3635
3636   if (!window)
3637     {
3638       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3639
3640       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3641                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3642                           &window);
3643
3644       gtk_window_set_title (GTK_WINDOW (window), "rulers");
3645       gtk_widget_set_usize (window, 300, 300);
3646       gtk_widget_set_events (window,
3647                              GDK_POINTER_MOTION_MASK
3648                              | GDK_POINTER_MOTION_HINT_MASK);
3649       gtk_container_border_width (GTK_CONTAINER (window), 0);
3650
3651       table = gtk_table_new (2, 2, FALSE);
3652       gtk_container_add (GTK_CONTAINER (window), table);
3653       gtk_widget_show (table);
3654
3655       ruler = gtk_hruler_new ();
3656       gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
3657
3658       gtk_signal_connect_object (
3659         GTK_OBJECT (window),
3660         "motion_notify_event",
3661         GTK_SIGNAL_FUNC(
3662           GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
3663         GTK_OBJECT (ruler));
3664
3665       gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
3666                         GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
3667       gtk_widget_show (ruler);
3668
3669
3670       ruler = gtk_vruler_new ();
3671       gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
3672
3673       gtk_signal_connect_object (
3674         GTK_OBJECT (window),
3675         "motion_notify_event",
3676         GTK_SIGNAL_FUNC (GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
3677         GTK_OBJECT (ruler));
3678
3679       gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
3680                         GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
3681       gtk_widget_show (ruler);
3682     }
3683
3684   if (!GTK_WIDGET_VISIBLE (window))
3685     gtk_widget_show (window);
3686   else
3687     gtk_widget_destroy (window);
3688 }
3689
3690
3691 static void
3692 text_toggle_editable (GtkWidget *checkbutton,
3693                        GtkWidget *text)
3694 {
3695    gtk_text_set_editable(GTK_TEXT(text),
3696                           GTK_TOGGLE_BUTTON(checkbutton)->active);
3697 }
3698
3699 static void
3700 text_toggle_word_wrap (GtkWidget *checkbutton,
3701                        GtkWidget *text)
3702 {
3703    gtk_text_set_word_wrap(GTK_TEXT(text),
3704                           GTK_TOGGLE_BUTTON(checkbutton)->active);
3705 }
3706
3707 /*
3708  * GtkText
3709  */
3710 void
3711 create_text ()
3712 {
3713   static GtkWidget *window = NULL;
3714   GtkWidget *box1;
3715   GtkWidget *box2;
3716   GtkWidget *hbox;
3717   GtkWidget *button;
3718   GtkWidget *check;
3719   GtkWidget *separator;
3720   GtkWidget *table;
3721   GtkWidget *hscrollbar;
3722   GtkWidget *vscrollbar;
3723   GtkWidget *text;
3724
3725   FILE *infile;
3726
3727   if (!window)
3728     {
3729       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3730       gtk_widget_set_name (window, "text window");
3731       gtk_widget_set_usize (window, 500, 500);
3732       gtk_window_set_policy (GTK_WINDOW(window), TRUE, TRUE, FALSE);
3733
3734       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3735                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3736                           &window);
3737
3738       gtk_window_set_title (GTK_WINDOW (window), "test");
3739       gtk_container_border_width (GTK_CONTAINER (window), 0);
3740
3741
3742       box1 = gtk_vbox_new (FALSE, 0);
3743       gtk_container_add (GTK_CONTAINER (window), box1);
3744       gtk_widget_show (box1);
3745
3746
3747       box2 = gtk_vbox_new (FALSE, 10);
3748       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3749       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3750       gtk_widget_show (box2);
3751
3752
3753       table = gtk_table_new (2, 2, FALSE);
3754       gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2);
3755       gtk_table_set_col_spacing (GTK_TABLE (table), 0, 2);
3756       gtk_box_pack_start (GTK_BOX (box2), table, TRUE, TRUE, 0);
3757       gtk_widget_show (table);
3758
3759       text = gtk_text_new (NULL, NULL);
3760       gtk_text_set_editable (GTK_TEXT (text), TRUE);
3761       gtk_table_attach (GTK_TABLE (table), text, 0, 1, 0, 1,
3762                         GTK_EXPAND | GTK_SHRINK | GTK_FILL,
3763                         GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
3764       gtk_widget_show (text);
3765
3766       hscrollbar = gtk_hscrollbar_new (GTK_TEXT (text)->hadj);
3767       gtk_table_attach (GTK_TABLE (table), hscrollbar, 0, 1, 1, 2,
3768                         GTK_EXPAND | GTK_FILL | GTK_SHRINK, GTK_FILL, 0, 0);
3769       gtk_widget_show (hscrollbar);
3770
3771       vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
3772       gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 0, 1,
3773                         GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
3774       gtk_widget_show (vscrollbar);
3775
3776       gtk_text_freeze (GTK_TEXT (text));
3777
3778       gtk_widget_realize (text);
3779
3780       infile = fopen("testgtk.c", "r");
3781
3782       if (infile)
3783         {
3784           char buffer[1024];
3785           int nchars;
3786
3787           while (1)
3788             {
3789               nchars = fread(buffer, 1, 1024, infile);
3790               gtk_text_insert (GTK_TEXT (text), NULL, NULL,
3791                                NULL, buffer, nchars);
3792
3793               if (nchars < 1024)
3794                 break;
3795             }
3796
3797           fclose (infile);
3798         }
3799
3800       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
3801                        "And even ", -1);
3802       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->bg[GTK_STATE_NORMAL], NULL,
3803                        "colored", -1);
3804       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
3805                        "text", -1);
3806
3807       gtk_text_thaw (GTK_TEXT (text));
3808
3809       hbox = gtk_hbutton_box_new ();
3810       gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, FALSE, 0);
3811       gtk_widget_show (hbox);
3812
3813       check = gtk_check_button_new_with_label("Editable");
3814       gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, FALSE, 0);
3815       gtk_signal_connect (GTK_OBJECT(check), "toggled",
3816                           GTK_SIGNAL_FUNC(text_toggle_editable), text);
3817       gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), TRUE);
3818       gtk_widget_show (check);
3819
3820       check = gtk_check_button_new_with_label("Wrap Words");
3821       gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
3822       gtk_signal_connect (GTK_OBJECT(check), "toggled",
3823                           GTK_SIGNAL_FUNC(text_toggle_word_wrap), text);
3824       gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), FALSE);
3825       gtk_widget_show (check);
3826
3827       separator = gtk_hseparator_new ();
3828       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3829       gtk_widget_show (separator);
3830
3831
3832       box2 = gtk_vbox_new (FALSE, 10);
3833       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3834       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3835       gtk_widget_show (box2);
3836
3837
3838       button = gtk_button_new_with_label ("close");
3839       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3840                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
3841                                  GTK_OBJECT (window));
3842       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3843       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3844       gtk_widget_grab_default (button);
3845       gtk_widget_show (button);
3846     }
3847
3848   if (!GTK_WIDGET_VISIBLE (window))
3849     gtk_widget_show (window);
3850   else
3851     gtk_widget_destroy (window);
3852 }
3853
3854
3855 /*
3856  * GtkNotebook
3857  */
3858
3859 GdkPixmap *book_open;
3860 GdkPixmap *book_closed;
3861 GdkBitmap *book_open_mask;
3862 GdkBitmap *book_closed_mask;
3863
3864 static char * book_open_xpm[] = {
3865 "16 16 4 1",
3866 "       c None s None",
3867 ".      c black",
3868 "X      c #808080",
3869 "o      c white",
3870 "                ",
3871 "  ..            ",
3872 " .Xo.    ...    ",
3873 " .Xoo. ..oo.    ",
3874 " .Xooo.Xooo...  ",
3875 " .Xooo.oooo.X.  ",
3876 " .Xooo.Xooo.X.  ",
3877 " .Xooo.oooo.X.  ",
3878 " .Xooo.Xooo.X.  ",
3879 " .Xooo.oooo.X.  ",
3880 "  .Xoo.Xoo..X.  ",
3881 "   .Xo.o..ooX.  ",
3882 "    .X..XXXXX.  ",
3883 "    ..X.......  ",
3884 "     ..         ",
3885 "                "};
3886
3887 static char * book_closed_xpm[] = {
3888 "16 16 6 1",
3889 "       c None s None",
3890 ".      c black",
3891 "X      c red",
3892 "o      c yellow",
3893 "O      c #808080",
3894 "#      c white",
3895 "                ",
3896 "       ..       ",
3897 "     ..XX.      ",
3898 "   ..XXXXX.     ",
3899 " ..XXXXXXXX.    ",
3900 ".ooXXXXXXXXX.   ",
3901 "..ooXXXXXXXXX.  ",
3902 ".X.ooXXXXXXXXX. ",
3903 ".XX.ooXXXXXX..  ",
3904 " .XX.ooXXX..#O  ",
3905 "  .XX.oo..##OO. ",
3906 "   .XX..##OO..  ",
3907 "    .X.#OO..    ",
3908 "     ..O..      ",
3909 "      ..        ",
3910 "                "};
3911
3912 static void
3913 page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num)
3914 {
3915   GtkNotebookPage *oldpage;
3916   GtkWidget *pixwid;
3917
3918   oldpage = GTK_NOTEBOOK (widget)->cur_page;
3919
3920   if (page == oldpage)
3921     return;
3922
3923   pixwid = ((GtkBoxChild*)(GTK_BOX (page->tab_label)->children->data))->widget;
3924   gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
3925   pixwid = ((GtkBoxChild*) (GTK_BOX (page->menu_label)->children->data))->widget;
3926   gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
3927
3928   if (oldpage)
3929     {
3930       pixwid = ((GtkBoxChild*) (GTK_BOX
3931                                 (oldpage->tab_label)->children->data))->widget;
3932       gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
3933       pixwid = ((GtkBoxChild*) (GTK_BOX (oldpage->menu_label)->children->data))->widget;
3934       gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
3935     }
3936 }
3937
3938 static void
3939 create_pages (GtkNotebook *notebook, gint start, gint end)
3940 {
3941   GtkWidget *child = NULL;
3942   GtkWidget *label;
3943   GtkWidget *entry;
3944   GtkWidget *box;
3945   GtkWidget *hbox;
3946   GtkWidget *label_box;
3947   GtkWidget *menu_box;
3948   GtkWidget *button;
3949   GtkWidget *pixwid;
3950   gint i;
3951   char buffer[32];
3952
3953   for (i = start; i <= end; i++)
3954     {
3955       sprintf (buffer, "Page %d", i);
3956
3957       switch (i%4)
3958         {
3959         case 3:
3960           child = gtk_button_new_with_label (buffer);
3961           gtk_container_border_width (GTK_CONTAINER(child), 10);
3962           break;
3963         case 2:
3964           child = gtk_label_new (buffer);
3965           break;
3966         case 1:
3967           child = gtk_frame_new (buffer);
3968           gtk_container_border_width (GTK_CONTAINER (child), 10);
3969
3970           box = gtk_vbox_new (TRUE,0);
3971           gtk_container_border_width (GTK_CONTAINER (box), 10);
3972           gtk_container_add (GTK_CONTAINER (child), box);
3973
3974           label = gtk_label_new (buffer);
3975           gtk_box_pack_start (GTK_BOX(box), label, TRUE, TRUE, 5);
3976
3977           entry = gtk_entry_new ();
3978           gtk_box_pack_start (GTK_BOX(box), entry, TRUE, TRUE, 5);
3979
3980           hbox = gtk_hbox_new (TRUE,0);
3981           gtk_box_pack_start (GTK_BOX(box), hbox, TRUE, TRUE, 5);
3982
3983           button = gtk_button_new_with_label ("Ok");
3984           gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
3985
3986           button = gtk_button_new_with_label ("Cancel");
3987           gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
3988           break;
3989         case 0:
3990           child = gtk_frame_new (buffer);
3991           gtk_container_border_width (GTK_CONTAINER (child), 10);
3992
3993           label = gtk_label_new (buffer);
3994           gtk_container_add (GTK_CONTAINER (child), label);
3995           break;
3996         }
3997
3998       gtk_widget_show_all (child);
3999
4000       label_box = gtk_hbox_new (FALSE, 0);
4001       pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
4002       gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
4003       gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
4004       label = gtk_label_new (buffer);
4005       gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
4006       gtk_widget_show_all (label_box);
4007
4008       menu_box = gtk_hbox_new (FALSE, 0);
4009       pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
4010       gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
4011       gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
4012       label = gtk_label_new (buffer);
4013       gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0);
4014       gtk_widget_show_all (menu_box);
4015
4016       gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
4017     }
4018 }
4019
4020 static void
4021 rotate_notebook (GtkButton   *button,
4022                  GtkNotebook *notebook)
4023 {
4024   gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos + 1) % 4);
4025 }
4026
4027 static void
4028 standard_notebook (GtkButton   *button,
4029                    GtkNotebook *notebook)
4030 {
4031   gint i;
4032
4033   gtk_notebook_set_show_tabs (notebook, TRUE);
4034   gtk_notebook_set_scrollable (notebook, FALSE);
4035   if (g_list_length (notebook->children) == 15)
4036     for (i = 0; i < 10; i++)
4037       gtk_notebook_remove_page (notebook, 5);
4038 }
4039
4040 static void
4041 notabs_notebook (GtkButton   *button,
4042                  GtkNotebook *notebook)
4043 {
4044   gint i;
4045
4046   gtk_notebook_set_show_tabs (notebook, FALSE);
4047   if (g_list_length (notebook->children) == 15)
4048     for (i = 0; i < 10; i++)
4049       gtk_notebook_remove_page (notebook, 5);
4050 }
4051
4052 static void
4053 scrollable_notebook (GtkButton   *button,
4054                      GtkNotebook *notebook)
4055 {
4056   gtk_notebook_set_show_tabs (notebook, TRUE);
4057   gtk_notebook_set_scrollable (notebook, TRUE);
4058   if (g_list_length (notebook->children) == 5)
4059     create_pages (notebook, 6, 15);
4060 }
4061
4062 static void
4063 notebook_popup (GtkToggleButton *button,
4064                 GtkNotebook     *notebook)
4065 {
4066   if (button->active)
4067     gtk_notebook_popup_enable (notebook);
4068   else
4069     gtk_notebook_popup_disable (notebook);
4070 }
4071
4072 static void
4073 create_notebook ()
4074 {
4075   static GtkWidget *window = NULL;
4076   GtkWidget *box1;
4077   GtkWidget *box2;
4078   GtkWidget *button;
4079   GtkWidget *separator;
4080   GtkWidget *notebook;
4081   GtkWidget *omenu;
4082   GtkWidget *menu;
4083   GtkWidget *submenu;
4084   GtkWidget *menuitem;
4085   GSList *group;
4086   GdkColor *transparent = NULL;
4087
4088   if (!window)
4089     {
4090       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4091
4092       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4093                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4094                           &window);
4095
4096       gtk_window_set_title (GTK_WINDOW (window), "notebook");
4097       gtk_container_border_width (GTK_CONTAINER (window), 0);
4098
4099       box1 = gtk_vbox_new (FALSE, 0);
4100       gtk_container_add (GTK_CONTAINER (window), box1);
4101
4102       notebook = gtk_notebook_new ();
4103       gtk_signal_connect (GTK_OBJECT (notebook), "switch_page",
4104                           GTK_SIGNAL_FUNC (page_switch), NULL);
4105       gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
4106       gtk_box_pack_start (GTK_BOX (box1), notebook, TRUE, TRUE, 0);
4107       gtk_container_border_width (GTK_CONTAINER (notebook), 10);
4108
4109       gtk_widget_realize (notebook);
4110       book_open = gdk_pixmap_create_from_xpm_d (notebook->window,
4111                                                 &book_open_mask,
4112                                                 transparent,
4113                                                 book_open_xpm);
4114       book_closed = gdk_pixmap_create_from_xpm_d (notebook->window,
4115                                                   &book_closed_mask,
4116                                                   transparent,
4117                                                   book_closed_xpm);
4118
4119       create_pages (GTK_NOTEBOOK (notebook), 1, 5);
4120
4121       separator = gtk_hseparator_new ();
4122       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10);
4123
4124       box2 = gtk_hbox_new (TRUE, 5);
4125       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4126
4127       omenu = gtk_option_menu_new ();
4128       menu = gtk_menu_new ();
4129       submenu = NULL;
4130       group = NULL;
4131
4132       menuitem = gtk_radio_menu_item_new_with_label (group, "Standard");
4133       gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
4134                                  GTK_SIGNAL_FUNC (standard_notebook),
4135                                  GTK_OBJECT (notebook));
4136       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
4137       gtk_menu_append (GTK_MENU (menu), menuitem);
4138       gtk_widget_show (menuitem);
4139       menuitem = gtk_radio_menu_item_new_with_label (group, "w/o Tabs");
4140       gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
4141                                  GTK_SIGNAL_FUNC (notabs_notebook),
4142                                  GTK_OBJECT (notebook));
4143       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
4144       gtk_menu_append (GTK_MENU (menu), menuitem);
4145       gtk_widget_show (menuitem);
4146       menuitem = gtk_radio_menu_item_new_with_label (group, "Scrollable");
4147       gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
4148                                  GTK_SIGNAL_FUNC (scrollable_notebook),
4149                                  GTK_OBJECT (notebook));
4150       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
4151       gtk_menu_append (GTK_MENU (menu), menuitem);
4152       gtk_widget_show (menuitem);
4153
4154       gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
4155       gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, FALSE, 0);
4156       button = gtk_check_button_new_with_label ("enable popup menu");
4157       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
4158       gtk_signal_connect (GTK_OBJECT(button), "clicked",
4159                           GTK_SIGNAL_FUNC (notebook_popup),
4160                           GTK_OBJECT (notebook));
4161
4162       box2 = gtk_hbox_new (FALSE, 10);
4163       gtk_container_border_width (GTK_CONTAINER (box2), 10);
4164       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4165
4166       button = gtk_button_new_with_label ("close");
4167       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4168                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
4169                                  GTK_OBJECT (window));
4170       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4171       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4172       gtk_widget_grab_default (button);
4173
4174       button = gtk_button_new_with_label ("next");
4175       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4176                                  GTK_SIGNAL_FUNC (gtk_notebook_next_page),
4177                                  GTK_OBJECT (notebook));
4178       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4179
4180       button = gtk_button_new_with_label ("prev");
4181       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4182                                  GTK_SIGNAL_FUNC (gtk_notebook_prev_page),
4183                                  GTK_OBJECT (notebook));
4184       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4185
4186       button = gtk_button_new_with_label ("rotate");
4187       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4188                           GTK_SIGNAL_FUNC (rotate_notebook),
4189                           notebook);
4190       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4191     }
4192
4193   if (!GTK_WIDGET_VISIBLE (window))
4194     gtk_widget_show_all (window);
4195   else
4196     gtk_widget_destroy (window);
4197 }
4198
4199
4200 /*
4201  * GtkPanes
4202  */
4203 void
4204 create_panes ()
4205 {
4206   static GtkWidget *window = NULL;
4207   GtkWidget *frame;
4208   GtkWidget *hpaned;
4209   GtkWidget *vpaned;
4210   GtkWidget *button;
4211
4212   if (!window)
4213     {
4214       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4215
4216       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4217                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4218                           &window);
4219
4220       gtk_window_set_title (GTK_WINDOW (window), "Panes");
4221       gtk_container_border_width (GTK_CONTAINER (window), 0);
4222
4223       vpaned = gtk_vpaned_new ();
4224       gtk_container_add (GTK_CONTAINER (window), vpaned);
4225       gtk_container_border_width (GTK_CONTAINER(vpaned), 5);
4226       gtk_widget_show (vpaned);
4227
4228       hpaned = gtk_hpaned_new ();
4229       gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
4230
4231       frame = gtk_frame_new (NULL);
4232       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
4233       gtk_widget_set_usize (frame, 60, 60);
4234       gtk_paned_add1 (GTK_PANED (hpaned), frame);
4235       gtk_widget_show (frame);
4236
4237       button = gtk_button_new_with_label ("Hi there");
4238       gtk_container_add (GTK_CONTAINER(frame), button);
4239       gtk_widget_show (button);
4240
4241       frame = gtk_frame_new (NULL);
4242       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
4243       gtk_widget_set_usize (frame, 80, 60);
4244       gtk_paned_add2 (GTK_PANED (hpaned), frame);
4245       gtk_widget_show (frame);
4246
4247       gtk_widget_show (hpaned);
4248
4249       frame = gtk_frame_new (NULL);
4250       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
4251       gtk_widget_set_usize (frame, 60, 80);
4252       gtk_paned_add2 (GTK_PANED (vpaned), frame);
4253       gtk_widget_show (frame);
4254     }
4255
4256   if (!GTK_WIDGET_VISIBLE (window))
4257     gtk_widget_show (window);
4258   else
4259     gtk_widget_destroy (window);
4260 }
4261
4262
4263 /*
4264  * Drag -N- Drop
4265  */
4266
4267 gint
4268 dnd_drop_destroy_popup (GtkWidget *widget, GtkWindow **window)
4269 {
4270   if(GTK_IS_BUTTON(widget)) /* I.e. they clicked the close button */
4271     gtk_widget_destroy(GTK_WIDGET(*window));
4272   else {
4273     gtk_grab_remove(GTK_WIDGET(*window));
4274     *window = NULL;
4275   }
4276
4277   return FALSE;
4278 }
4279
4280 void
4281 dnd_drop (GtkWidget *button, GdkEvent *event)
4282 {
4283   static GtkWidget *window = NULL;
4284   GtkWidget *vbox, *lbl, *btn;
4285   gchar *msg;
4286
4287   /* DND doesn't obey gtk_grab's, so check if we're already displaying
4288    * drop modal dialog first
4289    */
4290   if (window)
4291     return;
4292
4293   window = gtk_window_new(GTK_WINDOW_DIALOG);
4294   gtk_container_border_width (GTK_CONTAINER(window), 10);
4295
4296   gtk_signal_connect (GTK_OBJECT (window), "destroy",
4297                       GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
4298                       &window);
4299   gtk_signal_connect (GTK_OBJECT (window), "delete_event",
4300                       GTK_SIGNAL_FUNC(gtk_false),
4301                       &window);
4302
4303   vbox = gtk_vbox_new(FALSE, 5);
4304
4305   /* Display message that we got from drop source */
4306   msg = g_malloc(strlen(event->dropdataavailable.data)
4307                  + strlen(event->dropdataavailable.data_type) + 100);
4308   sprintf(msg, "Drop data of type %s was:\n\n%s",
4309           event->dropdataavailable.data_type,
4310           (char *)event->dropdataavailable.data);
4311   lbl = gtk_label_new(msg);
4312   gtk_label_set_justify(GTK_LABEL(lbl), GTK_JUSTIFY_FILL);
4313   g_free(msg);
4314   gtk_widget_show(lbl);
4315   gtk_box_pack_start_defaults(GTK_BOX(vbox), lbl);
4316
4317   /* Provide an obvious way out of this heinousness */
4318   btn = gtk_button_new_with_label("Continue with life in\nspite of this oppression");
4319   gtk_signal_connect_object (GTK_OBJECT (btn), "clicked",
4320                              GTK_SIGNAL_FUNC(gtk_widget_destroy),
4321                              GTK_OBJECT (window));
4322   gtk_widget_show(btn);
4323   gtk_box_pack_start_defaults(GTK_BOX(vbox), btn);
4324
4325   gtk_container_add(GTK_CONTAINER(window), vbox);
4326
4327   gtk_widget_show(vbox);
4328   gtk_grab_add(window);
4329   gtk_widget_show(window);
4330 }
4331
4332 void
4333 dnd_drag_request (GtkWidget *button, GdkEvent *event)
4334 {
4335 #define DND_STRING "Bill Gates demands royalties for\nyour use of his innovation."
4336   gtk_widget_dnd_data_set (button, event, DND_STRING, strlen(DND_STRING) + 1);
4337 }
4338
4339 void
4340 create_dnd ()
4341 {
4342   static GtkWidget *window = NULL;
4343   GtkWidget *box1;
4344   GtkWidget *box2;
4345   GtkWidget *box3;
4346   GtkWidget *frame;
4347   GtkWidget *button;
4348   GtkWidget *separator;
4349
4350   /* For clarity... */
4351   char *possible_drag_types[] = {"text/plain"};
4352   char *accepted_drop_types[] = {"text/plain"};
4353
4354   static GtkWidget *drag_icon = NULL;
4355   static GtkWidget *drop_icon = NULL;
4356
4357   if (!window)
4358     {
4359       GdkPoint hotspot = {5,5};
4360
4361       if (!drag_icon)
4362         {
4363           drag_icon = shape_create_icon ("Modeller.xpm",
4364                                          440, 140, 0,0, GTK_WINDOW_POPUP);
4365
4366           gtk_signal_connect (GTK_OBJECT (drag_icon), "destroy",
4367                               GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4368                               &drag_icon);
4369
4370           gtk_widget_hide (drag_icon);
4371         }
4372
4373       if (!drop_icon)
4374         {
4375           drop_icon = shape_create_icon ("3DRings.xpm",
4376                                          440, 140, 0,0, GTK_WINDOW_POPUP);
4377
4378           gtk_signal_connect (GTK_OBJECT (drop_icon), "destroy",
4379                               GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4380                               &drop_icon);
4381
4382           gtk_widget_hide (drop_icon);
4383         }
4384
4385       gdk_dnd_set_drag_shape(drag_icon->window,
4386                              &hotspot,
4387                              drop_icon->window,
4388                              &hotspot);
4389
4390       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4391
4392       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4393                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4394                           &window);
4395
4396       gtk_window_set_title (GTK_WINDOW (window), "Drag -N- Drop");
4397       gtk_container_border_width (GTK_CONTAINER (window), 0);
4398
4399       box1 = gtk_vbox_new (FALSE, 0);
4400       gtk_container_add (GTK_CONTAINER (window), box1);
4401       gtk_widget_show (box1);
4402
4403       box2 = gtk_hbox_new (FALSE, 5);
4404       gtk_container_border_width (GTK_CONTAINER (box2), 10);
4405       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
4406       gtk_widget_show (box2);
4407
4408       frame = gtk_frame_new ("Drag");
4409       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
4410       gtk_widget_show (frame);
4411
4412       box3 = gtk_vbox_new (FALSE, 5);
4413       gtk_container_border_width (GTK_CONTAINER (box3), 5);
4414       gtk_container_add (GTK_CONTAINER (frame), box3);
4415       gtk_widget_show (box3);
4416
4417       /*
4418        * FROM Button
4419        */
4420       button = gtk_button_new_with_label ("Drag me!");
4421       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
4422       gtk_widget_show (button);
4423
4424       /*
4425        * currently, the widget has to be realized to
4426        * set dnd on it, this needs to change
4427        */
4428       gtk_widget_realize (button);
4429       gtk_signal_connect (GTK_OBJECT (button),
4430                           "drag_request_event",
4431                           GTK_SIGNAL_FUNC(dnd_drag_request),
4432                           button);
4433
4434       gtk_widget_dnd_drag_set (button, TRUE, possible_drag_types, 1);
4435
4436
4437       frame = gtk_frame_new ("Drop");
4438       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
4439       gtk_widget_show (frame);
4440
4441       box3 = gtk_vbox_new (FALSE, 5);
4442       gtk_container_border_width (GTK_CONTAINER (box3), 5);
4443       gtk_container_add (GTK_CONTAINER (frame), box3);
4444       gtk_widget_show (box3);
4445
4446
4447       /*
4448        * TO Button
4449        */
4450       button = gtk_button_new_with_label ("To");
4451       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
4452       gtk_widget_show (button);
4453
4454       gtk_widget_realize (button);
4455       gtk_signal_connect (GTK_OBJECT (button),
4456                           "drop_data_available_event",
4457                           GTK_SIGNAL_FUNC(dnd_drop),
4458                           button);
4459
4460       gtk_widget_dnd_drop_set (button, TRUE, accepted_drop_types, 1, FALSE);
4461
4462
4463       separator = gtk_hseparator_new ();
4464       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4465       gtk_widget_show (separator);
4466
4467
4468       box2 = gtk_vbox_new (FALSE, 10);
4469       gtk_container_border_width (GTK_CONTAINER (box2), 10);
4470       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4471       gtk_widget_show (box2);
4472
4473
4474       button = gtk_button_new_with_label ("close");
4475
4476       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4477                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
4478                                  GTK_OBJECT (window));
4479
4480       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4481       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4482       gtk_widget_grab_default (button);
4483       gtk_widget_show (button);
4484     }
4485
4486   if (!GTK_WIDGET_VISIBLE (window))
4487     gtk_widget_show (window);
4488   else
4489     gtk_widget_destroy (window);
4490 }
4491
4492 /*
4493  * Shaped Windows
4494  */
4495 static GdkWindow *root_win = NULL;
4496
4497 typedef struct _cursoroffset {gint x,y;} CursorOffset;
4498
4499 static void
4500 shape_pressed (GtkWidget *widget, GdkEventButton *event)
4501 {
4502   CursorOffset *p;
4503
4504   /* ignore double and triple click */
4505   if (event->type != GDK_BUTTON_PRESS)
4506     return;
4507
4508   p = gtk_object_get_user_data (GTK_OBJECT(widget));
4509   p->x = (int) event->x;
4510   p->y = (int) event->y;
4511
4512   gtk_grab_add (widget);
4513   gdk_pointer_grab (widget->window, TRUE,
4514                     GDK_BUTTON_RELEASE_MASK |
4515                     GDK_BUTTON_MOTION_MASK |
4516                     GDK_POINTER_MOTION_HINT_MASK,
4517                     NULL, NULL, 0);
4518 }
4519
4520
4521 static void
4522 shape_released (GtkWidget *widget)
4523 {
4524   gtk_grab_remove (widget);
4525   gdk_pointer_ungrab (0);
4526 }
4527
4528 static void
4529 shape_motion (GtkWidget      *widget,
4530               GdkEventMotion *event)
4531 {
4532   gint xp, yp;
4533   CursorOffset * p;
4534   GdkModifierType mask;
4535
4536   p = gtk_object_get_user_data (GTK_OBJECT (widget));
4537
4538   /*
4539    * Can't use event->x / event->y here
4540    * because I need absolute coordinates.
4541    */
4542   gdk_window_get_pointer (root_win, &xp, &yp, &mask);
4543   gtk_widget_set_uposition (widget, xp  - p->x, yp  - p->y);
4544 }
4545
4546 GtkWidget *
4547 shape_create_icon (char     *xpm_file,
4548                    gint      x,
4549                    gint      y,
4550                    gint      px,
4551                    gint      py,
4552                    gint      window_type)
4553 {
4554   GtkWidget *window;
4555   GtkWidget *pixmap;
4556   GtkWidget *fixed;
4557   CursorOffset* icon_pos;
4558   GdkGC* gc;
4559   GdkBitmap *gdk_pixmap_mask;
4560   GdkPixmap *gdk_pixmap;
4561   GtkStyle *style;
4562
4563   style = gtk_widget_get_default_style ();
4564   gc = style->black_gc;
4565
4566   /*
4567    * GDK_WINDOW_TOPLEVEL works also, giving you a title border
4568    */
4569   window = gtk_window_new (window_type);
4570
4571   fixed = gtk_fixed_new ();
4572   gtk_widget_set_usize (fixed, 100,100);
4573   gtk_container_add (GTK_CONTAINER (window), fixed);
4574   gtk_widget_show (fixed);
4575
4576   gtk_widget_set_events (window,
4577                          gtk_widget_get_events (window) |
4578                          GDK_BUTTON_MOTION_MASK |
4579                          GDK_POINTER_MOTION_HINT_MASK |
4580                          GDK_BUTTON_PRESS_MASK);
4581
4582   gtk_widget_realize (window);
4583   gdk_pixmap = gdk_pixmap_create_from_xpm (window->window, &gdk_pixmap_mask,
4584                                            &style->bg[GTK_STATE_NORMAL],
4585                                            xpm_file);
4586
4587   pixmap = gtk_pixmap_new (gdk_pixmap, gdk_pixmap_mask);
4588   gtk_fixed_put (GTK_FIXED (fixed), pixmap, px,py);
4589   gtk_widget_show (pixmap);
4590
4591   gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px,py);
4592
4593
4594   gtk_signal_connect (GTK_OBJECT (window), "button_press_event",
4595                       GTK_SIGNAL_FUNC (shape_pressed),NULL);
4596   gtk_signal_connect (GTK_OBJECT (window), "button_release_event",
4597                       GTK_SIGNAL_FUNC (shape_released),NULL);
4598   gtk_signal_connect (GTK_OBJECT (window), "motion_notify_event",
4599                       GTK_SIGNAL_FUNC (shape_motion),NULL);
4600
4601   icon_pos = g_new (CursorOffset, 1);
4602   gtk_object_set_user_data(GTK_OBJECT(window), icon_pos);
4603
4604   gtk_widget_set_uposition (window, x, y);
4605   gtk_widget_show (window);
4606
4607   return window;
4608 }
4609
4610 void
4611 create_shapes ()
4612 {
4613   /* Variables used by the Drag/Drop and Shape Window demos */
4614   static GtkWidget *modeller = NULL;
4615   static GtkWidget *sheets = NULL;
4616   static GtkWidget *rings = NULL;
4617
4618   root_win = gdk_window_foreign_new (GDK_ROOT_WINDOW ());
4619
4620   if (!modeller)
4621     {
4622       modeller = shape_create_icon ("Modeller.xpm",
4623                                     440, 140, 0,0, GTK_WINDOW_POPUP);
4624
4625       gtk_signal_connect (GTK_OBJECT (modeller), "destroy",
4626                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4627                           &modeller);
4628     }
4629   else
4630     gtk_widget_destroy (modeller);
4631
4632   if (!sheets)
4633     {
4634       sheets = shape_create_icon ("FilesQueue.xpm",
4635                                   580, 170, 0,0, GTK_WINDOW_POPUP);
4636
4637       gtk_signal_connect (GTK_OBJECT (sheets), "destroy",
4638                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4639                           &sheets);
4640
4641     }
4642   else
4643     gtk_widget_destroy (sheets);
4644
4645   if (!rings)
4646     {
4647       rings = shape_create_icon ("3DRings.xpm",
4648                                  460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
4649
4650       gtk_signal_connect (GTK_OBJECT (rings), "destroy",
4651                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4652                           &rings);
4653     }
4654   else
4655     gtk_widget_destroy (rings);
4656 }
4657
4658 void
4659 create_wmhints ()
4660 {
4661   static GtkWidget *window = NULL;
4662   GtkWidget *label;
4663   GtkWidget *separator;
4664   GtkWidget *button;
4665   GtkWidget *box1;
4666   GtkWidget *box2;
4667
4668   GdkBitmap *circles;
4669
4670   if (!window)
4671     {
4672       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4673
4674       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4675                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4676                           &window);
4677
4678       gtk_window_set_title (GTK_WINDOW (window), "WM Hints");
4679       gtk_container_border_width (GTK_CONTAINER (window), 0);
4680
4681       gtk_widget_realize (window);
4682
4683       circles = gdk_bitmap_create_from_data (window->window,
4684                                              circles_bits,
4685                                              circles_width,
4686                                              circles_height);
4687       gdk_window_set_icon (window->window, NULL,
4688                            circles, circles);
4689
4690       gdk_window_set_icon_name (window->window, "WMHints Test Icon");
4691
4692       gdk_window_set_decorations (window->window, GDK_DECOR_ALL | GDK_DECOR_MENU);
4693       gdk_window_set_functions (window->window, GDK_FUNC_ALL | GDK_FUNC_RESIZE);
4694
4695       box1 = gtk_vbox_new (FALSE, 0);
4696       gtk_container_add (GTK_CONTAINER (window), box1);
4697       gtk_widget_show (box1);
4698
4699       label = gtk_label_new ("Try iconizing me!");
4700       gtk_widget_set_usize (label, 150, 50);
4701       gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
4702       gtk_widget_show (label);
4703
4704
4705       separator = gtk_hseparator_new ();
4706       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4707       gtk_widget_show (separator);
4708
4709
4710       box2 = gtk_vbox_new (FALSE, 10);
4711       gtk_container_border_width (GTK_CONTAINER (box2), 10);
4712       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4713       gtk_widget_show (box2);
4714
4715
4716       button = gtk_button_new_with_label ("close");
4717
4718       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4719                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
4720                                  GTK_OBJECT (window));
4721
4722       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4723       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4724       gtk_widget_grab_default (button);
4725       gtk_widget_show (button);
4726     }
4727
4728   if (!GTK_WIDGET_VISIBLE (window))
4729     gtk_widget_show (window);
4730   else
4731     gtk_widget_destroy (window);
4732 }
4733
4734 /*
4735  * Progress Bar
4736  */
4737 static int progress_timer = 0;
4738
4739 gint
4740 progress_timeout (gpointer data)
4741 {
4742   gfloat new_val;
4743
4744   new_val = GTK_PROGRESS_BAR (data)->percentage;
4745   if (new_val >= 1.0)
4746     new_val = 0.0;
4747   new_val += 0.02;
4748
4749   gtk_progress_bar_update (GTK_PROGRESS_BAR (data), new_val);
4750
4751   return TRUE;
4752 }
4753
4754 static void
4755 destroy_progress (GtkWidget  *widget,
4756                   GtkWidget **window)
4757 {
4758   gtk_timeout_remove (progress_timer);
4759   progress_timer = 0;
4760   *window = NULL;
4761 }
4762
4763 void
4764 create_progress_bar ()
4765 {
4766   static GtkWidget *window = NULL;
4767   GtkWidget *button;
4768   GtkWidget *vbox;
4769   GtkWidget *pbar;
4770   GtkWidget *label;
4771
4772   if (!window)
4773     {
4774       window = gtk_dialog_new ();
4775
4776       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4777                           GTK_SIGNAL_FUNC(destroy_progress),
4778                           &window);
4779
4780       gtk_window_set_title (GTK_WINDOW (window), "dialog");
4781       gtk_container_border_width (GTK_CONTAINER (window), 0);
4782
4783
4784       vbox = gtk_vbox_new (FALSE, 5);
4785       gtk_container_border_width (GTK_CONTAINER (vbox), 10);
4786       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
4787                           vbox, TRUE, TRUE, 0);
4788       gtk_widget_show (vbox);
4789
4790       label = gtk_label_new ("progress...");
4791       gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
4792       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
4793       gtk_widget_show (label);
4794
4795       pbar = gtk_progress_bar_new ();
4796       gtk_widget_set_usize (pbar, 200, 20);
4797       gtk_box_pack_start (GTK_BOX (vbox), pbar, TRUE, TRUE, 0);
4798       gtk_widget_show (pbar);
4799
4800       progress_timer = gtk_timeout_add (100, progress_timeout, pbar);
4801
4802       button = gtk_button_new_with_label ("close");
4803       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4804                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
4805                                  GTK_OBJECT (window));
4806       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4807       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
4808                           button, TRUE, TRUE, 0);
4809       gtk_widget_grab_default (button);
4810       gtk_widget_show (button);
4811     }
4812
4813   if (!GTK_WIDGET_VISIBLE (window))
4814     gtk_widget_show (window);
4815   else
4816     gtk_widget_destroy (window);
4817 }
4818
4819
4820 /*
4821  * Color Preview
4822  */
4823 static int color_idle = 0;
4824
4825 gint
4826 color_idle_func (GtkWidget *preview)
4827 {
4828   static int count = 1;
4829   guchar buf[768];
4830   int i, j, k;
4831
4832   for (i = 0; i < 256; i++)
4833     {
4834       for (j = 0, k = 0; j < 256; j++)
4835         {
4836           buf[k+0] = i + count;
4837           buf[k+1] = 0;
4838           buf[k+2] = j + count;
4839           k += 3;
4840         }
4841
4842       gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
4843     }
4844
4845   count += 1;
4846
4847   gtk_widget_draw (preview, NULL);
4848
4849   return TRUE;
4850 }
4851
4852 static void
4853 color_preview_destroy (GtkWidget  *widget,
4854                        GtkWidget **window)
4855 {
4856   gtk_idle_remove (color_idle);
4857   color_idle = 0;
4858
4859   *window = NULL;
4860 }
4861
4862 void
4863 create_color_preview ()
4864 {
4865   static GtkWidget *window = NULL;
4866   GtkWidget *preview;
4867   guchar buf[768];
4868   int i, j, k;
4869
4870   if (!window)
4871     {
4872       gtk_widget_push_visual (gtk_preview_get_visual ());
4873       gtk_widget_push_colormap (gtk_preview_get_cmap ());
4874
4875       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4876
4877       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4878                           GTK_SIGNAL_FUNC(color_preview_destroy),
4879                           &window);
4880
4881       gtk_window_set_title (GTK_WINDOW (window), "test");
4882       gtk_container_border_width (GTK_CONTAINER (window), 10);
4883
4884       preview = gtk_preview_new (GTK_PREVIEW_COLOR);
4885       gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
4886       gtk_container_add (GTK_CONTAINER (window), preview);
4887       gtk_widget_show (preview);
4888
4889       for (i = 0; i < 256; i++)
4890         {
4891           for (j = 0, k = 0; j < 256; j++)
4892             {
4893               buf[k+0] = i;
4894               buf[k+1] = 0;
4895               buf[k+2] = j;
4896               k += 3;
4897             }
4898
4899           gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
4900         }
4901
4902       color_idle = gtk_idle_add ((GtkFunction) color_idle_func, preview);
4903
4904       gtk_widget_pop_colormap ();
4905       gtk_widget_pop_visual ();
4906     }
4907
4908   if (!GTK_WIDGET_VISIBLE (window))
4909     gtk_widget_show (window);
4910   else
4911     gtk_widget_destroy (window);
4912 }
4913
4914
4915 /*
4916  * Gray Preview
4917  */
4918 static int gray_idle = 0;
4919
4920 gint
4921 gray_idle_func (GtkWidget *preview)
4922 {
4923   static int count = 1;
4924   guchar buf[256];
4925   int i, j;
4926
4927   for (i = 0; i < 256; i++)
4928     {
4929       for (j = 0; j < 256; j++)
4930         buf[j] = i + j + count;
4931
4932       gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
4933     }
4934
4935   count += 1;
4936
4937   gtk_widget_draw (preview, NULL);
4938
4939   return TRUE;
4940 }
4941
4942 static void
4943 gray_preview_destroy (GtkWidget  *widget,
4944                       GtkWidget **window)
4945 {
4946   gtk_idle_remove (gray_idle);
4947   gray_idle = 0;
4948
4949   *window = NULL;
4950 }
4951
4952 void
4953 create_gray_preview ()
4954 {
4955   static GtkWidget *window = NULL;
4956   GtkWidget *preview;
4957   guchar buf[256];
4958   int i, j;
4959
4960   if (!window)
4961     {
4962       gtk_widget_push_visual (gtk_preview_get_visual ());
4963       gtk_widget_push_colormap (gtk_preview_get_cmap ());
4964
4965       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4966
4967       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4968                           GTK_SIGNAL_FUNC(gray_preview_destroy),
4969                           &window);
4970
4971       gtk_window_set_title (GTK_WINDOW (window), "test");
4972       gtk_container_border_width (GTK_CONTAINER (window), 10);
4973
4974       preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
4975       gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
4976       gtk_container_add (GTK_CONTAINER (window), preview);
4977       gtk_widget_show (preview);
4978
4979       for (i = 0; i < 256; i++)
4980         {
4981           for (j = 0; j < 256; j++)
4982             buf[j] = i + j;
4983
4984           gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
4985         }
4986
4987       gray_idle = gtk_idle_add ((GtkFunction) gray_idle_func, preview);
4988
4989       gtk_widget_pop_colormap ();
4990       gtk_widget_pop_visual ();
4991     }
4992
4993   if (!GTK_WIDGET_VISIBLE (window))
4994     gtk_widget_show (window);
4995   else
4996     gtk_widget_destroy (window);
4997 }
4998
4999
5000 /*
5001  * Selection Test
5002  */
5003 void
5004 selection_test_received (GtkWidget *list, GtkSelectionData *data)
5005 {
5006   GdkAtom *atoms;
5007   GtkWidget *list_item;
5008   GList *item_list;
5009   int i, l;
5010
5011   if (data->length < 0)
5012     {
5013       g_print ("Selection retrieval failed\n");
5014       return;
5015     }
5016   if (data->type != GDK_SELECTION_TYPE_ATOM)
5017     {
5018       g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
5019       return;
5020     }
5021
5022   /* Clear out any current list items */
5023
5024   gtk_list_clear_items (GTK_LIST(list), 0, -1);
5025
5026   /* Add new items to list */
5027
5028   atoms = (GdkAtom *)data->data;
5029
5030   item_list = NULL;
5031   l = data->length / sizeof (GdkAtom);
5032   for (i = 0; i < l; i++)
5033     {
5034       char *name;
5035       name = gdk_atom_name (atoms[i]);
5036       if (name != NULL)
5037         {
5038           list_item = gtk_list_item_new_with_label (name);
5039           g_free (name);
5040         }
5041       else
5042         list_item = gtk_list_item_new_with_label ("(bad atom)");
5043
5044       gtk_widget_show (list_item);
5045       item_list = g_list_append (item_list, list_item);
5046     }
5047
5048   gtk_list_append_items (GTK_LIST (list), item_list);
5049
5050   return;
5051 }
5052
5053 void
5054 selection_test_get_targets (GtkWidget *widget, GtkWidget *list)
5055 {
5056   static GdkAtom targets_atom = GDK_NONE;
5057
5058   if (targets_atom == GDK_NONE)
5059     targets_atom = gdk_atom_intern ("TARGETS", FALSE);
5060
5061   gtk_selection_convert (list, GDK_SELECTION_PRIMARY, targets_atom,
5062                          GDK_CURRENT_TIME);
5063 }
5064
5065 void
5066 create_selection_test ()
5067 {
5068   static GtkWidget *window = NULL;
5069   GtkWidget *button;
5070   GtkWidget *vbox;
5071   GtkWidget *scrolled_win;
5072   GtkWidget *list;
5073   GtkWidget *label;
5074
5075   if (!window)
5076     {
5077       window = gtk_dialog_new ();
5078
5079       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5080                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5081                           &window);
5082
5083       gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
5084       gtk_container_border_width (GTK_CONTAINER (window), 0);
5085
5086       /* Create the list */
5087
5088       vbox = gtk_vbox_new (FALSE, 5);
5089       gtk_container_border_width (GTK_CONTAINER (vbox), 10);
5090       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox,
5091                           TRUE, TRUE, 0);
5092       gtk_widget_show (vbox);
5093
5094       label = gtk_label_new ("Gets available targets for current selection");
5095       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
5096       gtk_widget_show (label);
5097
5098       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
5099       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
5100                                       GTK_POLICY_AUTOMATIC,
5101                                       GTK_POLICY_AUTOMATIC);
5102       gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
5103       gtk_widget_set_usize (scrolled_win, 100, 200);
5104       gtk_widget_show (scrolled_win);
5105
5106       list = gtk_list_new ();
5107       gtk_container_add (GTK_CONTAINER (scrolled_win), list);
5108
5109       gtk_signal_connect (GTK_OBJECT(list), "selection_received",
5110                           GTK_SIGNAL_FUNC (selection_test_received), NULL);
5111       gtk_widget_show (list);
5112
5113       /* .. And create some buttons */
5114       button = gtk_button_new_with_label ("Get Targets");
5115       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5116                           button, TRUE, TRUE, 0);
5117
5118       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5119                           GTK_SIGNAL_FUNC (selection_test_get_targets), list);
5120       gtk_widget_show (button);
5121
5122       button = gtk_button_new_with_label ("Quit");
5123       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5124                           button, TRUE, TRUE, 0);
5125
5126       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5127                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
5128                                  GTK_OBJECT (window));
5129       gtk_widget_show (button);
5130     }
5131
5132   if (!GTK_WIDGET_VISIBLE (window))
5133     gtk_widget_show (window);
5134   else
5135     gtk_widget_destroy (window);
5136 }
5137
5138
5139 /*
5140  * Gamma Curve
5141  */
5142 void
5143 create_gamma_curve ()
5144 {
5145   static GtkWidget *window = NULL, *curve;
5146   static int count = 0;
5147   gfloat vec[256];
5148   gint max;
5149   gint i;
5150
5151   if (!window)
5152     {
5153       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5154       gtk_window_set_title (GTK_WINDOW (window), "test");
5155       gtk_container_border_width (GTK_CONTAINER (window), 10);
5156
5157       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5158                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5159                           &window);
5160
5161       curve = gtk_gamma_curve_new ();
5162       gtk_container_add (GTK_CONTAINER (window), curve);
5163       gtk_widget_show (curve);
5164     }
5165
5166   max = 127 + (count % 2)*128;
5167   gtk_curve_set_range (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
5168                        0, max, 0, max);
5169   for (i = 0; i < max; ++i)
5170     vec[i] = (127 / sqrt (max)) * sqrt (i);
5171   gtk_curve_set_vector (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
5172                         max, vec);
5173
5174   if (!GTK_WIDGET_VISIBLE (window))
5175     gtk_widget_show (window);
5176   else if (count % 4 == 3)
5177     {
5178       gtk_widget_destroy (window);
5179       window = NULL;
5180     }
5181
5182   ++count;
5183 }
5184
5185 static int scroll_test_pos = 0.0;
5186 static GdkGC *scroll_test_gc = NULL;
5187
5188 static gint
5189 scroll_test_expose (GtkWidget *widget, GdkEventExpose *event,
5190                     GtkAdjustment *adj)
5191 {
5192   gint i,j;
5193   gint imin, imax, jmin, jmax;
5194
5195   imin = (event->area.x) / 10;
5196   imax = (event->area.x + event->area.width + 9) / 10;
5197
5198   jmin = ((int)adj->value + event->area.y) / 10;
5199   jmax = ((int)adj->value + event->area.y + event->area.height + 9) / 10;
5200
5201   gdk_window_clear_area (widget->window,
5202                          event->area.x, event->area.y,
5203                          event->area.width, event->area.height);
5204
5205   for (i=imin; i<imax; i++)
5206     for (j=jmin; j<jmax; j++)
5207       if ((i+j) % 2)
5208         gdk_draw_rectangle (widget->window,
5209                             widget->style->black_gc,
5210                             TRUE,
5211                             10*i, 10*j - (int)adj->value, 1+i%10, 1+j%10);
5212
5213   return TRUE;
5214 }
5215
5216 static void
5217 scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
5218                        GtkAdjustment *adj)
5219 {
5220   adj->page_increment = 0.9 * widget->allocation.height;
5221   adj->page_size = widget->allocation.height;
5222
5223   gtk_signal_emit_by_name (GTK_OBJECT (adj), "changed");
5224 }
5225
5226 static void
5227 scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
5228 {
5229   gint source_min = (int)adj->value - scroll_test_pos;
5230   gint source_max = source_min + widget->allocation.height;
5231   gint dest_min = 0;
5232   gint dest_max = widget->allocation.height;
5233   GdkRectangle rect;
5234   GdkEvent *event;
5235
5236   scroll_test_pos = adj->value;
5237
5238   if (!GTK_WIDGET_DRAWABLE (widget))
5239     return;
5240
5241   if (source_min < 0)
5242     {
5243       rect.x = 0;
5244       rect.y = 0;
5245       rect.width = widget->allocation.width;
5246       rect.height = -source_min;
5247       if (rect.height > widget->allocation.height)
5248         rect.height = widget->allocation.height;
5249
5250       source_min = 0;
5251       dest_min = rect.height;
5252     }
5253   else
5254     {
5255       rect.x = 0;
5256       rect.y = 2*widget->allocation.height - source_max;
5257       if (rect.y < 0)
5258         rect.y = 0;
5259       rect.width = widget->allocation.width;
5260       rect.height = widget->allocation.height - rect.y;
5261
5262       source_max = widget->allocation.height;
5263       dest_max = rect.y;
5264     }
5265
5266   if (source_min != source_max)
5267     {
5268       if (scroll_test_gc == NULL)
5269         {
5270           scroll_test_gc = gdk_gc_new (widget->window);
5271           gdk_gc_set_exposures (scroll_test_gc, TRUE);
5272         }
5273
5274       gdk_draw_pixmap (widget->window,
5275                        scroll_test_gc,
5276                        widget->window,
5277                        0, source_min,
5278                        0, dest_min,
5279                        widget->allocation.width,
5280                        source_max - source_min);
5281
5282       /* Make sure graphics expose events are processed before scrolling
5283        * again */
5284
5285       while ((event = gdk_event_get_graphics_expose (widget->window)) != NULL)
5286         {
5287           gtk_widget_event (widget, event);
5288           if (event->expose.count == 0)
5289             {
5290               gdk_event_free (event);
5291               break;
5292             }
5293           gdk_event_free (event);
5294         }
5295     }
5296
5297
5298   if (rect.height != 0)
5299     gtk_widget_draw (widget, &rect);
5300 }
5301
5302
5303 void
5304 create_scroll_test ()
5305 {
5306   static GtkWidget *window = NULL;
5307   GtkWidget *hbox;
5308   GtkWidget *drawing_area;
5309   GtkWidget *scrollbar;
5310   GtkWidget *button;
5311   GtkAdjustment *adj;
5312
5313   if (!window)
5314     {
5315       window = gtk_dialog_new ();
5316
5317       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5318                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5319                           &window);
5320
5321       gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
5322       gtk_container_border_width (GTK_CONTAINER (window), 0);
5323
5324       hbox = gtk_hbox_new (FALSE, 0);
5325       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox,
5326                           TRUE, TRUE, 0);
5327       gtk_widget_show (hbox);
5328
5329       drawing_area = gtk_drawing_area_new ();
5330       gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 200, 200);
5331       gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
5332       gtk_widget_show (drawing_area);
5333
5334       gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK);
5335
5336       adj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0));
5337       scroll_test_pos = 0.0;
5338
5339       scrollbar = gtk_vscrollbar_new (adj);
5340       gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
5341       gtk_widget_show (scrollbar);
5342
5343       gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
5344                           GTK_SIGNAL_FUNC (scroll_test_expose), adj);
5345       gtk_signal_connect (GTK_OBJECT (drawing_area), "configure_event",
5346                           GTK_SIGNAL_FUNC (scroll_test_configure), adj);
5347
5348
5349       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
5350                           GTK_SIGNAL_FUNC (scroll_test_adjustment_changed),
5351                           drawing_area);
5352
5353       /* .. And create some buttons */
5354
5355       button = gtk_button_new_with_label ("Quit");
5356       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5357                           button, TRUE, TRUE, 0);
5358
5359       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5360                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
5361                                  GTK_OBJECT (window));
5362       gtk_widget_show (button);
5363     }
5364
5365   if (!GTK_WIDGET_VISIBLE (window))
5366     gtk_widget_show (window);
5367   else
5368     gtk_widget_destroy (window);
5369 }
5370
5371 /*
5372  * Timeout Test
5373  */
5374 static int timer = 0;
5375
5376 gint
5377 timeout_test (GtkWidget *label)
5378 {
5379   static int count = 0;
5380   static char buffer[32];
5381
5382   sprintf (buffer, "count: %d", ++count);
5383   gtk_label_set (GTK_LABEL (label), buffer);
5384
5385   return TRUE;
5386 }
5387
5388 void
5389 start_timeout_test (GtkWidget *widget,
5390                     GtkWidget *label)
5391 {
5392   if (!timer)
5393     {
5394       timer = gtk_timeout_add (100, (GtkFunction) timeout_test, label);
5395     }
5396 }
5397
5398 void
5399 stop_timeout_test (GtkWidget *widget,
5400                    gpointer   data)
5401 {
5402   if (timer)
5403     {
5404       gtk_timeout_remove (timer);
5405       timer = 0;
5406     }
5407 }
5408
5409 void
5410 destroy_timeout_test (GtkWidget  *widget,
5411                       GtkWidget **window)
5412 {
5413   stop_timeout_test (NULL, NULL);
5414
5415   *window = NULL;
5416 }
5417
5418 void
5419 create_timeout_test ()
5420 {
5421   static GtkWidget *window = NULL;
5422   GtkWidget *button;
5423   GtkWidget *label;
5424
5425   if (!window)
5426     {
5427       window = gtk_dialog_new ();
5428
5429       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5430                           GTK_SIGNAL_FUNC(destroy_timeout_test),
5431                           &window);
5432
5433       gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
5434       gtk_container_border_width (GTK_CONTAINER (window), 0);
5435
5436       label = gtk_label_new ("count: 0");
5437       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
5438       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
5439                           label, TRUE, TRUE, 0);
5440       gtk_widget_show (label);
5441
5442       button = gtk_button_new_with_label ("close");
5443       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5444                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
5445                                  GTK_OBJECT (window));
5446       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5447       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5448                           button, TRUE, TRUE, 0);
5449       gtk_widget_grab_default (button);
5450       gtk_widget_show (button);
5451
5452       button = gtk_button_new_with_label ("start");
5453       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5454                           GTK_SIGNAL_FUNC(start_timeout_test),
5455                           label);
5456       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5457       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5458                           button, TRUE, TRUE, 0);
5459       gtk_widget_show (button);
5460
5461       button = gtk_button_new_with_label ("stop");
5462       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5463                           GTK_SIGNAL_FUNC(stop_timeout_test),
5464                           NULL);
5465       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5466       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5467                           button, TRUE, TRUE, 0);
5468       gtk_widget_show (button);
5469     }
5470
5471   if (!GTK_WIDGET_VISIBLE (window))
5472     gtk_widget_show (window);
5473   else
5474     gtk_widget_destroy (window);
5475 }
5476
5477
5478 /*
5479  * Idle Test
5480  */
5481 static int idle = 0;
5482
5483 gint
5484 idle_test (GtkWidget *label)
5485 {
5486   static int count = 0;
5487   static char buffer[32];
5488
5489   sprintf (buffer, "count: %d", ++count);
5490   gtk_label_set (GTK_LABEL (label), buffer);
5491
5492   return TRUE;
5493 }
5494
5495 void
5496 start_idle_test (GtkWidget *widget,
5497                  GtkWidget *label)
5498 {
5499   if (!idle)
5500     {
5501       idle = gtk_idle_add ((GtkFunction) idle_test, label);
5502     }
5503 }
5504
5505 void
5506 stop_idle_test (GtkWidget *widget,
5507                 gpointer   data)
5508 {
5509   if (idle)
5510     {
5511       gtk_idle_remove (idle);
5512       idle = 0;
5513     }
5514 }
5515
5516 void
5517 destroy_idle_test (GtkWidget  *widget,
5518                    GtkWidget **window)
5519 {
5520   stop_idle_test (NULL, NULL);
5521
5522   *window = NULL;
5523 }
5524
5525 void
5526 create_idle_test ()
5527 {
5528   static GtkWidget *window = NULL;
5529   GtkWidget *button;
5530   GtkWidget *label;
5531
5532   if (!window)
5533     {
5534       window = gtk_dialog_new ();
5535
5536       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5537                           GTK_SIGNAL_FUNC(destroy_idle_test),
5538                           &window);
5539
5540       gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
5541       gtk_container_border_width (GTK_CONTAINER (window), 0);
5542
5543       label = gtk_label_new ("count: 0");
5544       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
5545       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
5546                           label, TRUE, TRUE, 0);
5547       gtk_widget_show (label);
5548
5549       button = gtk_button_new_with_label ("close");
5550       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5551                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
5552                                  GTK_OBJECT (window));
5553       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5554       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5555                           button, TRUE, TRUE, 0);
5556       gtk_widget_grab_default (button);
5557       gtk_widget_show (button);
5558
5559       button = gtk_button_new_with_label ("start");
5560       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5561                           GTK_SIGNAL_FUNC(start_idle_test),
5562                           label);
5563       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5564       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5565                           button, TRUE, TRUE, 0);
5566       gtk_widget_show (button);
5567
5568       button = gtk_button_new_with_label ("stop");
5569       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5570                           GTK_SIGNAL_FUNC(stop_idle_test),
5571                           NULL);
5572       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5573       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5574                           button, TRUE, TRUE, 0);
5575       gtk_widget_show (button);
5576     }
5577
5578   if (!GTK_WIDGET_VISIBLE (window))
5579     gtk_widget_show (window);
5580   else
5581     gtk_widget_destroy (window);
5582 }
5583
5584 /*
5585  * Test of recursive mainloop
5586  */
5587
5588 void
5589 mainloop_destroyed (GtkWidget *w, GtkWidget **window)
5590 {
5591   *window = NULL;
5592   gtk_main_quit ();
5593 }
5594
5595 void
5596 create_mainloop ()
5597 {
5598   static GtkWidget *window = NULL;
5599   GtkWidget *label;
5600   GtkWidget *button;
5601
5602   if (!window)
5603     {
5604       window = gtk_dialog_new ();
5605
5606       gtk_window_set_title (GTK_WINDOW (window), "Test Main Loop");
5607
5608       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5609                           GTK_SIGNAL_FUNC(mainloop_destroyed),
5610                           &window);
5611
5612       label = gtk_label_new ("In recursive main loop...");
5613       gtk_misc_set_padding (GTK_MISC(label), 20, 20);
5614
5615       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), label,
5616                           TRUE, TRUE, 0);
5617       gtk_widget_show (label);
5618
5619       button = gtk_button_new_with_label ("Leave");
5620       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button,
5621                           FALSE, TRUE, 0);
5622
5623       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5624                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
5625                                  GTK_OBJECT (window));
5626
5627       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5628       gtk_widget_grab_default (button);
5629
5630       gtk_widget_show (button);
5631     }
5632
5633   if (!GTK_WIDGET_VISIBLE (window))
5634     {
5635       gtk_widget_show (window);
5636
5637       g_print ("create_mainloop: start\n");
5638       gtk_main ();
5639       g_print ("create_mainloop: done\n");
5640     }
5641   else
5642     gtk_widget_destroy (window);
5643 }
5644
5645
5646 /*
5647  * Main Window and Exit
5648  */
5649 void
5650 do_exit (GtkWidget *widget, GtkWidget *window)
5651 {
5652   gtk_widget_destroy (window);
5653   gtk_main_quit ();
5654 }
5655
5656 void
5657 create_main_window ()
5658 {
5659   struct {
5660     char *label;
5661     void (*func) ();
5662   } buttons[] =
5663     {
5664       { "button box", create_button_box },
5665       { "buttons", create_buttons },
5666       { "check buttons", create_check_buttons },
5667       { "clist", create_clist},
5668       { "color selection", create_color_selection },
5669       { "cursors", create_cursors },
5670       { "dialog", create_dialog },
5671       { "dnd", create_dnd },
5672       { "entry", create_entry },
5673       { "file selection", create_file_selection },
5674       { "gamma curve", create_gamma_curve },
5675       { "handle box", create_handle_box },
5676       { "list", create_list },
5677       { "menus", create_menus },
5678       { "miscellaneous", NULL },
5679       { "notebook", create_notebook },
5680       { "panes", create_panes },
5681       { "pixmap", create_pixmap },
5682       { "preview color", create_color_preview },
5683       { "preview gray", create_gray_preview },
5684       { "progress bar", create_progress_bar },
5685       { "radio buttons", create_radio_buttons },
5686       { "range controls", create_range_controls },
5687       { "reparent", create_reparent },
5688       { "rulers", create_rulers },
5689       { "scrolled windows", create_scrolled_windows },
5690       { "shapes", create_shapes },
5691       { "spinbutton", create_spins },
5692       { "statusbar", create_statusbar },
5693       { "test idle", create_idle_test },
5694       { "test mainloop", create_mainloop },
5695       { "test scrolling", create_scroll_test },
5696       { "test selection", create_selection_test },
5697       { "test timeout", create_timeout_test },
5698       { "text", create_text },
5699       { "toggle buttons", create_toggle_buttons },
5700       { "toolbar", create_toolbar },
5701       { "tooltips", create_tooltips },
5702       { "tree", create_tree_mode_window},
5703       { "WM hints", create_wmhints },
5704     };
5705   int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
5706   GtkWidget *window;
5707   GtkWidget *box1;
5708   GtkWidget *box2;
5709   GtkWidget *scrolled_window;
5710   GtkWidget *button;
5711   GtkWidget *label;
5712   gchar buffer[64];
5713   GtkWidget *separator;
5714   int i;
5715
5716   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5717   gtk_widget_set_name (window, "main window");
5718   gtk_widget_set_usize (window, 200, 400);
5719   gtk_widget_set_uposition (window, 20, 20);
5720
5721   gtk_signal_connect (GTK_OBJECT (window), "destroy",
5722                       GTK_SIGNAL_FUNC(gtk_main_quit),
5723                       NULL);
5724   gtk_signal_connect (GTK_OBJECT (window), "delete_event",
5725                       GTK_SIGNAL_FUNC (gtk_false),
5726                       NULL);
5727
5728   box1 = gtk_vbox_new (FALSE, 0);
5729   gtk_container_add (GTK_CONTAINER (window), box1);
5730   gtk_widget_show (box1);
5731
5732   if (gtk_micro_version > 0)
5733     sprintf (buffer,
5734              "Gtk+ v%d.%d.%d",
5735              gtk_major_version,
5736              gtk_minor_version,
5737              gtk_micro_version);
5738   else
5739     sprintf (buffer,
5740              "Gtk+ v%d.%d",
5741              gtk_major_version,
5742              gtk_minor_version);
5743
5744   label = gtk_label_new (buffer);
5745   gtk_widget_show (label);
5746   gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
5747
5748   scrolled_window = gtk_scrolled_window_new (NULL, NULL);
5749   gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
5750   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
5751                                   GTK_POLICY_AUTOMATIC,
5752                                   GTK_POLICY_AUTOMATIC);
5753   gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
5754   gtk_widget_show (scrolled_window);
5755
5756   box2 = gtk_vbox_new (FALSE, 0);
5757   gtk_container_border_width (GTK_CONTAINER (box2), 10);
5758   gtk_container_add (GTK_CONTAINER (scrolled_window), box2);
5759   gtk_widget_show (box2);
5760
5761   for (i = 0; i < nbuttons; i++)
5762     {
5763       button = gtk_button_new_with_label (buttons[i].label);
5764       if (buttons[i].func)
5765         gtk_signal_connect (GTK_OBJECT (button),
5766                             "clicked",
5767                             GTK_SIGNAL_FUNC(buttons[i].func),
5768                             NULL);
5769       else
5770         gtk_widget_set_sensitive (button, FALSE);
5771       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5772       gtk_widget_show (button);
5773     }
5774
5775   separator = gtk_hseparator_new ();
5776   gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5777   gtk_widget_show (separator);
5778
5779   box2 = gtk_vbox_new (FALSE, 10);
5780   gtk_container_border_width (GTK_CONTAINER (box2), 10);
5781   gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5782   gtk_widget_show (box2);
5783
5784   button = gtk_button_new_with_label ("close");
5785   gtk_signal_connect (GTK_OBJECT (button), "clicked",
5786                       GTK_SIGNAL_FUNC (do_exit),
5787                       window);
5788   gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5789   GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5790   gtk_widget_grab_default (button);
5791   gtk_widget_show (button);
5792
5793   gtk_widget_show (window);
5794 }
5795
5796 int
5797 main (int argc, char *argv[])
5798 {
5799   gtk_set_locale ();
5800
5801   gtk_init (&argc, &argv);
5802
5803 #ifdef HAVE_LIBGLE
5804   gle_init (&argc, &argv);
5805 #endif /* !HAVE_LIBGLE */
5806
5807   gtk_rc_parse ("testgtkrc");
5808
5809   create_main_window ();
5810
5811   gtk_main ();
5812
5813   return 0;
5814 }