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

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