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

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