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