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