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

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