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