Pileus Git - ~andy/gtk/blob - tests/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 Free
  16  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include "gtk.h"
  21 #include "../gdk/gdk.h"
  22 #include "../gdk/gdkx.h"
  23 #include "gtkhandlebox.h"
  24
  25 void
  26 destroy_window (GtkWidget  *widget,
  27                 GtkWidget **window)
  28 {
  29   *window = NULL;
  30 }
  31
  32 void
  33 button_window (GtkWidget *widget,
  34                GtkWidget *button)
  35 {
  36   if (!GTK_WIDGET_VISIBLE (button))
  37     gtk_widget_show (button);
  38   else
  39     gtk_widget_hide (button);
  40 }
  41
  42 void
  43 create_buttons ()
  44 {
  45   static GtkWidget *window = NULL;
  46   GtkWidget *box1;
  47   GtkWidget *box2;
  48   GtkWidget *table;
  49   GtkWidget *button[10];
  50   GtkWidget *separator;
  51
  52   if (!window)
  53     {
  54       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  55
  56       gtk_signal_connect (GTK_OBJECT (window), "destroy",
  57                           GTK_SIGNAL_FUNC(destroy_window),
  58                           &window);
  59       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
  60                           GTK_SIGNAL_FUNC(destroy_window),
  61                           &window);
  62
  63       gtk_window_set_title (GTK_WINDOW (window), "buttons");
  64       gtk_container_border_width (GTK_CONTAINER (window), 0);
  65
  66       box1 = gtk_vbox_new (FALSE, 0);
  67       gtk_container_add (GTK_CONTAINER (window), box1);
  68       gtk_widget_show (box1);
  69
  70
  71       table = gtk_table_new (3, 3, FALSE);
  72       gtk_table_set_row_spacings (GTK_TABLE (table), 5);
  73       gtk_table_set_col_spacings (GTK_TABLE (table), 5);
  74       gtk_container_border_width (GTK_CONTAINER (table), 10);
  75       gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
  76       gtk_widget_show (table);
  77
  78
  79       button[0] = gtk_button_new_with_label ("button1");
  80       button[1] = gtk_button_new_with_label ("button2");
  81       button[2] = gtk_button_new_with_label ("button3");
  82       button[3] = gtk_button_new_with_label ("button4");
  83       button[4] = gtk_button_new_with_label ("button5");
  84       button[5] = gtk_button_new_with_label ("button6");
  85       button[6] = gtk_button_new_with_label ("button7");
  86       button[7] = gtk_button_new_with_label ("button8");
  87       button[8] = gtk_button_new_with_label ("button9");
  88
  89       gtk_signal_connect (GTK_OBJECT (button[0]), "clicked",
  90                           GTK_SIGNAL_FUNC(button_window),
  91                           button[1]);
  92
  93       gtk_table_attach (GTK_TABLE (table), button[0], 0, 1, 0, 1,
  94                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
  95       gtk_widget_show (button[0]);
  96
  97       gtk_signal_connect (GTK_OBJECT (button[1]), "clicked",
  98                           GTK_SIGNAL_FUNC(button_window),
  99                           button[2]);
 100
 101       gtk_table_attach (GTK_TABLE (table), button[1], 1, 2, 1, 2,
 102                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 103       gtk_widget_show (button[1]);
 104
 105       gtk_signal_connect (GTK_OBJECT (button[2]), "clicked",
 106                           GTK_SIGNAL_FUNC(button_window),
 107                           button[3]);
 108       gtk_table_attach (GTK_TABLE (table), button[2], 2, 3, 2, 3,
 109                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 110       gtk_widget_show (button[2]);
 111
 112       gtk_signal_connect (GTK_OBJECT (button[3]), "clicked",
 113                           GTK_SIGNAL_FUNC(button_window),
 114                           button[4]);
 115       gtk_table_attach (GTK_TABLE (table), button[3], 0, 1, 2, 3,
 116                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 117       gtk_widget_show (button[3]);
 118
 119       gtk_signal_connect (GTK_OBJECT (button[4]), "clicked",
 120                           GTK_SIGNAL_FUNC(button_window),
 121                           button[5]);
 122       gtk_table_attach (GTK_TABLE (table), button[4], 2, 3, 0, 1,
 123                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 124       gtk_widget_show (button[4]);
 125
 126       gtk_signal_connect (GTK_OBJECT (button[5]), "clicked",
 127                           GTK_SIGNAL_FUNC(button_window),
 128                           button[6]);
 129       gtk_table_attach (GTK_TABLE (table), button[5], 1, 2, 2, 3,
 130                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 131       gtk_widget_show (button[5]);
 132
 133       gtk_signal_connect (GTK_OBJECT (button[6]), "clicked",
 134                           GTK_SIGNAL_FUNC(button_window),
 135                           button[7]);
 136       gtk_table_attach (GTK_TABLE (table), button[6], 1, 2, 0, 1,
 137                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 138       gtk_widget_show (button[6]);
 139
 140       gtk_signal_connect (GTK_OBJECT (button[7]), "clicked",
 141                           GTK_SIGNAL_FUNC(button_window),
 142                           button[8]);
 143       gtk_table_attach (GTK_TABLE (table), button[7], 2, 3, 1, 2,
 144                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 145       gtk_widget_show (button[7]);
 146
 147       gtk_signal_connect (GTK_OBJECT (button[8]), "clicked",
 148                           GTK_SIGNAL_FUNC(button_window),
 149                           button[0]);
 150       gtk_table_attach (GTK_TABLE (table), button[8], 0, 1, 1, 2,
 151                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 152       gtk_widget_show (button[8]);
 153
 154
 155       separator = gtk_hseparator_new ();
 156       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 157       gtk_widget_show (separator);
 158
 159
 160       box2 = gtk_vbox_new (FALSE, 10);
 161       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 162       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 163       gtk_widget_show (box2);
 164
 165
 166       button[9] = gtk_button_new_with_label ("close");
 167       gtk_signal_connect_object (GTK_OBJECT (button[9]), "clicked",
 168                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
 169                                  GTK_OBJECT (window));
 170       gtk_box_pack_start (GTK_BOX (box2), button[9], TRUE, TRUE, 0);
 171       GTK_WIDGET_SET_FLAGS (button[9], GTK_CAN_DEFAULT);
 172       gtk_widget_grab_default (button[9]);
 173       gtk_widget_show (button[9]);
 174     }
 175
 176   if (!GTK_WIDGET_VISIBLE (window))
 177     gtk_widget_show (window);
 178   else
 179     gtk_widget_destroy (window);
 180 }
 181
 182 void
 183 create_toggle_buttons ()
 184 {
 185   static GtkWidget *window = NULL;
 186   GtkWidget *box1;
 187   GtkWidget *box2;
 188   GtkWidget *button;
 189   GtkWidget *separator;
 190
 191   if (!window)
 192     {
 193       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 194
 195       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 196                           GTK_SIGNAL_FUNC(destroy_window),
 197                           &window);
 198       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
 199                           GTK_SIGNAL_FUNC(destroy_window),
 200                           &window);
 201
 202       gtk_window_set_title (GTK_WINDOW (window), "toggle buttons");
 203       gtk_container_border_width (GTK_CONTAINER (window), 0);
 204
 205
 206       box1 = gtk_vbox_new (FALSE, 0);
 207       gtk_container_add (GTK_CONTAINER (window), box1);
 208       gtk_widget_show (box1);
 209
 210
 211       box2 = gtk_vbox_new (FALSE, 10);
 212       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 213       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
 214       gtk_widget_show (box2);
 215
 216
 217       button = gtk_toggle_button_new_with_label ("button1");
 218       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 219       gtk_widget_show (button);
 220
 221       button = gtk_toggle_button_new_with_label ("button2");
 222       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 223       gtk_widget_show (button);
 224
 225       button = gtk_toggle_button_new_with_label ("button3");
 226       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 227       gtk_widget_show (button);
 228
 229
 230       separator = gtk_hseparator_new ();
 231       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 232       gtk_widget_show (separator);
 233
 234
 235       box2 = gtk_vbox_new (FALSE, 10);
 236       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 237       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 238       gtk_widget_show (box2);
 239
 240
 241       button = gtk_button_new_with_label ("close");
 242       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
 243                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
 244                                  GTK_OBJECT (window));
 245       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 246       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 247       gtk_widget_grab_default (button);
 248       gtk_widget_show (button);
 249     }
 250
 251   if (!GTK_WIDGET_VISIBLE (window))
 252     gtk_widget_show (window);
 253   else
 254     gtk_widget_destroy (window);
 255 }
 256
 257 void
 258 create_check_buttons ()
 259 {
 260   static GtkWidget *window = NULL;
 261   GtkWidget *box1;
 262   GtkWidget *box2;
 263   GtkWidget *button;
 264   GtkWidget *separator;
 265
 266   if (!window)
 267     {
 268       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 269
 270       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 271                           GTK_SIGNAL_FUNC(destroy_window),
 272                           &window);
 273       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
 274                           GTK_SIGNAL_FUNC(destroy_window),
 275                           &window);
 276
 277       gtk_window_set_title (GTK_WINDOW (window), "check buttons");
 278       gtk_container_border_width (GTK_CONTAINER (window), 0);
 279
 280
 281       box1 = gtk_vbox_new (FALSE, 0);
 282       gtk_container_add (GTK_CONTAINER (window), box1);
 283       gtk_widget_show (box1);
 284
 285
 286       box2 = gtk_vbox_new (FALSE, 10);
 287       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 288       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
 289       gtk_widget_show (box2);
 290
 291
 292       button = gtk_check_button_new_with_label ("button1");
 293       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 294       gtk_widget_show (button);
 295
 296       button = gtk_check_button_new_with_label ("button2");
 297       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 298       gtk_widget_show (button);
 299
 300       button = gtk_check_button_new_with_label ("button3");
 301       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 302       gtk_widget_show (button);
 303
 304
 305       separator = gtk_hseparator_new ();
 306       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 307       gtk_widget_show (separator);
 308
 309
 310       box2 = gtk_vbox_new (FALSE, 10);
 311       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 312       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 313       gtk_widget_show (box2);
 314
 315
 316       button = gtk_button_new_with_label ("close");
 317       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
 318                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
 319                                  GTK_OBJECT (window));
 320       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 321       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 322       gtk_widget_grab_default (button);
 323       gtk_widget_show (button);
 324     }
 325
 326   if (!GTK_WIDGET_VISIBLE (window))
 327     gtk_widget_show (window);
 328   else
 329     gtk_widget_destroy (window);
 330 }
 331
 332 void
 333 create_radio_buttons ()
 334 {
 335   static GtkWidget *window = NULL;
 336   GtkWidget *box1;
 337   GtkWidget *box2;
 338   GtkWidget *button;
 339   GtkWidget *separator;
 340
 341   if (!window)
 342     {
 343       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 344
 345       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 346                           GTK_SIGNAL_FUNC(destroy_window),
 347                           &window);
 348       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
 349                           GTK_SIGNAL_FUNC(destroy_window),
 350                           &window);
 351
 352       gtk_window_set_title (GTK_WINDOW (window), "radio buttons");
 353       gtk_container_border_width (GTK_CONTAINER (window), 0);
 354
 355
 356       box1 = gtk_vbox_new (FALSE, 0);
 357       gtk_container_add (GTK_CONTAINER (window), box1);
 358       gtk_widget_show (box1);
 359
 360
 361       box2 = gtk_vbox_new (FALSE, 10);
 362       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 363       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
 364       gtk_widget_show (box2);
 365
 366
 367       button = gtk_radio_button_new_with_label (NULL, "button1");
 368       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 369       gtk_widget_show (button);
 370
 371       button = gtk_radio_button_new_with_label (
 372                  gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
 373                  "button2");
 374       gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
 375       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 376       gtk_widget_show (button);
 377
 378       button = gtk_radio_button_new_with_label (
 379                  gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
 380                  "button3");
 381       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 382       gtk_widget_show (button);
 383
 384
 385       separator = gtk_hseparator_new ();
 386       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 387       gtk_widget_show (separator);
 388
 389
 390       box2 = gtk_vbox_new (FALSE, 10);
 391       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 392       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 393       gtk_widget_show (box2);
 394
 395
 396       button = gtk_button_new_with_label ("close");
 397       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
 398                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
 399                                  GTK_OBJECT (window));
 400       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 401       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 402       gtk_widget_grab_default (button);
 403       gtk_widget_show (button);
 404     }
 405
 406   if (!GTK_WIDGET_VISIBLE (window))
 407     gtk_widget_show (window);
 408   else
 409     gtk_widget_destroy (window);
 410 }
 411
 412 void
 413 bbox_widget_destroy (GtkWidget* widget, GtkWidget* todestroy)
 414 {
 415 }
 416
 417 void
 418 create_bbox_window (gint  horizontal,
 419                     char* title,
 420                     gint  pos,
 421                     gint  spacing,
 422                     gint  child_w,
 423                     gint  child_h,
 424                     gint  layout)
 425 {
 426   GtkWidget* window;
 427   GtkWidget* box1;
 428   GtkWidget* bbox;
 429   GtkWidget* button;
 430
 431   /* create a new window */
 432   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 433   gtk_window_set_title (GTK_WINDOW (window), title);
 434
 435   gtk_signal_connect (GTK_OBJECT (window), "destroy",
 436                       GTK_SIGNAL_FUNC(bbox_widget_destroy), window);
 437   gtk_signal_connect (GTK_OBJECT (window), "delete_event",
 438                       GTK_SIGNAL_FUNC(bbox_widget_destroy), window);
 439
 440   if (horizontal)
 441   {
 442     gtk_widget_set_usize (window, 550, 60);
 443     gtk_widget_set_uposition (window, 150, pos);
 444     box1 = gtk_vbox_new (FALSE, 0);
 445   }
 446   else
 447   {
 448     gtk_widget_set_usize (window, 150, 400);
 449     gtk_widget_set_uposition (window, pos, 200);
 450     box1 = gtk_vbox_new (FALSE, 0);
 451   }
 452
 453   gtk_container_add (GTK_CONTAINER (window), box1);
 454   gtk_widget_show (box1);
 455
 456   if (horizontal)
 457     bbox = gtk_hbutton_box_new();
 458   else
 459     bbox = gtk_vbutton_box_new();
 460   gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), layout);
 461   gtk_button_box_set_spacing (GTK_BUTTON_BOX (bbox), spacing);
 462   gtk_button_box_set_child_size (GTK_BUTTON_BOX (bbox), child_w, child_h);
 463   gtk_widget_show (bbox);
 464
 465   gtk_container_border_width (GTK_CONTAINER(box1), 25);
 466   gtk_box_pack_start (GTK_BOX (box1), bbox, TRUE, TRUE, 0);
 467
 468   button = gtk_button_new_with_label ("OK");
 469   gtk_container_add (GTK_CONTAINER(bbox), button);
 470
 471   gtk_signal_connect (GTK_OBJECT (button), "clicked",
 472                       GTK_SIGNAL_FUNC(bbox_widget_destroy), window);
 473
 474   gtk_widget_show (button);
 475
 476   button = gtk_button_new_with_label ("Cancel");
 477   gtk_container_add (GTK_CONTAINER(bbox), button);
 478   gtk_widget_show (button);
 479
 480   button = gtk_button_new_with_label ("Help");
 481   gtk_container_add (GTK_CONTAINER(bbox), button);
 482   gtk_widget_show (button);
 483
 484   gtk_widget_show (window);
 485 }
 486
 487 void
 488 test_hbbox ()
 489 {
 490   create_bbox_window (TRUE, "Spread", 50, 40, 85, 28, GTK_BUTTONBOX_SPREAD);
 491   create_bbox_window (TRUE, "Edge", 200, 40, 85, 25, GTK_BUTTONBOX_EDGE);
 492   create_bbox_window (TRUE, "Start", 350, 40, 85, 25, GTK_BUTTONBOX_START);
 493   create_bbox_window (TRUE, "End", 500, 15, 30, 25, GTK_BUTTONBOX_END);
 494 }
 495
 496 void
 497 test_vbbox ()
 498 {
 499   create_bbox_window (FALSE, "Spread", 50, 40, 85, 25, GTK_BUTTONBOX_SPREAD);
 500   create_bbox_window (FALSE, "Edge", 250, 40, 85, 28, GTK_BUTTONBOX_EDGE);
 501   create_bbox_window (FALSE, "Start", 450, 40, 85, 25, GTK_BUTTONBOX_START);
 502   create_bbox_window (FALSE, "End", 650, 15, 30, 25, GTK_BUTTONBOX_END);
 503 }
 504
 505 void
 506 create_button_box ()
 507 {
 508   static GtkWidget* window = NULL;
 509   GtkWidget* bbox;
 510   GtkWidget* button;
 511
 512   if (!window)
 513   {
 514     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 515     gtk_window_set_title (GTK_WINDOW (window),
 516                           "Button Box Test");
 517
 518     gtk_signal_connect (GTK_OBJECT (window), "destroy",
 519                         GTK_SIGNAL_FUNC(destroy_window), &window);
 520     gtk_signal_connect (GTK_OBJECT (window), "delete_event",
 521                         GTK_SIGNAL_FUNC(destroy_window), &window);
 522
 523     gtk_container_border_width (GTK_CONTAINER (window), 20);
 524
 525     /*
 526      *these 15 lines are a nice and easy example for GtkHButtonBox
 527      */
 528     bbox = gtk_hbutton_box_new ();
 529     gtk_container_add (GTK_CONTAINER (window), bbox);
 530     gtk_widget_show (bbox);
 531
 532     button = gtk_button_new_with_label ("Horizontal");
 533     gtk_signal_connect (GTK_OBJECT (button), "clicked",
 534                         GTK_SIGNAL_FUNC(test_hbbox), 0);
 535     gtk_container_add (GTK_CONTAINER (bbox), button);
 536     gtk_widget_show (button);
 537
 538     button = gtk_button_new_with_label ("Vertical");
 539     gtk_signal_connect (GTK_OBJECT (button), "clicked",
 540                         GTK_SIGNAL_FUNC(test_vbbox), 0);
 541     gtk_container_add (GTK_CONTAINER (bbox), button);
 542     gtk_widget_show (button);
 543   }
 544
 545   if (!GTK_WIDGET_VISIBLE (window))
 546     gtk_widget_show (window);
 547   else
 548     gtk_widget_destroy (window);
 549 }
 550
 551 GtkWidget *
 552 new_pixmap (char      *filename,
 553             GdkWindow *window,
 554             GdkColor  *background)
 555 {
 556   GtkWidget *wpixmap;
 557   GdkPixmap *pixmap;
 558   GdkBitmap *mask;
 559
 560   pixmap = gdk_pixmap_create_from_xpm (window, &mask,
 561                                        background,
 562                                        "test.xpm");
 563   wpixmap = gtk_pixmap_new (pixmap, mask);
 564
 565   return wpixmap;
 566 }
 567
 568 void
 569 set_toolbar_horizontal (GtkWidget *widget,
 570                         gpointer   data)
 571 {
 572   gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_HORIZONTAL);
 573 }
 574
 575 void
 576 set_toolbar_vertical (GtkWidget *widget,
 577                       gpointer   data)
 578 {
 579   gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_VERTICAL);
 580 }
 581
 582 void
 583 set_toolbar_icons (GtkWidget *widget,
 584                    gpointer   data)
 585 {
 586   gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_ICONS);
 587 }
 588
 589 void
 590 set_toolbar_text (GtkWidget *widget,
 591                   gpointer   data)
 592 {
 593   gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_TEXT);
 594 }
 595
 596 void
 597 set_toolbar_both (GtkWidget *widget,
 598                   gpointer   data)
 599 {
 600   gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH);
 601 }
 602
 603 void
 604 set_toolbar_small_space (GtkWidget *widget,
 605                          gpointer   data)
 606 {
 607   gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 5);
 608 }
 609
 610 void
 611 set_toolbar_big_space (GtkWidget *widget,
 612                        gpointer   data)
 613 {
 614   gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 10);
 615 }
 616
 617 void
 618 set_toolbar_enable (GtkWidget *widget,
 619                     gpointer   data)
 620 {
 621   gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), TRUE);
 622 }
 623
 624 void
 625 set_toolbar_disable (GtkWidget *widget,
 626                      gpointer   data)
 627 {
 628   gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), FALSE);
 629 }
 630
 631 void
 632 create_toolbar (void)
 633 {
 634   static GtkWidget *window = NULL;
 635   GtkWidget *toolbar;
 636
 637   if (!window)
 638     {
 639       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 640       gtk_window_set_title (GTK_WINDOW (window), "Toolbar test");
 641       gtk_window_set_policy (GTK_WINDOW (window), TRUE, TRUE, TRUE);
 642
 643       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 644                           GTK_SIGNAL_FUNC (destroy_window),
 645                           &window);
 646       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
 647                           GTK_SIGNAL_FUNC (destroy_window),
 648                           &window);
 649
 650       gtk_container_border_width (GTK_CONTAINER (window), 0);
 651       gtk_widget_realize (window);
 652
 653       toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
 654
 655       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 656                                "Horizontal", "Horizontal toolbar layout",
 657                                GTK_PIXMAP (new_pixmap ("test.xpm", window->window,
 658                                                        &window->style->bg[GTK_STATE_NORMAL])),
 659                                (GtkSignalFunc) set_toolbar_horizontal, toolbar);
 660       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 661                                "Vertical", "Vertical toolbar layout",
 662                                GTK_PIXMAP (new_pixmap ("test.xpm", window->window,
 663                                                        &window->style->bg[GTK_STATE_NORMAL])),
 664                                (GtkSignalFunc) set_toolbar_vertical, toolbar);
 665
 666       gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
 667
 668       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 669                                "Icons", "Only show toolbar icons",
 670                                GTK_PIXMAP (new_pixmap ("test.xpm", window->window,
 671                                                        &window->style->bg[GTK_STATE_NORMAL])),
 672                                (GtkSignalFunc) set_toolbar_icons, toolbar);
 673       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 674                                "Text", "Only show toolbar text",
 675                                GTK_PIXMAP (new_pixmap ("test.xpm", window->window,
 676                                                        &window->style->bg[GTK_STATE_NORMAL])),
 677                                (GtkSignalFunc) set_toolbar_text, toolbar);
 678       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 679                                "Both", "Show toolbar icons and text",
 680                                GTK_PIXMAP (new_pixmap ("test.xpm", window->window,
 681                                                        &window->style->bg[GTK_STATE_NORMAL])),
 682                                (GtkSignalFunc) set_toolbar_both, toolbar);
 683
 684       gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 685
 686       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 687                                "Small", "Use small spaces",
 688                                GTK_PIXMAP (new_pixmap ("test.xpm", window->window,
 689                                                        &window->style->bg[GTK_STATE_NORMAL])),
 690                                (GtkSignalFunc) set_toolbar_small_space, toolbar);
 691       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 692                                "Big", "Use big spaces",
 693                                GTK_PIXMAP (new_pixmap ("test.xpm", window->window,
 694                                                        &window->style->bg[GTK_STATE_NORMAL])),
 695                                (GtkSignalFunc) set_toolbar_big_space, toolbar);
 696
 697       gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 698
 699       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 700                                "Enable", "Enable tooltips",
 701                                GTK_PIXMAP (new_pixmap ("test.xpm", window->window,
 702                                                        &window->style->bg[GTK_STATE_NORMAL])),
 703                                (GtkSignalFunc) set_toolbar_enable, toolbar);
 704       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 705                                "Disable", "Disable tooltips",
 706                                GTK_PIXMAP (new_pixmap ("test.xpm", window->window,
 707                                                        &window->style->bg[GTK_STATE_NORMAL])),
 708                                (GtkSignalFunc) set_toolbar_disable, toolbar);
 709
 710       gtk_container_add (GTK_CONTAINER (window), toolbar);
 711       gtk_widget_show (toolbar);
 712     }
 713
 714   if (!GTK_WIDGET_VISIBLE (window))
 715     gtk_widget_show (window);
 716   else
 717     gtk_widget_destroy (window);
 718 }
 719
 720 GtkWidget *
 721 make_toolbar (GtkWidget *window)
 722 {
 723   GtkWidget *toolbar;
 724
 725   if (!GTK_WIDGET_REALIZED (window))
 726     gtk_widget_realize (window);
 727
 728   toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
 729
 730   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 731                            "Horizontal", "Horizontal toolbar layout",
 732                            GTK_PIXMAP (new_pixmap ("test.xpm", window->window,
 733                                                    &window->style->bg[GTK_STATE_NORMAL])),
 734                            (GtkSignalFunc) set_toolbar_horizontal, toolbar);
 735   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 736                            "Vertical", "Vertical toolbar layout",
 737                            GTK_PIXMAP (new_pixmap ("test.xpm", window->window,
 738                                                    &window->style->bg[GTK_STATE_NORMAL])),
 739                            (GtkSignalFunc) set_toolbar_vertical, toolbar);
 740
 741   gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
 742
 743   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 744                            "Icons", "Only show toolbar icons",
 745                            GTK_PIXMAP (new_pixmap ("test.xpm", window->window,
 746                                                    &window->style->bg[GTK_STATE_NORMAL])),
 747                            (GtkSignalFunc) set_toolbar_icons, toolbar);
 748   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 749                            "Text", "Only show toolbar text",
 750                            GTK_PIXMAP (new_pixmap ("test.xpm", window->window,
 751                                                    &window->style->bg[GTK_STATE_NORMAL])),
 752                            (GtkSignalFunc) set_toolbar_text, toolbar);
 753   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 754                            "Both", "Show toolbar icons and text",
 755                            GTK_PIXMAP (new_pixmap ("test.xpm", window->window,
 756                                                    &window->style->bg[GTK_STATE_NORMAL])),
 757                            (GtkSignalFunc) set_toolbar_both, toolbar);
 758
 759   gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 760
 761   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 762                            "Small", "Use small spaces",
 763                            GTK_PIXMAP (new_pixmap ("test.xpm", window->window,
 764                                                    &window->style->bg[GTK_STATE_NORMAL])),
 765                            (GtkSignalFunc) set_toolbar_small_space, toolbar);
 766   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 767                            "Big", "Use big spaces",
 768                            GTK_PIXMAP (new_pixmap ("test.xpm", window->window,
 769                                                    &window->style->bg[GTK_STATE_NORMAL])),
 770                            (GtkSignalFunc) set_toolbar_big_space, toolbar);
 771
 772   gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 773
 774   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 775                            "Enable", "Enable tooltips",
 776                            GTK_PIXMAP (new_pixmap ("test.xpm", window->window,
 777                                                    &window->style->bg[GTK_STATE_NORMAL])),
 778                            (GtkSignalFunc) set_toolbar_enable, toolbar);
 779   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 780                            "Disable", "Disable tooltips",
 781                            GTK_PIXMAP (new_pixmap ("test.xpm", window->window,
 782                                                    &window->style->bg[GTK_STATE_NORMAL])),
 783                            (GtkSignalFunc) set_toolbar_disable, toolbar);
 784
 785   return toolbar;
 786 }
 787
 788 void
 789 create_handle_box ()
 790 {
 791   static GtkWidget* window = NULL;
 792   GtkWidget* hbox;
 793 #if 0
 794   GtkWidget* button;
 795 #endif
 796
 797   if (!window)
 798   {
 799     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 800     gtk_window_set_title (GTK_WINDOW (window),
 801                           "Handle Box Test");
 802
 803     gtk_signal_connect (GTK_OBJECT (window), "destroy",
 804                         GTK_SIGNAL_FUNC(destroy_window), &window);
 805     gtk_signal_connect (GTK_OBJECT (window), "delete_event",
 806                         GTK_SIGNAL_FUNC(destroy_window), &window);
 807
 808     gtk_container_border_width (GTK_CONTAINER (window), 20);
 809
 810     hbox = gtk_handle_box_new ();
 811     gtk_container_add (GTK_CONTAINER (window), hbox);
 812     gtk_widget_show (hbox);
 813 #if 0
 814 #if 0
 815     button = gtk_toggle_button_new_with_label ("Let's try this");
 816 #else
 817     button = gtk_label_new ("Let's try this");
 818 #endif
 819     gtk_container_add (GTK_CONTAINER (hbox), button);
 820     gtk_widget_set_usize(button, 250, 40);
 821     gtk_widget_show (button);
 822 #else
 823     {
 824       GtkWidget *toolbar = make_toolbar (window);
 825       gtk_container_add (GTK_CONTAINER (hbox), toolbar);
 826       gtk_widget_show (toolbar);
 827     }
 828 #endif
 829   }
 830
 831   if (!GTK_WIDGET_VISIBLE (window))
 832     gtk_widget_show (window);
 833   else
 834     gtk_widget_destroy (window);
 835 }
 836
 837
 838 void
 839 reparent_label (GtkWidget *widget,
 840                 GtkWidget *new_parent)
 841 {
 842   GtkWidget *label;
 843
 844   label = gtk_object_get_user_data (GTK_OBJECT (widget));
 845
 846   gtk_widget_reparent (label, new_parent);
 847 }
 848
 849 void
 850 create_reparent ()
 851 {
 852   static GtkWidget *window = NULL;
 853   GtkWidget *box1;
 854   GtkWidget *box2;
 855   GtkWidget *box3;
 856   GtkWidget *frame;
 857   GtkWidget *button;
 858   GtkWidget *label;
 859   GtkWidget *separator;
 860
 861   if (!window)
 862     {
 863       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 864
 865       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 866                           GTK_SIGNAL_FUNC(destroy_window),
 867                           &window);
 868       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
 869                           GTK_SIGNAL_FUNC(destroy_window),
 870                           &window);
 871
 872       gtk_window_set_title (GTK_WINDOW (window), "buttons");
 873       gtk_container_border_width (GTK_CONTAINER (window), 0);
 874
 875
 876       box1 = gtk_vbox_new (FALSE, 0);
 877       gtk_container_add (GTK_CONTAINER (window), box1);
 878       gtk_widget_show (box1);
 879
 880
 881       box2 = gtk_hbox_new (FALSE, 5);
 882       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 883       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
 884       gtk_widget_show (box2);
 885
 886
 887       label = gtk_label_new ("Hello World");
 888
 889       frame = gtk_frame_new ("Frame 1");
 890       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
 891       gtk_widget_show (frame);
 892
 893       box3 = gtk_vbox_new (FALSE, 5);
 894       gtk_container_border_width (GTK_CONTAINER (box3), 5);
 895       gtk_container_add (GTK_CONTAINER (frame), box3);
 896       gtk_widget_show (box3);
 897
 898       button = gtk_button_new_with_label ("switch");
 899       gtk_signal_connect (GTK_OBJECT (button), "clicked",
 900                           GTK_SIGNAL_FUNC(reparent_label),
 901                           box3);
 902       gtk_object_set_user_data (GTK_OBJECT (button), label);
 903       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
 904       gtk_widget_show (button);
 905
 906       gtk_box_pack_start (GTK_BOX (box3), label, FALSE, TRUE, 0);
 907       gtk_widget_show (label);
 908
 909
 910       frame = gtk_frame_new ("Frame 2");
 911       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
 912       gtk_widget_show (frame);
 913
 914       box3 = gtk_vbox_new (FALSE, 5);
 915       gtk_container_border_width (GTK_CONTAINER (box3), 5);
 916       gtk_container_add (GTK_CONTAINER (frame), box3);
 917       gtk_widget_show (box3);
 918
 919       button = gtk_button_new_with_label ("switch");
 920       gtk_signal_connect (GTK_OBJECT (button), "clicked",
 921                           GTK_SIGNAL_FUNC(reparent_label),
 922                           box3);
 923       gtk_object_set_user_data (GTK_OBJECT (button), label);
 924       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
 925       gtk_widget_show (button);
 926
 927
 928       separator = gtk_hseparator_new ();
 929       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 930       gtk_widget_show (separator);
 931
 932
 933       box2 = gtk_vbox_new (FALSE, 10);
 934       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 935       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 936       gtk_widget_show (box2);
 937
 938
 939       button = gtk_button_new_with_label ("close");
 940       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
 941                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
 942                                  GTK_OBJECT (window));
 943       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 944       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 945       gtk_widget_grab_default (button);
 946       gtk_widget_show (button);
 947     }
 948
 949   if (!GTK_WIDGET_VISIBLE (window))
 950     gtk_widget_show (window);
 951   else
 952     gtk_widget_destroy (window);
 953 }
 954
 955 void
 956 create_pixmap ()
 957 {
 958   static GtkWidget *window = NULL;
 959   GtkWidget *box1;
 960   GtkWidget *box2;
 961   GtkWidget *box3;
 962   GtkWidget *button;
 963   GtkWidget *label;
 964   GtkWidget *separator;
 965   GtkWidget *pixmapwid;
 966   GdkPixmap *pixmap;
 967   GdkBitmap *mask;
 968   GtkStyle *style;
 969
 970   if (!window)
 971     {
 972       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 973
 974       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 975                           GTK_SIGNAL_FUNC(destroy_window),
 976                           &window);
 977       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
 978                           GTK_SIGNAL_FUNC(destroy_window),
 979                           &window);
 980
 981       gtk_window_set_title (GTK_WINDOW (window), "pixmap");
 982       gtk_container_border_width (GTK_CONTAINER (window), 0);
 983       gtk_widget_realize(window);
 984
 985       box1 = gtk_vbox_new (FALSE, 0);
 986       gtk_container_add (GTK_CONTAINER (window), box1);
 987       gtk_widget_show (box1);
 988
 989       box2 = gtk_vbox_new (FALSE, 10);
 990       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 991       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
 992       gtk_widget_show (box2);
 993
 994       button = gtk_button_new ();
 995       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
 996       gtk_widget_show (button);
 997
 998       style=gtk_widget_get_style(button);
 999
