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

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