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

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