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

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