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
4539       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4540                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4541                           &window);
4542
4543       gtk_window_set_title (GTK_WINDOW (window), "rulers");
4544       gtk_widget_set_usize (window, 300, 300);
4545       gtk_widget_set_events (window,
4546                              GDK_POINTER_MOTION_MASK
4547                              | GDK_POINTER_MOTION_HINT_MASK);
4548       gtk_container_border_width (GTK_CONTAINER (window), 0);
4549
4550       table = gtk_table_new (2, 2, FALSE);
4551       gtk_container_add (GTK_CONTAINER (window), table);
4552       gtk_widget_show (table);
4553
4554       ruler = gtk_hruler_new ();
4555       gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
4556
4557       gtk_signal_connect_object (
4558         GTK_OBJECT (window),
4559         "motion_notify_event",
4560         GTK_SIGNAL_FUNC(
4561           GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
4562         GTK_OBJECT (ruler));
4563
4564       gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
4565                         GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
4566       gtk_widget_show (ruler);
4567
4568
4569       ruler = gtk_vruler_new ();
4570       gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
4571
4572       gtk_signal_connect_object (
4573         GTK_OBJECT (window),
4574         "motion_notify_event",
4575         GTK_SIGNAL_FUNC (GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
4576         GTK_OBJECT (ruler));
4577
4578       gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
4579                         GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
4580       gtk_widget_show (ruler);
4581     }
4582
4583   if (!GTK_WIDGET_VISIBLE (window))
4584     gtk_widget_show (window);
4585   else
4586     gtk_widget_destroy (window);
4587 }
4588
4589
4590 static void
4591 text_toggle_editable (GtkWidget *checkbutton,
4592                        GtkWidget *text)
4593 {
4594    gtk_text_set_editable(GTK_TEXT(text),
4595                           GTK_TOGGLE_BUTTON(checkbutton)->active);
4596 }
4597
4598 static void
4599 text_toggle_word_wrap (GtkWidget *checkbutton,
4600                        GtkWidget *text)
4601 {
4602    gtk_text_set_word_wrap(GTK_TEXT(text),
4603                           GTK_TOGGLE_BUTTON(checkbutton)->active);
4604 }
4605
4606 /*
4607  * GtkText
4608  */
4609 void
4610 create_text (void)
4611 {
4612   static GtkWidget *window = NULL;
4613   GtkWidget *box1;
4614   GtkWidget *box2;
4615   GtkWidget *hbox;
4616   GtkWidget *button;
4617   GtkWidget *check;
4618   GtkWidget *separator;
4619   GtkWidget *table;
4620   GtkWidget *hscrollbar;
4621   GtkWidget *vscrollbar;
4622   GtkWidget *text;
4623
4624   FILE *infile;
4625
4626   if (!window)
4627     {
4628       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4629       gtk_widget_set_name (window, "text window");
4630       gtk_widget_set_usize (window, 500, 500);
4631       gtk_window_set_policy (GTK_WINDOW(window), TRUE, TRUE, FALSE);
4632
4633       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4634                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4635                           &window);
4636
4637       gtk_window_set_title (GTK_WINDOW (window), "test");
4638       gtk_container_border_width (GTK_CONTAINER (window), 0);
4639
4640
4641       box1 = gtk_vbox_new (FALSE, 0);
4642       gtk_container_add (GTK_CONTAINER (window), box1);
4643       gtk_widget_show (box1);
4644
4645
4646       box2 = gtk_vbox_new (FALSE, 10);
4647       gtk_container_border_width (GTK_CONTAINER (box2), 10);
4648       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
4649       gtk_widget_show (box2);
4650
4651
4652       table = gtk_table_new (2, 2, FALSE);
4653       gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2);
4654       gtk_table_set_col_spacing (GTK_TABLE (table), 0, 2);
4655       gtk_box_pack_start (GTK_BOX (box2), table, TRUE, TRUE, 0);
4656       gtk_widget_show (table);
4657
4658       text = gtk_text_new (NULL, NULL);
4659       gtk_text_set_editable (GTK_TEXT (text), TRUE);
4660       gtk_table_attach (GTK_TABLE (table), text, 0, 1, 0, 1,
4661                         GTK_EXPAND | GTK_SHRINK | GTK_FILL,
4662                         GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
4663       gtk_widget_show (text);
4664
4665       hscrollbar = gtk_hscrollbar_new (GTK_TEXT (text)->hadj);
4666       gtk_table_attach (GTK_TABLE (table), hscrollbar, 0, 1, 1, 2,
4667                         GTK_EXPAND | GTK_FILL | GTK_SHRINK, GTK_FILL, 0, 0);
4668       gtk_widget_show (hscrollbar);
4669
4670       vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
4671       gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 0, 1,
4672                         GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
4673       gtk_widget_show (vscrollbar);
4674
4675       gtk_text_freeze (GTK_TEXT (text));
4676
4677       gtk_widget_realize (text);
4678
4679       infile = fopen("testgtk.c", "r");
4680
4681       if (infile)
4682         {
4683           char buffer[1024];
4684           int nchars;
4685
4686           while (1)
4687             {
4688               nchars = fread(buffer, 1, 1024, infile);
4689               gtk_text_insert (GTK_TEXT (text), NULL, NULL,
4690                                NULL, buffer, nchars);
4691
4692               if (nchars < 1024)
4693                 break;
4694             }
4695
4696           fclose (infile);
4697         }
4698
4699       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
4700                        "And even ", -1);
4701       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->bg[GTK_STATE_NORMAL], NULL,
4702                        "colored", -1);
4703       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
4704                        "text", -1);
4705
4706       gtk_text_thaw (GTK_TEXT (text));
4707
4708       hbox = gtk_hbutton_box_new ();
4709       gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, FALSE, 0);
4710       gtk_widget_show (hbox);
4711
4712       check = gtk_check_button_new_with_label("Editable");
4713       gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, FALSE, 0);
4714       gtk_signal_connect (GTK_OBJECT(check), "toggled",
4715                           GTK_SIGNAL_FUNC(text_toggle_editable), text);
4716       gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), TRUE);
4717       gtk_widget_show (check);
4718
4719       check = gtk_check_button_new_with_label("Wrap Words");
4720       gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
4721       gtk_signal_connect (GTK_OBJECT(check), "toggled",
4722                           GTK_SIGNAL_FUNC(text_toggle_word_wrap), text);
4723       gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), FALSE);
4724       gtk_widget_show (check);
4725
4726       separator = gtk_hseparator_new ();
4727       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4728       gtk_widget_show (separator);
4729
4730
4731       box2 = gtk_vbox_new (FALSE, 10);
4732       gtk_container_border_width (GTK_CONTAINER (box2), 10);
4733       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4734       gtk_widget_show (box2);
4735
4736
4737       button = gtk_button_new_with_label ("close");
4738       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4739                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
4740                                  GTK_OBJECT (window));
4741       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4742       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4743       gtk_widget_grab_default (button);
4744       gtk_widget_show (button);
4745     }
4746
4747   if (!GTK_WIDGET_VISIBLE (window))
4748     gtk_widget_show (window);
4749   else
4750     gtk_widget_destroy (window);
4751 }
4752
4753
4754 /*
4755  * GtkNotebook
4756  */
4757
4758 GdkPixmap *book_open;
4759 GdkPixmap *book_closed;
4760 GdkBitmap *book_open_mask;
4761 GdkBitmap *book_closed_mask;
4762
4763
4764 static void
4765 notebook_reparent (GtkWidget *widget, GtkWidget *scrollwin)
4766 {
4767   static GtkWidget *parent = NULL;
4768   static GtkWidget *float_parent;
4769
4770   if (parent)
4771     {
4772       gtk_widget_reparent (scrollwin, parent);
4773       gtk_widget_destroy (float_parent);
4774       float_parent = NULL;
4775       parent = NULL;
4776     }
4777   else
4778     {
4779       parent = widget->parent;
4780       float_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4781       gtk_widget_show (float_parent);
4782       gtk_widget_reparent (scrollwin, float_parent);
4783     }
4784 }
4785
4786 static void
4787 page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num)
4788 {
4789   GtkNotebookPage *oldpage;
4790   GtkWidget *pixwid;
4791
4792   oldpage = GTK_NOTEBOOK (widget)->cur_page;
4793
4794   if (page == oldpage)
4795     return;
4796
4797   pixwid = ((GtkBoxChild*)(GTK_BOX (page->tab_label)->children->data))->widget;
4798   gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
4799   pixwid = ((GtkBoxChild*) (GTK_BOX (page->menu_label)->children->data))->widget;
4800   gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
4801
4802   if (oldpage)
4803     {
4804       pixwid = ((GtkBoxChild*) (GTK_BOX
4805                                 (oldpage->tab_label)->children->data))->widget;
4806       gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
4807       pixwid = ((GtkBoxChild*) (GTK_BOX (oldpage->menu_label)->children->data))->widget;
4808       gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
4809     }
4810 }
4811
4812 static void
4813 create_pages (GtkNotebook *notebook, gint start, gint end)
4814 {
4815   GtkWidget *child = NULL;
4816   GtkWidget *label;
4817   GtkWidget *entry;
4818   GtkWidget *box;
4819   GtkWidget *hbox;
4820   GtkWidget *label_box;
4821   GtkWidget *menu_box;
4822   GtkWidget *button;
4823   GtkWidget *pixwid;
4824   gint i;
4825   char buffer[32];
4826
4827   for (i = start; i <= end; i++)
4828     {
4829       sprintf (buffer, "Page %d", i);
4830
4831       switch (i%4)
4832         {
4833         case 3:
4834           child = gtk_button_new_with_label (buffer);
4835           gtk_container_border_width (GTK_CONTAINER(child), 10);
4836           break;
4837         case 2:
4838           child = gtk_label_new (buffer);
4839           break;
4840         case 1:
4841           child = gtk_frame_new (buffer);
4842           gtk_container_border_width (GTK_CONTAINER (child), 10);
4843
4844           box = gtk_vbox_new (TRUE,0);
4845           gtk_container_border_width (GTK_CONTAINER (box), 10);
4846           gtk_container_add (GTK_CONTAINER (child), box);
4847
4848           label = gtk_label_new (buffer);
4849           gtk_box_pack_start (GTK_BOX(box), label, TRUE, TRUE, 5);
4850
4851           entry = gtk_entry_new ();
4852           gtk_box_pack_start (GTK_BOX(box), entry, TRUE, TRUE, 5);
4853
4854           hbox = gtk_hbox_new (TRUE,0);
4855           gtk_box_pack_start (GTK_BOX(box), hbox, TRUE, TRUE, 5);
4856
4857           button = gtk_button_new_with_label ("Ok");
4858           gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
4859
4860           button = gtk_button_new_with_label ("Cancel");
4861           gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
4862           break;
4863         case 0:
4864           child = gtk_frame_new (buffer);
4865           gtk_container_border_width (GTK_CONTAINER (child), 10);
4866
4867           label = gtk_label_new (buffer);
4868           gtk_container_add (GTK_CONTAINER (child), label);
4869           break;
4870         }
4871
4872       gtk_widget_show_all (child);
4873
4874       label_box = gtk_hbox_new (FALSE, 0);
4875       pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
4876       gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
4877       gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
4878       label = gtk_label_new (buffer);
4879       gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
4880       gtk_widget_show_all (label_box);
4881
4882       menu_box = gtk_hbox_new (FALSE, 0);
4883       pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
4884       gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
4885       gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
4886       label = gtk_label_new (buffer);
4887       gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0);
4888       gtk_widget_show_all (menu_box);
4889
4890       gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
4891     }
4892 }
4893
4894 static void
4895 rotate_notebook (GtkButton   *button,
4896                  GtkNotebook *notebook)
4897 {
4898   gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos + 1) % 4);
4899 }
4900
4901 static void
4902 standard_notebook (GtkButton   *button,
4903                    GtkNotebook *notebook)
4904 {
4905   gint i;
4906
4907   gtk_notebook_set_show_tabs (notebook, TRUE);
4908   gtk_notebook_set_scrollable (notebook, FALSE);
4909   if (g_list_length (notebook->children) == 15)
4910     for (i = 0; i < 10; i++)
4911       gtk_notebook_remove_page (notebook, 5);
4912 }
4913
4914 static void
4915 notabs_notebook (GtkButton   *button,
4916                  GtkNotebook *notebook)
4917 {
4918   gint i;
4919
4920   gtk_notebook_set_show_tabs (notebook, FALSE);
4921   if (g_list_length (notebook->children) == 15)
4922     for (i = 0; i < 10; i++)
4923       gtk_notebook_remove_page (notebook, 5);
4924 }
4925
4926 static void
4927 scrollable_notebook (GtkButton   *button,
4928                      GtkNotebook *notebook)
4929 {
4930   gtk_notebook_set_show_tabs (notebook, TRUE);
4931   gtk_notebook_set_scrollable (notebook, TRUE);
4932   if (g_list_length (notebook->children) == 5)
4933     create_pages (notebook, 6, 15);
4934 }
4935
4936 static void
4937 notebook_popup (GtkToggleButton *button,
4938                 GtkNotebook     *notebook)
4939 {
4940   if (button->active)
4941     gtk_notebook_popup_enable (notebook);
4942   else
4943     gtk_notebook_popup_disable (notebook);
4944 }
4945
4946 static void
4947 create_notebook (void)
4948 {
4949   static GtkWidget *window = NULL;
4950   GtkWidget *box1;
4951   GtkWidget *box2;
4952   GtkWidget *button;
4953   GtkWidget *separator;
4954   GtkWidget *notebook;
4955   GtkWidget *omenu;
4956   GtkWidget *menu;
4957   GtkWidget *submenu;
4958   GtkWidget *menuitem;
4959   GSList *group;
4960   GdkColor *transparent = NULL;
4961
4962   if (!window)
4963     {
4964       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4965
4966       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4967                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4968                           &window);
4969
4970       gtk_window_set_title (GTK_WINDOW (window), "notebook");
4971       gtk_container_border_width (GTK_CONTAINER (window), 0);
4972
4973       box1 = gtk_vbox_new (FALSE, 0);
4974       gtk_container_add (GTK_CONTAINER (window), box1);
4975
4976       notebook = gtk_notebook_new ();
4977       gtk_signal_connect (GTK_OBJECT (notebook), "switch_page",
4978                           GTK_SIGNAL_FUNC (page_switch), NULL);
4979       gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
4980       gtk_box_pack_start (GTK_BOX (box1), notebook, TRUE, TRUE, 0);
4981       gtk_container_border_width (GTK_CONTAINER (notebook), 10);
4982
4983       gtk_widget_realize (notebook);
4984       book_open = gdk_pixmap_create_from_xpm_d (notebook->window,
4985                                                 &book_open_mask,
4986                                                 transparent,
4987                                                 book_open_xpm);
4988       book_closed = gdk_pixmap_create_from_xpm_d (notebook->window,
4989                                                   &book_closed_mask,
4990                                                   transparent,
4991                                                   book_closed_xpm);
4992
4993       create_pages (GTK_NOTEBOOK (notebook), 1, 5);
4994
4995       separator = gtk_hseparator_new ();
4996       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10);
4997
4998       box2 = gtk_hbox_new (TRUE, 5);
4999       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5000
5001       omenu = gtk_option_menu_new ();
5002       menu = gtk_menu_new ();
5003       submenu = NULL;
5004       group = NULL;
5005
5006       menuitem = gtk_radio_menu_item_new_with_label (group, "Standard");
5007       gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
5008                                  GTK_SIGNAL_FUNC (standard_notebook),
5009                                  GTK_OBJECT (notebook));
5010       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
5011       gtk_menu_append (GTK_MENU (menu), menuitem);
5012       gtk_widget_show (menuitem);
5013       menuitem = gtk_radio_menu_item_new_with_label (group, "w/o Tabs");
5014       gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
5015                                  GTK_SIGNAL_FUNC (notabs_notebook),
5016                                  GTK_OBJECT (notebook));
5017       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
5018       gtk_menu_append (GTK_MENU (menu), menuitem);
5019       gtk_widget_show (menuitem);
5020       menuitem = gtk_radio_menu_item_new_with_label (group, "Scrollable");
5021       gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
5022                                  GTK_SIGNAL_FUNC (scrollable_notebook),
5023                                  GTK_OBJECT (notebook));
5024       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
5025       gtk_menu_append (GTK_MENU (menu), menuitem);
5026       gtk_widget_show (menuitem);
5027
5028       gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
5029       gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, FALSE, 0);
5030       button = gtk_check_button_new_with_label ("enable popup menu");
5031       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
5032       gtk_signal_connect (GTK_OBJECT(button), "clicked",
5033                           GTK_SIGNAL_FUNC (notebook_popup),
5034                           GTK_OBJECT (notebook));
5035
5036       box2 = gtk_hbox_new (FALSE, 10);
5037       gtk_container_border_width (GTK_CONTAINER (box2), 10);
5038       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5039
5040       button = gtk_button_new_with_label ("close");
5041       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5042                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
5043                                  GTK_OBJECT (window));
5044       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5045       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5046       gtk_widget_grab_default (button);
5047
5048       button = gtk_button_new_with_label ("next");
5049       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5050                                  GTK_SIGNAL_FUNC (gtk_notebook_next_page),
5051                                  GTK_OBJECT (notebook));
5052       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5053       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5054
5055       button = gtk_button_new_with_label ("prev");
5056       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5057                                  GTK_SIGNAL_FUNC (gtk_notebook_prev_page),
5058                                  GTK_OBJECT (notebook));
5059       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5060       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5061
5062       button = gtk_button_new_with_label ("rotate");
5063       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5064                           GTK_SIGNAL_FUNC (rotate_notebook),
5065                           notebook);
5066       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5067       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5068
5069       button = gtk_button_new_with_label ("reparent");
5070       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5071                           GTK_SIGNAL_FUNC (notebook_reparent),
5072                           notebook);
5073       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5074       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5075     }
5076
5077   if (!GTK_WIDGET_VISIBLE (window))
5078     gtk_widget_show_all (window);
5079   else
5080     gtk_widget_destroy (window);
5081 }
5082
5083
5084 /*
5085  * GtkPanes
5086  */
5087 void
5088 create_panes (void)
5089 {
5090   static GtkWidget *window = NULL;
5091   GtkWidget *frame;
5092   GtkWidget *hpaned;
5093   GtkWidget *vpaned;
5094   GtkWidget *button;
5095
5096   if (!window)
5097     {
5098       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5099
5100       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5101                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5102                           &window);
5103
5104       gtk_window_set_title (GTK_WINDOW (window), "Panes");
5105       gtk_container_border_width (GTK_CONTAINER (window), 0);
5106
5107       vpaned = gtk_vpaned_new ();
5108       gtk_container_add (GTK_CONTAINER (window), vpaned);
5109       gtk_container_border_width (GTK_CONTAINER(vpaned), 5);
5110       gtk_widget_show (vpaned);
5111
5112       hpaned = gtk_hpaned_new ();
5113       gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
5114
5115       frame = gtk_frame_new (NULL);
5116       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
5117       gtk_widget_set_usize (frame, 60, 60);
5118       gtk_paned_add1 (GTK_PANED (hpaned), frame);
5119       gtk_widget_show (frame);
5120
5121       button = gtk_button_new_with_label ("Hi there");
5122       gtk_container_add (GTK_CONTAINER(frame), button);
5123       gtk_widget_show (button);
5124
5125       frame = gtk_frame_new (NULL);
5126       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
5127       gtk_widget_set_usize (frame, 80, 60);
5128       gtk_paned_add2 (GTK_PANED (hpaned), frame);
5129       gtk_widget_show (frame);
5130
5131       gtk_widget_show (hpaned);
5132
5133       frame = gtk_frame_new (NULL);
5134       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
5135       gtk_widget_set_usize (frame, 60, 80);
5136       gtk_paned_add2 (GTK_PANED (vpaned), frame);
5137       gtk_widget_show (frame);
5138     }
5139
5140   if (!GTK_WIDGET_VISIBLE (window))
5141     gtk_widget_show (window);
5142   else
5143     gtk_widget_destroy (window);
5144 }
5145
5146
5147 /*
5148  * Drag -N- Drop
5149  */
5150
5151 gint
5152 dnd_drop_destroy_popup (GtkWidget *widget, GtkWindow **window)
5153 {
5154   if(GTK_IS_BUTTON(widget)) /* I.e. they clicked the close button */
5155     gtk_widget_destroy(GTK_WIDGET(*window));
5156   else {
5157     gtk_grab_remove(GTK_WIDGET(*window));
5158     *window = NULL;
5159   }
5160
5161   return FALSE;
5162 }
5163
5164 void
5165 dnd_drop (GtkWidget *button, GdkEvent *event)
5166 {
5167   static GtkWidget *window = NULL;
5168   GtkWidget *vbox, *lbl, *btn;
5169   gchar *msg;
5170
5171   /* DND doesn't obey gtk_grab's, so check if we're already displaying
5172    * drop modal dialog first
5173    */
5174   if (window)
5175     return;
5176
5177   window = gtk_window_new(GTK_WINDOW_DIALOG);
5178   gtk_container_border_width (GTK_CONTAINER(window), 10);
5179
5180   gtk_signal_connect (GTK_OBJECT (window), "destroy",
5181                       GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
5182                       &window);
5183   gtk_signal_connect (GTK_OBJECT (window), "delete-event",
5184                       GTK_SIGNAL_FUNC(gtk_false),
5185                       &window);
5186
5187   vbox = gtk_vbox_new(FALSE, 5);
5188
5189   /* Display message that we got from drop source */
5190   msg = g_malloc(strlen(event->dropdataavailable.data)
5191                  + strlen(event->dropdataavailable.data_type) + 100);
5192   sprintf(msg, "Drop data of type %s was:\n\n%s",
5193           event->dropdataavailable.data_type,
5194           (char *)event->dropdataavailable.data);
5195   lbl = gtk_label_new(msg);
5196   gtk_label_set_justify(GTK_LABEL(lbl), GTK_JUSTIFY_FILL);
5197   g_free(msg);
5198   gtk_widget_show(lbl);
5199   gtk_box_pack_start_defaults(GTK_BOX(vbox), lbl);
5200
5201   /* Provide an obvious way out of this heinousness */
5202   btn = gtk_button_new_with_label("Continue with life in\nspite of this oppression");
5203   gtk_signal_connect_object (GTK_OBJECT (btn), "clicked",
5204                              GTK_SIGNAL_FUNC(gtk_widget_destroy),
5205                              GTK_OBJECT (window));
5206   gtk_widget_show(btn);
5207   gtk_box_pack_start_defaults(GTK_BOX(vbox), btn);
5208
5209   gtk_container_add(GTK_CONTAINER(window), vbox);
5210
5211   gtk_widget_show(vbox);
5212   gtk_grab_add(window);
5213   gtk_widget_show(window);
5214 }
5215
5216 void
5217 dnd_drag_request (GtkWidget *button, GdkEvent *event)
5218 {
5219 #define DND_STRING "Bill Gates demands royalties for\nyour use of his innovation."
5220   gtk_widget_dnd_data_set (button, event, DND_STRING, strlen(DND_STRING) + 1);
5221 }
5222
5223 void
5224 create_dnd (void)
5225 {
5226   static GtkWidget *window = NULL;
5227   GtkWidget *box1;
5228   GtkWidget *box2;
5229   GtkWidget *box3;
5230   GtkWidget *frame;
5231   GtkWidget *button;
5232   GtkWidget *separator;
5233
5234   /* For clarity... */
5235   char *possible_drag_types[] = {"text/plain"};
5236   char *accepted_drop_types[] = {"text/plain"};
5237
5238   static GtkWidget *drag_icon = NULL;
5239   static GtkWidget *drop_icon = NULL;
5240
5241   if (!window)
5242     {
5243       GdkPoint hotspot = {5,5};
5244
5245       if (!drag_icon)
5246         {
5247           drag_icon = shape_create_icon ("Modeller.xpm",
5248                                          440, 140, 0,0, GTK_WINDOW_POPUP);
5249
5250           gtk_signal_connect (GTK_OBJECT (drag_icon), "destroy",
5251                               GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5252                               &drag_icon);
5253
5254           gtk_widget_hide (drag_icon);
5255         }
5256
5257       if (!drop_icon)
5258         {
5259           drop_icon = shape_create_icon ("3DRings.xpm",
5260                                          440, 140, 0,0, GTK_WINDOW_POPUP);
5261
5262           gtk_signal_connect (GTK_OBJECT (drop_icon), "destroy",
5263                               GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5264                               &drop_icon);
5265
5266           gtk_widget_hide (drop_icon);
5267         }
5268
5269       gdk_dnd_set_drag_shape(drag_icon->window,
5270                              &hotspot,
5271                              drop_icon->window,
5272                              &hotspot);
5273
5274       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5275
5276       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5277                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5278                           &window);
5279
5280       gtk_window_set_title (GTK_WINDOW (window), "Drag -N- Drop");
5281       gtk_container_border_width (GTK_CONTAINER (window), 0);
5282
5283       box1 = gtk_vbox_new (FALSE, 0);
5284       gtk_container_add (GTK_CONTAINER (window), box1);
5285       gtk_widget_show (box1);
5286
5287       box2 = gtk_hbox_new (FALSE, 5);
5288       gtk_container_border_width (GTK_CONTAINER (box2), 10);
5289       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
5290       gtk_widget_show (box2);
5291
5292       frame = gtk_frame_new ("Drag");
5293       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
5294       gtk_widget_show (frame);
5295
5296       box3 = gtk_vbox_new (FALSE, 5);
5297       gtk_container_border_width (GTK_CONTAINER (box3), 5);
5298       gtk_container_add (GTK_CONTAINER (frame), box3);
5299       gtk_widget_show (box3);
5300
5301       /*
5302        * FROM Button
5303        */
5304       button = gtk_button_new_with_label ("Drag me!");
5305       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
5306       gtk_widget_show (button);
5307
5308       /*
5309        * currently, the widget has to be realized to
5310        * set dnd on it, this needs to change
5311        */
5312       gtk_widget_realize (button);
5313       gtk_signal_connect (GTK_OBJECT (button),
5314                           "drag_request_event",
5315                           GTK_SIGNAL_FUNC(dnd_drag_request),
5316                           button);
5317
5318       gtk_widget_dnd_drag_set (button, TRUE, possible_drag_types, 1);
5319
5320
5321       frame = gtk_frame_new ("Drop");
5322       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
5323       gtk_widget_show (frame);
5324
5325       box3 = gtk_vbox_new (FALSE, 5);
5326       gtk_container_border_width (GTK_CONTAINER (box3), 5);
5327       gtk_container_add (GTK_CONTAINER (frame), box3);
5328       gtk_widget_show (box3);
5329
5330
5331       /*
5332        * TO Button
5333        */
5334       button = gtk_button_new_with_label ("To");
5335       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
5336       gtk_widget_show (button);
5337
5338       gtk_widget_realize (button);
5339       gtk_signal_connect (GTK_OBJECT (button),
5340                           "drop_data_available_event",
5341                           GTK_SIGNAL_FUNC(dnd_drop),
5342                           button);
5343
5344       gtk_widget_dnd_drop_set (button, TRUE, accepted_drop_types, 1, FALSE);
5345
5346
5347       separator = gtk_hseparator_new ();
5348       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5349       gtk_widget_show (separator);
5350
5351
5352       box2 = gtk_vbox_new (FALSE, 10);
5353       gtk_container_border_width (GTK_CONTAINER (box2), 10);
5354       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5355       gtk_widget_show (box2);
5356
5357
5358       button = gtk_button_new_with_label ("close");
5359
5360       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5361                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
5362                                  GTK_OBJECT (window));
5363
5364       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5365       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5366       gtk_widget_grab_default (button);
5367       gtk_widget_show (button);
5368     }
5369
5370   if (!GTK_WIDGET_VISIBLE (window))
5371     gtk_widget_show (window);
5372   else
5373     gtk_widget_destroy (window);
5374 }
5375
5376 /*
5377  * Shaped Windows
5378  */
5379 static GdkWindow *root_win = NULL;
5380
5381 typedef struct _cursoroffset {gint x,y;} CursorOffset;
5382
5383 static void
5384 shape_pressed (GtkWidget *widget, GdkEventButton *event)
5385 {
5386   CursorOffset *p;
5387
5388   /* ignore double and triple click */
5389   if (event->type != GDK_BUTTON_PRESS)
5390     return;
5391
5392   p = gtk_object_get_user_data (GTK_OBJECT(widget));
5393   p->x = (int) event->x;
5394   p->y = (int) event->y;
5395
5396   gtk_grab_add (widget);
5397   gdk_pointer_grab (widget->window, TRUE,
5398                     GDK_BUTTON_RELEASE_MASK |
5399                     GDK_BUTTON_MOTION_MASK |
5400                     GDK_POINTER_MOTION_HINT_MASK,
5401                     NULL, NULL, 0);
5402 }
5403
5404
5405 static void
5406 shape_released (GtkWidget *widget)
5407 {
5408   gtk_grab_remove (widget);
5409   gdk_pointer_ungrab (0);
5410 }
5411
5412 static void
5413 shape_motion (GtkWidget      *widget,
5414               GdkEventMotion *event)
5415 {
5416   gint xp, yp;
5417   CursorOffset * p;
5418   GdkModifierType mask;
5419
5420   p = gtk_object_get_user_data (GTK_OBJECT (widget));
5421
5422   /*
5423    * Can't use event->x / event->y here
5424    * because I need absolute coordinates.
5425    */
5426   gdk_window_get_pointer (root_win, &xp, &yp, &mask);
5427   gtk_widget_set_uposition (widget, xp  - p->x, yp  - p->y);
5428 }
5429
5430 GtkWidget *
5431 shape_create_icon (char     *xpm_file,
5432                    gint      x,
5433                    gint      y,
5434                    gint      px,
5435                    gint      py,
5436                    gint      window_type)
5437 {
5438   GtkWidget *window;
5439   GtkWidget *pixmap;
5440   GtkWidget *fixed;
5441   CursorOffset* icon_pos;
5442   GdkGC* gc;
5443   GdkBitmap *gdk_pixmap_mask;
5444   GdkPixmap *gdk_pixmap;
5445   GtkStyle *style;
5446
5447   style = gtk_widget_get_default_style ();
5448   gc = style->black_gc;
5449
5450   /*
5451    * GDK_WINDOW_TOPLEVEL works also, giving you a title border
5452    */
5453   window = gtk_window_new (window_type);
5454
5455   fixed = gtk_fixed_new ();
5456   gtk_widget_set_usize (fixed, 100,100);
5457   gtk_container_add (GTK_CONTAINER (window), fixed);
5458   gtk_widget_show (fixed);
5459
5460   gtk_widget_set_events (window,
5461                          gtk_widget_get_events (window) |
5462                          GDK_BUTTON_MOTION_MASK |
5463                          GDK_POINTER_MOTION_HINT_MASK |
5464                          GDK_BUTTON_PRESS_MASK);
5465
5466   gtk_widget_realize (window);
5467   gdk_pixmap = gdk_pixmap_create_from_xpm (window->window, &gdk_pixmap_mask,
5468                                            &style->bg[GTK_STATE_NORMAL],
5469                                            xpm_file);
5470
5471   pixmap = gtk_pixmap_new (gdk_pixmap, gdk_pixmap_mask);
5472   gtk_fixed_put (GTK_FIXED (fixed), pixmap, px,py);
5473   gtk_widget_show (pixmap);
5474
5475   gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px,py);
5476
5477
5478   gtk_signal_connect (GTK_OBJECT (window), "button_press_event",
5479                       GTK_SIGNAL_FUNC (shape_pressed),NULL);
5480   gtk_signal_connect (GTK_OBJECT (window), "button_release_event",
5481                       GTK_SIGNAL_FUNC (shape_released),NULL);
5482   gtk_signal_connect (GTK_OBJECT (window), "motion_notify_event",
5483                       GTK_SIGNAL_FUNC (shape_motion),NULL);
5484
5485   icon_pos = g_new (CursorOffset, 1);
5486   gtk_object_set_user_data(GTK_OBJECT(window), icon_pos);
5487
5488   gtk_widget_set_uposition (window, x, y);
5489   gtk_widget_show (window);
5490
5491   return window;
5492 }
5493
5494 void
5495 create_shapes (void)
5496 {
5497   /* Variables used by the Drag/Drop and Shape Window demos */
5498   static GtkWidget *modeller = NULL;
5499   static GtkWidget *sheets = NULL;
5500   static GtkWidget *rings = NULL;
5501
5502   root_win = gdk_window_foreign_new (GDK_ROOT_WINDOW ());
5503
5504   if (!modeller)
5505     {
5506       modeller = shape_create_icon ("Modeller.xpm",
5507                                     440, 140, 0,0, GTK_WINDOW_POPUP);
5508
5509       gtk_signal_connect (GTK_OBJECT (modeller), "destroy",
5510                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5511                           &modeller);
5512     }
5513   else
5514     gtk_widget_destroy (modeller);
5515
5516   if (!sheets)
5517     {
5518       sheets = shape_create_icon ("FilesQueue.xpm",
5519                                   580, 170, 0,0, GTK_WINDOW_POPUP);
5520
5521       gtk_signal_connect (GTK_OBJECT (sheets), "destroy",
5522                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5523                           &sheets);
5524
5525     }
5526   else
5527     gtk_widget_destroy (sheets);
5528
5529   if (!rings)
5530     {
5531       rings = shape_create_icon ("3DRings.xpm",
5532                                  460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
5533
5534       gtk_signal_connect (GTK_OBJECT (rings), "destroy",
5535                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5536                           &rings);
5537     }
5538   else
5539     gtk_widget_destroy (rings);
5540 }
5541
5542 void
5543 create_wmhints (void)
5544 {
5545   static GtkWidget *window = NULL;
5546   GtkWidget *label;
5547   GtkWidget *separator;
5548   GtkWidget *button;
5549   GtkWidget *box1;
5550   GtkWidget *box2;
5551
5552   GdkBitmap *circles;
5553
5554   if (!window)
5555     {
5556       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5557
5558       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5559                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5560                           &window);
5561
5562       gtk_window_set_title (GTK_WINDOW (window), "WM Hints");
5563       gtk_container_border_width (GTK_CONTAINER (window), 0);
5564
5565       gtk_widget_realize (window);
5566
5567       circles = gdk_bitmap_create_from_data (window->window,
5568                                              circles_bits,
5569                                              circles_width,
5570                                              circles_height);
5571       gdk_window_set_icon (window->window, NULL,
5572                            circles, circles);
5573
5574       gdk_window_set_icon_name (window->window, "WMHints Test Icon");
5575
5576       gdk_window_set_decorations (window->window, GDK_DECOR_ALL | GDK_DECOR_MENU);
5577       gdk_window_set_functions (window->window, GDK_FUNC_ALL | GDK_FUNC_RESIZE);
5578
5579       box1 = gtk_vbox_new (FALSE, 0);
5580       gtk_container_add (GTK_CONTAINER (window), box1);
5581       gtk_widget_show (box1);
5582
5583       label = gtk_label_new ("Try iconizing me!");
5584       gtk_widget_set_usize (label, 150, 50);
5585       gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
5586       gtk_widget_show (label);
5587
5588
5589       separator = gtk_hseparator_new ();
5590       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5591       gtk_widget_show (separator);
5592
5593
5594       box2 = gtk_vbox_new (FALSE, 10);
5595       gtk_container_border_width (GTK_CONTAINER (box2), 10);
5596       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5597       gtk_widget_show (box2);
5598
5599
5600       button = gtk_button_new_with_label ("close");
5601
5602       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5603                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
5604                                  GTK_OBJECT (window));
5605
5606       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5607       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5608       gtk_widget_grab_default (button);
5609       gtk_widget_show (button);
5610     }
5611
5612   if (!GTK_WIDGET_VISIBLE (window))
5613     gtk_widget_show (window);
5614   else
5615     gtk_widget_destroy (window);
5616 }
5617
5618 /*
5619  * Progress Bar
5620  */
5621 static int progress_timer = 0;
5622
5623 gint
5624 progress_timeout (gpointer data)
5625 {
5626   gfloat new_val;
5627
5628   new_val = GTK_PROGRESS_BAR (data)->percentage;
5629   if (new_val >= 1.0)
5630     new_val = 0.0;
5631   new_val += 0.02;
5632
5633   gtk_progress_bar_update (GTK_PROGRESS_BAR (data), new_val);
5634
5635   return TRUE;
5636 }
5637
5638 static void
5639 destroy_progress (GtkWidget  *widget,
5640                   GtkWidget **window)
5641 {
5642   gtk_timeout_remove (progress_timer);
5643   progress_timer = 0;
5644   *window = NULL;
5645 }
5646
5647 void
5648 create_progress_bar (void)
5649 {
5650   static GtkWidget *window = NULL;
5651   GtkWidget *button;
5652   GtkWidget *vbox;
5653   GtkWidget *pbar;
5654   GtkWidget *label;
5655   GtkTooltips *tooltips;
5656
5657   if (!window)
5658     {
5659       window = gtk_dialog_new ();
5660
5661       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5662                           GTK_SIGNAL_FUNC(destroy_progress),
5663                           &window);
5664
5665       gtk_window_set_title (GTK_WINDOW (window), "dialog");
5666       gtk_container_border_width (GTK_CONTAINER (window), 0);
5667
5668       tooltips = gtk_tooltips_new();
5669
5670       vbox = gtk_vbox_new (FALSE, 5);
5671       gtk_container_border_width (GTK_CONTAINER (vbox), 10);
5672       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
5673                           vbox, TRUE, TRUE, 0);
5674       gtk_widget_show (vbox);
5675
5676       label = gtk_label_new ("progress...");
5677       gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
5678       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
5679       gtk_widget_show (label);
5680
5681       pbar = gtk_progress_bar_new ();
5682       gtk_widget_set_events (pbar, GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK);
5683       gtk_widget_set_usize (pbar, 200, 20);
5684       gtk_box_pack_start (GTK_BOX (vbox), pbar, TRUE, TRUE, 0);
5685       gtk_widget_show (pbar);
5686       gtk_tooltips_set_tip (tooltips, pbar, "Countdown is progressing yet!", "Secret!");
5687       gtk_tooltips_set_delay (tooltips, 0);
5688
5689       progress_timer = gtk_timeout_add (100, progress_timeout, pbar);
5690
5691       button = gtk_button_new_with_label ("close");
5692       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5693                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
5694                                  GTK_OBJECT (window));
5695       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5696       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5697                           button, TRUE, TRUE, 0);
5698       gtk_widget_grab_default (button);
5699       gtk_widget_show (button);
5700     }
5701
5702   if (!GTK_WIDGET_VISIBLE (window))
5703     gtk_widget_show (window);
5704   else
5705     gtk_widget_destroy (window);
5706 }
5707
5708
5709 /*
5710  * Color Preview
5711  */
5712 static int color_idle = 0;
5713
5714 gint
5715 color_idle_func (GtkWidget *preview)
5716 {
5717   static int count = 1;
5718   guchar buf[768];
5719   int i, j, k;
5720
5721   for (i = 0; i < 256; i++)
5722     {
5723       for (j = 0, k = 0; j < 256; j++)
5724         {
5725           buf[k+0] = i + count;
5726           buf[k+1] = 0;
5727           buf[k+2] = j + count;
5728           k += 3;
5729         }
5730
5731       gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
5732     }
5733
5734   count += 1;
5735
5736   gtk_widget_draw (preview, NULL);
5737
5738   return TRUE;
5739 }
5740
5741 static void
5742 color_preview_destroy (GtkWidget  *widget,
5743                        GtkWidget **window)
5744 {
5745   gtk_idle_remove (color_idle);
5746   color_idle = 0;
5747
5748   *window = NULL;
5749 }
5750
5751 void
5752 create_color_preview (void)
5753 {
5754   static GtkWidget *window = NULL;
5755   GtkWidget *preview;
5756   guchar buf[768];
5757   int i, j, k;
5758
5759   if (!window)
5760     {
5761       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5762
5763       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5764                           GTK_SIGNAL_FUNC(color_preview_destroy),
5765                           &window);
5766
5767       gtk_window_set_title (GTK_WINDOW (window), "test");
5768       gtk_container_border_width (GTK_CONTAINER (window), 10);
5769
5770       preview = gtk_preview_new (GTK_PREVIEW_COLOR);
5771       gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
5772       gtk_container_add (GTK_CONTAINER (window), preview);
5773       gtk_widget_show (preview);
5774
5775       for (i = 0; i < 256; i++)
5776         {
5777           for (j = 0, k = 0; j < 256; j++)
5778             {
5779               buf[k+0] = i;
5780               buf[k+1] = 0;
5781               buf[k+2] = j;
5782               k += 3;
5783             }
5784
5785           gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
5786         }
5787
5788       color_idle = gtk_idle_add ((GtkFunction) color_idle_func, preview);
5789     }
5790
5791   if (!GTK_WIDGET_VISIBLE (window))
5792     gtk_widget_show (window);
5793   else
5794     gtk_widget_destroy (window);
5795 }
5796
5797
5798 /*
5799  * Gray Preview
5800  */
5801 static int gray_idle = 0;
5802
5803 gint
5804 gray_idle_func (GtkWidget *preview)
5805 {
5806   static int count = 1;
5807   guchar buf[256];
5808   int i, j;
5809
5810   for (i = 0; i < 256; i++)
5811     {
5812       for (j = 0; j < 256; j++)
5813         buf[j] = i + j + count;
5814
5815       gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
5816     }
5817
5818   count += 1;
5819
5820   gtk_widget_draw (preview, NULL);
5821
5822   return TRUE;
5823 }
5824
5825 static void
5826 gray_preview_destroy (GtkWidget  *widget,
5827                       GtkWidget **window)
5828 {
5829   gtk_idle_remove (gray_idle);
5830   gray_idle = 0;
5831
5832   *window = NULL;
5833 }
5834
5835 void
5836 create_gray_preview (void)
5837 {
5838   static GtkWidget *window = NULL;
5839   GtkWidget *preview;
5840   guchar buf[256];
5841   int i, j;
5842
5843   if (!window)
5844     {
5845       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5846
5847       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5848                           GTK_SIGNAL_FUNC(gray_preview_destroy),
5849                           &window);
5850
5851       gtk_window_set_title (GTK_WINDOW (window), "test");
5852       gtk_container_border_width (GTK_CONTAINER (window), 10);
5853
5854       preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
5855       gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
5856       gtk_container_add (GTK_CONTAINER (window), preview);
5857       gtk_widget_show (preview);
5858
5859       for (i = 0; i < 256; i++)
5860         {
5861           for (j = 0; j < 256; j++)
5862             buf[j] = i + j;
5863
5864           gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
5865         }
5866
5867       gray_idle = gtk_idle_add ((GtkFunction) gray_idle_func, preview);
5868     }
5869
5870   if (!GTK_WIDGET_VISIBLE (window))
5871     gtk_widget_show (window);
5872   else
5873     gtk_widget_destroy (window);
5874 }
5875
5876
5877 /*
5878  * Selection Test
5879  */
5880 void
5881 selection_test_received (GtkWidget *list, GtkSelectionData *data)
5882 {
5883   GdkAtom *atoms;
5884   GtkWidget *list_item;
5885   GList *item_list;
5886   int i, l;
5887
5888   if (data->length < 0)
5889     {
5890       g_print ("Selection retrieval failed\n");
5891       return;
5892     }
5893   if (data->type != GDK_SELECTION_TYPE_ATOM)
5894     {
5895       g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
5896       return;
5897     }
5898
5899   /* Clear out any current list items */
5900
5901   gtk_list_clear_items (GTK_LIST(list), 0, -1);
5902
5903   /* Add new items to list */
5904
5905   atoms = (GdkAtom *)data->data;
5906
5907   item_list = NULL;
5908   l = data->length / sizeof (GdkAtom);
5909   for (i = 0; i < l; i++)
5910     {
5911       char *name;
5912       name = gdk_atom_name (atoms[i]);
5913       if (name != NULL)
5914         {
5915           list_item = gtk_list_item_new_with_label (name);
5916           g_free (name);
5917         }
5918       else
5919         list_item = gtk_list_item_new_with_label ("(bad atom)");
5920
5921       gtk_widget_show (list_item);
5922       item_list = g_list_append (item_list, list_item);
5923     }
5924
5925   gtk_list_append_items (GTK_LIST (list), item_list);
5926
5927   return;
5928 }
5929
5930 void
5931 selection_test_get_targets (GtkWidget *widget, GtkWidget *list)
5932 {
5933   static GdkAtom targets_atom = GDK_NONE;
5934
5935   if (targets_atom == GDK_NONE)
5936     targets_atom = gdk_atom_intern ("TARGETS", FALSE);
5937
5938   gtk_selection_convert (list, GDK_SELECTION_PRIMARY, targets_atom,
5939                          GDK_CURRENT_TIME);
5940 }
5941
5942 void
5943 create_selection_test (void)
5944 {
5945   static GtkWidget *window = NULL;
5946   GtkWidget *button;
5947   GtkWidget *vbox;
5948   GtkWidget *scrolled_win;
5949   GtkWidget *list;
5950   GtkWidget *label;
5951
5952   if (!window)
5953     {
5954       window = gtk_dialog_new ();
5955
5956       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5957                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5958                           &window);
5959
5960       gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
5961       gtk_container_border_width (GTK_CONTAINER (window), 0);
5962
5963       /* Create the list */
5964
5965       vbox = gtk_vbox_new (FALSE, 5);
5966       gtk_container_border_width (GTK_CONTAINER (vbox), 10);
5967       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox,
5968                           TRUE, TRUE, 0);
5969       gtk_widget_show (vbox);
5970
5971       label = gtk_label_new ("Gets available targets for current selection");
5972       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
5973       gtk_widget_show (label);
5974
5975       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
5976       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
5977                                       GTK_POLICY_AUTOMATIC,
5978                                       GTK_POLICY_AUTOMATIC);
5979       gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
5980       gtk_widget_set_usize (scrolled_win, 100, 200);
5981       gtk_widget_show (scrolled_win);
5982
5983       list = gtk_list_new ();
5984       gtk_container_add (GTK_CONTAINER (scrolled_win), list);
5985
5986       gtk_signal_connect (GTK_OBJECT(list), "selection_received",
5987                           GTK_SIGNAL_FUNC (selection_test_received), NULL);
5988       gtk_widget_show (list);
5989
5990       /* .. And create some buttons */
5991       button = gtk_button_new_with_label ("Get Targets");
5992       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5993                           button, TRUE, TRUE, 0);
5994
5995       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5996                           GTK_SIGNAL_FUNC (selection_test_get_targets), list);
5997       gtk_widget_show (button);
5998
5999       button = gtk_button_new_with_label ("Quit");
6000       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6001                           button, TRUE, TRUE, 0);
6002
6003       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6004                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
6005                                  GTK_OBJECT (window));
6006       gtk_widget_show (button);
6007     }
6008
6009   if (!GTK_WIDGET_VISIBLE (window))
6010     gtk_widget_show (window);
6011   else
6012     gtk_widget_destroy (window);
6013 }
6014
6015
6016 /*
6017  * Gamma Curve
6018  */
6019 void
6020 create_gamma_curve (void)
6021 {
6022   static GtkWidget *window = NULL, *curve;
6023   static int count = 0;
6024   gfloat vec[256];
6025   gint max;
6026   gint i;
6027
6028   if (!window)
6029     {
6030       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6031       gtk_window_set_title (GTK_WINDOW (window), "test");
6032       gtk_container_border_width (GTK_CONTAINER (window), 10);
6033
6034       gtk_signal_connect (GTK_OBJECT (window), "destroy",
6035                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6036                           &window);
6037
6038       curve = gtk_gamma_curve_new ();
6039       gtk_container_add (GTK_CONTAINER (window), curve);
6040       gtk_widget_show (curve);
6041     }
6042
6043   max = 127 + (count % 2)*128;
6044   gtk_curve_set_range (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
6045                        0, max, 0, max);
6046   for (i = 0; i < max; ++i)
6047     vec[i] = (127 / sqrt (max)) * sqrt (i);
6048   gtk_curve_set_vector (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
6049                         max, vec);
6050
6051   if (!GTK_WIDGET_VISIBLE (window))
6052     gtk_widget_show (window);
6053   else if (count % 4 == 3)
6054     {
6055       gtk_widget_destroy (window);
6056       window = NULL;
6057     }
6058
6059   ++count;
6060 }
6061
6062 static int scroll_test_pos = 0.0;
6063 static GdkGC *scroll_test_gc = NULL;
6064
6065 static gint
6066 scroll_test_expose (GtkWidget *widget, GdkEventExpose *event,
6067                     GtkAdjustment *adj)
6068 {
6069   gint i,j;
6070   gint imin, imax, jmin, jmax;
6071
6072   imin = (event->area.x) / 10;
6073   imax = (event->area.x + event->area.width + 9) / 10;
6074
6075   jmin = ((int)adj->value + event->area.y) / 10;
6076   jmax = ((int)adj->value + event->area.y + event->area.height + 9) / 10;
6077
6078   gdk_window_clear_area (widget->window,
6079                          event->area.x, event->area.y,
6080                          event->area.width, event->area.height);
6081
6082   for (i=imin; i<imax; i++)
6083     for (j=jmin; j<jmax; j++)
6084       if ((i+j) % 2)
6085         gdk_draw_rectangle (widget->window,
6086                             widget->style->black_gc,
6087                             TRUE,
6088                             10*i, 10*j - (int)adj->value, 1+i%10, 1+j%10);
6089
6090   return TRUE;
6091 }
6092
6093 static void
6094 scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
6095                        GtkAdjustment *adj)
6096 {
6097   adj->page_increment = 0.9 * widget->allocation.height;
6098   adj->page_size = widget->allocation.height;
6099
6100   gtk_signal_emit_by_name (GTK_OBJECT (adj), "changed");
6101 }
6102
6103 static void
6104 scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
6105 {
6106   gint source_min = (int)adj->value - scroll_test_pos;
6107   gint source_max = source_min + widget->allocation.height;
6108   gint dest_min = 0;
6109   gint dest_max = widget->allocation.height;
6110   GdkRectangle rect;
6111   GdkEvent *event;
6112
6113   scroll_test_pos = adj->value;
6114
6115   if (!GTK_WIDGET_DRAWABLE (widget))
6116     return;
6117
6118   if (source_min < 0)
6119     {
6120       rect.x = 0;
6121       rect.y = 0;
6122       rect.width = widget->allocation.width;
6123       rect.height = -source_min;
6124       if (rect.height > widget->allocation.height)
6125         rect.height = widget->allocation.height;
6126
6127       source_min = 0;
6128       dest_min = rect.height;
6129     }
6130   else
6131     {
6132       rect.x = 0;
6133       rect.y = 2*widget->allocation.height - source_max;
6134       if (rect.y < 0)
6135         rect.y = 0;
6136       rect.width = widget->allocation.width;
6137       rect.height = widget->allocation.height - rect.y;
6138
6139       source_max = widget->allocation.height;
6140       dest_max = rect.y;
6141     }
6142
6143   if (source_min != source_max)
6144     {
6145       if (scroll_test_gc == NULL)
6146         {
6147           scroll_test_gc = gdk_gc_new (widget->window);
6148           gdk_gc_set_exposures (scroll_test_gc, TRUE);
6149         }
6150
6151       gdk_draw_pixmap (widget->window,
6152                        scroll_test_gc,
6153                        widget->window,
6154                        0, source_min,
6155                        0, dest_min,
6156                        widget->allocation.width,
6157                        source_max - source_min);
6158
6159       /* Make sure graphics expose events are processed before scrolling
6160        * again */
6161
6162       while ((event = gdk_event_get_graphics_expose (widget->window)) != NULL)
6163         {
6164           gtk_widget_event (widget, event);
6165           if (event->expose.count == 0)
6166             {
6167               gdk_event_free (event);
6168               break;
6169             }
6170           gdk_event_free (event);
6171         }
6172     }
6173
6174
6175   if (rect.height != 0)
6176     gtk_widget_draw (widget, &rect);
6177 }
6178
6179
6180 void
6181 create_scroll_test (void)
6182 {
6183   static GtkWidget *window = NULL;
6184   GtkWidget *hbox;
6185   GtkWidget *drawing_area;
6186   GtkWidget *scrollbar;
6187   GtkWidget *button;
6188   GtkAdjustment *adj;
6189
6190   if (!window)
6191     {
6192       window = gtk_dialog_new ();
6193
6194       gtk_signal_connect (GTK_OBJECT (window), "destroy",
6195                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6196                           &window);
6197
6198       gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
6199       gtk_container_border_width (GTK_CONTAINER (window), 0);
6200
6201       hbox = gtk_hbox_new (FALSE, 0);
6202       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox,
6203                           TRUE, TRUE, 0);
6204       gtk_widget_show (hbox);
6205
6206       drawing_area = gtk_drawing_area_new ();
6207       gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 200, 200);
6208       gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
6209       gtk_widget_show (drawing_area);
6210
6211       gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK);
6212
6213       adj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0));
6214       scroll_test_pos = 0.0;
6215
6216       scrollbar = gtk_vscrollbar_new (adj);
6217       gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
6218       gtk_widget_show (scrollbar);
6219
6220       gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
6221                           GTK_SIGNAL_FUNC (scroll_test_expose), adj);
6222       gtk_signal_connect (GTK_OBJECT (drawing_area), "configure_event",
6223                           GTK_SIGNAL_FUNC (scroll_test_configure), adj);
6224
6225
6226       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6227                           GTK_SIGNAL_FUNC (scroll_test_adjustment_changed),
6228                           drawing_area);
6229
6230       /* .. And create some buttons */
6231
6232       button = gtk_button_new_with_label ("Quit");
6233       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6234                           button, TRUE, TRUE, 0);
6235
6236       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6237                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
6238                                  GTK_OBJECT (window));
6239       gtk_widget_show (button);
6240     }
6241
6242   if (!GTK_WIDGET_VISIBLE (window))
6243     gtk_widget_show (window);
6244   else
6245     gtk_widget_destroy (window);
6246 }
6247
6248 /*
6249  * Timeout Test
6250  */
6251 static int timer = 0;
6252
6253 gint
6254 timeout_test (GtkWidget *label)
6255 {
6256   static int count = 0;
6257   static char buffer[32];
6258
6259   sprintf (buffer, "count: %d", ++count);
6260   gtk_label_set (GTK_LABEL (label), buffer);
6261
6262   return TRUE;
6263 }
6264
6265 void
6266 start_timeout_test (GtkWidget *widget,
6267                     GtkWidget *label)
6268 {
6269   if (!timer)
6270     {
6271       timer = gtk_timeout_add (100, (GtkFunction) timeout_test, label);
6272     }
6273 }
6274
6275 void
6276 stop_timeout_test (GtkWidget *widget,
6277                    gpointer   data)
6278 {
6279   if (timer)
6280     {
6281       gtk_timeout_remove (timer);
6282       timer = 0;
6283     }
6284 }
6285
6286 void
6287 destroy_timeout_test (GtkWidget  *widget,
6288                       GtkWidget **window)
6289 {
6290   stop_timeout_test (NULL, NULL);
6291
6292   *window = NULL;
6293 }
6294
6295 void
6296 create_timeout_test (void)
6297 {
6298   static GtkWidget *window = NULL;
6299   GtkWidget *button;
6300   GtkWidget *label;
6301
6302   if (!window)
6303     {
6304       window = gtk_dialog_new ();
6305
6306       gtk_signal_connect (GTK_OBJECT (window), "destroy",
6307                           GTK_SIGNAL_FUNC(destroy_timeout_test),
6308                           &window);
6309
6310       gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
6311       gtk_container_border_width (GTK_CONTAINER (window), 0);
6312
6313       label = gtk_label_new ("count: 0");
6314       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
6315       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
6316                           label, TRUE, TRUE, 0);
6317       gtk_widget_show (label);
6318
6319       button = gtk_button_new_with_label ("close");
6320       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6321                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
6322                                  GTK_OBJECT (window));
6323       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6324       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6325                           button, TRUE, TRUE, 0);
6326       gtk_widget_grab_default (button);
6327       gtk_widget_show (button);
6328
6329       button = gtk_button_new_with_label ("start");
6330       gtk_signal_connect (GTK_OBJECT (button), "clicked",
6331                           GTK_SIGNAL_FUNC(start_timeout_test),
6332                           label);
6333       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6334       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6335                           button, TRUE, TRUE, 0);
6336       gtk_widget_show (button);
6337
6338       button = gtk_button_new_with_label ("stop");
6339       gtk_signal_connect (GTK_OBJECT (button), "clicked",
6340                           GTK_SIGNAL_FUNC(stop_timeout_test),
6341                           NULL);
6342       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6343       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6344                           button, TRUE, TRUE, 0);
6345       gtk_widget_show (button);
6346     }
6347
6348   if (!GTK_WIDGET_VISIBLE (window))
6349     gtk_widget_show (window);
6350   else
6351     gtk_widget_destroy (window);
6352 }
6353
6354
6355 /*
6356  * Idle Test
6357  */
6358 static int idle = 0;
6359
6360 gint
6361 idle_test (GtkWidget *label)
6362 {
6363   static int count = 0;
6364   static char buffer[32];
6365
6366   sprintf (buffer, "count: %d", ++count);
6367   gtk_label_set (GTK_LABEL (label), buffer);
6368
6369   return TRUE;
6370 }
6371
6372 void
6373 start_idle_test (GtkWidget *widget,
6374                  GtkWidget *label)
6375 {
6376   if (!idle)
6377     {
6378       idle = gtk_idle_add ((GtkFunction) idle_test, label);
6379     }
6380 }
6381
6382 void
6383 stop_idle_test (GtkWidget *widget,
6384                 gpointer   data)
6385 {
6386   if (idle)
6387     {
6388       gtk_idle_remove (idle);
6389       idle = 0;
6390     }
6391 }
6392
6393 void
6394 destroy_idle_test (GtkWidget  *widget,
6395                    GtkWidget **window)
6396 {
6397   stop_idle_test (NULL, NULL);
6398
6399   *window = NULL;
6400 }
6401
6402 void
6403 create_idle_test (void)
6404 {
6405   static GtkWidget *window = NULL;
6406   GtkWidget *button;
6407   GtkWidget *label;
6408
6409   if (!window)
6410     {
6411       window = gtk_dialog_new ();
6412
6413       gtk_signal_connect (GTK_OBJECT (window), "destroy",
6414                           GTK_SIGNAL_FUNC(destroy_idle_test),
6415                           &window);
6416
6417       gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
6418       gtk_container_border_width (GTK_CONTAINER (window), 0);
6419
6420       label = gtk_label_new ("count: 0");
6421       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
6422       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
6423                           label, TRUE, TRUE, 0);
6424       gtk_widget_show (label);
6425
6426       button = gtk_button_new_with_label ("close");
6427       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6428                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
6429                                  GTK_OBJECT (window));
6430       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6431       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6432                           button, TRUE, TRUE, 0);
6433       gtk_widget_grab_default (button);
6434       gtk_widget_show (button);
6435
6436       button = gtk_button_new_with_label ("start");
6437       gtk_signal_connect (GTK_OBJECT (button), "clicked",
6438                           GTK_SIGNAL_FUNC(start_idle_test),
6439                           label);
6440       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6441       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6442                           button, TRUE, TRUE, 0);
6443       gtk_widget_show (button);
6444
6445       button = gtk_button_new_with_label ("stop");
6446       gtk_signal_connect (GTK_OBJECT (button), "clicked",
6447                           GTK_SIGNAL_FUNC(stop_idle_test),
6448                           NULL);
6449       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6450       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6451                           button, TRUE, TRUE, 0);
6452       gtk_widget_show (button);
6453     }
6454
6455   if (!GTK_WIDGET_VISIBLE (window))
6456     gtk_widget_show (window);
6457   else
6458     gtk_widget_destroy (window);
6459 }
6460
6461 void
6462 reload_rc_file (void)
6463 {
6464   GList *toplevels;
6465
6466   if (gtk_rc_reparse_all ())
6467     {
6468       toplevels = gdk_window_get_toplevels();
6469       while (toplevels)
6470         {
6471           GtkWidget *widget;
6472           gdk_window_get_user_data (toplevels->data, (gpointer *)&widget);
6473
6474           if (widget)
6475             gtk_widget_reset_rc_styles (widget);
6476
6477           toplevels = toplevels->next;
6478         }
6479       g_list_free (toplevels);
6480     }
6481 }
6482
6483 void
6484 reload_all_rc_files (void)
6485 {
6486   static GdkAtom atom_rcfiles = GDK_NONE;
6487
6488   GdkEventClient sev;
6489   int i;
6490
6491   if (!atom_rcfiles)
6492     atom_rcfiles = gdk_atom_intern("_GTK_READ_RCFILES", FALSE);
6493
6494   for(i = 0; i < 5; i++)
6495     sev.data.l[i] = 0;
6496   sev.data_format = 32;
6497   sev.message_type = atom_rcfiles;
6498   gdk_event_send_clientmessage_toall ((GdkEvent *) &sev);
6499 }
6500
6501 void
6502 create_rc_file (void)
6503 {
6504   static GtkWidget *window = NULL;
6505   GtkWidget *button;
6506
6507   if (!window)
6508     {
6509       window = gtk_dialog_new ();
6510
6511       gtk_signal_connect (GTK_OBJECT (window), "destroy",
6512                           GTK_SIGNAL_FUNC(destroy_idle_test),
6513                           &window);
6514
6515       gtk_window_set_title (GTK_WINDOW (window), "Reload Rc file");
6516       gtk_container_border_width (GTK_CONTAINER (window), 0);
6517
6518       button = gtk_button_new_with_label ("Reload");
6519       gtk_signal_connect (GTK_OBJECT (button), "clicked",
6520                           GTK_SIGNAL_FUNC(reload_rc_file), NULL);
6521       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6522       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6523                           button, TRUE, TRUE, 0);
6524       gtk_widget_grab_default (button);
6525       gtk_widget_show (button);
6526
6527       button = gtk_button_new_with_label ("Reload All");
6528       gtk_signal_connect (GTK_OBJECT (button), "clicked",
6529                           GTK_SIGNAL_FUNC(reload_all_rc_files), NULL);
6530       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6531       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6532                           button, TRUE, TRUE, 0);
6533       gtk_widget_show (button);
6534
6535       button = gtk_button_new_with_label ("Close");
6536       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6537                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
6538                                  GTK_OBJECT (window));
6539       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6540       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6541                           button, TRUE, TRUE, 0);
6542       gtk_widget_show (button);
6543
6544     }
6545
6546   if (!GTK_WIDGET_VISIBLE (window))
6547     gtk_widget_show (window);
6548   else
6549     gtk_widget_destroy (window);
6550 }
6551
6552 /*
6553  * Test of recursive mainloop
6554  */
6555
6556 void
6557 mainloop_destroyed (GtkWidget *w, GtkWidget **window)
6558 {
6559   *window = NULL;
6560   gtk_main_quit ();
6561 }
6562
6563 void
6564 create_mainloop (void)
6565 {
6566   static GtkWidget *window = NULL;
6567   GtkWidget *label;
6568   GtkWidget *button;
6569
6570   if (!window)
6571     {
6572       window = gtk_dialog_new ();
6573
6574       gtk_window_set_title (GTK_WINDOW (window), "Test Main Loop");
6575
6576       gtk_signal_connect (GTK_OBJECT (window), "destroy",
6577                           GTK_SIGNAL_FUNC(mainloop_destroyed),
6578                           &window);
6579
6580       label = gtk_label_new ("In recursive main loop...");
6581       gtk_misc_set_padding (GTK_MISC(label), 20, 20);
6582
6583       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), label,
6584                           TRUE, TRUE, 0);
6585       gtk_widget_show (label);
6586
6587       button = gtk_button_new_with_label ("Leave");
6588       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button,
6589                           FALSE, TRUE, 0);
6590
6591       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6592                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
6593                                  GTK_OBJECT (window));
6594
6595       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6596       gtk_widget_grab_default (button);
6597
6598       gtk_widget_show (button);
6599     }
6600
6601   if (!GTK_WIDGET_VISIBLE (window))
6602     {
6603       gtk_widget_show (window);
6604
6605       g_print ("create_mainloop: start\n");
6606       gtk_main ();
6607       g_print ("create_mainloop: done\n");
6608     }
6609   else
6610     gtk_widget_destroy (window);
6611 }
6612
6613
6614 /*
6615  * Main Window and Exit
6616  */
6617 void
6618 do_exit (GtkWidget *widget, GtkWidget *window)
6619 {
6620   gtk_widget_destroy (window);
6621   gtk_main_quit ();
6622 }
6623
6624 void
6625 create_main_window (void)
6626 {
6627   struct {
6628     char *label;
6629     void (*func) ();
6630   } buttons[] =
6631     {
6632       { "button box", create_button_box },
6633       { "buttons", create_buttons },
6634       { "check buttons", create_check_buttons },
6635       { "clist", create_clist},
6636       { "color selection", create_color_selection },
6637       { "ctree", create_ctree },
6638       { "cursors", create_cursors },
6639       { "dialog", create_dialog },
6640       { "dnd", create_dnd },
6641       { "entry", create_entry },
6642       { "file selection", create_file_selection },
6643       { "gamma curve", create_gamma_curve },
6644       { "handle box", create_handle_box },
6645       { "list", create_list },
6646       { "menus", create_menus },
6647       { "miscellaneous", NULL },
6648       { "notebook", create_notebook },
6649       { "panes", create_panes },
6650       { "pixmap", create_pixmap },
6651       { "preview color", create_color_preview },
6652       { "preview gray", create_gray_preview },
6653       { "progress bar", create_progress_bar },
6654       { "radio buttons", create_radio_buttons },
6655       { "range controls", create_range_controls },
6656       { "rc file", create_rc_file },
6657       { "reparent", create_reparent },
6658       { "rulers", create_rulers },
6659       { "scrolled windows", create_scrolled_windows },
6660       { "shapes", create_shapes },
6661       { "spinbutton", create_spins },
6662       { "statusbar", create_statusbar },
6663       { "test idle", create_idle_test },
6664       { "test mainloop", create_mainloop },
6665       { "test scrolling", create_scroll_test },
6666       { "test selection", create_selection_test },
6667       { "test timeout", create_timeout_test },
6668       { "text", create_text },
6669       { "toggle buttons", create_toggle_buttons },
6670       { "toolbar", create_toolbar },
6671       { "tooltips", create_tooltips },
6672       { "tree", create_tree_mode_window},
6673       { "WM hints", create_wmhints },
6674     };
6675   int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
6676   GtkWidget *window;
6677   GtkWidget *box1;
6678   GtkWidget *box2;
6679   GtkWidget *scrolled_window;
6680   GtkWidget *button;
6681   GtkWidget *label;
6682   gchar buffer[64];
6683   GtkWidget *separator;
6684   int i;
6685
6686   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6687   gtk_window_set_policy (GTK_WINDOW (window), FALSE, FALSE, FALSE);
6688   gtk_widget_set_name (window, "main window");
6689   gtk_widget_set_usize (window, 200, 400);
6690   gtk_widget_set_uposition (window, 20, 20);
6691
6692   gtk_signal_connect (GTK_OBJECT (window), "destroy",
6693                       GTK_SIGNAL_FUNC(gtk_main_quit),
6694                       NULL);
6695   gtk_signal_connect (GTK_OBJECT (window), "delete-event",
6696                       GTK_SIGNAL_FUNC (gtk_false),
6697                       NULL);
6698
6699   box1 = gtk_vbox_new (FALSE, 0);
6700   gtk_container_add (GTK_CONTAINER (window), box1);
6701   gtk_widget_show (box1);
6702
6703   if (gtk_micro_version > 0)
6704     sprintf (buffer,
6705              "Gtk+ v%d.%d.%d",
6706              gtk_major_version,
6707              gtk_minor_version,
6708              gtk_micro_version);
6709   else
6710     sprintf (buffer,
6711              "Gtk+ v%d.%d",
6712              gtk_major_version,
6713              gtk_minor_version);
6714
6715   label = gtk_label_new (buffer);
6716   gtk_widget_show (label);
6717   gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
6718
6719   scrolled_window = gtk_scrolled_window_new (NULL, NULL);
6720   gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
6721   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
6722                                   GTK_POLICY_AUTOMATIC,
6723                                   GTK_POLICY_AUTOMATIC);
6724   GTK_WIDGET_UNSET_FLAGS (GTK_SCROLLED_WINDOW (scrolled_window)->vscrollbar, GTK_CAN_FOCUS);
6725   gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
6726   gtk_widget_show (scrolled_window);
6727
6728   box2 = gtk_vbox_new (FALSE, 0);
6729   gtk_container_border_width (GTK_CONTAINER (box2), 10);
6730   gtk_container_add (GTK_CONTAINER (scrolled_window), box2);
6731   gtk_container_set_focus_vadjustment (GTK_CONTAINER (box2),
6732                                        gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
6733   gtk_widget_show (box2);
6734
6735   for (i = 0; i < nbuttons; i++)
6736     {
6737       button = gtk_button_new_with_label (buttons[i].label);
6738       if (buttons[i].func)
6739         gtk_signal_connect (GTK_OBJECT (button),
6740                             "clicked",
6741                             GTK_SIGNAL_FUNC(buttons[i].func),
6742                             NULL);
6743       else
6744         gtk_widget_set_sensitive (button, FALSE);
6745       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6746       gtk_widget_show (button);
6747     }
6748
6749   separator = gtk_hseparator_new ();
6750   gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
6751   gtk_widget_show (separator);
6752
6753   box2 = gtk_vbox_new (FALSE, 10);
6754   gtk_container_border_width (GTK_CONTAINER (box2), 10);
6755   gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6756   gtk_widget_show (box2);
6757
6758   button = gtk_button_new_with_label ("close");
6759   gtk_signal_connect (GTK_OBJECT (button), "clicked",
6760                       GTK_SIGNAL_FUNC (do_exit),
6761                       window);
6762   gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6763   GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6764   gtk_widget_grab_default (button);
6765   gtk_widget_show (button);
6766
6767   gtk_widget_show (window);
6768 }
6769
6770 int
6771 main (int argc, char *argv[])
6772 {
6773   gtk_set_locale ();
6774
6775   gtk_init (&argc, &argv);
6776
6777 #ifdef HAVE_LIBGLE
6778   gle_init (&argc, &argv);
6779 #endif /* !HAVE_LIBGLE */
6780
6781   gtk_rc_parse ("testgtkrc");
6782
6783   create_main_window ();
6784
6785   gtk_main ();
6786
6787   return 0;
6788 }