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

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the Free
  16  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include "gtk.h"
  21 #include "../gdk/gdk.h"
  22 #include "../gdk/gdkx.h"
  23
  24 #include "circles.xbm"
  25
  26 /* Variables used by the Drag/Drop and Shape Window demos */
  27 static GtkWidget *modeller = NULL;
  28 static GtkWidget *sheets = NULL;
  29 static GtkWidget *rings = NULL;
  30 void create_shapes(void);
  31
  32
  33 /* macro, structure and variables used by tree window demos */
  34 #define DEFAULT_NUMBER_OF_ITEM  3
  35 #define DEFAULT_RECURSION_LEVEL 3
  36
  37 struct {
  38   GSList* selection_mode_group;
  39   GtkWidget* single_button;
  40   GtkWidget* browse_button;
  41   GtkWidget* multiple_button;
  42   GtkWidget* draw_line_button;
  43   GtkWidget* view_line_button;
  44   GtkWidget* no_root_item_button;
  45   GtkWidget* nb_item_spinner;
  46   GtkWidget* recursion_spinner;
  47 } sTreeSampleSelection;
  48
  49 typedef struct sTreeButtons {
  50   guint nb_item_add;
  51   GtkWidget* add_button;
  52   GtkWidget* remove_button;
  53 } sTreeButtons;
  54 /* end of tree section */
  55
  56 static void
  57 destroy_tooltips (GtkWidget *widget, GtkWindow **window)
  58 {
  59   GtkTooltips *tt = gtk_object_get_data (GTK_OBJECT (*window), "tooltips");
  60   gtk_object_unref (GTK_OBJECT (tt));
  61
  62   *window = NULL;
  63 }
  64
  65 static void
  66 button_window (GtkWidget *widget,
  67                GtkWidget *button)
  68 {
  69   if (!GTK_WIDGET_VISIBLE (button))
  70     gtk_widget_show (button);
  71   else
  72     gtk_widget_hide (button);
  73 }
  74
  75 static void
  76 create_buttons ()
  77 {
  78   static GtkWidget *window = NULL;
  79   GtkWidget *box1;
  80   GtkWidget *box2;
  81   GtkWidget *table;
  82   GtkWidget *button[10];
  83   GtkWidget *separator;
  84
  85   if (!window)
  86     {
  87       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  88
  89       gtk_signal_connect (GTK_OBJECT (window), "destroy",
  90                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
  91                           &window);
  92
  93       gtk_window_set_title (GTK_WINDOW (window), "buttons");
  94       gtk_container_border_width (GTK_CONTAINER (window), 0);
  95
  96       box1 = gtk_vbox_new (FALSE, 0);
  97       gtk_container_add (GTK_CONTAINER (window), box1);
  98       gtk_widget_show (box1);
  99
 100
 101       table = gtk_table_new (3, 3, FALSE);
 102       gtk_table_set_row_spacings (GTK_TABLE (table), 5);
 103       gtk_table_set_col_spacings (GTK_TABLE (table), 5);
 104       gtk_container_border_width (GTK_CONTAINER (table), 10);
 105       gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
 106       gtk_widget_show (table);
 107
 108
 109       button[0] = gtk_button_new_with_label ("button1");
 110       button[1] = gtk_button_new_with_label ("button2");
 111       button[2] = gtk_button_new_with_label ("button3");
 112       button[3] = gtk_button_new_with_label ("button4");
 113       button[4] = gtk_button_new_with_label ("button5");
 114       button[5] = gtk_button_new_with_label ("button6");
 115       button[6] = gtk_button_new_with_label ("button7");
 116       button[7] = gtk_button_new_with_label ("button8");
 117       button[8] = gtk_button_new_with_label ("button9");
 118
 119       gtk_signal_connect (GTK_OBJECT (button[0]), "clicked",
 120                           GTK_SIGNAL_FUNC(button_window),
 121                           button[1]);
 122
 123       gtk_table_attach (GTK_TABLE (table), button[0], 0, 1, 0, 1,
 124                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 125       gtk_widget_show (button[0]);
 126
 127       gtk_signal_connect (GTK_OBJECT (button[1]), "clicked",
 128                           GTK_SIGNAL_FUNC(button_window),
 129                           button[2]);
 130
 131       gtk_table_attach (GTK_TABLE (table), button[1], 1, 2, 1, 2,
 132                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 133       gtk_widget_show (button[1]);
 134
 135       gtk_signal_connect (GTK_OBJECT (button[2]), "clicked",
 136                           GTK_SIGNAL_FUNC(button_window),
 137                           button[3]);
 138       gtk_table_attach (GTK_TABLE (table), button[2], 2, 3, 2, 3,
 139                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 140       gtk_widget_show (button[2]);
 141
 142       gtk_signal_connect (GTK_OBJECT (button[3]), "clicked",
 143                           GTK_SIGNAL_FUNC(button_window),
 144                           button[4]);
 145       gtk_table_attach (GTK_TABLE (table), button[3], 0, 1, 2, 3,
 146                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 147       gtk_widget_show (button[3]);
 148
 149       gtk_signal_connect (GTK_OBJECT (button[4]), "clicked",
 150                           GTK_SIGNAL_FUNC(button_window),
 151                           button[5]);
 152       gtk_table_attach (GTK_TABLE (table), button[4], 2, 3, 0, 1,
 153                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 154       gtk_widget_show (button[4]);
 155
 156       gtk_signal_connect (GTK_OBJECT (button[5]), "clicked",
 157                           GTK_SIGNAL_FUNC(button_window),
 158                           button[6]);
 159       gtk_table_attach (GTK_TABLE (table), button[5], 1, 2, 2, 3,
 160                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 161       gtk_widget_show (button[5]);
 162
 163       gtk_signal_connect (GTK_OBJECT (button[6]), "clicked",
 164                           GTK_SIGNAL_FUNC(button_window),
 165                           button[7]);
 166       gtk_table_attach (GTK_TABLE (table), button[6], 1, 2, 0, 1,
 167                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 168       gtk_widget_show (button[6]);
 169
 170       gtk_signal_connect (GTK_OBJECT (button[7]), "clicked",
 171                           GTK_SIGNAL_FUNC(button_window),
 172                           button[8]);
 173       gtk_table_attach (GTK_TABLE (table), button[7], 2, 3, 1, 2,
 174                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 175       gtk_widget_show (button[7]);
 176
 177       gtk_signal_connect (GTK_OBJECT (button[8]), "clicked",
 178                           GTK_SIGNAL_FUNC(button_window),
 179                           button[0]);
 180       gtk_table_attach (GTK_TABLE (table), button[8], 0, 1, 1, 2,
 181                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 182       gtk_widget_show (button[8]);
 183
 184
 185       separator = gtk_hseparator_new ();
 186       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 187       gtk_widget_show (separator);
 188
 189
 190       box2 = gtk_vbox_new (FALSE, 10);
 191       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 192       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 193       gtk_widget_show (box2);
 194
 195
 196       button[9] = gtk_button_new_with_label ("close");
 197       gtk_signal_connect_object (GTK_OBJECT (button[9]), "clicked",
 198                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
 199                                  GTK_OBJECT (window));
 200       gtk_box_pack_start (GTK_BOX (box2), button[9], TRUE, TRUE, 0);
 201       GTK_WIDGET_SET_FLAGS (button[9], GTK_CAN_DEFAULT);
 202       gtk_widget_grab_default (button[9]);
 203       gtk_widget_show (button[9]);
 204     }
 205
 206   if (!GTK_WIDGET_VISIBLE (window))
 207     gtk_widget_show (window);
 208   else
 209     gtk_widget_destroy (window);
 210 }
 211
 212 static void
 213 create_toggle_buttons ()
 214 {
 215   static GtkWidget *window = NULL;
 216   GtkWidget *box1;
 217   GtkWidget *box2;
 218   GtkWidget *button;
 219   GtkWidget *separator;
 220
 221   if (!window)
 222     {
 223       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 224
 225       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 226                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
 227                           &window);
 228
 229       gtk_window_set_title (GTK_WINDOW (window), "toggle buttons");
 230       gtk_container_border_width (GTK_CONTAINER (window), 0);
 231
 232
 233       box1 = gtk_vbox_new (FALSE, 0);
 234       gtk_container_add (GTK_CONTAINER (window), box1);
 235       gtk_widget_show (box1);
 236
 237
 238       box2 = gtk_vbox_new (FALSE, 10);
 239       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 240       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
 241       gtk_widget_show (box2);
 242
 243
 244       button = gtk_toggle_button_new_with_label ("button1");
 245       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 246       gtk_widget_show (button);
 247
 248       button = gtk_toggle_button_new_with_label ("button2");
 249       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 250       gtk_widget_show (button);
 251
 252       button = gtk_toggle_button_new_with_label ("button3");
 253       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 254       gtk_widget_show (button);
 255
 256
 257       separator = gtk_hseparator_new ();
 258       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 259       gtk_widget_show (separator);
 260
 261
 262       box2 = gtk_vbox_new (FALSE, 10);
 263       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 264       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 265       gtk_widget_show (box2);
 266
 267
 268       button = gtk_button_new_with_label ("close");
 269       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
 270                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
 271                                  GTK_OBJECT (window));
 272       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 273       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 274       gtk_widget_grab_default (button);
 275       gtk_widget_show (button);
 276     }
 277
 278   if (!GTK_WIDGET_VISIBLE (window))
 279     gtk_widget_show (window);
 280   else
 281     gtk_widget_destroy (window);
 282 }
 283
 284 static void
 285 create_check_buttons ()
 286 {
 287   static GtkWidget *window = NULL;
 288   GtkWidget *box1;
 289   GtkWidget *box2;
 290   GtkWidget *button;
 291   GtkWidget *separator;
 292
 293   if (!window)
 294     {
 295       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 296
 297       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 298                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
 299                           &window);
 300
 301       gtk_window_set_title (GTK_WINDOW (window), "check buttons");
 302       gtk_container_border_width (GTK_CONTAINER (window), 0);
 303
 304
 305       box1 = gtk_vbox_new (FALSE, 0);
 306       gtk_container_add (GTK_CONTAINER (window), box1);
 307       gtk_widget_show (box1);
 308
 309
 310       box2 = gtk_vbox_new (FALSE, 10);
 311       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 312       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
 313       gtk_widget_show (box2);
 314
 315
 316       button = gtk_check_button_new_with_label ("button1");
 317       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 318       gtk_widget_show (button);
 319
 320       button = gtk_check_button_new_with_label ("button2");
 321       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 322       gtk_widget_show (button);
 323
 324       button = gtk_check_button_new_with_label ("button3");
 325       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 326       gtk_widget_show (button);
 327
 328
 329       separator = gtk_hseparator_new ();
 330       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 331       gtk_widget_show (separator);
 332
 333
 334       box2 = gtk_vbox_new (FALSE, 10);
 335       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 336       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 337       gtk_widget_show (box2);
 338
 339
 340       button = gtk_button_new_with_label ("close");
 341       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
 342                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
 343                                  GTK_OBJECT (window));
 344       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 345       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 346       gtk_widget_grab_default (button);
 347       gtk_widget_show (button);
 348     }
 349
 350   if (!GTK_WIDGET_VISIBLE (window))
 351     gtk_widget_show (window);
 352   else
 353     gtk_widget_destroy (window);
 354 }
 355
 356 static void
 357 create_radio_buttons ()
 358 {
 359   static GtkWidget *window = NULL;
 360   GtkWidget *box1;
 361   GtkWidget *box2;
 362   GtkWidget *button;
 363   GtkWidget *separator;
 364
 365   if (!window)
 366     {
 367       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 368
 369       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 370                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
 371                           &window);
 372
 373       gtk_window_set_title (GTK_WINDOW (window), "radio buttons");
 374       gtk_container_border_width (GTK_CONTAINER (window), 0);
 375
 376
 377       box1 = gtk_vbox_new (FALSE, 0);
 378       gtk_container_add (GTK_CONTAINER (window), box1);
 379       gtk_widget_show (box1);
 380
 381
 382       box2 = gtk_vbox_new (FALSE, 10);
 383       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 384       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
 385       gtk_widget_show (box2);
 386
 387
 388       button = gtk_radio_button_new_with_label (NULL, "button1");
 389       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 390       gtk_widget_show (button);
 391
 392       button = gtk_radio_button_new_with_label (
 393                  gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
 394                  "button2");
 395       gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
 396       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 397       gtk_widget_show (button);
 398
 399       button = gtk_radio_button_new_with_label (
 400                  gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
 401                  "button3");
 402       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 403       gtk_widget_show (button);
 404
 405
 406       separator = gtk_hseparator_new ();
 407       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 408       gtk_widget_show (separator);
 409
 410
 411       box2 = gtk_vbox_new (FALSE, 10);
 412       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 413       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 414       gtk_widget_show (box2);
 415
 416
 417       button = gtk_button_new_with_label ("close");
 418       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
 419                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
 420                                  GTK_OBJECT (window));
 421       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 422       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 423       gtk_widget_grab_default (button);
 424       gtk_widget_show (button);
 425     }
 426
 427   if (!GTK_WIDGET_VISIBLE (window))
 428     gtk_widget_show (window);
 429   else
 430     gtk_widget_destroy (window);
 431 }
 432
 433 static void
 434 bbox_widget_destroy (GtkWidget* widget, GtkWidget* todestroy)
 435 {
 436 }
 437
 438 static void
 439 create_bbox_window (gint  horizontal,
 440                     char* title,
 441                     gint  pos,
 442                     gint  spacing,
 443                     gint  child_w,
 444                     gint  child_h,
 445                     gint  layout)
 446 {
 447   GtkWidget* window;
 448   GtkWidget* box1;
 449   GtkWidget* bbox;
 450   GtkWidget* button;
 451
 452   /* create a new window */
 453   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 454   gtk_window_set_title (GTK_WINDOW (window), title);
 455
 456   gtk_signal_connect (GTK_OBJECT (window), "destroy",
 457                       GTK_SIGNAL_FUNC(bbox_widget_destroy), window);
 458
 459   if (horizontal)
 460   {
 461     gtk_widget_set_usize (window, 550, 60);
 462     gtk_widget_set_uposition (window, 150, pos);
 463     box1 = gtk_vbox_new (FALSE, 0);
 464   }
 465   else
 466   {
 467     gtk_widget_set_usize (window, 150, 400);
 468     gtk_widget_set_uposition (window, pos, 200);
 469     box1 = gtk_vbox_new (FALSE, 0);
 470   }
 471
 472   gtk_container_add (GTK_CONTAINER (window), box1);
 473   gtk_widget_show (box1);
 474
 475   if (horizontal)
 476     bbox = gtk_hbutton_box_new();
 477   else
 478     bbox = gtk_vbutton_box_new();
 479   gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), layout);
 480   gtk_button_box_set_spacing (GTK_BUTTON_BOX (bbox), spacing);
 481   gtk_button_box_set_child_size (GTK_BUTTON_BOX (bbox), child_w, child_h);
 482   gtk_widget_show (bbox);
 483
 484   gtk_container_border_width (GTK_CONTAINER(box1), 25);
 485   gtk_box_pack_start (GTK_BOX (box1), bbox, TRUE, TRUE, 0);
 486
 487   button = gtk_button_new_with_label ("OK");
 488   gtk_container_add (GTK_CONTAINER(bbox), button);
 489
 490   gtk_signal_connect (GTK_OBJECT (button), "clicked",
 491                       GTK_SIGNAL_FUNC(bbox_widget_destroy), window);
 492
 493   gtk_widget_show (button);
 494
 495   button = gtk_button_new_with_label ("Cancel");
 496   gtk_container_add (GTK_CONTAINER(bbox), button);
 497   gtk_widget_show (button);
 498
 499   button = gtk_button_new_with_label ("Help");
 500   gtk_container_add (GTK_CONTAINER(bbox), button);
 501   gtk_widget_show (button);
 502
 503   gtk_widget_show (window);
 504 }
 505
 506 static void
 507 test_hbbox ()
 508 {
 509   create_bbox_window (TRUE, "Spread", 50, 40, 85, 28, GTK_BUTTONBOX_SPREAD);
 510   create_bbox_window (TRUE, "Edge", 200, 40, 85, 25, GTK_BUTTONBOX_EDGE);
 511   create_bbox_window (TRUE, "Start", 350, 40, 85, 25, GTK_BUTTONBOX_START);
 512   create_bbox_window (TRUE, "End", 500, 15, 30, 25, GTK_BUTTONBOX_END);
 513 }
 514
 515 static void
 516 test_vbbox ()
 517 {
 518   create_bbox_window (FALSE, "Spread", 50, 40, 85, 25, GTK_BUTTONBOX_SPREAD);
 519   create_bbox_window (FALSE, "Edge", 250, 40, 85, 28, GTK_BUTTONBOX_EDGE);
 520   create_bbox_window (FALSE, "Start", 450, 40, 85, 25, GTK_BUTTONBOX_START);
 521   create_bbox_window (FALSE, "End", 650, 15, 30, 25, GTK_BUTTONBOX_END);
 522 }
 523
 524 static void
 525 create_button_box ()
 526 {
 527   static GtkWidget* window = NULL;
 528   GtkWidget* bbox;
 529   GtkWidget* button;
 530
 531   if (!window)
 532   {
 533     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 534     gtk_window_set_title (GTK_WINDOW (window),
 535                           "Button Box Test");
 536
 537     gtk_signal_connect (GTK_OBJECT (window), "destroy",
 538                         GTK_SIGNAL_FUNC(gtk_widget_destroyed),
 539                         &window);
 540
 541     gtk_container_border_width (GTK_CONTAINER (window), 20);
 542
 543     /*
 544      *these 15 lines are a nice and easy example for GtkHButtonBox
 545      */
 546     bbox = gtk_hbutton_box_new ();
 547     gtk_container_add (GTK_CONTAINER (window), bbox);
 548     gtk_widget_show (bbox);
 549
 550     button = gtk_button_new_with_label ("Horizontal");
 551     gtk_signal_connect (GTK_OBJECT (button), "clicked",
 552                         GTK_SIGNAL_FUNC(test_hbbox), 0);
 553     gtk_container_add (GTK_CONTAINER (bbox), button);
 554     gtk_widget_show (button);
 555
 556     button = gtk_button_new_with_label ("Vertical");
 557     gtk_signal_connect (GTK_OBJECT (button), "clicked",
 558                         GTK_SIGNAL_FUNC(test_vbbox), 0);
 559     gtk_container_add (GTK_CONTAINER (bbox), button);
 560     gtk_widget_show (button);
 561   }
 562
 563   if (!GTK_WIDGET_VISIBLE (window))
 564     gtk_widget_show (window);
 565   else
 566     gtk_widget_destroy (window);
 567 }
 568
 569 static GtkWidget*
 570 new_pixmap (char      *filename,
 571             GdkWindow *window,
 572             GdkColor  *background)
 573 {
 574   GtkWidget *wpixmap;
 575   GdkPixmap *pixmap;
 576   GdkBitmap *mask;
 577
 578   pixmap = gdk_pixmap_create_from_xpm (window, &mask,
 579                                        background,
 580                                        filename);
 581   wpixmap = gtk_pixmap_new (pixmap, mask);
 582
 583   return wpixmap;
 584 }
 585
 586 static void
 587 set_toolbar_horizontal (GtkWidget *widget,
 588                         gpointer   data)
 589 {
 590   gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_HORIZONTAL);
 591 }
 592
 593 static void
 594 set_toolbar_vertical (GtkWidget *widget,
 595                       gpointer   data)
 596 {
 597   gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_VERTICAL);
 598 }
 599
 600 static void
 601 set_toolbar_icons (GtkWidget *widget,
 602                    gpointer   data)
 603 {
 604   gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_ICONS);
 605 }
 606
 607 static void
 608 set_toolbar_text (GtkWidget *widget,
 609                   gpointer   data)
 610 {
 611   gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_TEXT);
 612 }
 613
 614 static void
 615 set_toolbar_both (GtkWidget *widget,
 616                   gpointer   data)
 617 {
 618   gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH);
 619 }
 620
 621 static void
 622 set_toolbar_small_space (GtkWidget *widget,
 623                          gpointer   data)
 624 {
 625   gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 5);
 626 }
 627
 628 static void
 629 set_toolbar_big_space (GtkWidget *widget,
 630                        gpointer   data)
 631 {
 632   gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 10);
 633 }
 634
 635 static void
 636 set_toolbar_enable (GtkWidget *widget,
 637                     gpointer   data)
 638 {
 639   gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), TRUE);
 640 }
 641
 642 static void
 643 set_toolbar_disable (GtkWidget *widget,
 644                      gpointer   data)
 645 {
 646   gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), FALSE);
 647 }
 648
 649 static void
 650 create_toolbar (void)
 651 {
 652   static GtkWidget *window = NULL;
 653   GtkWidget *toolbar;
 654   GtkWidget *entry;
 655
 656   if (!window)
 657     {
 658       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 659       gtk_window_set_title (GTK_WINDOW (window), "Toolbar test");
 660       gtk_window_set_policy (GTK_WINDOW (window), FALSE, TRUE, TRUE);
 661
 662       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 663                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
 664                           &window);
 665
 666       gtk_container_border_width (GTK_CONTAINER (window), 0);
 667       gtk_widget_realize (window);
 668
 669       toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
 670
 671       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 672                                "Horizontal", "Horizontal toolbar layout", "Toolbar/Horizontal",
 673                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 674                                (GtkSignalFunc) set_toolbar_horizontal, toolbar);
 675       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 676                                "Vertical", "Vertical toolbar layout", "Toolbar/Vertical",
 677                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 678                                (GtkSignalFunc) set_toolbar_vertical, toolbar);
 679
 680       gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
 681
 682       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 683                                "Icons", "Only show toolbar icons", "Toolbar/IconsOnly",
 684                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 685                                (GtkSignalFunc) set_toolbar_icons, toolbar);
 686       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 687                                "Text", "Only show toolbar text", "Toolbar/TextOnly",
 688                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 689                                (GtkSignalFunc) set_toolbar_text, toolbar);
 690       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 691                                "Both", "Show toolbar icons and text", "Toolbar/Both",
 692                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 693                                (GtkSignalFunc) set_toolbar_both, toolbar);
 694
 695       gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 696
 697       entry = gtk_entry_new ();
 698       gtk_widget_show(entry);
 699       gtk_toolbar_append_widget (GTK_TOOLBAR (toolbar), entry, "This is an unusable GtkEntry ;)", "Hey don't click me!!!");
 700
 701       gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 702
 703       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 704                                "Small", "Use small spaces", "Toolbar/Small",
 705                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 706                                (GtkSignalFunc) set_toolbar_small_space, toolbar);
 707       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 708                                "Big", "Use big spaces", "Toolbar/Big",
 709                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 710                                (GtkSignalFunc) set_toolbar_big_space, toolbar);
 711
 712       gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 713
 714       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 715                                "Enable", "Enable tooltips", NULL,
 716                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 717                                (GtkSignalFunc) set_toolbar_enable, toolbar);
 718       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 719                                "Disable", "Disable tooltips", NULL,
 720                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 721                                (GtkSignalFunc) set_toolbar_disable, toolbar);
 722
 723       gtk_container_add (GTK_CONTAINER (window), toolbar);
 724       gtk_widget_show (toolbar);
 725     }
 726
 727   if (!GTK_WIDGET_VISIBLE (window))
 728     gtk_widget_show (window);
 729   else
 730     gtk_widget_destroy (window);
 731 }
 732
 733 static GtkWidget*
 734 make_toolbar (GtkWidget *window)
 735 {
 736   GtkWidget *toolbar;
 737
 738   if (!GTK_WIDGET_REALIZED (window))
 739     gtk_widget_realize (window);
 740
 741   toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
 742
 743   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 744                            "Horizontal", "Horizontal toolbar layout", NULL,
 745                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 746                            (GtkSignalFunc) set_toolbar_horizontal, toolbar);
 747   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 748                            "Vertical", "Vertical toolbar layout", NULL,
 749                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 750                            (GtkSignalFunc) set_toolbar_vertical, toolbar);
 751
 752   gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
 753
 754   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 755                            "Icons", "Only show toolbar icons", NULL,
 756                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 757                            (GtkSignalFunc) set_toolbar_icons, toolbar);
 758   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 759                            "Text", "Only show toolbar text", NULL,
 760                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 761                            (GtkSignalFunc) set_toolbar_text, toolbar);
 762   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 763                            "Both", "Show toolbar icons and text", NULL,
 764                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 765                            (GtkSignalFunc) set_toolbar_both, toolbar);
 766
 767   gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 768
 769   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 770                            "Small", "Use small spaces", NULL,
 771                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 772                            (GtkSignalFunc) set_toolbar_small_space, toolbar);
 773   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 774                            "Big", "Use big spaces", "Toolbar/Big",
 775                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 776                            (GtkSignalFunc) set_toolbar_big_space, toolbar);
 777
 778   gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 779
 780   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 781                            "Enable", "Enable tooltips", NULL,
 782                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 783                            (GtkSignalFunc) set_toolbar_enable, toolbar);
 784   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 785                            "Disable", "Disable tooltips", NULL,
 786                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 787                            (GtkSignalFunc) set_toolbar_disable, toolbar);
 788
 789   return toolbar;
 790 }
 791
 792 static guint statusbar_counter = 1;
 793
 794 static void
 795 statusbar_push (GtkWidget *button,
 796                 GtkStatusbar *statusbar)
 797 {
 798   gchar text[1024];
 799
 800   sprintf (text, "something %d", statusbar_counter++);
 801
 802   gtk_statusbar_push (statusbar, 1, text);
 803 }
 804
 805 static void
 806 statusbar_pop (GtkWidget *button,
 807                GtkStatusbar *statusbar)
 808 {
 809   gtk_statusbar_pop (statusbar, 1);
 810 }
 811
 812 static void
 813 statusbar_steal (GtkWidget *button,
 814                  GtkStatusbar *statusbar)
 815 {
 816   gtk_statusbar_remove (statusbar, 1, 4);
 817 }
 818
 819 static void
 820 statusbar_popped (GtkStatusbar  *statusbar,
 821                   guint          context_id,
 822                   const gchar   *text)
 823 {
 824   if (!statusbar->messages)
 825     statusbar_counter = 1;
 826 }
 827
 828 static void
 829 statusbar_contexts (GtkWidget *button,
 830                     GtkStatusbar *statusbar)
 831 {
 832   gchar *string;
 833
 834   string = "any context";
 835   g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
 836            string,
 837            gtk_statusbar_get_context_id (statusbar, string));
 838
 839   string = "idle messages";
 840   g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
 841            string,
 842            gtk_statusbar_get_context_id (statusbar, string));
 843
 844   string = "some text";
 845   g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
 846            string,
 847            gtk_statusbar_get_context_id (statusbar, string));
 848
 849   string = "hit the mouse";
 850   g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
 851            string,
 852            gtk_statusbar_get_context_id (statusbar, string));
 853
 854   string = "hit the mouse2";
 855   g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
 856            string,
 857            gtk_statusbar_get_context_id (statusbar, string));
 858 }
 859
 860 static void
 861 statusbar_dump_stack (GtkWidget *button,
 862                       GtkStatusbar *statusbar)
 863 {
 864   GSList *list;
 865
 866   for (list = statusbar->messages; list; list = list->next)
 867     {
 868       GtkStatusbarMsg *msg;
 869
 870       msg = list->data;
 871       g_print ("context_id: %d, message_id: %d, status_text: \"%s\"\n",
 872                msg->context_id,
 873                msg->message_id,
 874                msg->text);
 875     }
 876 }
 877
 878 static void
 879 create_statusbar ()
 880 {
 881   static GtkWidget *window = NULL;
 882   GtkWidget *box1;
 883   GtkWidget *box2;
 884   GtkWidget *button;
 885   GtkWidget *separator;
 886   GtkWidget *statusbar;
 887
 888   if (!window)
 889     {
 890       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 891
 892       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 893                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
 894                           &window);
 895
 896       gtk_window_set_title (GTK_WINDOW (window), "statusbar");
 897       gtk_container_border_width (GTK_CONTAINER (window), 0);
 898
 899
 900       box1 = gtk_vbox_new (FALSE, 0);
 901       gtk_container_add (GTK_CONTAINER (window), box1);
 902       gtk_widget_show (box1);
 903
 904
 905       box2 = gtk_vbox_new (FALSE, 10);
 906       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 907       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
 908       gtk_widget_show (box2);
 909
 910       statusbar = gtk_statusbar_new ();
 911       gtk_box_pack_end (GTK_BOX (box1), statusbar, TRUE, TRUE, 0);
 912       gtk_widget_show (statusbar);
 913       gtk_signal_connect (GTK_OBJECT (statusbar),
 914                           "text_popped",
 915                           GTK_SIGNAL_FUNC (statusbar_popped),
 916                           NULL);
 917
 918       button = gtk_widget_new (gtk_button_get_type (),
 919                                "GtkButton::label", "push something",
 920                                "GtkWidget::visible", TRUE,
 921                                "GtkWidget::parent", box2,
 922                                "GtkObject::signal::clicked", statusbar_push, statusbar,
 923                                NULL);
 924
 925       button = gtk_widget_new (gtk_button_get_type (),
 926                                "GtkButton::label", "pop",
 927                                "GtkWidget::visible", TRUE,
 928                                "GtkWidget::parent", box2,
 929                                "GtkObject::signal::clicked", statusbar_pop, statusbar,
 930                                NULL);
 931
 932       button = gtk_widget_new (gtk_button_get_type (),
 933                                "GtkButton::label", "steal #4",
 934                                "GtkWidget::visible", TRUE,
 935                                "GtkWidget::parent", box2,
 936                                "GtkObject::signal::clicked", statusbar_steal, statusbar,
 937                                NULL);
 938
 939       button = gtk_widget_new (gtk_button_get_type (),
 940                                "GtkButton::label", "dump stack",
 941                                "GtkWidget::visible", TRUE,
 942                                "GtkWidget::parent", box2,
 943                                "GtkObject::signal::clicked", statusbar_dump_stack, statusbar,
 944                                NULL);
 945
 946       button = gtk_widget_new (gtk_button_get_type (),
 947                                "GtkButton::label", "test contexts",
 948                                "GtkWidget::visible", TRUE,
 949                                "GtkWidget::parent", box2,
 950                                "GtkObject::signal::clicked", statusbar_contexts, statusbar,
 951                                NULL);
 952
 953       separator = gtk_hseparator_new ();
 954       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 955       gtk_widget_show (separator);
 956
 957
 958       box2 = gtk_vbox_new (FALSE, 10);
 959       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 960       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 961       gtk_widget_show (box2);
 962
 963
 964       button = gtk_button_new_with_label ("close");
 965       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
 966                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
 967                                  GTK_OBJECT (window));
 968       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 969       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 970       gtk_widget_grab_default (button);
 971       gtk_widget_show (button);
 972     }
 973
 974   if (!GTK_WIDGET_VISIBLE (window))
 975     gtk_widget_show (window);
 976   else
 977     gtk_widget_destroy (window);
 978 }
 979
 980 static void
 981 handle_box_child_signal (GtkHandleBox *hb,
 982                          GtkWidget    *child,
 983                          const gchar  *action)
 984 {
 985   printf ("%s: child <%s> %sed\n",
 986           gtk_type_name (GTK_OBJECT_TYPE (hb)),
 987           gtk_type_name (GTK_OBJECT_TYPE (child)),
 988           action);
 989 }
 990
 991 static void
 992 cb_tree_destroy_event(GtkWidget* w)
 993 {
 994   sTreeButtons* tree_buttons;
 995
 996   /* free buttons structure associate at this tree */
 997   tree_buttons = gtk_object_get_user_data(GTK_OBJECT(w));
 998   free(tree_buttons);
 999 }
