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