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

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