1000 static void
1001 cb_add_new_item(GtkWidget* w, GtkTree* tree)
1002 {
1003   sTreeButtons* tree_buttons;
1004   GList* selected_list;
1005   GtkWidget* selected_item;
1006   GtkWidget* subtree;
1007   GtkWidget* item_new;
1008   char buffer[255];
1009
1010   tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree));
1011
1012   selected_list = GTK_TREE_SELECTION(tree);
1013
1014   if(selected_list == NULL)
1015     {
1016       /* there is no item in tree */
1017       subtree = GTK_WIDGET(tree);
1018     }
1019   else
1020     {
1021       /* list can have only one element */
1022       selected_item = GTK_WIDGET(selected_list->data);
1023
1024       subtree = GTK_TREE_ITEM_SUBTREE(selected_item);
1025
1026       if(subtree == NULL)
1027         {
1028           /* current selected item have not subtree ... create it */
1029           subtree = gtk_tree_new();
1030           gtk_tree_item_set_subtree(GTK_TREE_ITEM(selected_item),
1031                                     subtree);
1032         }
1033     }
1034
1035   /* at this point, we know which subtree will be used to add new item */
1036   /* create a new item */
1037   sprintf(buffer, "item add %d", tree_buttons->nb_item_add);
1038   item_new = gtk_tree_item_new_with_label(buffer);
1039   gtk_tree_append(GTK_TREE(subtree), item_new);
1040   gtk_widget_show(item_new);
1041
1042   tree_buttons->nb_item_add++;
1043 }
1044
1045 static void
1046 cb_remove_item(GtkWidget*w, GtkTree* tree)
1047 {
1048   GList* selected_list;
1049   GList* clear_list;
1050
1051   selected_list = GTK_TREE_SELECTION(tree);
1052
1053   clear_list = NULL;
1054
1055   while (selected_list)
1056     {
1057       clear_list = g_list_prepend (clear_list, selected_list->data);
1058       selected_list = selected_list->next;
1059     }
1060
1061   clear_list = g_list_reverse (clear_list);
1062   gtk_tree_remove_items(tree, clear_list);
1063
1064   g_list_free (clear_list);
1065 }
1066
1067 static void
1068 cb_tree_changed(GtkTree* tree)
1069 {
1070   sTreeButtons* tree_buttons;
1071   GList* selected_list;
1072   guint nb_selected;
1073
1074   tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree));
1075
1076   selected_list = GTK_TREE_SELECTION(tree);
1077   nb_selected = g_list_length(selected_list);
1078
1079   if(nb_selected == 0)
1080     {
1081       if(tree->children == NULL)
1082         gtk_widget_set_sensitive(tree_buttons->add_button, TRUE);
1083       else
1084         gtk_widget_set_sensitive(tree_buttons->add_button, FALSE);
1085       gtk_widget_set_sensitive(tree_buttons->remove_button, FALSE);
1086     }
1087   else
1088     {
1089       gtk_widget_set_sensitive(tree_buttons->remove_button, TRUE);
1090       gtk_widget_set_sensitive(tree_buttons->add_button, (nb_selected == 1));
1091     }
1092 }
1093
1094 static void
1095 create_subtree(GtkWidget* item, guint level, guint nb_item_max, guint recursion_level_max)
1096 {
1097   GtkWidget* item_subtree;
1098   GtkWidget* item_new;
1099   guint nb_item;
1100   char buffer[255];
1101   int no_root_item;
1102
1103   if(level == recursion_level_max) return;
1104
1105   if(level == -1)
1106     {
1107       /* query with no root item */
1108       level = 0;
1109       item_subtree = item;
1110       no_root_item = 1;
1111     }
1112   else
1113     {
1114       /* query with no root item */
1115       /* create subtree and associate it with current item */
1116       item_subtree = gtk_tree_new();
1117       no_root_item = 0;
1118     }
1119
1120   for(nb_item = 0; nb_item < nb_item_max; nb_item++)
1121     {
1122       sprintf(buffer, "item %d-%d", level, nb_item);
1123       item_new = gtk_tree_item_new_with_label(buffer);
1124       gtk_tree_append(GTK_TREE(item_subtree), item_new);
1125       create_subtree(item_new, level+1, nb_item_max, recursion_level_max);
1126       gtk_widget_show(item_new);
1127     }
1128
1129   if(!no_root_item)
1130     gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), item_subtree);
1131 }
1132
1133 static void
1134 create_tree_sample(guint selection_mode,
1135                    guint draw_line, guint view_line, guint no_root_item,
1136                    guint nb_item_max, guint recursion_level_max)
1137 {
1138   GtkWidget* window;
1139   GtkWidget* box1;
1140   GtkWidget* box2;
1141   GtkWidget* separator;
1142   GtkWidget* button;
1143   GtkWidget* scrolled_win;
1144   GtkWidget* root_tree;
1145   GtkWidget* root_item;
1146   sTreeButtons* tree_buttons;
1147
1148   /* create tree buttons struct */
1149   if((tree_buttons = g_malloc(sizeof(sTreeButtons))) == NULL)
1150     {
1151       g_error("can't allocate memory for tree structure !\n");
1152       return;
1153     }
1154   tree_buttons->nb_item_add = 0;
1155
1156   /* create top level window */
1157   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1158   gtk_window_set_title(GTK_WINDOW(window), "Tree Sample");
1159   gtk_signal_connect(GTK_OBJECT(window), "destroy",
1160                      (GtkSignalFunc) cb_tree_destroy_event, NULL);
1161   gtk_object_set_user_data(GTK_OBJECT(window), tree_buttons);
1162
1163   box1 = gtk_vbox_new(FALSE, 0);
1164   gtk_container_add(GTK_CONTAINER(window), box1);
1165   gtk_widget_show(box1);
1166
1167   /* create tree box */
1168   box2 = gtk_vbox_new(FALSE, 0);
1169   gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);
1170   gtk_container_border_width(GTK_CONTAINER(box2), 5);
1171   gtk_widget_show(box2);
1172
1173   /* create scrolled window */
1174   scrolled_win = gtk_scrolled_window_new (NULL, NULL);
1175   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
1176                                   GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1177   gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
1178   gtk_widget_set_usize (scrolled_win, 200, 200);
1179   gtk_widget_show (scrolled_win);
1180
1181   /* create root tree widget */
1182   root_tree = gtk_tree_new();
1183   gtk_signal_connect(GTK_OBJECT(root_tree), "selection_changed",
1184                      (GtkSignalFunc)cb_tree_changed,
1185                      (gpointer)NULL);
1186   gtk_object_set_user_data(GTK_OBJECT(root_tree), tree_buttons);
1187   gtk_container_add(GTK_CONTAINER(scrolled_win), root_tree);
1188   gtk_tree_set_selection_mode(GTK_TREE(root_tree), selection_mode);
1189   gtk_tree_set_view_lines(GTK_TREE(root_tree), draw_line);
1190   gtk_tree_set_view_mode(GTK_TREE(root_tree), !view_line);
1191   gtk_widget_show(root_tree);
1192
1193   if ( no_root_item )
1194     {
1195       /* set root tree to subtree function with root item variable */
1196       root_item = GTK_WIDGET(root_tree);
1197     }
1198   else
1199     {
1200       /* create root tree item widget */
1201       root_item = gtk_tree_item_new_with_label("root item");
1202       gtk_tree_append(GTK_TREE(root_tree), root_item);
1203       gtk_widget_show(root_item);
1204      }
1205   create_subtree(root_item, -no_root_item, nb_item_max, recursion_level_max);
1206
1207   box2 = gtk_vbox_new(FALSE, 0);
1208   gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1209   gtk_container_border_width(GTK_CONTAINER(box2), 5);
1210   gtk_widget_show(box2);
1211
1212   button = gtk_button_new_with_label("Add Item");
1213   gtk_widget_set_sensitive(button, FALSE);
1214   gtk_signal_connect(GTK_OBJECT (button), "clicked",
1215                      (GtkSignalFunc) cb_add_new_item,
1216                      (gpointer)root_tree);
1217   gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1218   gtk_widget_show(button);
1219   tree_buttons->add_button = button;
1220
1221   button = gtk_button_new_with_label("Remove Item(s)");
1222   gtk_widget_set_sensitive(button, FALSE);
1223   gtk_signal_connect(GTK_OBJECT (button), "clicked",
1224                      (GtkSignalFunc) cb_remove_item,
1225                      (gpointer)root_tree);
1226   gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1227   gtk_widget_show(button);
1228   tree_buttons->remove_button = button;
1229
1230   /* create separator */
1231   separator = gtk_hseparator_new();
1232   gtk_box_pack_start(GTK_BOX(box1), separator, FALSE, FALSE, 0);
1233   gtk_widget_show(separator);
1234
1235   /* create button box */
1236   box2 = gtk_vbox_new(FALSE, 0);
1237   gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1238   gtk_container_border_width(GTK_CONTAINER(box2), 5);
1239   gtk_widget_show(box2);
1240
1241   button = gtk_button_new_with_label("Close");
1242   gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1243   gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
1244                             (GtkSignalFunc) gtk_widget_destroy,
1245                             GTK_OBJECT(window));
1246   gtk_widget_show(button);
1247
1248   gtk_widget_show(window);
1249 }
1250
1251 static void
1252 cb_create_tree(GtkWidget* w)
1253 {
1254   guint selection_mode = GTK_SELECTION_SINGLE;
1255   guint view_line;
1256   guint draw_line;
1257   guint no_root_item;
1258   guint nb_item;
1259   guint recursion_level;
1260
1261   /* get selection mode choice */
1262   if(GTK_TOGGLE_BUTTON(sTreeSampleSelection.single_button)->active)
1263     selection_mode = GTK_SELECTION_SINGLE;
1264   else
1265     if(GTK_TOGGLE_BUTTON(sTreeSampleSelection.browse_button)->active)
1266       selection_mode = GTK_SELECTION_BROWSE;
1267     else
1268       selection_mode = GTK_SELECTION_MULTIPLE;
1269
1270   /* get options choice */
1271   draw_line = GTK_TOGGLE_BUTTON(sTreeSampleSelection.draw_line_button)->active;
1272   view_line = GTK_TOGGLE_BUTTON(sTreeSampleSelection.view_line_button)->active;
1273   no_root_item = GTK_TOGGLE_BUTTON(sTreeSampleSelection.no_root_item_button)->active;
1274
1275   /* get levels */
1276   nb_item = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sTreeSampleSelection.nb_item_spinner));
1277   recursion_level = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sTreeSampleSelection.recursion_spinner));
1278
1279   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  * GtkList
2426  */
2427 static void
2428 list_add (GtkWidget *widget,
2429           GtkWidget *list)
2430 {
2431   static int i = 1;
2432   gchar buffer[64];
2433   GtkWidget *list_item;
2434
2435   sprintf (buffer, "added item %d", i++);
2436   list_item = gtk_list_item_new_with_label (buffer);
2437   gtk_widget_show (list_item);
2438   gtk_container_add (GTK_CONTAINER (list), list_item);
2439 }
2440
2441 static void
2442 list_remove (GtkWidget *widget,
2443              GtkWidget *list)
2444 {
2445   GList *tmp_list;
2446   GList *clear_list;
2447
2448   tmp_list = GTK_LIST (list)->selection;
2449   clear_list = NULL;
2450
2451   while (tmp_list)
2452     {
2453       clear_list = g_list_prepend (clear_list, tmp_list->data);
2454       tmp_list = tmp_list->next;
2455     }
2456
2457   clear_list = g_list_reverse (clear_list);
2458
2459   gtk_list_remove_items (GTK_LIST (list), clear_list);
2460
2461   g_list_free (clear_list);
2462 }
2463
2464 static void
2465 list_clear (GtkWidget *widget,
2466             GtkWidget *list)
2467 {
2468   gtk_list_clear_items (GTK_LIST (list), 3 - 1, 5 - 1);
2469 }
2470
2471 static void
2472 create_list ()
2473 {
2474   static GtkWidget *window = NULL;
2475   static char *list_items[] =
2476   {
2477     "hello",
2478     "world",
2479     "blah",
2480     "foo",
2481     "bar",
2482     "argh",
2483     "spencer",
2484     "is a",
2485     "wussy",
2486     "programmer",
2487   };
2488   static int nlist_items = sizeof (list_items) / sizeof (list_items[0]);
2489
2490   GtkWidget *box1;
2491   GtkWidget *box2;
2492   GtkWidget *scrolled_win;
2493   GtkWidget *list;
2494   GtkWidget *list_item;
2495   GtkWidget *button;
2496   GtkWidget *separator;
2497   int i;
2498
2499   if (!window)
2500     {
2501       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2502
2503       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2504                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2505                           &window);
2506
2507       gtk_window_set_title (GTK_WINDOW (window), "list");
2508       gtk_container_border_width (GTK_CONTAINER (window), 0);
2509
2510
2511       box1 = gtk_vbox_new (FALSE, 0);
2512       gtk_container_add (GTK_CONTAINER (window), box1);
2513       gtk_widget_show (box1);
2514
2515
2516       box2 = gtk_vbox_new (FALSE, 10);
2517       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2518       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2519       gtk_widget_show (box2);
2520
2521
2522       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
2523       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
2524                                       GTK_POLICY_AUTOMATIC,
2525                                       GTK_POLICY_AUTOMATIC);
2526       gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
2527       gtk_widget_show (scrolled_win);
2528
2529       list = gtk_list_new ();
2530       gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_MULTIPLE);
2531       gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_BROWSE);
2532       gtk_container_add (GTK_CONTAINER (scrolled_win), list);
2533       gtk_widget_show (list);
2534
2535       for (i = 0; i < nlist_items; i++)
2536         {
2537           list_item = gtk_list_item_new_with_label (list_items[i]);
2538           gtk_container_add (GTK_CONTAINER (list), list_item);
2539           gtk_widget_show (list_item);
2540         }
2541
2542       button = gtk_button_new_with_label ("add");
2543       GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
2544       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2545                           GTK_SIGNAL_FUNC(list_add),
2546                           list);
2547       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
2548       gtk_widget_show (button);
2549
2550       button = gtk_button_new_with_label ("clear items 3 - 5");
2551       GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
2552       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2553                           GTK_SIGNAL_FUNC(list_clear),
2554                           list);
2555       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
2556       gtk_widget_show (button);
2557
2558       button = gtk_button_new_with_label ("remove");
2559       GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
2560       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2561                           GTK_SIGNAL_FUNC(list_remove),
2562                           list);
2563       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
2564       gtk_widget_show (button);
2565
2566
2567       separator = gtk_hseparator_new ();
2568       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2569       gtk_widget_show (separator);
2570
2571
2572       box2 = gtk_vbox_new (FALSE, 10);
2573       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2574       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2575       gtk_widget_show (box2);
2576
2577
2578       button = gtk_button_new_with_label ("close");
2579       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2580                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2581                                  GTK_OBJECT (window));
2582       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2583       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2584       gtk_widget_grab_default (button);
2585       gtk_widget_show (button);
2586     }
2587
2588   if (!GTK_WIDGET_VISIBLE (window))
2589     gtk_widget_show (window);
2590   else
2591     gtk_widget_destroy (window);
2592 }
2593
2594 /*
2595  * GtkCList
2596  */
2597 #define TESTGTK_CLIST_COLUMNS 7
2598 static gint clist_rows = 0;
2599 static gint clist_selected_row = 0;
2600
2601 static void
2602 add1000_clist (GtkWidget *widget, gpointer data)
2603 {
2604   gint i, row;
2605   char text[TESTGTK_CLIST_COLUMNS][50];
2606   char *texts[TESTGTK_CLIST_COLUMNS];
2607   GdkBitmap *mask;
2608   GdkPixmap *pixmap;
2609
2610   pixmap = gdk_pixmap_create_from_xpm (GTK_CLIST (data)->clist_window,
2611                                        &mask,
2612                                        &GTK_WIDGET (data)->style->white,
2613                                        "test.xpm");
2614
2615   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
2616     {
2617       texts[i] = text[i];
2618       sprintf (text[i], "Column %d", i);
2619     }
2620
2621   texts[3] = NULL;
2622   sprintf (text[1], "Right");
2623   sprintf (text[2], "Center");
2624
2625   gtk_clist_freeze (GTK_CLIST (data));
2626   for (i = 0; i < 1000; i++)
2627     {
2628       sprintf (text[0], "Row %d", clist_rows++);
2629       row = gtk_clist_append (GTK_CLIST (data), texts);
2630       gtk_clist_set_pixtext (GTK_CLIST (data), row, 3, "Testing", 5, pixmap, mask);
2631     }
2632   gtk_clist_thaw (GTK_CLIST (data));
2633
2634   gdk_pixmap_unref (pixmap);
2635   gdk_bitmap_unref (mask);
2636 }
2637
2638 static void
2639 add10000_clist (GtkWidget *widget, gpointer data)
2640 {
2641   gint i;
2642   char text[TESTGTK_CLIST_COLUMNS][50];
2643   char *texts[TESTGTK_CLIST_COLUMNS];
2644
2645   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
2646     {
2647       texts[i] = text[i];
2648       sprintf (text[i], "Column %d", i);
2649     }
2650
2651   sprintf (text[1], "Right");
2652   sprintf (text[2], "Center");
2653
2654   gtk_clist_freeze (GTK_CLIST (data));
2655   for (i = 0; i < 10000; i++)
2656     {
2657       sprintf (text[0], "Row %d", clist_rows++);
2658       gtk_clist_append (GTK_CLIST (data), texts);
2659     }
2660   gtk_clist_thaw (GTK_CLIST (data));
2661
2662 }
2663
2664 void
2665 clear_clist (GtkWidget *widget, gpointer data)
2666 {
2667   gtk_clist_clear (GTK_CLIST (data));
2668   clist_rows = 0;
2669 }
2670
2671 void
2672 remove_row_clist (GtkWidget *widget, gpointer data)
2673 {
2674   gtk_clist_remove (GTK_CLIST (data), clist_selected_row);
2675   clist_rows--;
2676 }
2677
2678 void
2679 show_titles_clist (GtkWidget *widget, gpointer data)
2680 {
2681   gtk_clist_column_titles_show (GTK_CLIST (data));
2682 }
2683
2684 void
2685 hide_titles_clist (GtkWidget *widget, gpointer data)
2686 {
2687   gtk_clist_column_titles_hide (GTK_CLIST (data));
2688 }
2689
2690 void
2691 select_clist (GtkWidget *widget,
2692               gint row,
2693               gint column,
2694               GdkEventButton * bevent)
2695 {
2696   gint i;
2697   guint8 spacing;
2698   gchar *text;
2699   GdkPixmap *pixmap;
2700   GdkBitmap *mask;
2701   GList *list;
2702
2703   g_print ("GtkCList Selection: row %d column %d button %d\n",
2704            row, column, bevent ? bevent->button : 0);
2705
2706   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
2707     {
2708       switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i))
2709         {
2710         case GTK_CELL_TEXT:
2711           g_print ("CELL %d GTK_CELL_TEXT\n", i);
2712           gtk_clist_get_text (GTK_CLIST (widget), row, i, &text);
2713           g_print ("TEXT: %s\n", text);
2714           break;
2715
2716         case GTK_CELL_PIXMAP:
2717           g_print ("CELL %d GTK_CELL_PIXMAP\n", i);
2718           gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask);
2719           g_print ("PIXMAP: %d\n", (int) pixmap);
2720           g_print ("MASK: %d\n", (int) mask);
2721           break;
2722
2723         case GTK_CELL_PIXTEXT:
2724           g_print ("CELL %d GTK_CELL_PIXTEXT\n", i);
2725           gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask);
2726           g_print ("TEXT: %s\n", text);
2727           g_print ("SPACING: %d\n", spacing);
2728           g_print ("PIXMAP: %d\n", (int) pixmap);
2729           g_print ("MASK: %d\n", (int) mask);
2730           break;
2731
2732         default:
2733           break;
2734         }
2735     }
2736
2737   /* print selections list */
2738   g_print ("\nSelected Rows:");
2739   list = GTK_CLIST (widget)->selection;
2740   while (list)
2741     {
2742       g_print (" %d ", (gint) list->data);
2743       list = list->next;
2744     }
2745
2746   g_print ("\n\n\n");
2747
2748   clist_selected_row = row;
2749 }
2750
2751 void
2752 unselect_clist (GtkWidget *widget,
2753                 gint row,
2754                 gint column,
2755                 GdkEventButton * bevent)
2756 {
2757   gint i;
2758   guint8 spacing;
2759   gchar *text;
2760   GdkPixmap *pixmap;
2761   GdkBitmap *mask;
2762   GList *list;
2763
2764   g_print ("GtkCList Unselection: row %d column %d button %d\n",
2765            row, column, bevent ? bevent->button : 0);
2766
2767   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
2768     {
2769       switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i))
2770         {
2771         case GTK_CELL_TEXT:
2772           g_print ("CELL %d GTK_CELL_TEXT\n", i);
2773           gtk_clist_get_text (GTK_CLIST (widget), row, i, &text);
2774           g_print ("TEXT: %s\n", text);
2775           break;
2776
2777         case GTK_CELL_PIXMAP:
2778           g_print ("CELL %d GTK_CELL_PIXMAP\n", i);
2779           gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask);
2780           g_print ("PIXMAP: %d\n", (int) pixmap);
2781           g_print ("MASK: %d\n", (int) mask);
2782           break;
2783
2784         case GTK_CELL_PIXTEXT:
2785           g_print ("CELL %d GTK_CELL_PIXTEXT\n", i);
2786           gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask);
2787           g_print ("TEXT: %s\n", text);
2788           g_print ("SPACING: %d\n", spacing);
2789           g_print ("PIXMAP: %d\n", (int) pixmap);
2790           g_print ("MASK: %d\n", (int) mask);
2791           break;
2792
2793         default:
2794           break;
2795         }
2796     }
2797
2798   /* print selections list */
2799   g_print ("\nSelected Rows:");
2800   list = GTK_CLIST (widget)->selection;
2801   while (list)
2802     {
2803       g_print (" %d ", (gint) list->data);
2804       list = list->next;
2805     }
2806
2807   g_print ("\n\n\n");
2808
2809   clist_selected_row = row;
2810 }
2811
2812 void
2813 insert_row_clist (GtkWidget *widget, gpointer data)
2814 {
2815   static char *text[] =
2816   {
2817     "This",
2818     "is",
2819     "a",
2820     "inserted",
2821     "row",
2822     "la la la la la",
2823     "la la la la"
2824   };
2825
2826   gtk_clist_insert (GTK_CLIST (data), clist_selected_row, text);
2827   clist_rows++;
2828 }
2829
2830 void
2831 create_clist ()
2832 {
2833   gint i;
2834   static GtkWidget *window = NULL;
2835
2836   static char *titles[] =
2837   {
2838     "Title 0",
2839     "Title 1",
2840     "Title 2",
2841     "Title 3",
2842     "Title 4",
2843     "Title 5",
2844     "Title 6"
2845   };
2846
2847   char text[TESTGTK_CLIST_COLUMNS][50];
2848   char *texts[TESTGTK_CLIST_COLUMNS];
2849
2850   GtkWidget *box1;
2851   GtkWidget *box2;
2852   GtkWidget *clist;
2853   GtkWidget *button;
2854   GtkWidget *separator;
2855
2856
2857   if (!window)
2858     {
2859       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2860
2861       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2862                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2863                           &window);
2864
2865       gtk_window_set_title (GTK_WINDOW (window), "clist");
2866       gtk_container_border_width (GTK_CONTAINER (window), 0);
2867
2868
2869       box1 = gtk_vbox_new (FALSE, 0);
2870       gtk_container_add (GTK_CONTAINER (window), box1);
2871       gtk_widget_show (box1);
2872
2873
2874       box2 = gtk_hbox_new (FALSE, 10);
2875       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2876       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
2877       gtk_widget_show (box2);
2878
2879       /* create GtkCList here so we have a pointer to throw at the
2880        * button callbacks -- more is done with it later */
2881       clist = gtk_clist_new_with_titles (TESTGTK_CLIST_COLUMNS, titles);
2882       /*clist = gtk_clist_new (TESTGTK_CLIST_COLUMNS);*/
2883
2884       /* control buttons */
2885       button = gtk_button_new_with_label ("Add 1,000 Rows With Pixmaps");
2886       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2887
2888       gtk_signal_connect (GTK_OBJECT (button),
2889                           "clicked",
2890                           (GtkSignalFunc) add1000_clist,
2891                           (gpointer) clist);
2892
2893       gtk_widget_show (button);
2894
2895
2896       button = gtk_button_new_with_label ("Add 10,000 Rows");
2897       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2898
2899       gtk_signal_connect (GTK_OBJECT (button),
2900                           "clicked",
2901                           (GtkSignalFunc) add10000_clist,
2902                           (gpointer) clist);
2903
2904       gtk_widget_show (button);
2905
2906       button = gtk_button_new_with_label ("Clear List");
2907       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2908
2909       gtk_signal_connect (GTK_OBJECT (button),
2910                           "clicked",
2911                           (GtkSignalFunc) clear_clist,
2912                           (gpointer) clist);
2913
2914       gtk_widget_show (button);
2915
2916       button = gtk_button_new_with_label ("Remove Row");
2917       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2918
2919       gtk_signal_connect (GTK_OBJECT (button),
2920                           "clicked",
2921                           (GtkSignalFunc) remove_row_clist,
2922                           (gpointer) clist);
2923
2924       gtk_widget_show (button);
2925
2926       /* second layer of buttons */
2927       box2 = gtk_hbox_new (FALSE, 10);
2928       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2929       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
2930       gtk_widget_show (box2);
2931
2932       button = gtk_button_new_with_label ("Insert Row");
2933       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2934
2935       gtk_signal_connect (GTK_OBJECT (button),
2936                           "clicked",
2937                           (GtkSignalFunc) insert_row_clist,
2938                           (gpointer) clist);
2939
2940       gtk_widget_show (button);
2941
2942       button = gtk_button_new_with_label ("Show Title Buttons");
2943       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2944
2945       gtk_signal_connect (GTK_OBJECT (button),
2946                           "clicked",
2947                           (GtkSignalFunc) show_titles_clist,
2948                           (gpointer) clist);
2949
2950       gtk_widget_show (button);
2951
2952       button = gtk_button_new_with_label ("Hide Title Buttons");
2953       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2954
2955       gtk_signal_connect (GTK_OBJECT (button),
2956                           "clicked",
2957                           (GtkSignalFunc) hide_titles_clist,
2958                           (gpointer) clist);
2959
2960       gtk_widget_show (button);
2961
2962       /* vbox for the list itself */
2963       box2 = gtk_vbox_new (FALSE, 10);
2964       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2965       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2966       gtk_widget_show (box2);
2967
2968       /*
2969        * the rest of the clist configuration
2970        */
2971       gtk_clist_set_row_height (GTK_CLIST (clist), 20);
2972
2973       gtk_signal_connect (GTK_OBJECT (clist),
2974                           "select_row",
2975                           (GtkSignalFunc) select_clist,
2976                           NULL);
2977
2978       gtk_signal_connect (GTK_OBJECT (clist),
2979                           "unselect_row",
2980                           (GtkSignalFunc) unselect_clist,
2981                           NULL);
2982
2983       gtk_clist_set_column_width (GTK_CLIST (clist), 0, 100);
2984
2985       for (i = 1; i < TESTGTK_CLIST_COLUMNS; i++)
2986         gtk_clist_set_column_width (GTK_CLIST (clist), i, 80);
2987
2988       gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_BROWSE);
2989       gtk_clist_set_policy (GTK_CLIST (clist),
2990                             GTK_POLICY_AUTOMATIC,
2991                             GTK_POLICY_AUTOMATIC);
2992
2993       gtk_clist_set_policy (GTK_CLIST (clist), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2994
2995       gtk_clist_set_column_justification (GTK_CLIST (clist), 1, GTK_JUSTIFY_RIGHT);
2996       gtk_clist_set_column_justification (GTK_CLIST (clist), 2, GTK_JUSTIFY_CENTER);
2997
2998       for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
2999         {
3000           texts[i] = text[i];
3001           sprintf (text[i], "Column %d", i);
3002         }
3003
3004       sprintf (text[1], "Right");
3005       sprintf (text[2], "Center");
3006
3007       for (i = 0; i < 100; i++)
3008         {
3009           sprintf (text[0], "Row %d", clist_rows++);
3010           gtk_clist_append (GTK_CLIST (clist), texts);
3011         }
3012
3013       gtk_container_border_width (GTK_CONTAINER (clist), 5);
3014       gtk_box_pack_start (GTK_BOX (box2), clist, TRUE, TRUE, 0);
3015       gtk_widget_show (clist);
3016
3017
3018       separator = gtk_hseparator_new ();
3019       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3020       gtk_widget_show (separator);
3021
3022       box2 = gtk_vbox_new (FALSE, 10);
3023       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3024       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3025       gtk_widget_show (box2);
3026
3027       button = gtk_button_new_with_label ("close");
3028       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3029                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
3030                                  GTK_OBJECT (window));
3031
3032       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3033       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3034       gtk_widget_grab_default (button);
3035
3036       gtk_widget_show (button);
3037     }
3038
3039   if (!GTK_WIDGET_VISIBLE (window))
3040     gtk_widget_show (window);
3041   else
3042     {
3043       clist_rows = 0;
3044       gtk_widget_destroy (window);
3045     }
3046
3047 }
3048
3049 /*
3050  * GtkColorSelect
3051  */
3052 void
3053 color_selection_ok (GtkWidget               *w,
3054                     GtkColorSelectionDialog *cs)
3055 {
3056   GtkColorSelection *colorsel;
3057   gdouble color[4];
3058
3059   colorsel=GTK_COLOR_SELECTION(cs->colorsel);
3060
3061   gtk_color_selection_get_color(colorsel,color);
3062   gtk_color_selection_set_color(colorsel,color);
3063 }
3064
3065 void
3066 color_selection_changed (GtkWidget *w,
3067                          GtkColorSelectionDialog *cs)
3068 {
3069   GtkColorSelection *colorsel;
3070   gdouble color[4];
3071
3072   colorsel=GTK_COLOR_SELECTION(cs->colorsel);
3073   gtk_color_selection_get_color(colorsel,color);
3074 }
3075
3076 void
3077 create_color_selection ()
3078 {
3079   static GtkWidget *window = NULL;
3080
3081   if (!window)
3082     {
3083       gtk_preview_set_install_cmap (TRUE);
3084       gtk_widget_push_visual (gtk_preview_get_visual ());
3085       gtk_widget_push_colormap (gtk_preview_get_cmap ());
3086
3087       window = gtk_color_selection_dialog_new ("color selection dialog");
3088
3089       gtk_color_selection_set_opacity (
3090         GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
3091         TRUE);
3092
3093       gtk_color_selection_set_update_policy(
3094         GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
3095         GTK_UPDATE_CONTINUOUS);
3096
3097       gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
3098
3099       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3100                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3101                           &window);
3102
3103       gtk_signal_connect (
3104         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
3105         "color_changed",
3106         GTK_SIGNAL_FUNC(color_selection_changed),
3107         window);
3108
3109       gtk_signal_connect (
3110         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->ok_button),
3111         "clicked",
3112         GTK_SIGNAL_FUNC(color_selection_ok),
3113         window);
3114
3115       gtk_signal_connect_object (
3116         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->cancel_button),
3117         "clicked",
3118         GTK_SIGNAL_FUNC(gtk_widget_destroy),
3119         GTK_OBJECT (window));
3120
3121       gtk_widget_pop_colormap ();
3122       gtk_widget_pop_visual ();
3123     }
3124
3125   if (!GTK_WIDGET_VISIBLE (window))
3126     gtk_widget_show (window);
3127   else
3128     gtk_widget_destroy (window);
3129 }
3130
3131 void
3132 file_selection_hide_fileops (GtkWidget *widget,
3133                              GtkFileSelection *fs)
3134 {
3135   gtk_file_selection_hide_fileop_buttons (fs);
3136 }
3137
3138 void
3139 file_selection_ok (GtkWidget        *w,
3140                    GtkFileSelection *fs)
3141 {
3142   g_print ("%s\n", gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs)));
3143   gtk_widget_destroy (GTK_WIDGET (fs));
3144 }
3145
3146 void
3147 create_file_selection ()
3148 {
3149   static GtkWidget *window = NULL;
3150   GtkWidget *button;
3151
3152   if (!window)
3153     {
3154       window = gtk_file_selection_new ("file selection dialog");
3155
3156       gtk_file_selection_hide_fileop_buttons (GTK_FILE_SELECTION (window));
3157
3158       gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
3159
3160       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3161                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3162                           &window);
3163
3164       gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (window)->ok_button),
3165                           "clicked", GTK_SIGNAL_FUNC(file_selection_ok),
3166                           window);
3167       gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (window)->cancel_button),
3168                                  "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
3169                                  GTK_OBJECT (window));
3170
3171       button = gtk_button_new_with_label ("Hide Fileops");
3172       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3173                           (GtkSignalFunc) file_selection_hide_fileops,
3174                           (gpointer) window);
3175       gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
3176                           button, FALSE, FALSE, 0);
3177       gtk_widget_show (button);
3178
3179       button = gtk_button_new_with_label ("Show Fileops");
3180       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3181                                  (GtkSignalFunc) gtk_file_selection_show_fileop_buttons,
3182                                  (gpointer) window);
3183       gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
3184                           button, FALSE, FALSE, 0);
3185       gtk_widget_show (button);
3186
3187
3188
3189     }
3190
3191   if (!GTK_WIDGET_VISIBLE (window))
3192     gtk_widget_show (window);
3193   else
3194     gtk_widget_destroy (window);
3195 }
3196
3197
3198 /*
3199  * GtkDialog
3200  */
3201 static GtkWidget *dialog_window = NULL;
3202
3203 void
3204 label_toggle (GtkWidget  *widget,
3205               GtkWidget **label)
3206 {
3207   if (!(*label))
3208     {
3209       *label = gtk_label_new ("Dialog Test");
3210       gtk_signal_connect (GTK_OBJECT (*label),
3211                           "destroy",
3212                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
3213                           label);
3214       gtk_misc_set_padding (GTK_MISC (*label), 10, 10);
3215       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
3216                           *label, TRUE, TRUE, 0);
3217       gtk_widget_show (*label);
3218     }
3219   else
3220     gtk_widget_destroy (*label);
3221 }
3222
3223 void
3224 create_dialog ()
3225 {
3226   static GtkWidget *label;
3227   GtkWidget *button;
3228
3229   if (!dialog_window)
3230     {
3231       dialog_window = gtk_dialog_new ();
3232
3233       gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
3234                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3235                           &dialog_window);
3236
3237       gtk_window_set_title (GTK_WINDOW (dialog_window), "dialog");
3238       gtk_container_border_width (GTK_CONTAINER (dialog_window), 0);
3239
3240       button = gtk_button_new_with_label ("OK");
3241       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3242       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
3243                           button, TRUE, TRUE, 0);
3244       gtk_widget_grab_default (button);
3245       gtk_widget_show (button);
3246
3247       button = gtk_button_new_with_label ("Toggle");
3248       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3249                           GTK_SIGNAL_FUNC (label_toggle),
3250                           &label);
3251       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3252       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
3253                           button, TRUE, TRUE, 0);
3254       gtk_widget_show (button);
3255
3256       label = NULL;
3257     }
3258
3259   if (!GTK_WIDGET_VISIBLE (dialog_window))
3260     gtk_widget_show (dialog_window);
3261   else
3262     gtk_widget_destroy (dialog_window);
3263 }
3264
3265
3266 /*
3267  * GtkRange
3268  */
3269 void
3270 create_range_controls ()
3271 {
3272   static GtkWidget *window = NULL;
3273   GtkWidget *box1;
3274   GtkWidget *box2;
3275   GtkWidget *button;
3276   GtkWidget *scrollbar;
3277   GtkWidget *scale;
3278   GtkWidget *separator;
3279   GtkObject *adjustment;
3280
3281   if (!window)
3282     {
3283       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3284
3285       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3286                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3287                           &window);
3288
3289       gtk_window_set_title (GTK_WINDOW (window), "range controls");
3290       gtk_container_border_width (GTK_CONTAINER (window), 0);
3291
3292
3293       box1 = gtk_vbox_new (FALSE, 0);
3294       gtk_container_add (GTK_CONTAINER (window), box1);
3295       gtk_widget_show (box1);
3296
3297
3298       box2 = gtk_vbox_new (FALSE, 10);
3299       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3300       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3301       gtk_widget_show (box2);
3302
3303
3304       adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
3305
3306       scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
3307       gtk_widget_set_usize (GTK_WIDGET (scale), 150, 30);
3308       gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
3309       gtk_scale_set_digits (GTK_SCALE (scale), 1);
3310       gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
3311       gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
3312       gtk_widget_show (scale);
3313
3314       scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adjustment));
3315       gtk_range_set_update_policy (GTK_RANGE (scrollbar),
3316                                    GTK_UPDATE_CONTINUOUS);
3317       gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0);
3318       gtk_widget_show (scrollbar);
3319
3320
3321       separator = gtk_hseparator_new ();
3322       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3323       gtk_widget_show (separator);
3324
3325
3326       box2 = gtk_vbox_new (FALSE, 10);
3327       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3328       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3329       gtk_widget_show (box2);
3330
3331
3332       button = gtk_button_new_with_label ("close");
3333       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3334                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
3335                                  GTK_OBJECT (window));
3336       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3337       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3338       gtk_widget_grab_default (button);
3339       gtk_widget_show (button);
3340     }
3341
3342   if (!GTK_WIDGET_VISIBLE (window))
3343     gtk_widget_show (window);
3344   else
3345     gtk_widget_destroy (window);
3346 }
3347
3348
3349 /*
3350  * GtkRulers
3351  */
3352 void
3353 create_rulers ()
3354 {
3355   static GtkWidget *window = NULL;
3356   GtkWidget *table;
3357   GtkWidget *ruler;
3358
3359   if (!window)
3360     {
3361       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3362
3363       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3364                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3365                           &window);
3366
3367       gtk_window_set_title (GTK_WINDOW (window), "rulers");
3368       gtk_widget_set_usize (window, 300, 300);
3369       gtk_widget_set_events (window,
3370                              GDK_POINTER_MOTION_MASK
3371                              | GDK_POINTER_MOTION_HINT_MASK);
3372       gtk_container_border_width (GTK_CONTAINER (window), 0);
3373
3374       table = gtk_table_new (2, 2, FALSE);
3375       gtk_container_add (GTK_CONTAINER (window), table);
3376       gtk_widget_show (table);
3377
3378       ruler = gtk_hruler_new ();
3379       gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
3380
3381       gtk_signal_connect_object (
3382         GTK_OBJECT (window),
3383         "motion_notify_event",
3384         GTK_SIGNAL_FUNC(
3385           GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
3386         GTK_OBJECT (ruler));
3387
3388       gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
3389                         GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
3390       gtk_widget_show (ruler);
3391
3392
3393       ruler = gtk_vruler_new ();
3394       gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
3395
3396       gtk_signal_connect_object (
3397         GTK_OBJECT (window),
3398         "motion_notify_event",
3399         GTK_SIGNAL_FUNC (GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
3400         GTK_OBJECT (ruler));
3401
3402       gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
3403                         GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
3404       gtk_widget_show (ruler);
3405     }
3406
3407   if (!GTK_WIDGET_VISIBLE (window))
3408     gtk_widget_show (window);
3409   else
3410     gtk_widget_destroy (window);
3411 }
3412
3413
3414 static void
3415 text_toggle_editable (GtkWidget *checkbutton,
3416                        GtkWidget *text)
3417 {
3418    gtk_text_set_editable(GTK_TEXT(text),
3419                           GTK_TOGGLE_BUTTON(checkbutton)->active);
3420 }
3421
3422 /*
3423  * GtkText
3424  */
3425 void
3426 create_text ()
3427 {
3428   static GtkWidget *window = NULL;
3429   GtkWidget *box1;
3430   GtkWidget *box2;
3431   GtkWidget *button;
3432   GtkWidget *editable_check;
3433   GtkWidget *separator;
3434   GtkWidget *table;
3435   GtkWidget *hscrollbar;
3436   GtkWidget *vscrollbar;
3437   GtkWidget *text;
3438
3439   FILE *infile;
3440
3441   if (!window)
3442     {
3443       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3444       gtk_widget_set_name (window, "text window");
3445       gtk_widget_set_usize (window, 500, 500);
3446       gtk_window_set_policy (GTK_WINDOW(window), TRUE, TRUE, FALSE);
3447
3448       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3449                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3450                           &window);
3451
3452       gtk_window_set_title (GTK_WINDOW (window), "test");
3453       gtk_container_border_width (GTK_CONTAINER (window), 0);
3454
3455
3456       box1 = gtk_vbox_new (FALSE, 0);
3457       gtk_container_add (GTK_CONTAINER (window), box1);
3458       gtk_widget_show (box1);
3459
3460
3461       box2 = gtk_vbox_new (FALSE, 10);
3462       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3463       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3464       gtk_widget_show (box2);
3465
3466
3467       table = gtk_table_new (2, 2, FALSE);
3468       gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2);
3469       gtk_table_set_col_spacing (GTK_TABLE (table), 0, 2);
3470       gtk_box_pack_start (GTK_BOX (box2), table, TRUE, TRUE, 0);
3471       gtk_widget_show (table);
3472
3473       text = gtk_text_new (NULL, NULL);
3474       gtk_text_set_editable (GTK_TEXT (text), TRUE);
3475       gtk_table_attach (GTK_TABLE (table), text, 0, 1, 0, 1,
3476                         GTK_EXPAND | GTK_SHRINK | GTK_FILL,
3477                         GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
3478       gtk_widget_show (text);
3479
3480       hscrollbar = gtk_hscrollbar_new (GTK_TEXT (text)->hadj);
3481       gtk_table_attach (GTK_TABLE (table), hscrollbar, 0, 1, 1, 2,
3482                         GTK_EXPAND | GTK_FILL | GTK_SHRINK, GTK_FILL, 0, 0);
3483       gtk_widget_show (hscrollbar);
3484
3485       vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
3486       gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 0, 1,
3487                         GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
3488       gtk_widget_show (vscrollbar);
3489
3490       gtk_text_freeze (GTK_TEXT (text));
3491
3492       gtk_widget_realize (text);
3493
3494       infile = fopen("testgtk.c", "r");
3495
3496       if (infile)
3497         {
3498           char buffer[1024];
3499           int nchars;
3500
3501           while (1)
3502             {
3503               nchars = fread(buffer, 1, 1024, infile);
3504               gtk_text_insert (GTK_TEXT (text), NULL, NULL,
3505                                NULL, buffer, nchars);
3506
3507               if (nchars < 1024)
3508                 break;
3509             }
3510
3511           fclose (infile);
3512         }
3513
3514       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
3515                        "And even ", -1);
3516       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->bg[GTK_STATE_NORMAL], NULL,
3517                        "colored", -1);
3518       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
3519                        "text", -1);
3520
3521       gtk_text_thaw (GTK_TEXT (text));
3522
3523       editable_check = gtk_check_button_new_with_label("Editable");
3524       gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
3525       gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
3526                           GTK_SIGNAL_FUNC(text_toggle_editable), text);
3527       gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE);
3528       gtk_widget_show (editable_check);
3529
3530       separator = gtk_hseparator_new ();
3531       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3532       gtk_widget_show (separator);
3533
3534
3535       box2 = gtk_vbox_new (FALSE, 10);
3536       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3537       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3538       gtk_widget_show (box2);
3539
3540
3541       button = gtk_button_new_with_label ("close");
3542       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3543                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
3544                                  GTK_OBJECT (window));
3545       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3546       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3547       gtk_widget_grab_default (button);
3548       gtk_widget_show (button);
3549     }
3550
3551   if (!GTK_WIDGET_VISIBLE (window))
3552     gtk_widget_show (window);
3553   else
3554     gtk_widget_destroy (window);
3555 }
3556
3557
3558 /*
3559  * GtkNotebook
3560  */
3561
3562 GdkPixmap *book_open;
3563 GdkPixmap *book_closed;
3564 GdkBitmap *book_open_mask;
3565 GdkBitmap *book_closed_mask;
3566
3567 static char * book_open_xpm[] = {
3568 "16 16 4 1",
3569 "       c None s None",
3570 ".      c black",
3571 "X      c #808080",
3572 "o      c white",
3573 "                ",
3574 "  ..            ",
3575 " .Xo.    ...    ",
3576 " .Xoo. ..oo.    ",
3577 " .Xooo.Xooo...  ",
3578 " .Xooo.oooo.X.  ",
3579 " .Xooo.Xooo.X.  ",
3580 " .Xooo.oooo.X.  ",
3581 " .Xooo.Xooo.X.  ",
3582 " .Xooo.oooo.X.  ",
3583 "  .Xoo.Xoo..X.  ",
3584 "   .Xo.o..ooX.  ",
3585 "    .X..XXXXX.  ",
3586 "    ..X.......  ",
3587 "     ..         ",
3588 "                "};
3589
3590 static char * book_closed_xpm[] = {
3591 "16 16 6 1",
3592 "       c None s None",
3593 ".      c black",
3594 "X      c red",
3595 "o      c yellow",
3596 "O      c #808080",
3597 "#      c white",
3598 "                ",
3599 "       ..       ",
3600 "     ..XX.      ",
3601 "   ..XXXXX.     ",
3602 " ..XXXXXXXX.    ",
3603 ".ooXXXXXXXXX.   ",
3604 "..ooXXXXXXXXX.  ",
3605 ".X.ooXXXXXXXXX. ",
3606 ".XX.ooXXXXXX..  ",
3607 " .XX.ooXXX..#O  ",
3608 "  .XX.oo..##OO. ",
3609 "   .XX..##OO..  ",
3610 "    .X.#OO..    ",
3611 "     ..O..      ",
3612 "      ..        ",
3613 "                "};
3614
3615 static void
3616 page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num)
3617 {
3618   GtkNotebookPage *oldpage;
3619   GtkWidget *pixwid;
3620
3621   oldpage = GTK_NOTEBOOK (widget)->cur_page;
3622
3623   if (page == oldpage)
3624     return;
3625
3626   pixwid = ((GtkBoxChild*)(GTK_BOX (page->tab_label)->children->data))->widget;
3627   gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
3628   pixwid = ((GtkBoxChild*) (GTK_BOX (page->menu_label)->children->data))->widget;
3629   gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
3630
3631   if (oldpage)
3632     {
3633       pixwid = ((GtkBoxChild*) (GTK_BOX
3634                                 (oldpage->tab_label)->children->data))->widget;
3635       gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
3636       pixwid = ((GtkBoxChild*) (GTK_BOX (oldpage->menu_label)->children->data))->widget;
3637       gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
3638     }
3639 }
3640
3641 static void
3642 create_pages (GtkNotebook *notebook, gint start, gint end)
3643 {
3644   GtkWidget *child = NULL;
3645   GtkWidget *label;
3646   GtkWidget *entry;
3647   GtkWidget *box;
3648   GtkWidget *hbox;
3649   GtkWidget *label_box;
3650   GtkWidget *menu_box;
3651   GtkWidget *button;
3652   GtkWidget *pixwid;
3653   gint i;
3654   char buffer[32];
3655
3656   for (i = start; i <= end; i++)
3657     {
3658       sprintf (buffer, "Page %d", i);
3659
3660       switch (i%4)
3661         {
3662         case 3:
3663           child = gtk_button_new_with_label (buffer);
3664           gtk_container_border_width (GTK_CONTAINER(child), 10);
3665           break;
3666         case 2:
3667           child = gtk_label_new (buffer);
3668           break;
3669         case 1:
3670           child = gtk_frame_new (buffer);
3671           gtk_container_border_width (GTK_CONTAINER (child), 10);
3672
3673           box = gtk_vbox_new (TRUE,0);
3674           gtk_container_border_width (GTK_CONTAINER (box), 10);
3675           gtk_container_add (GTK_CONTAINER (child), box);
3676
3677           label = gtk_label_new (buffer);
3678           gtk_box_pack_start (GTK_BOX(box), label, TRUE, TRUE, 5);
3679
3680           entry = gtk_entry_new ();
3681           gtk_box_pack_start (GTK_BOX(box), entry, TRUE, TRUE, 5);
3682
3683           hbox = gtk_hbox_new (TRUE,0);
3684           gtk_box_pack_start (GTK_BOX(box), hbox, TRUE, TRUE, 5);
3685
3686           button = gtk_button_new_with_label ("Ok");
3687           gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
3688
3689           button = gtk_button_new_with_label ("Cancel");
3690           gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
3691           break;
3692         case 0:
3693           child = gtk_frame_new (buffer);
3694           gtk_container_border_width (GTK_CONTAINER (child), 10);
3695
3696           label = gtk_label_new (buffer);
3697           gtk_container_add (GTK_CONTAINER (child), label);
3698           break;
3699         }
3700
3701       gtk_widget_show_all (child);
3702
3703       label_box = gtk_hbox_new (FALSE, 0);
3704       pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
3705       gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
3706       gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
3707       label = gtk_label_new (buffer);
3708       gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
3709       gtk_widget_show_all (label_box);
3710
3711       menu_box = gtk_hbox_new (FALSE, 0);
3712       pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
3713       gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
3714       gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
3715       label = gtk_label_new (buffer);
3716       gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0);
3717       gtk_widget_show_all (menu_box);
3718
3719       gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
3720     }
3721 }
3722
3723 static void
3724 rotate_notebook (GtkButton   *button,
3725                  GtkNotebook *notebook)
3726 {
3727   gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos + 1) % 4);
3728 }
3729
3730 static void
3731 standard_notebook (GtkButton   *button,
3732                    GtkNotebook *notebook)
3733 {
3734   gint i;
3735
3736   gtk_notebook_set_show_tabs (notebook, TRUE);
3737   gtk_notebook_set_scrollable (notebook, FALSE);
3738   if (g_list_length (notebook->children) == 15)
3739     for (i = 0; i < 10; i++)
3740       gtk_notebook_remove_page (notebook, 5);
3741 }
3742
3743 static void
3744 notabs_notebook (GtkButton   *button,
3745                  GtkNotebook *notebook)
3746 {
3747   gint i;
3748
3749   gtk_notebook_set_show_tabs (notebook, FALSE);
3750   if (g_list_length (notebook->children) == 15)
3751     for (i = 0; i < 10; i++)
3752       gtk_notebook_remove_page (notebook, 5);
3753 }
3754
3755 static void
3756 scrollable_notebook (GtkButton   *button,
3757                      GtkNotebook *notebook)
3758 {
3759   gtk_notebook_set_show_tabs (notebook, TRUE);
3760   gtk_notebook_set_scrollable (notebook, TRUE);
3761   if (g_list_length (notebook->children) == 5)
3762     create_pages (notebook, 6, 15);
3763 }
3764
3765 static void
3766 notebook_popup (GtkToggleButton *button,
3767                 GtkNotebook     *notebook)
3768 {
3769   if (button->active)
3770     gtk_notebook_popup_enable (notebook);
3771   else
3772     gtk_notebook_popup_disable (notebook);
3773 }
3774
3775 static void
3776 create_notebook ()
3777 {
3778   static GtkWidget *window = NULL;
3779   GtkWidget *box1;
3780   GtkWidget *box2;
3781   GtkWidget *button;
3782   GtkWidget *separator;
3783   GtkWidget *notebook;
3784   GtkWidget *omenu;
3785   GtkWidget *menu;
3786   GtkWidget *submenu;
3787   GtkWidget *menuitem;
3788   GSList *group;
3789   GdkColor transparent;
3790
3791   if (!window)
3792     {
3793       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3794
3795       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3796                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3797                           &window);
3798
3799       gtk_window_set_title (GTK_WINDOW (window), "notebook");
3800       gtk_container_border_width (GTK_CONTAINER (window), 0);
3801
3802       box1 = gtk_vbox_new (FALSE, 0);
3803       gtk_container_add (GTK_CONTAINER (window), box1);
3804
3805       notebook = gtk_notebook_new ();
3806       gtk_signal_connect (GTK_OBJECT (notebook), "switch_page",
3807                           GTK_SIGNAL_FUNC (page_switch), NULL);
3808       gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
3809       gtk_box_pack_start (GTK_BOX (box1), notebook, TRUE, TRUE, 0);
3810       gtk_container_border_width (GTK_CONTAINER (notebook), 10);
3811
3812       gtk_widget_realize (notebook);
3813       book_open = gdk_pixmap_create_from_xpm_d (notebook->window,
3814                                                 &book_open_mask,
3815                                                 &transparent,
3816                                                 book_open_xpm);
3817       book_closed = gdk_pixmap_create_from_xpm_d (notebook->window,
3818                                                   &book_closed_mask,
3819                                                   &transparent,
3820                                                   book_closed_xpm);
3821
3822       create_pages (GTK_NOTEBOOK (notebook), 1, 5);
3823
3824       separator = gtk_hseparator_new ();
3825       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10);
3826
3827       box2 = gtk_hbox_new (TRUE, 5);
3828       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3829
3830       omenu = gtk_option_menu_new ();
3831       menu = gtk_menu_new ();
3832       submenu = NULL;
3833       group = NULL;
3834
3835       menuitem = gtk_radio_menu_item_new_with_label (group, "Standard");
3836       gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
3837                                  GTK_SIGNAL_FUNC (standard_notebook),
3838                                  GTK_OBJECT (notebook));
3839       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
3840       gtk_menu_append (GTK_MENU (menu), menuitem);
3841       gtk_widget_show (menuitem);
3842       menuitem = gtk_radio_menu_item_new_with_label (group, "w/o Tabs");
3843       gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
3844                                  GTK_SIGNAL_FUNC (notabs_notebook),
3845                                  GTK_OBJECT (notebook));
3846       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
3847       gtk_menu_append (GTK_MENU (menu), menuitem);
3848       gtk_widget_show (menuitem);
3849       menuitem = gtk_radio_menu_item_new_with_label (group, "Scrollable");
3850       gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
3851                                  GTK_SIGNAL_FUNC (scrollable_notebook),
3852                                  GTK_OBJECT (notebook));
3853       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
3854       gtk_menu_append (GTK_MENU (menu), menuitem);
3855       gtk_widget_show (menuitem);
3856
3857       gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
3858       gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, FALSE, 0);
3859       button = gtk_check_button_new_with_label ("enable popup menu");
3860       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
3861       gtk_signal_connect (GTK_OBJECT(button), "clicked",
3862                           GTK_SIGNAL_FUNC (notebook_popup),
3863                           GTK_OBJECT (notebook));
3864
3865       box2 = gtk_hbox_new (FALSE, 10);
3866       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3867       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3868
3869       button = gtk_button_new_with_label ("close");
3870       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3871                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
3872                                  GTK_OBJECT (window));
3873       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3874       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3875       gtk_widget_grab_default (button);
3876
3877       button = gtk_button_new_with_label ("next");
3878       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3879                                  GTK_SIGNAL_FUNC (gtk_notebook_next_page),
3880                                  GTK_OBJECT (notebook));
3881       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3882
3883       button = gtk_button_new_with_label ("prev");
3884       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3885                                  GTK_SIGNAL_FUNC (gtk_notebook_prev_page),
3886                                  GTK_OBJECT (notebook));
3887       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3888
3889       button = gtk_button_new_with_label ("rotate");
3890       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3891                           GTK_SIGNAL_FUNC (rotate_notebook),
3892                           notebook);
3893       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3894     }
3895
3896   if (!GTK_WIDGET_VISIBLE (window))
3897     gtk_widget_show_all (window);
3898   else
3899     gtk_widget_destroy (window);
3900 }
3901
3902
3903 /*
3904  * GtkPanes
3905  */
3906 void
3907 create_panes ()
3908 {
3909   static GtkWidget *window = NULL;
3910   GtkWidget *frame;
3911   GtkWidget *hpaned;
3912   GtkWidget *vpaned;
3913
3914   if (!window)
3915     {
3916       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3917
3918       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3919                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3920                           &window);
3921
3922       gtk_window_set_title (GTK_WINDOW (window), "Panes");
3923       gtk_container_border_width (GTK_CONTAINER (window), 0);
3924
3925       vpaned = gtk_vpaned_new ();
3926       gtk_container_add (GTK_CONTAINER (window), vpaned);
3927       gtk_container_border_width (GTK_CONTAINER(vpaned), 5);
3928       gtk_widget_show (vpaned);
3929
3930       hpaned = gtk_hpaned_new ();
3931       gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
3932
3933       frame = gtk_frame_new (NULL);
3934       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
3935       gtk_widget_set_usize (frame, 60, 60);
3936       gtk_paned_add1 (GTK_PANED (hpaned), frame);
3937       gtk_widget_show (frame);
3938
3939       frame = gtk_frame_new (NULL);
3940       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
3941       gtk_widget_set_usize (frame, 80, 60);
3942       gtk_paned_add2 (GTK_PANED (hpaned), frame);
3943       gtk_widget_show (frame);
3944
3945       gtk_widget_show (hpaned);
3946
3947       frame = gtk_frame_new (NULL);
3948       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
3949       gtk_widget_set_usize (frame, 60, 80);
3950       gtk_paned_add2 (GTK_PANED (vpaned), frame);
3951       gtk_widget_show (frame);
3952     }
3953
3954   if (!GTK_WIDGET_VISIBLE (window))
3955     gtk_widget_show (window);
3956   else
3957     gtk_widget_destroy (window);
3958 }
3959
3960
3961 /*
3962  * Drag -N- Drop
3963  */
3964
3965 gint
3966 dnd_drop_destroy_popup (GtkWidget *widget, GtkWindow **window)
3967 {
3968   if(GTK_IS_BUTTON(widget)) /* I.e. they clicked the close button */
3969     gtk_widget_destroy(GTK_WIDGET(*window));
3970   else {
3971     gtk_grab_remove(GTK_WIDGET(*window));
3972     *window = NULL;
3973   }
3974
3975   return FALSE;
3976 }
3977
3978 void
3979 dnd_drop (GtkWidget *button, GdkEvent *event)
3980 {
3981   static GtkWidget *window = NULL;
3982   GtkWidget *vbox, *lbl, *btn;
3983   gchar *msg;
3984
3985   window = gtk_window_new(GTK_WINDOW_DIALOG);
3986   gtk_container_border_width (GTK_CONTAINER(window), 10);
3987
3988   gtk_signal_connect (GTK_OBJECT (window), "destroy",
3989                       GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
3990                       &window);
3991   gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3992                       GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
3993                       &window);
3994
3995   vbox = gtk_vbox_new(FALSE, 5);
3996
3997   /* Display message that we got from drop source */
3998   msg = g_malloc(strlen(event->dropdataavailable.data)
3999                  + strlen(event->dropdataavailable.data_type) + 100);
4000   sprintf(msg, "Drop data of type %s was:\n\n%s",
4001           event->dropdataavailable.data_type,
4002           (char *)event->dropdataavailable.data);
4003   lbl = gtk_label_new(msg);
4004   gtk_label_set_justify(GTK_LABEL(lbl), GTK_JUSTIFY_FILL);
4005   g_free(msg);
4006   gtk_widget_show(lbl);
4007   gtk_box_pack_start_defaults(GTK_BOX(vbox), lbl);
4008
4009   /* Provide an obvious way out of this heinousness */
4010   btn = gtk_button_new_with_label("Continue with life in\nspite of this oppression");
4011   gtk_signal_connect (GTK_OBJECT (btn), "clicked",
4012                       GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
4013                       &window);
4014   gtk_widget_show(btn);
4015   gtk_box_pack_start_defaults(GTK_BOX(vbox), btn);
4016
4017   gtk_container_add(GTK_CONTAINER(window), vbox);
4018
4019   gtk_widget_show(vbox);
4020   gtk_grab_add(window);
4021   gtk_widget_show(window);
4022 }
4023
4024 void
4025 dnd_drag_request (GtkWidget *button, GdkEvent *event)
4026 {
4027 #define DND_STRING "Bill Gates demands royalties for\nyour use of his innovation."
4028   gtk_widget_dnd_data_set (button, event, DND_STRING, strlen(DND_STRING) + 1);
4029 }
4030
4031 void
4032 create_dnd ()
4033 {
4034   static GtkWidget *window = NULL;
4035   GtkWidget *box1;
4036   GtkWidget *box2;
4037   GtkWidget *box3;
4038   GtkWidget *frame;
4039   GtkWidget *button;
4040   GtkWidget *separator;
4041
4042   /* For clarity... */
4043   char *possible_drag_types[] = {"text/plain"};
4044   char *accepted_drop_types[] = {"text/plain"};
4045
4046   if(!modeller)
4047     create_shapes();
4048
4049   if (!window)
4050     {
4051       GdkPoint hotspot = {5,5};
4052
4053       gdk_dnd_set_drag_shape(modeller->window,
4054                              &hotspot,
4055                              rings->window,
4056                              &hotspot);
4057
4058       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4059
4060       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4061                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4062                           &window);
4063
4064       gtk_window_set_title (GTK_WINDOW (window), "Drag -N- Drop");
4065       gtk_container_border_width (GTK_CONTAINER (window), 0);
4066
4067       box1 = gtk_vbox_new (FALSE, 0);
4068       gtk_container_add (GTK_CONTAINER (window), box1);
4069       gtk_widget_show (box1);
4070
4071       box2 = gtk_hbox_new (FALSE, 5);
4072       gtk_container_border_width (GTK_CONTAINER (box2), 10);
4073       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
4074       gtk_widget_show (box2);
4075
4076       frame = gtk_frame_new ("Drag");
4077       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
4078       gtk_widget_show (frame);
4079
4080       box3 = gtk_vbox_new (FALSE, 5);
4081       gtk_container_border_width (GTK_CONTAINER (box3), 5);
4082       gtk_container_add (GTK_CONTAINER (frame), box3);
4083       gtk_widget_show (box3);
4084
4085       /*
4086        * FROM Button
4087        */
4088       button = gtk_button_new_with_label ("Drag me!");
4089       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
4090       gtk_widget_show (button);
4091
4092       /*
4093        * currently, the widget has to be realized to
4094        * set dnd on it, this needs to change
4095        */
4096       gtk_widget_realize (button);
4097       gtk_signal_connect (GTK_OBJECT (button),
4098                           "drag_request_event",
4099                           GTK_SIGNAL_FUNC(dnd_drag_request),
4100                           button);
4101
4102       gtk_widget_dnd_drag_set (button, TRUE, possible_drag_types, 1);
4103
4104
4105       frame = gtk_frame_new ("Drop");
4106       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
4107       gtk_widget_show (frame);
4108
4109       box3 = gtk_vbox_new (FALSE, 5);
4110       gtk_container_border_width (GTK_CONTAINER (box3), 5);
4111       gtk_container_add (GTK_CONTAINER (frame), box3);
4112       gtk_widget_show (box3);
4113
4114
4115       /*
4116        * TO Button
4117        */
4118       button = gtk_button_new_with_label ("To");
4119       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
4120       gtk_widget_show (button);
4121
4122       gtk_widget_realize (button);
4123       gtk_signal_connect (GTK_OBJECT (button),
4124                           "drop_data_available_event",
4125                           GTK_SIGNAL_FUNC(dnd_drop),
4126                           button);
4127
4128       gtk_widget_dnd_drop_set (button, TRUE, accepted_drop_types, 1, FALSE);
4129
4130
4131       separator = gtk_hseparator_new ();
4132       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4133       gtk_widget_show (separator);
4134
4135
4136       box2 = gtk_vbox_new (FALSE, 10);
4137       gtk_container_border_width (GTK_CONTAINER (box2), 10);
4138       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4139       gtk_widget_show (box2);
4140
4141
4142       button = gtk_button_new_with_label ("close");
4143
4144       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4145                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
4146                                  GTK_OBJECT (window));
4147
4148       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4149       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4150       gtk_widget_grab_default (button);
4151       gtk_widget_show (button);
4152     }
4153
4154   gtk_widget_hide(modeller); gtk_widget_hide(rings);
4155
4156   if (!GTK_WIDGET_VISIBLE (window))
4157     gtk_widget_show (window);
4158   else
4159     gtk_widget_destroy (window);
4160 }
4161
4162 /*
4163  * Shaped Windows
4164  */
4165 static GdkWindow *root_win = NULL;
4166
4167 typedef struct _cursoroffset {gint x,y;} CursorOffset;
4168
4169 static void
4170 shape_pressed (GtkWidget *widget, GdkEventButton *event)
4171 {
4172   CursorOffset *p;
4173
4174   /* ignore double and triple click */
4175   if (event->type != GDK_BUTTON_PRESS)
4176     return;
4177
4178   p = gtk_object_get_user_data (GTK_OBJECT(widget));
4179   p->x = (int) event->x;
4180   p->y = (int) event->y;
4181
4182   gtk_grab_add (widget);
4183   gdk_pointer_grab (widget->window, TRUE,
4184                     GDK_BUTTON_RELEASE_MASK |
4185                     GDK_BUTTON_MOTION_MASK |
4186                     GDK_POINTER_MOTION_HINT_MASK,
4187                     NULL, NULL, 0);
4188 }
4189
4190
4191 static void
4192 shape_released (GtkWidget *widget)
4193 {
4194   gtk_grab_remove (widget);
4195   gdk_pointer_ungrab (0);
4196 }
4197
4198 static void
4199 shape_motion (GtkWidget      *widget,
4200               GdkEventMotion *event)
4201 {
4202   gint xp, yp;
4203   CursorOffset * p;
4204   GdkModifierType mask;
4205
4206   p = gtk_object_get_user_data (GTK_OBJECT (widget));
4207
4208   /*
4209    * Can't use event->x / event->y here
4210    * because I need absolute coordinates.
4211    */
4212   gdk_window_get_pointer (root_win, &xp, &yp, &mask);
4213   gtk_widget_set_uposition (widget, xp  - p->x, yp  - p->y);
4214 }
4215
4216 GtkWidget *
4217 shape_create_icon (char     *xpm_file,
4218                    gint      x,
4219                    gint      y,
4220                    gint      px,
4221                    gint      py,
4222                    gint      window_type)
4223 {
4224   GtkWidget *window;
4225   GtkWidget *pixmap;
4226   GtkWidget *fixed;
4227   CursorOffset* icon_pos;
4228   GdkGC* gc;
4229   GdkBitmap *gdk_pixmap_mask;
4230   GdkPixmap *gdk_pixmap;
4231   GtkStyle *style;
4232
4233   style = gtk_widget_get_default_style ();
4234   gc = style->black_gc;
4235
4236   /*
4237    * GDK_WINDOW_TOPLEVEL works also, giving you a title border
4238    */
4239   window = gtk_window_new (window_type);
4240
4241   fixed = gtk_fixed_new ();
4242   gtk_widget_set_usize (fixed, 100,100);
4243   gtk_container_add (GTK_CONTAINER (window), fixed);
4244   gtk_widget_show (fixed);
4245
4246   gtk_widget_set_events (window,
4247                          gtk_widget_get_events (window) |
4248                          GDK_BUTTON_MOTION_MASK |
4249                          GDK_POINTER_MOTION_HINT_MASK |
4250                          GDK_BUTTON_PRESS_MASK);
4251
4252   gtk_widget_realize (window);
4253   gdk_pixmap = gdk_pixmap_create_from_xpm (window->window, &gdk_pixmap_mask,
4254                                            &style->bg[GTK_STATE_NORMAL],
4255                                            xpm_file);
4256
4257   pixmap = gtk_pixmap_new (gdk_pixmap, gdk_pixmap_mask);
4258   gtk_fixed_put (GTK_FIXED (fixed), pixmap, px,py);
4259   gtk_widget_show (pixmap);
4260
4261   gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px,py);
4262
4263
4264   gtk_signal_connect (GTK_OBJECT (window), "button_press_event",
4265                       GTK_SIGNAL_FUNC (shape_pressed),NULL);
4266   gtk_signal_connect (GTK_OBJECT (window), "button_release_event",
4267                       GTK_SIGNAL_FUNC (shape_released),NULL);
4268   gtk_signal_connect (GTK_OBJECT (window), "motion_notify_event",
4269                       GTK_SIGNAL_FUNC (shape_motion),NULL);
4270
4271   icon_pos = g_new (CursorOffset, 1);
4272   gtk_object_set_user_data(GTK_OBJECT(window), icon_pos);
4273
4274   gtk_widget_set_uposition (window, x, y);
4275   gtk_widget_show (window);
4276
4277   return window;
4278 }
4279
4280 void
4281 create_shapes ()
4282 {
4283   root_win = gdk_window_foreign_new (GDK_ROOT_WINDOW ());
4284
4285   if (!modeller)
4286     {
4287       modeller = shape_create_icon ("Modeller.xpm",
4288                                     440, 140, 0,0, GTK_WINDOW_POPUP);
4289
4290       gtk_signal_connect (GTK_OBJECT (modeller), "destroy",
4291                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4292                           &modeller);
4293     }
4294   else
4295     gtk_widget_destroy (modeller);
4296
4297   if (!sheets)
4298     {
4299       sheets = shape_create_icon ("FilesQueue.xpm",
4300                                   580, 170, 0,0, GTK_WINDOW_POPUP);
4301
4302       gtk_signal_connect (GTK_OBJECT (sheets), "destroy",
4303                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4304                           &sheets);
4305
4306     }
4307   else
4308     gtk_widget_destroy (sheets);
4309
4310   if (!rings)
4311     {
4312       rings = shape_create_icon ("3DRings.xpm",
4313                                  460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
4314
4315       gtk_signal_connect (GTK_OBJECT (rings), "destroy",
4316                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4317                           &rings);
4318     }
4319   else
4320     gtk_widget_destroy (rings);
4321 }
4322
4323 void
4324 create_wmhints ()
4325 {
4326   static GtkWidget *window = NULL;
4327   GtkWidget *label;
4328   GtkWidget *separator;
4329   GtkWidget *button;
4330   GtkWidget *box1;
4331   GtkWidget *box2;
4332
4333   GdkBitmap *circles;
4334
4335   if (!window)
4336     {
4337       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4338
4339       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4340                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4341                           &window);
4342
4343       gtk_window_set_title (GTK_WINDOW (window), "WM Hints");
4344       gtk_container_border_width (GTK_CONTAINER (window), 0);
4345
4346       gtk_widget_realize (window);
4347
4348       circles = gdk_bitmap_create_from_data (window->window,
4349                                              circles_bits,
4350                                              circles_width,
4351                                              circles_height);
4352       gdk_window_set_icon (window->window, NULL,
4353                            circles, circles);
4354
4355       gdk_window_set_icon_name (window->window, "WMHints Test Icon");
4356
4357       gdk_window_set_decorations (window->window, GDK_DECOR_ALL | GDK_DECOR_MENU);
4358       gdk_window_set_functions (window->window, GDK_FUNC_ALL | GDK_FUNC_RESIZE);
4359
4360       box1 = gtk_vbox_new (FALSE, 0);
4361       gtk_container_add (GTK_CONTAINER (window), box1);
4362       gtk_widget_show (box1);
4363
4364       label = gtk_label_new ("Try iconizing me!");
4365       gtk_widget_set_usize (label, 150, 50);
4366       gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
4367       gtk_widget_show (label);
4368
4369
4370       separator = gtk_hseparator_new ();
4371       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4372       gtk_widget_show (separator);
4373
4374
4375       box2 = gtk_vbox_new (FALSE, 10);
4376       gtk_container_border_width (GTK_CONTAINER (box2), 10);
4377       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4378       gtk_widget_show (box2);
4379
4380
4381       button = gtk_button_new_with_label ("close");
4382
4383       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4384                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
4385                                  GTK_OBJECT (window));
4386
4387       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4388       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4389       gtk_widget_grab_default (button);
4390       gtk_widget_show (button);
4391     }
4392
4393   if (!GTK_WIDGET_VISIBLE (window))
4394     gtk_widget_show (window);
4395   else
4396     gtk_widget_destroy (window);
4397 }
4398
4399 /*
4400  * Progress Bar
4401  */
4402 static int progress_timer = 0;
4403
4404 gint
4405 progress_timeout (gpointer data)
4406 {
4407   gfloat new_val;
4408
4409   new_val = GTK_PROGRESS_BAR (data)->percentage;
4410   if (new_val >= 1.0)
4411     new_val = 0.0;
4412   new_val += 0.02;
4413
4414   gtk_progress_bar_update (GTK_PROGRESS_BAR (data), new_val);
4415
4416   return TRUE;
4417 }
4418
4419 static void
4420 destroy_progress (GtkWidget  *widget,
4421                   GtkWidget **window)
4422 {
4423   gtk_timeout_remove (progress_timer);
4424   progress_timer = 0;
4425   *window = NULL;
4426 }
4427
4428 void
4429 create_progress_bar ()
4430 {
4431   static GtkWidget *window = NULL;
4432   GtkWidget *button;
4433   GtkWidget *vbox;
4434   GtkWidget *pbar;
4435   GtkWidget *label;
4436
4437   if (!window)
4438     {
4439       window = gtk_dialog_new ();
4440
4441       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4442                           GTK_SIGNAL_FUNC(destroy_progress),
4443                           &window);
4444
4445       gtk_window_set_title (GTK_WINDOW (window), "dialog");
4446       gtk_container_border_width (GTK_CONTAINER (window), 0);
4447
4448
4449       vbox = gtk_vbox_new (FALSE, 5);
4450       gtk_container_border_width (GTK_CONTAINER (vbox), 10);
4451       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
4452                           vbox, TRUE, TRUE, 0);
4453       gtk_widget_show (vbox);
4454
4455       label = gtk_label_new ("progress...");
4456       gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
4457       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
4458       gtk_widget_show (label);
4459
4460       pbar = gtk_progress_bar_new ();
4461       gtk_widget_set_usize (pbar, 200, 20);
4462       gtk_box_pack_start (GTK_BOX (vbox), pbar, TRUE, TRUE, 0);
4463       gtk_widget_show (pbar);
4464
4465       progress_timer = gtk_timeout_add (100, progress_timeout, pbar);
4466
4467       button = gtk_button_new_with_label ("close");
4468       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4469                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
4470                                  GTK_OBJECT (window));
4471       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4472       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
4473                           button, TRUE, TRUE, 0);
4474       gtk_widget_grab_default (button);
4475       gtk_widget_show (button);
4476     }
4477
4478   if (!GTK_WIDGET_VISIBLE (window))
4479     gtk_widget_show (window);
4480   else
4481     gtk_widget_destroy (window);
4482 }
4483
4484
4485 /*
4486  * Color Preview
4487  */
4488 static int color_idle = 0;
4489
4490 gint
4491 color_idle_func (GtkWidget *preview)
4492 {
4493   static int count = 1;
4494   guchar buf[768];
4495   int i, j, k;
4496
4497   for (i = 0; i < 256; i++)
4498     {
4499       for (j = 0, k = 0; j < 256; j++)
4500         {
4501           buf[k+0] = i + count;
4502           buf[k+1] = 0;
4503           buf[k+2] = j + count;
4504           k += 3;
4505         }
4506
4507       gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
4508     }
4509
4510   count += 1;
4511
4512   gtk_widget_draw (preview, NULL);
4513
4514   return TRUE;
4515 }
4516
4517 static void
4518 color_preview_destroy (GtkWidget  *widget,
4519                        GtkWidget **window)
4520 {
4521   gtk_idle_remove (color_idle);
4522   color_idle = 0;
4523
4524   *window = NULL;
4525 }
4526
4527 void
4528 create_color_preview ()
4529 {
4530   static GtkWidget *window = NULL;
4531   GtkWidget *preview;
4532   guchar buf[768];
4533   int i, j, k;
4534
4535   if (!window)
4536     {
4537       gtk_widget_push_visual (gtk_preview_get_visual ());
4538       gtk_widget_push_colormap (gtk_preview_get_cmap ());
4539
4540       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4541
4542       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4543                           GTK_SIGNAL_FUNC(color_preview_destroy),
4544                           &window);
4545
4546       gtk_window_set_title (GTK_WINDOW (window), "test");
4547       gtk_container_border_width (GTK_CONTAINER (window), 10);
4548
4549       preview = gtk_preview_new (GTK_PREVIEW_COLOR);
4550       gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
4551       gtk_container_add (GTK_CONTAINER (window), preview);
4552       gtk_widget_show (preview);
4553
4554       for (i = 0; i < 256; i++)
4555         {
4556           for (j = 0, k = 0; j < 256; j++)
4557             {
4558               buf[k+0] = i;
4559               buf[k+1] = 0;
4560               buf[k+2] = j;
4561               k += 3;
4562             }
4563
4564           gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
4565         }
4566
4567       color_idle = gtk_idle_add ((GtkFunction) color_idle_func, preview);
4568
4569       gtk_widget_pop_colormap ();
4570       gtk_widget_pop_visual ();
4571     }
4572
4573   if (!GTK_WIDGET_VISIBLE (window))
4574     gtk_widget_show (window);
4575   else
4576     gtk_widget_destroy (window);
4577 }
4578
4579
4580 /*
4581  * Gray Preview
4582  */
4583 static int gray_idle = 0;
4584
4585 gint
4586 gray_idle_func (GtkWidget *preview)
4587 {
4588   static int count = 1;
4589   guchar buf[256];
4590   int i, j;
4591
4592   for (i = 0; i < 256; i++)
4593     {
4594       for (j = 0; j < 256; j++)
4595         buf[j] = i + j + count;
4596
4597       gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
4598     }
4599
4600   count += 1;
4601
4602   gtk_widget_draw (preview, NULL);
4603
4604   return TRUE;
4605 }
4606
4607 static void
4608 gray_preview_destroy (GtkWidget  *widget,
4609                       GtkWidget **window)
4610 {
4611   gtk_idle_remove (gray_idle);
4612   gray_idle = 0;
4613
4614   *window = NULL;
4615 }
4616
4617 void
4618 create_gray_preview ()
4619 {
4620   static GtkWidget *window = NULL;
4621   GtkWidget *preview;
4622   guchar buf[256];
4623   int i, j;
4624
4625   if (!window)
4626     {
4627       gtk_widget_push_visual (gtk_preview_get_visual ());
4628       gtk_widget_push_colormap (gtk_preview_get_cmap ());
4629
4630       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4631
4632       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4633                           GTK_SIGNAL_FUNC(gray_preview_destroy),
4634                           &window);
4635
4636       gtk_window_set_title (GTK_WINDOW (window), "test");
4637       gtk_container_border_width (GTK_CONTAINER (window), 10);
4638
4639       preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
4640       gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
4641       gtk_container_add (GTK_CONTAINER (window), preview);
4642       gtk_widget_show (preview);
4643
4644       for (i = 0; i < 256; i++)
4645         {
4646           for (j = 0; j < 256; j++)
4647             buf[j] = i + j;
4648
4649           gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
4650         }
4651
4652       gray_idle = gtk_idle_add ((GtkFunction) gray_idle_func, preview);
4653
4654       gtk_widget_pop_colormap ();
4655       gtk_widget_pop_visual ();
4656     }
4657
4658   if (!GTK_WIDGET_VISIBLE (window))
4659     gtk_widget_show (window);
4660   else
4661     gtk_widget_destroy (window);
4662 }
4663
4664
4665 /*
4666  * Selection Test
4667  */
4668 void
4669 selection_test_received (GtkWidget *list, GtkSelectionData *data)
4670 {
4671   GdkAtom *atoms;
4672   GtkWidget *list_item;
4673   GList *item_list;
4674   int i, l;
4675
4676   if (data->length < 0)
4677     {
4678       g_print ("Selection retrieval failed\n");
4679       return;
4680     }
4681   if (data->type != GDK_SELECTION_TYPE_ATOM)
4682     {
4683       g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
4684       return;
4685     }
4686
4687   /* Clear out any current list items */
4688
4689   gtk_list_clear_items (GTK_LIST(list), 0, -1);
4690
4691   /* Add new items to list */
4692
4693   atoms = (GdkAtom *)data->data;
4694
4695   item_list = NULL;
4696   l = data->length / sizeof (GdkAtom);
4697   for (i = 0; i < l; i++)
4698     {
4699       char *name;
4700       name = gdk_atom_name (atoms[i]);
4701       if (name != NULL)
4702         {
4703           list_item = gtk_list_item_new_with_label (name);
4704           g_free (name);
4705         }
4706       else
4707         list_item = gtk_list_item_new_with_label ("(bad atom)");
4708
4709       gtk_widget_show (list_item);
4710       item_list = g_list_append (item_list, list_item);
4711     }
4712
4713   gtk_list_append_items (GTK_LIST (list), item_list);
4714
4715   return;
4716 }
4717
4718 void
4719 selection_test_get_targets (GtkWidget *widget, GtkWidget *list)
4720 {
4721   static GdkAtom targets_atom = GDK_NONE;
4722
4723   if (targets_atom == GDK_NONE)
4724     targets_atom = gdk_atom_intern ("TARGETS", FALSE);
4725
4726   gtk_selection_convert (list, GDK_SELECTION_PRIMARY, targets_atom,
4727                          GDK_CURRENT_TIME);
4728 }
4729
4730 void
4731 create_selection_test ()
4732 {
4733   static GtkWidget *window = NULL;
4734   GtkWidget *button;
4735   GtkWidget *vbox;
4736   GtkWidget *scrolled_win;
4737   GtkWidget *list;
4738   GtkWidget *label;
4739
4740   if (!window)
4741     {
4742       window = gtk_dialog_new ();
4743
4744       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4745                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4746                           &window);
4747
4748       gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
4749       gtk_container_border_width (GTK_CONTAINER (window), 0);
4750
4751       /* Create the list */
4752
4753       vbox = gtk_vbox_new (FALSE, 5);
4754       gtk_container_border_width (GTK_CONTAINER (vbox), 10);
4755       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox,
4756                           TRUE, TRUE, 0);
4757       gtk_widget_show (vbox);
4758
4759       label = gtk_label_new ("Gets available targets for current selection");
4760       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
4761       gtk_widget_show (label);
4762
4763       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
4764       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
4765                                       GTK_POLICY_AUTOMATIC,
4766                                       GTK_POLICY_AUTOMATIC);
4767       gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
4768       gtk_widget_set_usize (scrolled_win, 100, 200);
4769       gtk_widget_show (scrolled_win);
4770
4771       list = gtk_list_new ();
4772       gtk_container_add (GTK_CONTAINER (scrolled_win), list);
4773
4774       gtk_signal_connect (GTK_OBJECT(list), "selection_received",
4775                           GTK_SIGNAL_FUNC (selection_test_received), NULL);
4776       gtk_widget_show (list);
4777
4778       /* .. And create some buttons */
4779       button = gtk_button_new_with_label ("Get Targets");
4780       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
4781                           button, TRUE, TRUE, 0);
4782
4783       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4784                           GTK_SIGNAL_FUNC (selection_test_get_targets), list);
4785       gtk_widget_show (button);
4786
4787       button = gtk_button_new_with_label ("Quit");
4788       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
4789                           button, TRUE, TRUE, 0);
4790
4791       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4792                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
4793                                  GTK_OBJECT (window));
4794       gtk_widget_show (button);
4795     }
4796
4797   if (!GTK_WIDGET_VISIBLE (window))
4798     gtk_widget_show (window);
4799   else
4800     gtk_widget_destroy (window);
4801 }
4802
4803
4804 /*
4805  * Gamma Curve
4806  */
4807 void
4808 create_gamma_curve ()
4809 {
4810   static GtkWidget *window = NULL, *curve;
4811   static int count = 0;
4812   gfloat vec[256];
4813   gint max;
4814   gint i;
4815
4816   if (!window)
4817     {
4818       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4819       gtk_window_set_title (GTK_WINDOW (window), "test");
4820       gtk_container_border_width (GTK_CONTAINER (window), 10);
4821
4822       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4823                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4824                           &window);
4825
4826       curve = gtk_gamma_curve_new ();
4827       gtk_container_add (GTK_CONTAINER (window), curve);
4828       gtk_widget_show (curve);
4829     }
4830
4831   max = 127 + (count % 2)*128;
4832   gtk_curve_set_range (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
4833                        0, max, 0, max);
4834   for (i = 0; i < max; ++i)
4835     vec[i] = (127 / sqrt (max)) * sqrt (i);
4836   gtk_curve_set_vector (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
4837                         max, vec);
4838
4839   if (!GTK_WIDGET_VISIBLE (window))
4840     gtk_widget_show (window);
4841   else if (count % 4 == 3)
4842     {
4843       gtk_widget_destroy (window);
4844       window = NULL;
4845     }
4846
4847   ++count;
4848 }
4849
4850 static int scroll_test_pos = 0.0;
4851 static GdkGC *scroll_test_gc = NULL;
4852
4853 static gint
4854 scroll_test_expose (GtkWidget *widget, GdkEventExpose *event,
4855                     GtkAdjustment *adj)
4856 {
4857   gint i,j;
4858   gint imin, imax, jmin, jmax;
4859
4860   imin = (event->area.x) / 10;
4861   imax = (event->area.x + event->area.width + 9) / 10;
4862
4863   jmin = ((int)adj->value + event->area.y) / 10;
4864   jmax = ((int)adj->value + event->area.y + event->area.height + 9) / 10;
4865
4866   gdk_window_clear_area (widget->window,
4867                          event->area.x, event->area.y,
4868                          event->area.width, event->area.height);
4869
4870   for (i=imin; i<imax; i++)
4871     for (j=jmin; j<jmax; j++)
4872       if ((i+j) % 2)
4873         gdk_draw_rectangle (widget->window,
4874                             widget->style->black_gc,
4875                             TRUE,
4876                             10*i, 10*j - (int)adj->value, 1+i%10, 1+j%10);
4877
4878   return TRUE;
4879 }
4880
4881 static void
4882 scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
4883                        GtkAdjustment *adj)
4884 {
4885   adj->page_increment = 0.9 * widget->allocation.height;
4886   adj->page_size = widget->allocation.height;
4887
4888   gtk_signal_emit_by_name (GTK_OBJECT (adj), "changed");
4889 }
4890
4891 static void
4892 scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
4893 {
4894   gint source_min = (int)adj->value - scroll_test_pos;
4895   gint source_max = source_min + widget->allocation.height;
4896   gint dest_min = 0;
4897   gint dest_max = widget->allocation.height;
4898   GdkRectangle rect;
4899   GdkEvent *event;
4900
4901   scroll_test_pos = adj->value;
4902
4903   if (!GTK_WIDGET_DRAWABLE (widget))
4904     return;
4905
4906   if (source_min < 0)
4907     {
4908       rect.x = 0;
4909       rect.y = 0;
4910       rect.width = widget->allocation.width;
4911       rect.height = -source_min;
4912       if (rect.height > widget->allocation.height)
4913         rect.height = widget->allocation.height;
4914
4915       source_min = 0;
4916       dest_min = rect.height;
4917     }
4918   else
4919     {
4920       rect.x = 0;
4921       rect.y = 2*widget->allocation.height - source_max;
4922       if (rect.y < 0)
4923         rect.y = 0;
4924       rect.width = widget->allocation.width;
4925       rect.height = widget->allocation.height - rect.y;
4926
4927       source_max = widget->allocation.height;
4928       dest_max = rect.y;
4929     }
4930
4931   if (source_min != source_max)
4932     {
4933       if (scroll_test_gc == NULL)
4934         {
4935           scroll_test_gc = gdk_gc_new (widget->window);
4936           gdk_gc_set_exposures (scroll_test_gc, TRUE);
4937         }
4938
4939       gdk_draw_pixmap (widget->window,
4940                        scroll_test_gc,
4941                        widget->window,
4942                        0, source_min,
4943                        0, dest_min,
4944                        widget->allocation.width,
4945                        source_max - source_min);
4946
4947       /* Make sure graphics expose events are processed before scrolling
4948        * again */
4949
4950       while ((event = gdk_event_get_graphics_expose (widget->window)) != NULL)
4951         {
4952           gtk_widget_event (widget, event);
4953           if (event->expose.count == 0)
4954             {
4955               gdk_event_free (event);
4956               break;
4957             }
4958           gdk_event_free (event);
4959         }
4960     }
4961
4962
4963   if (rect.height != 0)
4964     gtk_widget_draw (widget, &rect);
4965 }
4966
4967
4968 void
4969 create_scroll_test ()
4970 {
4971   static GtkWidget *window = NULL;
4972   GtkWidget *hbox;
4973   GtkWidget *drawing_area;
4974   GtkWidget *scrollbar;
4975   GtkWidget *button;
4976   GtkAdjustment *adj;
4977
4978   if (!window)
4979     {
4980       window = gtk_dialog_new ();
4981
4982       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4983                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4984                           &window);
4985
4986       gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
4987       gtk_container_border_width (GTK_CONTAINER (window), 0);
4988
4989       hbox = gtk_hbox_new (FALSE, 0);
4990       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox,
4991                           TRUE, TRUE, 0);
4992       gtk_widget_show (hbox);
4993
4994       drawing_area = gtk_drawing_area_new ();
4995       gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 200, 200);
4996       gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
4997       gtk_widget_show (drawing_area);
4998
4999       gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK);
5000
5001       adj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0));
5002       scroll_test_pos = 0.0;
5003
5004       scrollbar = gtk_vscrollbar_new (adj);
5005       gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
5006       gtk_widget_show (scrollbar);
5007
5008       gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
5009                           GTK_SIGNAL_FUNC (scroll_test_expose), adj);
5010       gtk_signal_connect (GTK_OBJECT (drawing_area), "configure_event",
5011                           GTK_SIGNAL_FUNC (scroll_test_configure), adj);
5012
5013
5014       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
5015                           GTK_SIGNAL_FUNC (scroll_test_adjustment_changed),
5016                           drawing_area);
5017
5018       /* .. And create some buttons */
5019
5020       button = gtk_button_new_with_label ("Quit");
5021       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5022                           button, TRUE, TRUE, 0);
5023
5024       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5025                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
5026                                  GTK_OBJECT (window));
5027       gtk_widget_show (button);
5028     }
5029
5030   if (!GTK_WIDGET_VISIBLE (window))
5031     gtk_widget_show (window);
5032   else
5033     gtk_widget_destroy (window);
5034 }
5035
5036 /*
5037  * Timeout Test
5038  */
5039 static int timer = 0;
5040
5041 void
5042 timeout_test (GtkWidget *label)
5043 {
5044   static int count = 0;
5045   static char buffer[32];
5046
5047   sprintf (buffer, "count: %d", ++count);
5048   gtk_label_set (GTK_LABEL (label), buffer);
5049 }
5050
5051 void
5052 start_timeout_test (GtkWidget *widget,
5053                     GtkWidget *label)
5054 {
5055   if (!timer)
5056     {
5057       timer = gtk_timeout_add (100, (GtkFunction) timeout_test, label);
5058     }
5059 }
5060
5061 void
5062 stop_timeout_test (GtkWidget *widget,
5063                    gpointer   data)
5064 {
5065   if (timer)
5066     {
5067       gtk_timeout_remove (timer);
5068       timer = 0;
5069     }
5070 }
5071
5072 void
5073 destroy_timeout_test (GtkWidget  *widget,
5074                       GtkWidget **window)
5075 {
5076   stop_timeout_test (NULL, NULL);
5077
5078   *window = NULL;
5079 }
5080
5081 void
5082 create_timeout_test ()
5083 {
5084   static GtkWidget *window = NULL;
5085   GtkWidget *button;
5086   GtkWidget *label;
5087
5088   if (!window)
5089     {
5090       window = gtk_dialog_new ();
5091
5092       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5093                           GTK_SIGNAL_FUNC(destroy_timeout_test),
5094                           &window);
5095
5096       gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
5097       gtk_container_border_width (GTK_CONTAINER (window), 0);
5098
5099       label = gtk_label_new ("count: 0");
5100       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
5101       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
5102                           label, TRUE, TRUE, 0);
5103       gtk_widget_show (label);
5104
5105       button = gtk_button_new_with_label ("close");
5106       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5107                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
5108                                  GTK_OBJECT (window));
5109       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5110       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5111                           button, TRUE, TRUE, 0);
5112       gtk_widget_grab_default (button);
5113       gtk_widget_show (button);
5114
5115       button = gtk_button_new_with_label ("start");
5116       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5117                           GTK_SIGNAL_FUNC(start_timeout_test),
5118                           label);
5119       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5120       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5121                           button, TRUE, TRUE, 0);
5122       gtk_widget_show (button);
5123
5124       button = gtk_button_new_with_label ("stop");
5125       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5126                           GTK_SIGNAL_FUNC(stop_timeout_test),
5127                           NULL);
5128       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5129       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5130                           button, TRUE, TRUE, 0);
5131       gtk_widget_show (button);
5132     }
5133
5134   if (!GTK_WIDGET_VISIBLE (window))
5135     gtk_widget_show (window);
5136   else
5137     gtk_widget_destroy (window);
5138 }
5139
5140
5141 /*
5142  * Idle Test
5143  */
5144 static int idle = 0;
5145
5146 gint
5147 idle_test (GtkWidget *label)
5148 {
5149   static int count = 0;
5150   static char buffer[32];
5151
5152   sprintf (buffer, "count: %d", ++count);
5153   gtk_label_set (GTK_LABEL (label), buffer);
5154
5155   return TRUE;
5156 }
5157
5158 void
5159 start_idle_test (GtkWidget *widget,
5160                  GtkWidget *label)
5161 {
5162   if (!idle)
5163     {
5164       idle = gtk_idle_add ((GtkFunction) idle_test, label);
5165     }
5166 }
5167
5168 void
5169 stop_idle_test (GtkWidget *widget,
5170                 gpointer   data)
5171 {
5172   if (idle)
5173     {
5174       gtk_idle_remove (idle);
5175       idle = 0;
5176     }
5177 }
5178
5179 void
5180 destroy_idle_test (GtkWidget  *widget,
5181                    GtkWidget **window)
5182 {
5183   stop_idle_test (NULL, NULL);
5184
5185   *window = NULL;
5186 }
5187
5188 void
5189 create_idle_test ()
5190 {
5191   static GtkWidget *window = NULL;
5192   GtkWidget *button;
5193   GtkWidget *label;
5194
5195   if (!window)
5196     {
5197       window = gtk_dialog_new ();
5198
5199       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5200                           GTK_SIGNAL_FUNC(destroy_idle_test),
5201                           &window);
5202
5203       gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
5204       gtk_container_border_width (GTK_CONTAINER (window), 0);
5205
5206       label = gtk_label_new ("count: 0");
5207       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
5208       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
5209                           label, TRUE, TRUE, 0);
5210       gtk_widget_show (label);
5211
5212       button = gtk_button_new_with_label ("close");
5213       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5214                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
5215                                  GTK_OBJECT (window));
5216       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5217       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5218                           button, TRUE, TRUE, 0);
5219       gtk_widget_grab_default (button);
5220       gtk_widget_show (button);
5221
5222       button = gtk_button_new_with_label ("start");
5223       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5224                           GTK_SIGNAL_FUNC(start_idle_test),
5225                           label);
5226       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5227       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5228                           button, TRUE, TRUE, 0);
5229       gtk_widget_show (button);
5230
5231       button = gtk_button_new_with_label ("stop");
5232       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5233                           GTK_SIGNAL_FUNC(stop_idle_test),
5234                           NULL);
5235       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5236       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5237                           button, TRUE, TRUE, 0);
5238       gtk_widget_show (button);
5239     }
5240
5241   if (!GTK_WIDGET_VISIBLE (window))
5242     gtk_widget_show (window);
5243   else
5244     gtk_widget_destroy (window);
5245 }
5246
5247 /*
5248  * Basic Test
5249  */
5250 void
5251 create_test ()
5252 {
5253   static GtkWidget *window = NULL;
5254
5255   if (!window)
5256     {
5257       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5258
5259       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5260                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5261                           &window);
5262
5263
5264       gtk_window_set_title (GTK_WINDOW (window), "test");
5265       gtk_container_border_width (GTK_CONTAINER (window), 0);
5266     }
5267
5268   if (!GTK_WIDGET_VISIBLE (window))
5269     {
5270       gtk_widget_show (window);
5271
5272       g_print ("create_test: start\n");
5273       gtk_main ();
5274       g_print ("create_test: done\n");
5275     }
5276   else
5277     gtk_widget_destroy (window);
5278 }
5279
5280
5281 /*
5282  * Main Window and Exit
5283  */
5284 void
5285 do_exit (GtkWidget *widget, GtkWidget *window)
5286 {
5287   gtk_widget_destroy (window);
5288   gtk_main_quit ();
5289 }
5290
5291 void
5292 create_main_window ()
5293 {
5294   struct {
5295     char *label;
5296     void (*func) ();
5297   } buttons[] =
5298     {
5299       { "buttons", create_buttons },
5300       { "toggle buttons", create_toggle_buttons },
5301       { "check buttons", create_check_buttons },
5302       { "radio buttons", create_radio_buttons },
5303       { "button box", create_button_box },
5304       { "toolbar", create_toolbar },
5305       { "handle box", create_handle_box },
5306       { "statusbar", create_statusbar },
5307       { "reparent", create_reparent },
5308       { "pixmap", create_pixmap },
5309       { "tooltips", create_tooltips },
5310       { "menus", create_menus },
5311       { "scrolled windows", create_scrolled_windows },
5312       { "drawing areas", NULL },
5313       { "entry", create_entry },
5314       { "spinbutton", create_spins },
5315       { "list", create_list },
5316       { "clist", create_clist},
5317       { "tree", create_tree_mode_window},
5318       { "color selection", create_color_selection },
5319       { "file selection", create_file_selection },
5320       { "dialog", create_dialog },
5321       { "miscellaneous", NULL },
5322       { "range controls", create_range_controls },
5323       { "rulers", create_rulers },
5324       { "text", create_text },
5325       { "notebook", create_notebook },
5326       { "panes", create_panes },
5327       { "shapes", create_shapes },
5328       { "dnd", create_dnd },
5329       { "WM hints", create_wmhints },
5330       { "progress bar", create_progress_bar },
5331       { "preview color", create_color_preview },
5332       { "preview gray", create_gray_preview },
5333       { "gamma curve", create_gamma_curve },
5334       { "test scrolling", create_scroll_test },
5335       { "test selection", create_selection_test },
5336       { "test timeout", create_timeout_test },
5337       { "test idle", create_idle_test },
5338       { "test", create_test },
5339     };
5340   int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
5341   GtkWidget *window;
5342   GtkWidget *box1;
5343   GtkWidget *box2;
5344   GtkWidget *scrolled_window;
5345   GtkWidget *button;
5346   GtkWidget *label;
5347   gchar buffer[64];
5348   GtkWidget *separator;
5349   int i;
5350
5351   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5352   gtk_widget_set_name (window, "main window");
5353   gtk_widget_set_usize (window, 200, 400);
5354   gtk_widget_set_uposition (window, 20, 20);
5355
5356   gtk_signal_connect (GTK_OBJECT (window), "destroy",
5357                       GTK_SIGNAL_FUNC(gtk_main_quit),
5358                       NULL);
5359   gtk_signal_connect (GTK_OBJECT (window), "delete_event",
5360                       GTK_SIGNAL_FUNC (gtk_false),
5361                       NULL);
5362
5363   box1 = gtk_vbox_new (FALSE, 0);
5364   gtk_container_add (GTK_CONTAINER (window), box1);
5365   gtk_widget_show (box1);
5366
5367   if (gtk_micro_version > 0)
5368     sprintf (buffer,
5369              "Gtk+ v%d.%d.%d",
5370              gtk_major_version,
5371              gtk_minor_version,
5372              gtk_micro_version);
5373   else
5374     sprintf (buffer,
5375              "Gtk+ v%d.%d",
5376              gtk_major_version,
5377              gtk_minor_version);
5378
5379   label = gtk_label_new (buffer);
5380   gtk_widget_show (label);
5381   gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
5382
5383   scrolled_window = gtk_scrolled_window_new (NULL, NULL);
5384   gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
5385   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
5386                                   GTK_POLICY_AUTOMATIC,
5387                                   GTK_POLICY_AUTOMATIC);
5388   gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
5389   gtk_widget_show (scrolled_window);
5390
5391   box2 = gtk_vbox_new (FALSE, 0);
5392   gtk_container_border_width (GTK_CONTAINER (box2), 10);
5393   gtk_container_add (GTK_CONTAINER (scrolled_window), box2);
5394   gtk_widget_show (box2);
5395
5396   for (i = 0; i < nbuttons; i++)
5397     {
5398       button = gtk_button_new_with_label (buttons[i].label);
5399       if (buttons[i].func)
5400         gtk_signal_connect (GTK_OBJECT (button),
5401                             "clicked",
5402                             GTK_SIGNAL_FUNC(buttons[i].func),
5403                             NULL);
5404       else
5405         gtk_widget_set_sensitive (button, FALSE);
5406       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5407       gtk_widget_show (button);
5408     }
5409
5410   separator = gtk_hseparator_new ();
5411   gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5412   gtk_widget_show (separator);
5413
5414   box2 = gtk_vbox_new (FALSE, 10);
5415   gtk_container_border_width (GTK_CONTAINER (box2), 10);
5416   gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5417   gtk_widget_show (box2);
5418
5419   button = gtk_button_new_with_label ("close");
5420   gtk_signal_connect (GTK_OBJECT (button), "clicked",
5421                       GTK_SIGNAL_FUNC (do_exit),
5422                       window);
5423   gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5424   GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5425   gtk_widget_grab_default (button);
5426   gtk_widget_show (button);
5427
5428   gtk_widget_show (window);
5429 }
5430
5431 int
5432 main (int argc, char *argv[])
5433 {
5434   gtk_set_locale ();
5435
5436   gtk_init (&argc, &argv);
5437
5438 #ifdef HAVE_LIBGLE
5439   gle_init (&argc, &argv);
5440 #endif /* !HAVE_LIBGLE */
5441
5442   gtk_rc_parse ("testgtkrc");
5443
5444   create_main_window ();
5445
5446   gtk_main ();
5447
5448   return 0;
5449 }