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