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