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