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

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