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