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 /* Variables used by the Drag/Drop and Shape Window demos */
  27 static GtkWidget *modeller = NULL;
  28 static GtkWidget *sheets = NULL;
  29 static GtkWidget *rings = NULL;
  30 void create_shapes(void);
  31
  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 *hbox;
1468   GtkWidget *toolbar;
1469   GtkWidget *label;
1470
1471   if (!window)
1472   {
1473     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1474     gtk_window_set_title (GTK_WINDOW (window),
1475                           "Handle Box Test");
1476
1477     gtk_signal_connect (GTK_OBJECT (window), "destroy",
1478                         GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1479                         &window);
1480
1481     gtk_container_border_width (GTK_CONTAINER (window), 20);
1482
1483     hbox = gtk_hbox_new (FALSE, 10);
1484     gtk_container_add (GTK_CONTAINER (window), hbox);
1485     gtk_widget_show (hbox);
1486
1487     handle_box = gtk_handle_box_new ();
1488     gtk_container_add (GTK_CONTAINER (hbox), handle_box);
1489     gtk_signal_connect (GTK_OBJECT (handle_box),
1490                         "child_attached",
1491                         GTK_SIGNAL_FUNC (handle_box_child_signal),
1492                         "attached");
1493     gtk_signal_connect (GTK_OBJECT (handle_box),
1494                         "child_detached",
1495                         GTK_SIGNAL_FUNC (handle_box_child_signal),
1496                         "detached");
1497     gtk_widget_show (handle_box);
1498
1499     toolbar = make_toolbar (window);
1500     gtk_container_add (GTK_CONTAINER (handle_box), toolbar);
1501     gtk_widget_show (toolbar);
1502
1503     handle_box = gtk_handle_box_new ();
1504     gtk_container_add (GTK_CONTAINER (hbox), handle_box);
1505     gtk_signal_connect (GTK_OBJECT (handle_box),
1506                         "child_attached",
1507                         GTK_SIGNAL_FUNC (handle_box_child_signal),
1508                         "attached");
1509     gtk_signal_connect (GTK_OBJECT (handle_box),
1510                         "child_detached",
1511                         GTK_SIGNAL_FUNC (handle_box_child_signal),
1512                         "detached");
1513     gtk_widget_show (handle_box);
1514
1515     label = gtk_label_new ("Fooo!");
1516     gtk_container_add (GTK_CONTAINER (handle_box), label);
1517     gtk_widget_show (label);
1518   }
1519
1520   if (!GTK_WIDGET_VISIBLE (window))
1521     gtk_widget_show (window);
1522   else
1523     gtk_widget_destroy (window);
1524 }
1525
1526
1527 static void
1528 reparent_label (GtkWidget *widget,
1529                 GtkWidget *new_parent)
1530 {
1531   GtkWidget *label;
1532
1533   label = gtk_object_get_user_data (GTK_OBJECT (widget));
1534
1535   gtk_widget_reparent (label, new_parent);
1536 }
1537
1538 static void
1539 set_parent_signal (GtkWidget *child,
1540                    GtkWidget *old_parent,
1541                    gpointer   func_data)
1542 {
1543   g_print ("set_parent for \"%s\": new parent: \"%s\", old parent: \"%s\", data: %d\n",
1544            gtk_type_name (GTK_OBJECT_TYPE (child)),
1545            child->parent ? gtk_type_name (GTK_OBJECT_TYPE (child->parent)) : "NULL",
1546            old_parent ? gtk_type_name (GTK_OBJECT_TYPE (old_parent)) : "NULL",
1547            (gint) func_data);
1548 }
1549
1550 static void
1551 create_reparent ()
1552 {
1553   static GtkWidget *window = NULL;
1554   GtkWidget *box1;
1555   GtkWidget *box2;
1556   GtkWidget *box3;
1557   GtkWidget *frame;
1558   GtkWidget *button;
1559   GtkWidget *label;
1560   GtkWidget *separator;
1561
1562   if (!window)
1563     {
1564       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1565
1566       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1567                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1568                           &window);
1569
1570       gtk_window_set_title (GTK_WINDOW (window), "buttons");
1571       gtk_container_border_width (GTK_CONTAINER (window), 0);
1572
1573
1574       box1 = gtk_vbox_new (FALSE, 0);
1575       gtk_container_add (GTK_CONTAINER (window), box1);
1576       gtk_widget_show (box1);
1577
1578
1579       box2 = gtk_hbox_new (FALSE, 5);
1580       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1581       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1582       gtk_widget_show (box2);
1583
1584
1585       label = gtk_label_new ("Hello World");
1586
1587       frame = gtk_frame_new ("Frame 1");
1588       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
1589       gtk_widget_show (frame);
1590
1591       box3 = gtk_vbox_new (FALSE, 5);
1592       gtk_container_border_width (GTK_CONTAINER (box3), 5);
1593       gtk_container_add (GTK_CONTAINER (frame), box3);
1594       gtk_widget_show (box3);
1595
1596       button = gtk_button_new_with_label ("switch");
1597       gtk_signal_connect (GTK_OBJECT (button), "clicked",
1598                           GTK_SIGNAL_FUNC(reparent_label),
1599                           box3);
1600       gtk_object_set_user_data (GTK_OBJECT (button), label);
1601       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
1602       gtk_widget_show (button);
1603
1604       gtk_box_pack_start (GTK_BOX (box3), label, FALSE, TRUE, 0);
1605       gtk_signal_connect (GTK_OBJECT (label),
1606                           "parent_set",
1607                           GTK_SIGNAL_FUNC (set_parent_signal),
1608                           (GtkObject*) 42);
1609       gtk_widget_show (label);
1610
1611
1612       frame = gtk_frame_new ("Frame 2");
1613       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
1614       gtk_widget_show (frame);
1615
1616       box3 = gtk_vbox_new (FALSE, 5);
1617       gtk_container_border_width (GTK_CONTAINER (box3), 5);
1618       gtk_container_add (GTK_CONTAINER (frame), box3);
1619       gtk_widget_show (box3);
1620
1621       button = gtk_button_new_with_label ("switch");
1622       gtk_signal_connect (GTK_OBJECT (button), "clicked",
1623                           GTK_SIGNAL_FUNC(reparent_label),
1624                           box3);
1625       gtk_object_set_user_data (GTK_OBJECT (button), label);
1626       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
1627       gtk_widget_show (button);
1628
1629
1630       separator = gtk_hseparator_new ();
1631       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1632       gtk_widget_show (separator);
1633
1634
1635       box2 = gtk_vbox_new (FALSE, 10);
1636       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1637       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1638       gtk_widget_show (box2);
1639
1640
1641       button = gtk_button_new_with_label ("close");
1642       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1643                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1644                                  GTK_OBJECT (window));
1645       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1646       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1647       gtk_widget_grab_default (button);
1648       gtk_widget_show (button);
1649     }
1650
1651   if (!GTK_WIDGET_VISIBLE (window))
1652     gtk_widget_show (window);
1653   else
1654     gtk_widget_destroy (window);
1655 }
1656
1657 static void
1658 create_pixmap ()
1659 {
1660   static GtkWidget *window = NULL;
1661   GtkWidget *box1;
1662   GtkWidget *box2;
1663   GtkWidget *box3;
1664   GtkWidget *button;
1665   GtkWidget *label;
1666   GtkWidget *separator;
1667   GtkWidget *pixmapwid;
1668   GdkPixmap *pixmap;
1669   GdkBitmap *mask;
1670   GtkStyle *style;
1671
1672   if (!window)
1673     {
1674       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1675
1676       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1677                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1678                           &window);
1679
1680       gtk_window_set_title (GTK_WINDOW (window), "pixmap");
1681       gtk_container_border_width (GTK_CONTAINER (window), 0);
1682       gtk_widget_realize(window);
1683
1684       box1 = gtk_vbox_new (FALSE, 0);
1685       gtk_container_add (GTK_CONTAINER (window), box1);
1686       gtk_widget_show (box1);
1687
1688       box2 = gtk_vbox_new (FALSE, 10);
1689       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1690       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1691       gtk_widget_show (box2);
1692
1693       button = gtk_button_new ();
1694       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
1695       gtk_widget_show (button);
1696
1697       style=gtk_widget_get_style(button);
1698
1699       pixmap = gdk_pixmap_create_from_xpm (window->window, &mask,
1700                                            &style->bg[GTK_STATE_NORMAL],
1701                                            "test.xpm");
1702       pixmapwid = gtk_pixmap_new (pixmap, mask);
1703
1704       label = gtk_label_new ("Pixmap\ntest");
1705       box3 = gtk_hbox_new (FALSE, 0);
1706       gtk_container_border_width (GTK_CONTAINER (box3), 2);
1707       gtk_container_add (GTK_CONTAINER (box3), pixmapwid);
1708       gtk_container_add (GTK_CONTAINER (box3), label);
1709       gtk_container_add (GTK_CONTAINER (button), box3);
1710       gtk_widget_show (pixmapwid);
1711       gtk_widget_show (label);
1712       gtk_widget_show (box3);
1713
1714       separator = gtk_hseparator_new ();
1715       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1716       gtk_widget_show (separator);
1717
1718
1719       box2 = gtk_vbox_new (FALSE, 10);
1720       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1721       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1722       gtk_widget_show (box2);
1723
1724
1725       button = gtk_button_new_with_label ("close");
1726       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1727                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1728                                  GTK_OBJECT (window));
1729       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1730       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1731       gtk_widget_grab_default (button);
1732       gtk_widget_show (button);
1733     }
1734
1735   if (!GTK_WIDGET_VISIBLE (window))
1736     gtk_widget_show (window);
1737   else
1738     gtk_widget_destroy (window);
1739 }
1740
1741 static void
1742 tips_query_widget_entered (GtkTipsQuery   *tips_query,
1743                            GtkWidget      *widget,
1744                            const gchar    *tip_text,
1745                            const gchar    *tip_private,
1746                            GtkWidget      *toggle)
1747 {
1748   if (GTK_TOGGLE_BUTTON (toggle)->active)
1749     {
1750       gtk_label_set (GTK_LABEL (tips_query), tip_text ? "There is a Tip!" : "There is no Tip!");
1751       /* don't let GtkTipsQuery reset it's label */
1752       gtk_signal_emit_stop_by_name (GTK_OBJECT (tips_query), "widget_entered");
1753     }
1754 }
1755
1756 static gint
1757 tips_query_widget_selected (GtkWidget      *tips_query,
1758                             GtkWidget      *widget,
1759                             const gchar    *tip_text,
1760                             const gchar    *tip_private,
1761                             GdkEventButton *event,
1762                             gpointer        func_data)
1763 {
1764   if (widget)
1765     g_print ("Help \"%s\" requested for <%s>\n",
1766              tip_private ? tip_private : "None",
1767              gtk_type_name (GTK_OBJECT_TYPE (widget)));
1768
1769   return TRUE;
1770 }
1771
1772 static void
1773 create_tooltips ()
1774 {
1775   static GtkWidget *window = NULL;
1776   GtkWidget *box1;
1777   GtkWidget *box2;
1778   GtkWidget *box3;
1779   GtkWidget *button;
1780   GtkWidget *toggle;
1781   GtkWidget *frame;
1782   GtkWidget *tips_query;
1783   GtkWidget *separator;
1784   GtkTooltips *tooltips;
1785
1786   if (!window)
1787     {
1788       window =
1789         gtk_widget_new (gtk_window_get_type (),
1790                         "GtkWindow::type", GTK_WINDOW_TOPLEVEL,
1791                         "GtkContainer::border_width", 0,
1792                         "GtkWindow::title", "Tooltips",
1793                         "GtkWindow::allow_shrink", TRUE,
1794                         "GtkWindow::allow_grow", FALSE,
1795                         "GtkWindow::auto_shrink", TRUE,
1796                         "GtkWidget::width", 200,
1797                         NULL);
1798
1799       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1800                           GTK_SIGNAL_FUNC (destroy_tooltips),
1801                           &window);
1802
1803       tooltips=gtk_tooltips_new();
1804       gtk_object_set_data (GTK_OBJECT (window), "tooltips", tooltips);
1805
1806       box1 = gtk_vbox_new (FALSE, 0);
1807       gtk_container_add (GTK_CONTAINER (window), box1);
1808       gtk_widget_show (box1);
1809
1810
1811       box2 = gtk_vbox_new (FALSE, 10);
1812       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1813       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1814       gtk_widget_show (box2);
1815
1816
1817       button = gtk_toggle_button_new_with_label ("button1");
1818       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1819       gtk_widget_show (button);
1820
1821       gtk_tooltips_set_tip (tooltips,button,"This is button 1", "ContextHelp/buttons/1");
1822
1823       button = gtk_toggle_button_new_with_label ("button2");
1824       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1825       gtk_widget_show (button);
1826
1827       gtk_tooltips_set_tip (tooltips,
1828                             button,
1829                             "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.",
1830                             "ContextHelp/buttons/2_long");
1831
1832       toggle = gtk_toggle_button_new_with_label ("Override TipsQuery Label");
1833       gtk_box_pack_start (GTK_BOX (box2), toggle, TRUE, TRUE, 0);
1834       gtk_widget_show (toggle);
1835
1836       gtk_tooltips_set_tip (tooltips, toggle, "Toggle TipsQuery view.", "Hi msw! ;)");
1837
1838       box3 =
1839         gtk_widget_new (gtk_vbox_get_type (),
1840                         "GtkBox::homogeneous", FALSE,
1841                         "GtkBox::spacing", 5,
1842                         "GtkContainer::border_width", 5,
1843                         "GtkWidget::visible", TRUE,
1844                         NULL);
1845
1846       tips_query = gtk_tips_query_new ();
1847
1848       button =
1849         gtk_widget_new (gtk_button_get_type (),
1850                         "GtkButton::label", "[?]",
1851                         "GtkWidget::visible", TRUE,
1852                         "GtkWidget::parent", box3,
1853                         "GtkObject::object_signal::clicked", gtk_tips_query_start_query, tips_query,
1854                         NULL);
1855       gtk_box_set_child_packing (GTK_BOX (box3), button, FALSE, FALSE, 0, GTK_PACK_START);
1856       gtk_tooltips_set_tip (tooltips,
1857                             button,
1858                             "Start the Tooltips Inspector",
1859                             "ContextHelp/buttons/?");
1860
1861
1862       gtk_widget_set (tips_query,
1863                       "GtkWidget::visible", TRUE,
1864                       "GtkWidget::parent", box3,
1865                       "GtkTipsQuery::caller", button,
1866                       "GtkObject::signal::widget_entered", tips_query_widget_entered, toggle,
1867                       "GtkObject::signal::widget_selected", tips_query_widget_selected, NULL,
1868                       NULL);
1869
1870       frame =
1871         gtk_widget_new (gtk_frame_get_type (),
1872                         "GtkFrame::label", "ToolTips Inspector",
1873                         "GtkFrame::label_xalign", (double) 0.5,
1874                         "GtkContainer::border_width", 0,
1875                         "GtkWidget::visible", TRUE,
1876                         "GtkWidget::parent", box2,
1877                         "GtkContainer::child", box3,
1878                         NULL);
1879       gtk_box_set_child_packing (GTK_BOX (box2), frame, TRUE, TRUE, 10, GTK_PACK_START);
1880
1881       separator = gtk_hseparator_new ();
1882       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1883       gtk_widget_show (separator);
1884
1885
1886       box2 = gtk_vbox_new (FALSE, 10);
1887       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1888       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1889       gtk_widget_show (box2);
1890
1891
1892       button = gtk_button_new_with_label ("close");
1893       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1894                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1895                                  GTK_OBJECT (window));
1896       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1897       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1898       gtk_widget_grab_default (button);
1899       gtk_widget_show (button);
1900
1901       gtk_tooltips_set_tip (tooltips, button, "Push this button to close window", "ContextHelp/buttons/Close");
1902     }
1903
1904   if (!GTK_WIDGET_VISIBLE (window))
1905     gtk_widget_show (window);
1906   else
1907     gtk_widget_destroy (window);
1908 }
1909
1910 static GtkWidget*
1911 create_menu (int depth)
1912 {
1913   GtkWidget *menu;
1914   GtkWidget *menuitem;
1915   GSList *group;
1916   char buf[32];
1917   int i, j;
1918
1919   if (depth < 1)
1920     return NULL;
1921
1922   menu = gtk_menu_new ();
1923   group = NULL;
1924
1925   for (i = 0, j = 1; i < 5; i++, j++)
1926     {
1927       sprintf (buf, "item %2d - %d", depth, j);
1928       menuitem = gtk_radio_menu_item_new_with_label (group, buf);
1929       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
1930       if (depth % 2)
1931         gtk_check_menu_item_set_show_toggle (GTK_CHECK_MENU_ITEM (menuitem), TRUE);
1932       gtk_menu_append (GTK_MENU (menu), menuitem);
1933       gtk_widget_show (menuitem);
1934       if (i == 3)
1935         gtk_widget_set_sensitive (menuitem, FALSE);
1936
1937       gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (depth - 1));
1938     }
1939
1940   return menu;
1941 }
1942
1943 static void
1944 create_menus ()
1945 {
1946   static GtkWidget *window = NULL;
1947   GtkWidget *box1;
1948   GtkWidget *box2;
1949   GtkWidget *button;
1950   GtkWidget *menu;
1951   GtkWidget *menubar;
1952   GtkWidget *menuitem;
1953   GtkWidget *optionmenu;
1954   GtkWidget *separator;
1955
1956   if (!window)
1957     {
1958       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1959
1960       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1961                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1962                           &window);
1963       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
1964                           GTK_SIGNAL_FUNC (gtk_true),
1965                           NULL);
1966
1967       gtk_window_set_title (GTK_WINDOW (window), "menus");
1968       gtk_container_border_width (GTK_CONTAINER (window), 0);
1969
1970
1971       box1 = gtk_vbox_new (FALSE, 0);
1972       gtk_container_add (GTK_CONTAINER (window), box1);
1973       gtk_widget_show (box1);
1974
1975
1976       menubar = gtk_menu_bar_new ();
1977       gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
1978       gtk_widget_show (menubar);
1979
1980       menu = create_menu (2);
1981
1982       menuitem = gtk_menu_item_new_with_label ("test\nline2");
1983       gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
1984       gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
1985       gtk_widget_show (menuitem);
1986
1987       menuitem = gtk_menu_item_new_with_label ("foo");
1988       gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (3));
1989       gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
1990       gtk_widget_show (menuitem);
1991
1992       menuitem = gtk_menu_item_new_with_label ("bar");
1993       gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4));
1994       gtk_menu_item_right_justify (GTK_MENU_ITEM (menuitem));
1995       gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
1996       gtk_widget_show (menuitem);
1997
1998
1999       box2 = gtk_vbox_new (FALSE, 10);
2000       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2001       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2002       gtk_widget_show (box2);
2003
2004
2005       optionmenu = gtk_option_menu_new ();
2006       gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), create_menu (1));
2007       gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu), 4);
2008       gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0);
2009       gtk_widget_show (optionmenu);
2010
2011
2012       separator = gtk_hseparator_new ();
2013       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2014       gtk_widget_show (separator);
2015
2016
2017       box2 = gtk_vbox_new (FALSE, 10);
2018       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2019       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2020       gtk_widget_show (box2);
2021
2022
2023       button = gtk_button_new_with_label ("close");
2024       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2025                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2026                                  GTK_OBJECT (window));
2027       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2028       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2029       gtk_widget_grab_default (button);
2030       gtk_widget_show (button);
2031     }
2032
2033   if (!GTK_WIDGET_VISIBLE (window))
2034     gtk_widget_show (window);
2035   else
2036     gtk_widget_destroy (window);
2037 }
2038
2039 /*
2040  * GtkScrolledWindow
2041  */
2042 static void
2043 create_scrolled_windows ()
2044 {
2045   static GtkWidget *window;
2046   GtkWidget *scrolled_window;
2047   GtkWidget *table;
2048   GtkWidget *button;
2049   char buffer[32];
2050   int i, j;
2051
2052   if (!window)
2053     {
2054       window = gtk_dialog_new ();
2055
2056       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2057                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2058                           &window);
2059
2060       gtk_window_set_title (GTK_WINDOW (window), "dialog");
2061       gtk_container_border_width (GTK_CONTAINER (window), 0);
2062
2063
2064       scrolled_window = gtk_scrolled_window_new (NULL, NULL);
2065       gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
2066       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
2067                                       GTK_POLICY_AUTOMATIC,
2068                                       GTK_POLICY_AUTOMATIC);
2069       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
2070                           scrolled_window, TRUE, TRUE, 0);
2071       gtk_widget_show (scrolled_window);
2072
2073       table = gtk_table_new (20, 20, FALSE);
2074       gtk_table_set_row_spacings (GTK_TABLE (table), 10);
2075       gtk_table_set_col_spacings (GTK_TABLE (table), 10);
2076       gtk_container_add (GTK_CONTAINER (scrolled_window), table);
2077       gtk_widget_show (table);
2078
2079       for (i = 0; i < 20; i++)
2080         for (j = 0; j < 20; j++)
2081           {
2082             sprintf (buffer, "button (%d,%d)\n", i, j);
2083             button = gtk_toggle_button_new_with_label (buffer);
2084             gtk_table_attach_defaults (GTK_TABLE (table), button,
2085                                        i, i+1, j, j+1);
2086             gtk_widget_show (button);
2087           }
2088
2089
2090       button = gtk_button_new_with_label ("close");
2091       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2092                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2093                                  GTK_OBJECT (window));
2094       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2095       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
2096                           button, TRUE, TRUE, 0);
2097       gtk_widget_grab_default (button);
2098       gtk_widget_show (button);
2099     }
2100
2101   if (!GTK_WIDGET_VISIBLE (window))
2102     gtk_widget_show (window);
2103   else
2104     gtk_widget_destroy (window);
2105 }
2106
2107 /*
2108  * GtkEntry
2109  */
2110
2111 static void
2112 entry_toggle_editable (GtkWidget *checkbutton,
2113                        GtkWidget *entry)
2114 {
2115    gtk_entry_set_editable(GTK_ENTRY(entry),
2116                           GTK_TOGGLE_BUTTON(checkbutton)->active);
2117 }
2118
2119 static void
2120 create_entry ()
2121 {
2122   static GtkWidget *window = NULL;
2123   GtkWidget *box1;
2124   GtkWidget *box2;
2125   GtkWidget *editable_check;
2126   GtkWidget *entry, *cb;
2127   GtkWidget *button;
2128   GtkWidget *separator;
2129   GList *cbitems = NULL;
2130
2131   if (!window)
2132     {
2133       cbitems = g_list_append(cbitems, "item0");
2134       cbitems = g_list_append(cbitems, "item1 item1");
2135       cbitems = g_list_append(cbitems, "item2 item2 item2");
2136       cbitems = g_list_append(cbitems, "item3 item3 item3 item3");
2137       cbitems = g_list_append(cbitems, "item4 item4 item4 item4 item4");
2138       cbitems = g_list_append(cbitems, "item5 item5 item5 item5 item5 item5");
2139       cbitems = g_list_append(cbitems, "item6 item6 item6 item6 item6");
2140       cbitems = g_list_append(cbitems, "item7 item7 item7 item7");
2141       cbitems = g_list_append(cbitems, "item8 item8 item8");
2142       cbitems = g_list_append(cbitems, "item9 item9");
2143
2144       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2145
2146       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2147                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2148                           &window);
2149
2150       gtk_window_set_title (GTK_WINDOW (window), "entry");
2151       gtk_container_border_width (GTK_CONTAINER (window), 0);
2152
2153
2154       box1 = gtk_vbox_new (FALSE, 0);
2155       gtk_container_add (GTK_CONTAINER (window), box1);
2156       gtk_widget_show (box1);
2157
2158
2159       box2 = gtk_vbox_new (FALSE, 10);
2160       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2161       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2162       gtk_widget_show (box2);
2163
2164       entry = gtk_entry_new ();
2165       gtk_entry_set_text (GTK_ENTRY (entry), "hello world");
2166       gtk_editable_select_region (GTK_EDITABLE (entry), 0, -1);
2167       gtk_box_pack_start (GTK_BOX (box2), entry, TRUE, TRUE, 0);
2168       gtk_widget_show (entry);
2169
2170       cb = gtk_combo_new ();
2171       gtk_combo_set_popdown_strings (GTK_COMBO (cb), cbitems);
2172       gtk_entry_set_text (GTK_ENTRY (GTK_COMBO(cb)->entry), "hello world");
2173       gtk_editable_select_region (GTK_EDITABLE (GTK_COMBO(cb)->entry),
2174                                   0, -1);
2175       gtk_box_pack_start (GTK_BOX (box2), cb, TRUE, TRUE, 0);
2176       gtk_widget_show (cb);
2177
2178       editable_check = gtk_check_button_new_with_label("Editable");
2179       gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
2180       gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
2181                           GTK_SIGNAL_FUNC(entry_toggle_editable), entry);
2182       gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE);
2183       gtk_widget_show (editable_check);
2184
2185       separator = gtk_hseparator_new ();
2186       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2187       gtk_widget_show (separator);
2188
2189
2190       box2 = gtk_vbox_new (FALSE, 10);
2191       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2192       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2193       gtk_widget_show (box2);
2194
2195
2196       button = gtk_button_new_with_label ("close");
2197       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2198                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2199                                  GTK_OBJECT (window));
2200       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2201       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2202       gtk_widget_grab_default (button);
2203       gtk_widget_show (button);
2204     }
2205
2206   if (!GTK_WIDGET_VISIBLE (window))
2207     gtk_widget_show (window);
2208   else
2209     gtk_widget_destroy (window);
2210 }
2211
2212 /*
2213  * GtkSpinButton
2214  */
2215
2216 static GtkWidget *spinner1;
2217
2218 static void
2219 toggle_snap (GtkWidget *widget, GtkSpinButton *spin)
2220 {
2221   if (GTK_TOGGLE_BUTTON (widget)->active)
2222     gtk_spin_button_set_update_policy (spin, GTK_UPDATE_ALWAYS
2223                                        | GTK_UPDATE_SNAP_TO_TICKS);
2224   else
2225     gtk_spin_button_set_update_policy (spin, GTK_UPDATE_ALWAYS);
2226 }
2227
2228 static void
2229 toggle_numeric (GtkWidget *widget, GtkSpinButton *spin)
2230 {
2231   gtk_spin_button_set_numeric (spin, GTK_TOGGLE_BUTTON (widget)->active);
2232 }
2233
2234 static void
2235 change_digits (GtkWidget *widget, GtkSpinButton *spin)
2236 {
2237   gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spinner1),
2238                               gtk_spin_button_get_value_as_int (spin));
2239 }
2240
2241 static void
2242 get_value (GtkWidget *widget, gint data)
2243 {
2244   gchar buf[32];
2245   GtkLabel *label;
2246   GtkSpinButton *spin;
2247
2248   spin = GTK_SPIN_BUTTON (spinner1);
2249   label = GTK_LABEL (gtk_object_get_user_data (GTK_OBJECT (widget)));
2250   if (data == 1)
2251     sprintf (buf, "%d", gtk_spin_button_get_value_as_int (spin));
2252   else
2253     sprintf (buf, "%0.*f", spin->digits,
2254              gtk_spin_button_get_value_as_float (spin));
2255   gtk_label_set (label, buf);
2256 }
2257
2258 static void
2259 create_spins ()
2260 {
2261   static GtkWidget *window = NULL;
2262   GtkWidget *frame;
2263   GtkWidget *hbox;
2264   GtkWidget *main_vbox;
2265   GtkWidget *vbox;
2266   GtkWidget *vbox2;
2267   GtkWidget *spinner2;
2268   GtkWidget *spinner;
2269   GtkWidget *button;
2270   GtkWidget *label;
2271   GtkWidget *val_label;
2272   GtkAdjustment *adj;
2273
2274   if (!window)
2275     {
2276       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2277
2278       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2279                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
2280                           &window);
2281
2282       gtk_window_set_title (GTK_WINDOW (window), "GtkSpinButton");
2283
2284       main_vbox = gtk_vbox_new (FALSE, 5);
2285       gtk_container_border_width (GTK_CONTAINER (main_vbox), 10);
2286       gtk_container_add (GTK_CONTAINER (window), main_vbox);
2287
2288       frame = gtk_frame_new ("Not accelerated");
2289       gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
2290
2291       vbox = gtk_vbox_new (FALSE, 0);
2292       gtk_container_border_width (GTK_CONTAINER (vbox), 5);
2293       gtk_container_add (GTK_CONTAINER (frame), vbox);
2294
2295       /* Day, month, year spinners */
2296
2297       hbox = gtk_hbox_new (FALSE, 0);
2298       gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
2299
2300       vbox2 = gtk_vbox_new (FALSE, 0);
2301       gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2302
2303       label = gtk_label_new ("Day :");
2304       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2305       gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2306
2307       adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 31.0, 1.0,
2308                                                   5.0, 0.0);
2309       spinner = gtk_spin_button_new (adj, 0, 0);
2310       gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2311
2312       vbox2 = gtk_vbox_new (FALSE, 0);
2313       gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2314
2315       label = gtk_label_new ("Month :");
2316       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2317       gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2318
2319       adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 12.0, 1.0,
2320                                                   5.0, 0.0);
2321       spinner = gtk_spin_button_new (adj, 0, 0);
2322       gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2323
2324       vbox2 = gtk_vbox_new (FALSE, 0);
2325       gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2326
2327       label = gtk_label_new ("Year :");
2328       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2329       gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2330
2331       adj = (GtkAdjustment *) gtk_adjustment_new (1998.0, 0.0, 2100.0,
2332                                                   1.0, 100.0, 0.0);
2333       spinner = gtk_spin_button_new (adj, 0, 0);
2334       gtk_widget_set_usize (spinner, 55, 0);
2335       gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2336
2337       frame = gtk_frame_new ("Accelerated");
2338       gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
2339
2340       vbox = gtk_vbox_new (FALSE, 0);
2341       gtk_container_border_width (GTK_CONTAINER (vbox), 5);
2342       gtk_container_add (GTK_CONTAINER (frame), vbox);
2343
2344       hbox = gtk_hbox_new (FALSE, 0);
2345       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2346
2347       vbox2 = gtk_vbox_new (FALSE, 0);
2348       gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2349
2350       label = gtk_label_new ("Value :");
2351       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2352       gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2353
2354       adj = (GtkAdjustment *) gtk_adjustment_new (0.0, -10000.0, 10000.0,
2355                                                   0.5, 100.0, 0.0);
2356       spinner1 = gtk_spin_button_new (adj, 1.0, 2);
2357       gtk_widget_set_usize (spinner1, 100, 0);
2358       gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (spinner1),
2359                                          GTK_UPDATE_ALWAYS);
2360       gtk_box_pack_start (GTK_BOX (vbox2), spinner1, FALSE, TRUE, 0);
2361
2362       vbox2 = gtk_vbox_new (FALSE, 0);
2363       gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2364
2365       label = gtk_label_new ("Digits :");
2366       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2367       gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2368
2369       adj = (GtkAdjustment *) gtk_adjustment_new (2, 1, 5, 1, 1, 0);
2370       spinner2 = gtk_spin_button_new (adj, 0.0, 0);
2371       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
2372                           GTK_SIGNAL_FUNC (change_digits),
2373                           (gpointer) spinner2);
2374       gtk_box_pack_start (GTK_BOX (vbox2), spinner2, FALSE, TRUE, 0);
2375
2376       hbox = gtk_hbox_new (FALSE, 0);
2377       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2378
2379       button = gtk_check_button_new_with_label ("Snap to 0.5-ticks");
2380       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2381                           GTK_SIGNAL_FUNC (toggle_snap),
2382                           spinner1);
2383       gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
2384       gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
2385
2386       button = gtk_check_button_new_with_label ("Numeric only input mode");
2387       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2388                           GTK_SIGNAL_FUNC (toggle_numeric),
2389                           spinner1);
2390       gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
2391       gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
2392
2393       val_label = gtk_label_new ("");
2394
2395       hbox = gtk_hbox_new (FALSE, 0);
2396       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2397
2398       button = gtk_button_new_with_label ("Value as Int");
2399       gtk_object_set_user_data (GTK_OBJECT (button), val_label);
2400       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2401                           GTK_SIGNAL_FUNC (get_value),
2402                           (gpointer) 1);
2403       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2404
2405       button = gtk_button_new_with_label ("Value as Float");
2406       gtk_object_set_user_data (GTK_OBJECT (button), val_label);
2407       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2408                           GTK_SIGNAL_FUNC (get_value),
2409                           (gpointer) 2);
2410       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2411
2412       gtk_box_pack_start (GTK_BOX (vbox), val_label, TRUE, TRUE, 0);
2413       gtk_label_set (GTK_LABEL (val_label), "0");
2414
2415       hbox = gtk_hbox_new (FALSE, 0);
2416       gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
2417
2418       button = gtk_button_new_with_label ("Close");
2419       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2420                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
2421                                  GTK_OBJECT (window));
2422       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2423     }
2424
2425   if (!GTK_WIDGET_VISIBLE (window))
2426     gtk_widget_show_all (window);
2427   else
2428     gtk_widget_destroy (window);
2429 }
2430
2431
2432 /*
2433  * Cursors
2434  */
2435
2436 static gint
2437 cursor_expose_event (GtkWidget *widget,
2438                      GdkEvent  *event,
2439                      gpointer   user_data)
2440 {
2441   GtkDrawingArea *darea;
2442   GdkDrawable *drawable;
2443   GdkGC *black_gc;
2444   GdkGC *gray_gc;
2445   GdkGC *white_gc;
2446   guint max_width;
2447   guint max_height;
2448
2449   g_return_val_if_fail (widget != NULL, TRUE);
2450   g_return_val_if_fail (GTK_IS_DRAWING_AREA (widget), TRUE);
2451
2452   darea = GTK_DRAWING_AREA (widget);
2453   drawable = widget->window;
2454   white_gc = widget->style->white_gc;
2455   gray_gc = widget->style->bg_gc[GTK_STATE_NORMAL];
2456   black_gc = widget->style->black_gc;
2457   max_width = widget->allocation.width;
2458   max_height = widget->allocation.height;
2459
2460   gdk_draw_rectangle (drawable, white_gc,
2461                       TRUE,
2462                       0,
2463                       0,
2464                       max_width,
2465                       max_height / 2);
2466
2467   gdk_draw_rectangle (drawable, black_gc,
2468                       TRUE,
2469                       0,
2470                       max_height / 2,
2471                       max_width,
2472                       max_height / 2);
2473
2474   gdk_draw_rectangle (drawable, gray_gc,
2475                       TRUE,
2476                       max_width / 3,
2477                       max_height / 3,
2478                       max_width / 3,
2479                       max_height / 3);
2480
2481   return TRUE;
2482 }
2483
2484 static void
2485 set_cursor (GtkWidget *spinner,
2486             GtkWidget *widget)
2487 {
2488   guint c;
2489   GdkCursor *cursor;
2490
2491   c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152);
2492   c &= 0xfe;
2493
2494   cursor = gdk_cursor_new (c);
2495   gdk_window_set_cursor (widget->window, cursor);
2496   gdk_cursor_destroy (cursor);
2497 }
2498
2499 static gint
2500 cursor_event (GtkWidget          *widget,
2501               GdkEvent           *event,
2502               GtkSpinButton      *spinner)
2503 {
2504   if ((event->type == GDK_BUTTON_PRESS) &&
2505       ((event->button.button == 1) ||
2506        (event->button.button == 3)))
2507     {
2508       gtk_spin_button_spin (spinner,
2509                             event->button.button == 1 ? GTK_ARROW_UP : GTK_ARROW_DOWN,
2510                             spinner->adjustment->step_increment);
2511       return TRUE;
2512     }
2513
2514   return FALSE;
2515 }
2516
2517 static void
2518 create_cursors ()
2519 {
2520   static GtkWidget *window = NULL;
2521   GtkWidget *frame;
2522   GtkWidget *hbox;
2523   GtkWidget *main_vbox;
2524   GtkWidget *vbox;
2525   GtkWidget *darea;
2526   GtkWidget *spinner;
2527   GtkWidget *button;
2528   GtkWidget *label;
2529   GtkWidget *any;
2530   GtkAdjustment *adj;
2531
2532   if (!window)
2533     {
2534       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2535
2536       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2537                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
2538                           &window);
2539
2540       gtk_window_set_title (GTK_WINDOW (window), "Cursors");
2541
2542       main_vbox = gtk_vbox_new (FALSE, 5);
2543       gtk_container_border_width (GTK_CONTAINER (main_vbox), 0);
2544       gtk_container_add (GTK_CONTAINER (window), main_vbox);
2545
2546       vbox =
2547         gtk_widget_new (gtk_vbox_get_type (),
2548                         "GtkBox::homogeneous", FALSE,
2549                         "GtkBox::spacing", 5,
2550                         "GtkContainer::border_width", 10,
2551                         "GtkWidget::parent", main_vbox,
2552                         "GtkWidget::visible", TRUE,
2553                         NULL);
2554
2555       hbox = gtk_hbox_new (FALSE, 0);
2556       gtk_container_border_width (GTK_CONTAINER (hbox), 5);
2557       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
2558
2559       label = gtk_label_new ("Cursor Value:");
2560       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2561       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
2562
2563       adj = (GtkAdjustment *) gtk_adjustment_new (0,
2564                                                   0, 152,
2565                                                   2,
2566                                                   10, 0);
2567       spinner = gtk_spin_button_new (adj, 0, 0);
2568       gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 0);
2569
2570       frame =
2571         gtk_widget_new (gtk_frame_get_type (),
2572                         "GtkFrame::shadow", GTK_SHADOW_ETCHED_IN,
2573                         "GtkFrame::label_xalign", 0.5,
2574                         "GtkFrame::label", "Cursor Area",
2575                         "GtkContainer::border_width", 10,
2576                         "GtkWidget::parent", vbox,
2577                         "GtkWidget::visible", TRUE,
2578                         NULL);
2579
2580       darea = gtk_drawing_area_new ();
2581       gtk_widget_set_usize (darea, 80, 80);
2582       gtk_container_add (GTK_CONTAINER (frame), darea);
2583       gtk_signal_connect (GTK_OBJECT (darea),
2584                           "expose_event",
2585                           GTK_SIGNAL_FUNC (cursor_expose_event),
2586                           NULL);
2587       gtk_widget_set_events (darea, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
2588       gtk_signal_connect (GTK_OBJECT (darea),
2589                           "button_press_event",
2590                           GTK_SIGNAL_FUNC (cursor_event),
2591                           spinner);
2592       gtk_widget_show (darea);
2593
2594       gtk_signal_connect (GTK_OBJECT (spinner), "changed",
2595                           GTK_SIGNAL_FUNC (set_cursor),
2596                           darea);
2597
2598       any =
2599         gtk_widget_new (gtk_hseparator_get_type (),
2600                         "GtkWidget::visible", TRUE,
2601                         NULL);
2602       gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
2603
2604       hbox = gtk_hbox_new (FALSE, 0);
2605       gtk_container_border_width (GTK_CONTAINER (hbox), 10);
2606       gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
2607
2608       button = gtk_button_new_with_label ("Close");
2609       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2610                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
2611                                  GTK_OBJECT (window));
2612       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2613     }
2614
2615   if (!GTK_WIDGET_VISIBLE (window))
2616     gtk_widget_show_all (window);
2617   else
2618     gtk_widget_destroy (window);
2619 }
2620
2621 /*
2622  * GtkList
2623  */
2624 static void
2625 list_add (GtkWidget *widget,
2626           GtkWidget *list)
2627 {
2628   static int i = 1;
2629   gchar buffer[64];
2630   GtkWidget *list_item;
2631
2632   sprintf (buffer, "added item %d", i++);
2633   list_item = gtk_list_item_new_with_label (buffer);
2634   gtk_widget_show (list_item);
2635   gtk_container_add (GTK_CONTAINER (list), list_item);
2636 }
2637
2638 static void
2639 list_remove (GtkWidget *widget,
2640              GtkWidget *list)
2641 {
2642   GList *tmp_list;
2643   GList *clear_list;
2644
2645   tmp_list = GTK_LIST (list)->selection;
2646   clear_list = NULL;
2647
2648   while (tmp_list)
2649     {
2650       clear_list = g_list_prepend (clear_list, tmp_list->data);
2651       tmp_list = tmp_list->next;
2652     }
2653
2654   clear_list = g_list_reverse (clear_list);
2655
2656   gtk_list_remove_items (GTK_LIST (list), clear_list);
2657
2658   g_list_free (clear_list);
2659 }
2660
2661 static void
2662 list_clear (GtkWidget *widget,
2663             GtkWidget *list)
2664 {
2665   gtk_list_clear_items (GTK_LIST (list), 3 - 1, 5 - 1);
2666 }
2667
2668 static void
2669 create_list ()
2670 {
2671   static GtkWidget *window = NULL;
2672   static char *list_items[] =
2673   {
2674     "hello",
2675     "world",
2676     "blah",
2677     "foo",
2678     "bar",
2679     "argh",
2680     "spencer",
2681     "is a",
2682     "wussy",
2683     "programmer",
2684   };
2685   static int nlist_items = sizeof (list_items) / sizeof (list_items[0]);
2686
2687   GtkWidget *box1;
2688   GtkWidget *box2;
2689   GtkWidget *scrolled_win;
2690   GtkWidget *list;
2691   GtkWidget *list_item;
2692   GtkWidget *button;
2693   GtkWidget *separator;
2694   int i;
2695
2696   if (!window)
2697     {
2698       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2699
2700       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2701                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2702                           &window);
2703
2704       gtk_window_set_title (GTK_WINDOW (window), "list");
2705       gtk_container_border_width (GTK_CONTAINER (window), 0);
2706
2707
2708       box1 = gtk_vbox_new (FALSE, 0);
2709       gtk_container_add (GTK_CONTAINER (window), box1);
2710       gtk_widget_show (box1);
2711
2712
2713       box2 = gtk_vbox_new (FALSE, 10);
2714       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2715       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2716       gtk_widget_show (box2);
2717
2718
2719       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
2720       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
2721                                       GTK_POLICY_AUTOMATIC,
2722                                       GTK_POLICY_AUTOMATIC);
2723       gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
2724       gtk_widget_show (scrolled_win);
2725
2726       list = gtk_list_new ();
2727       gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_MULTIPLE);
2728       gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_BROWSE);
2729       gtk_container_add (GTK_CONTAINER (scrolled_win), list);
2730       gtk_widget_show (list);
2731
2732       for (i = 0; i < nlist_items; i++)
2733         {
2734           list_item = gtk_list_item_new_with_label (list_items[i]);
2735           gtk_container_add (GTK_CONTAINER (list), list_item);
2736           gtk_widget_show (list_item);
2737         }
2738
2739       button = gtk_button_new_with_label ("add");
2740       GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
2741       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2742                           GTK_SIGNAL_FUNC(list_add),
2743                           list);
2744       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
2745       gtk_widget_show (button);
2746
2747       button = gtk_button_new_with_label ("clear items 3 - 5");
2748       GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
2749       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2750                           GTK_SIGNAL_FUNC(list_clear),
2751                           list);
2752       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
2753       gtk_widget_show (button);
2754
2755       button = gtk_button_new_with_label ("remove");
2756       GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
2757       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2758                           GTK_SIGNAL_FUNC(list_remove),
2759                           list);
2760       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
2761       gtk_widget_show (button);
2762
2763
2764       separator = gtk_hseparator_new ();
2765       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2766       gtk_widget_show (separator);
2767
2768
2769       box2 = gtk_vbox_new (FALSE, 10);
2770       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2771       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2772       gtk_widget_show (box2);
2773
2774
2775       button = gtk_button_new_with_label ("close");
2776       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2777                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2778                                  GTK_OBJECT (window));
2779       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2780       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2781       gtk_widget_grab_default (button);
2782       gtk_widget_show (button);
2783     }
2784
2785   if (!GTK_WIDGET_VISIBLE (window))
2786     gtk_widget_show (window);
2787   else
2788     gtk_widget_destroy (window);
2789 }
2790
2791 /*
2792  * GtkCList
2793  */
2794 #define TESTGTK_CLIST_COLUMNS 7
2795 static gint clist_rows = 0;
2796 static gint clist_selected_row = 0;
2797
2798 static void
2799 add1000_clist (GtkWidget *widget, gpointer data)
2800 {
2801   gint i, row;
2802   char text[TESTGTK_CLIST_COLUMNS][50];
2803   char *texts[TESTGTK_CLIST_COLUMNS];
2804   GdkBitmap *mask;
2805   GdkPixmap *pixmap;
2806
2807   pixmap = gdk_pixmap_create_from_xpm (GTK_CLIST (data)->clist_window,
2808                                        &mask,
2809                                        &GTK_WIDGET (data)->style->white,
2810                                        "test.xpm");
2811
2812   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
2813     {
2814       texts[i] = text[i];
2815       sprintf (text[i], "Column %d", i);
2816     }
2817
2818   texts[3] = NULL;
2819   sprintf (text[1], "Right");
2820   sprintf (text[2], "Center");
2821
2822   gtk_clist_freeze (GTK_CLIST (data));
2823   for (i = 0; i < 1000; i++)
2824     {
2825       sprintf (text[0], "Row %d", clist_rows++);
2826       row = gtk_clist_append (GTK_CLIST (data), texts);
2827       gtk_clist_set_pixtext (GTK_CLIST (data), row, 3, "Testing", 5, pixmap, mask);
2828     }
2829   gtk_clist_thaw (GTK_CLIST (data));
2830
2831   gdk_pixmap_unref (pixmap);
2832   gdk_bitmap_unref (mask);
2833 }
2834
2835 static void
2836 add10000_clist (GtkWidget *widget, gpointer data)
2837 {
2838   gint i;
2839   char text[TESTGTK_CLIST_COLUMNS][50];
2840   char *texts[TESTGTK_CLIST_COLUMNS];
2841
2842   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
2843     {
2844       texts[i] = text[i];
2845       sprintf (text[i], "Column %d", i);
2846     }
2847
2848   sprintf (text[1], "Right");
2849   sprintf (text[2], "Center");
2850
2851   gtk_clist_freeze (GTK_CLIST (data));
2852   for (i = 0; i < 10000; i++)
2853     {
2854       sprintf (text[0], "Row %d", clist_rows++);
2855       gtk_clist_append (GTK_CLIST (data), texts);
2856     }
2857   gtk_clist_thaw (GTK_CLIST (data));
2858
2859 }
2860
2861 void
2862 clear_clist (GtkWidget *widget, gpointer data)
2863 {
2864   gtk_clist_clear (GTK_CLIST (data));
2865   clist_rows = 0;
2866 }
2867
2868 void
2869 remove_row_clist (GtkWidget *widget, gpointer data)
2870 {
2871   gtk_clist_remove (GTK_CLIST (data), clist_selected_row);
2872   clist_rows--;
2873 }
2874
2875 void
2876 show_titles_clist (GtkWidget *widget, gpointer data)
2877 {
2878   gtk_clist_column_titles_show (GTK_CLIST (data));
2879 }
2880
2881 void
2882 hide_titles_clist (GtkWidget *widget, gpointer data)
2883 {
2884   gtk_clist_column_titles_hide (GTK_CLIST (data));
2885 }
2886
2887 void
2888 select_clist (GtkWidget *widget,
2889               gint row,
2890               gint column,
2891               GdkEventButton * bevent)
2892 {
2893   gint i;
2894   guint8 spacing;
2895   gchar *text;
2896   GdkPixmap *pixmap;
2897   GdkBitmap *mask;
2898   GList *list;
2899
2900   g_print ("GtkCList Selection: row %d column %d button %d\n",
2901            row, column, bevent ? bevent->button : 0);
2902
2903   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
2904     {
2905       switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i))
2906         {
2907         case GTK_CELL_TEXT:
2908           g_print ("CELL %d GTK_CELL_TEXT\n", i);
2909           gtk_clist_get_text (GTK_CLIST (widget), row, i, &text);
2910           g_print ("TEXT: %s\n", text);
2911           break;
2912
2913         case GTK_CELL_PIXMAP:
2914           g_print ("CELL %d GTK_CELL_PIXMAP\n", i);
2915           gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask);
2916           g_print ("PIXMAP: %d\n", (int) pixmap);
2917           g_print ("MASK: %d\n", (int) mask);
2918           break;
2919
2920         case GTK_CELL_PIXTEXT:
2921           g_print ("CELL %d GTK_CELL_PIXTEXT\n", i);
2922           gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask);
2923           g_print ("TEXT: %s\n", text);
2924           g_print ("SPACING: %d\n", spacing);
2925           g_print ("PIXMAP: %d\n", (int) pixmap);
2926           g_print ("MASK: %d\n", (int) mask);
2927           break;
2928
2929         default:
2930           break;
2931         }
2932     }
2933
2934   /* print selections list */
2935   g_print ("\nSelected Rows:");
2936   list = GTK_CLIST (widget)->selection;
2937   while (list)
2938     {
2939       g_print (" %d ", (gint) list->data);
2940       list = list->next;
2941     }
2942
2943   g_print ("\n\n\n");
2944
2945   clist_selected_row = row;
2946 }
2947
2948 void
2949 unselect_clist (GtkWidget *widget,
2950                 gint row,
2951                 gint column,
2952                 GdkEventButton * bevent)
2953 {
2954   gint i;
2955   guint8 spacing;
2956   gchar *text;
2957   GdkPixmap *pixmap;
2958   GdkBitmap *mask;
2959   GList *list;
2960
2961   g_print ("GtkCList Unselection: row %d column %d button %d\n",
2962            row, column, bevent ? bevent->button : 0);
2963
2964   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
2965     {
2966       switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i))
2967         {
2968         case GTK_CELL_TEXT:
2969           g_print ("CELL %d GTK_CELL_TEXT\n", i);
2970           gtk_clist_get_text (GTK_CLIST (widget), row, i, &text);
2971           g_print ("TEXT: %s\n", text);
2972           break;
2973
2974         case GTK_CELL_PIXMAP:
2975           g_print ("CELL %d GTK_CELL_PIXMAP\n", i);
2976           gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask);
2977           g_print ("PIXMAP: %d\n", (int) pixmap);
2978           g_print ("MASK: %d\n", (int) mask);
2979           break;
2980
2981         case GTK_CELL_PIXTEXT:
2982           g_print ("CELL %d GTK_CELL_PIXTEXT\n", i);
2983           gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask);
2984           g_print ("TEXT: %s\n", text);
2985           g_print ("SPACING: %d\n", spacing);
2986           g_print ("PIXMAP: %d\n", (int) pixmap);
2987           g_print ("MASK: %d\n", (int) mask);
2988           break;
2989
2990         default:
2991           break;
2992         }
2993     }
2994
2995   /* print selections list */
2996   g_print ("\nSelected Rows:");
2997   list = GTK_CLIST (widget)->selection;
2998   while (list)
2999     {
3000       g_print (" %d ", (gint) list->data);
3001       list = list->next;
3002     }
3003
3004   g_print ("\n\n\n");
3005
3006   clist_selected_row = row;
3007 }
3008
3009 void
3010 insert_row_clist (GtkWidget *widget, gpointer data)
3011 {
3012   static char *text[] =
3013   {
3014     "This",
3015     "is",
3016     "a",
3017     "inserted",
3018     "row",
3019     "la la la la la",
3020     "la la la la"
3021   };
3022
3023   gtk_clist_insert (GTK_CLIST (data), clist_selected_row, text);
3024   clist_rows++;
3025 }
3026
3027 void
3028 create_clist ()
3029 {
3030   gint i;
3031   static GtkWidget *window = NULL;
3032
3033   static char *titles[] =
3034   {
3035     "Title 0",
3036     "Title 1",
3037     "Title 2",
3038     "Title 3",
3039     "Title 4",
3040     "Title 5",
3041     "Title 6"
3042   };
3043
3044   char text[TESTGTK_CLIST_COLUMNS][50];
3045   char *texts[TESTGTK_CLIST_COLUMNS];
3046
3047   GtkWidget *box1;
3048   GtkWidget *box2;
3049   GtkWidget *clist;
3050   GtkWidget *button;
3051   GtkWidget *separator;
3052
3053
3054   if (!window)
3055     {
3056       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3057
3058       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3059                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3060                           &window);
3061
3062       gtk_window_set_title (GTK_WINDOW (window), "clist");
3063       gtk_container_border_width (GTK_CONTAINER (window), 0);
3064
3065
3066       box1 = gtk_vbox_new (FALSE, 0);
3067       gtk_container_add (GTK_CONTAINER (window), box1);
3068       gtk_widget_show (box1);
3069
3070
3071       box2 = gtk_hbox_new (FALSE, 10);
3072       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3073       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
3074       gtk_widget_show (box2);
3075
3076       /* create GtkCList here so we have a pointer to throw at the
3077        * button callbacks -- more is done with it later */
3078       clist = gtk_clist_new_with_titles (TESTGTK_CLIST_COLUMNS, titles);
3079       /*clist = gtk_clist_new (TESTGTK_CLIST_COLUMNS);*/
3080
3081       /* control buttons */
3082       button = gtk_button_new_with_label ("Add 1,000 Rows With Pixmaps");
3083       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3084
3085       gtk_signal_connect (GTK_OBJECT (button),
3086                           "clicked",
3087                           (GtkSignalFunc) add1000_clist,
3088                           (gpointer) clist);
3089
3090       gtk_widget_show (button);
3091
3092
3093       button = gtk_button_new_with_label ("Add 10,000 Rows");
3094       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3095
3096       gtk_signal_connect (GTK_OBJECT (button),
3097                           "clicked",
3098                           (GtkSignalFunc) add10000_clist,
3099                           (gpointer) clist);
3100
3101       gtk_widget_show (button);
3102
3103       button = gtk_button_new_with_label ("Clear List");
3104       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3105
3106       gtk_signal_connect (GTK_OBJECT (button),
3107                           "clicked",
3108                           (GtkSignalFunc) clear_clist,
3109                           (gpointer) clist);
3110
3111       gtk_widget_show (button);
3112
3113       button = gtk_button_new_with_label ("Remove Row");
3114       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3115
3116       gtk_signal_connect (GTK_OBJECT (button),
3117                           "clicked",
3118                           (GtkSignalFunc) remove_row_clist,
3119                           (gpointer) clist);
3120
3121       gtk_widget_show (button);
3122
3123       /* second layer of buttons */
3124       box2 = gtk_hbox_new (FALSE, 10);
3125       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3126       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
3127       gtk_widget_show (box2);
3128
3129       button = gtk_button_new_with_label ("Insert Row");
3130       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3131
3132       gtk_signal_connect (GTK_OBJECT (button),
3133                           "clicked",
3134                           (GtkSignalFunc) insert_row_clist,
3135                           (gpointer) clist);
3136
3137       gtk_widget_show (button);
3138
3139       button = gtk_button_new_with_label ("Show Title Buttons");
3140       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3141
3142       gtk_signal_connect (GTK_OBJECT (button),
3143                           "clicked",
3144                           (GtkSignalFunc) show_titles_clist,
3145                           (gpointer) clist);
3146
3147       gtk_widget_show (button);
3148
3149       button = gtk_button_new_with_label ("Hide Title Buttons");
3150       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3151
3152       gtk_signal_connect (GTK_OBJECT (button),
3153                           "clicked",
3154                           (GtkSignalFunc) hide_titles_clist,
3155                           (gpointer) clist);
3156
3157       gtk_widget_show (button);
3158
3159       /* vbox for the list itself */
3160       box2 = gtk_vbox_new (FALSE, 10);
3161       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3162       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3163       gtk_widget_show (box2);
3164
3165       /*
3166        * the rest of the clist configuration
3167        */
3168       gtk_clist_set_row_height (GTK_CLIST (clist), 20);
3169
3170       gtk_signal_connect (GTK_OBJECT (clist),
3171                           "select_row",
3172                           (GtkSignalFunc) select_clist,
3173                           NULL);
3174
3175       gtk_signal_connect (GTK_OBJECT (clist),
3176                           "unselect_row",
3177                           (GtkSignalFunc) unselect_clist,
3178                           NULL);
3179
3180       gtk_clist_set_column_width (GTK_CLIST (clist), 0, 100);
3181
3182       for (i = 1; i < TESTGTK_CLIST_COLUMNS; i++)
3183         gtk_clist_set_column_width (GTK_CLIST (clist), i, 80);
3184
3185       gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_BROWSE);
3186       gtk_clist_set_policy (GTK_CLIST (clist),
3187                             GTK_POLICY_AUTOMATIC,
3188                             GTK_POLICY_AUTOMATIC);
3189
3190       gtk_clist_set_policy (GTK_CLIST (clist), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
3191
3192       gtk_clist_set_column_justification (GTK_CLIST (clist), 1, GTK_JUSTIFY_RIGHT);
3193       gtk_clist_set_column_justification (GTK_CLIST (clist), 2, GTK_JUSTIFY_CENTER);
3194
3195       for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3196         {
3197           texts[i] = text[i];
3198           sprintf (text[i], "Column %d", i);
3199         }
3200
3201       sprintf (text[1], "Right");
3202       sprintf (text[2], "Center");
3203
3204       for (i = 0; i < 100; i++)
3205         {
3206           sprintf (text[0], "Row %d", clist_rows++);
3207           gtk_clist_append (GTK_CLIST (clist), texts);
3208         }
3209
3210       gtk_container_border_width (GTK_CONTAINER (clist), 5);
3211       gtk_box_pack_start (GTK_BOX (box2), clist, TRUE, TRUE, 0);
3212       gtk_widget_show (clist);
3213
3214
3215       separator = gtk_hseparator_new ();
3216       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3217       gtk_widget_show (separator);
3218
3219       box2 = gtk_vbox_new (FALSE, 10);
3220       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3221       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3222       gtk_widget_show (box2);
3223
3224       button = gtk_button_new_with_label ("close");
3225       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3226                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
3227                                  GTK_OBJECT (window));
3228
3229       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3230       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3231       gtk_widget_grab_default (button);
3232
3233       gtk_widget_show (button);
3234     }
3235
3236   if (!GTK_WIDGET_VISIBLE (window))
3237     gtk_widget_show (window);
3238   else
3239     {
3240       clist_rows = 0;
3241       gtk_widget_destroy (window);
3242     }
3243
3244 }
3245
3246 /*
3247  * GtkColorSelect
3248  */
3249 void
3250 color_selection_ok (GtkWidget               *w,
3251                     GtkColorSelectionDialog *cs)
3252 {
3253   GtkColorSelection *colorsel;
3254   gdouble color[4];
3255
3256   colorsel=GTK_COLOR_SELECTION(cs->colorsel);
3257
3258   gtk_color_selection_get_color(colorsel,color);
3259   gtk_color_selection_set_color(colorsel,color);
3260 }
3261
3262 void
3263 color_selection_changed (GtkWidget *w,
3264                          GtkColorSelectionDialog *cs)
3265 {
3266   GtkColorSelection *colorsel;
3267   gdouble color[4];
3268
3269   colorsel=GTK_COLOR_SELECTION(cs->colorsel);
3270   gtk_color_selection_get_color(colorsel,color);
3271 }
3272
3273 void
3274 create_color_selection ()
3275 {
3276   static GtkWidget *window = NULL;
3277
3278   if (!window)
3279     {
3280       gtk_preview_set_install_cmap (TRUE);
3281       gtk_widget_push_visual (gtk_preview_get_visual ());
3282       gtk_widget_push_colormap (gtk_preview_get_cmap ());
3283
3284       window = gtk_color_selection_dialog_new ("color selection dialog");
3285
3286       gtk_color_selection_set_opacity (
3287         GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
3288         TRUE);
3289
3290       gtk_color_selection_set_update_policy(
3291         GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
3292         GTK_UPDATE_CONTINUOUS);
3293
3294       gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
3295
3296       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3297                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3298                           &window);
3299
3300       gtk_signal_connect (
3301         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
3302         "color_changed",
3303         GTK_SIGNAL_FUNC(color_selection_changed),
3304         window);
3305
3306       gtk_signal_connect (
3307         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->ok_button),
3308         "clicked",
3309         GTK_SIGNAL_FUNC(color_selection_ok),
3310         window);
3311
3312       gtk_signal_connect_object (
3313         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->cancel_button),
3314         "clicked",
3315         GTK_SIGNAL_FUNC(gtk_widget_destroy),
3316         GTK_OBJECT (window));
3317
3318       gtk_widget_pop_colormap ();
3319       gtk_widget_pop_visual ();
3320     }
3321
3322   if (!GTK_WIDGET_VISIBLE (window))
3323     gtk_widget_show (window);
3324   else
3325     gtk_widget_destroy (window);
3326 }
3327
3328 void
3329 file_selection_hide_fileops (GtkWidget *widget,
3330                              GtkFileSelection *fs)
3331 {
3332   gtk_file_selection_hide_fileop_buttons (fs);
3333 }
3334
3335 void
3336 file_selection_ok (GtkWidget        *w,
3337                    GtkFileSelection *fs)
3338 {
3339   g_print ("%s\n", gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs)));
3340   gtk_widget_destroy (GTK_WIDGET (fs));
3341 }
3342
3343 void
3344 create_file_selection ()
3345 {
3346   static GtkWidget *window = NULL;
3347   GtkWidget *button;
3348
3349   if (!window)
3350     {
3351       window = gtk_file_selection_new ("file selection dialog");
3352
3353       gtk_file_selection_hide_fileop_buttons (GTK_FILE_SELECTION (window));
3354
3355       gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
3356
3357       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3358                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3359                           &window);
3360
3361       gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (window)->ok_button),
3362                           "clicked", GTK_SIGNAL_FUNC(file_selection_ok),
3363                           window);
3364       gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (window)->cancel_button),
3365                                  "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
3366                                  GTK_OBJECT (window));
3367
3368       button = gtk_button_new_with_label ("Hide Fileops");
3369       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3370                           (GtkSignalFunc) file_selection_hide_fileops,
3371                           (gpointer) window);
3372       gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
3373                           button, FALSE, FALSE, 0);
3374       gtk_widget_show (button);
3375
3376       button = gtk_button_new_with_label ("Show Fileops");
3377       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3378                                  (GtkSignalFunc) gtk_file_selection_show_fileop_buttons,
3379                                  (gpointer) window);
3380       gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
3381                           button, FALSE, FALSE, 0);
3382       gtk_widget_show (button);
3383
3384
3385
3386     }
3387
3388   if (!GTK_WIDGET_VISIBLE (window))
3389     gtk_widget_show (window);
3390   else
3391     gtk_widget_destroy (window);
3392 }
3393
3394
3395 /*
3396  * GtkDialog
3397  */
3398 static GtkWidget *dialog_window = NULL;
3399
3400 void
3401 label_toggle (GtkWidget  *widget,
3402               GtkWidget **label)
3403 {
3404   if (!(*label))
3405     {
3406       *label = gtk_label_new ("Dialog Test");
3407       gtk_signal_connect (GTK_OBJECT (*label),
3408                           "destroy",
3409                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
3410                           label);
3411       gtk_misc_set_padding (GTK_MISC (*label), 10, 10);
3412       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
3413                           *label, TRUE, TRUE, 0);
3414       gtk_widget_show (*label);
3415     }
3416   else
3417     gtk_widget_destroy (*label);
3418 }
3419
3420 void
3421 create_dialog ()
3422 {
3423   static GtkWidget *label;
3424   GtkWidget *button;
3425
3426   if (!dialog_window)
3427     {
3428       dialog_window = gtk_dialog_new ();
3429
3430       gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
3431                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3432                           &dialog_window);
3433
3434       gtk_window_set_title (GTK_WINDOW (dialog_window), "dialog");
3435       gtk_container_border_width (GTK_CONTAINER (dialog_window), 0);
3436
3437       button = gtk_button_new_with_label ("OK");
3438       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3439       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
3440                           button, TRUE, TRUE, 0);
3441       gtk_widget_grab_default (button);
3442       gtk_widget_show (button);
3443
3444       button = gtk_button_new_with_label ("Toggle");
3445       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3446                           GTK_SIGNAL_FUNC (label_toggle),
3447                           &label);
3448       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3449       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
3450                           button, TRUE, TRUE, 0);
3451       gtk_widget_show (button);
3452
3453       label = NULL;
3454     }
3455
3456   if (!GTK_WIDGET_VISIBLE (dialog_window))
3457     gtk_widget_show (dialog_window);
3458   else
3459     gtk_widget_destroy (dialog_window);
3460 }
3461
3462
3463 /*
3464  * GtkRange
3465  */
3466 void
3467 create_range_controls ()
3468 {
3469   static GtkWidget *window = NULL;
3470   GtkWidget *box1;
3471   GtkWidget *box2;
3472   GtkWidget *button;
3473   GtkWidget *scrollbar;
3474   GtkWidget *scale;
3475   GtkWidget *separator;
3476   GtkObject *adjustment;
3477
3478   if (!window)
3479     {
3480       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3481
3482       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3483                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3484                           &window);
3485
3486       gtk_window_set_title (GTK_WINDOW (window), "range controls");
3487       gtk_container_border_width (GTK_CONTAINER (window), 0);
3488
3489
3490       box1 = gtk_vbox_new (FALSE, 0);
3491       gtk_container_add (GTK_CONTAINER (window), box1);
3492       gtk_widget_show (box1);
3493
3494
3495       box2 = gtk_vbox_new (FALSE, 10);
3496       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3497       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3498       gtk_widget_show (box2);
3499
3500
3501       adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
3502
3503       scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
3504       gtk_widget_set_usize (GTK_WIDGET (scale), 150, 30);
3505       gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
3506       gtk_scale_set_digits (GTK_SCALE (scale), 1);
3507       gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
3508       gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
3509       gtk_widget_show (scale);
3510
3511       scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adjustment));
3512       gtk_range_set_update_policy (GTK_RANGE (scrollbar),
3513                                    GTK_UPDATE_CONTINUOUS);
3514       gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0);
3515       gtk_widget_show (scrollbar);
3516
3517
3518       separator = gtk_hseparator_new ();
3519       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3520       gtk_widget_show (separator);
3521
3522
3523       box2 = gtk_vbox_new (FALSE, 10);
3524       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3525       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3526       gtk_widget_show (box2);
3527
3528
3529       button = gtk_button_new_with_label ("close");
3530       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3531                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
3532                                  GTK_OBJECT (window));
3533       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3534       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3535       gtk_widget_grab_default (button);
3536       gtk_widget_show (button);
3537     }
3538
3539   if (!GTK_WIDGET_VISIBLE (window))
3540     gtk_widget_show (window);
3541   else
3542     gtk_widget_destroy (window);
3543 }
3544
3545
3546 /*
3547  * GtkRulers
3548  */
3549 void
3550 create_rulers ()
3551 {
3552   static GtkWidget *window = NULL;
3553   GtkWidget *table;
3554   GtkWidget *ruler;
3555
3556   if (!window)
3557     {
3558       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3559
3560       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3561                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3562                           &window);
3563
3564       gtk_window_set_title (GTK_WINDOW (window), "rulers");
3565       gtk_widget_set_usize (window, 300, 300);
3566       gtk_widget_set_events (window,
3567                              GDK_POINTER_MOTION_MASK
3568                              | GDK_POINTER_MOTION_HINT_MASK);
3569       gtk_container_border_width (GTK_CONTAINER (window), 0);
3570
3571       table = gtk_table_new (2, 2, FALSE);
3572       gtk_container_add (GTK_CONTAINER (window), table);
3573       gtk_widget_show (table);
3574
3575       ruler = gtk_hruler_new ();
3576       gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
3577
3578       gtk_signal_connect_object (
3579         GTK_OBJECT (window),
3580         "motion_notify_event",
3581         GTK_SIGNAL_FUNC(
3582           GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
3583         GTK_OBJECT (ruler));
3584
3585       gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
3586                         GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
3587       gtk_widget_show (ruler);
3588
3589
3590       ruler = gtk_vruler_new ();
3591       gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
3592
3593       gtk_signal_connect_object (
3594         GTK_OBJECT (window),
3595         "motion_notify_event",
3596         GTK_SIGNAL_FUNC (GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
3597         GTK_OBJECT (ruler));
3598
3599       gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
3600                         GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
3601       gtk_widget_show (ruler);
3602     }
3603
3604   if (!GTK_WIDGET_VISIBLE (window))
3605     gtk_widget_show (window);
3606   else
3607     gtk_widget_destroy (window);
3608 }
3609
3610
3611 static void
3612 text_toggle_editable (GtkWidget *checkbutton,
3613                        GtkWidget *text)
3614 {
3615    gtk_text_set_editable(GTK_TEXT(text),
3616                           GTK_TOGGLE_BUTTON(checkbutton)->active);
3617 }
3618
3619 /*
3620  * GtkText
3621  */
3622 void
3623 create_text ()
3624 {
3625   static GtkWidget *window = NULL;
3626   GtkWidget *box1;
3627   GtkWidget *box2;
3628   GtkWidget *button;
3629   GtkWidget *editable_check;
3630   GtkWidget *separator;
3631   GtkWidget *table;
3632   GtkWidget *hscrollbar;
3633   GtkWidget *vscrollbar;
3634   GtkWidget *text;
3635
3636   FILE *infile;
3637
3638   if (!window)
3639     {
3640       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3641       gtk_widget_set_name (window, "text window");
3642       gtk_widget_set_usize (window, 500, 500);
3643       gtk_window_set_policy (GTK_WINDOW(window), TRUE, TRUE, FALSE);
3644
3645       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3646                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3647                           &window);
3648
3649       gtk_window_set_title (GTK_WINDOW (window), "test");
3650       gtk_container_border_width (GTK_CONTAINER (window), 0);
3651
3652
3653       box1 = gtk_vbox_new (FALSE, 0);
3654       gtk_container_add (GTK_CONTAINER (window), box1);
3655       gtk_widget_show (box1);
3656
3657
3658       box2 = gtk_vbox_new (FALSE, 10);
3659       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3660       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3661       gtk_widget_show (box2);
3662
3663
3664       table = gtk_table_new (2, 2, FALSE);
3665       gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2);
3666       gtk_table_set_col_spacing (GTK_TABLE (table), 0, 2);
3667       gtk_box_pack_start (GTK_BOX (box2), table, TRUE, TRUE, 0);
3668       gtk_widget_show (table);
3669
3670       text = gtk_text_new (NULL, NULL);
3671       gtk_text_set_editable (GTK_TEXT (text), TRUE);
3672       gtk_table_attach (GTK_TABLE (table), text, 0, 1, 0, 1,
3673                         GTK_EXPAND | GTK_SHRINK | GTK_FILL,
3674                         GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
3675       gtk_widget_show (text);
3676
3677       hscrollbar = gtk_hscrollbar_new (GTK_TEXT (text)->hadj);
3678       gtk_table_attach (GTK_TABLE (table), hscrollbar, 0, 1, 1, 2,
3679                         GTK_EXPAND | GTK_FILL | GTK_SHRINK, GTK_FILL, 0, 0);
3680       gtk_widget_show (hscrollbar);
3681
3682       vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
3683       gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 0, 1,
3684                         GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
3685       gtk_widget_show (vscrollbar);
3686
3687       gtk_text_freeze (GTK_TEXT (text));
3688
3689       gtk_widget_realize (text);
3690
3691       infile = fopen("testgtk.c", "r");
3692
3693       if (infile)
3694         {
3695           char buffer[1024];
3696           int nchars;
3697
3698           while (1)
3699             {
3700               nchars = fread(buffer, 1, 1024, infile);
3701               gtk_text_insert (GTK_TEXT (text), NULL, NULL,
3702                                NULL, buffer, nchars);
3703
3704               if (nchars < 1024)
3705                 break;
3706             }
3707
3708           fclose (infile);
3709         }
3710
3711       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
3712                        "And even ", -1);
3713       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->bg[GTK_STATE_NORMAL], NULL,
3714                        "colored", -1);
3715       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
3716                        "text", -1);
3717
3718       gtk_text_thaw (GTK_TEXT (text));
3719
3720       editable_check = gtk_check_button_new_with_label("Editable");
3721       gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
3722       gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
3723                           GTK_SIGNAL_FUNC(text_toggle_editable), text);
3724       gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE);
3725       gtk_widget_show (editable_check);
3726
3727       separator = gtk_hseparator_new ();
3728       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3729       gtk_widget_show (separator);
3730
3731
3732       box2 = gtk_vbox_new (FALSE, 10);
3733       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3734       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3735       gtk_widget_show (box2);
3736
3737
3738       button = gtk_button_new_with_label ("close");
3739       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3740                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
3741                                  GTK_OBJECT (window));
3742       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3743       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3744       gtk_widget_grab_default (button);
3745       gtk_widget_show (button);
3746     }
3747
3748   if (!GTK_WIDGET_VISIBLE (window))
3749     gtk_widget_show (window);
3750   else
3751     gtk_widget_destroy (window);
3752 }
3753
3754
3755 /*
3756  * GtkNotebook
3757  */
3758
3759 GdkPixmap *book_open;
3760 GdkPixmap *book_closed;
3761 GdkBitmap *book_open_mask;
3762 GdkBitmap *book_closed_mask;
3763
3764 static char * book_open_xpm[] = {
3765 "16 16 4 1",
3766 "       c None s None",
3767 ".      c black",
3768 "X      c #808080",
3769 "o      c white",
3770 "                ",
3771 "  ..            ",
3772 " .Xo.    ...    ",
3773 " .Xoo. ..oo.    ",
3774 " .Xooo.Xooo...  ",
3775 " .Xooo.oooo.X.  ",
3776 " .Xooo.Xooo.X.  ",
3777 " .Xooo.oooo.X.  ",
3778 " .Xooo.Xooo.X.  ",
3779 " .Xooo.oooo.X.  ",
3780 "  .Xoo.Xoo..X.  ",
3781 "   .Xo.o..ooX.  ",
3782 "    .X..XXXXX.  ",
3783 "    ..X.......  ",
3784 "     ..         ",
3785 "                "};
3786
3787 static char * book_closed_xpm[] = {
3788 "16 16 6 1",
3789 "       c None s None",
3790 ".      c black",
3791 "X      c red",
3792 "o      c yellow",
3793 "O      c #808080",
3794 "#      c white",
3795 "                ",
3796 "       ..       ",
3797 "     ..XX.      ",
3798 "   ..XXXXX.     ",
3799 " ..XXXXXXXX.    ",
3800 ".ooXXXXXXXXX.   ",
3801 "..ooXXXXXXXXX.  ",
3802 ".X.ooXXXXXXXXX. ",
3803 ".XX.ooXXXXXX..  ",
3804 " .XX.ooXXX..#O  ",
3805 "  .XX.oo..##OO. ",
3806 "   .XX..##OO..  ",
3807 "    .X.#OO..    ",
3808 "     ..O..      ",
3809 "      ..        ",
3810 "                "};
3811
3812 static void
3813 page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num)
3814 {
3815   GtkNotebookPage *oldpage;
3816   GtkWidget *pixwid;
3817
3818   oldpage = GTK_NOTEBOOK (widget)->cur_page;
3819
3820   if (page == oldpage)
3821     return;
3822
3823   pixwid = ((GtkBoxChild*)(GTK_BOX (page->tab_label)->children->data))->widget;
3824   gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
3825   pixwid = ((GtkBoxChild*) (GTK_BOX (page->menu_label)->children->data))->widget;
3826   gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
3827
3828   if (oldpage)
3829     {
3830       pixwid = ((GtkBoxChild*) (GTK_BOX
3831                                 (oldpage->tab_label)->children->data))->widget;
3832       gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
3833       pixwid = ((GtkBoxChild*) (GTK_BOX (oldpage->menu_label)->children->data))->widget;
3834       gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
3835     }
3836 }
3837
3838 static void
3839 create_pages (GtkNotebook *notebook, gint start, gint end)
3840 {
3841   GtkWidget *child = NULL;
3842   GtkWidget *label;
3843   GtkWidget *entry;
3844   GtkWidget *box;
3845   GtkWidget *hbox;
3846   GtkWidget *label_box;
3847   GtkWidget *menu_box;
3848   GtkWidget *button;
3849   GtkWidget *pixwid;
3850   gint i;
3851   char buffer[32];
3852
3853   for (i = start; i <= end; i++)
3854     {
3855       sprintf (buffer, "Page %d", i);
3856
3857       switch (i%4)
3858         {
3859         case 3:
3860           child = gtk_button_new_with_label (buffer);
3861           gtk_container_border_width (GTK_CONTAINER(child), 10);
3862           break;
3863         case 2:
3864           child = gtk_label_new (buffer);
3865           break;
3866         case 1:
3867           child = gtk_frame_new (buffer);
3868           gtk_container_border_width (GTK_CONTAINER (child), 10);
3869
3870           box = gtk_vbox_new (TRUE,0);
3871           gtk_container_border_width (GTK_CONTAINER (box), 10);
3872           gtk_container_add (GTK_CONTAINER (child), box);
3873
3874           label = gtk_label_new (buffer);
3875           gtk_box_pack_start (GTK_BOX(box), label, TRUE, TRUE, 5);
3876
3877           entry = gtk_entry_new ();
3878           gtk_box_pack_start (GTK_BOX(box), entry, TRUE, TRUE, 5);
3879
3880           hbox = gtk_hbox_new (TRUE,0);
3881           gtk_box_pack_start (GTK_BOX(box), hbox, TRUE, TRUE, 5);
3882
3883           button = gtk_button_new_with_label ("Ok");
3884           gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
3885
3886           button = gtk_button_new_with_label ("Cancel");
3887           gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
3888           break;
3889         case 0:
3890           child = gtk_frame_new (buffer);
3891           gtk_container_border_width (GTK_CONTAINER (child), 10);
3892
3893           label = gtk_label_new (buffer);
3894           gtk_container_add (GTK_CONTAINER (child), label);
3895           break;
3896         }
3897
3898       gtk_widget_show_all (child);
3899
3900       label_box = gtk_hbox_new (FALSE, 0);
3901       pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
3902       gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
3903       gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
3904       label = gtk_label_new (buffer);
3905       gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
3906       gtk_widget_show_all (label_box);
3907
3908       menu_box = gtk_hbox_new (FALSE, 0);
3909       pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
3910       gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
3911       gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
3912       label = gtk_label_new (buffer);
3913       gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0);
3914       gtk_widget_show_all (menu_box);
3915
3916       gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
3917     }
3918 }
3919
3920 static void
3921 rotate_notebook (GtkButton   *button,
3922                  GtkNotebook *notebook)
3923 {
3924   gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos + 1) % 4);
3925 }
3926
3927 static void
3928 standard_notebook (GtkButton   *button,
3929                    GtkNotebook *notebook)
3930 {
3931   gint i;
3932
3933   gtk_notebook_set_show_tabs (notebook, TRUE);
3934   gtk_notebook_set_scrollable (notebook, FALSE);
3935   if (g_list_length (notebook->children) == 15)
3936     for (i = 0; i < 10; i++)
3937       gtk_notebook_remove_page (notebook, 5);
3938 }
3939
3940 static void
3941 notabs_notebook (GtkButton   *button,
3942                  GtkNotebook *notebook)
3943 {
3944   gint i;
3945
3946   gtk_notebook_set_show_tabs (notebook, FALSE);
3947   if (g_list_length (notebook->children) == 15)
3948     for (i = 0; i < 10; i++)
3949       gtk_notebook_remove_page (notebook, 5);
3950 }
3951
3952 static void
3953 scrollable_notebook (GtkButton   *button,
3954                      GtkNotebook *notebook)
3955 {
3956   gtk_notebook_set_show_tabs (notebook, TRUE);
3957   gtk_notebook_set_scrollable (notebook, TRUE);
3958   if (g_list_length (notebook->children) == 5)
3959     create_pages (notebook, 6, 15);
3960 }
3961
3962 static void
3963 notebook_popup (GtkToggleButton *button,
3964                 GtkNotebook     *notebook)
3965 {
3966   if (button->active)
3967     gtk_notebook_popup_enable (notebook);
3968   else
3969     gtk_notebook_popup_disable (notebook);
3970 }
3971
3972 static void
3973 create_notebook ()
3974 {
3975   static GtkWidget *window = NULL;
3976   GtkWidget *box1;
3977   GtkWidget *box2;
3978   GtkWidget *button;
3979   GtkWidget *separator;
3980   GtkWidget *notebook;
3981   GtkWidget *omenu;
3982   GtkWidget *menu;
3983   GtkWidget *submenu;
3984   GtkWidget *menuitem;
3985   GSList *group;
3986   GdkColor *transparent = NULL;
3987
3988   if (!window)
3989     {
3990       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3991
3992       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3993                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3994                           &window);
3995
3996       gtk_window_set_title (GTK_WINDOW (window), "notebook");
3997       gtk_container_border_width (GTK_CONTAINER (window), 0);
3998
3999       box1 = gtk_vbox_new (FALSE, 0);
4000       gtk_container_add (GTK_CONTAINER (window), box1);
4001
4002       notebook = gtk_notebook_new ();
4003       gtk_signal_connect (GTK_OBJECT (notebook), "switch_page",
4004                           GTK_SIGNAL_FUNC (page_switch), NULL);
4005       gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
4006       gtk_box_pack_start (GTK_BOX (box1), notebook, TRUE, TRUE, 0);
4007       gtk_container_border_width (GTK_CONTAINER (notebook), 10);
4008
4009       gtk_widget_realize (notebook);
4010       book_open = gdk_pixmap_create_from_xpm_d (notebook->window,
4011                                                 &book_open_mask,
4012                                                 transparent,
4013                                                 book_open_xpm);
4014       book_closed = gdk_pixmap_create_from_xpm_d (notebook->window,
4015                                                   &book_closed_mask,
4016                                                   transparent,
4017                                                   book_closed_xpm);
4018
4019       create_pages (GTK_NOTEBOOK (notebook), 1, 5);
4020
4021       separator = gtk_hseparator_new ();
4022       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10);
4023
4024       box2 = gtk_hbox_new (TRUE, 5);
4025       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4026
4027       omenu = gtk_option_menu_new ();
4028       menu = gtk_menu_new ();
4029       submenu = NULL;
4030       group = NULL;
4031
4032       menuitem = gtk_radio_menu_item_new_with_label (group, "Standard");
4033       gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
4034                                  GTK_SIGNAL_FUNC (standard_notebook),
4035                                  GTK_OBJECT (notebook));
4036       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
4037       gtk_menu_append (GTK_MENU (menu), menuitem);
4038       gtk_widget_show (menuitem);
4039       menuitem = gtk_radio_menu_item_new_with_label (group, "w/o Tabs");
4040       gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
4041                                  GTK_SIGNAL_FUNC (notabs_notebook),
4042                                  GTK_OBJECT (notebook));
4043       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
4044       gtk_menu_append (GTK_MENU (menu), menuitem);
4045       gtk_widget_show (menuitem);
4046       menuitem = gtk_radio_menu_item_new_with_label (group, "Scrollable");
4047       gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
4048                                  GTK_SIGNAL_FUNC (scrollable_notebook),
4049                                  GTK_OBJECT (notebook));
4050       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
4051       gtk_menu_append (GTK_MENU (menu), menuitem);
4052       gtk_widget_show (menuitem);
4053
4054       gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
4055       gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, FALSE, 0);
4056       button = gtk_check_button_new_with_label ("enable popup menu");
4057       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
4058       gtk_signal_connect (GTK_OBJECT(button), "clicked",
4059                           GTK_SIGNAL_FUNC (notebook_popup),
4060                           GTK_OBJECT (notebook));
4061
4062       box2 = gtk_hbox_new (FALSE, 10);
4063       gtk_container_border_width (GTK_CONTAINER (box2), 10);
4064       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4065
4066       button = gtk_button_new_with_label ("close");
4067       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4068                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
4069                                  GTK_OBJECT (window));
4070       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4071       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4072       gtk_widget_grab_default (button);
4073
4074       button = gtk_button_new_with_label ("next");
4075       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4076                                  GTK_SIGNAL_FUNC (gtk_notebook_next_page),
4077                                  GTK_OBJECT (notebook));
4078       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4079
4080       button = gtk_button_new_with_label ("prev");
4081       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4082                                  GTK_SIGNAL_FUNC (gtk_notebook_prev_page),
4083                                  GTK_OBJECT (notebook));
4084       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4085
4086       button = gtk_button_new_with_label ("rotate");
4087       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4088                           GTK_SIGNAL_FUNC (rotate_notebook),
4089                           notebook);
4090       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4091     }
4092
4093   if (!GTK_WIDGET_VISIBLE (window))
4094     gtk_widget_show_all (window);
4095   else
4096     gtk_widget_destroy (window);
4097 }
4098
4099
4100 /*
4101  * GtkPanes
4102  */
4103 void
4104 create_panes ()
4105 {
4106   static GtkWidget *window = NULL;
4107   GtkWidget *frame;
4108   GtkWidget *hpaned;
4109   GtkWidget *vpaned;
4110   GtkWidget *button;
4111
4112   if (!window)
4113     {
4114       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4115
4116       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4117                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4118                           &window);
4119
4120       gtk_window_set_title (GTK_WINDOW (window), "Panes");
4121       gtk_container_border_width (GTK_CONTAINER (window), 0);
4122
4123       vpaned = gtk_vpaned_new ();
4124       gtk_container_add (GTK_CONTAINER (window), vpaned);
4125       gtk_container_border_width (GTK_CONTAINER(vpaned), 5);
4126       gtk_widget_show (vpaned);
4127
4128       hpaned = gtk_hpaned_new ();
4129       gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
4130
4131       frame = gtk_frame_new (NULL);
4132       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
4133       gtk_widget_set_usize (frame, 60, 60);
4134       gtk_paned_add1 (GTK_PANED (hpaned), frame);
4135       gtk_widget_show (frame);
4136
4137       button = gtk_button_new_with_label ("Hi there");
4138       gtk_container_add (GTK_CONTAINER(frame), button);
4139       gtk_widget_show (button);
4140
4141       frame = gtk_frame_new (NULL);
4142       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
4143       gtk_widget_set_usize (frame, 80, 60);
4144       gtk_paned_add2 (GTK_PANED (hpaned), frame);
4145       gtk_widget_show (frame);
4146
4147       gtk_widget_show (hpaned);
4148
4149       frame = gtk_frame_new (NULL);
4150       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
4151       gtk_widget_set_usize (frame, 60, 80);
4152       gtk_paned_add2 (GTK_PANED (vpaned), frame);
4153       gtk_widget_show (frame);
4154     }
4155
4156   if (!GTK_WIDGET_VISIBLE (window))
4157     gtk_widget_show (window);
4158   else
4159     gtk_widget_destroy (window);
4160 }
4161
4162
4163 /*
4164  * Drag -N- Drop
4165  */
4166
4167 gint
4168 dnd_drop_destroy_popup (GtkWidget *widget, GtkWindow **window)
4169 {
4170   if(GTK_IS_BUTTON(widget)) /* I.e. they clicked the close button */
4171     gtk_widget_destroy(GTK_WIDGET(*window));
4172   else {
4173     gtk_grab_remove(GTK_WIDGET(*window));
4174     *window = NULL;
4175   }
4176
4177   return FALSE;
4178 }
4179
4180 void
4181 dnd_drop (GtkWidget *button, GdkEvent *event)
4182 {
4183   static GtkWidget *window = NULL;
4184   GtkWidget *vbox, *lbl, *btn;
4185   gchar *msg;
4186
4187   window = gtk_window_new(GTK_WINDOW_DIALOG);
4188   gtk_container_border_width (GTK_CONTAINER(window), 10);
4189
4190   gtk_signal_connect (GTK_OBJECT (window), "destroy",
4191                       GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
4192                       &window);
4193   gtk_signal_connect (GTK_OBJECT (window), "delete_event",
4194                       GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
4195                       &window);
4196
4197   vbox = gtk_vbox_new(FALSE, 5);
4198
4199   /* Display message that we got from drop source */
4200   msg = g_malloc(strlen(event->dropdataavailable.data)
4201                  + strlen(event->dropdataavailable.data_type) + 100);
4202   sprintf(msg, "Drop data of type %s was:\n\n%s",
4203           event->dropdataavailable.data_type,
4204           (char *)event->dropdataavailable.data);
4205   lbl = gtk_label_new(msg);
4206   gtk_label_set_justify(GTK_LABEL(lbl), GTK_JUSTIFY_FILL);
4207   g_free(msg);
4208   gtk_widget_show(lbl);
4209   gtk_box_pack_start_defaults(GTK_BOX(vbox), lbl);
4210
4211   /* Provide an obvious way out of this heinousness */
4212   btn = gtk_button_new_with_label("Continue with life in\nspite of this oppression");
4213   gtk_signal_connect (GTK_OBJECT (btn), "clicked",
4214                       GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
4215                       &window);
4216   gtk_widget_show(btn);
4217   gtk_box_pack_start_defaults(GTK_BOX(vbox), btn);
4218
4219   gtk_container_add(GTK_CONTAINER(window), vbox);
4220
4221   gtk_widget_show(vbox);
4222   gtk_grab_add(window);
4223   gtk_widget_show(window);
4224 }
4225
4226 void
4227 dnd_drag_request (GtkWidget *button, GdkEvent *event)
4228 {
4229 #define DND_STRING "Bill Gates demands royalties for\nyour use of his innovation."
4230   gtk_widget_dnd_data_set (button, event, DND_STRING, strlen(DND_STRING) + 1);
4231 }
4232
4233 void
4234 create_dnd ()
4235 {
4236   static GtkWidget *window = NULL;
4237   GtkWidget *box1;
4238   GtkWidget *box2;
4239   GtkWidget *box3;
4240   GtkWidget *frame;
4241   GtkWidget *button;
4242   GtkWidget *separator;
4243
4244   /* For clarity... */
4245   char *possible_drag_types[] = {"text/plain"};
4246   char *accepted_drop_types[] = {"text/plain"};
4247
4248   if(!modeller)
4249     create_shapes();
4250
4251   if (!window)
4252     {
4253       GdkPoint hotspot = {5,5};
4254
4255       gdk_dnd_set_drag_shape(modeller->window,
4256                              &hotspot,
4257                              rings->window,
4258                              &hotspot);
4259
4260       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4261
4262       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4263                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4264                           &window);
4265
4266       gtk_window_set_title (GTK_WINDOW (window), "Drag -N- Drop");
4267       gtk_container_border_width (GTK_CONTAINER (window), 0);
4268
4269       box1 = gtk_vbox_new (FALSE, 0);
4270       gtk_container_add (GTK_CONTAINER (window), box1);
4271       gtk_widget_show (box1);
4272
4273       box2 = gtk_hbox_new (FALSE, 5);
4274       gtk_container_border_width (GTK_CONTAINER (box2), 10);
4275       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
4276       gtk_widget_show (box2);
4277
4278       frame = gtk_frame_new ("Drag");
4279       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
4280       gtk_widget_show (frame);
4281
4282       box3 = gtk_vbox_new (FALSE, 5);
4283       gtk_container_border_width (GTK_CONTAINER (box3), 5);
4284       gtk_container_add (GTK_CONTAINER (frame), box3);
4285       gtk_widget_show (box3);
4286
4287       /*
4288        * FROM Button
4289        */
4290       button = gtk_button_new_with_label ("Drag me!");
4291       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
4292       gtk_widget_show (button);
4293
4294       /*
4295        * currently, the widget has to be realized to
4296        * set dnd on it, this needs to change
4297        */
4298       gtk_widget_realize (button);
4299       gtk_signal_connect (GTK_OBJECT (button),
4300                           "drag_request_event",
4301                           GTK_SIGNAL_FUNC(dnd_drag_request),
4302                           button);
4303
4304       gtk_widget_dnd_drag_set (button, TRUE, possible_drag_types, 1);
4305
4306
4307       frame = gtk_frame_new ("Drop");
4308       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
4309       gtk_widget_show (frame);
4310
4311       box3 = gtk_vbox_new (FALSE, 5);
4312       gtk_container_border_width (GTK_CONTAINER (box3), 5);
4313       gtk_container_add (GTK_CONTAINER (frame), box3);
4314       gtk_widget_show (box3);
4315
4316
4317       /*
4318        * TO Button
4319        */
4320       button = gtk_button_new_with_label ("To");
4321       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
4322       gtk_widget_show (button);
4323
4324       gtk_widget_realize (button);
4325       gtk_signal_connect (GTK_OBJECT (button),
4326                           "drop_data_available_event",
4327                           GTK_SIGNAL_FUNC(dnd_drop),
4328                           button);
4329
4330       gtk_widget_dnd_drop_set (button, TRUE, accepted_drop_types, 1, FALSE);
4331
4332
4333       separator = gtk_hseparator_new ();
4334       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4335       gtk_widget_show (separator);
4336
4337
4338       box2 = gtk_vbox_new (FALSE, 10);
4339       gtk_container_border_width (GTK_CONTAINER (box2), 10);
4340       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4341       gtk_widget_show (box2);
4342
4343
4344       button = gtk_button_new_with_label ("close");
4345
4346       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4347                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
4348                                  GTK_OBJECT (window));
4349
4350       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4351       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4352       gtk_widget_grab_default (button);
4353       gtk_widget_show (button);
4354     }
4355
4356   gtk_widget_hide(modeller); gtk_widget_hide(rings);
4357
4358   if (!GTK_WIDGET_VISIBLE (window))
4359     gtk_widget_show (window);
4360   else
4361     gtk_widget_destroy (window);
4362 }
4363
4364 /*
4365  * Shaped Windows
4366  */
4367 static GdkWindow *root_win = NULL;
4368
4369 typedef struct _cursoroffset {gint x,y;} CursorOffset;
4370
4371 static void
4372 shape_pressed (GtkWidget *widget, GdkEventButton *event)
4373 {
4374   CursorOffset *p;
4375
4376   /* ignore double and triple click */
4377   if (event->type != GDK_BUTTON_PRESS)
4378     return;
4379
4380   p = gtk_object_get_user_data (GTK_OBJECT(widget));
4381   p->x = (int) event->x;
4382   p->y = (int) event->y;
4383
4384   gtk_grab_add (widget);
4385   gdk_pointer_grab (widget->window, TRUE,
4386                     GDK_BUTTON_RELEASE_MASK |
4387                     GDK_BUTTON_MOTION_MASK |
4388                     GDK_POINTER_MOTION_HINT_MASK,
4389                     NULL, NULL, 0);
4390 }
4391
4392
4393 static void
4394 shape_released (GtkWidget *widget)
4395 {
4396   gtk_grab_remove (widget);
4397   gdk_pointer_ungrab (0);
4398 }
4399
4400 static void
4401 shape_motion (GtkWidget      *widget,
4402               GdkEventMotion *event)
4403 {
4404   gint xp, yp;
4405   CursorOffset * p;
4406   GdkModifierType mask;
4407
4408   p = gtk_object_get_user_data (GTK_OBJECT (widget));
4409
4410   /*
4411    * Can't use event->x / event->y here
4412    * because I need absolute coordinates.
4413    */
4414   gdk_window_get_pointer (root_win, &xp, &yp, &mask);
4415   gtk_widget_set_uposition (widget, xp  - p->x, yp  - p->y);
4416 }
4417
4418 GtkWidget *
4419 shape_create_icon (char     *xpm_file,
4420                    gint      x,
4421                    gint      y,
4422                    gint      px,
4423                    gint      py,
4424                    gint      window_type)
4425 {
4426   GtkWidget *window;
4427   GtkWidget *pixmap;
4428   GtkWidget *fixed;
4429   CursorOffset* icon_pos;
4430   GdkGC* gc;
4431   GdkBitmap *gdk_pixmap_mask;
4432   GdkPixmap *gdk_pixmap;
4433   GtkStyle *style;
4434
4435   style = gtk_widget_get_default_style ();
4436   gc = style->black_gc;
4437
4438   /*
4439    * GDK_WINDOW_TOPLEVEL works also, giving you a title border
4440    */
4441   window = gtk_window_new (window_type);
4442
4443   fixed = gtk_fixed_new ();
4444   gtk_widget_set_usize (fixed, 100,100);
4445   gtk_container_add (GTK_CONTAINER (window), fixed);
4446   gtk_widget_show (fixed);
4447
4448   gtk_widget_set_events (window,
4449                          gtk_widget_get_events (window) |
4450                          GDK_BUTTON_MOTION_MASK |
4451                          GDK_POINTER_MOTION_HINT_MASK |
4452                          GDK_BUTTON_PRESS_MASK);
4453
4454   gtk_widget_realize (window);
4455   gdk_pixmap = gdk_pixmap_create_from_xpm (window->window, &gdk_pixmap_mask,
4456                                            &style->bg[GTK_STATE_NORMAL],
4457                                            xpm_file);
4458
4459   pixmap = gtk_pixmap_new (gdk_pixmap, gdk_pixmap_mask);
4460   gtk_fixed_put (GTK_FIXED (fixed), pixmap, px,py);
4461   gtk_widget_show (pixmap);
4462
4463   gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px,py);
4464
4465
4466   gtk_signal_connect (GTK_OBJECT (window), "button_press_event",
4467                       GTK_SIGNAL_FUNC (shape_pressed),NULL);
4468   gtk_signal_connect (GTK_OBJECT (window), "button_release_event",
4469                       GTK_SIGNAL_FUNC (shape_released),NULL);
4470   gtk_signal_connect (GTK_OBJECT (window), "motion_notify_event",
4471                       GTK_SIGNAL_FUNC (shape_motion),NULL);
4472
4473   icon_pos = g_new (CursorOffset, 1);
4474   gtk_object_set_user_data(GTK_OBJECT(window), icon_pos);
4475
4476   gtk_widget_set_uposition (window, x, y);
4477   gtk_widget_show (window);
4478
4479   return window;
4480 }
4481
4482 void
4483 create_shapes ()
4484 {
4485   root_win = gdk_window_foreign_new (GDK_ROOT_WINDOW ());
4486
4487   if (!modeller)
4488     {
4489       modeller = shape_create_icon ("Modeller.xpm",
4490                                     440, 140, 0,0, GTK_WINDOW_POPUP);
4491
4492       gtk_signal_connect (GTK_OBJECT (modeller), "destroy",
4493                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4494                           &modeller);
4495     }
4496   else
4497     gtk_widget_destroy (modeller);
4498
4499   if (!sheets)
4500     {
4501       sheets = shape_create_icon ("FilesQueue.xpm",
4502                                   580, 170, 0,0, GTK_WINDOW_POPUP);
4503
4504       gtk_signal_connect (GTK_OBJECT (sheets), "destroy",
4505                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4506                           &sheets);
4507
4508     }
4509   else
4510     gtk_widget_destroy (sheets);
4511
4512   if (!rings)
4513     {
4514       rings = shape_create_icon ("3DRings.xpm",
4515                                  460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
4516
4517       gtk_signal_connect (GTK_OBJECT (rings), "destroy",
4518                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4519                           &rings);
4520     }
4521   else
4522     gtk_widget_destroy (rings);
4523 }
4524
4525 void
4526 create_wmhints ()
4527 {
4528   static GtkWidget *window = NULL;
4529   GtkWidget *label;
4530   GtkWidget *separator;
4531   GtkWidget *button;
4532   GtkWidget *box1;
4533   GtkWidget *box2;
4534
4535   GdkBitmap *circles;
4536
4537   if (!window)
4538     {
4539       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4540
4541       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4542                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4543                           &window);
4544
4545       gtk_window_set_title (GTK_WINDOW (window), "WM Hints");
4546       gtk_container_border_width (GTK_CONTAINER (window), 0);
4547
4548       gtk_widget_realize (window);
4549
4550       circles = gdk_bitmap_create_from_data (window->window,
4551                                              circles_bits,
4552                                              circles_width,
4553                                              circles_height);
4554       gdk_window_set_icon (window->window, NULL,
4555                            circles, circles);
4556
4557       gdk_window_set_icon_name (window->window, "WMHints Test Icon");
4558
4559       gdk_window_set_decorations (window->window, GDK_DECOR_ALL | GDK_DECOR_MENU);
4560       gdk_window_set_functions (window->window, GDK_FUNC_ALL | GDK_FUNC_RESIZE);
4561
4562       box1 = gtk_vbox_new (FALSE, 0);
4563       gtk_container_add (GTK_CONTAINER (window), box1);
4564       gtk_widget_show (box1);
4565
4566       label = gtk_label_new ("Try iconizing me!");
4567       gtk_widget_set_usize (label, 150, 50);
4568       gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
4569       gtk_widget_show (label);
4570
4571
4572       separator = gtk_hseparator_new ();
4573       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4574       gtk_widget_show (separator);
4575
4576
4577       box2 = gtk_vbox_new (FALSE, 10);
4578       gtk_container_border_width (GTK_CONTAINER (box2), 10);
4579       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4580       gtk_widget_show (box2);
4581
4582
4583       button = gtk_button_new_with_label ("close");
4584
4585       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4586                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
4587                                  GTK_OBJECT (window));
4588
4589       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4590       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4591       gtk_widget_grab_default (button);
4592       gtk_widget_show (button);
4593     }
4594
4595   if (!GTK_WIDGET_VISIBLE (window))
4596     gtk_widget_show (window);
4597   else
4598     gtk_widget_destroy (window);
4599 }
4600
4601 /*
4602  * Progress Bar
4603  */
4604 static int progress_timer = 0;
4605
4606 gint
4607 progress_timeout (gpointer data)
4608 {
4609   gfloat new_val;
4610
4611   new_val = GTK_PROGRESS_BAR (data)->percentage;
4612   if (new_val >= 1.0)
4613     new_val = 0.0;
4614   new_val += 0.02;
4615
4616   gtk_progress_bar_update (GTK_PROGRESS_BAR (data), new_val);
4617
4618   return TRUE;
4619 }
4620
4621 static void
4622 destroy_progress (GtkWidget  *widget,
4623                   GtkWidget **window)
4624 {
4625   gtk_timeout_remove (progress_timer);
4626   progress_timer = 0;
4627   *window = NULL;
4628 }
4629
4630 void
4631 create_progress_bar ()
4632 {
4633   static GtkWidget *window = NULL;
4634   GtkWidget *button;
4635   GtkWidget *vbox;
4636   GtkWidget *pbar;
4637   GtkWidget *label;
4638
4639   if (!window)
4640     {
4641       window = gtk_dialog_new ();
4642
4643       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4644                           GTK_SIGNAL_FUNC(destroy_progress),
4645                           &window);
4646
4647       gtk_window_set_title (GTK_WINDOW (window), "dialog");
4648       gtk_container_border_width (GTK_CONTAINER (window), 0);
4649
4650
4651       vbox = gtk_vbox_new (FALSE, 5);
4652       gtk_container_border_width (GTK_CONTAINER (vbox), 10);
4653       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
4654                           vbox, TRUE, TRUE, 0);
4655       gtk_widget_show (vbox);
4656
4657       label = gtk_label_new ("progress...");
4658       gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
4659       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
4660       gtk_widget_show (label);
4661
4662       pbar = gtk_progress_bar_new ();
4663       gtk_widget_set_usize (pbar, 200, 20);
4664       gtk_box_pack_start (GTK_BOX (vbox), pbar, TRUE, TRUE, 0);
4665       gtk_widget_show (pbar);
4666
4667       progress_timer = gtk_timeout_add (100, progress_timeout, pbar);
4668
4669       button = gtk_button_new_with_label ("close");
4670       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4671                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
4672                                  GTK_OBJECT (window));
4673       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4674       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
4675                           button, TRUE, TRUE, 0);
4676       gtk_widget_grab_default (button);
4677       gtk_widget_show (button);
4678     }
4679
4680   if (!GTK_WIDGET_VISIBLE (window))
4681     gtk_widget_show (window);
4682   else
4683     gtk_widget_destroy (window);
4684 }
4685
4686
4687 /*
4688  * Color Preview
4689  */
4690 static int color_idle = 0;
4691
4692 gint
4693 color_idle_func (GtkWidget *preview)
4694 {
4695   static int count = 1;
4696   guchar buf[768];
4697   int i, j, k;
4698
4699   for (i = 0; i < 256; i++)
4700     {
4701       for (j = 0, k = 0; j < 256; j++)
4702         {
4703           buf[k+0] = i + count;
4704           buf[k+1] = 0;
4705           buf[k+2] = j + count;
4706           k += 3;
4707         }
4708
4709       gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
4710     }
4711
4712   count += 1;
4713
4714   gtk_widget_draw (preview, NULL);
4715
4716   return TRUE;
4717 }
4718
4719 static void
4720 color_preview_destroy (GtkWidget  *widget,
4721                        GtkWidget **window)
4722 {
4723   gtk_idle_remove (color_idle);
4724   color_idle = 0;
4725
4726   *window = NULL;
4727 }
4728
4729 void
4730 create_color_preview ()
4731 {
4732   static GtkWidget *window = NULL;
4733   GtkWidget *preview;
4734   guchar buf[768];
4735   int i, j, k;
4736
4737   if (!window)
4738     {
4739       gtk_widget_push_visual (gtk_preview_get_visual ());
4740       gtk_widget_push_colormap (gtk_preview_get_cmap ());
4741
4742       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4743
4744       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4745                           GTK_SIGNAL_FUNC(color_preview_destroy),
4746                           &window);
4747
4748       gtk_window_set_title (GTK_WINDOW (window), "test");
4749       gtk_container_border_width (GTK_CONTAINER (window), 10);
4750
4751       preview = gtk_preview_new (GTK_PREVIEW_COLOR);
4752       gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
4753       gtk_container_add (GTK_CONTAINER (window), preview);
4754       gtk_widget_show (preview);
4755
4756       for (i = 0; i < 256; i++)
4757         {
4758           for (j = 0, k = 0; j < 256; j++)
4759             {
4760               buf[k+0] = i;
4761               buf[k+1] = 0;
4762               buf[k+2] = j;
4763               k += 3;
4764             }
4765
4766           gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
4767         }
4768
4769       color_idle = gtk_idle_add ((GtkFunction) color_idle_func, preview);
4770
4771       gtk_widget_pop_colormap ();
4772       gtk_widget_pop_visual ();
4773     }
4774
4775   if (!GTK_WIDGET_VISIBLE (window))
4776     gtk_widget_show (window);
4777   else
4778     gtk_widget_destroy (window);
4779 }
4780
4781
4782 /*
4783  * Gray Preview
4784  */
4785 static int gray_idle = 0;
4786
4787 gint
4788 gray_idle_func (GtkWidget *preview)
4789 {
4790   static int count = 1;
4791   guchar buf[256];
4792   int i, j;
4793
4794   for (i = 0; i < 256; i++)
4795     {
4796       for (j = 0; j < 256; j++)
4797         buf[j] = i + j + count;
4798
4799       gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
4800     }
4801
4802   count += 1;
4803
4804   gtk_widget_draw (preview, NULL);
4805
4806   return TRUE;
4807 }
4808
4809 static void
4810 gray_preview_destroy (GtkWidget  *widget,
4811                       GtkWidget **window)
4812 {
4813   gtk_idle_remove (gray_idle);
4814   gray_idle = 0;
4815
4816   *window = NULL;
4817 }
4818
4819 void
4820 create_gray_preview ()
4821 {
4822   static GtkWidget *window = NULL;
4823   GtkWidget *preview;
4824   guchar buf[256];
4825   int i, j;
4826
4827   if (!window)
4828     {
4829       gtk_widget_push_visual (gtk_preview_get_visual ());
4830       gtk_widget_push_colormap (gtk_preview_get_cmap ());
4831
4832       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4833
4834       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4835                           GTK_SIGNAL_FUNC(gray_preview_destroy),
4836                           &window);
4837
4838       gtk_window_set_title (GTK_WINDOW (window), "test");
4839       gtk_container_border_width (GTK_CONTAINER (window), 10);
4840
4841       preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
4842       gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
4843       gtk_container_add (GTK_CONTAINER (window), preview);
4844       gtk_widget_show (preview);
4845
4846       for (i = 0; i < 256; i++)
4847         {
4848           for (j = 0; j < 256; j++)
4849             buf[j] = i + j;
4850
4851           gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
4852         }
4853
4854       gray_idle = gtk_idle_add ((GtkFunction) gray_idle_func, preview);
4855
4856       gtk_widget_pop_colormap ();
4857       gtk_widget_pop_visual ();
4858     }
4859
4860   if (!GTK_WIDGET_VISIBLE (window))
4861     gtk_widget_show (window);
4862   else
4863     gtk_widget_destroy (window);
4864 }
4865
4866
4867 /*
4868  * Selection Test
4869  */
4870 void
4871 selection_test_received (GtkWidget *list, GtkSelectionData *data)
4872 {
4873   GdkAtom *atoms;
4874   GtkWidget *list_item;
4875   GList *item_list;
4876   int i, l;
4877
4878   if (data->length < 0)
4879     {
4880       g_print ("Selection retrieval failed\n");
4881       return;
4882     }
4883   if (data->type != GDK_SELECTION_TYPE_ATOM)
4884     {
4885       g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
4886       return;
4887     }
4888
4889   /* Clear out any current list items */
4890
4891   gtk_list_clear_items (GTK_LIST(list), 0, -1);
4892
4893   /* Add new items to list */
4894
4895   atoms = (GdkAtom *)data->data;
4896
4897   item_list = NULL;
4898   l = data->length / sizeof (GdkAtom);
4899   for (i = 0; i < l; i++)
4900     {
4901       char *name;
4902       name = gdk_atom_name (atoms[i]);
4903       if (name != NULL)
4904         {
4905           list_item = gtk_list_item_new_with_label (name);
4906           g_free (name);
4907         }
4908       else
4909         list_item = gtk_list_item_new_with_label ("(bad atom)");
4910
4911       gtk_widget_show (list_item);
4912       item_list = g_list_append (item_list, list_item);
4913     }
4914
4915   gtk_list_append_items (GTK_LIST (list), item_list);
4916
4917   return;
4918 }
4919
4920 void
4921 selection_test_get_targets (GtkWidget *widget, GtkWidget *list)
4922 {
4923   static GdkAtom targets_atom = GDK_NONE;
4924
4925   if (targets_atom == GDK_NONE)
4926     targets_atom = gdk_atom_intern ("TARGETS", FALSE);
4927
4928   gtk_selection_convert (list, GDK_SELECTION_PRIMARY, targets_atom,
4929                          GDK_CURRENT_TIME);
4930 }
4931
4932 void
4933 create_selection_test ()
4934 {
4935   static GtkWidget *window = NULL;
4936   GtkWidget *button;
4937   GtkWidget *vbox;
4938   GtkWidget *scrolled_win;
4939   GtkWidget *list;
4940   GtkWidget *label;
4941
4942   if (!window)
4943     {
4944       window = gtk_dialog_new ();
4945
4946       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4947                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4948                           &window);
4949
4950       gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
4951       gtk_container_border_width (GTK_CONTAINER (window), 0);
4952
4953       /* Create the list */
4954
4955       vbox = gtk_vbox_new (FALSE, 5);
4956       gtk_container_border_width (GTK_CONTAINER (vbox), 10);
4957       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox,
4958                           TRUE, TRUE, 0);
4959       gtk_widget_show (vbox);
4960
4961       label = gtk_label_new ("Gets available targets for current selection");
4962       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
4963       gtk_widget_show (label);
4964
4965       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
4966       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
4967                                       GTK_POLICY_AUTOMATIC,
4968                                       GTK_POLICY_AUTOMATIC);
4969       gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
4970       gtk_widget_set_usize (scrolled_win, 100, 200);
4971       gtk_widget_show (scrolled_win);
4972
4973       list = gtk_list_new ();
4974       gtk_container_add (GTK_CONTAINER (scrolled_win), list);
4975
4976       gtk_signal_connect (GTK_OBJECT(list), "selection_received",
4977                           GTK_SIGNAL_FUNC (selection_test_received), NULL);
4978       gtk_widget_show (list);
4979
4980       /* .. And create some buttons */
4981       button = gtk_button_new_with_label ("Get Targets");
4982       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
4983                           button, TRUE, TRUE, 0);
4984
4985       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4986                           GTK_SIGNAL_FUNC (selection_test_get_targets), list);
4987       gtk_widget_show (button);
4988
4989       button = gtk_button_new_with_label ("Quit");
4990       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
4991                           button, TRUE, TRUE, 0);
4992
4993       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4994                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
4995                                  GTK_OBJECT (window));
4996       gtk_widget_show (button);
4997     }
4998
4999   if (!GTK_WIDGET_VISIBLE (window))
5000     gtk_widget_show (window);
5001   else
5002     gtk_widget_destroy (window);
5003 }
5004
5005
5006 /*
5007  * Gamma Curve
5008  */
5009 void
5010 create_gamma_curve ()
5011 {
5012   static GtkWidget *window = NULL, *curve;
5013   static int count = 0;
5014   gfloat vec[256];
5015   gint max;
5016   gint i;
5017
5018   if (!window)
5019     {
5020       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5021       gtk_window_set_title (GTK_WINDOW (window), "test");
5022       gtk_container_border_width (GTK_CONTAINER (window), 10);
5023
5024       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5025                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5026                           &window);
5027
5028       curve = gtk_gamma_curve_new ();
5029       gtk_container_add (GTK_CONTAINER (window), curve);
5030       gtk_widget_show (curve);
5031     }
5032
5033   max = 127 + (count % 2)*128;
5034   gtk_curve_set_range (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
5035                        0, max, 0, max);
5036   for (i = 0; i < max; ++i)
5037     vec[i] = (127 / sqrt (max)) * sqrt (i);
5038   gtk_curve_set_vector (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
5039                         max, vec);
5040
5041   if (!GTK_WIDGET_VISIBLE (window))
5042     gtk_widget_show (window);
5043   else if (count % 4 == 3)
5044     {
5045       gtk_widget_destroy (window);
5046       window = NULL;
5047     }
5048
5049   ++count;
5050 }
5051
5052 static int scroll_test_pos = 0.0;
5053 static GdkGC *scroll_test_gc = NULL;
5054
5055 static gint
5056 scroll_test_expose (GtkWidget *widget, GdkEventExpose *event,
5057                     GtkAdjustment *adj)
5058 {
5059   gint i,j;
5060   gint imin, imax, jmin, jmax;
5061
5062   imin = (event->area.x) / 10;
5063   imax = (event->area.x + event->area.width + 9) / 10;
5064
5065   jmin = ((int)adj->value + event->area.y) / 10;
5066   jmax = ((int)adj->value + event->area.y + event->area.height + 9) / 10;
5067
5068   gdk_window_clear_area (widget->window,
5069                          event->area.x, event->area.y,
5070                          event->area.width, event->area.height);
5071
5072   for (i=imin; i<imax; i++)
5073     for (j=jmin; j<jmax; j++)
5074       if ((i+j) % 2)
5075         gdk_draw_rectangle (widget->window,
5076                             widget->style->black_gc,
5077                             TRUE,
5078                             10*i, 10*j - (int)adj->value, 1+i%10, 1+j%10);
5079
5080   return TRUE;
5081 }
5082
5083 static void
5084 scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
5085                        GtkAdjustment *adj)
5086 {
5087   adj->page_increment = 0.9 * widget->allocation.height;
5088   adj->page_size = widget->allocation.height;
5089
5090   gtk_signal_emit_by_name (GTK_OBJECT (adj), "changed");
5091 }
5092
5093 static void
5094 scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
5095 {
5096   gint source_min = (int)adj->value - scroll_test_pos;
5097   gint source_max = source_min + widget->allocation.height;
5098   gint dest_min = 0;
5099   gint dest_max = widget->allocation.height;
5100   GdkRectangle rect;
5101   GdkEvent *event;
5102
5103   scroll_test_pos = adj->value;
5104
5105   if (!GTK_WIDGET_DRAWABLE (widget))
5106     return;
5107
5108   if (source_min < 0)
5109     {
5110       rect.x = 0;
5111       rect.y = 0;
5112       rect.width = widget->allocation.width;
5113       rect.height = -source_min;
5114       if (rect.height > widget->allocation.height)
5115         rect.height = widget->allocation.height;
5116
5117       source_min = 0;
5118       dest_min = rect.height;
5119     }
5120   else
5121     {
5122       rect.x = 0;
5123       rect.y = 2*widget->allocation.height - source_max;
5124       if (rect.y < 0)
5125         rect.y = 0;
5126       rect.width = widget->allocation.width;
5127       rect.height = widget->allocation.height - rect.y;
5128
5129       source_max = widget->allocation.height;
5130       dest_max = rect.y;
5131     }
5132
5133   if (source_min != source_max)
5134     {
5135       if (scroll_test_gc == NULL)
5136         {
5137           scroll_test_gc = gdk_gc_new (widget->window);
5138           gdk_gc_set_exposures (scroll_test_gc, TRUE);
5139         }
5140
5141       gdk_draw_pixmap (widget->window,
5142                        scroll_test_gc,
5143                        widget->window,
5144                        0, source_min,
5145                        0, dest_min,
5146                        widget->allocation.width,
5147                        source_max - source_min);
5148
5149       /* Make sure graphics expose events are processed before scrolling
5150        * again */
5151
5152       while ((event = gdk_event_get_graphics_expose (widget->window)) != NULL)
5153         {
5154           gtk_widget_event (widget, event);
5155           if (event->expose.count == 0)
5156             {
5157               gdk_event_free (event);
5158               break;
5159             }
5160           gdk_event_free (event);
5161         }
5162     }
5163
5164
5165   if (rect.height != 0)
5166     gtk_widget_draw (widget, &rect);
5167 }
5168
5169
5170 void
5171 create_scroll_test ()
5172 {
5173   static GtkWidget *window = NULL;
5174   GtkWidget *hbox;
5175   GtkWidget *drawing_area;
5176   GtkWidget *scrollbar;
5177   GtkWidget *button;
5178   GtkAdjustment *adj;
5179
5180   if (!window)
5181     {
5182       window = gtk_dialog_new ();
5183
5184       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5185                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5186                           &window);
5187
5188       gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
5189       gtk_container_border_width (GTK_CONTAINER (window), 0);
5190
5191       hbox = gtk_hbox_new (FALSE, 0);
5192       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox,
5193                           TRUE, TRUE, 0);
5194       gtk_widget_show (hbox);
5195
5196       drawing_area = gtk_drawing_area_new ();
5197       gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 200, 200);
5198       gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
5199       gtk_widget_show (drawing_area);
5200
5201       gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK);
5202
5203       adj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0));
5204       scroll_test_pos = 0.0;
5205
5206       scrollbar = gtk_vscrollbar_new (adj);
5207       gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
5208       gtk_widget_show (scrollbar);
5209
5210       gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
5211                           GTK_SIGNAL_FUNC (scroll_test_expose), adj);
5212       gtk_signal_connect (GTK_OBJECT (drawing_area), "configure_event",
5213                           GTK_SIGNAL_FUNC (scroll_test_configure), adj);
5214
5215
5216       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
5217                           GTK_SIGNAL_FUNC (scroll_test_adjustment_changed),
5218                           drawing_area);
5219
5220       /* .. And create some buttons */
5221
5222       button = gtk_button_new_with_label ("Quit");
5223       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5224                           button, TRUE, TRUE, 0);
5225
5226       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5227                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
5228                                  GTK_OBJECT (window));
5229       gtk_widget_show (button);
5230     }
5231
5232   if (!GTK_WIDGET_VISIBLE (window))
5233     gtk_widget_show (window);
5234   else
5235     gtk_widget_destroy (window);
5236 }
5237
5238 /*
5239  * Timeout Test
5240  */
5241 static int timer = 0;
5242
5243 void
5244 timeout_test (GtkWidget *label)
5245 {
5246   static int count = 0;
5247   static char buffer[32];
5248
5249   sprintf (buffer, "count: %d", ++count);
5250   gtk_label_set (GTK_LABEL (label), buffer);
5251 }
5252
5253 void
5254 start_timeout_test (GtkWidget *widget,
5255                     GtkWidget *label)
5256 {
5257   if (!timer)
5258     {
5259       timer = gtk_timeout_add (100, (GtkFunction) timeout_test, label);
5260     }
5261 }
5262
5263 void
5264 stop_timeout_test (GtkWidget *widget,
5265                    gpointer   data)
5266 {
5267   if (timer)
5268     {
5269       gtk_timeout_remove (timer);
5270       timer = 0;
5271     }
5272 }
5273
5274 void
5275 destroy_timeout_test (GtkWidget  *widget,
5276                       GtkWidget **window)
5277 {
5278   stop_timeout_test (NULL, NULL);
5279
5280   *window = NULL;
5281 }
5282
5283 void
5284 create_timeout_test ()
5285 {
5286   static GtkWidget *window = NULL;
5287   GtkWidget *button;
5288   GtkWidget *label;
5289
5290   if (!window)
5291     {
5292       window = gtk_dialog_new ();
5293
5294       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5295                           GTK_SIGNAL_FUNC(destroy_timeout_test),
5296                           &window);
5297
5298       gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
5299       gtk_container_border_width (GTK_CONTAINER (window), 0);
5300
5301       label = gtk_label_new ("count: 0");
5302       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
5303       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
5304                           label, TRUE, TRUE, 0);
5305       gtk_widget_show (label);
5306
5307       button = gtk_button_new_with_label ("close");
5308       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5309                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
5310                                  GTK_OBJECT (window));
5311       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5312       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5313                           button, TRUE, TRUE, 0);
5314       gtk_widget_grab_default (button);
5315       gtk_widget_show (button);
5316
5317       button = gtk_button_new_with_label ("start");
5318       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5319                           GTK_SIGNAL_FUNC(start_timeout_test),
5320                           label);
5321       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5322       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5323                           button, TRUE, TRUE, 0);
5324       gtk_widget_show (button);
5325
5326       button = gtk_button_new_with_label ("stop");
5327       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5328                           GTK_SIGNAL_FUNC(stop_timeout_test),
5329                           NULL);
5330       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5331       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5332                           button, TRUE, TRUE, 0);
5333       gtk_widget_show (button);
5334     }
5335
5336   if (!GTK_WIDGET_VISIBLE (window))
5337     gtk_widget_show (window);
5338   else
5339     gtk_widget_destroy (window);
5340 }
5341
5342
5343 /*
5344  * Idle Test
5345  */
5346 static int idle = 0;
5347
5348 gint
5349 idle_test (GtkWidget *label)
5350 {
5351   static int count = 0;
5352   static char buffer[32];
5353
5354   sprintf (buffer, "count: %d", ++count);
5355   gtk_label_set (GTK_LABEL (label), buffer);
5356
5357   return TRUE;
5358 }
5359
5360 void
5361 start_idle_test (GtkWidget *widget,
5362                  GtkWidget *label)
5363 {
5364   if (!idle)
5365     {
5366       idle = gtk_idle_add ((GtkFunction) idle_test, label);
5367     }
5368 }
5369
5370 void
5371 stop_idle_test (GtkWidget *widget,
5372                 gpointer   data)
5373 {
5374   if (idle)
5375     {
5376       gtk_idle_remove (idle);
5377       idle = 0;
5378     }
5379 }
5380
5381 void
5382 destroy_idle_test (GtkWidget  *widget,
5383                    GtkWidget **window)
5384 {
5385   stop_idle_test (NULL, NULL);
5386
5387   *window = NULL;
5388 }
5389
5390 void
5391 create_idle_test ()
5392 {
5393   static GtkWidget *window = NULL;
5394   GtkWidget *button;
5395   GtkWidget *label;
5396
5397   if (!window)
5398     {
5399       window = gtk_dialog_new ();
5400
5401       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5402                           GTK_SIGNAL_FUNC(destroy_idle_test),
5403                           &window);
5404
5405       gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
5406       gtk_container_border_width (GTK_CONTAINER (window), 0);
5407
5408       label = gtk_label_new ("count: 0");
5409       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
5410       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
5411                           label, TRUE, TRUE, 0);
5412       gtk_widget_show (label);
5413
5414       button = gtk_button_new_with_label ("close");
5415       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5416                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
5417                                  GTK_OBJECT (window));
5418       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5419       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5420                           button, TRUE, TRUE, 0);
5421       gtk_widget_grab_default (button);
5422       gtk_widget_show (button);
5423
5424       button = gtk_button_new_with_label ("start");
5425       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5426                           GTK_SIGNAL_FUNC(start_idle_test),
5427                           label);
5428       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5429       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5430                           button, TRUE, TRUE, 0);
5431       gtk_widget_show (button);
5432
5433       button = gtk_button_new_with_label ("stop");
5434       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5435                           GTK_SIGNAL_FUNC(stop_idle_test),
5436                           NULL);
5437       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5438       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5439                           button, TRUE, TRUE, 0);
5440       gtk_widget_show (button);
5441     }
5442
5443   if (!GTK_WIDGET_VISIBLE (window))
5444     gtk_widget_show (window);
5445   else
5446     gtk_widget_destroy (window);
5447 }
5448
5449 /*
5450  * Basic Test
5451  */
5452 void
5453 create_test ()
5454 {
5455   static GtkWidget *window = NULL;
5456
5457   if (!window)
5458     {
5459       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5460
5461       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5462                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5463                           &window);
5464
5465
5466       gtk_window_set_title (GTK_WINDOW (window), "test");
5467       gtk_container_border_width (GTK_CONTAINER (window), 0);
5468     }
5469
5470   if (!GTK_WIDGET_VISIBLE (window))
5471     {
5472       gtk_widget_show (window);
5473
5474       g_print ("create_test: start\n");
5475       gtk_main ();
5476       g_print ("create_test: done\n");
5477     }
5478   else
5479     gtk_widget_destroy (window);
5480 }
5481
5482
5483 /*
5484  * Main Window and Exit
5485  */
5486 void
5487 do_exit (GtkWidget *widget, GtkWidget *window)
5488 {
5489   gtk_widget_destroy (window);
5490   gtk_main_quit ();
5491 }
5492
5493 void
5494 create_main_window ()
5495 {
5496   struct {
5497     char *label;
5498     void (*func) ();
5499   } buttons[] =
5500     {
5501       { "button box", create_button_box },
5502       { "buttons", create_buttons },
5503       { "check buttons", create_check_buttons },
5504       { "clist", create_clist},
5505       { "color selection", create_color_selection },
5506       { "cursors", create_cursors },
5507       { "dialog", create_dialog },
5508       { "dnd", create_dnd },
5509       { "entry", create_entry },
5510       { "file selection", create_file_selection },
5511       { "gamma curve", create_gamma_curve },
5512       { "handle box", create_handle_box },
5513       { "list", create_list },
5514       { "menus", create_menus },
5515       { "miscellaneous", NULL },
5516       { "notebook", create_notebook },
5517       { "panes", create_panes },
5518       { "pixmap", create_pixmap },
5519       { "preview color", create_color_preview },
5520       { "preview gray", create_gray_preview },
5521       { "progress bar", create_progress_bar },
5522       { "radio buttons", create_radio_buttons },
5523       { "range controls", create_range_controls },
5524       { "reparent", create_reparent },
5525       { "rulers", create_rulers },
5526       { "scrolled windows", create_scrolled_windows },
5527       { "shapes", create_shapes },
5528       { "spinbutton", create_spins },
5529       { "statusbar", create_statusbar },
5530       { "test idle", create_idle_test },
5531       { "test mainloop", create_test },
5532       { "test scrolling", create_scroll_test },
5533       { "test selection", create_selection_test },
5534       { "test timeout", create_timeout_test },
5535       { "text", create_text },
5536       { "toggle buttons", create_toggle_buttons },
5537       { "toolbar", create_toolbar },
5538       { "tooltips", create_tooltips },
5539       { "tree", create_tree_mode_window},
5540       { "WM hints", create_wmhints },
5541     };
5542   int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
5543   GtkWidget *window;
5544   GtkWidget *box1;
5545   GtkWidget *box2;
5546   GtkWidget *scrolled_window;
5547   GtkWidget *button;
5548   GtkWidget *label;
5549   gchar buffer[64];
5550   GtkWidget *separator;
5551   int i;
5552
5553   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5554   gtk_widget_set_name (window, "main window");
5555   gtk_widget_set_usize (window, 200, 400);
5556   gtk_widget_set_uposition (window, 20, 20);
5557
5558   gtk_signal_connect (GTK_OBJECT (window), "destroy",
5559                       GTK_SIGNAL_FUNC(gtk_main_quit),
5560                       NULL);
5561   gtk_signal_connect (GTK_OBJECT (window), "delete_event",
5562                       GTK_SIGNAL_FUNC (gtk_false),
5563                       NULL);
5564
5565   box1 = gtk_vbox_new (FALSE, 0);
5566   gtk_container_add (GTK_CONTAINER (window), box1);
5567   gtk_widget_show (box1);
5568
5569   if (gtk_micro_version > 0)
5570     sprintf (buffer,
5571              "Gtk+ v%d.%d.%d",
5572              gtk_major_version,
5573              gtk_minor_version,
5574              gtk_micro_version);
5575   else
5576     sprintf (buffer,
5577              "Gtk+ v%d.%d",
5578              gtk_major_version,
5579              gtk_minor_version);
5580
5581   label = gtk_label_new (buffer);
5582   gtk_widget_show (label);
5583   gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
5584
5585   scrolled_window = gtk_scrolled_window_new (NULL, NULL);
5586   gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
5587   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
5588                                   GTK_POLICY_AUTOMATIC,
5589                                   GTK_POLICY_AUTOMATIC);
5590   gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
5591   gtk_widget_show (scrolled_window);
5592
5593   box2 = gtk_vbox_new (FALSE, 0);
5594   gtk_container_border_width (GTK_CONTAINER (box2), 10);
5595   gtk_container_add (GTK_CONTAINER (scrolled_window), box2);
5596   gtk_widget_show (box2);
5597
5598   for (i = 0; i < nbuttons; i++)
5599     {
5600       button = gtk_button_new_with_label (buttons[i].label);
5601       if (buttons[i].func)
5602         gtk_signal_connect (GTK_OBJECT (button),
5603                             "clicked",
5604                             GTK_SIGNAL_FUNC(buttons[i].func),
5605                             NULL);
5606       else
5607         gtk_widget_set_sensitive (button, FALSE);
5608       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5609       gtk_widget_show (button);
5610     }
5611
5612   separator = gtk_hseparator_new ();
5613   gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5614   gtk_widget_show (separator);
5615
5616   box2 = gtk_vbox_new (FALSE, 10);
5617   gtk_container_border_width (GTK_CONTAINER (box2), 10);
5618   gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5619   gtk_widget_show (box2);
5620
5621   button = gtk_button_new_with_label ("close");
5622   gtk_signal_connect (GTK_OBJECT (button), "clicked",
5623                       GTK_SIGNAL_FUNC (do_exit),
5624                       window);
5625   gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5626   GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5627   gtk_widget_grab_default (button);
5628   gtk_widget_show (button);
5629
5630   gtk_widget_show (window);
5631 }
5632
5633 int
5634 main (int argc, char *argv[])
5635 {
5636   gtk_set_locale ();
5637
5638   gtk_init (&argc, &argv);
5639
5640 #ifdef HAVE_LIBGLE
5641   gle_init (&argc, &argv);
5642 #endif /* !HAVE_LIBGLE */
5643
5644   gtk_rc_parse ("testgtkrc");
5645
5646   create_main_window ();
5647
5648   gtk_main ();
5649
5650   return 0;
5651 }