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   g_free (event->dropdataavailable.data);
2596   g_free (event->dropdataavailable.data_type);
2597 }
2598
2599 void
2600 dnd_drag_request (GtkWidget *button, GdkEvent *event)
2601 {
2602 #define DND_STRING "Bill Gates demands royalties for\nyour use of his innovation."
2603   gtk_widget_dnd_data_set (button, event, DND_STRING, strlen(DND_STRING) + 1);
2604 }
2605
2606 void
2607 create_dnd ()
2608 {
2609   static GtkWidget *window = NULL;
2610   GtkWidget *box1;
2611   GtkWidget *box2;
2612   GtkWidget *box3;
2613   GtkWidget *frame;
2614   GtkWidget *button;
2615   GtkWidget *separator;
2616
2617   /* For clarity... */
2618   char *possible_drag_types[] = {"text/plain"};
2619   char *accepted_drop_types[] = {"text/plain"};
2620
2621   if (!window)
2622     {
2623       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2624
2625       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2626                           GTK_SIGNAL_FUNC(destroy_window),
2627                           &window);
2628       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2629                           GTK_SIGNAL_FUNC(destroy_window),
2630                           &window);
2631
2632       gtk_window_set_title (GTK_WINDOW (window), "Drag -N- Drop");
2633       gtk_container_border_width (GTK_CONTAINER (window), 0);
2634
2635       box1 = gtk_vbox_new (FALSE, 0);
2636       gtk_container_add (GTK_CONTAINER (window), box1);
2637       gtk_widget_show (box1);
2638
2639       box2 = gtk_hbox_new (FALSE, 5);
2640       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2641       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2642       gtk_widget_show (box2);
2643
2644       frame = gtk_frame_new ("Drag");
2645       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
2646       gtk_widget_show (frame);
2647
2648       box3 = gtk_vbox_new (FALSE, 5);
2649       gtk_container_border_width (GTK_CONTAINER (box3), 5);
2650       gtk_container_add (GTK_CONTAINER (frame), box3);
2651       gtk_widget_show (box3);
2652
2653       /*
2654        * FROM Button
2655        */
2656       button = gtk_button_new_with_label ("Drag me!");
2657       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
2658       gtk_widget_show (button);
2659
2660       /*
2661        * currently, the widget has to be realized to
2662        * set dnd on it, this needs to change
2663        */
2664       gtk_widget_realize (button);
2665       gtk_signal_connect (GTK_OBJECT (button),
2666                           "drag_request_event",
2667                           GTK_SIGNAL_FUNC(dnd_drag_request),
2668                           button);
2669
2670       gtk_widget_dnd_drag_set (button, TRUE, possible_drag_types, 1);
2671
2672
2673       frame = gtk_frame_new ("Drop");
2674       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
2675       gtk_widget_show (frame);
2676
2677       box3 = gtk_vbox_new (FALSE, 5);
2678       gtk_container_border_width (GTK_CONTAINER (box3), 5);
2679       gtk_container_add (GTK_CONTAINER (frame), box3);
2680       gtk_widget_show (box3);
2681
2682
2683       /*
2684        * TO Button
2685        */
2686       button = gtk_button_new_with_label ("To");
2687       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
2688       gtk_widget_show (button);
2689
2690       gtk_widget_realize (button);
2691       gtk_signal_connect (GTK_OBJECT (button),
2692                           "drop_data_available_event",
2693                           GTK_SIGNAL_FUNC(dnd_drop),
2694                           button);
2695
2696       gtk_widget_dnd_drop_set (button, TRUE, accepted_drop_types, 1, FALSE);
2697
2698
2699       separator = gtk_hseparator_new ();
2700       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2701       gtk_widget_show (separator);
2702
2703
2704       box2 = gtk_vbox_new (FALSE, 10);
2705       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2706       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2707       gtk_widget_show (box2);
2708
2709
2710       button = gtk_button_new_with_label ("close");
2711
2712       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2713                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2714                                  GTK_OBJECT (window));
2715
2716       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2717       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2718       gtk_widget_grab_default (button);
2719       gtk_widget_show (button);
2720     }
2721
2722   if (!GTK_WIDGET_VISIBLE (window))
2723     gtk_widget_show (window);
2724   else
2725     gtk_widget_destroy (window);
2726 }
2727
2728 /*
2729  * Shaped Windows
2730  */
2731 static GdkWindow *root_win = NULL;
2732 static GtkWidget *modeller = NULL;
2733 static GtkWidget *sheets = NULL;
2734 static GtkWidget *rings = NULL;
2735
2736 typedef struct _cursoroffset {gint x,y;} CursorOffset;
2737
2738 static void
2739 shape_pressed (GtkWidget *widget)
2740 {
2741   CursorOffset *p;
2742
2743   p = gtk_object_get_user_data (GTK_OBJECT(widget));
2744   gtk_widget_get_pointer (widget, &(p->x), &(p->y));
2745
2746   gtk_grab_add (widget);
2747   gdk_pointer_grab (widget->window, TRUE,
2748                     GDK_BUTTON_RELEASE_MASK |
2749                     GDK_BUTTON_MOTION_MASK,
2750                     NULL, NULL, 0);
2751 }
2752
2753
2754 static void
2755 shape_released (GtkWidget *widget)
2756 {
2757   gtk_grab_remove (widget);
2758   gdk_pointer_ungrab (0);
2759 }
2760
2761 static void
2762 shape_motion (GtkWidget      *widget,
2763               GdkEventMotion *event)
2764 {
2765   gint xp, yp;
2766   CursorOffset * p;
2767   GdkModifierType mask;
2768
2769   p = gtk_object_get_user_data (GTK_OBJECT (widget));
2770
2771   gdk_window_get_pointer (root_win, &xp, &yp, &mask);
2772   gtk_widget_set_uposition (widget, xp  - p->x, yp  - p->y);
2773 }
2774
2775 GtkWidget *
2776 shape_create_icon (char     *xpm_file,
2777                    gint      x,
2778                    gint      y,
2779                    gint      px,
2780                    gint      py,
2781                    gint      window_type)
2782 {
2783   GtkWidget *window;
2784   GtkWidget *pixmap;
2785   GtkWidget *fixed;
2786   CursorOffset* icon_pos;
2787   GdkGC* gc;
2788   GdkBitmap *gdk_pixmap_mask;
2789   GdkPixmap *gdk_pixmap;
2790   GtkStyle *style;
2791
2792   style = gtk_widget_get_default_style ();
2793   gc = style->black_gc;
2794
2795   /*
2796    * GDK_WINDOW_TOPLEVEL works also, giving you a title border
2797    */
2798   window = gtk_window_new (window_type);
2799
2800   fixed = gtk_fixed_new ();
2801   gtk_widget_set_usize (fixed, 100,100);
2802   gtk_container_add (GTK_CONTAINER (window), fixed);
2803   gtk_widget_show (fixed);
2804
2805   gdk_pixmap = gdk_pixmap_create_from_xpm (window->window, &gdk_pixmap_mask,
2806                                            &style->bg[GTK_STATE_NORMAL],
2807                                            xpm_file);
2808
2809   pixmap = gtk_pixmap_new (gdk_pixmap, gdk_pixmap_mask);
2810   gtk_fixed_put (GTK_FIXED (fixed), pixmap, px,py);
2811   gtk_widget_show (pixmap);
2812
2813   gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px,py);
2814
2815   gtk_widget_set_events (window,
2816                          gtk_widget_get_events (window) |
2817                          GDK_BUTTON_MOTION_MASK |
2818                          GDK_BUTTON_PRESS_MASK);
2819
2820   gtk_signal_connect (GTK_OBJECT (window), "button_press_event",
2821                       GTK_SIGNAL_FUNC (shape_pressed),NULL);
2822   gtk_signal_connect (GTK_OBJECT (window), "button_release_event",
2823                       GTK_SIGNAL_FUNC (shape_released),NULL);
2824   gtk_signal_connect (GTK_OBJECT (window), "motion_notify_event",
2825                       GTK_SIGNAL_FUNC (shape_motion),NULL);
2826
2827   icon_pos = g_new (CursorOffset, 1);
2828   gtk_object_set_user_data(GTK_OBJECT(window), icon_pos);
2829
2830   gtk_widget_set_uposition (window, x, y);
2831   gtk_widget_show (window);
2832
2833   return window;
2834 }
2835
2836 void
2837 create_shapes ()
2838 {
2839   root_win = gdk_window_foreign_new (GDK_ROOT_WINDOW ());
2840
2841   if (!modeller)
2842     {
2843       modeller = shape_create_icon ("Modeller.xpm",
2844                                     440, 140, 0,0, GTK_WINDOW_POPUP);
2845
2846       gtk_signal_connect (GTK_OBJECT (modeller), "destroy",
2847                           GTK_SIGNAL_FUNC(destroy_window),
2848                           &modeller);
2849       gtk_signal_connect (GTK_OBJECT (modeller), "delete_event",
2850                           GTK_SIGNAL_FUNC(destroy_window),
2851                           &modeller);
2852     }
2853   else
2854     gtk_widget_destroy (modeller);
2855
2856   if (!sheets)
2857     {
2858       sheets = shape_create_icon ("FilesQueue.xpm",
2859                                   580, 170, 0,0, GTK_WINDOW_POPUP);
2860
2861       gtk_signal_connect (GTK_OBJECT (sheets), "destroy",
2862                           GTK_SIGNAL_FUNC(destroy_window),
2863                           &sheets);
2864       gtk_signal_connect (GTK_OBJECT (sheets), "delete_event",
2865                           GTK_SIGNAL_FUNC(destroy_window),
2866                           &sheets);
2867
2868     }
2869   else
2870     gtk_widget_destroy (sheets);
2871
2872   if (!rings)
2873     {
2874       rings = shape_create_icon ("3DRings.xpm",
2875                                  460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
2876
2877       gtk_signal_connect (GTK_OBJECT (rings), "destroy",
2878                           GTK_SIGNAL_FUNC(destroy_window),
2879                           &rings);
2880       gtk_signal_connect (GTK_OBJECT (rings), "delete_event",
2881                           GTK_SIGNAL_FUNC(destroy_window),
2882                           &rings);
2883     }
2884   else
2885     gtk_widget_destroy (rings);
2886 }
2887
2888
2889 /*
2890  * Progress Bar
2891  */
2892 static int progress_timer = 0;
2893
2894 gint
2895 progress_timeout (gpointer data)
2896 {
2897   gfloat new_val;
2898
2899   new_val = GTK_PROGRESS_BAR (data)->percentage;
2900   if (new_val >= 1.0)
2901     new_val = 0.0;
2902   new_val += 0.02;
2903
2904   gtk_progress_bar_update (GTK_PROGRESS_BAR (data), new_val);
2905
2906   return TRUE;
2907 }
2908
2909 void
2910 destroy_progress (GtkWidget  *widget,
2911                   GtkWidget **window)
2912 {
2913   destroy_window (widget, window);
2914   gtk_timeout_remove (progress_timer);
2915   progress_timer = 0;
2916 }
2917
2918 void
2919 create_progress_bar ()
2920 {
2921   static GtkWidget *window = NULL;
2922   GtkWidget *button;
2923   GtkWidget *vbox;
2924   GtkWidget *pbar;
2925   GtkWidget *label;
2926
2927   if (!window)
2928     {
2929       window = gtk_dialog_new ();
2930
2931       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2932                           GTK_SIGNAL_FUNC(destroy_progress),
2933                           &window);
2934       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2935                           GTK_SIGNAL_FUNC(destroy_progress),
2936                           &window);
2937
2938       gtk_window_set_title (GTK_WINDOW (window), "dialog");
2939       gtk_container_border_width (GTK_CONTAINER (window), 0);
2940
2941
2942       vbox = gtk_vbox_new (FALSE, 5);
2943       gtk_container_border_width (GTK_CONTAINER (vbox), 10);
2944       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
2945                           vbox, TRUE, TRUE, 0);
2946       gtk_widget_show (vbox);
2947
2948       label = gtk_label_new ("progress...");
2949       gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
2950       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
2951       gtk_widget_show (label);
2952
2953       pbar = gtk_progress_bar_new ();
2954       gtk_widget_set_usize (pbar, 200, 20);
2955       gtk_box_pack_start (GTK_BOX (vbox), pbar, TRUE, TRUE, 0);
2956       gtk_widget_show (pbar);
2957
2958       progress_timer = gtk_timeout_add (100, progress_timeout, pbar);
2959
2960       button = gtk_button_new_with_label ("close");
2961       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2962                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2963                                  GTK_OBJECT (window));
2964       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2965       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
2966                           button, TRUE, TRUE, 0);
2967       gtk_widget_grab_default (button);
2968       gtk_widget_show (button);
2969     }
2970
2971   if (!GTK_WIDGET_VISIBLE (window))
2972     gtk_widget_show (window);
2973   else
2974     gtk_widget_destroy (window);
2975 }
2976
2977
2978 /*
2979  * Color Preview
2980  */
2981 static int color_idle = 0;
2982
2983 gint
2984 color_idle_func (GtkWidget *preview)
2985 {
2986   static int count = 1;
2987   guchar buf[768];
2988   int i, j, k;
2989
2990   for (i = 0; i < 256; i++)
2991     {
2992       for (j = 0, k = 0; j < 256; j++)
2993         {
2994           buf[k+0] = i + count;
2995           buf[k+1] = 0;
2996           buf[k+2] = j + count;
2997           k += 3;
2998         }
2999
3000       gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
3001     }
3002
3003   count += 1;
3004
3005   gtk_widget_draw (preview, NULL);
3006
3007   return TRUE;
3008 }
3009
3010 void
3011 color_preview_destroy (GtkWidget  *widget,
3012                        GtkWidget **window)
3013 {
3014   gtk_idle_remove (color_idle);
3015   color_idle = 0;
3016
3017   destroy_window (widget, window);
3018 }
3019
3020 void
3021 create_color_preview ()
3022 {
3023   static GtkWidget *window = NULL;
3024   GtkWidget *preview;
3025   guchar buf[768];
3026   int i, j, k;
3027
3028   if (!window)
3029     {
3030       gtk_widget_push_visual (gtk_preview_get_visual ());
3031       gtk_widget_push_colormap (gtk_preview_get_cmap ());
3032
3033       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3034
3035       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3036                           GTK_SIGNAL_FUNC(color_preview_destroy),
3037                           &window);
3038       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3039                           GTK_SIGNAL_FUNC(color_preview_destroy),
3040                           &window);
3041
3042       gtk_window_set_title (GTK_WINDOW (window), "test");
3043       gtk_container_border_width (GTK_CONTAINER (window), 10);
3044
3045       preview = gtk_preview_new (GTK_PREVIEW_COLOR);
3046       gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
3047       gtk_container_add (GTK_CONTAINER (window), preview);
3048       gtk_widget_show (preview);
3049
3050       for (i = 0; i < 256; i++)
3051         {
3052           for (j = 0, k = 0; j < 256; j++)
3053             {
3054               buf[k+0] = i;
3055               buf[k+1] = 0;
3056               buf[k+2] = j;
3057               k += 3;
3058             }
3059
3060           gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
3061         }
3062
3063       color_idle = gtk_idle_add ((GtkFunction) color_idle_func, preview);
3064
3065       gtk_widget_pop_colormap ();
3066       gtk_widget_pop_visual ();
3067     }
3068
3069   if (!GTK_WIDGET_VISIBLE (window))
3070     gtk_widget_show (window);
3071   else
3072     gtk_widget_destroy (window);
3073 }
3074
3075
3076 /*
3077  * Gray Preview
3078  */
3079 static int gray_idle = 0;
3080
3081 gint
3082 gray_idle_func (GtkWidget *preview)
3083 {
3084   static int count = 1;
3085   guchar buf[256];
3086   int i, j;
3087
3088   for (i = 0; i < 256; i++)
3089     {
3090       for (j = 0; j < 256; j++)
3091         buf[j] = i + j + count;
3092
3093       gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
3094     }
3095
3096   count += 1;
3097
3098   gtk_widget_draw (preview, NULL);
3099
3100   return TRUE;
3101 }
3102
3103 void
3104 gray_preview_destroy (GtkWidget  *widget,
3105                       GtkWidget **window)
3106 {
3107   gtk_idle_remove (gray_idle);
3108   gray_idle = 0;
3109
3110   destroy_window (widget, window);
3111 }
3112
3113 void
3114 create_gray_preview ()
3115 {
3116   static GtkWidget *window = NULL;
3117   GtkWidget *preview;
3118   guchar buf[256];
3119   int i, j;
3120
3121   if (!window)
3122     {
3123       gtk_widget_push_visual (gtk_preview_get_visual ());
3124       gtk_widget_push_colormap (gtk_preview_get_cmap ());
3125
3126       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3127
3128       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3129                           GTK_SIGNAL_FUNC(gray_preview_destroy),
3130                           &window);
3131       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3132                           GTK_SIGNAL_FUNC(gray_preview_destroy),
3133                           &window);
3134
3135       gtk_window_set_title (GTK_WINDOW (window), "test");
3136       gtk_container_border_width (GTK_CONTAINER (window), 10);
3137
3138       preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
3139       gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
3140       gtk_container_add (GTK_CONTAINER (window), preview);
3141       gtk_widget_show (preview);
3142
3143       for (i = 0; i < 256; i++)
3144         {
3145           for (j = 0; j < 256; j++)
3146             buf[j] = i + j;
3147
3148           gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
3149         }
3150
3151       gray_idle = gtk_idle_add ((GtkFunction) gray_idle_func, preview);
3152
3153       gtk_widget_pop_colormap ();
3154       gtk_widget_pop_visual ();
3155     }
3156
3157   if (!GTK_WIDGET_VISIBLE (window))
3158     gtk_widget_show (window);
3159   else
3160     gtk_widget_destroy (window);
3161 }
3162
3163
3164 /*
3165  * Selection Test
3166  */
3167 void
3168 selection_test_received (GtkWidget *list, GtkSelectionData *data)
3169 {
3170   GdkAtom *atoms;
3171   GtkWidget *list_item;
3172   GList *item_list;
3173   int i, l;
3174
3175   if (data->length < 0)
3176     {
3177       g_print ("Selection retrieval failed\n");
3178       return;
3179     }
3180   if (data->type != GDK_SELECTION_TYPE_ATOM)
3181     {
3182       g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
3183       return;
3184     }
3185
3186   /* Clear out any current list items */
3187
3188   gtk_list_clear_items (GTK_LIST(list), 0, -1);
3189
3190   /* Add new items to list */
3191
3192   atoms = (GdkAtom *)data->data;
3193
3194   item_list = NULL;
3195   l = data->length / sizeof (GdkAtom);
3196   for (i = 0; i < l; i++)
3197     {
3198       char *name;
3199       name = gdk_atom_name (atoms[i]);
3200       if (name != NULL)
3201         {
3202           list_item = gtk_list_item_new_with_label (name);
3203           g_free (name);
3204         }
3205       else
3206         list_item = gtk_list_item_new_with_label ("(bad atom)");
3207
3208       gtk_widget_show (list_item);
3209       item_list = g_list_append (item_list, list_item);
3210     }
3211
3212   gtk_list_append_items (GTK_LIST (list), item_list);
3213
3214   return;
3215 }
3216
3217 void
3218 selection_test_get_targets (GtkWidget *widget, GtkWidget *list)
3219 {
3220   static GdkAtom targets_atom = GDK_NONE;
3221
3222   if (targets_atom == GDK_NONE)
3223     targets_atom = gdk_atom_intern ("TARGETS", FALSE);
3224
3225   gtk_selection_convert (list, GDK_SELECTION_PRIMARY, targets_atom,
3226                          GDK_CURRENT_TIME);
3227 }
3228
3229 void
3230 create_selection_test ()
3231 {
3232   static GtkWidget *window = NULL;
3233   GtkWidget *button;
3234   GtkWidget *vbox;
3235   GtkWidget *scrolled_win;
3236   GtkWidget *list;
3237   GtkWidget *label;
3238
3239   if (!window)
3240     {
3241       window = gtk_dialog_new ();
3242
3243       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3244                           GTK_SIGNAL_FUNC(destroy_window),
3245                           &window);
3246       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3247                           GTK_SIGNAL_FUNC(destroy_window),
3248                           &window);
3249
3250       gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
3251       gtk_container_border_width (GTK_CONTAINER (window), 0);
3252
3253       /* Create the list */
3254
3255       vbox = gtk_vbox_new (FALSE, 5);
3256       gtk_container_border_width (GTK_CONTAINER (vbox), 10);
3257       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox,
3258                           TRUE, TRUE, 0);
3259       gtk_widget_show (vbox);
3260
3261       label = gtk_label_new ("Gets available targets for current selection");
3262       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
3263       gtk_widget_show (label);
3264
3265       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
3266       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
3267                                       GTK_POLICY_AUTOMATIC,
3268                                       GTK_POLICY_AUTOMATIC);
3269       gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
3270       gtk_widget_set_usize (scrolled_win, 100, 200);
3271       gtk_widget_show (scrolled_win);
3272
3273       list = gtk_list_new ();
3274       gtk_container_add (GTK_CONTAINER (scrolled_win), list);
3275
3276       gtk_signal_connect (GTK_OBJECT(list), "selection_received",
3277                           GTK_SIGNAL_FUNC (selection_test_received), NULL);
3278       gtk_widget_show (list);
3279
3280       /* .. And create some buttons */
3281       button = gtk_button_new_with_label ("Get Targets");
3282       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3283                           button, TRUE, TRUE, 0);
3284
3285       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3286                           GTK_SIGNAL_FUNC (selection_test_get_targets), list);
3287       gtk_widget_show (button);
3288
3289       button = gtk_button_new_with_label ("Quit");
3290       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3291                           button, TRUE, TRUE, 0);
3292
3293       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3294                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
3295                                  GTK_OBJECT (window));
3296       gtk_widget_show (button);
3297     }
3298
3299   if (!GTK_WIDGET_VISIBLE (window))
3300     gtk_widget_show (window);
3301   else
3302     gtk_widget_destroy (window);
3303 }
3304
3305
3306 /*
3307  * Gamma Curve
3308  */
3309 void
3310 create_gamma_curve ()
3311 {
3312   static GtkWidget *window = NULL, *curve;
3313   static int count = 0;
3314   gfloat vec[256];
3315   gint max;
3316   gint i;
3317
3318   if (!window)
3319     {
3320       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3321       gtk_window_set_title (GTK_WINDOW (window), "test");
3322       gtk_container_border_width (GTK_CONTAINER (window), 10);
3323
3324       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3325                           GTK_SIGNAL_FUNC(destroy_window),
3326                           &window);
3327       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3328                           GTK_SIGNAL_FUNC(destroy_window),
3329                           &window);
3330
3331       curve = gtk_gamma_curve_new ();
3332       gtk_container_add (GTK_CONTAINER (window), curve);
3333       gtk_widget_show (curve);
3334     }
3335
3336   max = 127 + (count % 2)*128;
3337   gtk_curve_set_range (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
3338                        0, max, 0, max);
3339   for (i = 0; i < max; ++i)
3340     vec[i] = (127 / sqrt (max)) * sqrt (i);
3341   gtk_curve_set_vector (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
3342                         max, vec);
3343
3344   if (!GTK_WIDGET_VISIBLE (window))
3345     gtk_widget_show (window);
3346   else if (count % 4 == 3)
3347     {
3348       gtk_widget_destroy (window);
3349       window = NULL;
3350     }
3351
3352   ++count;
3353 }
3354
3355 static int scroll_test_pos = 0.0;
3356 static GdkGC *scroll_test_gc = NULL;
3357
3358 static gint
3359 scroll_test_expose (GtkWidget *widget, GdkEventExpose *event,
3360                     GtkAdjustment *adj)
3361 {
3362   gint i,j;
3363   gint imin, imax, jmin, jmax;
3364
3365   imin = (event->area.x) / 10;
3366   imax = (event->area.x + event->area.width + 9) / 10;
3367
3368   jmin = ((int)adj->value + event->area.y) / 10;
3369   jmax = ((int)adj->value + event->area.y + event->area.height + 9) / 10;
3370
3371   gdk_window_clear_area (widget->window,
3372                          event->area.x, event->area.y,
3373                          event->area.width, event->area.height);
3374
3375   for (i=imin; i<imax; i++)
3376     for (j=jmin; j<jmax; j++)
3377       if ((i+j) % 2)
3378         gdk_draw_rectangle (widget->window,
3379                             widget->style->black_gc,
3380                             TRUE,
3381                             10*i, 10*j - (int)adj->value, 1+i%10, 1+j%10);
3382
3383   return TRUE;
3384 }
3385
3386 static void
3387 scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
3388                        GtkAdjustment *adj)
3389 {
3390   adj->page_increment = 0.9 * widget->allocation.height;
3391   adj->page_size = widget->allocation.height;
3392
3393   gtk_signal_emit_by_name (GTK_OBJECT (adj), "changed");
3394 }
3395
3396 static void
3397 scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
3398 {
3399   gint source_min = (int)adj->value - scroll_test_pos;
3400   gint source_max = source_min + widget->allocation.height;
3401   gint dest_min = 0;
3402   gint dest_max = widget->allocation.height;
3403   GdkRectangle rect;
3404   GdkEvent *event;
3405
3406   scroll_test_pos = adj->value;
3407
3408   if (!GTK_WIDGET_DRAWABLE (widget))
3409     return;
3410
3411   if (source_min < 0)
3412     {
3413       rect.x = 0;
3414       rect.y = 0;
3415       rect.width = widget->allocation.width;
3416       rect.height = -source_min;
3417       if (rect.height > widget->allocation.height)
3418         rect.height = widget->allocation.height;
3419
3420       source_min = 0;
3421       dest_min = rect.height;
3422     }
3423   else
3424     {
3425       rect.x = 0;
3426       rect.y = 2*widget->allocation.height - source_max;
3427       if (rect.y < 0)
3428         rect.y = 0;
3429       rect.width = widget->allocation.width;
3430       rect.height = widget->allocation.height - rect.y;
3431
3432       source_max = widget->allocation.height;
3433       dest_max = rect.y;
3434     }
3435
3436   if (source_min != source_max)
3437     {
3438       if (scroll_test_gc == NULL)
3439         {
3440           scroll_test_gc = gdk_gc_new (widget->window);
3441           gdk_gc_set_exposures (scroll_test_gc, TRUE);
3442         }
3443
3444       gdk_draw_pixmap (widget->window,
3445                        scroll_test_gc,
3446                        widget->window,
3447                        0, source_min,
3448                        0, dest_min,
3449                        widget->allocation.width,
3450                        source_max - source_min);
3451
3452       /* Make sure graphics expose events are processed before scrolling
3453        * again */
3454
3455       while ((event = gdk_event_get_graphics_expose (widget->window)) != NULL)
3456         {
3457           gtk_widget_event (widget, event);
3458           if (event->expose.count == 0)
3459             {
3460               gdk_event_free (event);
3461               break;
3462             }
3463           gdk_event_free (event);
3464         }
3465     }
3466
3467
3468   if (rect.height != 0)
3469     gtk_widget_draw (widget, &rect);
3470 }
3471
3472
3473 void
3474 create_scroll_test ()
3475 {
3476   static GtkWidget *window = NULL;
3477   GtkWidget *hbox;
3478   GtkWidget *drawing_area;
3479   GtkWidget *scrollbar;
3480   GtkWidget *button;
3481   GtkAdjustment *adj;
3482
3483   if (!window)
3484     {
3485       window = gtk_dialog_new ();
3486
3487       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3488                           GTK_SIGNAL_FUNC(destroy_window),
3489                           &window);
3490       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3491                           GTK_SIGNAL_FUNC(destroy_window),
3492                           &window);
3493
3494       gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
3495       gtk_container_border_width (GTK_CONTAINER (window), 0);
3496
3497       hbox = gtk_hbox_new (FALSE, 0);
3498       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox,
3499                           TRUE, TRUE, 0);
3500       gtk_widget_show (hbox);
3501
3502       drawing_area = gtk_drawing_area_new ();
3503       gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 200, 200);
3504       gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
3505       gtk_widget_show (drawing_area);
3506
3507       gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK);
3508
3509       adj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0));
3510       scroll_test_pos = 0.0;
3511
3512       scrollbar = gtk_vscrollbar_new (adj);
3513       gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
3514       gtk_widget_show (scrollbar);
3515
3516       gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
3517                           GTK_SIGNAL_FUNC (scroll_test_expose), adj);
3518       gtk_signal_connect (GTK_OBJECT (drawing_area), "configure_event",
3519                           GTK_SIGNAL_FUNC (scroll_test_configure), adj);
3520
3521
3522       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
3523                           GTK_SIGNAL_FUNC (scroll_test_adjustment_changed),
3524                           drawing_area);
3525
3526       /* .. And create some buttons */
3527
3528       button = gtk_button_new_with_label ("Quit");
3529       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3530                           button, TRUE, TRUE, 0);
3531
3532       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3533                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
3534                                  GTK_OBJECT (window));
3535       gtk_widget_show (button);
3536     }
3537
3538   if (!GTK_WIDGET_VISIBLE (window))
3539     gtk_widget_show (window);
3540   else
3541     gtk_widget_destroy (window);
3542 }
3543
3544 /*
3545  * Timeout Test
3546  */
3547 static int timer = 0;
3548
3549 void
3550 timeout_test (GtkWidget *label)
3551 {
3552   static int count = 0;
3553   static char buffer[32];
3554
3555   sprintf (buffer, "count: %d", ++count);
3556   gtk_label_set (GTK_LABEL (label), buffer);
3557 }
3558
3559 void
3560 start_timeout_test (GtkWidget *widget,
3561                     GtkWidget *label)
3562 {
3563   if (!timer)
3564     {
3565       timer = gtk_timeout_add (100, (GtkFunction) timeout_test, label);
3566     }
3567 }
3568
3569 void
3570 stop_timeout_test (GtkWidget *widget,
3571                    gpointer   data)
3572 {
3573   if (timer)
3574     {
3575       gtk_timeout_remove (timer);
3576       timer = 0;
3577     }
3578 }
3579
3580 void
3581 destroy_timeout_test (GtkWidget  *widget,
3582                       GtkWidget **window)
3583 {
3584   destroy_window (widget, window);
3585   stop_timeout_test (NULL, NULL);
3586 }
3587
3588 void
3589 create_timeout_test ()
3590 {
3591   static GtkWidget *window = NULL;
3592   GtkWidget *button;
3593   GtkWidget *label;
3594
3595   if (!window)
3596     {
3597       window = gtk_dialog_new ();
3598
3599       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3600                           GTK_SIGNAL_FUNC(destroy_timeout_test),
3601                           &window);
3602       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3603                           GTK_SIGNAL_FUNC(destroy_timeout_test),
3604                           &window);
3605
3606       gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
3607       gtk_container_border_width (GTK_CONTAINER (window), 0);
3608
3609       label = gtk_label_new ("count: 0");
3610       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
3611       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
3612                           label, TRUE, TRUE, 0);
3613       gtk_widget_show (label);
3614
3615       button = gtk_button_new_with_label ("close");
3616       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3617                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
3618                                  GTK_OBJECT (window));
3619       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3620       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3621                           button, TRUE, TRUE, 0);
3622       gtk_widget_grab_default (button);
3623       gtk_widget_show (button);
3624
3625       button = gtk_button_new_with_label ("start");
3626       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3627                           GTK_SIGNAL_FUNC(start_timeout_test),
3628                           label);
3629       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3630       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3631                           button, TRUE, TRUE, 0);
3632       gtk_widget_show (button);
3633
3634       button = gtk_button_new_with_label ("stop");
3635       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3636                           GTK_SIGNAL_FUNC(stop_timeout_test),
3637                           NULL);
3638       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3639       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3640                           button, TRUE, TRUE, 0);
3641       gtk_widget_show (button);
3642     }
3643
3644   if (!GTK_WIDGET_VISIBLE (window))
3645     gtk_widget_show (window);
3646   else
3647     gtk_widget_destroy (window);
3648 }
3649
3650
3651 /*
3652  * Idle Test
3653  */
3654 static int idle = 0;
3655
3656 gint
3657 idle_test (GtkWidget *label)
3658 {
3659   static int count = 0;
3660   static char buffer[32];
3661
3662   sprintf (buffer, "count: %d", ++count);
3663   gtk_label_set (GTK_LABEL (label), buffer);
3664
3665   return TRUE;
3666 }
3667
3668 void
3669 start_idle_test (GtkWidget *widget,
3670                  GtkWidget *label)
3671 {
3672   if (!idle)
3673     {
3674       idle = gtk_idle_add ((GtkFunction) idle_test, label);
3675     }
3676 }
3677
3678 void
3679 stop_idle_test (GtkWidget *widget,
3680                 gpointer   data)
3681 {
3682   if (idle)
3683     {
3684       gtk_idle_remove (idle);
3685       idle = 0;
3686     }
3687 }
3688
3689 void
3690 destroy_idle_test (GtkWidget  *widget,
3691                    GtkWidget **window)
3692 {
3693   destroy_window (widget, window);
3694   stop_idle_test (NULL, NULL);
3695 }
3696
3697 void
3698 create_idle_test ()
3699 {
3700   static GtkWidget *window = NULL;
3701   GtkWidget *button;
3702   GtkWidget *label;
3703
3704   if (!window)
3705     {
3706       window = gtk_dialog_new ();
3707
3708       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3709                           GTK_SIGNAL_FUNC(destroy_idle_test),
3710                           &window);
3711       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3712                           GTK_SIGNAL_FUNC(destroy_idle_test),
3713                           &window);
3714
3715       gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
3716       gtk_container_border_width (GTK_CONTAINER (window), 0);
3717
3718       label = gtk_label_new ("count: 0");
3719       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
3720       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
3721                           label, TRUE, TRUE, 0);
3722       gtk_widget_show (label);
3723
3724       button = gtk_button_new_with_label ("close");
3725       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3726                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
3727                                  GTK_OBJECT (window));
3728       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3729       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3730                           button, TRUE, TRUE, 0);
3731       gtk_widget_grab_default (button);
3732       gtk_widget_show (button);
3733
3734       button = gtk_button_new_with_label ("start");
3735       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3736                           GTK_SIGNAL_FUNC(start_idle_test),
3737                           label);
3738       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3739       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3740                           button, TRUE, TRUE, 0);
3741       gtk_widget_show (button);
3742
3743       button = gtk_button_new_with_label ("stop");
3744       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3745                           GTK_SIGNAL_FUNC(stop_idle_test),
3746                           NULL);
3747       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3748       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3749                           button, TRUE, TRUE, 0);
3750       gtk_widget_show (button);
3751     }
3752
3753   if (!GTK_WIDGET_VISIBLE (window))
3754     gtk_widget_show (window);
3755   else
3756     gtk_widget_destroy (window);
3757 }
3758
3759 void
3760 test_destroy (GtkWidget  *widget,
3761               GtkWidget **window)
3762 {
3763   destroy_window (widget, window);
3764   gtk_main_quit ();
3765 }
3766
3767 /*
3768  * Basic Test
3769  */
3770 void
3771 create_test ()
3772 {
3773   static GtkWidget *window = NULL;
3774
3775   if (!window)
3776     {
3777       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3778
3779       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3780                           GTK_SIGNAL_FUNC(test_destroy),
3781                           &window);
3782       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3783                           GTK_SIGNAL_FUNC(test_destroy),
3784                           &window);
3785
3786
3787       gtk_window_set_title (GTK_WINDOW (window), "test");
3788       gtk_container_border_width (GTK_CONTAINER (window), 0);
3789     }
3790
3791   if (!GTK_WIDGET_VISIBLE (window))
3792     {
3793       gtk_widget_show (window);
3794
3795       g_print ("create_test: start\n");
3796       gtk_main ();
3797       g_print ("create_test: done\n");
3798     }
3799   else
3800     gtk_widget_destroy (window);
3801 }
3802
3803
3804 /*
3805  * Main Window and Exit
3806  */
3807 void
3808 do_exit ()
3809 {
3810   gtk_exit (0);
3811 }
3812
3813 void
3814 create_main_window ()
3815 {
3816   struct {
3817     char *label;
3818     void (*func) ();
3819   } buttons[] =
3820     {
3821       { "buttons", create_buttons },
3822       { "toggle buttons", create_toggle_buttons },
3823       { "check buttons", create_check_buttons },
3824       { "radio buttons", create_radio_buttons },
3825       { "button box", create_button_box },
3826       { "toolbar", create_toolbar },
3827       { "handle box", create_handle_box },
3828       { "reparent", create_reparent },
3829       { "pixmap", create_pixmap },
3830       { "tooltips", create_tooltips },
3831       { "menus", create_menus },
3832       { "scrolled windows", create_scrolled_windows },
3833       { "drawing areas", NULL },
3834       { "entry", create_entry },
3835       { "list", create_list },
3836       { "clist", create_clist},
3837       { "color selection", create_color_selection },
3838       { "file selection", create_file_selection },
3839       { "dialog", create_dialog },
3840       { "miscellaneous", NULL },
3841       { "range controls", create_range_controls },
3842       { "rulers", create_rulers },
3843       { "text", create_text },
3844       { "notebook", create_notebook },
3845       { "panes", create_panes },
3846       { "shapes", create_shapes },
3847       { "dnd", create_dnd },
3848       { "progress bar", create_progress_bar },
3849       { "preview color", create_color_preview },
3850       { "preview gray", create_gray_preview },
3851       { "gamma curve", create_gamma_curve },
3852       { "test scrolling", create_scroll_test },
3853       { "test selection", create_selection_test },
3854       { "test timeout", create_timeout_test },
3855       { "test idle", create_idle_test },
3856       { "test", create_test },
3857     };
3858   int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
3859   GtkWidget *window;
3860   GtkWidget *box1;
3861   GtkWidget *box2;
3862   GtkWidget *scrolled_window;
3863   GtkWidget *button;
3864   GtkWidget *separator;
3865   int i;
3866
3867   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3868   gtk_widget_set_name (window, "main window");
3869   gtk_widget_set_usize (window, 200, 400);
3870   gtk_widget_set_uposition (window, 20, 20);
3871
3872   gtk_signal_connect (GTK_OBJECT (window), "destroy",
3873                       GTK_SIGNAL_FUNC(gtk_main_quit),
3874                       NULL);
3875   gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3876                       GTK_SIGNAL_FUNC(gtk_main_quit),
3877                       NULL);
3878
3879   box1 = gtk_vbox_new (FALSE, 0);
3880   gtk_container_add (GTK_CONTAINER (window), box1);
3881   gtk_widget_show (box1);
3882
3883   scrolled_window = gtk_scrolled_window_new (NULL, NULL);
3884   gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
3885   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
3886                                   GTK_POLICY_AUTOMATIC,
3887                                   GTK_POLICY_AUTOMATIC);
3888   gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
3889   gtk_widget_show (scrolled_window);
3890
3891   box2 = gtk_vbox_new (FALSE, 0);
3892   gtk_container_border_width (GTK_CONTAINER (box2), 10);
3893   gtk_container_add (GTK_CONTAINER (scrolled_window), box2);
3894   gtk_widget_show (box2);
3895
3896   for (i = 0; i < nbuttons; i++)
3897     {
3898       button = gtk_button_new_with_label (buttons[i].label);
3899       if (buttons[i].func)
3900         gtk_signal_connect (GTK_OBJECT (button),
3901                             "clicked",
3902                             GTK_SIGNAL_FUNC(buttons[i].func),
3903                             NULL);
3904       else
3905         gtk_widget_set_sensitive (button, FALSE);
3906       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3907       gtk_widget_show (button);
3908     }
3909
3910   separator = gtk_hseparator_new ();
3911   gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3912   gtk_widget_show (separator);
3913
3914   box2 = gtk_vbox_new (FALSE, 10);
3915   gtk_container_border_width (GTK_CONTAINER (box2), 10);
3916   gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3917   gtk_widget_show (box2);
3918
3919   button = gtk_button_new_with_label ("close");
3920   gtk_signal_connect (GTK_OBJECT (button), "clicked",
3921                       GTK_SIGNAL_FUNC(do_exit), NULL);
3922   gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3923   GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3924   gtk_widget_grab_default (button);
3925   gtk_widget_show (button);
3926
3927   gtk_widget_show (window);
3928 }
3929
3930 int
3931 main (int argc, char *argv[])
3932 {
3933   gtk_set_locale ();
3934
3935   gtk_init (&argc, &argv);
3936   gtk_rc_parse ("testgtkrc");
3937
3938   create_main_window ();
3939
3940   gtk_main ();
3941
3942   return 0;
3943 }