1000       pixmap = gdk_pixmap_create_from_xpm (window->window, &mask,
1001                                            &style->bg[GTK_STATE_NORMAL],
1002                                            "test.xpm");
1003       pixmapwid = gtk_pixmap_new (pixmap, mask);
1004
1005       label = gtk_label_new ("Pixmap\ntest");
1006       box3 = gtk_hbox_new (FALSE, 0);
1007       gtk_container_border_width (GTK_CONTAINER (box3), 2);
1008       gtk_container_add (GTK_CONTAINER (box3), pixmapwid);
1009       gtk_container_add (GTK_CONTAINER (box3), label);
1010       gtk_container_add (GTK_CONTAINER (button), box3);
1011       gtk_widget_show (pixmapwid);
1012       gtk_widget_show (label);
1013       gtk_widget_show (box3);
1014
1015       separator = gtk_hseparator_new ();
1016       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1017       gtk_widget_show (separator);
1018
1019
1020       box2 = gtk_vbox_new (FALSE, 10);
1021       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1022       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1023       gtk_widget_show (box2);
1024
1025
1026       button = gtk_button_new_with_label ("close");
1027       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1028                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1029                                  GTK_OBJECT (window));
1030       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1031       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1032       gtk_widget_grab_default (button);
1033       gtk_widget_show (button);
1034     }
1035
1036   if (!GTK_WIDGET_VISIBLE (window))
1037     gtk_widget_show (window);
1038   else
1039     gtk_widget_destroy (window);
1040 }
1041
1042 void
1043 create_tooltips ()
1044 {
1045   static GtkWidget *window = NULL;
1046   GtkWidget *box1;
1047   GtkWidget *box2;
1048   GtkWidget *button;
1049   GtkWidget *separator;
1050   GtkTooltips *tooltips;
1051
1052   if (!window)
1053     {
1054       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1055
1056       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1057                           GTK_SIGNAL_FUNC(destroy_window),
1058                           &window);
1059       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
1060                           GTK_SIGNAL_FUNC(destroy_window),
1061                           &window);
1062
1063       gtk_window_set_title (GTK_WINDOW (window), "tooltips");
1064       gtk_container_border_width (GTK_CONTAINER (window), 0);
1065
1066       tooltips=gtk_tooltips_new();
1067
1068       box1 = gtk_vbox_new (FALSE, 0);
1069       gtk_container_add (GTK_CONTAINER (window), box1);
1070       gtk_widget_show (box1);
1071
1072
1073       box2 = gtk_vbox_new (FALSE, 10);
1074       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1075       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1076       gtk_widget_show (box2);
1077
1078
1079       button = gtk_toggle_button_new_with_label ("button1");
1080       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1081       gtk_widget_show (button);
1082
1083       gtk_tooltips_set_tips(tooltips,button,"This is button 1");
1084
1085       button = gtk_toggle_button_new_with_label ("button2");
1086       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1087       gtk_widget_show (button);
1088
1089       gtk_tooltips_set_tips(tooltips,button,"This is button 2");
1090
1091       button = gtk_toggle_button_new_with_label ("button3");
1092       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1093       gtk_widget_show (button);
1094
1095       gtk_tooltips_set_tips (tooltips, button, "This is button 3. 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.");
1096
1097       separator = gtk_hseparator_new ();
1098       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1099       gtk_widget_show (separator);
1100
1101
1102       box2 = gtk_vbox_new (FALSE, 10);
1103       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1104       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1105       gtk_widget_show (box2);
1106
1107
1108       button = gtk_button_new_with_label ("close");
1109       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1110                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1111                                  GTK_OBJECT (window));
1112       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1113       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1114       gtk_widget_grab_default (button);
1115       gtk_widget_show (button);
1116
1117       gtk_tooltips_set_tips (tooltips, button, "Push this button to close window");
1118     }
1119
1120   if (!GTK_WIDGET_VISIBLE (window))
1121     gtk_widget_show (window);
1122   else
1123     gtk_widget_destroy (window);
1124 }
1125
1126 GtkWidget*
1127 create_menu (int depth)
1128 {
1129   GtkWidget *menu;
1130   GtkWidget *submenu;
1131   GtkWidget *menuitem;
1132   GSList *group;
1133   char buf[32];
1134   int i, j;
1135
1136   if (depth < 1)
1137     return NULL;
1138
1139   menu = gtk_menu_new ();
1140   submenu = NULL;
1141   group = NULL;
1142
1143   for (i = 0, j = 1; i < 5; i++, j++)
1144     {
1145       sprintf (buf, "item %2d - %d", depth, j);
1146       menuitem = gtk_radio_menu_item_new_with_label (group, buf);
1147       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
1148       if (depth % 2)
1149         gtk_check_menu_item_set_show_toggle (GTK_CHECK_MENU_ITEM (menuitem), TRUE);
1150       gtk_menu_append (GTK_MENU (menu), menuitem);
1151       gtk_widget_show (menuitem);
1152
1153       if (depth > 0)
1154         {
1155           if (!submenu)
1156             submenu = create_menu (depth - 1);
1157           gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
1158         }
1159     }
1160
1161   return menu;
1162 }
1163
1164 void
1165 create_menus ()
1166 {
1167   static GtkWidget *window = NULL;
1168   GtkWidget *box1;
1169   GtkWidget *box2;
1170   GtkWidget *button;
1171   GtkWidget *menu;
1172   GtkWidget *menubar;
1173   GtkWidget *menuitem;
1174   GtkWidget *optionmenu;
1175   GtkWidget *separator;
1176
1177   if (!window)
1178     {
1179       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1180
1181       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1182                           GTK_SIGNAL_FUNC(destroy_window),
1183                           &window);
1184       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
1185                           GTK_SIGNAL_FUNC(destroy_window),
1186                           &window);
1187
1188       gtk_window_set_title (GTK_WINDOW (window), "menus");
1189       gtk_container_border_width (GTK_CONTAINER (window), 0);
1190
1191
1192       box1 = gtk_vbox_new (FALSE, 0);
1193       gtk_container_add (GTK_CONTAINER (window), box1);
1194       gtk_widget_show (box1);
1195
1196
1197       menubar = gtk_menu_bar_new ();
1198       gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
1199       gtk_widget_show (menubar);
1200
1201       menu = create_menu (2);
1202
1203       menuitem = gtk_menu_item_new_with_label ("test\nline2");
1204       gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
1205       gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
1206       gtk_widget_show (menuitem);
1207
1208       menuitem = gtk_menu_item_new_with_label ("foo");
1209       gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
1210       gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
1211       gtk_widget_show (menuitem);
1212
1213       menuitem = gtk_menu_item_new_with_label ("bar");
1214       gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
1215       gtk_menu_item_right_justify (GTK_MENU_ITEM (menuitem));
1216       gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
1217       gtk_widget_show (menuitem);
1218
1219
1220       box2 = gtk_vbox_new (FALSE, 10);
1221       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1222       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1223       gtk_widget_show (box2);
1224
1225
1226       optionmenu = gtk_option_menu_new ();
1227       gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), create_menu (1));
1228       gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu), 4);
1229       gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0);
1230       gtk_widget_show (optionmenu);
1231
1232
1233       separator = gtk_hseparator_new ();
1234       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1235       gtk_widget_show (separator);
1236
1237
1238       box2 = gtk_vbox_new (FALSE, 10);
1239       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1240       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1241       gtk_widget_show (box2);
1242
1243
1244       button = gtk_button_new_with_label ("close");
1245       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1246                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1247                                  GTK_OBJECT (window));
1248       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1249       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1250       gtk_widget_grab_default (button);
1251       gtk_widget_show (button);
1252     }
1253
1254   if (!GTK_WIDGET_VISIBLE (window))
1255     gtk_widget_show (window);
1256   else
1257     gtk_widget_destroy (window);
1258 }
1259
1260 /*
1261  * GtkScrolledWindow
1262  */
1263 void
1264 create_scrolled_windows ()
1265 {
1266   static GtkWidget *window;
1267   GtkWidget *scrolled_window;
1268   GtkWidget *table;
1269   GtkWidget *button;
1270   char buffer[32];
1271   int i, j;
1272
1273   if (!window)
1274     {
1275       window = gtk_dialog_new ();
1276
1277       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1278                           GTK_SIGNAL_FUNC(destroy_window),
1279                           &window);
1280       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
1281                           GTK_SIGNAL_FUNC(destroy_window),
1282                           &window);
1283
1284       gtk_window_set_title (GTK_WINDOW (window), "dialog");
1285       gtk_container_border_width (GTK_CONTAINER (window), 0);
1286
1287
1288       scrolled_window = gtk_scrolled_window_new (NULL, NULL);
1289       gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
1290       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
1291                                       GTK_POLICY_AUTOMATIC,
1292                                       GTK_POLICY_AUTOMATIC);
1293       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
1294                           scrolled_window, TRUE, TRUE, 0);
1295       gtk_widget_show (scrolled_window);
1296
1297       table = gtk_table_new (20, 20, FALSE);
1298       gtk_table_set_row_spacings (GTK_TABLE (table), 10);
1299       gtk_table_set_col_spacings (GTK_TABLE (table), 10);
1300       gtk_container_add (GTK_CONTAINER (scrolled_window), table);
1301       gtk_widget_show (table);
1302
1303       for (i = 0; i < 20; i++)
1304         for (j = 0; j < 20; j++)
1305           {
1306             sprintf (buffer, "button (%d,%d)\n", i, j);
1307             button = gtk_toggle_button_new_with_label (buffer);
1308             gtk_table_attach_defaults (GTK_TABLE (table), button,
1309                                        i, i+1, j, j+1);
1310             gtk_widget_show (button);
1311           }
1312
1313
1314       button = gtk_button_new_with_label ("close");
1315       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1316                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1317                                  GTK_OBJECT (window));
1318       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1319       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
1320                           button, TRUE, TRUE, 0);
1321       gtk_widget_grab_default (button);
1322       gtk_widget_show (button);
1323     }
1324
1325   if (!GTK_WIDGET_VISIBLE (window))
1326     gtk_widget_show (window);
1327   else
1328     gtk_widget_destroy (window);
1329 }
1330
1331 /*
1332  * GtkEntry
1333  */
1334
1335 void entry_toggle_editable (GtkWidget *checkbutton,
1336                             GtkWidget *entry)
1337 {
1338    gtk_entry_set_editable(GTK_ENTRY(entry),
1339                           GTK_TOGGLE_BUTTON(checkbutton)->active);
1340 }
1341
1342 void
1343 create_entry ()
1344 {
1345   static GtkWidget *window = NULL;
1346   GtkWidget *box1;
1347   GtkWidget *box2;
1348   GtkWidget *editable_check;
1349   GtkWidget *entry;
1350   GtkWidget *button;
1351   GtkWidget *separator;
1352
1353   /*  if (!window) */
1354     {
1355       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1356
1357       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1358                           GTK_SIGNAL_FUNC(destroy_window),
1359                           &window);
1360       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
1361                           GTK_SIGNAL_FUNC(destroy_window),
1362                           &window);
1363
1364       gtk_window_set_title (GTK_WINDOW (window), "entry");
1365       gtk_container_border_width (GTK_CONTAINER (window), 0);
1366
1367
1368       box1 = gtk_vbox_new (FALSE, 0);
1369       gtk_container_add (GTK_CONTAINER (window), box1);
1370       gtk_widget_show (box1);
1371
1372
1373       box2 = gtk_vbox_new (FALSE, 10);
1374       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1375       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1376       gtk_widget_show (box2);
1377
1378       entry = gtk_entry_new ();
1379       /* gtk_widget_set_usize (entry, 0, 25); */
1380       gtk_entry_set_text (GTK_ENTRY (entry), "hello world");
1381       gtk_entry_select_region (GTK_ENTRY (entry),
1382                                0, GTK_ENTRY(entry)->text_length);
1383       gtk_box_pack_start (GTK_BOX (box2), entry, TRUE, TRUE, 0);
1384       gtk_widget_show (entry);
1385
1386       editable_check = gtk_check_button_new_with_label("Editable");
1387       gtk_box_pack_start (GTK_BOX (box2), editable_check, TRUE, TRUE, 0);
1388       gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
1389                           GTK_SIGNAL_FUNC(entry_toggle_editable), entry);
1390       gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE);
1391       gtk_widget_show (editable_check);
1392
1393       separator = gtk_hseparator_new ();
1394       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1395       gtk_widget_show (separator);
1396
1397
1398       box2 = gtk_vbox_new (FALSE, 10);
1399       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1400       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1401       gtk_widget_show (box2);
1402
1403
1404       button = gtk_button_new_with_label ("close");
1405       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1406                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1407                                  GTK_OBJECT (window));
1408       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1409       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1410       gtk_widget_grab_default (button);
1411       gtk_widget_show (button);
1412     }
1413
1414   if (!GTK_WIDGET_VISIBLE (window))
1415     gtk_widget_show (window);
1416   /*  else
1417     gtk_widget_destroy (window); */
1418 }
1419
1420 /*
1421  * GtkList
1422  */
1423 void
1424 list_add (GtkWidget *widget,
1425           GtkWidget *list)
1426 {
1427   static int i = 1;
1428   gchar buffer[64];
1429   GtkWidget *list_item;
1430
1431   sprintf (buffer, "added item %d", i++);
1432   list_item = gtk_list_item_new_with_label (buffer);
1433   gtk_widget_show (list_item);
1434   gtk_container_add (GTK_CONTAINER (list), list_item);
1435 }
1436
1437 void
1438 list_remove (GtkWidget *widget,
1439              GtkWidget *list)
1440 {
1441   GList *tmp_list;
1442   GList *clear_list;
1443
1444   tmp_list = GTK_LIST (list)->selection;
1445   clear_list = NULL;
1446
1447   while (tmp_list)
1448     {
1449       clear_list = g_list_prepend (clear_list, tmp_list->data);
1450       tmp_list = tmp_list->next;
1451     }
1452
1453   clear_list = g_list_reverse (clear_list);
1454
1455   gtk_list_remove_items (GTK_LIST (list), clear_list);
1456
1457   tmp_list = clear_list;
1458
1459   while (tmp_list)
1460     {
1461       gtk_widget_destroy (GTK_WIDGET (tmp_list->data));
1462       tmp_list = tmp_list->next;
1463     }
1464
1465   g_list_free (clear_list);
1466 }
1467
1468 void
1469 create_list ()
1470 {
1471   static GtkWidget *window = NULL;
1472   static char *list_items[] =
1473   {
1474     "hello",
1475     "world",
1476     "blah",
1477     "foo",
1478     "bar",
1479     "argh",
1480     "spencer",
1481     "is a",
1482     "wussy",
1483     "programmer",
1484   };
1485   static int nlist_items = sizeof (list_items) / sizeof (list_items[0]);
1486
1487   GtkWidget *box1;
1488   GtkWidget *box2;
1489   GtkWidget *scrolled_win;
1490   GtkWidget *list;
1491   GtkWidget *list_item;
1492   GtkWidget *button;
1493   GtkWidget *separator;
1494   int i;
1495
1496   if (!window)
1497     {
1498       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1499
1500       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1501                           GTK_SIGNAL_FUNC(destroy_window),
1502                           &window);
1503       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
1504                           GTK_SIGNAL_FUNC(destroy_window),
1505                           &window);
1506
1507       gtk_window_set_title (GTK_WINDOW (window), "list");
1508       gtk_container_border_width (GTK_CONTAINER (window), 0);
1509
1510
1511       box1 = gtk_vbox_new (FALSE, 0);
1512       gtk_container_add (GTK_CONTAINER (window), box1);
1513       gtk_widget_show (box1);
1514
1515
1516       box2 = gtk_vbox_new (FALSE, 10);
1517       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1518       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1519       gtk_widget_show (box2);
1520
1521
1522       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
1523       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
1524                                       GTK_POLICY_AUTOMATIC,
1525                                       GTK_POLICY_AUTOMATIC);
1526       gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
1527       gtk_widget_show (scrolled_win);
1528
1529       list = gtk_list_new ();
1530       gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_MULTIPLE);
1531       gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_BROWSE);
1532       gtk_container_add (GTK_CONTAINER (scrolled_win), list);
1533       gtk_widget_show (list);
1534
1535       for (i = 0; i < nlist_items; i++)
1536         {
1537           list_item = gtk_list_item_new_with_label (list_items[i]);
1538           gtk_container_add (GTK_CONTAINER (list), list_item);
1539           gtk_widget_show (list_item);
1540         }
1541
1542       button = gtk_button_new_with_label ("add");
1543       GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
1544       gtk_signal_connect (GTK_OBJECT (button), "clicked",
1545                           GTK_SIGNAL_FUNC(list_add),
1546                           list);
1547       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
1548       gtk_widget_show (button);
1549
1550       button = gtk_button_new_with_label ("remove");
1551       GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
1552       gtk_signal_connect (GTK_OBJECT (button), "clicked",
1553                           GTK_SIGNAL_FUNC(list_remove),
1554                           list);
1555       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
1556       gtk_widget_show (button);
1557
1558
1559       separator = gtk_hseparator_new ();
1560       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1561       gtk_widget_show (separator);
1562
1563
1564       box2 = gtk_vbox_new (FALSE, 10);
1565       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1566       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1567       gtk_widget_show (box2);
1568
1569
1570       button = gtk_button_new_with_label ("close");
1571       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1572                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1573                                  GTK_OBJECT (window));
1574       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1575       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1576       gtk_widget_grab_default (button);
1577       gtk_widget_show (button);
1578     }
1579
1580   if (!GTK_WIDGET_VISIBLE (window))
1581     gtk_widget_show (window);
1582   else
1583     gtk_widget_destroy (window);
1584 }
1585
1586 /*
1587  * GtkCList
1588  */
1589 #define TESTGTK_CLIST_COLUMNS 7
1590 static gint clist_rows = 0;
1591 static gint clist_selected_row = 0;
1592
1593 void
1594 add1000_clist (GtkWidget *widget, gpointer data)
1595 {
1596   gint i;
1597   char text[TESTGTK_CLIST_COLUMNS][50];
1598   char *texts[TESTGTK_CLIST_COLUMNS];
1599
1600   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
1601     {
1602       texts[i] = text[i];
1603       sprintf (text[i], "Column %d", i);
1604     }
1605
1606   sprintf (text[1], "Right");
1607   sprintf (text[2], "Center");
1608
1609   gtk_clist_freeze (GTK_CLIST (data));
1610   for (i = 0; i < 1000; i++)
1611     {
1612       sprintf (text[0], "Row %d", clist_rows++);
1613       gtk_clist_append (GTK_CLIST (data), texts);
1614     }
1615   gtk_clist_thaw (GTK_CLIST (data));
1616
1617 }
1618
1619 void
1620 add10000_clist (GtkWidget *widget, gpointer data)
1621 {
1622   gint i;
1623   char text[TESTGTK_CLIST_COLUMNS][50];
1624   char *texts[TESTGTK_CLIST_COLUMNS];
1625
1626   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
1627     {
1628       texts[i] = text[i];
1629       sprintf (text[i], "Column %d", i);
1630     }
1631
1632   sprintf (text[1], "Right");
1633   sprintf (text[2], "Center");
1634
1635   gtk_clist_freeze (GTK_CLIST (data));
1636   for (i = 0; i < 10000; i++)
1637     {
1638       sprintf (text[0], "Row %d", clist_rows++);
1639       gtk_clist_append (GTK_CLIST (data), texts);
1640     }
1641   gtk_clist_thaw (GTK_CLIST (data));
1642
1643 }
1644
1645 void
1646 clear_clist (GtkWidget *widget, gpointer data)
1647 {
1648   gtk_clist_clear (GTK_CLIST (data));
1649   clist_rows = 0;
1650 }
1651
1652 void
1653 remove_row_clist (GtkWidget *widget, gpointer data)
1654 {
1655   gtk_clist_remove (GTK_CLIST (data), clist_selected_row);
1656   clist_rows--;
1657 }
1658
1659 void
1660 select_clist (GtkWidget *widget,
1661               gint row,
1662               gint column,
1663               GdkEventButton *bevent)
1664 {
1665   gint button = 0;
1666
1667   if (bevent)
1668     button = bevent->button;
1669
1670   g_print ("GtkCList Selection: row %d column %d button %d\n",
1671            row, column, button);
1672
1673   clist_selected_row = row;
1674 }
1675
1676 void
1677 create_clist ()
1678 {
1679   gint i;
1680   static GtkWidget *window = NULL;
1681
1682   static char *titles[] =
1683   {
1684     "Title 0",
1685     "Title 1",
1686     "Title 2",
1687     "Title 3",
1688     "Title 4",
1689     "Title 5",
1690     "Title 6"
1691   };
1692
1693   char text[TESTGTK_CLIST_COLUMNS][50];
1694   char *texts[TESTGTK_CLIST_COLUMNS];
1695
1696   GtkWidget *box1;
1697   GtkWidget *box2;
1698   GtkWidget *clist;
1699   GtkWidget *button;
1700   GtkWidget *separator;
1701
1702
1703   if (!window)
1704     {
1705       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1706
1707       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1708                           GTK_SIGNAL_FUNC(destroy_window),
1709                           &window);
1710       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
1711                           GTK_SIGNAL_FUNC(destroy_window),
1712                           &window);
1713
1714       gtk_window_set_title (GTK_WINDOW (window), "clist");
1715       gtk_container_border_width (GTK_CONTAINER (window), 0);
1716
1717
1718       box1 = gtk_vbox_new (FALSE, 0);
1719       gtk_container_add (GTK_CONTAINER (window), box1);
1720       gtk_widget_show (box1);
1721
1722
1723       box2 = gtk_hbox_new (FALSE, 10);
1724       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1725       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
1726       gtk_widget_show (box2);
1727
1728       /* create this here so we have a pointer to throw at the
1729        * button callbacks -- more is done with it later */
1730       clist = gtk_clist_new (TESTGTK_CLIST_COLUMNS, titles);
1731
1732       button = gtk_button_new_with_label ("Add 1,000 Rows");
1733       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1734
1735       gtk_signal_connect (GTK_OBJECT (button),
1736                           "clicked",
1737                           (GtkSignalFunc) add1000_clist,
1738                           (gpointer) clist);
1739
1740       gtk_widget_show (button);
1741
1742
1743       button = gtk_button_new_with_label ("Add 10,000 Rows");
1744       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1745
1746       gtk_signal_connect (GTK_OBJECT (button),
1747                           "clicked",
1748                           (GtkSignalFunc) add10000_clist,
1749                           (gpointer) clist);
1750
1751       gtk_widget_show (button);
1752
1753       button = gtk_button_new_with_label ("Clear List");
1754       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1755
1756       gtk_signal_connect (GTK_OBJECT (button),
1757                           "clicked",
1758                           (GtkSignalFunc) clear_clist,
1759                           (gpointer) clist);
1760
1761       gtk_widget_show (button);
1762
1763       button = gtk_button_new_with_label ("Remove Row");
1764       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1765
1766       gtk_signal_connect (GTK_OBJECT (button),
1767                           "clicked",
1768                           (GtkSignalFunc) remove_row_clist,
1769                           (gpointer) clist);
1770
1771       gtk_widget_show (button);
1772
1773       box2 = gtk_vbox_new (FALSE, 10);
1774       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1775       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1776       gtk_widget_show (box2);
1777
1778
1779       /*
1780        * the rest of the clist configuration
1781        */
1782       gtk_clist_set_row_height (GTK_CLIST (clist), 20);
1783
1784       gtk_signal_connect (GTK_OBJECT (clist),
1785                           "select_row",
1786                           (GtkSignalFunc) select_clist,
1787                           NULL);
1788
1789       gtk_clist_set_column_width (GTK_CLIST (clist), 0, 100);
1790
1791       for (i = 1; i < TESTGTK_CLIST_COLUMNS; i++)
1792         gtk_clist_set_column_width (GTK_CLIST (clist), i, 80);
1793
1794       gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_BROWSE);
1795
1796       gtk_clist_set_policy (GTK_CLIST (clist), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1797
1798       gtk_clist_set_column_justification (GTK_CLIST (clist), 1, GTK_JUSTIFY_RIGHT);
1799       gtk_clist_set_column_justification (GTK_CLIST (clist), 2, GTK_JUSTIFY_CENTER);
1800
1801       for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
1802         {
1803           texts[i] = text[i];
1804           sprintf (text[i], "Column %d", i);
1805         }
1806
1807       sprintf (text[1], "Right");
1808       sprintf (text[2], "Center");
1809
1810       for (i = 0; i < 100; i++)
1811         {
1812           sprintf (text[0], "Row %d", clist_rows++);
1813           gtk_clist_append (GTK_CLIST (clist), texts);
1814         }
1815
1816       gtk_container_border_width (GTK_CONTAINER (clist), 5);
1817       gtk_box_pack_start (GTK_BOX (box2), clist, TRUE, TRUE, 0);
1818       gtk_widget_show (clist);
1819
1820
1821       separator = gtk_hseparator_new ();
1822       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1823       gtk_widget_show (separator);
1824
1825       box2 = gtk_vbox_new (FALSE, 10);
1826       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1827       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1828       gtk_widget_show (box2);
1829
1830       button = gtk_button_new_with_label ("close");
1831       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1832                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1833                                  GTK_OBJECT (window));
1834
1835       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1836       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1837       gtk_widget_grab_default (button);
1838
1839       gtk_widget_show (button);
1840     }
1841
1842   if (!GTK_WIDGET_VISIBLE (window))
1843     gtk_widget_show (window);
1844   else
1845     gtk_widget_destroy (window);
1846
1847 }
1848
1849 /*
1850  * GtkColorSelect
1851  */
1852 void
1853 color_selection_ok (GtkWidget               *w,
1854                     GtkColorSelectionDialog *cs)
1855 {
1856   GtkColorSelection *colorsel;
1857   gdouble color[4];
1858
1859   colorsel=GTK_COLOR_SELECTION(cs->colorsel);
1860
1861   gtk_color_selection_get_color(colorsel,color);
1862   gtk_color_selection_set_color(colorsel,color);
1863 }
1864
1865 void
1866 color_selection_changed (GtkWidget *w,
1867                          GtkColorSelectionDialog *cs)
1868 {
1869   GtkColorSelection *colorsel;
1870   gdouble color[4];
1871
1872   colorsel=GTK_COLOR_SELECTION(cs->colorsel);
1873   gtk_color_selection_get_color(colorsel,color);
1874 }
1875
1876 void
1877 create_color_selection ()
1878 {
1879   static GtkWidget *window = NULL;
1880
1881   if (!window)
1882     {
1883       gtk_preview_set_install_cmap (TRUE);
1884       gtk_widget_push_visual (gtk_preview_get_visual ());
1885       gtk_widget_push_colormap (gtk_preview_get_cmap ());
1886
1887       window = gtk_color_selection_dialog_new ("color selection dialog");
1888
1889       gtk_color_selection_set_opacity (
1890         GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
1891         TRUE);
1892
1893       gtk_color_selection_set_update_policy(
1894         GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
1895         GTK_UPDATE_CONTINUOUS);
1896
1897       gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
1898
1899       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1900                           GTK_SIGNAL_FUNC(destroy_window),
1901                           &window);
1902       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
1903                           GTK_SIGNAL_FUNC(destroy_window),
1904                           &window);
1905
1906       gtk_signal_connect (
1907         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
1908         "color_changed",
1909         GTK_SIGNAL_FUNC(color_selection_changed),
1910         window);
1911
1912       gtk_signal_connect (
1913         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->ok_button),
1914         "clicked",
1915         GTK_SIGNAL_FUNC(color_selection_ok),
1916         window);
1917
1918       gtk_signal_connect_object (
1919         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->cancel_button),
1920         "clicked",
1921         GTK_SIGNAL_FUNC(gtk_widget_destroy),
1922         GTK_OBJECT (window));
1923
1924       gtk_widget_pop_colormap ();
1925       gtk_widget_pop_visual ();
1926     }
1927
1928   if (!GTK_WIDGET_VISIBLE (window))
1929     gtk_widget_show (window);
1930   else
1931     gtk_widget_destroy (window);
1932 }
1933
1934
1935 void
1936 file_selection_ok (GtkWidget        *w,
1937                    GtkFileSelection *fs)
1938 {
1939   g_print ("%s\n", gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs)));
1940 }
1941
1942 void
1943 create_file_selection ()
1944 {
1945   static GtkWidget *window = NULL;
1946
1947   if (!window)
1948     {
1949       window = gtk_file_selection_new ("file selection dialog");
1950       gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
1951
1952       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1953                           GTK_SIGNAL_FUNC(destroy_window),
1954                           &window);
1955       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
1956                           GTK_SIGNAL_FUNC(destroy_window),
1957                           &window);
1958
1959       gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (window)->ok_button),
1960                           "clicked", GTK_SIGNAL_FUNC(file_selection_ok),
1961                           window);
1962       gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (window)->cancel_button),
1963                                  "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
1964                                  GTK_OBJECT (window));
1965     }
1966
1967   if (!GTK_WIDGET_VISIBLE (window))
1968     gtk_widget_show (window);
1969   else
1970     gtk_widget_destroy (window);
1971 }
1972
1973
1974 /*
1975  * GtkDialog
1976  */
1977 static GtkWidget *dialog_window = NULL;
1978
1979 void
1980 label_toggle (GtkWidget  *widget,
1981               GtkWidget **label)
1982 {
1983   if (!(*label))
1984     {
1985       *label = gtk_label_new ("Dialog Test");
1986       gtk_misc_set_padding (GTK_MISC (*label), 10, 10);
1987       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
1988                           *label, TRUE, TRUE, 0);
1989       gtk_widget_show (*label);
1990     }
1991   else
1992     {
1993       gtk_widget_destroy (*label);
1994       *label = NULL;
1995     }
1996 }
1997
1998 void
1999 create_dialog ()
2000 {
2001   static GtkWidget *label;
2002   GtkWidget *button;
2003
2004   if (!dialog_window)
2005     {
2006       dialog_window = gtk_dialog_new ();
2007
2008       gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
2009                           GTK_SIGNAL_FUNC(destroy_window),
2010                           &dialog_window);
2011       gtk_signal_connect (GTK_OBJECT (dialog_window), "delete_event",
2012                           GTK_SIGNAL_FUNC(destroy_window),
2013                           &dialog_window);
2014
2015       gtk_window_set_title (GTK_WINDOW (dialog_window), "dialog");
2016       gtk_container_border_width (GTK_CONTAINER (dialog_window), 0);
2017
2018       button = gtk_button_new_with_label ("OK");
2019       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2020       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
2021                           button, TRUE, TRUE, 0);
2022       gtk_widget_grab_default (button);
2023       gtk_widget_show (button);
2024
2025       button = gtk_button_new_with_label ("Toggle");
2026       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2027                           GTK_SIGNAL_FUNC(label_toggle),
2028                           &label);
2029       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2030       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
2031                           button, TRUE, TRUE, 0);
2032       gtk_widget_show (button);
2033
2034       label = NULL;
2035     }
2036
2037   if (!GTK_WIDGET_VISIBLE (dialog_window))
2038     gtk_widget_show (dialog_window);
2039   else
2040     gtk_widget_destroy (dialog_window);
2041 }
2042
2043
2044 /*
2045  * GtkRange
2046  */
2047 void
2048 create_range_controls ()
2049 {
2050   static GtkWidget *window = NULL;
2051   GtkWidget *box1;
2052   GtkWidget *box2;
2053   GtkWidget *button;
2054   GtkWidget *scrollbar;
2055   GtkWidget *scale;
2056   GtkWidget *separator;
2057   GtkObject *adjustment;
2058
2059   if (!window)
2060     {
2061       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2062
2063       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2064                           GTK_SIGNAL_FUNC(destroy_window),
2065                           &window);
2066       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2067                           GTK_SIGNAL_FUNC(destroy_window),
2068                           &window);
2069
2070       gtk_window_set_title (GTK_WINDOW (window), "range controls");
2071       gtk_container_border_width (GTK_CONTAINER (window), 0);
2072
2073
2074       box1 = gtk_vbox_new (FALSE, 0);
2075       gtk_container_add (GTK_CONTAINER (window), box1);
2076       gtk_widget_show (box1);
2077
2078
2079       box2 = gtk_vbox_new (FALSE, 10);
2080       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2081       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2082       gtk_widget_show (box2);
2083
2084
2085       adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
2086
2087       scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
2088       gtk_widget_set_usize (GTK_WIDGET (scale), 150, 30);
2089       gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
2090       gtk_scale_set_digits (GTK_SCALE (scale), 1);
2091       gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
2092       gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
2093       gtk_widget_show (scale);
2094
2095       scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adjustment));
2096       gtk_range_set_update_policy (GTK_RANGE (scrollbar),
2097                                    GTK_UPDATE_CONTINUOUS);
2098       gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0);
2099       gtk_widget_show (scrollbar);
2100
2101
2102       separator = gtk_hseparator_new ();
2103       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2104       gtk_widget_show (separator);
2105
2106
2107       box2 = gtk_vbox_new (FALSE, 10);
2108       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2109       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2110       gtk_widget_show (box2);
2111
2112
2113       button = gtk_button_new_with_label ("close");
2114       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2115                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2116                                  GTK_OBJECT (window));
2117       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2118       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2119       gtk_widget_grab_default (button);
2120       gtk_widget_show (button);
2121     }
2122
2123   if (!GTK_WIDGET_VISIBLE (window))
2124     gtk_widget_show (window);
2125   else
2126     gtk_widget_destroy (window);
2127 }
2128
2129
2130 /*
2131  * GtkRulers
2132  */
2133 void
2134 create_rulers ()
2135 {
2136   static GtkWidget *window = NULL;
2137   GtkWidget *table;
2138   GtkWidget *ruler;
2139
2140   if (!window)
2141     {
2142       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2143
2144       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2145                           GTK_SIGNAL_FUNC(destroy_window),
2146                           &window);
2147       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2148                           GTK_SIGNAL_FUNC(destroy_window),
2149                           &window);
2150
2151       gtk_window_set_title (GTK_WINDOW (window), "rulers");
2152       gtk_widget_set_usize (window, 300, 300);
2153       gtk_widget_set_events (window,
2154                              GDK_POINTER_MOTION_MASK
2155                              | GDK_POINTER_MOTION_HINT_MASK);
2156       gtk_container_border_width (GTK_CONTAINER (window), 0);
2157
2158       table = gtk_table_new (2, 2, FALSE);
2159       gtk_container_add (GTK_CONTAINER (window), table);
2160       gtk_widget_show (table);
2161
2162       ruler = gtk_hruler_new ();
2163       gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
2164
2165       gtk_signal_connect_object (
2166         GTK_OBJECT (window),
2167         "motion_notify_event",
2168         GTK_SIGNAL_FUNC(
2169           GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
2170         GTK_OBJECT (ruler));
2171
2172       gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
2173                         GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
2174       gtk_widget_show (ruler);
2175
2176
2177       ruler = gtk_vruler_new ();
2178       gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
2179
2180       gtk_signal_connect_object (
2181         GTK_OBJECT (window),
2182         "motion_notify_event",
2183         GTK_SIGNAL_FUNC (GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
2184         GTK_OBJECT (ruler));
2185
2186       gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
2187                         GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
2188       gtk_widget_show (ruler);
2189     }
2190
2191   if (!GTK_WIDGET_VISIBLE (window))
2192     gtk_widget_show (window);
2193   else
2194     gtk_widget_destroy (window);
2195 }
2196
2197
2198 /*
2199  * GtkText
2200  */
2201 void
2202 create_text ()
2203 {
2204   static GtkWidget *window = NULL;
2205   GtkWidget *box1;
2206   GtkWidget *box2;
2207   GtkWidget *button;
2208   GtkWidget *separator;
2209   GtkWidget *table;
2210   GtkWidget *hscrollbar;
2211   GtkWidget *vscrollbar;
2212   GtkWidget *text;
2213
2214   if (!window)
2215     {
2216       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2217       gtk_widget_set_name (window, "text window");
2218
2219       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2220                           GTK_SIGNAL_FUNC(destroy_window),
2221                           &window);
2222       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2223                           GTK_SIGNAL_FUNC(destroy_window),
2224                           &window);
2225
2226       gtk_window_set_title (GTK_WINDOW (window), "test");
2227       gtk_container_border_width (GTK_CONTAINER (window), 0);
2228
2229
2230       box1 = gtk_vbox_new (FALSE, 0);
2231       gtk_container_add (GTK_CONTAINER (window), box1);
2232       gtk_widget_show (box1);
2233
2234
2235       box2 = gtk_vbox_new (FALSE, 10);
2236       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2237       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2238       gtk_widget_show (box2);
2239
2240
2241       table = gtk_table_new (2, 2, FALSE);
2242       gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2);
2243       gtk_table_set_col_spacing (GTK_TABLE (table), 0, 2);
2244       gtk_box_pack_start (GTK_BOX (box2), table, TRUE, TRUE, 0);
2245       gtk_widget_show (table);
2246
2247       text = gtk_text_new (NULL, NULL);
2248       gtk_table_attach_defaults (GTK_TABLE (table), text, 0, 1, 0, 1);
2249       gtk_widget_show (text);
2250
2251       hscrollbar = gtk_hscrollbar_new (GTK_TEXT (text)->hadj);
2252       gtk_table_attach (GTK_TABLE (table), hscrollbar, 0, 1, 1, 2,
2253                         GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
2254       gtk_widget_show (hscrollbar);
2255
2256       vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
2257       gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 0, 1,
2258                         GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
2259       gtk_widget_show (vscrollbar);
2260
2261       gtk_text_freeze (GTK_TEXT (text));
2262
2263       gtk_widget_realize (text);
2264
2265       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2266                        "spencer blah blah blah\n", -1);
2267       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2268                        "kimball\n", -1);
2269       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2270                        "is\n", -1);
2271       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2272                        "a\n", -1);
2273       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2274                        "wuss.\n", -1);
2275       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2276                        "but\n", -1);
2277       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2278                        "josephine\n", -1);
2279       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2280                        "(his\n", -1);
2281       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2282                        "girlfriend\n", -1);
2283       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2284                        "is\n", -1);
2285       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2286                        "not).\n", -1);
2287       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2288                        "why?\n", -1);
2289       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2290                        "because\n", -1);
2291       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2292                        "spencer\n", -1);
2293       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2294                        "puked\n", -1);
2295       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2296                        "last\n", -1);
2297       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2298                        "night\n", -1);
2299       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2300                        "but\n", -1);
2301       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2302                        "josephine\n", -1);
2303       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2304                        "did\n", -1);
2305       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2306                        "not", -1);
2307
2308       gtk_text_thaw (GTK_TEXT (text));
2309
2310       separator = gtk_hseparator_new ();
2311       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2312       gtk_widget_show (separator);
2313
2314
2315       box2 = gtk_vbox_new (FALSE, 10);
2316       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2317       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2318       gtk_widget_show (box2);
2319
2320
2321       button = gtk_button_new_with_label ("close");
2322       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2323                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2324                                  GTK_OBJECT (window));
2325       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2326       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2327       gtk_widget_grab_default (button);
2328       gtk_widget_show (button);
2329     }
2330
2331   if (!GTK_WIDGET_VISIBLE (window))
2332     gtk_widget_show (window);
2333   else
2334     gtk_widget_destroy (window);
2335 }
2336
2337
2338 /*
2339  * GtkNotebook
2340  */
2341 void
2342 rotate_notebook (GtkButton   *button,
2343                  GtkNotebook *notebook)
2344 {
2345   gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos + 1) % 4);
2346 }
2347
2348 void
2349 create_notebook ()
2350 {
2351   static GtkWidget *window = NULL;
2352   GtkWidget *box1;
2353   GtkWidget *box2;
2354   GtkWidget *button;
2355   GtkWidget *separator;
2356   GtkWidget *notebook;
2357   GtkWidget *frame;
2358   GtkWidget *label;
2359   char buffer[32];
2360   int i;
2361
2362   if (!window)
2363     {
2364       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2365
2366       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2367                           GTK_SIGNAL_FUNC(destroy_window),
2368                           &window);
2369       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2370                           GTK_SIGNAL_FUNC(destroy_window),
2371                           &window);
2372
2373       gtk_window_set_title (GTK_WINDOW (window), "notebook");
2374       gtk_container_border_width (GTK_CONTAINER (window), 0);
2375
2376
2377       box1 = gtk_vbox_new (FALSE, 0);
2378       gtk_container_add (GTK_CONTAINER (window), box1);
2379       gtk_widget_show (box1);
2380
2381
2382       box2 = gtk_vbox_new (FALSE, 10);
2383       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2384       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2385       gtk_widget_show (box2);
2386
2387
2388       notebook = gtk_notebook_new ();
2389       gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
2390       gtk_box_pack_start (GTK_BOX (box2), notebook, TRUE, TRUE, 0);
2391       gtk_widget_show (notebook);
2392
2393
2394       for (i = 0; i < 5; i++)
2395         {
2396           sprintf (buffer, "Page %d", i+1);
2397
2398           frame = gtk_frame_new (buffer);
2399           gtk_container_border_width (GTK_CONTAINER (frame), 10);
2400           gtk_widget_set_usize (frame, 200, 150);
2401           gtk_widget_show (frame);
2402
2403           label = gtk_label_new (buffer);
2404           gtk_container_add (GTK_CONTAINER (frame), label);
2405           gtk_widget_show (label);
2406
2407           label = gtk_label_new (buffer);
2408           gtk_notebook_append_page (GTK_NOTEBOOK (notebook), frame, label);
2409         }
2410
2411
2412       separator = gtk_hseparator_new ();
2413       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2414       gtk_widget_show (separator);
2415
2416
2417       box2 = gtk_hbox_new (FALSE, 10);
2418       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2419       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2420       gtk_widget_show (box2);
2421
2422
2423       button = gtk_button_new_with_label ("close");
2424       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2425                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2426                                  GTK_OBJECT (window));
2427       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2428       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2429       gtk_widget_grab_default (button);
2430       gtk_widget_show (button);
2431
2432       button = gtk_button_new_with_label ("next");
2433       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2434                                  GTK_SIGNAL_FUNC(gtk_notebook_next_page),
2435                                  GTK_OBJECT (notebook));
2436       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2437       gtk_widget_show (button);
2438
2439       button = gtk_button_new_with_label ("prev");
2440       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2441                                  GTK_SIGNAL_FUNC(gtk_notebook_prev_page),
2442                                  GTK_OBJECT (notebook));
2443       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2444       gtk_widget_show (button);
2445
2446       button = gtk_button_new_with_label ("rotate");
2447       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2448                           GTK_SIGNAL_FUNC(rotate_notebook),
2449                           notebook);
2450       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2451       gtk_widget_show (button);
2452     }
2453
2454   if (!GTK_WIDGET_VISIBLE (window))
2455     gtk_widget_show (window);
2456   else
2457     gtk_widget_destroy (window);
2458 }
2459
2460
2461 /*
2462  * GtkPanes
2463  */
2464 void
2465 create_panes ()
2466 {
2467   static GtkWidget *window = NULL;
2468   GtkWidget *frame;
2469   GtkWidget *hpaned;
2470   GtkWidget *vpaned;
2471
2472   if (!window)
2473     {
2474       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2475
2476       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2477                           GTK_SIGNAL_FUNC(destroy_window),
2478                           &window);
2479       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2480                           GTK_SIGNAL_FUNC(destroy_window),
2481                           &window);
2482
2483       gtk_window_set_title (GTK_WINDOW (window), "Panes");
2484       gtk_container_border_width (GTK_CONTAINER (window), 0);
2485
2486       vpaned = gtk_vpaned_new ();
2487       gtk_container_add (GTK_CONTAINER (window), vpaned);
2488       gtk_container_border_width (GTK_CONTAINER(vpaned), 5);
2489       gtk_widget_show (vpaned);
2490
2491       hpaned = gtk_hpaned_new ();
2492       gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
2493
2494       frame = gtk_frame_new (NULL);
2495       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
2496       gtk_widget_set_usize (frame, 60, 60);
2497       gtk_paned_add1 (GTK_PANED (hpaned), frame);
2498       gtk_widget_show (frame);
2499
2500       frame = gtk_frame_new (NULL);
2501       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
2502       gtk_widget_set_usize (frame, 80, 60);
2503       gtk_paned_add2 (GTK_PANED (hpaned), frame);
2504       gtk_widget_show (frame);
2505
2506       gtk_widget_show (hpaned);
2507
2508       frame = gtk_frame_new (NULL);
2509       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
2510       gtk_widget_set_usize (frame, 60, 80);
2511       gtk_paned_add2 (GTK_PANED (vpaned), frame);
2512       gtk_widget_show (frame);
2513     }
2514
2515   if (!GTK_WIDGET_VISIBLE (window))
2516     gtk_widget_show (window);
2517   else
2518     gtk_widget_destroy (window);
2519 }
2520
2521
2522 /*
2523  * Drag -N- Drop
2524  */
2525
2526 gboolean
2527 dnd_drop_destroy_popup (GtkWidget *widget, GtkWindow **window)
2528 {
2529   if(GTK_IS_BUTTON(widget)) /* I.e. they clicked the close button */
2530     gtk_widget_destroy(GTK_WIDGET(*window));
2531   else {
2532     gtk_grab_remove(GTK_WIDGET(*window));
2533     *window = NULL;
2534   }
2535   return TRUE;
2536 }
2537
2538 void
2539 dnd_drop (GtkWidget *button, GdkEvent *event)
2540 {
2541   static GtkWidget *window = NULL;
2542   GtkWidget *vbox, *lbl, *btn;
2543   gchar *msg;
2544
2545   window = gtk_window_new(GTK_WINDOW_DIALOG);
2546   gtk_container_border_width (GTK_CONTAINER(window), 10);
2547
2548   gtk_signal_connect (GTK_OBJECT (window), "destroy",
2549                       GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
2550                       &window);
2551   gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2552                       GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
2553                       &window);
2554
2555   vbox = gtk_vbox_new(FALSE, 5);
2556
2557   /* Display message that we got from drop source */
2558   msg = g_malloc(strlen(event->dropdataavailable.data)
2559                  + strlen(event->dropdataavailable.data_type) + 100);
2560   sprintf(msg, "Drop data of type %s was:\n\n%s",
2561           event->dropdataavailable.data_type,
2562           (char *)event->dropdataavailable.data);
2563   lbl = gtk_label_new(msg);
2564   gtk_label_set_justify(GTK_LABEL(lbl), GTK_JUSTIFY_FILL);
2565   g_free(msg);
2566   gtk_widget_show(lbl);
2567   gtk_box_pack_start_defaults(GTK_BOX(vbox), lbl);
2568
2569   /* Provide an obvious way out of this heinousness */
2570   btn = gtk_button_new_with_label("Continue with life in\nspite of this oppression");
2571   gtk_signal_connect (GTK_OBJECT (btn), "clicked",
2572                       GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
2573                       &window);
2574   gtk_widget_show(btn);
2575   gtk_box_pack_start_defaults(GTK_BOX(vbox), btn);
2576
2577   gtk_container_add(GTK_CONTAINER(window), vbox);
2578
2579   gtk_widget_show(vbox);
2580   gtk_grab_add(window);
2581   gtk_widget_show(window);
2582
2583   g_free (event->dropdataavailable.data);
2584   g_free (event->dropdataavailable.data_type);
2585 }
2586
2587 void
2588 dnd_drag_request (GtkWidget *button, GdkEvent *event)
2589 {
2590 #define DND_STRING "Bill Gates demands royalties for\nyour use of his innovation."
2591   gtk_widget_dnd_data_set (button, event, DND_STRING, strlen(DND_STRING) + 1);
2592 }
2593
2594 void
2595 create_dnd ()
2596 {
2597   static GtkWidget *window = NULL;
2598   GtkWidget *box1;
2599   GtkWidget *box2;
2600   GtkWidget *box3;
2601   GtkWidget *frame;
2602   GtkWidget *button;
2603   GtkWidget *separator;
2604
2605   /* For clarity... */
2606   char *possible_drag_types[] = {"text/plain"};
2607   char *accepted_drop_types[] = {"text/plain"};
2608
2609   if (!window)
2610     {
2611       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2612
2613       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2614                           GTK_SIGNAL_FUNC(destroy_window),
2615                           &window);
2616       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2617                           GTK_SIGNAL_FUNC(destroy_window),
2618                           &window);
2619
2620       gtk_window_set_title (GTK_WINDOW (window), "Drag -N- Drop");
2621       gtk_container_border_width (GTK_CONTAINER (window), 0);
2622
2623       box1 = gtk_vbox_new (FALSE, 0);
2624       gtk_container_add (GTK_CONTAINER (window), box1);
2625       gtk_widget_show (box1);
2626
2627       box2 = gtk_hbox_new (FALSE, 5);
2628       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2629       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2630       gtk_widget_show (box2);
2631
2632       frame = gtk_frame_new ("Drag");
2633       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
2634       gtk_widget_show (frame);
2635
2636       box3 = gtk_vbox_new (FALSE, 5);
2637       gtk_container_border_width (GTK_CONTAINER (box3), 5);
2638       gtk_container_add (GTK_CONTAINER (frame), box3);
2639       gtk_widget_show (box3);
2640
2641       /*
2642        * FROM Button
2643        */
2644       button = gtk_button_new_with_label ("Drag me!");
2645       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
2646       gtk_widget_show (button);
2647
2648       /*
2649        * currently, the widget has to be realized to
2650        * set dnd on it, this needs to change
2651        */
2652       gtk_widget_realize (button);
2653       gtk_signal_connect (GTK_OBJECT (button),
2654                           "drag_request_event",
2655                           GTK_SIGNAL_FUNC(dnd_drag_request),
2656                           button);
2657
2658       gtk_widget_dnd_drag_set (button, TRUE, possible_drag_types, 1);
2659
2660
2661       frame = gtk_frame_new ("Drop");
2662       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
2663       gtk_widget_show (frame);
2664
2665       box3 = gtk_vbox_new (FALSE, 5);
2666       gtk_container_border_width (GTK_CONTAINER (box3), 5);
2667       gtk_container_add (GTK_CONTAINER (frame), box3);
2668       gtk_widget_show (box3);
2669
2670
2671       /*
2672        * TO Button
2673        */
2674       button = gtk_button_new_with_label ("To");
2675       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
2676       gtk_widget_show (button);
2677
2678       gtk_widget_realize (button);
2679       gtk_signal_connect (GTK_OBJECT (button),
2680                           "drop_data_available_event",
2681                           GTK_SIGNAL_FUNC(dnd_drop),
2682                           button);
2683
2684       gtk_widget_dnd_drop_set (button, TRUE, accepted_drop_types, 1, FALSE);
2685
2686
2687       separator = gtk_hseparator_new ();
2688       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2689       gtk_widget_show (separator);
2690
2691
2692       box2 = gtk_vbox_new (FALSE, 10);
2693       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2694       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2695       gtk_widget_show (box2);
2696
2697
2698       button = gtk_button_new_with_label ("close");
2699
2700       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2701                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2702                                  GTK_OBJECT (window));
2703
2704       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2705       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2706       gtk_widget_grab_default (button);
2707       gtk_widget_show (button);
2708     }
2709
2710   if (!GTK_WIDGET_VISIBLE (window))
2711     gtk_widget_show (window);
2712   else
2713     gtk_widget_destroy (window);
2714 }
2715
2716 /*
2717  * Shaped Windows
2718  */
2719 static GdkWindow *root_win = NULL;
2720 static GtkWidget *modeller = NULL;
2721 static GtkWidget *sheets = NULL;
2722 static GtkWidget *rings = NULL;
2723
2724 typedef struct _cursoroffset {gint x,y;} CursorOffset;
2725
2726 static void
2727 shape_pressed (GtkWidget *widget)
2728 {
2729   CursorOffset *p;
2730
2731   p = gtk_object_get_user_data (GTK_OBJECT(widget));
2732   gtk_widget_get_pointer (widget, &(p->x), &(p->y));
2733
2734   gtk_grab_add (widget);
2735   gdk_pointer_grab (widget->window, TRUE,
2736                     GDK_BUTTON_RELEASE_MASK |
2737                     GDK_BUTTON_MOTION_MASK,
2738                     NULL, NULL, 0);
2739 }
2740
2741
2742 static void
2743 shape_released (GtkWidget *widget)
2744 {
2745   gtk_grab_remove (widget);
2746   gdk_pointer_ungrab (0);
2747 }
2748
2749 static void
2750 shape_motion (GtkWidget      *widget,
2751               GdkEventMotion *event)
2752 {
2753   gint xp, yp;
2754   CursorOffset * p;
2755   GdkModifierType mask;
2756
2757   p = gtk_object_get_user_data (GTK_OBJECT (widget));
2758
2759   gdk_window_get_pointer (root_win, &xp, &yp, &mask);
2760   gtk_widget_set_uposition (widget, xp  - p->x, yp  - p->y);
2761 }
2762
2763 GtkWidget *
2764 shape_create_icon (char     *xpm_file,
2765                    gint      x,
2766                    gint      y,
2767                    gint      px,
2768                    gint      py,
2769                    gint      window_type)
2770 {
2771   GtkWidget *window;
2772   GtkWidget *pixmap;
2773   GtkWidget *fixed;
2774   CursorOffset* icon_pos;
2775   GdkGC* gc;
2776   GdkBitmap *gdk_pixmap_mask;
2777   GdkPixmap *gdk_pixmap;
2778   GtkStyle *style;
2779
2780   style = gtk_widget_get_default_style ();
2781   gc = style->black_gc;
2782
2783   /*
2784    * GDK_WINDOW_TOPLEVEL works also, giving you a title border
2785    */
2786   window = gtk_window_new (window_type);
2787
2788   fixed = gtk_fixed_new ();
2789   gtk_widget_set_usize (fixed, 100,100);
2790   gtk_container_add (GTK_CONTAINER (window), fixed);
2791   gtk_widget_show (fixed);
2792
2793   gdk_pixmap = gdk_pixmap_create_from_xpm (window->window, &gdk_pixmap_mask,
2794                                            &style->bg[GTK_STATE_NORMAL],
2795                                            xpm_file);
2796
2797   pixmap = gtk_pixmap_new (gdk_pixmap, gdk_pixmap_mask);
2798   gtk_fixed_put (GTK_FIXED (fixed), pixmap, px,py);
2799   gtk_widget_show (pixmap);
2800
2801   gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px,py);
2802
2803   gtk_widget_set_events (window,
2804                          gtk_widget_get_events (window) |
2805                          GDK_BUTTON_MOTION_MASK |
2806                          GDK_BUTTON_PRESS_MASK);
2807
2808   gtk_signal_connect (GTK_OBJECT (window), "button_press_event",
2809                       GTK_SIGNAL_FUNC (shape_pressed),NULL);
2810   gtk_signal_connect (GTK_OBJECT (window), "button_release_event",
2811                       GTK_SIGNAL_FUNC (shape_released),NULL);
2812   gtk_signal_connect (GTK_OBJECT (window), "motion_notify_event",
2813                       GTK_SIGNAL_FUNC (shape_motion),NULL);
2814
2815   icon_pos = g_new (CursorOffset, 1);
2816   gtk_object_set_user_data(GTK_OBJECT(window), icon_pos);
2817
2818   gtk_widget_set_uposition (window, x, y);
2819   gtk_widget_show (window);
2820
2821   return window;
2822 }
2823
2824 void
2825 create_shapes ()
2826 {
2827   root_win = gdk_window_foreign_new (GDK_ROOT_WINDOW ());
2828
2829   if (!modeller)
2830     {
2831       modeller = shape_create_icon ("Modeller.xpm",
2832                                     440, 140, 0,0, GTK_WINDOW_POPUP);
2833
2834       gtk_signal_connect (GTK_OBJECT (modeller), "destroy",
2835                           GTK_SIGNAL_FUNC(destroy_window),
2836                           &modeller);
2837       gtk_signal_connect (GTK_OBJECT (modeller), "delete_event",
2838                           GTK_SIGNAL_FUNC(destroy_window),
2839                           &modeller);
2840     }
2841   else
2842     gtk_widget_destroy (modeller);
2843
2844   if (!sheets)
2845     {
2846       sheets = shape_create_icon ("FilesQueue.xpm",
2847                                   580, 170, 0,0, GTK_WINDOW_POPUP);
2848
2849       gtk_signal_connect (GTK_OBJECT (sheets), "destroy",
2850                           GTK_SIGNAL_FUNC(destroy_window),
2851                           &sheets);
2852       gtk_signal_connect (GTK_OBJECT (sheets), "delete_event",
2853                           GTK_SIGNAL_FUNC(destroy_window),
2854                           &sheets);
2855
2856     }
2857   else
2858     gtk_widget_destroy (sheets);
2859
2860   if (!rings)
2861     {
2862       rings = shape_create_icon ("3DRings.xpm",
2863                                  460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
2864
2865       gtk_signal_connect (GTK_OBJECT (rings), "destroy",
2866                           GTK_SIGNAL_FUNC(destroy_window),
2867                           &rings);
2868       gtk_signal_connect (GTK_OBJECT (rings), "delete_event",
2869                           GTK_SIGNAL_FUNC(destroy_window),
2870                           &rings);
2871     }
2872   else
2873     gtk_widget_destroy (rings);
2874 }
2875
2876
2877 /*
2878  * Progress Bar
2879  */
2880 static int progress_timer = 0;
2881
2882 gint
2883 progress_timeout (gpointer data)
2884 {
2885   gfloat new_val;
2886
2887   new_val = GTK_PROGRESS_BAR (data)->percentage;
2888   if (new_val >= 1.0)
2889     new_val = 0.0;
2890   new_val += 0.02;
2891
2892   gtk_progress_bar_update (GTK_PROGRESS_BAR (data), new_val);
2893
2894   return TRUE;
2895 }
2896
2897 void
2898 destroy_progress (GtkWidget  *widget,
2899                   GtkWidget **window)
2900 {
2901   destroy_window (widget, window);
2902   gtk_timeout_remove (progress_timer);
2903   progress_timer = 0;
2904 }
2905
2906 void
2907 create_progress_bar ()
2908 {
2909   static GtkWidget *window = NULL;
2910   GtkWidget *button;
2911   GtkWidget *vbox;
2912   GtkWidget *pbar;
2913   GtkWidget *label;
2914
2915   if (!window)
2916     {
2917       window = gtk_dialog_new ();
2918
2919       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2920                           GTK_SIGNAL_FUNC(destroy_progress),
2921                           &window);
2922       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2923                           GTK_SIGNAL_FUNC(destroy_progress),
2924                           &window);
2925
2926       gtk_window_set_title (GTK_WINDOW (window), "dialog");
2927       gtk_container_border_width (GTK_CONTAINER (window), 0);
2928
2929
2930       vbox = gtk_vbox_new (FALSE, 5);
2931       gtk_container_border_width (GTK_CONTAINER (vbox), 10);
2932       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
2933                           vbox, TRUE, TRUE, 0);
2934       gtk_widget_show (vbox);
2935
2936       label = gtk_label_new ("progress...");
2937       gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
2938       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
2939       gtk_widget_show (label);
2940
2941       pbar = gtk_progress_bar_new ();
2942       gtk_widget_set_usize (pbar, 200, 20);
2943       gtk_box_pack_start (GTK_BOX (vbox), pbar, TRUE, TRUE, 0);
2944       gtk_widget_show (pbar);
2945
2946       progress_timer = gtk_timeout_add (100, progress_timeout, pbar);
2947
2948       button = gtk_button_new_with_label ("close");
2949       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2950                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2951                                  GTK_OBJECT (window));
2952       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2953       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
2954                           button, TRUE, TRUE, 0);
2955       gtk_widget_grab_default (button);
2956       gtk_widget_show (button);
2957     }
2958
2959   if (!GTK_WIDGET_VISIBLE (window))
2960     gtk_widget_show (window);
2961   else
2962     gtk_widget_destroy (window);
2963 }
2964
2965
2966 /*
2967  * Color Preview
2968  */
2969 static int color_idle = 0;
2970
2971 gint
2972 color_idle_func (GtkWidget *preview)
2973 {
2974   static int count = 1;
2975   guchar buf[768];
2976   int i, j, k;
2977
2978   for (i = 0; i < 256; i++)
2979     {
2980       for (j = 0, k = 0; j < 256; j++)
2981         {
2982           buf[k+0] = i + count;
2983           buf[k+1] = 0;
2984           buf[k+2] = j + count;
2985           k += 3;
2986         }
2987
2988       gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
2989     }
2990
2991   count += 1;
2992
2993   gtk_widget_draw (preview, NULL);
2994
2995   return TRUE;
2996 }
2997
2998 void
2999 color_preview_destroy (GtkWidget  *widget,
3000                        GtkWidget **window)
3001 {
3002   gtk_idle_remove (color_idle);
3003   color_idle = 0;
3004
3005   destroy_window (widget, window);
3006 }
3007
3008 void
3009 create_color_preview ()
3010 {
3011   static GtkWidget *window = NULL;
3012   GtkWidget *preview;
3013   guchar buf[768];
3014   int i, j, k;
3015
3016   if (!window)
3017     {
3018       gtk_widget_push_visual (gtk_preview_get_visual ());
3019       gtk_widget_push_colormap (gtk_preview_get_cmap ());
3020
3021       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3022
3023       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3024                           GTK_SIGNAL_FUNC(color_preview_destroy),
3025                           &window);
3026       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3027                           GTK_SIGNAL_FUNC(color_preview_destroy),
3028                           &window);
3029
3030       gtk_window_set_title (GTK_WINDOW (window), "test");
3031       gtk_container_border_width (GTK_CONTAINER (window), 10);
3032
3033       preview = gtk_preview_new (GTK_PREVIEW_COLOR);
3034       gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
3035       gtk_container_add (GTK_CONTAINER (window), preview);
3036       gtk_widget_show (preview);
3037
3038       for (i = 0; i < 256; i++)
3039         {
3040           for (j = 0, k = 0; j < 256; j++)
3041             {
3042               buf[k+0] = i;
3043               buf[k+1] = 0;
3044               buf[k+2] = j;
3045               k += 3;
3046             }
3047
3048           gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
3049         }
3050
3051       color_idle = gtk_idle_add ((GtkFunction) color_idle_func, preview);
3052
3053       gtk_widget_pop_colormap ();
3054       gtk_widget_pop_visual ();
3055     }
3056
3057   if (!GTK_WIDGET_VISIBLE (window))
3058     gtk_widget_show (window);
3059   else
3060     gtk_widget_destroy (window);
3061 }
3062
3063
3064 /*
3065  * Gray Preview
3066  */
3067 static int gray_idle = 0;
3068
3069 gint
3070 gray_idle_func (GtkWidget *preview)
3071 {
3072   static int count = 1;
3073   guchar buf[256];
3074   int i, j;
3075
3076   for (i = 0; i < 256; i++)
3077     {
3078       for (j = 0; j < 256; j++)
3079         buf[j] = i + j + count;
3080
3081       gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
3082     }
3083
3084   count += 1;
3085
3086   gtk_widget_draw (preview, NULL);
3087
3088   return TRUE;
3089 }
3090
3091 void
3092 gray_preview_destroy (GtkWidget  *widget,
3093                       GtkWidget **window)
3094 {
3095   gtk_idle_remove (gray_idle);
3096   gray_idle = 0;
3097
3098   destroy_window (widget, window);
3099 }
3100
3101 void
3102 create_gray_preview ()
3103 {
3104   static GtkWidget *window = NULL;
3105   GtkWidget *preview;
3106   guchar buf[256];
3107   int i, j;
3108
3109   if (!window)
3110     {
3111       gtk_widget_push_visual (gtk_preview_get_visual ());
3112       gtk_widget_push_colormap (gtk_preview_get_cmap ());
3113
3114       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3115
3116       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3117                           GTK_SIGNAL_FUNC(gray_preview_destroy),
3118                           &window);
3119       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3120                           GTK_SIGNAL_FUNC(gray_preview_destroy),
3121                           &window);
3122
3123       gtk_window_set_title (GTK_WINDOW (window), "test");
3124       gtk_container_border_width (GTK_CONTAINER (window), 10);
3125
3126       preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
3127       gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
3128       gtk_container_add (GTK_CONTAINER (window), preview);
3129       gtk_widget_show (preview);
3130
3131       for (i = 0; i < 256; i++)
3132         {
3133           for (j = 0; j < 256; j++)
3134             buf[j] = i + j;
3135
3136           gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
3137         }
3138
3139       gray_idle = gtk_idle_add ((GtkFunction) gray_idle_func, preview);
3140
3141       gtk_widget_pop_colormap ();
3142       gtk_widget_pop_visual ();
3143     }
3144
3145   if (!GTK_WIDGET_VISIBLE (window))
3146     gtk_widget_show (window);
3147   else
3148     gtk_widget_destroy (window);
3149 }
3150
3151
3152 /*
3153  * Selection Test
3154  */
3155 void
3156 selection_test_received (GtkWidget *list, GtkSelectionData *data)
3157 {
3158   GdkAtom *atoms;
3159   GtkWidget *list_item;
3160   GList *item_list;
3161   int i, l;
3162
3163   if (data->length < 0)
3164     {
3165       g_print ("Selection retrieval failed\n");
3166       return;
3167     }
3168   if (data->type != GDK_SELECTION_TYPE_ATOM)
3169     {
3170       g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
3171       return;
3172     }
3173
3174   /* Clear out any current list items */
3175
3176   gtk_list_clear_items (GTK_LIST(list), 0, -1);
3177
3178   /* Add new items to list */
3179
3180   atoms = (GdkAtom *)data->data;
3181
3182   item_list = NULL;
3183   l = data->length / sizeof (GdkAtom);
3184   for (i = 0; i < l; i++)
3185     {
3186       char *name;
3187       name = gdk_atom_name (atoms[i]);
3188       if (name != NULL)
3189         {
3190           list_item = gtk_list_item_new_with_label (name);
3191           g_free (name);
3192         }
3193       else
3194         list_item = gtk_list_item_new_with_label ("(bad atom)");
3195
3196       gtk_widget_show (list_item);
3197       item_list = g_list_append (item_list, list_item);
3198     }
3199
3200   gtk_list_append_items (GTK_LIST (list), item_list);
3201
3202   return;
3203 }
3204
3205 void
3206 selection_test_get_targets (GtkWidget *widget, GtkWidget *list)
3207 {
3208   static GdkAtom targets_atom = GDK_NONE;
3209
3210   if (targets_atom == GDK_NONE)
3211     targets_atom = gdk_atom_intern ("TARGETS", FALSE);
3212
3213   gtk_selection_convert (list, GDK_SELECTION_PRIMARY, targets_atom,
3214                          GDK_CURRENT_TIME);
3215 }
3216
3217 void
3218 create_selection_test ()
3219 {
3220   static GtkWidget *window = NULL;
3221   GtkWidget *button;
3222   GtkWidget *vbox;
3223   GtkWidget *scrolled_win;
3224   GtkWidget *list;
3225   GtkWidget *label;
3226
3227   if (!window)
3228     {
3229       window = gtk_dialog_new ();
3230
3231       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3232                           GTK_SIGNAL_FUNC(destroy_window),
3233                           &window);
3234       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3235                           GTK_SIGNAL_FUNC(destroy_window),
3236                           &window);
3237
3238       gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
3239       gtk_container_border_width (GTK_CONTAINER (window), 0);
3240
3241       /* Create the list */
3242
3243       vbox = gtk_vbox_new (FALSE, 5);
3244       gtk_container_border_width (GTK_CONTAINER (vbox), 10);
3245       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox,
3246                           TRUE, TRUE, 0);
3247       gtk_widget_show (vbox);
3248
3249       label = gtk_label_new ("Gets available targets for current selection");
3250       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
3251       gtk_widget_show (label);
3252
3253       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
3254       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
3255                                       GTK_POLICY_AUTOMATIC,
3256                                       GTK_POLICY_AUTOMATIC);
3257       gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
3258       gtk_widget_set_usize (scrolled_win, 100, 200);
3259       gtk_widget_show (scrolled_win);
3260
3261       list = gtk_list_new ();
3262       gtk_container_add (GTK_CONTAINER (scrolled_win), list);
3263
3264       gtk_signal_connect (GTK_OBJECT(list), "selection_received",
3265                           GTK_SIGNAL_FUNC (selection_test_received), NULL);
3266       gtk_widget_show (list);
3267
3268       /* .. And create some buttons */
3269       button = gtk_button_new_with_label ("Get Targets");
3270       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3271                           button, TRUE, TRUE, 0);
3272
3273       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3274                           GTK_SIGNAL_FUNC (selection_test_get_targets), list);
3275       gtk_widget_show (button);
3276
3277       button = gtk_button_new_with_label ("Quit");
3278       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3279                           button, TRUE, TRUE, 0);
3280
3281       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3282                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
3283                                  GTK_OBJECT (window));
3284       gtk_widget_show (button);
3285     }
3286
3287   if (!GTK_WIDGET_VISIBLE (window))
3288     gtk_widget_show (window);
3289   else
3290     gtk_widget_destroy (window);
3291 }
3292
3293
3294 /*
3295  * Gamma Curve
3296  */
3297 void
3298 create_gamma_curve ()
3299 {
3300   static GtkWidget *window = NULL, *curve;
3301   static int count = 0;
3302   gfloat vec[256];
3303   gint max;
3304   gint i;
3305
3306   if (!window)
3307     {
3308       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3309       gtk_window_set_title (GTK_WINDOW (window), "test");
3310       gtk_container_border_width (GTK_CONTAINER (window), 10);
3311
3312       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3313                           GTK_SIGNAL_FUNC(destroy_window),
3314                           &window);
3315       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3316                           GTK_SIGNAL_FUNC(destroy_window),
3317                           &window);
3318
3319       curve = gtk_gamma_curve_new ();
3320       gtk_container_add (GTK_CONTAINER (window), curve);
3321       gtk_widget_show (curve);
3322     }
3323
3324   max = 127 + (count % 2)*128;
3325   gtk_curve_set_range (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
3326                        0, max, 0, max);
3327   for (i = 0; i < max; ++i)
3328     vec[i] = (127 / sqrt (max)) * sqrt (i);
3329   gtk_curve_set_vector (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
3330                         max, vec);
3331
3332   if (!GTK_WIDGET_VISIBLE (window))
3333     gtk_widget_show (window);
3334   else if (count % 4 == 3)
3335     {
3336       gtk_widget_destroy (window);
3337       window = NULL;
3338     }
3339
3340   ++count;
3341 }
3342
3343 static int scroll_test_pos = 0.0;
3344 static GdkGC *scroll_test_gc = NULL;
3345
3346 static gint
3347 scroll_test_expose (GtkWidget *widget, GdkEventExpose *event,
3348                     GtkAdjustment *adj)
3349 {
3350   gint i,j;
3351   gint imin, imax, jmin, jmax;
3352
3353   imin = (event->area.x) / 10;
3354   imax = (event->area.x + event->area.width + 9) / 10;
3355
3356   jmin = ((int)adj->value + event->area.y) / 10;
3357   jmax = ((int)adj->value + event->area.y + event->area.height + 9) / 10;
3358
3359   gdk_window_clear_area (widget->window,
3360                          event->area.x, event->area.y,
3361                          event->area.width, event->area.height);
3362
3363   for (i=imin; i<imax; i++)
3364     for (j=jmin; j<jmax; j++)
3365       if ((i+j) % 2)
3366         gdk_draw_rectangle (widget->window,
3367                             widget->style->black_gc,
3368                             TRUE,
3369                             10*i, 10*j - (int)adj->value, 1+i%10, 1+j%10);
3370
3371   return TRUE;
3372 }
3373
3374 static void
3375 scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
3376                        GtkAdjustment *adj)
3377 {
3378   adj->page_increment = 0.9 * widget->allocation.height;
3379   adj->page_size = widget->allocation.height;
3380
3381   gtk_signal_emit_by_name (GTK_OBJECT (adj), "changed");
3382 }
3383
3384 static void
3385 scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
3386 {
3387   gint source_min = (int)adj->value - scroll_test_pos;
3388   gint source_max = source_min + widget->allocation.height;
3389   gint dest_min = 0;
3390   gint dest_max = widget->allocation.height;
3391   GdkRectangle rect;
3392   GdkEvent *event;
3393
3394   scroll_test_pos = adj->value;
3395
3396   if (!GTK_WIDGET_DRAWABLE (widget))
3397     return;
3398
3399   if (source_min < 0)
3400     {
3401       rect.x = 0;
3402       rect.y = 0;
3403       rect.width = widget->allocation.width;
3404       rect.height = -source_min;
3405       if (rect.height > widget->allocation.height)
3406         rect.height = widget->allocation.height;
3407
3408       source_min = 0;
3409       dest_min = rect.height;
3410     }
3411   else
3412     {
3413       rect.x = 0;
3414       rect.y = 2*widget->allocation.height - source_max;
3415       if (rect.y < 0)
3416         rect.y = 0;
3417       rect.width = widget->allocation.width;
3418       rect.height = widget->allocation.height - rect.y;
3419
3420       source_max = widget->allocation.height;
3421       dest_max = rect.y;
3422     }
3423
3424   if (source_min != source_max)
3425     {
3426       if (scroll_test_gc == NULL)
3427         {
3428           scroll_test_gc = gdk_gc_new (widget->window);
3429           gdk_gc_set_exposures (scroll_test_gc, TRUE);
3430         }
3431
3432       gdk_draw_pixmap (widget->window,
3433                        scroll_test_gc,
3434                        widget->window,
3435                        0, source_min,
3436                        0, dest_min,
3437                        widget->allocation.width,
3438                        source_max - source_min);
3439
3440       /* Make sure graphics expose events are processed before scrolling
3441        * again */
3442
3443       while ((event = gdk_event_get_graphics_expose (widget->window)) != NULL)
3444         {
3445           gtk_widget_event (widget, event);
3446           if (event->expose.count == 0)
3447             {
3448               gdk_event_free (event);
3449               break;
3450             }
3451           gdk_event_free (event);
3452         }
3453     }
3454
3455
3456   if (rect.height != 0)
3457     gtk_widget_draw (widget, &rect);
3458 }
3459
3460
3461 void
3462 create_scroll_test ()
3463 {
3464   static GtkWidget *window = NULL;
3465   GtkWidget *hbox;
3466   GtkWidget *drawing_area;
3467   GtkWidget *scrollbar;
3468   GtkWidget *button;
3469   GtkAdjustment *adj;
3470
3471   if (!window)
3472     {
3473       window = gtk_dialog_new ();
3474
3475       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3476                           GTK_SIGNAL_FUNC(destroy_window),
3477                           &window);
3478       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3479                           GTK_SIGNAL_FUNC(destroy_window),
3480                           &window);
3481
3482       gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
3483       gtk_container_border_width (GTK_CONTAINER (window), 0);
3484
3485       hbox = gtk_hbox_new (FALSE, 0);
3486       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox,
3487                           TRUE, TRUE, 0);
3488       gtk_widget_show (hbox);
3489
3490       drawing_area = gtk_drawing_area_new ();
3491       gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 200, 200);
3492       gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
3493       gtk_widget_show (drawing_area);
3494
3495       gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK);
3496
3497       adj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0));
3498       scroll_test_pos = 0.0;
3499
3500       scrollbar = gtk_vscrollbar_new (adj);
3501       gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
3502       gtk_widget_show (scrollbar);
3503
3504       gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
3505                           GTK_SIGNAL_FUNC (scroll_test_expose), adj);
3506       gtk_signal_connect (GTK_OBJECT (drawing_area), "configure_event",
3507                           GTK_SIGNAL_FUNC (scroll_test_configure), adj);
3508
3509
3510       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
3511                           GTK_SIGNAL_FUNC (scroll_test_adjustment_changed),
3512                           drawing_area);
3513
3514       /* .. And create some buttons */
3515
3516       button = gtk_button_new_with_label ("Quit");
3517       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3518                           button, TRUE, TRUE, 0);
3519
3520       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3521                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
3522                                  GTK_OBJECT (window));
3523       gtk_widget_show (button);
3524     }
3525
3526   if (!GTK_WIDGET_VISIBLE (window))
3527     gtk_widget_show (window);
3528   else
3529     gtk_widget_destroy (window);
3530 }
3531
3532 /*
3533  * Timeout Test
3534  */
3535 static int timer = 0;
3536
3537 void
3538 timeout_test (GtkWidget *label)
3539 {
3540   static int count = 0;
3541   static char buffer[32];
3542
3543   sprintf (buffer, "count: %d", ++count);
3544   gtk_label_set (GTK_LABEL (label), buffer);
3545 }
3546
3547 void
3548 start_timeout_test (GtkWidget *widget,
3549                     GtkWidget *label)
3550 {
3551   if (!timer)
3552     {
3553       timer = gtk_timeout_add (100, (GtkFunction) timeout_test, label);
3554     }
3555 }
3556
3557 void
3558 stop_timeout_test (GtkWidget *widget,
3559                    gpointer   data)
3560 {
3561   if (timer)
3562     {
3563       gtk_timeout_remove (timer);
3564       timer = 0;
3565     }
3566 }
3567
3568 void
3569 destroy_timeout_test (GtkWidget  *widget,
3570                       GtkWidget **window)
3571 {
3572   destroy_window (widget, window);
3573   stop_timeout_test (NULL, NULL);
3574 }
3575
3576 void
3577 create_timeout_test ()
3578 {
3579   static GtkWidget *window = NULL;
3580   GtkWidget *button;
3581   GtkWidget *label;
3582
3583   if (!window)
3584     {
3585       window = gtk_dialog_new ();
3586
3587       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3588                           GTK_SIGNAL_FUNC(destroy_timeout_test),
3589                           &window);
3590       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3591                           GTK_SIGNAL_FUNC(destroy_timeout_test),
3592                           &window);
3593
3594       gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
3595       gtk_container_border_width (GTK_CONTAINER (window), 0);
3596
3597       label = gtk_label_new ("count: 0");
3598       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
3599       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
3600                           label, TRUE, TRUE, 0);
3601       gtk_widget_show (label);
3602
3603       button = gtk_button_new_with_label ("close");
3604       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3605                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
3606                                  GTK_OBJECT (window));
3607       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3608       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3609                           button, TRUE, TRUE, 0);
3610       gtk_widget_grab_default (button);
3611       gtk_widget_show (button);
3612
3613       button = gtk_button_new_with_label ("start");
3614       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3615                           GTK_SIGNAL_FUNC(start_timeout_test),
3616                           label);
3617       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3618       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3619                           button, TRUE, TRUE, 0);
3620       gtk_widget_show (button);
3621
3622       button = gtk_button_new_with_label ("stop");
3623       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3624                           GTK_SIGNAL_FUNC(stop_timeout_test),
3625                           NULL);
3626       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3627       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3628                           button, TRUE, TRUE, 0);
3629       gtk_widget_show (button);
3630     }
3631
3632   if (!GTK_WIDGET_VISIBLE (window))
3633     gtk_widget_show (window);
3634   else
3635     gtk_widget_destroy (window);
3636 }
3637
3638
3639 /*
3640  * Idle Test
3641  */
3642 static int idle = 0;
3643
3644 gint
3645 idle_test (GtkWidget *label)
3646 {
3647   static int count = 0;
3648   static char buffer[32];
3649
3650   sprintf (buffer, "count: %d", ++count);
3651   gtk_label_set (GTK_LABEL (label), buffer);
3652
3653   return TRUE;
3654 }
3655
3656 void
3657 start_idle_test (GtkWidget *widget,
3658                  GtkWidget *label)
3659 {
3660   if (!idle)
3661     {
3662       idle = gtk_idle_add ((GtkFunction) idle_test, label);
3663     }
3664 }
3665
3666 void
3667 stop_idle_test (GtkWidget *widget,
3668                 gpointer   data)
3669 {
3670   if (idle)
3671     {
3672       gtk_idle_remove (idle);
3673       idle = 0;
3674     }
3675 }
3676
3677 void
3678 destroy_idle_test (GtkWidget  *widget,
3679                    GtkWidget **window)
3680 {
3681   destroy_window (widget, window);
3682   stop_idle_test (NULL, NULL);
3683 }
3684
3685 void
3686 create_idle_test ()
3687 {
3688   static GtkWidget *window = NULL;
3689   GtkWidget *button;
3690   GtkWidget *label;
3691
3692   if (!window)
3693     {
3694       window = gtk_dialog_new ();
3695
3696       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3697                           GTK_SIGNAL_FUNC(destroy_idle_test),
3698                           &window);
3699       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3700                           GTK_SIGNAL_FUNC(destroy_idle_test),
3701                           &window);
3702
3703       gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
3704       gtk_container_border_width (GTK_CONTAINER (window), 0);
3705
3706       label = gtk_label_new ("count: 0");
3707       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
3708       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
3709                           label, TRUE, TRUE, 0);
3710       gtk_widget_show (label);
3711
3712       button = gtk_button_new_with_label ("close");
3713       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3714                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
3715                                  GTK_OBJECT (window));
3716       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3717       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3718                           button, TRUE, TRUE, 0);
3719       gtk_widget_grab_default (button);
3720       gtk_widget_show (button);
3721
3722       button = gtk_button_new_with_label ("start");
3723       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3724                           GTK_SIGNAL_FUNC(start_idle_test),
3725                           label);
3726       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3727       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3728                           button, TRUE, TRUE, 0);
3729       gtk_widget_show (button);
3730
3731       button = gtk_button_new_with_label ("stop");
3732       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3733                           GTK_SIGNAL_FUNC(stop_idle_test),
3734                           NULL);
3735       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3736       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3737                           button, TRUE, TRUE, 0);
3738       gtk_widget_show (button);
3739     }
3740
3741   if (!GTK_WIDGET_VISIBLE (window))
3742     gtk_widget_show (window);
3743   else
3744     gtk_widget_destroy (window);
3745 }
3746
3747 void
3748 test_destroy (GtkWidget  *widget,
3749               GtkWidget **window)
3750 {
3751   destroy_window (widget, window);
3752   gtk_main_quit ();
3753 }
3754
3755 /*
3756  * Basic Test
3757  */
3758 void
3759 create_test ()
3760 {
3761   static GtkWidget *window = NULL;
3762
3763   if (!window)
3764     {
3765       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3766
3767       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3768                           GTK_SIGNAL_FUNC(test_destroy),
3769                           &window);
3770       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3771                           GTK_SIGNAL_FUNC(test_destroy),
3772                           &window);
3773
3774
3775       gtk_window_set_title (GTK_WINDOW (window), "test");
3776       gtk_container_border_width (GTK_CONTAINER (window), 0);
3777     }
3778
3779   if (!GTK_WIDGET_VISIBLE (window))
3780     {
3781       gtk_widget_show (window);
3782
3783       g_print ("create_test: start\n");
3784       gtk_main ();
3785       g_print ("create_test: done\n");
3786     }
3787   else
3788     gtk_widget_destroy (window);
3789 }
3790
3791
3792 /*
3793  * Main Window and Exit
3794  */
3795 void
3796 do_exit ()
3797 {
3798   gtk_exit (0);
3799 }
3800
3801 void
3802 create_main_window ()
3803 {
3804   struct {
3805     char *label;
3806     void (*func) ();
3807   } buttons[] =
3808     {
3809       { "buttons", create_buttons },
3810       { "toggle buttons", create_toggle_buttons },
3811       { "check buttons", create_check_buttons },
3812       { "radio buttons", create_radio_buttons },
3813       { "button box", create_button_box },
3814       { "toolbar", create_toolbar },
3815       { "handle box", create_handle_box },
3816       { "reparent", create_reparent },
3817       { "pixmap", create_pixmap },
3818       { "tooltips", create_tooltips },
3819       { "menus", create_menus },
3820       { "scrolled windows", create_scrolled_windows },
3821       { "drawing areas", NULL },
3822       { "entry", create_entry },
3823       { "list", create_list },
3824       { "clist", create_clist},
3825       { "color selection", create_color_selection },
3826       { "file selection", create_file_selection },
3827       { "dialog", create_dialog },
3828       { "miscellaneous", NULL },
3829       { "range controls", create_range_controls },
3830       { "rulers", create_rulers },
3831       { "text", create_text },
3832       { "notebook", create_notebook },
3833       { "panes", create_panes },
3834       { "shapes", create_shapes },
3835       { "dnd", create_dnd },
3836       { "progress bar", create_progress_bar },
3837       { "preview color", create_color_preview },
3838       { "preview gray", create_gray_preview },
3839       { "gamma curve", create_gamma_curve },
3840       { "test scrolling", create_scroll_test },
3841       { "test selection", create_selection_test },
3842       { "test timeout", create_timeout_test },
3843       { "test idle", create_idle_test },
3844       { "test", create_test },
3845     };
3846   int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
3847   GtkWidget *window;
3848   GtkWidget *box1;
3849   GtkWidget *box2;
3850   GtkWidget *scrolled_window;
3851   GtkWidget *button;
3852   GtkWidget *separator;
3853   int i;
3854
3855   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3856   gtk_widget_set_name (window, "main window");
3857   gtk_widget_set_usize (window, 200, 400);
3858   gtk_widget_set_uposition (window, 20, 20);
3859
3860   gtk_signal_connect (GTK_OBJECT (window), "destroy",
3861                       GTK_SIGNAL_FUNC(gtk_main_quit),
3862                       NULL);
3863   gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3864                       GTK_SIGNAL_FUNC(gtk_main_quit),
3865                       NULL);
3866
3867   box1 = gtk_vbox_new (FALSE, 0);
3868   gtk_container_add (GTK_CONTAINER (window), box1);
3869   gtk_widget_show (box1);
3870
3871   scrolled_window = gtk_scrolled_window_new (NULL, NULL);
3872   gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
3873   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
3874                                   GTK_POLICY_AUTOMATIC,
3875                                   GTK_POLICY_AUTOMATIC);
3876   gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
3877   gtk_widget_show (scrolled_window);
3878
3879   box2 = gtk_vbox_new (FALSE, 0);
3880   gtk_container_border_width (GTK_CONTAINER (box2), 10);
3881   gtk_container_add (GTK_CONTAINER (scrolled_window), box2);
3882   gtk_widget_show (box2);
3883
3884   for (i = 0; i < nbuttons; i++)
3885     {
3886       button = gtk_button_new_with_label (buttons[i].label);
3887       if (buttons[i].func)
3888         gtk_signal_connect (GTK_OBJECT (button),
3889                             "clicked",
3890                             GTK_SIGNAL_FUNC(buttons[i].func),
3891                             NULL);
3892       else
3893         gtk_widget_set_sensitive (button, FALSE);
3894       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3895       gtk_widget_show (button);
3896     }
3897
3898   separator = gtk_hseparator_new ();
3899   gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3900   gtk_widget_show (separator);
3901
3902   box2 = gtk_vbox_new (FALSE, 10);
3903   gtk_container_border_width (GTK_CONTAINER (box2), 10);
3904   gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3905   gtk_widget_show (box2);
3906
3907   button = gtk_button_new_with_label ("close");
3908   gtk_signal_connect (GTK_OBJECT (button), "clicked",
3909                       GTK_SIGNAL_FUNC(do_exit), NULL);
3910   gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3911   GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3912   gtk_widget_grab_default (button);
3913   gtk_widget_show (button);
3914
3915   gtk_widget_show (window);
3916 }
3917
3918 int
3919 main (int argc, char *argv[])
3920 {
3921   gtk_set_locale ();
3922
3923   gtk_init (&argc, &argv);
3924   gtk_rc_parse ("testgtkrc");
3925
3926   create_main_window ();
3927
3928   gtk_main ();
3929
3930   return 0;
3931 }