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