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

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