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 void
1335 create_entry ()
1336 {
1337   static GtkWidget *window = NULL;
1338   GtkWidget *box1;
1339   GtkWidget *box2;
1340   GtkWidget *entry;
1341   GtkWidget *button;
1342   GtkWidget *separator;
1343
1344   /*  if (!window) */
1345     {
1346       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1347
1348       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1349                           GTK_SIGNAL_FUNC(destroy_window),
1350                           &window);
1351       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
1352                           GTK_SIGNAL_FUNC(destroy_window),
1353                           &window);
1354
1355       gtk_window_set_title (GTK_WINDOW (window), "entry");
1356       gtk_container_border_width (GTK_CONTAINER (window), 0);
1357
1358
1359       box1 = gtk_vbox_new (FALSE, 0);
1360       gtk_container_add (GTK_CONTAINER (window), box1);
1361       gtk_widget_show (box1);
1362
1363
1364       box2 = gtk_vbox_new (FALSE, 10);
1365       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1366       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1367       gtk_widget_show (box2);
1368
1369
1370       entry = gtk_entry_new ();
1371       /* gtk_widget_set_usize (entry, 0, 25); */
1372       gtk_entry_set_text (GTK_ENTRY (entry), "hello world");
1373       gtk_entry_select_region (GTK_ENTRY (entry),
1374                                0, GTK_ENTRY(entry)->text_length);
1375       gtk_box_pack_start (GTK_BOX (box2), entry, TRUE, TRUE, 0);
1376       gtk_widget_show (entry);
1377
1378
1379       separator = gtk_hseparator_new ();
1380       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1381       gtk_widget_show (separator);
1382
1383
1384       box2 = gtk_vbox_new (FALSE, 10);
1385       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1386       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1387       gtk_widget_show (box2);
1388
1389
1390       button = gtk_button_new_with_label ("close");
1391       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1392                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1393                                  GTK_OBJECT (window));
1394       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1395       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1396       gtk_widget_grab_default (button);
1397       gtk_widget_show (button);
1398     }
1399
1400   if (!GTK_WIDGET_VISIBLE (window))
1401     gtk_widget_show (window);
1402   /*  else
1403     gtk_widget_destroy (window); */
1404 }
1405
1406 /*
1407  * GtkList
1408  */
1409 void
1410 list_add (GtkWidget *widget,
1411           GtkWidget *list)
1412 {
1413   static int i = 1;
1414   gchar buffer[64];
1415   GtkWidget *list_item;
1416
1417   sprintf (buffer, "added item %d", i++);
1418   list_item = gtk_list_item_new_with_label (buffer);
1419   gtk_widget_show (list_item);
1420   gtk_container_add (GTK_CONTAINER (list), list_item);
1421 }
1422
1423 void
1424 list_remove (GtkWidget *widget,
1425              GtkWidget *list)
1426 {
1427   GList *tmp_list;
1428   GList *clear_list;
1429
1430   tmp_list = GTK_LIST (list)->selection;
1431   clear_list = NULL;
1432
1433   while (tmp_list)
1434     {
1435       clear_list = g_list_prepend (clear_list, tmp_list->data);
1436       tmp_list = tmp_list->next;
1437     }
1438
1439   clear_list = g_list_reverse (clear_list);
1440
1441   gtk_list_remove_items (GTK_LIST (list), clear_list);
1442
1443   tmp_list = clear_list;
1444
1445   while (tmp_list)
1446     {
1447       gtk_widget_destroy (GTK_WIDGET (tmp_list->data));
1448       tmp_list = tmp_list->next;
1449     }
1450
1451   g_list_free (clear_list);
1452 }
1453
1454 void
1455 create_list ()
1456 {
1457   static GtkWidget *window = NULL;
1458   static char *list_items[] =
1459   {
1460     "hello",
1461     "world",
1462     "blah",
1463     "foo",
1464     "bar",
1465     "argh",
1466     "spencer",
1467     "is a",
1468     "wussy",
1469     "programmer",
1470   };
1471   static int nlist_items = sizeof (list_items) / sizeof (list_items[0]);
1472
1473   GtkWidget *box1;
1474   GtkWidget *box2;
1475   GtkWidget *scrolled_win;
1476   GtkWidget *list;
1477   GtkWidget *list_item;
1478   GtkWidget *button;
1479   GtkWidget *separator;
1480   int i;
1481
1482   if (!window)
1483     {
1484       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1485
1486       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1487                           GTK_SIGNAL_FUNC(destroy_window),
1488                           &window);
1489       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
1490                           GTK_SIGNAL_FUNC(destroy_window),
1491                           &window);
1492
1493       gtk_window_set_title (GTK_WINDOW (window), "list");
1494       gtk_container_border_width (GTK_CONTAINER (window), 0);
1495
1496
1497       box1 = gtk_vbox_new (FALSE, 0);
1498       gtk_container_add (GTK_CONTAINER (window), box1);
1499       gtk_widget_show (box1);
1500
1501
1502       box2 = gtk_vbox_new (FALSE, 10);
1503       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1504       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1505       gtk_widget_show (box2);
1506
1507
1508       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
1509       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
1510                                       GTK_POLICY_AUTOMATIC,
1511                                       GTK_POLICY_AUTOMATIC);
1512       gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
1513       gtk_widget_show (scrolled_win);
1514
1515       list = gtk_list_new ();
1516       gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_MULTIPLE);
1517       gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_BROWSE);
1518       gtk_container_add (GTK_CONTAINER (scrolled_win), list);
1519       gtk_widget_show (list);
1520
1521       for (i = 0; i < nlist_items; i++)
1522         {
1523           list_item = gtk_list_item_new_with_label (list_items[i]);
1524           gtk_container_add (GTK_CONTAINER (list), list_item);
1525           gtk_widget_show (list_item);
1526         }
1527
1528       button = gtk_button_new_with_label ("add");
1529       GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
1530       gtk_signal_connect (GTK_OBJECT (button), "clicked",
1531                           GTK_SIGNAL_FUNC(list_add),
1532                           list);
1533       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
1534       gtk_widget_show (button);
1535
1536       button = gtk_button_new_with_label ("remove");
1537       GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
1538       gtk_signal_connect (GTK_OBJECT (button), "clicked",
1539                           GTK_SIGNAL_FUNC(list_remove),
1540                           list);
1541       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
1542       gtk_widget_show (button);
1543
1544
1545       separator = gtk_hseparator_new ();
1546       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1547       gtk_widget_show (separator);
1548
1549
1550       box2 = gtk_vbox_new (FALSE, 10);
1551       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1552       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1553       gtk_widget_show (box2);
1554
1555
1556       button = gtk_button_new_with_label ("close");
1557       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1558                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1559                                  GTK_OBJECT (window));
1560       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1561       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1562       gtk_widget_grab_default (button);
1563       gtk_widget_show (button);
1564     }
1565
1566   if (!GTK_WIDGET_VISIBLE (window))
1567     gtk_widget_show (window);
1568   else
1569     gtk_widget_destroy (window);
1570 }
1571
1572 /*
1573  * GtkCList
1574  */
1575 #define TESTGTK_CLIST_COLUMNS 7
1576 static gint clist_rows = 0;
1577 static gint clist_selected_row = 0;
1578
1579 void
1580 add1000_clist (GtkWidget *widget, gpointer data)
1581 {
1582   gint i;
1583   char text[TESTGTK_CLIST_COLUMNS][50];
1584   char *texts[TESTGTK_CLIST_COLUMNS];
1585
1586   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
1587     {
1588       texts[i] = text[i];
1589       sprintf (text[i], "Column %d", i);
1590     }
1591
1592   sprintf (text[1], "Right");
1593   sprintf (text[2], "Center");
1594
1595   gtk_clist_freeze (GTK_CLIST (data));
1596   for (i = 0; i < 1000; i++)
1597     {
1598       sprintf (text[0], "Row %d", clist_rows++);
1599       gtk_clist_append (GTK_CLIST (data), texts);
1600     }
1601   gtk_clist_thaw (GTK_CLIST (data));
1602
1603 }
1604
1605 void
1606 add10000_clist (GtkWidget *widget, gpointer data)
1607 {
1608   gint i;
1609   char text[TESTGTK_CLIST_COLUMNS][50];
1610   char *texts[TESTGTK_CLIST_COLUMNS];
1611
1612   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
1613     {
1614       texts[i] = text[i];
1615       sprintf (text[i], "Column %d", i);
1616     }
1617
1618   sprintf (text[1], "Right");
1619   sprintf (text[2], "Center");
1620
1621   gtk_clist_freeze (GTK_CLIST (data));
1622   for (i = 0; i < 10000; i++)
1623     {
1624       sprintf (text[0], "Row %d", clist_rows++);
1625       gtk_clist_append (GTK_CLIST (data), texts);
1626     }
1627   gtk_clist_thaw (GTK_CLIST (data));
1628
1629 }
1630
1631 void
1632 clear_clist (GtkWidget *widget, gpointer data)
1633 {
1634   gtk_clist_clear (GTK_CLIST (data));
1635   clist_rows = 0;
1636 }
1637
1638 void
1639 remove_row_clist (GtkWidget *widget, gpointer data)
1640 {
1641   gtk_clist_remove (GTK_CLIST (data), clist_selected_row);
1642   clist_rows--;
1643 }
1644
1645 void
1646 select_clist (GtkWidget *widget,
1647               gint row,
1648               gint column,
1649               GdkEventButton *bevent)
1650 {
1651   gint button = 0;
1652
1653   if (bevent)
1654     button = bevent->button;
1655
1656   g_print ("GtkCList Selection: row %d column %d button %d\n",
1657            row, column, button);
1658
1659   clist_selected_row = row;
1660 }
1661
1662 void
1663 create_clist ()
1664 {
1665   gint i;
1666   static GtkWidget *window = NULL;
1667
1668   static char *titles[] =
1669   {
1670     "Title 0",
1671     "Title 1",
1672     "Title 2",
1673     "Title 3",
1674     "Title 4",
1675     "Title 5",
1676     "Title 6"
1677   };
1678
1679   char text[TESTGTK_CLIST_COLUMNS][50];
1680   char *texts[TESTGTK_CLIST_COLUMNS];
1681
1682   GtkWidget *box1;
1683   GtkWidget *box2;
1684   GtkWidget *clist;
1685   GtkWidget *button;
1686   GtkWidget *separator;
1687
1688
1689   if (!window)
1690     {
1691       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1692
1693       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1694                           GTK_SIGNAL_FUNC(destroy_window),
1695                           &window);
1696       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
1697                           GTK_SIGNAL_FUNC(destroy_window),
1698                           &window);
1699
1700       gtk_window_set_title (GTK_WINDOW (window), "clist");
1701       gtk_container_border_width (GTK_CONTAINER (window), 0);
1702
1703
1704       box1 = gtk_vbox_new (FALSE, 0);
1705       gtk_container_add (GTK_CONTAINER (window), box1);
1706       gtk_widget_show (box1);
1707
1708
1709       box2 = gtk_hbox_new (FALSE, 10);
1710       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1711       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
1712       gtk_widget_show (box2);
1713
1714       /* create this here so we have a pointer to throw at the
1715        * button callbacks -- more is done with it later */
1716       clist = gtk_clist_new (TESTGTK_CLIST_COLUMNS, titles);
1717
1718       button = gtk_button_new_with_label ("Add 1,000 Rows");
1719       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1720
1721       gtk_signal_connect (GTK_OBJECT (button),
1722                           "clicked",
1723                           (GtkSignalFunc) add1000_clist,
1724                           (gpointer) clist);
1725
1726       gtk_widget_show (button);
1727
1728
1729       button = gtk_button_new_with_label ("Add 10,000 Rows");
1730       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1731
1732       gtk_signal_connect (GTK_OBJECT (button),
1733                           "clicked",
1734                           (GtkSignalFunc) add10000_clist,
1735                           (gpointer) clist);
1736
1737       gtk_widget_show (button);
1738
1739       button = gtk_button_new_with_label ("Clear List");
1740       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1741
1742       gtk_signal_connect (GTK_OBJECT (button),
1743                           "clicked",
1744                           (GtkSignalFunc) clear_clist,
1745                           (gpointer) clist);
1746
1747       gtk_widget_show (button);
1748
1749       button = gtk_button_new_with_label ("Remove Row");
1750       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1751
1752       gtk_signal_connect (GTK_OBJECT (button),
1753                           "clicked",
1754                           (GtkSignalFunc) remove_row_clist,
1755                           (gpointer) clist);
1756
1757       gtk_widget_show (button);
1758
1759       box2 = gtk_vbox_new (FALSE, 10);
1760       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1761       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1762       gtk_widget_show (box2);
1763
1764
1765       /*
1766        * the rest of the clist configuration
1767        */
1768       gtk_clist_set_row_height (GTK_CLIST (clist), 20);
1769
1770       gtk_signal_connect (GTK_OBJECT (clist),
1771                           "select_row",
1772                           (GtkSignalFunc) select_clist,
1773                           NULL);
1774
1775       gtk_clist_set_column_width (GTK_CLIST (clist), 0, 100);
1776
1777       for (i = 1; i < TESTGTK_CLIST_COLUMNS; i++)
1778         gtk_clist_set_column_width (GTK_CLIST (clist), i, 80);
1779
1780       gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_BROWSE);
1781
1782       gtk_clist_set_policy (GTK_CLIST (clist), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1783
1784       gtk_clist_set_column_justification (GTK_CLIST (clist), 1, GTK_JUSTIFY_RIGHT);
1785       gtk_clist_set_column_justification (GTK_CLIST (clist), 2, GTK_JUSTIFY_CENTER);
1786
1787       for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
1788         {
1789           texts[i] = text[i];
1790           sprintf (text[i], "Column %d", i);
1791         }
1792
1793       sprintf (text[1], "Right");
1794       sprintf (text[2], "Center");
1795
1796       for (i = 0; i < 100; i++)
1797         {
1798           sprintf (text[0], "Row %d", clist_rows++);
1799           gtk_clist_append (GTK_CLIST (clist), texts);
1800         }
1801
1802       gtk_container_border_width (GTK_CONTAINER (clist), 5);
1803       gtk_box_pack_start (GTK_BOX (box2), clist, TRUE, TRUE, 0);
1804       gtk_widget_show (clist);
1805
1806
1807       separator = gtk_hseparator_new ();
1808       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1809       gtk_widget_show (separator);
1810
1811       box2 = gtk_vbox_new (FALSE, 10);
1812       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1813       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1814       gtk_widget_show (box2);
1815
1816       button = gtk_button_new_with_label ("close");
1817       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1818                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1819                                  GTK_OBJECT (window));
1820
1821       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1822       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1823       gtk_widget_grab_default (button);
1824
1825       gtk_widget_show (button);
1826     }
1827
1828   if (!GTK_WIDGET_VISIBLE (window))
1829     gtk_widget_show (window);
1830   else
1831     gtk_widget_destroy (window);
1832
1833 }
1834
1835 /*
1836  * GtkColorSelect
1837  */
1838 void
1839 color_selection_ok (GtkWidget               *w,
1840                     GtkColorSelectionDialog *cs)
1841 {
1842   GtkColorSelection *colorsel;
1843   gdouble color[4];
1844
1845   colorsel=GTK_COLOR_SELECTION(cs->colorsel);
1846
1847   gtk_color_selection_get_color(colorsel,color);
1848   gtk_color_selection_set_color(colorsel,color);
1849 }
1850
1851 void
1852 color_selection_changed (GtkWidget *w,
1853                          GtkColorSelectionDialog *cs)
1854 {
1855   GtkColorSelection *colorsel;
1856   gdouble color[4];
1857
1858   colorsel=GTK_COLOR_SELECTION(cs->colorsel);
1859   gtk_color_selection_get_color(colorsel,color);
1860 }
1861
1862 void
1863 create_color_selection ()
1864 {
1865   static GtkWidget *window = NULL;
1866
1867   if (!window)
1868     {
1869       gtk_preview_set_install_cmap (TRUE);
1870       gtk_widget_push_visual (gtk_preview_get_visual ());
1871       gtk_widget_push_colormap (gtk_preview_get_cmap ());
1872
1873       window = gtk_color_selection_dialog_new ("color selection dialog");
1874
1875       gtk_color_selection_set_opacity (
1876         GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
1877         TRUE);
1878
1879       gtk_color_selection_set_update_policy(
1880         GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
1881         GTK_UPDATE_CONTINUOUS);
1882
1883       gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
1884
1885       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1886                           GTK_SIGNAL_FUNC(destroy_window),
1887                           &window);
1888       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
1889                           GTK_SIGNAL_FUNC(destroy_window),
1890                           &window);
1891
1892       gtk_signal_connect (
1893         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
1894         "color_changed",
1895         GTK_SIGNAL_FUNC(color_selection_changed),
1896         window);
1897
1898       gtk_signal_connect (
1899         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->ok_button),
1900         "clicked",
1901         GTK_SIGNAL_FUNC(color_selection_ok),
1902         window);
1903
1904       gtk_signal_connect_object (
1905         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->cancel_button),
1906         "clicked",
1907         GTK_SIGNAL_FUNC(gtk_widget_destroy),
1908         GTK_OBJECT (window));
1909
1910       gtk_widget_pop_colormap ();
1911       gtk_widget_pop_visual ();
1912     }
1913
1914   if (!GTK_WIDGET_VISIBLE (window))
1915     gtk_widget_show (window);
1916   else
1917     gtk_widget_destroy (window);
1918 }
1919
1920
1921 void
1922 file_selection_ok (GtkWidget        *w,
1923                    GtkFileSelection *fs)
1924 {
1925   g_print ("%s\n", gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs)));
1926 }
1927
1928 void
1929 create_file_selection ()
1930 {
1931   static GtkWidget *window = NULL;
1932
1933   if (!window)
1934     {
1935       window = gtk_file_selection_new ("file selection dialog");
1936       gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
1937
1938       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1939                           GTK_SIGNAL_FUNC(destroy_window),
1940                           &window);
1941       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
1942                           GTK_SIGNAL_FUNC(destroy_window),
1943                           &window);
1944
1945       gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (window)->ok_button),
1946                           "clicked", GTK_SIGNAL_FUNC(file_selection_ok),
1947                           window);
1948       gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (window)->cancel_button),
1949                                  "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
1950                                  GTK_OBJECT (window));
1951     }
1952
1953   if (!GTK_WIDGET_VISIBLE (window))
1954     gtk_widget_show (window);
1955   else
1956     gtk_widget_destroy (window);
1957 }
1958
1959
1960 /*
1961  * GtkDialog
1962  */
1963 static GtkWidget *dialog_window = NULL;
1964
1965 void
1966 label_toggle (GtkWidget  *widget,
1967               GtkWidget **label)
1968 {
1969   if (!(*label))
1970     {
1971       *label = gtk_label_new ("Dialog Test");
1972       gtk_misc_set_padding (GTK_MISC (*label), 10, 10);
1973       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
1974                           *label, TRUE, TRUE, 0);
1975       gtk_widget_show (*label);
1976     }
1977   else
1978     {
1979       gtk_widget_destroy (*label);
1980       *label = NULL;
1981     }
1982 }
1983
1984 void
1985 create_dialog ()
1986 {
1987   static GtkWidget *label;
1988   GtkWidget *button;
1989
1990   if (!dialog_window)
1991     {
1992       dialog_window = gtk_dialog_new ();
1993
1994       gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
1995                           GTK_SIGNAL_FUNC(destroy_window),
1996                           &dialog_window);
1997       gtk_signal_connect (GTK_OBJECT (dialog_window), "delete_event",
1998                           GTK_SIGNAL_FUNC(destroy_window),
1999                           &dialog_window);
2000
2001       gtk_window_set_title (GTK_WINDOW (dialog_window), "dialog");
2002       gtk_container_border_width (GTK_CONTAINER (dialog_window), 0);
2003
2004       button = gtk_button_new_with_label ("OK");
2005       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2006       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
2007                           button, TRUE, TRUE, 0);
2008       gtk_widget_grab_default (button);
2009       gtk_widget_show (button);
2010
2011       button = gtk_button_new_with_label ("Toggle");
2012       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2013                           GTK_SIGNAL_FUNC(label_toggle),
2014                           &label);
2015       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2016       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
2017                           button, TRUE, TRUE, 0);
2018       gtk_widget_show (button);
2019
2020       label = NULL;
2021     }
2022
2023   if (!GTK_WIDGET_VISIBLE (dialog_window))
2024     gtk_widget_show (dialog_window);
2025   else
2026     gtk_widget_destroy (dialog_window);
2027 }
2028
2029
2030 /*
2031  * GtkRange
2032  */
2033 void
2034 create_range_controls ()
2035 {
2036   static GtkWidget *window = NULL;
2037   GtkWidget *box1;
2038   GtkWidget *box2;
2039   GtkWidget *button;
2040   GtkWidget *scrollbar;
2041   GtkWidget *scale;
2042   GtkWidget *separator;
2043   GtkObject *adjustment;
2044
2045   if (!window)
2046     {
2047       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2048
2049       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2050                           GTK_SIGNAL_FUNC(destroy_window),
2051                           &window);
2052       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2053                           GTK_SIGNAL_FUNC(destroy_window),
2054                           &window);
2055
2056       gtk_window_set_title (GTK_WINDOW (window), "range controls");
2057       gtk_container_border_width (GTK_CONTAINER (window), 0);
2058
2059
2060       box1 = gtk_vbox_new (FALSE, 0);
2061       gtk_container_add (GTK_CONTAINER (window), box1);
2062       gtk_widget_show (box1);
2063
2064
2065       box2 = gtk_vbox_new (FALSE, 10);
2066       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2067       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2068       gtk_widget_show (box2);
2069
2070
2071       adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
2072
2073       scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
2074       gtk_widget_set_usize (GTK_WIDGET (scale), 150, 30);
2075       gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
2076       gtk_scale_set_digits (GTK_SCALE (scale), 1);
2077       gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
2078       gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
2079       gtk_widget_show (scale);
2080
2081       scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adjustment));
2082       gtk_range_set_update_policy (GTK_RANGE (scrollbar),
2083                                    GTK_UPDATE_CONTINUOUS);
2084       gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0);
2085       gtk_widget_show (scrollbar);
2086
2087
2088       separator = gtk_hseparator_new ();
2089       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2090       gtk_widget_show (separator);
2091
2092
2093       box2 = gtk_vbox_new (FALSE, 10);
2094       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2095       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2096       gtk_widget_show (box2);
2097
2098
2099       button = gtk_button_new_with_label ("close");
2100       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2101                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2102                                  GTK_OBJECT (window));
2103       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2104       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2105       gtk_widget_grab_default (button);
2106       gtk_widget_show (button);
2107     }
2108
2109   if (!GTK_WIDGET_VISIBLE (window))
2110     gtk_widget_show (window);
2111   else
2112     gtk_widget_destroy (window);
2113 }
2114
2115
2116 /*
2117  * GtkRulers
2118  */
2119 void
2120 create_rulers ()
2121 {
2122   static GtkWidget *window = NULL;
2123   GtkWidget *table;
2124   GtkWidget *ruler;
2125
2126   if (!window)
2127     {
2128       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2129
2130       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2131                           GTK_SIGNAL_FUNC(destroy_window),
2132                           &window);
2133       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2134                           GTK_SIGNAL_FUNC(destroy_window),
2135                           &window);
2136
2137       gtk_window_set_title (GTK_WINDOW (window), "rulers");
2138       gtk_widget_set_usize (window, 300, 300);
2139       gtk_widget_set_events (window,
2140                              GDK_POINTER_MOTION_MASK
2141                              | GDK_POINTER_MOTION_HINT_MASK);
2142       gtk_container_border_width (GTK_CONTAINER (window), 0);
2143
2144       table = gtk_table_new (2, 2, FALSE);
2145       gtk_container_add (GTK_CONTAINER (window), table);
2146       gtk_widget_show (table);
2147
2148       ruler = gtk_hruler_new ();
2149       gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
2150
2151       gtk_signal_connect_object (
2152         GTK_OBJECT (window),
2153         "motion_notify_event",
2154         GTK_SIGNAL_FUNC(
2155           GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
2156         GTK_OBJECT (ruler));
2157
2158       gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
2159                         GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
2160       gtk_widget_show (ruler);
2161
2162
2163       ruler = gtk_vruler_new ();
2164       gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
2165
2166       gtk_signal_connect_object (
2167         GTK_OBJECT (window),
2168         "motion_notify_event",
2169         GTK_SIGNAL_FUNC (GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
2170         GTK_OBJECT (ruler));
2171
2172       gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
2173                         GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
2174       gtk_widget_show (ruler);
2175     }
2176
2177   if (!GTK_WIDGET_VISIBLE (window))
2178     gtk_widget_show (window);
2179   else
2180     gtk_widget_destroy (window);
2181 }
2182
2183
2184 /*
2185  * GtkText
2186  */
2187 void
2188 create_text ()
2189 {
2190   static GtkWidget *window = NULL;
2191   GtkWidget *box1;
2192   GtkWidget *box2;
2193   GtkWidget *button;
2194   GtkWidget *separator;
2195   GtkWidget *table;
2196   GtkWidget *hscrollbar;
2197   GtkWidget *vscrollbar;
2198   GtkWidget *text;
2199
2200   if (!window)
2201     {
2202       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2203       gtk_widget_set_name (window, "text window");
2204
2205       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2206                           GTK_SIGNAL_FUNC(destroy_window),
2207                           &window);
2208       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2209                           GTK_SIGNAL_FUNC(destroy_window),
2210                           &window);
2211
2212       gtk_window_set_title (GTK_WINDOW (window), "test");
2213       gtk_container_border_width (GTK_CONTAINER (window), 0);
2214
2215
2216       box1 = gtk_vbox_new (FALSE, 0);
2217       gtk_container_add (GTK_CONTAINER (window), box1);
2218       gtk_widget_show (box1);
2219
2220
2221       box2 = gtk_vbox_new (FALSE, 10);
2222       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2223       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2224       gtk_widget_show (box2);
2225
2226
2227       table = gtk_table_new (2, 2, FALSE);
2228       gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2);
2229       gtk_table_set_col_spacing (GTK_TABLE (table), 0, 2);
2230       gtk_box_pack_start (GTK_BOX (box2), table, TRUE, TRUE, 0);
2231       gtk_widget_show (table);
2232
2233       text = gtk_text_new (NULL, NULL);
2234       gtk_table_attach_defaults (GTK_TABLE (table), text, 0, 1, 0, 1);
2235       gtk_widget_show (text);
2236
2237       hscrollbar = gtk_hscrollbar_new (GTK_TEXT (text)->hadj);
2238       gtk_table_attach (GTK_TABLE (table), hscrollbar, 0, 1, 1, 2,
2239                         GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
2240       gtk_widget_show (hscrollbar);
2241
2242       vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
2243       gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 0, 1,
2244                         GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
2245       gtk_widget_show (vscrollbar);
2246
2247       gtk_text_freeze (GTK_TEXT (text));
2248
2249       gtk_widget_realize (text);
2250
2251       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2252                        "spencer blah blah blah\n", -1);
2253       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2254                        "kimball\n", -1);
2255       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2256                        "is\n", -1);
2257       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2258                        "a\n", -1);
2259       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2260                        "wuss.\n", -1);
2261       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2262                        "but\n", -1);
2263       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2264                        "josephine\n", -1);
2265       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2266                        "(his\n", -1);
2267       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2268                        "girlfriend\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                        "not).\n", -1);
2273       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2274                        "why?\n", -1);
2275       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2276                        "because\n", -1);
2277       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2278                        "spencer\n", -1);
2279       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2280                        "puked\n", -1);
2281       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2282                        "last\n", -1);
2283       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2284                        "night\n", -1);
2285       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2286                        "but\n", -1);
2287       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2288                        "josephine\n", -1);
2289       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2290                        "did\n", -1);
2291       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2292                        "not", -1);
2293
2294       gtk_text_thaw (GTK_TEXT (text));
2295
2296       separator = gtk_hseparator_new ();
2297       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2298       gtk_widget_show (separator);
2299
2300
2301       box2 = gtk_vbox_new (FALSE, 10);
2302       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2303       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2304       gtk_widget_show (box2);
2305
2306
2307       button = gtk_button_new_with_label ("close");
2308       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2309                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2310                                  GTK_OBJECT (window));
2311       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2312       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2313       gtk_widget_grab_default (button);
2314       gtk_widget_show (button);
2315     }
2316
2317   if (!GTK_WIDGET_VISIBLE (window))
2318     gtk_widget_show (window);
2319   else
2320     gtk_widget_destroy (window);
2321 }
2322
2323
2324 /*
2325  * GtkNotebook
2326  */
2327 void
2328 rotate_notebook (GtkButton   *button,
2329                  GtkNotebook *notebook)
2330 {
2331   gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos + 1) % 4);
2332 }
2333
2334 void
2335 create_notebook ()
2336 {
2337   static GtkWidget *window = NULL;
2338   GtkWidget *box1;
2339   GtkWidget *box2;
2340   GtkWidget *button;
2341   GtkWidget *separator;
2342   GtkWidget *notebook;
2343   GtkWidget *frame;
2344   GtkWidget *label;
2345   char buffer[32];
2346   int i;
2347
2348   if (!window)
2349     {
2350       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2351
2352       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2353                           GTK_SIGNAL_FUNC(destroy_window),
2354                           &window);
2355       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2356                           GTK_SIGNAL_FUNC(destroy_window),
2357                           &window);
2358
2359       gtk_window_set_title (GTK_WINDOW (window), "notebook");
2360       gtk_container_border_width (GTK_CONTAINER (window), 0);
2361
2362
2363       box1 = gtk_vbox_new (FALSE, 0);
2364       gtk_container_add (GTK_CONTAINER (window), box1);
2365       gtk_widget_show (box1);
2366
2367
2368       box2 = gtk_vbox_new (FALSE, 10);
2369       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2370       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2371       gtk_widget_show (box2);
2372
2373
2374       notebook = gtk_notebook_new ();
2375       gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
2376       gtk_box_pack_start (GTK_BOX (box2), notebook, TRUE, TRUE, 0);
2377       gtk_widget_show (notebook);
2378
2379
2380       for (i = 0; i < 5; i++)
2381         {
2382           sprintf (buffer, "Page %d", i+1);
2383
2384           frame = gtk_frame_new (buffer);
2385           gtk_container_border_width (GTK_CONTAINER (frame), 10);
2386           gtk_widget_set_usize (frame, 200, 150);
2387           gtk_widget_show (frame);
2388
2389           label = gtk_label_new (buffer);
2390           gtk_container_add (GTK_CONTAINER (frame), label);
2391           gtk_widget_show (label);
2392
2393           label = gtk_label_new (buffer);
2394           gtk_notebook_append_page (GTK_NOTEBOOK (notebook), frame, label);
2395         }
2396
2397
2398       separator = gtk_hseparator_new ();
2399       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2400       gtk_widget_show (separator);
2401
2402
2403       box2 = gtk_hbox_new (FALSE, 10);
2404       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2405       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2406       gtk_widget_show (box2);
2407
2408
2409       button = gtk_button_new_with_label ("close");
2410       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2411                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2412                                  GTK_OBJECT (window));
2413       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2414       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2415       gtk_widget_grab_default (button);
2416       gtk_widget_show (button);
2417
2418       button = gtk_button_new_with_label ("next");
2419       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2420                                  GTK_SIGNAL_FUNC(gtk_notebook_next_page),
2421                                  GTK_OBJECT (notebook));
2422       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2423       gtk_widget_show (button);
2424
2425       button = gtk_button_new_with_label ("prev");
2426       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2427                                  GTK_SIGNAL_FUNC(gtk_notebook_prev_page),
2428                                  GTK_OBJECT (notebook));
2429       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2430       gtk_widget_show (button);
2431
2432       button = gtk_button_new_with_label ("rotate");
2433       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2434                           GTK_SIGNAL_FUNC(rotate_notebook),
2435                           notebook);
2436       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2437       gtk_widget_show (button);
2438     }
2439
2440   if (!GTK_WIDGET_VISIBLE (window))
2441     gtk_widget_show (window);
2442   else
2443     gtk_widget_destroy (window);
2444 }
2445
2446
2447 /*
2448  * GtkPanes
2449  */
2450 void
2451 create_panes ()
2452 {
2453   static GtkWidget *window = NULL;
2454   GtkWidget *frame;
2455   GtkWidget *hpaned;
2456   GtkWidget *vpaned;
2457
2458   if (!window)
2459     {
2460       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2461
2462       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2463                           GTK_SIGNAL_FUNC(destroy_window),
2464                           &window);
2465       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2466                           GTK_SIGNAL_FUNC(destroy_window),
2467                           &window);
2468
2469       gtk_window_set_title (GTK_WINDOW (window), "Panes");
2470       gtk_container_border_width (GTK_CONTAINER (window), 0);
2471
2472       vpaned = gtk_vpaned_new ();
2473       gtk_container_add (GTK_CONTAINER (window), vpaned);
2474       gtk_container_border_width (GTK_CONTAINER(vpaned), 5);
2475       gtk_widget_show (vpaned);
2476
2477       hpaned = gtk_hpaned_new ();
2478       gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
2479
2480       frame = gtk_frame_new (NULL);
2481       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
2482       gtk_widget_set_usize (frame, 60, 60);
2483       gtk_paned_add1 (GTK_PANED (hpaned), frame);
2484       gtk_widget_show (frame);
2485
2486       frame = gtk_frame_new (NULL);
2487       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
2488       gtk_widget_set_usize (frame, 80, 60);
2489       gtk_paned_add2 (GTK_PANED (hpaned), frame);
2490       gtk_widget_show (frame);
2491
2492       gtk_widget_show (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, 80);
2497       gtk_paned_add2 (GTK_PANED (vpaned), frame);
2498       gtk_widget_show (frame);
2499     }
2500
2501   if (!GTK_WIDGET_VISIBLE (window))
2502     gtk_widget_show (window);
2503   else
2504     gtk_widget_destroy (window);
2505 }
2506
2507
2508 /*
2509  * Drag -N- Drop
2510  */
2511
2512 gboolean
2513 dnd_drop_destroy_popup (GtkWidget *widget, GtkWindow **window)
2514 {
2515   if(GTK_IS_BUTTON(widget)) /* I.e. they clicked the close button */
2516     gtk_widget_destroy(GTK_WIDGET(*window));
2517   else {
2518     gtk_grab_remove(GTK_WIDGET(*window));
2519     *window = NULL;
2520   }
2521   return TRUE;
2522 }
2523
2524 void
2525 dnd_drop (GtkWidget *button, GdkEvent *event)
2526 {
2527   static GtkWidget *window = NULL;
2528   GtkWidget *vbox, *lbl, *btn;
2529   gchar *msg;
2530
2531   window = gtk_window_new(GTK_WINDOW_DIALOG);
2532   gtk_container_border_width (GTK_CONTAINER(window), 10);
2533
2534   gtk_signal_connect (GTK_OBJECT (window), "destroy",
2535                       GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
2536                       &window);
2537   gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2538                       GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
2539                       &window);
2540
2541   vbox = gtk_vbox_new(FALSE, 5);
2542
2543   /* Display message that we got from drop source */
2544   msg = g_malloc(strlen(event->dropdataavailable.data)
2545                  + strlen(event->dropdataavailable.data_type) + 100);
2546   sprintf(msg, "Drop data of type %s was:\n\n%s",
2547           event->dropdataavailable.data_type,
2548           (char *)event->dropdataavailable.data);
2549   lbl = gtk_label_new(msg);
2550   gtk_label_set_justify(GTK_LABEL(lbl), GTK_JUSTIFY_FILL);
2551   g_free(msg);
2552   gtk_widget_show(lbl);
2553   gtk_box_pack_start_defaults(GTK_BOX(vbox), lbl);
2554
2555   /* Provide an obvious way out of this heinousness */
2556   btn = gtk_button_new_with_label("Continue with life in\nspite of this oppression");
2557   gtk_signal_connect (GTK_OBJECT (btn), "clicked",
2558                       GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
2559                       &window);
2560   gtk_widget_show(btn);
2561   gtk_box_pack_start_defaults(GTK_BOX(vbox), btn);
2562
2563   gtk_container_add(GTK_CONTAINER(window), vbox);
2564
2565   gtk_widget_show(vbox);
2566   gtk_grab_add(window);
2567   gtk_widget_show(window);
2568
2569   g_free (event->dropdataavailable.data);
2570   g_free (event->dropdataavailable.data_type);
2571 }
2572
2573 void
2574 dnd_drag_request (GtkWidget *button, GdkEvent *event)
2575 {
2576 #define DND_STRING "Bill Gates demands royalties for\nyour use of his innovation."
2577   gtk_widget_dnd_data_set (button, event, DND_STRING, strlen(DND_STRING) + 1);
2578 }
2579
2580 void
2581 create_dnd ()
2582 {
2583   static GtkWidget *window = NULL;
2584   GtkWidget *box1;
2585   GtkWidget *box2;
2586   GtkWidget *box3;
2587   GtkWidget *frame;
2588   GtkWidget *button;
2589   GtkWidget *separator;
2590
2591   /* For clarity... */
2592   char *possible_drag_types[] = {"text/plain"};
2593   char *accepted_drop_types[] = {"text/plain"};
2594
2595   if (!window)
2596     {
2597       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2598
2599       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2600                           GTK_SIGNAL_FUNC(destroy_window),
2601                           &window);
2602       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2603                           GTK_SIGNAL_FUNC(destroy_window),
2604                           &window);
2605
2606       gtk_window_set_title (GTK_WINDOW (window), "Drag -N- Drop");
2607       gtk_container_border_width (GTK_CONTAINER (window), 0);
2608
2609       box1 = gtk_vbox_new (FALSE, 0);
2610       gtk_container_add (GTK_CONTAINER (window), box1);
2611       gtk_widget_show (box1);
2612
2613       box2 = gtk_hbox_new (FALSE, 5);
2614       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2615       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2616       gtk_widget_show (box2);
2617
2618       frame = gtk_frame_new ("Drag");
2619       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
2620       gtk_widget_show (frame);
2621
2622       box3 = gtk_vbox_new (FALSE, 5);
2623       gtk_container_border_width (GTK_CONTAINER (box3), 5);
2624       gtk_container_add (GTK_CONTAINER (frame), box3);
2625       gtk_widget_show (box3);
2626
2627       /*
2628        * FROM Button
2629        */
2630       button = gtk_button_new_with_label ("Drag me!");
2631       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
2632       gtk_widget_show (button);
2633
2634       /*
2635        * currently, the widget has to be realized to
2636        * set dnd on it, this needs to change
2637        */
2638       gtk_widget_realize (button);
2639       gtk_signal_connect (GTK_OBJECT (button),
2640                           "drag_request_event",
2641                           GTK_SIGNAL_FUNC(dnd_drag_request),
2642                           button);
2643
2644       gtk_widget_dnd_drag_set (button, TRUE, possible_drag_types, 1);
2645
2646
2647       frame = gtk_frame_new ("Drop");
2648       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
2649       gtk_widget_show (frame);
2650
2651       box3 = gtk_vbox_new (FALSE, 5);
2652       gtk_container_border_width (GTK_CONTAINER (box3), 5);
2653       gtk_container_add (GTK_CONTAINER (frame), box3);
2654       gtk_widget_show (box3);
2655
2656
2657       /*
2658        * TO Button
2659        */
2660       button = gtk_button_new_with_label ("To");
2661       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
2662       gtk_widget_show (button);
2663
2664       gtk_widget_realize (button);
2665       gtk_signal_connect (GTK_OBJECT (button),
2666                           "drop_data_available_event",
2667                           GTK_SIGNAL_FUNC(dnd_drop),
2668                           button);
2669
2670       gtk_widget_dnd_drop_set (button, TRUE, accepted_drop_types, 1, FALSE);
2671
2672
2673       separator = gtk_hseparator_new ();
2674       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2675       gtk_widget_show (separator);
2676
2677
2678       box2 = gtk_vbox_new (FALSE, 10);
2679       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2680       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2681       gtk_widget_show (box2);
2682
2683
2684       button = gtk_button_new_with_label ("close");
2685
2686       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2687                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2688                                  GTK_OBJECT (window));
2689
2690       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2691       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2692       gtk_widget_grab_default (button);
2693       gtk_widget_show (button);
2694     }
2695
2696   if (!GTK_WIDGET_VISIBLE (window))
2697     gtk_widget_show (window);
2698   else
2699     gtk_widget_destroy (window);
2700 }
2701
2702 /*
2703  * Shaped Windows
2704  */
2705 static GdkWindow *root_win = NULL;
2706 static GtkWidget *modeller = NULL;
2707 static GtkWidget *sheets = NULL;
2708 static GtkWidget *rings = NULL;
2709
2710 typedef struct _cursoroffset {gint x,y;} CursorOffset;
2711
2712 static void
2713 shape_pressed (GtkWidget *widget)
2714 {
2715   CursorOffset *p;
2716
2717   p = gtk_object_get_user_data (GTK_OBJECT(widget));
2718   gtk_widget_get_pointer (widget, &(p->x), &(p->y));
2719
2720   gtk_grab_add (widget);
2721   gdk_pointer_grab (widget->window, TRUE,
2722                     GDK_BUTTON_RELEASE_MASK |
2723                     GDK_BUTTON_MOTION_MASK,
2724                     NULL, NULL, 0);
2725 }
2726
2727
2728 static void
2729 shape_released (GtkWidget *widget)
2730 {
2731   gtk_grab_remove (widget);
2732   gdk_pointer_ungrab (0);
2733 }
2734
2735 static void
2736 shape_motion (GtkWidget      *widget,
2737               GdkEventMotion *event)
2738 {
2739   gint xp, yp;
2740   CursorOffset * p;
2741   GdkModifierType mask;
2742
2743   p = gtk_object_get_user_data (GTK_OBJECT (widget));
2744
2745   gdk_window_get_pointer (root_win, &xp, &yp, &mask);
2746   gtk_widget_set_uposition (widget, xp  - p->x, yp  - p->y);
2747 }
2748
2749 GtkWidget *
2750 shape_create_icon (char     *xpm_file,
2751                    gint      x,
2752                    gint      y,
2753                    gint      px,
2754                    gint      py,
2755                    gint      window_type)
2756 {
2757   GtkWidget *window;
2758   GtkWidget *pixmap;
2759   GtkWidget *fixed;
2760   CursorOffset* icon_pos;
2761   GdkGC* gc;
2762   GdkBitmap *gdk_pixmap_mask;
2763   GdkPixmap *gdk_pixmap;
2764   GtkStyle *style;
2765
2766   style = gtk_widget_get_default_style ();
2767   gc = style->black_gc;
2768
2769   /*
2770    * GDK_WINDOW_TOPLEVEL works also, giving you a title border
2771    */
2772   window = gtk_window_new (window_type);
2773
2774   fixed = gtk_fixed_new ();
2775   gtk_widget_set_usize (fixed, 100,100);
2776   gtk_container_add (GTK_CONTAINER (window), fixed);
2777   gtk_widget_show (fixed);
2778
2779   gdk_pixmap = gdk_pixmap_create_from_xpm (window->window, &gdk_pixmap_mask,
2780                                            &style->bg[GTK_STATE_NORMAL],
2781                                            xpm_file);
2782
2783   pixmap = gtk_pixmap_new (gdk_pixmap, gdk_pixmap_mask);
2784   gtk_fixed_put (GTK_FIXED (fixed), pixmap, px,py);
2785   gtk_widget_show (pixmap);
2786
2787   gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px,py);
2788
2789   gtk_widget_set_events (window,
2790                          gtk_widget_get_events (window) |
2791                          GDK_BUTTON_MOTION_MASK |
2792                          GDK_BUTTON_PRESS_MASK);
2793
2794   gtk_signal_connect (GTK_OBJECT (window), "button_press_event",
2795                       GTK_SIGNAL_FUNC (shape_pressed),NULL);
2796   gtk_signal_connect (GTK_OBJECT (window), "button_release_event",
2797                       GTK_SIGNAL_FUNC (shape_released),NULL);
2798   gtk_signal_connect (GTK_OBJECT (window), "motion_notify_event",
2799                       GTK_SIGNAL_FUNC (shape_motion),NULL);
2800
2801   icon_pos = g_new (CursorOffset, 1);
2802   gtk_object_set_user_data(GTK_OBJECT(window), icon_pos);
2803
2804   gtk_widget_set_uposition (window, x, y);
2805   gtk_widget_show (window);
2806
2807   return window;
2808 }
2809
2810 void
2811 create_shapes ()
2812 {
2813   root_win = gdk_window_foreign_new (GDK_ROOT_WINDOW ());
2814
2815   if (!modeller)
2816     {
2817       modeller = shape_create_icon ("Modeller.xpm",
2818                                     440, 140, 0,0, GTK_WINDOW_POPUP);
2819
2820       gtk_signal_connect (GTK_OBJECT (modeller), "destroy",
2821                           GTK_SIGNAL_FUNC(destroy_window),
2822                           &modeller);
2823       gtk_signal_connect (GTK_OBJECT (modeller), "delete_event",
2824                           GTK_SIGNAL_FUNC(destroy_window),
2825                           &modeller);
2826     }
2827   else
2828     gtk_widget_destroy (modeller);
2829
2830   if (!sheets)
2831     {
2832       sheets = shape_create_icon ("FilesQueue.xpm",
2833                                   580, 170, 0,0, GTK_WINDOW_POPUP);
2834
2835       gtk_signal_connect (GTK_OBJECT (sheets), "destroy",
2836                           GTK_SIGNAL_FUNC(destroy_window),
2837                           &sheets);
2838       gtk_signal_connect (GTK_OBJECT (sheets), "delete_event",
2839                           GTK_SIGNAL_FUNC(destroy_window),
2840                           &sheets);
2841
2842     }
2843   else
2844     gtk_widget_destroy (sheets);
2845
2846   if (!rings)
2847     {
2848       rings = shape_create_icon ("3DRings.xpm",
2849                                  460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
2850
2851       gtk_signal_connect (GTK_OBJECT (rings), "destroy",
2852                           GTK_SIGNAL_FUNC(destroy_window),
2853                           &rings);
2854       gtk_signal_connect (GTK_OBJECT (rings), "delete_event",
2855                           GTK_SIGNAL_FUNC(destroy_window),
2856                           &rings);
2857     }
2858   else
2859     gtk_widget_destroy (rings);
2860 }
2861
2862
2863 /*
2864  * Progress Bar
2865  */
2866 static int progress_timer = 0;
2867
2868 gint
2869 progress_timeout (gpointer data)
2870 {
2871   gfloat new_val;
2872
2873   new_val = GTK_PROGRESS_BAR (data)->percentage;
2874   if (new_val >= 1.0)
2875     new_val = 0.0;
2876   new_val += 0.02;
2877
2878   gtk_progress_bar_update (GTK_PROGRESS_BAR (data), new_val);
2879
2880   return TRUE;
2881 }
2882
2883 void
2884 destroy_progress (GtkWidget  *widget,
2885                   GtkWidget **window)
2886 {
2887   destroy_window (widget, window);
2888   gtk_timeout_remove (progress_timer);
2889   progress_timer = 0;
2890 }
2891
2892 void
2893 create_progress_bar ()
2894 {
2895   static GtkWidget *window = NULL;
2896   GtkWidget *button;
2897   GtkWidget *vbox;
2898   GtkWidget *pbar;
2899   GtkWidget *label;
2900
2901   if (!window)
2902     {
2903       window = gtk_dialog_new ();
2904
2905       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2906                           GTK_SIGNAL_FUNC(destroy_progress),
2907                           &window);
2908       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2909                           GTK_SIGNAL_FUNC(destroy_progress),
2910                           &window);
2911
2912       gtk_window_set_title (GTK_WINDOW (window), "dialog");
2913       gtk_container_border_width (GTK_CONTAINER (window), 0);
2914
2915
2916       vbox = gtk_vbox_new (FALSE, 5);
2917       gtk_container_border_width (GTK_CONTAINER (vbox), 10);
2918       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
2919                           vbox, TRUE, TRUE, 0);
2920       gtk_widget_show (vbox);
2921
2922       label = gtk_label_new ("progress...");
2923       gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
2924       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
2925       gtk_widget_show (label);
2926
2927       pbar = gtk_progress_bar_new ();
2928       gtk_widget_set_usize (pbar, 200, 20);
2929       gtk_box_pack_start (GTK_BOX (vbox), pbar, TRUE, TRUE, 0);
2930       gtk_widget_show (pbar);
2931
2932       progress_timer = gtk_timeout_add (100, progress_timeout, pbar);
2933
2934       button = gtk_button_new_with_label ("close");
2935       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2936                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2937                                  GTK_OBJECT (window));
2938       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2939       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
2940                           button, TRUE, TRUE, 0);
2941       gtk_widget_grab_default (button);
2942       gtk_widget_show (button);
2943     }
2944
2945   if (!GTK_WIDGET_VISIBLE (window))
2946     gtk_widget_show (window);
2947   else
2948     gtk_widget_destroy (window);
2949 }
2950
2951
2952 /*
2953  * Color Preview
2954  */
2955 static int color_idle = 0;
2956
2957 gint
2958 color_idle_func (GtkWidget *preview)
2959 {
2960   static int count = 1;
2961   guchar buf[768];
2962   int i, j, k;
2963
2964   for (i = 0; i < 256; i++)
2965     {
2966       for (j = 0, k = 0; j < 256; j++)
2967         {
2968           buf[k+0] = i + count;
2969           buf[k+1] = 0;
2970           buf[k+2] = j + count;
2971           k += 3;
2972         }
2973
2974       gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
2975     }
2976
2977   count += 1;
2978
2979   gtk_widget_draw (preview, NULL);
2980
2981   return TRUE;
2982 }
2983
2984 void
2985 color_preview_destroy (GtkWidget  *widget,
2986                        GtkWidget **window)
2987 {
2988   gtk_idle_remove (color_idle);
2989   color_idle = 0;
2990
2991   destroy_window (widget, window);
2992 }
2993
2994 void
2995 create_color_preview ()
2996 {
2997   static GtkWidget *window = NULL;
2998   GtkWidget *preview;
2999   guchar buf[768];
3000   int i, j, k;
3001
3002   if (!window)
3003     {
3004       gtk_widget_push_visual (gtk_preview_get_visual ());
3005       gtk_widget_push_colormap (gtk_preview_get_cmap ());
3006
3007       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3008
3009       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3010                           GTK_SIGNAL_FUNC(color_preview_destroy),
3011                           &window);
3012       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3013                           GTK_SIGNAL_FUNC(color_preview_destroy),
3014                           &window);
3015
3016       gtk_window_set_title (GTK_WINDOW (window), "test");
3017       gtk_container_border_width (GTK_CONTAINER (window), 10);
3018
3019       preview = gtk_preview_new (GTK_PREVIEW_COLOR);
3020       gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
3021       gtk_container_add (GTK_CONTAINER (window), preview);
3022       gtk_widget_show (preview);
3023
3024       for (i = 0; i < 256; i++)
3025         {
3026           for (j = 0, k = 0; j < 256; j++)
3027             {
3028               buf[k+0] = i;
3029               buf[k+1] = 0;
3030               buf[k+2] = j;
3031               k += 3;
3032             }
3033
3034           gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
3035         }
3036
3037       color_idle = gtk_idle_add ((GtkFunction) color_idle_func, preview);
3038
3039       gtk_widget_pop_colormap ();
3040       gtk_widget_pop_visual ();
3041     }
3042
3043   if (!GTK_WIDGET_VISIBLE (window))
3044     gtk_widget_show (window);
3045   else
3046     gtk_widget_destroy (window);
3047 }
3048
3049
3050 /*
3051  * Gray Preview
3052  */
3053 static int gray_idle = 0;
3054
3055 gint
3056 gray_idle_func (GtkWidget *preview)
3057 {
3058   static int count = 1;
3059   guchar buf[256];
3060   int i, j;
3061
3062   for (i = 0; i < 256; i++)
3063     {
3064       for (j = 0; j < 256; j++)
3065         buf[j] = i + j + count;
3066
3067       gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
3068     }
3069
3070   count += 1;
3071
3072   gtk_widget_draw (preview, NULL);
3073
3074   return TRUE;
3075 }
3076
3077 void
3078 gray_preview_destroy (GtkWidget  *widget,
3079                       GtkWidget **window)
3080 {
3081   gtk_idle_remove (gray_idle);
3082   gray_idle = 0;
3083
3084   destroy_window (widget, window);
3085 }
3086
3087 void
3088 create_gray_preview ()
3089 {
3090   static GtkWidget *window = NULL;
3091   GtkWidget *preview;
3092   guchar buf[256];
3093   int i, j;
3094
3095   if (!window)
3096     {
3097       gtk_widget_push_visual (gtk_preview_get_visual ());
3098       gtk_widget_push_colormap (gtk_preview_get_cmap ());
3099
3100       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3101
3102       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3103                           GTK_SIGNAL_FUNC(gray_preview_destroy),
3104                           &window);
3105       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3106                           GTK_SIGNAL_FUNC(gray_preview_destroy),
3107                           &window);
3108
3109       gtk_window_set_title (GTK_WINDOW (window), "test");
3110       gtk_container_border_width (GTK_CONTAINER (window), 10);
3111
3112       preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
3113       gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
3114       gtk_container_add (GTK_CONTAINER (window), preview);
3115       gtk_widget_show (preview);
3116
3117       for (i = 0; i < 256; i++)
3118         {
3119           for (j = 0; j < 256; j++)
3120             buf[j] = i + j;
3121
3122           gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
3123         }
3124
3125       gray_idle = gtk_idle_add ((GtkFunction) gray_idle_func, preview);
3126
3127       gtk_widget_pop_colormap ();
3128       gtk_widget_pop_visual ();
3129     }
3130
3131   if (!GTK_WIDGET_VISIBLE (window))
3132     gtk_widget_show (window);
3133   else
3134     gtk_widget_destroy (window);
3135 }
3136
3137
3138 /*
3139  * Selection Test
3140  */
3141 void
3142 selection_test_received (GtkWidget *list, GtkSelectionData *data)
3143 {
3144   GdkAtom *atoms;
3145   GtkWidget *list_item;
3146   GList *item_list;
3147   int i, l;
3148
3149   if (data->length < 0)
3150     {
3151       g_print ("Selection retrieval failed\n");
3152       return;
3153     }
3154   if (data->type != GDK_SELECTION_TYPE_ATOM)
3155     {
3156       g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
3157       return;
3158     }
3159
3160   /* Clear out any current list items */
3161
3162   gtk_list_clear_items (GTK_LIST(list), 0, -1);
3163
3164   /* Add new items to list */
3165
3166   atoms = (GdkAtom *)data->data;
3167
3168   item_list = NULL;
3169   l = data->length / sizeof (GdkAtom);
3170   for (i = 0; i < l; i++)
3171     {
3172       char *name;
3173       name = gdk_atom_name (atoms[i]);
3174       if (name != NULL)
3175         {
3176           list_item = gtk_list_item_new_with_label (name);
3177           g_free (name);
3178         }
3179       else
3180         list_item = gtk_list_item_new_with_label ("(bad atom)");
3181
3182       gtk_widget_show (list_item);
3183       item_list = g_list_append (item_list, list_item);
3184     }
3185
3186   gtk_list_append_items (GTK_LIST (list), item_list);
3187
3188   return;
3189 }
3190
3191 void
3192 selection_test_get_targets (GtkWidget *widget, GtkWidget *list)
3193 {
3194   static GdkAtom targets_atom = GDK_NONE;
3195
3196   if (targets_atom == GDK_NONE)
3197     targets_atom = gdk_atom_intern ("TARGETS", FALSE);
3198
3199   gtk_selection_convert (list, GDK_SELECTION_PRIMARY, targets_atom,
3200                          GDK_CURRENT_TIME);
3201 }
3202
3203 void
3204 create_selection_test ()
3205 {
3206   static GtkWidget *window = NULL;
3207   GtkWidget *button;
3208   GtkWidget *vbox;
3209   GtkWidget *scrolled_win;
3210   GtkWidget *list;
3211   GtkWidget *label;
3212
3213   if (!window)
3214     {
3215       window = gtk_dialog_new ();
3216
3217       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3218                           GTK_SIGNAL_FUNC(destroy_window),
3219                           &window);
3220       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3221                           GTK_SIGNAL_FUNC(destroy_window),
3222                           &window);
3223
3224       gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
3225       gtk_container_border_width (GTK_CONTAINER (window), 0);
3226
3227       /* Create the list */
3228
3229       vbox = gtk_vbox_new (FALSE, 5);
3230       gtk_container_border_width (GTK_CONTAINER (vbox), 10);
3231       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox,
3232                           TRUE, TRUE, 0);
3233       gtk_widget_show (vbox);
3234
3235       label = gtk_label_new ("Gets available targets for current selection");
3236       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
3237       gtk_widget_show (label);
3238
3239       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
3240       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
3241                                       GTK_POLICY_AUTOMATIC,
3242                                       GTK_POLICY_AUTOMATIC);
3243       gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
3244       gtk_widget_set_usize (scrolled_win, 100, 200);
3245       gtk_widget_show (scrolled_win);
3246
3247       list = gtk_list_new ();
3248       gtk_container_add (GTK_CONTAINER (scrolled_win), list);
3249
3250       gtk_signal_connect (GTK_OBJECT(list), "selection_received",
3251                           GTK_SIGNAL_FUNC (selection_test_received), NULL);
3252       gtk_widget_show (list);
3253
3254       /* .. And create some buttons */
3255       button = gtk_button_new_with_label ("Get Targets");
3256       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3257                           button, TRUE, TRUE, 0);
3258
3259       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3260                           GTK_SIGNAL_FUNC (selection_test_get_targets), list);
3261       gtk_widget_show (button);
3262
3263       button = gtk_button_new_with_label ("Quit");
3264       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3265                           button, TRUE, TRUE, 0);
3266
3267       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3268                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
3269                                  GTK_OBJECT (window));
3270       gtk_widget_show (button);
3271     }
3272
3273   if (!GTK_WIDGET_VISIBLE (window))
3274     gtk_widget_show (window);
3275   else
3276     gtk_widget_destroy (window);
3277 }
3278
3279
3280 /*
3281  * Gamma Curve
3282  */
3283 void
3284 create_gamma_curve ()
3285 {
3286   static GtkWidget *window = NULL, *curve;
3287   static int count = 0;
3288   gfloat vec[256];
3289   gint max;
3290   gint i;
3291
3292   if (!window)
3293     {
3294       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3295       gtk_window_set_title (GTK_WINDOW (window), "test");
3296       gtk_container_border_width (GTK_CONTAINER (window), 10);
3297
3298       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3299                           GTK_SIGNAL_FUNC(destroy_window),
3300                           &window);
3301       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3302                           GTK_SIGNAL_FUNC(destroy_window),
3303                           &window);
3304
3305       curve = gtk_gamma_curve_new ();
3306       gtk_container_add (GTK_CONTAINER (window), curve);
3307       gtk_widget_show (curve);
3308     }
3309
3310   max = 127 + (count % 2)*128;
3311   gtk_curve_set_range (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
3312                        0, max, 0, max);
3313   for (i = 0; i < max; ++i)
3314     vec[i] = (127 / sqrt (max)) * sqrt (i);
3315   gtk_curve_set_vector (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
3316                         max, vec);
3317
3318   if (!GTK_WIDGET_VISIBLE (window))
3319     gtk_widget_show (window);
3320   else if (count % 4 == 3)
3321     {
3322       gtk_widget_destroy (window);
3323       window = NULL;
3324     }
3325
3326   ++count;
3327 }
3328
3329 static int scroll_test_pos = 0.0;
3330 static GdkGC *scroll_test_gc = NULL;
3331
3332 static gint
3333 scroll_test_expose (GtkWidget *widget, GdkEventExpose *event,
3334                     GtkAdjustment *adj)
3335 {
3336   gint i,j;
3337   gint imin, imax, jmin, jmax;
3338
3339   imin = (event->area.x) / 10;
3340   imax = (event->area.x + event->area.width + 9) / 10;
3341
3342   jmin = ((int)adj->value + event->area.y) / 10;
3343   jmax = ((int)adj->value + event->area.y + event->area.height + 9) / 10;
3344
3345   gdk_window_clear_area (widget->window,
3346                          event->area.x, event->area.y,
3347                          event->area.width, event->area.height);
3348
3349   for (i=imin; i<imax; i++)
3350     for (j=jmin; j<jmax; j++)
3351       if ((i+j) % 2)
3352         gdk_draw_rectangle (widget->window,
3353                             widget->style->black_gc,
3354                             TRUE,
3355                             10*i, 10*j - (int)adj->value, 1+i%10, 1+j%10);
3356
3357   return TRUE;
3358 }
3359
3360 static void
3361 scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
3362                        GtkAdjustment *adj)
3363 {
3364   adj->page_increment = 0.9 * widget->allocation.height;
3365   adj->page_size = widget->allocation.height;
3366
3367   gtk_signal_emit_by_name (GTK_OBJECT (adj), "changed");
3368 }
3369
3370 static void
3371 scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
3372 {
3373   gint source_min = (int)adj->value - scroll_test_pos;
3374   gint source_max = source_min + widget->allocation.height;
3375   gint dest_min = 0;
3376   gint dest_max = widget->allocation.height;
3377   GdkRectangle rect;
3378   GdkEvent *event;
3379
3380   scroll_test_pos = adj->value;
3381
3382   if (!GTK_WIDGET_DRAWABLE (widget))
3383     return;
3384
3385   if (source_min < 0)
3386     {
3387       rect.x = 0;
3388       rect.y = 0;
3389       rect.width = widget->allocation.width;
3390       rect.height = -source_min;
3391       if (rect.height > widget->allocation.height)
3392         rect.height = widget->allocation.height;
3393
3394       source_min = 0;
3395       dest_min = rect.height;
3396     }
3397   else
3398     {
3399       rect.x = 0;
3400       rect.y = 2*widget->allocation.height - source_max;
3401       if (rect.y < 0)
3402         rect.y = 0;
3403       rect.width = widget->allocation.width;
3404       rect.height = widget->allocation.height - rect.y;
3405
3406       source_max = widget->allocation.height;
3407       dest_max = rect.y;
3408     }
3409
3410   if (source_min != source_max)
3411     {
3412       if (scroll_test_gc == NULL)
3413         {
3414           scroll_test_gc = gdk_gc_new (widget->window);
3415           gdk_gc_set_exposures (scroll_test_gc, TRUE);
3416         }
3417
3418       gdk_draw_pixmap (widget->window,
3419                        scroll_test_gc,
3420                        widget->window,
3421                        0, source_min,
3422                        0, dest_min,
3423                        widget->allocation.width,
3424                        source_max - source_min);
3425
3426       /* Make sure graphics expose events are processed before scrolling
3427        * again */
3428
3429       while ((event = gdk_event_get_graphics_expose (widget->window)) != NULL)
3430         {
3431           gtk_widget_event (widget, event);
3432           if (event->expose.count == 0)
3433             {
3434               gdk_event_free (event);
3435               break;
3436             }
3437           gdk_event_free (event);
3438         }
3439     }
3440
3441
3442   if (rect.height != 0)
3443     gtk_widget_draw (widget, &rect);
3444 }
3445
3446
3447 void
3448 create_scroll_test ()
3449 {
3450   static GtkWidget *window = NULL;
3451   GtkWidget *hbox;
3452   GtkWidget *drawing_area;
3453   GtkWidget *scrollbar;
3454   GtkWidget *button;
3455   GtkAdjustment *adj;
3456
3457   if (!window)
3458     {
3459       window = gtk_dialog_new ();
3460
3461       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3462                           GTK_SIGNAL_FUNC(destroy_window),
3463                           &window);
3464       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3465                           GTK_SIGNAL_FUNC(destroy_window),
3466                           &window);
3467
3468       gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
3469       gtk_container_border_width (GTK_CONTAINER (window), 0);
3470
3471       hbox = gtk_hbox_new (FALSE, 0);
3472       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox,
3473                           TRUE, TRUE, 0);
3474       gtk_widget_show (hbox);
3475
3476       drawing_area = gtk_drawing_area_new ();
3477       gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 200, 200);
3478       gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
3479       gtk_widget_show (drawing_area);
3480
3481       gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK);
3482
3483       adj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0));
3484       scroll_test_pos = 0.0;
3485
3486       scrollbar = gtk_vscrollbar_new (adj);
3487       gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
3488       gtk_widget_show (scrollbar);
3489
3490       gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
3491                           GTK_SIGNAL_FUNC (scroll_test_expose), adj);
3492       gtk_signal_connect (GTK_OBJECT (drawing_area), "configure_event",
3493                           GTK_SIGNAL_FUNC (scroll_test_configure), adj);
3494
3495
3496       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
3497                           GTK_SIGNAL_FUNC (scroll_test_adjustment_changed),
3498                           drawing_area);
3499
3500       /* .. And create some buttons */
3501
3502       button = gtk_button_new_with_label ("Quit");
3503       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3504                           button, TRUE, TRUE, 0);
3505
3506       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3507                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
3508                                  GTK_OBJECT (window));
3509       gtk_widget_show (button);
3510     }
3511
3512   if (!GTK_WIDGET_VISIBLE (window))
3513     gtk_widget_show (window);
3514   else
3515     gtk_widget_destroy (window);
3516 }
3517
3518 /*
3519  * Timeout Test
3520  */
3521 static int timer = 0;
3522
3523 void
3524 timeout_test (GtkWidget *label)
3525 {
3526   static int count = 0;
3527   static char buffer[32];
3528
3529   sprintf (buffer, "count: %d", ++count);
3530   gtk_label_set (GTK_LABEL (label), buffer);
3531 }
3532
3533 void
3534 start_timeout_test (GtkWidget *widget,
3535                     GtkWidget *label)
3536 {
3537   if (!timer)
3538     {
3539       timer = gtk_timeout_add (100, (GtkFunction) timeout_test, label);
3540     }
3541 }
3542
3543 void
3544 stop_timeout_test (GtkWidget *widget,
3545                    gpointer   data)
3546 {
3547   if (timer)
3548     {
3549       gtk_timeout_remove (timer);
3550       timer = 0;
3551     }
3552 }
3553
3554 void
3555 destroy_timeout_test (GtkWidget  *widget,
3556                       GtkWidget **window)
3557 {
3558   destroy_window (widget, window);
3559   stop_timeout_test (NULL, NULL);
3560 }
3561
3562 void
3563 create_timeout_test ()
3564 {
3565   static GtkWidget *window = NULL;
3566   GtkWidget *button;
3567   GtkWidget *label;
3568
3569   if (!window)
3570     {
3571       window = gtk_dialog_new ();
3572
3573       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3574                           GTK_SIGNAL_FUNC(destroy_timeout_test),
3575                           &window);
3576       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3577                           GTK_SIGNAL_FUNC(destroy_timeout_test),
3578                           &window);
3579
3580       gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
3581       gtk_container_border_width (GTK_CONTAINER (window), 0);
3582
3583       label = gtk_label_new ("count: 0");
3584       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
3585       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
3586                           label, TRUE, TRUE, 0);
3587       gtk_widget_show (label);
3588
3589       button = gtk_button_new_with_label ("close");
3590       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3591                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
3592                                  GTK_OBJECT (window));
3593       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3594       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3595                           button, TRUE, TRUE, 0);
3596       gtk_widget_grab_default (button);
3597       gtk_widget_show (button);
3598
3599       button = gtk_button_new_with_label ("start");
3600       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3601                           GTK_SIGNAL_FUNC(start_timeout_test),
3602                           label);
3603       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3604       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3605                           button, TRUE, TRUE, 0);
3606       gtk_widget_show (button);
3607
3608       button = gtk_button_new_with_label ("stop");
3609       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3610                           GTK_SIGNAL_FUNC(stop_timeout_test),
3611                           NULL);
3612       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3613       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3614                           button, TRUE, TRUE, 0);
3615       gtk_widget_show (button);
3616     }
3617
3618   if (!GTK_WIDGET_VISIBLE (window))
3619     gtk_widget_show (window);
3620   else
3621     gtk_widget_destroy (window);
3622 }
3623
3624
3625 /*
3626  * Idle Test
3627  */
3628 static int idle = 0;
3629
3630 gint
3631 idle_test (GtkWidget *label)
3632 {
3633   static int count = 0;
3634   static char buffer[32];
3635
3636   sprintf (buffer, "count: %d", ++count);
3637   gtk_label_set (GTK_LABEL (label), buffer);
3638
3639   return TRUE;
3640 }
3641
3642 void
3643 start_idle_test (GtkWidget *widget,
3644                  GtkWidget *label)
3645 {
3646   if (!idle)
3647     {
3648       idle = gtk_idle_add ((GtkFunction) idle_test, label);
3649     }
3650 }
3651
3652 void
3653 stop_idle_test (GtkWidget *widget,
3654                 gpointer   data)
3655 {
3656   if (idle)
3657     {
3658       gtk_idle_remove (idle);
3659       idle = 0;
3660     }
3661 }
3662
3663 void
3664 destroy_idle_test (GtkWidget  *widget,
3665                    GtkWidget **window)
3666 {
3667   destroy_window (widget, window);
3668   stop_idle_test (NULL, NULL);
3669 }
3670
3671 void
3672 create_idle_test ()
3673 {
3674   static GtkWidget *window = NULL;
3675   GtkWidget *button;
3676   GtkWidget *label;
3677
3678   if (!window)
3679     {
3680       window = gtk_dialog_new ();
3681
3682       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3683                           GTK_SIGNAL_FUNC(destroy_idle_test),
3684                           &window);
3685       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3686                           GTK_SIGNAL_FUNC(destroy_idle_test),
3687                           &window);
3688
3689       gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
3690       gtk_container_border_width (GTK_CONTAINER (window), 0);
3691
3692       label = gtk_label_new ("count: 0");
3693       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
3694       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
3695                           label, TRUE, TRUE, 0);
3696       gtk_widget_show (label);
3697
3698       button = gtk_button_new_with_label ("close");
3699       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3700                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
3701                                  GTK_OBJECT (window));
3702       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3703       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3704                           button, TRUE, TRUE, 0);
3705       gtk_widget_grab_default (button);
3706       gtk_widget_show (button);
3707
3708       button = gtk_button_new_with_label ("start");
3709       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3710                           GTK_SIGNAL_FUNC(start_idle_test),
3711                           label);
3712       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3713       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3714                           button, TRUE, TRUE, 0);
3715       gtk_widget_show (button);
3716
3717       button = gtk_button_new_with_label ("stop");
3718       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3719                           GTK_SIGNAL_FUNC(stop_idle_test),
3720                           NULL);
3721       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3722       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3723                           button, TRUE, TRUE, 0);
3724       gtk_widget_show (button);
3725     }
3726
3727   if (!GTK_WIDGET_VISIBLE (window))
3728     gtk_widget_show (window);
3729   else
3730     gtk_widget_destroy (window);
3731 }
3732
3733 void
3734 test_destroy (GtkWidget  *widget,
3735               GtkWidget **window)
3736 {
3737   destroy_window (widget, window);
3738   gtk_main_quit ();
3739 }
3740
3741 /*
3742  * Basic Test
3743  */
3744 void
3745 create_test ()
3746 {
3747   static GtkWidget *window = NULL;
3748
3749   if (!window)
3750     {
3751       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3752
3753       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3754                           GTK_SIGNAL_FUNC(test_destroy),
3755                           &window);
3756       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3757                           GTK_SIGNAL_FUNC(test_destroy),
3758                           &window);
3759
3760
3761       gtk_window_set_title (GTK_WINDOW (window), "test");
3762       gtk_container_border_width (GTK_CONTAINER (window), 0);
3763     }
3764
3765   if (!GTK_WIDGET_VISIBLE (window))
3766     {
3767       gtk_widget_show (window);
3768
3769       g_print ("create_test: start\n");
3770       gtk_main ();
3771       g_print ("create_test: done\n");
3772     }
3773   else
3774     gtk_widget_destroy (window);
3775 }
3776
3777
3778 /*
3779  * Main Window and Exit
3780  */
3781 void
3782 do_exit ()
3783 {
3784   gtk_exit (0);
3785 }
3786
3787 void
3788 create_main_window ()
3789 {
3790   struct {
3791     char *label;
3792     void (*func) ();
3793   } buttons[] =
3794     {
3795       { "buttons", create_buttons },
3796       { "toggle buttons", create_toggle_buttons },
3797       { "check buttons", create_check_buttons },
3798       { "radio buttons", create_radio_buttons },
3799       { "button box", create_button_box },
3800       { "toolbar", create_toolbar },
3801       { "handle box", create_handle_box },
3802       { "reparent", create_reparent },
3803       { "pixmap", create_pixmap },
3804       { "tooltips", create_tooltips },
3805       { "menus", create_menus },
3806       { "scrolled windows", create_scrolled_windows },
3807       { "drawing areas", NULL },
3808       { "entry", create_entry },
3809       { "list", create_list },
3810       { "clist", create_clist},
3811       { "color selection", create_color_selection },
3812       { "file selection", create_file_selection },
3813       { "dialog", create_dialog },
3814       { "miscellaneous", NULL },
3815       { "range controls", create_range_controls },
3816       { "rulers", create_rulers },
3817       { "text", create_text },
3818       { "notebook", create_notebook },
3819       { "panes", create_panes },
3820       { "shapes", create_shapes },
3821       { "dnd", create_dnd },
3822       { "progress bar", create_progress_bar },
3823       { "preview color", create_color_preview },
3824       { "preview gray", create_gray_preview },
3825       { "gamma curve", create_gamma_curve },
3826       { "test scrolling", create_scroll_test },
3827       { "test selection", create_selection_test },
3828       { "test timeout", create_timeout_test },
3829       { "test idle", create_idle_test },
3830       { "test", create_test },
3831     };
3832   int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
3833   GtkWidget *window;
3834   GtkWidget *box1;
3835   GtkWidget *box2;
3836   GtkWidget *scrolled_window;
3837   GtkWidget *button;
3838   GtkWidget *separator;
3839   int i;
3840
3841   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3842   gtk_widget_set_name (window, "main window");
3843   gtk_widget_set_usize (window, 200, 400);
3844   gtk_widget_set_uposition (window, 20, 20);
3845
3846   gtk_signal_connect (GTK_OBJECT (window), "destroy",
3847                       GTK_SIGNAL_FUNC(gtk_main_quit),
3848                       NULL);
3849   gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3850                       GTK_SIGNAL_FUNC(gtk_main_quit),
3851                       NULL);
3852
3853   box1 = gtk_vbox_new (FALSE, 0);
3854   gtk_container_add (GTK_CONTAINER (window), box1);
3855   gtk_widget_show (box1);
3856
3857   scrolled_window = gtk_scrolled_window_new (NULL, NULL);
3858   gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
3859   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
3860                                   GTK_POLICY_AUTOMATIC,
3861                                   GTK_POLICY_AUTOMATIC);
3862   gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
3863   gtk_widget_show (scrolled_window);
3864
3865   box2 = gtk_vbox_new (FALSE, 0);
3866   gtk_container_border_width (GTK_CONTAINER (box2), 10);
3867   gtk_container_add (GTK_CONTAINER (scrolled_window), box2);
3868   gtk_widget_show (box2);
3869
3870   for (i = 0; i < nbuttons; i++)
3871     {
3872       button = gtk_button_new_with_label (buttons[i].label);
3873       if (buttons[i].func)
3874         gtk_signal_connect (GTK_OBJECT (button),
3875                             "clicked",
3876                             GTK_SIGNAL_FUNC(buttons[i].func),
3877                             NULL);
3878       else
3879         gtk_widget_set_sensitive (button, FALSE);
3880       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3881       gtk_widget_show (button);
3882     }
3883
3884   separator = gtk_hseparator_new ();
3885   gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3886   gtk_widget_show (separator);
3887
3888   box2 = gtk_vbox_new (FALSE, 10);
3889   gtk_container_border_width (GTK_CONTAINER (box2), 10);
3890   gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3891   gtk_widget_show (box2);
3892
3893   button = gtk_button_new_with_label ("close");
3894   gtk_signal_connect (GTK_OBJECT (button), "clicked",
3895                       GTK_SIGNAL_FUNC(do_exit), NULL);
3896   gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3897   GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3898   gtk_widget_grab_default (button);
3899   gtk_widget_show (button);
3900
3901   gtk_widget_show (window);
3902 }
3903
3904 int
3905 main (int argc, char *argv[])
3906 {
3907   gtk_set_locale ();
3908
3909   gtk_init (&argc, &argv);
3910   gtk_rc_parse ("testgtkrc");
3911
3912   create_main_window ();
3913
3914   gtk_main ();
3915
3916   return 0;
3917 }