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 create_list ()
1878 {
1879   static GtkWidget *window = NULL;
1880   static char *list_items[] =
1881   {
1882     "hello",
1883     "world",
1884     "blah",
1885     "foo",
1886     "bar",
1887     "argh",
1888     "spencer",
1889     "is a",
1890     "wussy",
1891     "programmer",
1892   };
1893   static int nlist_items = sizeof (list_items) / sizeof (list_items[0]);
1894
1895   GtkWidget *box1;
1896   GtkWidget *box2;
1897   GtkWidget *scrolled_win;
1898   GtkWidget *list;
1899   GtkWidget *list_item;
1900   GtkWidget *button;
1901   GtkWidget *separator;
1902   int i;
1903
1904   if (!window)
1905     {
1906       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1907
1908       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1909                           GTK_SIGNAL_FUNC(destroy_window),
1910                           &window);
1911       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
1912                           GTK_SIGNAL_FUNC(destroy_window),
1913                           &window);
1914
1915       gtk_window_set_title (GTK_WINDOW (window), "list");
1916       gtk_container_border_width (GTK_CONTAINER (window), 0);
1917
1918
1919       box1 = gtk_vbox_new (FALSE, 0);
1920       gtk_container_add (GTK_CONTAINER (window), box1);
1921       gtk_widget_show (box1);
1922
1923
1924       box2 = gtk_vbox_new (FALSE, 10);
1925       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1926       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1927       gtk_widget_show (box2);
1928
1929
1930       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
1931       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
1932                                       GTK_POLICY_AUTOMATIC,
1933                                       GTK_POLICY_AUTOMATIC);
1934       gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
1935       gtk_widget_show (scrolled_win);
1936
1937       list = gtk_list_new ();
1938       gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_MULTIPLE);
1939       gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_BROWSE);
1940       gtk_container_add (GTK_CONTAINER (scrolled_win), list);
1941       gtk_widget_show (list);
1942
1943       for (i = 0; i < nlist_items; i++)
1944         {
1945           list_item = gtk_list_item_new_with_label (list_items[i]);
1946           gtk_container_add (GTK_CONTAINER (list), list_item);
1947           gtk_widget_show (list_item);
1948         }
1949
1950       button = gtk_button_new_with_label ("add");
1951       GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
1952       gtk_signal_connect (GTK_OBJECT (button), "clicked",
1953                           GTK_SIGNAL_FUNC(list_add),
1954                           list);
1955       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
1956       gtk_widget_show (button);
1957
1958       button = gtk_button_new_with_label ("remove");
1959       GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
1960       gtk_signal_connect (GTK_OBJECT (button), "clicked",
1961                           GTK_SIGNAL_FUNC(list_remove),
1962                           list);
1963       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
1964       gtk_widget_show (button);
1965
1966
1967       separator = gtk_hseparator_new ();
1968       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1969       gtk_widget_show (separator);
1970
1971
1972       box2 = gtk_vbox_new (FALSE, 10);
1973       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1974       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1975       gtk_widget_show (box2);
1976
1977
1978       button = gtk_button_new_with_label ("close");
1979       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1980                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1981                                  GTK_OBJECT (window));
1982       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1983       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1984       gtk_widget_grab_default (button);
1985       gtk_widget_show (button);
1986     }
1987
1988   if (!GTK_WIDGET_VISIBLE (window))
1989     gtk_widget_show (window);
1990   else
1991     gtk_widget_destroy (window);
1992 }
1993
1994 /*
1995  * GtkCList
1996  */
1997 #define TESTGTK_CLIST_COLUMNS 7
1998 static gint clist_rows = 0;
1999 static gint clist_selected_row = 0;
2000
2001 static void
2002 add1000_clist (GtkWidget *widget, gpointer data)
2003 {
2004   gint i, row;
2005   char text[TESTGTK_CLIST_COLUMNS][50];
2006   char *texts[TESTGTK_CLIST_COLUMNS];
2007   GdkBitmap *mask;
2008   GdkPixmap *pixmap;
2009
2010   pixmap = gdk_pixmap_create_from_xpm (GTK_CLIST (data)->clist_window,
2011                                        &mask,
2012                                        &GTK_WIDGET (data)->style->white,
2013                                        "test.xpm");
2014
2015   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
2016     {
2017       texts[i] = text[i];
2018       sprintf (text[i], "Column %d", i);
2019     }
2020
2021   texts[3] = NULL;
2022   sprintf (text[1], "Right");
2023   sprintf (text[2], "Center");
2024
2025   gtk_clist_freeze (GTK_CLIST (data));
2026   for (i = 0; i < 1000; i++)
2027     {
2028       sprintf (text[0], "Row %d", clist_rows++);
2029       row = gtk_clist_append (GTK_CLIST (data), texts);
2030       gtk_clist_set_pixtext (GTK_CLIST (data), row, 3, "Testing", 5, pixmap, mask);
2031     }
2032   gtk_clist_thaw (GTK_CLIST (data));
2033
2034   gdk_pixmap_unref (pixmap);
2035   gdk_bitmap_unref (mask);
2036 }
2037
2038 static void
2039 add10000_clist (GtkWidget *widget, gpointer data)
2040 {
2041   gint i;
2042   char text[TESTGTK_CLIST_COLUMNS][50];
2043   char *texts[TESTGTK_CLIST_COLUMNS];
2044
2045   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
2046     {
2047       texts[i] = text[i];
2048       sprintf (text[i], "Column %d", i);
2049     }
2050
2051   sprintf (text[1], "Right");
2052   sprintf (text[2], "Center");
2053
2054   gtk_clist_freeze (GTK_CLIST (data));
2055   for (i = 0; i < 10000; i++)
2056     {
2057       sprintf (text[0], "Row %d", clist_rows++);
2058       gtk_clist_append (GTK_CLIST (data), texts);
2059     }
2060   gtk_clist_thaw (GTK_CLIST (data));
2061
2062 }
2063
2064 void
2065 clear_clist (GtkWidget *widget, gpointer data)
2066 {
2067   gtk_clist_clear (GTK_CLIST (data));
2068   clist_rows = 0;
2069 }
2070
2071 void
2072 remove_row_clist (GtkWidget *widget, gpointer data)
2073 {
2074   gtk_clist_remove (GTK_CLIST (data), clist_selected_row);
2075   clist_rows--;
2076 }
2077
2078 void
2079 show_titles_clist (GtkWidget *widget, gpointer data)
2080 {
2081   gtk_clist_column_titles_show (GTK_CLIST (data));
2082 }
2083
2084 void
2085 hide_titles_clist (GtkWidget *widget, gpointer data)
2086 {
2087   gtk_clist_column_titles_hide (GTK_CLIST (data));
2088 }
2089
2090 void
2091 select_clist (GtkWidget *widget,
2092               gint row,
2093               gint column,
2094               GdkEventButton * bevent)
2095 {
2096   gint i;
2097   guint8 spacing;
2098   gchar *text;
2099   GdkPixmap *pixmap;
2100   GdkBitmap *mask;
2101
2102   g_print ("GtkCList Selection: row %d column %d button %d\n",
2103            row, column, bevent ? bevent->button : 0);
2104
2105   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
2106     {
2107       switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i))
2108         {
2109         case GTK_CELL_TEXT:
2110           g_print ("CELL %d GTK_CELL_TEXT\n", i);
2111           gtk_clist_get_text (GTK_CLIST (widget), row, i, &text);
2112           g_print ("TEXT: %s\n", text);
2113           break;
2114
2115         case GTK_CELL_PIXMAP:
2116           g_print ("CELL %d GTK_CELL_PIXMAP\n", i);
2117           gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask);
2118           g_print ("PIXMAP: %d\n", (int) pixmap);
2119           g_print ("MASK: %d\n", (int) mask);
2120           break;
2121
2122         case GTK_CELL_PIXTEXT:
2123           g_print ("CELL %d GTK_CELL_PIXTEXT\n", i);
2124           gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask);
2125           g_print ("TEXT: %s\n", text);
2126           g_print ("SPACING: %d\n", spacing);
2127           g_print ("PIXMAP: %d\n", (int) pixmap);
2128           g_print ("MASK: %d\n", (int) mask);
2129           break;
2130
2131         default:
2132           break;
2133         }
2134     }
2135
2136   g_print ("\n\n");
2137
2138   clist_selected_row = row;
2139 }
2140
2141 void
2142 list_selection_clist (GtkWidget *widget, gpointer data)
2143 {
2144 }
2145
2146 void
2147 create_clist ()
2148 {
2149   gint i;
2150   static GtkWidget *window = NULL;
2151
2152   static char *titles[] =
2153   {
2154     "Title 0",
2155     "Title 1",
2156     "Title 2",
2157     "Title 3",
2158     "Title 4",
2159     "Title 5",
2160     "Title 6"
2161   };
2162
2163   char text[TESTGTK_CLIST_COLUMNS][50];
2164   char *texts[TESTGTK_CLIST_COLUMNS];
2165
2166   GtkWidget *box1;
2167   GtkWidget *box2;
2168   GtkWidget *clist;
2169   GtkWidget *button;
2170   GtkWidget *separator;
2171
2172
2173   if (!window)
2174     {
2175       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2176
2177       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2178                           GTK_SIGNAL_FUNC(destroy_window),
2179                           &window);
2180       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2181                           GTK_SIGNAL_FUNC(destroy_window),
2182                           &window);
2183
2184       gtk_window_set_title (GTK_WINDOW (window), "clist");
2185       gtk_container_border_width (GTK_CONTAINER (window), 0);
2186
2187
2188       box1 = gtk_vbox_new (FALSE, 0);
2189       gtk_container_add (GTK_CONTAINER (window), box1);
2190       gtk_widget_show (box1);
2191
2192
2193       box2 = gtk_hbox_new (FALSE, 10);
2194       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2195       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
2196       gtk_widget_show (box2);
2197
2198       /* create GtkCList here so we have a pointer to throw at the
2199        * button callbacks -- more is done with it later */
2200       clist = gtk_clist_new_with_titles (TESTGTK_CLIST_COLUMNS, titles);
2201       /*clist = gtk_clist_new (TESTGTK_CLIST_COLUMNS);*/
2202
2203       /* control buttons */
2204       button = gtk_button_new_with_label ("Add 1,000 Rows With Pixmaps");
2205       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2206
2207       gtk_signal_connect (GTK_OBJECT (button),
2208                           "clicked",
2209                           (GtkSignalFunc) add1000_clist,
2210                           (gpointer) clist);
2211
2212       gtk_widget_show (button);
2213
2214
2215       button = gtk_button_new_with_label ("Add 10,000 Rows");
2216       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2217
2218       gtk_signal_connect (GTK_OBJECT (button),
2219                           "clicked",
2220                           (GtkSignalFunc) add10000_clist,
2221                           (gpointer) clist);
2222
2223       gtk_widget_show (button);
2224
2225       button = gtk_button_new_with_label ("Clear List");
2226       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2227
2228       gtk_signal_connect (GTK_OBJECT (button),
2229                           "clicked",
2230                           (GtkSignalFunc) clear_clist,
2231                           (gpointer) clist);
2232
2233       gtk_widget_show (button);
2234
2235       button = gtk_button_new_with_label ("Remove Row");
2236       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2237
2238       gtk_signal_connect (GTK_OBJECT (button),
2239                           "clicked",
2240                           (GtkSignalFunc) remove_row_clist,
2241                           (gpointer) clist);
2242
2243       gtk_widget_show (button);
2244
2245       /* second layer of buttons */
2246       box2 = gtk_hbox_new (FALSE, 10);
2247       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2248       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
2249       gtk_widget_show (box2);
2250
2251       button = gtk_button_new_with_label ("Show Title Buttons");
2252       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2253
2254       gtk_signal_connect (GTK_OBJECT (button),
2255                           "clicked",
2256                           (GtkSignalFunc) show_titles_clist,
2257                           (gpointer) clist);
2258
2259       gtk_widget_show (button);
2260
2261       button = gtk_button_new_with_label ("Hide Title Buttons");
2262       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2263
2264       gtk_signal_connect (GTK_OBJECT (button),
2265                           "clicked",
2266                           (GtkSignalFunc) hide_titles_clist,
2267                           (gpointer) clist);
2268
2269       gtk_widget_show (button);
2270
2271       /* vbox for the list itself */
2272       box2 = gtk_vbox_new (FALSE, 10);
2273       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2274       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2275       gtk_widget_show (box2);
2276
2277       /*
2278        * the rest of the clist configuration
2279        */
2280       gtk_clist_set_row_height (GTK_CLIST (clist), 20);
2281
2282       gtk_signal_connect (GTK_OBJECT (clist),
2283                           "select_row",
2284                           (GtkSignalFunc) select_clist,
2285                           NULL);
2286
2287       gtk_clist_set_column_width (GTK_CLIST (clist), 0, 100);
2288
2289       for (i = 1; i < TESTGTK_CLIST_COLUMNS; i++)
2290         gtk_clist_set_column_width (GTK_CLIST (clist), i, 80);
2291
2292       gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_BROWSE);
2293
2294       gtk_clist_set_policy (GTK_CLIST (clist), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2295
2296       gtk_clist_set_column_justification (GTK_CLIST (clist), 1, GTK_JUSTIFY_RIGHT);
2297       gtk_clist_set_column_justification (GTK_CLIST (clist), 2, GTK_JUSTIFY_CENTER);
2298
2299       for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
2300         {
2301           texts[i] = text[i];
2302           sprintf (text[i], "Column %d", i);
2303         }
2304
2305       sprintf (text[1], "Right");
2306       sprintf (text[2], "Center");
2307
2308       for (i = 0; i < 100; i++)
2309         {
2310           sprintf (text[0], "Row %d", clist_rows++);
2311           gtk_clist_append (GTK_CLIST (clist), texts);
2312         }
2313
2314       gtk_container_border_width (GTK_CONTAINER (clist), 5);
2315       gtk_box_pack_start (GTK_BOX (box2), clist, TRUE, TRUE, 0);
2316       gtk_widget_show (clist);
2317
2318
2319       separator = gtk_hseparator_new ();
2320       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2321       gtk_widget_show (separator);
2322
2323       box2 = gtk_vbox_new (FALSE, 10);
2324       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2325       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2326       gtk_widget_show (box2);
2327
2328       button = gtk_button_new_with_label ("close");
2329       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2330                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2331                                  GTK_OBJECT (window));
2332
2333       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2334       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2335       gtk_widget_grab_default (button);
2336
2337       gtk_widget_show (button);
2338     }
2339
2340   if (!GTK_WIDGET_VISIBLE (window))
2341     gtk_widget_show (window);
2342   else
2343     gtk_widget_destroy (window);
2344
2345 }
2346
2347 /*
2348  * GtkColorSelect
2349  */
2350 void
2351 color_selection_ok (GtkWidget               *w,
2352                     GtkColorSelectionDialog *cs)
2353 {
2354   GtkColorSelection *colorsel;
2355   gdouble color[4];
2356
2357   colorsel=GTK_COLOR_SELECTION(cs->colorsel);
2358
2359   gtk_color_selection_get_color(colorsel,color);
2360   gtk_color_selection_set_color(colorsel,color);
2361 }
2362
2363 void
2364 color_selection_changed (GtkWidget *w,
2365                          GtkColorSelectionDialog *cs)
2366 {
2367   GtkColorSelection *colorsel;
2368   gdouble color[4];
2369
2370   colorsel=GTK_COLOR_SELECTION(cs->colorsel);
2371   gtk_color_selection_get_color(colorsel,color);
2372 }
2373
2374 void
2375 create_color_selection ()
2376 {
2377   static GtkWidget *window = NULL;
2378
2379   if (!window)
2380     {
2381       gtk_preview_set_install_cmap (TRUE);
2382       gtk_widget_push_visual (gtk_preview_get_visual ());
2383       gtk_widget_push_colormap (gtk_preview_get_cmap ());
2384
2385       window = gtk_color_selection_dialog_new ("color selection dialog");
2386
2387       gtk_color_selection_set_opacity (
2388         GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
2389         TRUE);
2390
2391       gtk_color_selection_set_update_policy(
2392         GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
2393         GTK_UPDATE_CONTINUOUS);
2394
2395       gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
2396
2397       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2398                           GTK_SIGNAL_FUNC(destroy_window),
2399                           &window);
2400       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2401                           GTK_SIGNAL_FUNC(destroy_window),
2402                           &window);
2403
2404       gtk_signal_connect (
2405         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
2406         "color_changed",
2407         GTK_SIGNAL_FUNC(color_selection_changed),
2408         window);
2409
2410       gtk_signal_connect (
2411         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->ok_button),
2412         "clicked",
2413         GTK_SIGNAL_FUNC(color_selection_ok),
2414         window);
2415
2416       gtk_signal_connect_object (
2417         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->cancel_button),
2418         "clicked",
2419         GTK_SIGNAL_FUNC(gtk_widget_destroy),
2420         GTK_OBJECT (window));
2421
2422       gtk_widget_pop_colormap ();
2423       gtk_widget_pop_visual ();
2424     }
2425
2426   if (!GTK_WIDGET_VISIBLE (window))
2427     gtk_widget_show (window);
2428   else
2429     gtk_widget_destroy (window);
2430 }
2431
2432
2433 void
2434 file_selection_ok (GtkWidget        *w,
2435                    GtkFileSelection *fs)
2436 {
2437   g_print ("%s\n", gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs)));
2438   gtk_widget_destroy (GTK_WIDGET (fs));
2439 }
2440
2441 void
2442 create_file_selection ()
2443 {
2444   static GtkWidget *window = NULL;
2445
2446   if (!window)
2447     {
2448       window = gtk_file_selection_new ("file selection dialog");
2449       gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
2450
2451       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2452                           GTK_SIGNAL_FUNC(destroy_window),
2453                           &window);
2454       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2455                           GTK_SIGNAL_FUNC(destroy_window),
2456                           &window);
2457
2458       gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (window)->ok_button),
2459                           "clicked", GTK_SIGNAL_FUNC(file_selection_ok),
2460                           window);
2461       gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (window)->cancel_button),
2462                                  "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
2463                                  GTK_OBJECT (window));
2464     }
2465
2466   if (!GTK_WIDGET_VISIBLE (window))
2467     gtk_widget_show (window);
2468   else
2469     gtk_widget_destroy (window);
2470 }
2471
2472
2473 /*
2474  * GtkDialog
2475  */
2476 static GtkWidget *dialog_window = NULL;
2477
2478 void
2479 label_toggle (GtkWidget  *widget,
2480               GtkWidget **label)
2481 {
2482   if (!(*label))
2483     {
2484       *label = gtk_label_new ("Dialog Test");
2485       gtk_signal_connect (GTK_OBJECT (*label),
2486                           "destroy",
2487                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
2488                           label);
2489       gtk_misc_set_padding (GTK_MISC (*label), 10, 10);
2490       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
2491                           *label, TRUE, TRUE, 0);
2492       gtk_widget_show (*label);
2493     }
2494   else
2495     gtk_widget_destroy (*label);
2496 }
2497
2498 void
2499 create_dialog ()
2500 {
2501   static GtkWidget *label;
2502   GtkWidget *button;
2503
2504   if (!dialog_window)
2505     {
2506       dialog_window = gtk_dialog_new ();
2507
2508       gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
2509                           GTK_SIGNAL_FUNC(destroy_window),
2510                           &dialog_window);
2511       gtk_signal_connect (GTK_OBJECT (dialog_window), "delete_event",
2512                           GTK_SIGNAL_FUNC(destroy_window),
2513                           &dialog_window);
2514
2515       gtk_window_set_title (GTK_WINDOW (dialog_window), "dialog");
2516       gtk_container_border_width (GTK_CONTAINER (dialog_window), 0);
2517
2518       button = gtk_button_new_with_label ("OK");
2519       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2520       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
2521                           button, TRUE, TRUE, 0);
2522       gtk_widget_grab_default (button);
2523       gtk_widget_show (button);
2524
2525       button = gtk_button_new_with_label ("Toggle");
2526       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2527                           GTK_SIGNAL_FUNC (label_toggle),
2528                           &label);
2529       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2530       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
2531                           button, TRUE, TRUE, 0);
2532       gtk_widget_show (button);
2533
2534       label = NULL;
2535     }
2536
2537   if (!GTK_WIDGET_VISIBLE (dialog_window))
2538     gtk_widget_show (dialog_window);
2539   else
2540     gtk_widget_destroy (dialog_window);
2541 }
2542
2543
2544 /*
2545  * GtkRange
2546  */
2547 void
2548 create_range_controls ()
2549 {
2550   static GtkWidget *window = NULL;
2551   GtkWidget *box1;
2552   GtkWidget *box2;
2553   GtkWidget *button;
2554   GtkWidget *scrollbar;
2555   GtkWidget *scale;
2556   GtkWidget *separator;
2557   GtkObject *adjustment;
2558
2559   if (!window)
2560     {
2561       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2562
2563       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2564                           GTK_SIGNAL_FUNC(destroy_window),
2565                           &window);
2566       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2567                           GTK_SIGNAL_FUNC(destroy_window),
2568                           &window);
2569
2570       gtk_window_set_title (GTK_WINDOW (window), "range controls");
2571       gtk_container_border_width (GTK_CONTAINER (window), 0);
2572
2573
2574       box1 = gtk_vbox_new (FALSE, 0);
2575       gtk_container_add (GTK_CONTAINER (window), box1);
2576       gtk_widget_show (box1);
2577
2578
2579       box2 = gtk_vbox_new (FALSE, 10);
2580       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2581       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2582       gtk_widget_show (box2);
2583
2584
2585       adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
2586
2587       scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
2588       gtk_widget_set_usize (GTK_WIDGET (scale), 150, 30);
2589       gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
2590       gtk_scale_set_digits (GTK_SCALE (scale), 1);
2591       gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
2592       gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
2593       gtk_widget_show (scale);
2594
2595       scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adjustment));
2596       gtk_range_set_update_policy (GTK_RANGE (scrollbar),
2597                                    GTK_UPDATE_CONTINUOUS);
2598       gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0);
2599       gtk_widget_show (scrollbar);
2600
2601
2602       separator = gtk_hseparator_new ();
2603       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2604       gtk_widget_show (separator);
2605
2606
2607       box2 = gtk_vbox_new (FALSE, 10);
2608       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2609       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2610       gtk_widget_show (box2);
2611
2612
2613       button = gtk_button_new_with_label ("close");
2614       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2615                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2616                                  GTK_OBJECT (window));
2617       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2618       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2619       gtk_widget_grab_default (button);
2620       gtk_widget_show (button);
2621     }
2622
2623   if (!GTK_WIDGET_VISIBLE (window))
2624     gtk_widget_show (window);
2625   else
2626     gtk_widget_destroy (window);
2627 }
2628
2629
2630 /*
2631  * GtkRulers
2632  */
2633 void
2634 create_rulers ()
2635 {
2636   static GtkWidget *window = NULL;
2637   GtkWidget *table;
2638   GtkWidget *ruler;
2639
2640   if (!window)
2641     {
2642       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2643
2644       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2645                           GTK_SIGNAL_FUNC(destroy_window),
2646                           &window);
2647       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2648                           GTK_SIGNAL_FUNC(destroy_window),
2649                           &window);
2650
2651       gtk_window_set_title (GTK_WINDOW (window), "rulers");
2652       gtk_widget_set_usize (window, 300, 300);
2653       gtk_widget_set_events (window,
2654                              GDK_POINTER_MOTION_MASK
2655                              | GDK_POINTER_MOTION_HINT_MASK);
2656       gtk_container_border_width (GTK_CONTAINER (window), 0);
2657
2658       table = gtk_table_new (2, 2, FALSE);
2659       gtk_container_add (GTK_CONTAINER (window), table);
2660       gtk_widget_show (table);
2661
2662       ruler = gtk_hruler_new ();
2663       gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
2664
2665       gtk_signal_connect_object (
2666         GTK_OBJECT (window),
2667         "motion_notify_event",
2668         GTK_SIGNAL_FUNC(
2669           GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
2670         GTK_OBJECT (ruler));
2671
2672       gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
2673                         GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
2674       gtk_widget_show (ruler);
2675
2676
2677       ruler = gtk_vruler_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 (GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
2684         GTK_OBJECT (ruler));
2685
2686       gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
2687                         GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
2688       gtk_widget_show (ruler);
2689     }
2690
2691   if (!GTK_WIDGET_VISIBLE (window))
2692     gtk_widget_show (window);
2693   else
2694     gtk_widget_destroy (window);
2695 }
2696
2697
2698 /*
2699  * GtkText
2700  */
2701 void
2702 create_text ()
2703 {
2704   static GtkWidget *window = NULL;
2705   GtkWidget *box1;
2706   GtkWidget *box2;
2707   GtkWidget *button;
2708   GtkWidget *separator;
2709   GtkWidget *table;
2710   GtkWidget *hscrollbar;
2711   GtkWidget *vscrollbar;
2712   GtkWidget *text;
2713
2714   if (!window)
2715     {
2716       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2717       gtk_widget_set_name (window, "text window");
2718
2719       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2720                           GTK_SIGNAL_FUNC(destroy_window),
2721                           &window);
2722       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2723                           GTK_SIGNAL_FUNC(destroy_window),
2724                           &window);
2725
2726       gtk_window_set_title (GTK_WINDOW (window), "test");
2727       gtk_container_border_width (GTK_CONTAINER (window), 0);
2728
2729
2730       box1 = gtk_vbox_new (FALSE, 0);
2731       gtk_container_add (GTK_CONTAINER (window), box1);
2732       gtk_widget_show (box1);
2733
2734
2735       box2 = gtk_vbox_new (FALSE, 10);
2736       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2737       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2738       gtk_widget_show (box2);
2739
2740
2741       table = gtk_table_new (2, 2, FALSE);
2742       gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2);
2743       gtk_table_set_col_spacing (GTK_TABLE (table), 0, 2);
2744       gtk_box_pack_start (GTK_BOX (box2), table, TRUE, TRUE, 0);
2745       gtk_widget_show (table);
2746
2747       text = gtk_text_new (NULL, NULL);
2748       gtk_text_set_editable (GTK_TEXT (text), TRUE);
2749       gtk_table_attach_defaults (GTK_TABLE (table), text, 0, 1, 0, 1);
2750       gtk_widget_show (text);
2751
2752       hscrollbar = gtk_hscrollbar_new (GTK_TEXT (text)->hadj);
2753       gtk_table_attach (GTK_TABLE (table), hscrollbar, 0, 1, 1, 2,
2754                         GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
2755       gtk_widget_show (hscrollbar);
2756
2757       vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
2758       gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 0, 1,
2759                         GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
2760       gtk_widget_show (vscrollbar);
2761
2762       gtk_text_freeze (GTK_TEXT (text));
2763
2764       gtk_widget_realize (text);
2765
2766       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2767                        "spencer blah blah blah\n", -1);
2768       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2769                        "kimball\n", -1);
2770       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
2771                        "is\n", -1);
2772       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2773                        "a\n", -1);
2774       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2775                        "wuss.\n", -1);
2776       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2777                        "but\n", -1);
2778       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2779                        "josephine\n", -1);
2780       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2781                        "(his\n", -1);
2782       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2783                        "girlfriend\n", -1);
2784       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2785                        "is\n", -1);
2786       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2787                        "not).\n", -1);
2788       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2789                        "why?\n", -1);
2790       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2791                        "because\n", -1);
2792       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2793                        "spencer\n", -1);
2794       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2795                        "puked\n", -1);
2796       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2797                        "last\n", -1);
2798       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2799                        "night\n", -1);
2800       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2801                        "but\n", -1);
2802       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2803                        "josephine\n", -1);
2804       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2805                        "did\n", -1);
2806       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2807                        "not", -1);
2808
2809       gtk_text_thaw (GTK_TEXT (text));
2810
2811       separator = gtk_hseparator_new ();
2812       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2813       gtk_widget_show (separator);
2814
2815
2816       box2 = gtk_vbox_new (FALSE, 10);
2817       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2818       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2819       gtk_widget_show (box2);
2820
2821
2822       button = gtk_button_new_with_label ("close");
2823       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2824                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2825                                  GTK_OBJECT (window));
2826       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2827       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2828       gtk_widget_grab_default (button);
2829       gtk_widget_show (button);
2830     }
2831
2832   if (!GTK_WIDGET_VISIBLE (window))
2833     gtk_widget_show (window);
2834   else
2835     gtk_widget_destroy (window);
2836 }
2837
2838
2839 /*
2840  * GtkNotebook
2841  */
2842
2843 GdkPixmap *book_open;
2844 GdkPixmap *book_closed;
2845 GdkBitmap *book_open_mask;
2846 GdkBitmap *book_closed_mask;
2847
2848 static char * book_open_xpm[] = {
2849 "16 16 11 1",
2850 "       c None",
2851 ".      c #28A22CB228A2",
2852 "X      c #FFFFFFFFFFFF",
2853 "o      c #F7DEF7DEF7DE",
2854 "O      c #000000000000",
2855 "+      c #FFFF6DB60000",
2856 "@      c #CF3CCF3CCF3C",
2857 "#      c #FFFFDB6C0000",
2858 "$      c #30C234D330C2",
2859 "%      c #C71BC30BC71B",
2860 "&      c #D75C6DB60000",
2861 "                ",
2862 "  ..            ",
2863 "  .X.           ",
2864 "  .oO     ...   ",
2865 " .+Xo.  ..oX..  ",
2866 " .+oXo..XXoX.@..",
2867 " .+ooX.@ooXo.@#.",
2868 " .+XXo.@XooX.@+.",
2869 " .+XoX.@XoXo.@#.",
2870 " .+oXo.@oXXX.@+.",
2871 " .++Xo$@oOO..%#.",
2872 " ..+&X.@.O@@@@+.",
2873 "   .++........#.",
2874 "   .+..+++++++&$",
2875 "   .+++.......$.",
2876 "    ...         "};
2877
2878 static char * book_closed_xpm[] = {
2879 "16 16 12 1",
2880 "       c None",
2881 ".      c #000000000000",
2882 "X      c #FFFF6DB60000",
2883 "o      c #082008200820",
2884 "O      c #AEBA00005144",
2885 "+      c #FFFFDB6C0000",
2886 "@      c #AEBA00000000",
2887 "#      c #D75CDB6C0000",
2888 "$      c #28A22CB228A2",
2889 "%      c #FFFFFFFFFFFF",
2890 "&      c #F7DEF7DEF7DE",
2891 "*      c #30C234D330C2",
2892 "                ",
2893 "       ..       ",
2894 "     ..XX.      ",
2895 "   ..XXXXX.     ",
2896 " o.XXXXXXXX.    ",
2897 ".O+XXXXXXXXX.   ",
2898 "o.@#XXXXXXXXX.  ",
2899 ".X.O+XXXXXXXXXo ",
2900 ".XX.@+XXXXXXXX.$",
2901 "oXXX.O+XXXXX..%$",
2902 " .XXX.@+XX..&&&$",
2903 "  .XXX.O..&%&%.*",
2904 "   .XX$.&&%&..  ",
2905 "    .X$&%&.o    ",
2906 "     .$%..      ",
2907 "      .o        "};
2908
2909 static void
2910 page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num)
2911 {
2912   GtkNotebookPage *oldpage;
2913   GtkWidget *pixwid;
2914
2915   oldpage = GTK_NOTEBOOK (widget)->cur_page;
2916
2917   if (page == oldpage)
2918     return;
2919
2920   pixwid = ((GtkBoxChild*)(GTK_BOX (page->tab_label)->children->data))->widget;
2921   gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
2922   pixwid = ((GtkBoxChild*) (GTK_BOX (page->menu_label)->children->data))->widget;
2923   gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
2924
2925   if (oldpage)
2926     {
2927       pixwid = ((GtkBoxChild*) (GTK_BOX
2928                                 (oldpage->tab_label)->children->data))->widget;
2929       gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
2930       pixwid = ((GtkBoxChild*) (GTK_BOX (oldpage->menu_label)->children->data))->widget;
2931       gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
2932     }
2933 }
2934
2935 static void
2936 create_pages (GtkNotebook *notebook, gint start, gint end)
2937 {
2938   GtkWidget *child = NULL;
2939   GtkWidget *label;
2940   GtkWidget *entry;
2941   GtkWidget *box;
2942   GtkWidget *hbox;
2943   GtkWidget *label_box;
2944   GtkWidget *menu_box;
2945   GtkWidget *button;
2946   GtkWidget *pixwid;
2947   gint i;
2948   char buffer[32];
2949
2950   for (i = start; i <= end; i++)
2951     {
2952       sprintf (buffer, "Page %d", i);
2953
2954       switch (i%4)
2955         {
2956         case 3:
2957           child = gtk_button_new_with_label (buffer);
2958           gtk_container_border_width (GTK_CONTAINER(child), 10);
2959           break;
2960         case 2:
2961           child = gtk_label_new (buffer);
2962           break;
2963         case 1:
2964           child = gtk_frame_new (buffer);
2965           gtk_container_border_width (GTK_CONTAINER (child), 10);
2966
2967           box = gtk_vbox_new (TRUE,0);
2968           gtk_container_border_width (GTK_CONTAINER (box), 10);
2969           gtk_container_add (GTK_CONTAINER (child), box);
2970
2971           label = gtk_label_new (buffer);
2972           gtk_box_pack_start (GTK_BOX(box), label, TRUE, TRUE, 5);
2973
2974           entry = gtk_entry_new ();
2975           gtk_box_pack_start (GTK_BOX(box), entry, TRUE, TRUE, 5);
2976
2977           hbox = gtk_hbox_new (TRUE,0);
2978           gtk_box_pack_start (GTK_BOX(box), hbox, TRUE, TRUE, 5);
2979
2980           button = gtk_button_new_with_label ("Ok");
2981           gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
2982
2983           button = gtk_button_new_with_label ("Cancel");
2984           gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
2985           break;
2986         case 0:
2987           child = gtk_frame_new (buffer);
2988           gtk_container_border_width (GTK_CONTAINER (child), 10);
2989
2990           label = gtk_label_new (buffer);
2991           gtk_container_add (GTK_CONTAINER (child), label);
2992           break;
2993         }
2994
2995       gtk_widget_show_all (child);
2996
2997       label_box = gtk_hbox_new (FALSE, 0);
2998       pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
2999       gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
3000       gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
3001       label = gtk_label_new (buffer);
3002       gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
3003       gtk_widget_show_all (label_box);
3004
3005       menu_box = gtk_hbox_new (FALSE, 0);
3006       pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
3007       gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
3008       gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
3009       label = gtk_label_new (buffer);
3010       gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0);
3011       gtk_widget_show_all (menu_box);
3012
3013       gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
3014     }
3015 }
3016
3017 static void
3018 rotate_notebook (GtkButton   *button,
3019                  GtkNotebook *notebook)
3020 {
3021   gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos + 1) % 4);
3022 }
3023
3024 static void
3025 standard_notebook (GtkButton   *button,
3026                    GtkNotebook *notebook)
3027 {
3028   gint i;
3029
3030   gtk_notebook_set_show_tabs (notebook, TRUE);
3031   gtk_notebook_set_scrollable (notebook, FALSE);
3032   if (g_list_length (notebook->children) == 15)
3033     for (i = 0; i < 10; i++)
3034       gtk_notebook_remove_page (notebook, 5);
3035 }
3036
3037 static void
3038 notabs_notebook (GtkButton   *button,
3039                  GtkNotebook *notebook)
3040 {
3041   gint i;
3042
3043   gtk_notebook_set_show_tabs (notebook, FALSE);
3044   if (g_list_length (notebook->children) == 15)
3045     for (i = 0; i < 10; i++)
3046       gtk_notebook_remove_page (notebook, 5);
3047 }
3048
3049 static void
3050 scrollable_notebook (GtkButton   *button,
3051                      GtkNotebook *notebook)
3052 {
3053   gtk_notebook_set_show_tabs (notebook, TRUE);
3054   gtk_notebook_set_scrollable (notebook, TRUE);
3055   if (g_list_length (notebook->children) == 5)
3056     create_pages (notebook, 6, 15);
3057 }
3058
3059 static void
3060 notebook_popup (GtkToggleButton *button,
3061                 GtkNotebook     *notebook)
3062 {
3063   if (button->active)
3064     gtk_notebook_popup_enable (notebook);
3065   else
3066     gtk_notebook_popup_disable (notebook);
3067 }
3068
3069 static void
3070 create_notebook ()
3071 {
3072   static GtkWidget *window = NULL;
3073   GtkWidget *box1;
3074   GtkWidget *box2;
3075   GtkWidget *button;
3076   GtkWidget *separator;
3077   GtkWidget *notebook;
3078   GtkWidget *omenu;
3079   GtkWidget *menu;
3080   GtkWidget *submenu;
3081   GtkWidget *menuitem;
3082   GSList *group;
3083   GdkColor transparent;
3084
3085   if (!window)
3086     {
3087       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3088
3089       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3090                           GTK_SIGNAL_FUNC(destroy_window),
3091                           &window);
3092       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3093                           GTK_SIGNAL_FUNC(destroy_window),
3094                           &window);
3095
3096       gtk_window_set_title (GTK_WINDOW (window), "notebook");
3097       gtk_container_border_width (GTK_CONTAINER (window), 0);
3098
3099       box1 = gtk_vbox_new (FALSE, 0);
3100       gtk_container_add (GTK_CONTAINER (window), box1);
3101
3102       notebook = gtk_notebook_new ();
3103       gtk_signal_connect (GTK_OBJECT (notebook), "switch_page",
3104                           GTK_SIGNAL_FUNC (page_switch), NULL);
3105       gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
3106       gtk_box_pack_start (GTK_BOX (box1), notebook, TRUE, TRUE, 0);
3107       gtk_container_border_width (GTK_CONTAINER (notebook), 10);
3108
3109       book_open = gdk_pixmap_create_from_xpm_d (notebook->window,
3110                                                 &book_open_mask,
3111                                                 &transparent,
3112                                                 book_open_xpm);
3113       book_closed = gdk_pixmap_create_from_xpm_d (notebook->window,
3114                                                   &book_closed_mask,
3115                                                   &transparent,
3116                                                   book_closed_xpm);
3117
3118       create_pages (GTK_NOTEBOOK (notebook), 1, 5);
3119
3120       separator = gtk_hseparator_new ();
3121       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10);
3122
3123       box2 = gtk_hbox_new (TRUE, 5);
3124       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3125
3126       omenu = gtk_option_menu_new ();
3127       menu = gtk_menu_new ();
3128       submenu = NULL;
3129       group = NULL;
3130
3131       menuitem = gtk_radio_menu_item_new_with_label (group, "Standard");
3132       gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
3133                                  GTK_SIGNAL_FUNC (standard_notebook),
3134                                  GTK_OBJECT (notebook));
3135       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
3136       gtk_menu_append (GTK_MENU (menu), menuitem);
3137       gtk_widget_show (menuitem);
3138       menuitem = gtk_radio_menu_item_new_with_label (group, "w/o Tabs");
3139       gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
3140                                  GTK_SIGNAL_FUNC (notabs_notebook),
3141                                  GTK_OBJECT (notebook));
3142       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
3143       gtk_menu_append (GTK_MENU (menu), menuitem);
3144       gtk_widget_show (menuitem);
3145       menuitem = gtk_radio_menu_item_new_with_label (group, "Scrollable");
3146       gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
3147                                  GTK_SIGNAL_FUNC (scrollable_notebook),
3148                                  GTK_OBJECT (notebook));
3149       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
3150       gtk_menu_append (GTK_MENU (menu), menuitem);
3151       gtk_widget_show (menuitem);
3152
3153       gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
3154       gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, FALSE, 0);
3155       button = gtk_check_button_new_with_label ("enable popup menu");
3156       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
3157       gtk_signal_connect (GTK_OBJECT(button), "clicked",
3158                           GTK_SIGNAL_FUNC (notebook_popup),
3159                           GTK_OBJECT (notebook));
3160
3161       box2 = gtk_hbox_new (FALSE, 10);
3162       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3163       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3164
3165       button = gtk_button_new_with_label ("close");
3166       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3167                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
3168                                  GTK_OBJECT (window));
3169       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3170       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3171       gtk_widget_grab_default (button);
3172
3173       button = gtk_button_new_with_label ("next");
3174       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3175                                  GTK_SIGNAL_FUNC (gtk_notebook_next_page),
3176                                  GTK_OBJECT (notebook));
3177       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3178
3179       button = gtk_button_new_with_label ("prev");
3180       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3181                                  GTK_SIGNAL_FUNC (gtk_notebook_prev_page),
3182                                  GTK_OBJECT (notebook));
3183       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3184
3185       button = gtk_button_new_with_label ("rotate");
3186       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3187                           GTK_SIGNAL_FUNC (rotate_notebook),
3188                           notebook);
3189       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3190     }
3191
3192   if (!GTK_WIDGET_VISIBLE (window))
3193     gtk_widget_show_all (window);
3194   else
3195     gtk_widget_destroy (window);
3196 }
3197
3198
3199 /*
3200  * GtkPanes
3201  */
3202 void
3203 create_panes ()
3204 {
3205   static GtkWidget *window = NULL;
3206   GtkWidget *frame;
3207   GtkWidget *hpaned;
3208   GtkWidget *vpaned;
3209
3210   if (!window)
3211     {
3212       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3213
3214       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3215                           GTK_SIGNAL_FUNC(destroy_window),
3216                           &window);
3217       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3218                           GTK_SIGNAL_FUNC(destroy_window),
3219                           &window);
3220
3221       gtk_window_set_title (GTK_WINDOW (window), "Panes");
3222       gtk_container_border_width (GTK_CONTAINER (window), 0);
3223
3224       vpaned = gtk_vpaned_new ();
3225       gtk_container_add (GTK_CONTAINER (window), vpaned);
3226       gtk_container_border_width (GTK_CONTAINER(vpaned), 5);
3227       gtk_widget_show (vpaned);
3228
3229       hpaned = gtk_hpaned_new ();
3230       gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
3231
3232       frame = gtk_frame_new (NULL);
3233       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
3234       gtk_widget_set_usize (frame, 60, 60);
3235       gtk_paned_add1 (GTK_PANED (hpaned), frame);
3236       gtk_widget_show (frame);
3237
3238       frame = gtk_frame_new (NULL);
3239       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
3240       gtk_widget_set_usize (frame, 80, 60);
3241       gtk_paned_add2 (GTK_PANED (hpaned), frame);
3242       gtk_widget_show (frame);
3243
3244       gtk_widget_show (hpaned);
3245
3246       frame = gtk_frame_new (NULL);
3247       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
3248       gtk_widget_set_usize (frame, 60, 80);
3249       gtk_paned_add2 (GTK_PANED (vpaned), frame);
3250       gtk_widget_show (frame);
3251     }
3252
3253   if (!GTK_WIDGET_VISIBLE (window))
3254     gtk_widget_show (window);
3255   else
3256     gtk_widget_destroy (window);
3257 }
3258
3259
3260 /*
3261  * Drag -N- Drop
3262  */
3263
3264 gboolean
3265 dnd_drop_destroy_popup (GtkWidget *widget, GtkWindow **window)
3266 {
3267   if(GTK_IS_BUTTON(widget)) /* I.e. they clicked the close button */
3268     gtk_widget_destroy(GTK_WIDGET(*window));
3269   else {
3270     gtk_grab_remove(GTK_WIDGET(*window));
3271     *window = NULL;
3272   }
3273   return TRUE;
3274 }
3275
3276 void
3277 dnd_drop (GtkWidget *button, GdkEvent *event)
3278 {
3279   static GtkWidget *window = NULL;
3280   GtkWidget *vbox, *lbl, *btn;
3281   gchar *msg;
3282
3283   window = gtk_window_new(GTK_WINDOW_DIALOG);
3284   gtk_container_border_width (GTK_CONTAINER(window), 10);
3285
3286   gtk_signal_connect (GTK_OBJECT (window), "destroy",
3287                       GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
3288                       &window);
3289   gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3290                       GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
3291                       &window);
3292
3293   vbox = gtk_vbox_new(FALSE, 5);
3294
3295   /* Display message that we got from drop source */
3296   msg = g_malloc(strlen(event->dropdataavailable.data)
3297                  + strlen(event->dropdataavailable.data_type) + 100);
3298   sprintf(msg, "Drop data of type %s was:\n\n%s",
3299           event->dropdataavailable.data_type,
3300           (char *)event->dropdataavailable.data);
3301   lbl = gtk_label_new(msg);
3302   gtk_label_set_justify(GTK_LABEL(lbl), GTK_JUSTIFY_FILL);
3303   g_free(msg);
3304   gtk_widget_show(lbl);
3305   gtk_box_pack_start_defaults(GTK_BOX(vbox), lbl);
3306
3307   /* Provide an obvious way out of this heinousness */
3308   btn = gtk_button_new_with_label("Continue with life in\nspite of this oppression");
3309   gtk_signal_connect (GTK_OBJECT (btn), "clicked",
3310                       GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
3311                       &window);
3312   gtk_widget_show(btn);
3313   gtk_box_pack_start_defaults(GTK_BOX(vbox), btn);
3314
3315   gtk_container_add(GTK_CONTAINER(window), vbox);
3316
3317   gtk_widget_show(vbox);
3318   gtk_grab_add(window);
3319   gtk_widget_show(window);
3320 }
3321
3322 void
3323 dnd_drag_request (GtkWidget *button, GdkEvent *event)
3324 {
3325 #define DND_STRING "Bill Gates demands royalties for\nyour use of his innovation."
3326   gtk_widget_dnd_data_set (button, event, DND_STRING, strlen(DND_STRING) + 1);
3327 }
3328
3329 void
3330 create_dnd ()
3331 {
3332   static GtkWidget *window = NULL;
3333   GtkWidget *box1;
3334   GtkWidget *box2;
3335   GtkWidget *box3;
3336   GtkWidget *frame;
3337   GtkWidget *button;
3338   GtkWidget *separator;
3339
3340   /* For clarity... */
3341   char *possible_drag_types[] = {"text/plain"};
3342   char *accepted_drop_types[] = {"text/plain"};
3343
3344   if(!modeller)
3345     create_shapes();
3346
3347   if (!window)
3348     {
3349       GdkPoint hotspot = {5,5};
3350       gdk_dnd_set_drag_shape(modeller->window,
3351                              &hotspot,
3352                              rings->window,
3353                              &hotspot);
3354
3355       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3356
3357       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3358                           GTK_SIGNAL_FUNC(destroy_window),
3359                           &window);
3360       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3361                           GTK_SIGNAL_FUNC(destroy_window),
3362                           &window);
3363
3364       gtk_window_set_title (GTK_WINDOW (window), "Drag -N- Drop");
3365       gtk_container_border_width (GTK_CONTAINER (window), 0);
3366
3367       box1 = gtk_vbox_new (FALSE, 0);
3368       gtk_container_add (GTK_CONTAINER (window), box1);
3369       gtk_widget_show (box1);
3370
3371       box2 = gtk_hbox_new (FALSE, 5);
3372       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3373       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3374       gtk_widget_show (box2);
3375
3376       frame = gtk_frame_new ("Drag");
3377       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
3378       gtk_widget_show (frame);
3379
3380       box3 = gtk_vbox_new (FALSE, 5);
3381       gtk_container_border_width (GTK_CONTAINER (box3), 5);
3382       gtk_container_add (GTK_CONTAINER (frame), box3);
3383       gtk_widget_show (box3);
3384
3385       /*
3386        * FROM Button
3387        */
3388       button = gtk_button_new_with_label ("Drag me!");
3389       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
3390       gtk_widget_show (button);
3391
3392       /*
3393        * currently, the widget has to be realized to
3394        * set dnd on it, this needs to change
3395        */
3396       gtk_widget_realize (button);
3397       gtk_signal_connect (GTK_OBJECT (button),
3398                           "drag_request_event",
3399                           GTK_SIGNAL_FUNC(dnd_drag_request),
3400                           button);
3401
3402       gtk_widget_dnd_drag_set (button, TRUE, possible_drag_types, 1);
3403
3404
3405       frame = gtk_frame_new ("Drop");
3406       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
3407       gtk_widget_show (frame);
3408
3409       box3 = gtk_vbox_new (FALSE, 5);
3410       gtk_container_border_width (GTK_CONTAINER (box3), 5);
3411       gtk_container_add (GTK_CONTAINER (frame), box3);
3412       gtk_widget_show (box3);
3413
3414
3415       /*
3416        * TO Button
3417        */
3418       button = gtk_button_new_with_label ("To");
3419       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
3420       gtk_widget_show (button);
3421
3422       gtk_widget_realize (button);
3423       gtk_signal_connect (GTK_OBJECT (button),
3424                           "drop_data_available_event",
3425                           GTK_SIGNAL_FUNC(dnd_drop),
3426                           button);
3427
3428       gtk_widget_dnd_drop_set (button, TRUE, accepted_drop_types, 1, FALSE);
3429
3430
3431       separator = gtk_hseparator_new ();
3432       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3433       gtk_widget_show (separator);
3434
3435
3436       box2 = gtk_vbox_new (FALSE, 10);
3437       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3438       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3439       gtk_widget_show (box2);
3440
3441
3442       button = gtk_button_new_with_label ("close");
3443
3444       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3445                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
3446                                  GTK_OBJECT (window));
3447
3448       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3449       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3450       gtk_widget_grab_default (button);
3451       gtk_widget_show (button);
3452     }
3453
3454   gtk_widget_hide(modeller); gtk_widget_hide(rings);
3455
3456   if (!GTK_WIDGET_VISIBLE (window))
3457     gtk_widget_show (window);
3458   else
3459     gtk_widget_destroy (window);
3460 }
3461
3462 /*
3463  * Shaped Windows
3464  */
3465 static GdkWindow *root_win = NULL;
3466
3467 typedef struct _cursoroffset {gint x,y;} CursorOffset;
3468
3469 static void
3470 shape_pressed (GtkWidget *widget, GdkEventButton *event)
3471 {
3472   CursorOffset *p;
3473
3474   /* ignore double and triple click */
3475   if (event->type != GDK_BUTTON_PRESS)
3476     return;
3477
3478   p = gtk_object_get_user_data (GTK_OBJECT(widget));
3479   p->x = (int) event->x;
3480   p->y = (int) event->y;
3481
3482   gtk_grab_add (widget);
3483   gdk_pointer_grab (widget->window, TRUE,
3484                     GDK_BUTTON_RELEASE_MASK |
3485                     GDK_BUTTON_MOTION_MASK |
3486                     GDK_POINTER_MOTION_HINT_MASK,
3487                     NULL, NULL, 0);
3488 }
3489
3490
3491 static void
3492 shape_released (GtkWidget *widget)
3493 {
3494   gtk_grab_remove (widget);
3495   gdk_pointer_ungrab (0);
3496 }
3497
3498 static void
3499 shape_motion (GtkWidget      *widget,
3500               GdkEventMotion *event)
3501 {
3502   gint xp, yp;
3503   CursorOffset * p;
3504   GdkModifierType mask;
3505
3506   p = gtk_object_get_user_data (GTK_OBJECT (widget));
3507
3508   /*
3509    * Can't use event->x / event->y here
3510    * because I need absolute coordinates.
3511    */
3512   gdk_window_get_pointer (root_win, &xp, &yp, &mask);
3513   gtk_widget_set_uposition (widget, xp  - p->x, yp  - p->y);
3514 }
3515
3516 GtkWidget *
3517 shape_create_icon (char     *xpm_file,
3518                    gint      x,
3519                    gint      y,
3520                    gint      px,
3521                    gint      py,
3522                    gint      window_type)
3523 {
3524   GtkWidget *window;
3525   GtkWidget *pixmap;
3526   GtkWidget *fixed;
3527   CursorOffset* icon_pos;
3528   GdkGC* gc;
3529   GdkBitmap *gdk_pixmap_mask;
3530   GdkPixmap *gdk_pixmap;
3531   GtkStyle *style;
3532
3533   style = gtk_widget_get_default_style ();
3534   gc = style->black_gc;
3535
3536   /*
3537    * GDK_WINDOW_TOPLEVEL works also, giving you a title border
3538    */
3539   window = gtk_window_new (window_type);
3540
3541   fixed = gtk_fixed_new ();
3542   gtk_widget_set_usize (fixed, 100,100);
3543   gtk_container_add (GTK_CONTAINER (window), fixed);
3544   gtk_widget_show (fixed);
3545
3546   gtk_widget_set_events (window,
3547                          gtk_widget_get_events (window) |
3548                          GDK_BUTTON_MOTION_MASK |
3549                          GDK_POINTER_MOTION_HINT_MASK |
3550                          GDK_BUTTON_PRESS_MASK);
3551
3552   gtk_widget_realize (window);
3553   gdk_pixmap = gdk_pixmap_create_from_xpm (window->window, &gdk_pixmap_mask,
3554                                            &style->bg[GTK_STATE_NORMAL],
3555                                            xpm_file);
3556
3557   pixmap = gtk_pixmap_new (gdk_pixmap, gdk_pixmap_mask);
3558   gtk_fixed_put (GTK_FIXED (fixed), pixmap, px,py);
3559   gtk_widget_show (pixmap);
3560
3561   gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px,py);
3562
3563
3564   gtk_signal_connect (GTK_OBJECT (window), "button_press_event",
3565                       GTK_SIGNAL_FUNC (shape_pressed),NULL);
3566   gtk_signal_connect (GTK_OBJECT (window), "button_release_event",
3567                       GTK_SIGNAL_FUNC (shape_released),NULL);
3568   gtk_signal_connect (GTK_OBJECT (window), "motion_notify_event",
3569                       GTK_SIGNAL_FUNC (shape_motion),NULL);
3570
3571   icon_pos = g_new (CursorOffset, 1);
3572   gtk_object_set_user_data(GTK_OBJECT(window), icon_pos);
3573
3574   gtk_widget_set_uposition (window, x, y);
3575   gtk_widget_show (window);
3576
3577   return window;
3578 }
3579
3580 void
3581 create_shapes ()
3582 {
3583   root_win = gdk_window_foreign_new (GDK_ROOT_WINDOW ());
3584
3585   if (!modeller)
3586     {
3587       modeller = shape_create_icon ("Modeller.xpm",
3588                                     440, 140, 0,0, GTK_WINDOW_POPUP);
3589
3590       gtk_signal_connect (GTK_OBJECT (modeller), "destroy",
3591                           GTK_SIGNAL_FUNC(destroy_window),
3592                           &modeller);
3593       gtk_signal_connect (GTK_OBJECT (modeller), "delete_event",
3594                           GTK_SIGNAL_FUNC(destroy_window),
3595                           &modeller);
3596     }
3597   else
3598     gtk_widget_destroy (modeller);
3599
3600   if (!sheets)
3601     {
3602       sheets = shape_create_icon ("FilesQueue.xpm",
3603                                   580, 170, 0,0, GTK_WINDOW_POPUP);
3604
3605       gtk_signal_connect (GTK_OBJECT (sheets), "destroy",
3606                           GTK_SIGNAL_FUNC(destroy_window),
3607                           &sheets);
3608       gtk_signal_connect (GTK_OBJECT (sheets), "delete_event",
3609                           GTK_SIGNAL_FUNC(destroy_window),
3610                           &sheets);
3611
3612     }
3613   else
3614     gtk_widget_destroy (sheets);
3615
3616   if (!rings)
3617     {
3618       rings = shape_create_icon ("3DRings.xpm",
3619                                  460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
3620
3621       gtk_signal_connect (GTK_OBJECT (rings), "destroy",
3622                           GTK_SIGNAL_FUNC(destroy_window),
3623                           &rings);
3624       gtk_signal_connect (GTK_OBJECT (rings), "delete_event",
3625                           GTK_SIGNAL_FUNC(destroy_window),
3626                           &rings);
3627     }
3628   else
3629     gtk_widget_destroy (rings);
3630 }
3631
3632 void
3633 create_wmhints ()
3634 {
3635   static GtkWidget *window = NULL;
3636   GtkWidget *label;
3637   GtkWidget *separator;
3638   GtkWidget *button;
3639   GtkWidget *box1;
3640   GtkWidget *box2;
3641
3642   GdkBitmap *circles;
3643
3644   if (!window)
3645     {
3646       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3647
3648       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3649                           GTK_SIGNAL_FUNC(destroy_window),
3650                           &window);
3651       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3652                           GTK_SIGNAL_FUNC(destroy_window),
3653                           &window);
3654
3655       gtk_window_set_title (GTK_WINDOW (window), "WM Hints");
3656       gtk_container_border_width (GTK_CONTAINER (window), 0);
3657
3658       gtk_widget_realize (window);
3659
3660       circles = gdk_bitmap_create_from_data (window->window,
3661                                              circles_bits,
3662                                              circles_width,
3663                                              circles_height);
3664       gdk_window_set_icon (window->window, NULL,
3665                            circles, circles);
3666
3667       gdk_window_set_icon_name (window->window, "WMHints Test Icon");
3668
3669       gdk_window_set_decorations (window->window, GDK_DECOR_ALL | GDK_DECOR_MENU);
3670       gdk_window_set_functions (window->window, GDK_FUNC_ALL | GDK_FUNC_RESIZE);
3671
3672       box1 = gtk_vbox_new (FALSE, 0);
3673       gtk_container_add (GTK_CONTAINER (window), box1);
3674       gtk_widget_show (box1);
3675
3676       label = gtk_label_new ("Try iconizing me!");
3677       gtk_widget_set_usize (label, 150, 50);
3678       gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
3679       gtk_widget_show (label);
3680
3681
3682       separator = gtk_hseparator_new ();
3683       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3684       gtk_widget_show (separator);
3685
3686
3687       box2 = gtk_vbox_new (FALSE, 10);
3688       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3689       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3690       gtk_widget_show (box2);
3691
3692
3693       button = gtk_button_new_with_label ("close");
3694
3695       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3696                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
3697                                  GTK_OBJECT (window));
3698
3699       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3700       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3701       gtk_widget_grab_default (button);
3702       gtk_widget_show (button);
3703     }
3704
3705   if (!GTK_WIDGET_VISIBLE (window))
3706     gtk_widget_show (window);
3707   else
3708     gtk_widget_destroy (window);
3709 }
3710
3711 /*
3712  * Progress Bar
3713  */
3714 static int progress_timer = 0;
3715
3716 gint
3717 progress_timeout (gpointer data)
3718 {
3719   gfloat new_val;
3720
3721   new_val = GTK_PROGRESS_BAR (data)->percentage;
3722   if (new_val >= 1.0)
3723     new_val = 0.0;
3724   new_val += 0.02;
3725
3726   gtk_progress_bar_update (GTK_PROGRESS_BAR (data), new_val);
3727
3728   return TRUE;
3729 }
3730
3731 void
3732 destroy_progress (GtkWidget  *widget,
3733                   GtkWidget **window)
3734 {
3735   destroy_window (widget, window);
3736   gtk_timeout_remove (progress_timer);
3737   progress_timer = 0;
3738 }
3739
3740 void
3741 create_progress_bar ()
3742 {
3743   static GtkWidget *window = NULL;
3744   GtkWidget *button;
3745   GtkWidget *vbox;
3746   GtkWidget *pbar;
3747   GtkWidget *label;
3748
3749   if (!window)
3750     {
3751       window = gtk_dialog_new ();
3752
3753       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3754                           GTK_SIGNAL_FUNC(destroy_progress),
3755                           &window);
3756       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3757                           GTK_SIGNAL_FUNC(destroy_progress),
3758                           &window);
3759
3760       gtk_window_set_title (GTK_WINDOW (window), "dialog");
3761       gtk_container_border_width (GTK_CONTAINER (window), 0);
3762
3763
3764       vbox = gtk_vbox_new (FALSE, 5);
3765       gtk_container_border_width (GTK_CONTAINER (vbox), 10);
3766       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
3767                           vbox, TRUE, TRUE, 0);
3768       gtk_widget_show (vbox);
3769
3770       label = gtk_label_new ("progress...");
3771       gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3772       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
3773       gtk_widget_show (label);
3774
3775       pbar = gtk_progress_bar_new ();
3776       gtk_widget_set_usize (pbar, 200, 20);
3777       gtk_box_pack_start (GTK_BOX (vbox), pbar, TRUE, TRUE, 0);
3778       gtk_widget_show (pbar);
3779
3780       progress_timer = gtk_timeout_add (100, progress_timeout, pbar);
3781
3782       button = gtk_button_new_with_label ("close");
3783       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3784                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
3785                                  GTK_OBJECT (window));
3786       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3787       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3788                           button, TRUE, TRUE, 0);
3789       gtk_widget_grab_default (button);
3790       gtk_widget_show (button);
3791     }
3792
3793   if (!GTK_WIDGET_VISIBLE (window))
3794     gtk_widget_show (window);
3795   else
3796     gtk_widget_destroy (window);
3797 }
3798
3799
3800 /*
3801  * Color Preview
3802  */
3803 static int color_idle = 0;
3804
3805 gint
3806 color_idle_func (GtkWidget *preview)
3807 {
3808   static int count = 1;
3809   guchar buf[768];
3810   int i, j, k;
3811
3812   for (i = 0; i < 256; i++)
3813     {
3814       for (j = 0, k = 0; j < 256; j++)
3815         {
3816           buf[k+0] = i + count;
3817           buf[k+1] = 0;
3818           buf[k+2] = j + count;
3819           k += 3;
3820         }
3821
3822       gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
3823     }
3824
3825   count += 1;
3826
3827   gtk_widget_draw (preview, NULL);
3828
3829   return TRUE;
3830 }
3831
3832 void
3833 color_preview_destroy (GtkWidget  *widget,
3834                        GtkWidget **window)
3835 {
3836   gtk_idle_remove (color_idle);
3837   color_idle = 0;
3838
3839   destroy_window (widget, window);
3840 }
3841
3842 void
3843 create_color_preview ()
3844 {
3845   static GtkWidget *window = NULL;
3846   GtkWidget *preview;
3847   guchar buf[768];
3848   int i, j, k;
3849
3850   if (!window)
3851     {
3852       gtk_widget_push_visual (gtk_preview_get_visual ());
3853       gtk_widget_push_colormap (gtk_preview_get_cmap ());
3854
3855       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3856
3857       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3858                           GTK_SIGNAL_FUNC(color_preview_destroy),
3859                           &window);
3860       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3861                           GTK_SIGNAL_FUNC(color_preview_destroy),
3862                           &window);
3863
3864       gtk_window_set_title (GTK_WINDOW (window), "test");
3865       gtk_container_border_width (GTK_CONTAINER (window), 10);
3866
3867       preview = gtk_preview_new (GTK_PREVIEW_COLOR);
3868       gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
3869       gtk_container_add (GTK_CONTAINER (window), preview);
3870       gtk_widget_show (preview);
3871
3872       for (i = 0; i < 256; i++)
3873         {
3874           for (j = 0, k = 0; j < 256; j++)
3875             {
3876               buf[k+0] = i;
3877               buf[k+1] = 0;
3878               buf[k+2] = j;
3879               k += 3;
3880             }
3881
3882           gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
3883         }
3884
3885       color_idle = gtk_idle_add ((GtkFunction) color_idle_func, preview);
3886
3887       gtk_widget_pop_colormap ();
3888       gtk_widget_pop_visual ();
3889     }
3890
3891   if (!GTK_WIDGET_VISIBLE (window))
3892     gtk_widget_show (window);
3893   else
3894     gtk_widget_destroy (window);
3895 }
3896
3897
3898 /*
3899  * Gray Preview
3900  */
3901 static int gray_idle = 0;
3902
3903 gint
3904 gray_idle_func (GtkWidget *preview)
3905 {
3906   static int count = 1;
3907   guchar buf[256];
3908   int i, j;
3909
3910   for (i = 0; i < 256; i++)
3911     {
3912       for (j = 0; j < 256; j++)
3913         buf[j] = i + j + count;
3914
3915       gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
3916     }
3917
3918   count += 1;
3919
3920   gtk_widget_draw (preview, NULL);
3921
3922   return TRUE;
3923 }
3924
3925 void
3926 gray_preview_destroy (GtkWidget  *widget,
3927                       GtkWidget **window)
3928 {
3929   gtk_idle_remove (gray_idle);
3930   gray_idle = 0;
3931
3932   destroy_window (widget, window);
3933 }
3934
3935 void
3936 create_gray_preview ()
3937 {
3938   static GtkWidget *window = NULL;
3939   GtkWidget *preview;
3940   guchar buf[256];
3941   int i, j;
3942
3943   if (!window)
3944     {
3945       gtk_widget_push_visual (gtk_preview_get_visual ());
3946       gtk_widget_push_colormap (gtk_preview_get_cmap ());
3947
3948       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3949
3950       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3951                           GTK_SIGNAL_FUNC(gray_preview_destroy),
3952                           &window);
3953       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3954                           GTK_SIGNAL_FUNC(gray_preview_destroy),
3955                           &window);
3956
3957       gtk_window_set_title (GTK_WINDOW (window), "test");
3958       gtk_container_border_width (GTK_CONTAINER (window), 10);
3959
3960       preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
3961       gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
3962       gtk_container_add (GTK_CONTAINER (window), preview);
3963       gtk_widget_show (preview);
3964
3965       for (i = 0; i < 256; i++)
3966         {
3967           for (j = 0; j < 256; j++)
3968             buf[j] = i + j;
3969
3970           gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
3971         }
3972
3973       gray_idle = gtk_idle_add ((GtkFunction) gray_idle_func, preview);
3974
3975       gtk_widget_pop_colormap ();
3976       gtk_widget_pop_visual ();
3977     }
3978
3979   if (!GTK_WIDGET_VISIBLE (window))
3980     gtk_widget_show (window);
3981   else
3982     gtk_widget_destroy (window);
3983 }
3984
3985
3986 /*
3987  * Selection Test
3988  */
3989 void
3990 selection_test_received (GtkWidget *list, GtkSelectionData *data)
3991 {
3992   GdkAtom *atoms;
3993   GtkWidget *list_item;
3994   GList *item_list;
3995   int i, l;
3996
3997   if (data->length < 0)
3998     {
3999       g_print ("Selection retrieval failed\n");
4000       return;
4001     }
4002   if (data->type != GDK_SELECTION_TYPE_ATOM)
4003     {
4004       g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
4005       return;
4006     }
4007
4008   /* Clear out any current list items */
4009
4010   gtk_list_clear_items (GTK_LIST(list), 0, -1);
4011
4012   /* Add new items to list */
4013
4014   atoms = (GdkAtom *)data->data;
4015
4016   item_list = NULL;
4017   l = data->length / sizeof (GdkAtom);
4018   for (i = 0; i < l; i++)
4019     {
4020       char *name;
4021       name = gdk_atom_name (atoms[i]);
4022       if (name != NULL)
4023         {
4024           list_item = gtk_list_item_new_with_label (name);
4025           g_free (name);
4026         }
4027       else
4028         list_item = gtk_list_item_new_with_label ("(bad atom)");
4029
4030       gtk_widget_show (list_item);
4031       item_list = g_list_append (item_list, list_item);
4032     }
4033
4034   gtk_list_append_items (GTK_LIST (list), item_list);
4035
4036   return;
4037 }
4038
4039 void
4040 selection_test_get_targets (GtkWidget *widget, GtkWidget *list)
4041 {
4042   static GdkAtom targets_atom = GDK_NONE;
4043
4044   if (targets_atom == GDK_NONE)
4045     targets_atom = gdk_atom_intern ("TARGETS", FALSE);
4046
4047   gtk_selection_convert (list, GDK_SELECTION_PRIMARY, targets_atom,
4048                          GDK_CURRENT_TIME);
4049 }
4050
4051 void
4052 create_selection_test ()
4053 {
4054   static GtkWidget *window = NULL;
4055   GtkWidget *button;
4056   GtkWidget *vbox;
4057   GtkWidget *scrolled_win;
4058   GtkWidget *list;
4059   GtkWidget *label;
4060
4061   if (!window)
4062     {
4063       window = gtk_dialog_new ();
4064
4065       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4066                           GTK_SIGNAL_FUNC(destroy_window),
4067                           &window);
4068       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
4069                           GTK_SIGNAL_FUNC(destroy_window),
4070                           &window);
4071
4072       gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
4073       gtk_container_border_width (GTK_CONTAINER (window), 0);
4074
4075       /* Create the list */
4076
4077       vbox = gtk_vbox_new (FALSE, 5);
4078       gtk_container_border_width (GTK_CONTAINER (vbox), 10);
4079       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox,
4080                           TRUE, TRUE, 0);
4081       gtk_widget_show (vbox);
4082
4083       label = gtk_label_new ("Gets available targets for current selection");
4084       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
4085       gtk_widget_show (label);
4086
4087       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
4088       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
4089                                       GTK_POLICY_AUTOMATIC,
4090                                       GTK_POLICY_AUTOMATIC);
4091       gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
4092       gtk_widget_set_usize (scrolled_win, 100, 200);
4093       gtk_widget_show (scrolled_win);
4094
4095       list = gtk_list_new ();
4096       gtk_container_add (GTK_CONTAINER (scrolled_win), list);
4097
4098       gtk_signal_connect (GTK_OBJECT(list), "selection_received",
4099                           GTK_SIGNAL_FUNC (selection_test_received), NULL);
4100       gtk_widget_show (list);
4101
4102       /* .. And create some buttons */
4103       button = gtk_button_new_with_label ("Get Targets");
4104       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
4105                           button, TRUE, TRUE, 0);
4106
4107       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4108                           GTK_SIGNAL_FUNC (selection_test_get_targets), list);
4109       gtk_widget_show (button);
4110
4111       button = gtk_button_new_with_label ("Quit");
4112       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
4113                           button, TRUE, TRUE, 0);
4114
4115       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4116                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
4117                                  GTK_OBJECT (window));
4118       gtk_widget_show (button);
4119     }
4120
4121   if (!GTK_WIDGET_VISIBLE (window))
4122     gtk_widget_show (window);
4123   else
4124     gtk_widget_destroy (window);
4125 }
4126
4127
4128 /*
4129  * Gamma Curve
4130  */
4131 void
4132 create_gamma_curve ()
4133 {
4134   static GtkWidget *window = NULL, *curve;
4135   static int count = 0;
4136   gfloat vec[256];
4137   gint max;
4138   gint i;
4139
4140   if (!window)
4141     {
4142       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4143       gtk_window_set_title (GTK_WINDOW (window), "test");
4144       gtk_container_border_width (GTK_CONTAINER (window), 10);
4145
4146       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4147                           GTK_SIGNAL_FUNC(destroy_window),
4148                           &window);
4149       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
4150                           GTK_SIGNAL_FUNC(destroy_window),
4151                           &window);
4152
4153       curve = gtk_gamma_curve_new ();
4154       gtk_container_add (GTK_CONTAINER (window), curve);
4155       gtk_widget_show (curve);
4156     }
4157
4158   max = 127 + (count % 2)*128;
4159   gtk_curve_set_range (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
4160                        0, max, 0, max);
4161   for (i = 0; i < max; ++i)
4162     vec[i] = (127 / sqrt (max)) * sqrt (i);
4163   gtk_curve_set_vector (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
4164                         max, vec);
4165
4166   if (!GTK_WIDGET_VISIBLE (window))
4167     gtk_widget_show (window);
4168   else if (count % 4 == 3)
4169     {
4170       gtk_widget_destroy (window);
4171       window = NULL;
4172     }
4173
4174   ++count;
4175 }
4176
4177 static int scroll_test_pos = 0.0;
4178 static GdkGC *scroll_test_gc = NULL;
4179
4180 static gint
4181 scroll_test_expose (GtkWidget *widget, GdkEventExpose *event,
4182                     GtkAdjustment *adj)
4183 {
4184   gint i,j;
4185   gint imin, imax, jmin, jmax;
4186
4187   imin = (event->area.x) / 10;
4188   imax = (event->area.x + event->area.width + 9) / 10;
4189
4190   jmin = ((int)adj->value + event->area.y) / 10;
4191   jmax = ((int)adj->value + event->area.y + event->area.height + 9) / 10;
4192
4193   gdk_window_clear_area (widget->window,
4194                          event->area.x, event->area.y,
4195                          event->area.width, event->area.height);
4196
4197   for (i=imin; i<imax; i++)
4198     for (j=jmin; j<jmax; j++)
4199       if ((i+j) % 2)
4200         gdk_draw_rectangle (widget->window,
4201                             widget->style->black_gc,
4202                             TRUE,
4203                             10*i, 10*j - (int)adj->value, 1+i%10, 1+j%10);
4204
4205   return TRUE;
4206 }
4207
4208 static void
4209 scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
4210                        GtkAdjustment *adj)
4211 {
4212   adj->page_increment = 0.9 * widget->allocation.height;
4213   adj->page_size = widget->allocation.height;
4214
4215   gtk_signal_emit_by_name (GTK_OBJECT (adj), "changed");
4216 }
4217
4218 static void
4219 scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
4220 {
4221   gint source_min = (int)adj->value - scroll_test_pos;
4222   gint source_max = source_min + widget->allocation.height;
4223   gint dest_min = 0;
4224   gint dest_max = widget->allocation.height;
4225   GdkRectangle rect;
4226   GdkEvent *event;
4227
4228   scroll_test_pos = adj->value;
4229
4230   if (!GTK_WIDGET_DRAWABLE (widget))
4231     return;
4232
4233   if (source_min < 0)
4234     {
4235       rect.x = 0;
4236       rect.y = 0;
4237       rect.width = widget->allocation.width;
4238       rect.height = -source_min;
4239       if (rect.height > widget->allocation.height)
4240         rect.height = widget->allocation.height;
4241
4242       source_min = 0;
4243       dest_min = rect.height;
4244     }
4245   else
4246     {
4247       rect.x = 0;
4248       rect.y = 2*widget->allocation.height - source_max;
4249       if (rect.y < 0)
4250         rect.y = 0;
4251       rect.width = widget->allocation.width;
4252       rect.height = widget->allocation.height - rect.y;
4253
4254       source_max = widget->allocation.height;
4255       dest_max = rect.y;
4256     }
4257
4258   if (source_min != source_max)
4259     {
4260       if (scroll_test_gc == NULL)
4261         {
4262           scroll_test_gc = gdk_gc_new (widget->window);
4263           gdk_gc_set_exposures (scroll_test_gc, TRUE);
4264         }
4265
4266       gdk_draw_pixmap (widget->window,
4267                        scroll_test_gc,
4268                        widget->window,
4269                        0, source_min,
4270                        0, dest_min,
4271                        widget->allocation.width,
4272                        source_max - source_min);
4273
4274       /* Make sure graphics expose events are processed before scrolling
4275        * again */
4276
4277       while ((event = gdk_event_get_graphics_expose (widget->window)) != NULL)
4278         {
4279           gtk_widget_event (widget, event);
4280           if (event->expose.count == 0)
4281             {
4282               gdk_event_free (event);
4283               break;
4284             }
4285           gdk_event_free (event);
4286         }
4287     }
4288
4289
4290   if (rect.height != 0)
4291     gtk_widget_draw (widget, &rect);
4292 }
4293
4294
4295 void
4296 create_scroll_test ()
4297 {
4298   static GtkWidget *window = NULL;
4299   GtkWidget *hbox;
4300   GtkWidget *drawing_area;
4301   GtkWidget *scrollbar;
4302   GtkWidget *button;
4303   GtkAdjustment *adj;
4304
4305   if (!window)
4306     {
4307       window = gtk_dialog_new ();
4308
4309       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4310                           GTK_SIGNAL_FUNC(destroy_window),
4311                           &window);
4312       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
4313                           GTK_SIGNAL_FUNC(destroy_window),
4314                           &window);
4315
4316       gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
4317       gtk_container_border_width (GTK_CONTAINER (window), 0);
4318
4319       hbox = gtk_hbox_new (FALSE, 0);
4320       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox,
4321                           TRUE, TRUE, 0);
4322       gtk_widget_show (hbox);
4323
4324       drawing_area = gtk_drawing_area_new ();
4325       gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 200, 200);
4326       gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
4327       gtk_widget_show (drawing_area);
4328
4329       gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK);
4330
4331       adj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0));
4332       scroll_test_pos = 0.0;
4333
4334       scrollbar = gtk_vscrollbar_new (adj);
4335       gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
4336       gtk_widget_show (scrollbar);
4337
4338       gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
4339                           GTK_SIGNAL_FUNC (scroll_test_expose), adj);
4340       gtk_signal_connect (GTK_OBJECT (drawing_area), "configure_event",
4341                           GTK_SIGNAL_FUNC (scroll_test_configure), adj);
4342
4343
4344       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
4345                           GTK_SIGNAL_FUNC (scroll_test_adjustment_changed),
4346                           drawing_area);
4347
4348       /* .. And create some buttons */
4349
4350       button = gtk_button_new_with_label ("Quit");
4351       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
4352                           button, TRUE, TRUE, 0);
4353
4354       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4355                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
4356                                  GTK_OBJECT (window));
4357       gtk_widget_show (button);
4358     }
4359
4360   if (!GTK_WIDGET_VISIBLE (window))
4361     gtk_widget_show (window);
4362   else
4363     gtk_widget_destroy (window);
4364 }
4365
4366 /*
4367  * Timeout Test
4368  */
4369 static int timer = 0;
4370
4371 void
4372 timeout_test (GtkWidget *label)
4373 {
4374   static int count = 0;
4375   static char buffer[32];
4376
4377   sprintf (buffer, "count: %d", ++count);
4378   gtk_label_set (GTK_LABEL (label), buffer);
4379 }
4380
4381 void
4382 start_timeout_test (GtkWidget *widget,
4383                     GtkWidget *label)
4384 {
4385   if (!timer)
4386     {
4387       timer = gtk_timeout_add (100, (GtkFunction) timeout_test, label);
4388     }
4389 }
4390
4391 void
4392 stop_timeout_test (GtkWidget *widget,
4393                    gpointer   data)
4394 {
4395   if (timer)
4396     {
4397       gtk_timeout_remove (timer);
4398       timer = 0;
4399     }
4400 }
4401
4402 void
4403 destroy_timeout_test (GtkWidget  *widget,
4404                       GtkWidget **window)
4405 {
4406   destroy_window (widget, window);
4407   stop_timeout_test (NULL, NULL);
4408 }
4409
4410 void
4411 create_timeout_test ()
4412 {
4413   static GtkWidget *window = NULL;
4414   GtkWidget *button;
4415   GtkWidget *label;
4416
4417   if (!window)
4418     {
4419       window = gtk_dialog_new ();
4420
4421       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4422                           GTK_SIGNAL_FUNC(destroy_timeout_test),
4423                           &window);
4424       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
4425                           GTK_SIGNAL_FUNC(destroy_timeout_test),
4426                           &window);
4427
4428       gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
4429       gtk_container_border_width (GTK_CONTAINER (window), 0);
4430
4431       label = gtk_label_new ("count: 0");
4432       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
4433       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
4434                           label, TRUE, TRUE, 0);
4435       gtk_widget_show (label);
4436
4437       button = gtk_button_new_with_label ("close");
4438       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4439                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
4440                                  GTK_OBJECT (window));
4441       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4442       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
4443                           button, TRUE, TRUE, 0);
4444       gtk_widget_grab_default (button);
4445       gtk_widget_show (button);
4446
4447       button = gtk_button_new_with_label ("start");
4448       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4449                           GTK_SIGNAL_FUNC(start_timeout_test),
4450                           label);
4451       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4452       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
4453                           button, TRUE, TRUE, 0);
4454       gtk_widget_show (button);
4455
4456       button = gtk_button_new_with_label ("stop");
4457       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4458                           GTK_SIGNAL_FUNC(stop_timeout_test),
4459                           NULL);
4460       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4461       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
4462                           button, TRUE, TRUE, 0);
4463       gtk_widget_show (button);
4464     }
4465
4466   if (!GTK_WIDGET_VISIBLE (window))
4467     gtk_widget_show (window);
4468   else
4469     gtk_widget_destroy (window);
4470 }
4471
4472
4473 /*
4474  * Idle Test
4475  */
4476 static int idle = 0;
4477
4478 gint
4479 idle_test (GtkWidget *label)
4480 {
4481   static int count = 0;
4482   static char buffer[32];
4483
4484   sprintf (buffer, "count: %d", ++count);
4485   gtk_label_set (GTK_LABEL (label), buffer);
4486
4487   return TRUE;
4488 }
4489
4490 void
4491 start_idle_test (GtkWidget *widget,
4492                  GtkWidget *label)
4493 {
4494   if (!idle)
4495     {
4496       idle = gtk_idle_add ((GtkFunction) idle_test, label);
4497     }
4498 }
4499
4500 void
4501 stop_idle_test (GtkWidget *widget,
4502                 gpointer   data)
4503 {
4504   if (idle)
4505     {
4506       gtk_idle_remove (idle);
4507       idle = 0;
4508     }
4509 }
4510
4511 void
4512 destroy_idle_test (GtkWidget  *widget,
4513                    GtkWidget **window)
4514 {
4515   destroy_window (widget, window);
4516   stop_idle_test (NULL, NULL);
4517 }
4518
4519 void
4520 create_idle_test ()
4521 {
4522   static GtkWidget *window = NULL;
4523   GtkWidget *button;
4524   GtkWidget *label;
4525
4526   if (!window)
4527     {
4528       window = gtk_dialog_new ();
4529
4530       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4531                           GTK_SIGNAL_FUNC(destroy_idle_test),
4532                           &window);
4533       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
4534                           GTK_SIGNAL_FUNC(destroy_idle_test),
4535                           &window);
4536
4537       gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
4538       gtk_container_border_width (GTK_CONTAINER (window), 0);
4539
4540       label = gtk_label_new ("count: 0");
4541       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
4542       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
4543                           label, TRUE, TRUE, 0);
4544       gtk_widget_show (label);
4545
4546       button = gtk_button_new_with_label ("close");
4547       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4548                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
4549                                  GTK_OBJECT (window));
4550       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4551       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
4552                           button, TRUE, TRUE, 0);
4553       gtk_widget_grab_default (button);
4554       gtk_widget_show (button);
4555
4556       button = gtk_button_new_with_label ("start");
4557       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4558                           GTK_SIGNAL_FUNC(start_idle_test),
4559                           label);
4560       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4561       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
4562                           button, TRUE, TRUE, 0);
4563       gtk_widget_show (button);
4564
4565       button = gtk_button_new_with_label ("stop");
4566       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4567                           GTK_SIGNAL_FUNC(stop_idle_test),
4568                           NULL);
4569       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4570       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
4571                           button, TRUE, TRUE, 0);
4572       gtk_widget_show (button);
4573     }
4574
4575   if (!GTK_WIDGET_VISIBLE (window))
4576     gtk_widget_show (window);
4577   else
4578     gtk_widget_destroy (window);
4579 }
4580
4581 void
4582 test_destroy (GtkWidget  *widget,
4583               GtkWidget **window)
4584 {
4585   destroy_window (widget, window);
4586   gtk_main_quit ();
4587 }
4588
4589 /*
4590  * Basic Test
4591  */
4592 void
4593 create_test ()
4594 {
4595   static GtkWidget *window = NULL;
4596
4597   if (!window)
4598     {
4599       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4600
4601       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4602                           GTK_SIGNAL_FUNC(test_destroy),
4603                           &window);
4604       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
4605                           GTK_SIGNAL_FUNC(test_destroy),
4606                           &window);
4607
4608
4609       gtk_window_set_title (GTK_WINDOW (window), "test");
4610       gtk_container_border_width (GTK_CONTAINER (window), 0);
4611     }
4612
4613   if (!GTK_WIDGET_VISIBLE (window))
4614     {
4615       gtk_widget_show (window);
4616
4617       g_print ("create_test: start\n");
4618       gtk_main ();
4619       g_print ("create_test: done\n");
4620     }
4621   else
4622     gtk_widget_destroy (window);
4623 }
4624
4625
4626 /*
4627  * Main Window and Exit
4628  */
4629 void
4630 do_exit (GtkWidget *widget, GtkWidget *window)
4631 {
4632   gtk_widget_destroy (window);
4633   gtk_main_quit ();
4634 }
4635
4636 void
4637 create_main_window ()
4638 {
4639   struct {
4640     char *label;
4641     void (*func) ();
4642   } buttons[] =
4643     {
4644       { "buttons", create_buttons },
4645       { "toggle buttons", create_toggle_buttons },
4646       { "check buttons", create_check_buttons },
4647       { "radio buttons", create_radio_buttons },
4648       { "button box", create_button_box },
4649       { "toolbar", create_toolbar },
4650       { "handle box", create_handle_box },
4651       { "statusbar", create_statusbar },
4652       { "reparent", create_reparent },
4653       { "pixmap", create_pixmap },
4654       { "tooltips", create_tooltips },
4655       { "menus", create_menus },
4656       { "scrolled windows", create_scrolled_windows },
4657       { "drawing areas", NULL },
4658       { "entry", create_entry },
4659       { "spinbutton", create_spins },
4660       { "list", create_list },
4661       { "clist", create_clist},
4662       { "color selection", create_color_selection },
4663       { "file selection", create_file_selection },
4664       { "dialog", create_dialog },
4665       { "miscellaneous", NULL },
4666       { "range controls", create_range_controls },
4667       { "rulers", create_rulers },
4668       { "text", create_text },
4669       { "notebook", create_notebook },
4670       { "panes", create_panes },
4671       { "shapes", create_shapes },
4672       { "dnd", create_dnd },
4673       { "WM hints", create_wmhints },
4674       { "progress bar", create_progress_bar },
4675       { "preview color", create_color_preview },
4676       { "preview gray", create_gray_preview },
4677       { "gamma curve", create_gamma_curve },
4678       { "test scrolling", create_scroll_test },
4679       { "test selection", create_selection_test },
4680       { "test timeout", create_timeout_test },
4681       { "test idle", create_idle_test },
4682       { "test", create_test },
4683     };
4684   int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
4685   GtkWidget *window;
4686   GtkWidget *box1;
4687   GtkWidget *box2;
4688   GtkWidget *scrolled_window;
4689   GtkWidget *button;
4690   GtkWidget *separator;
4691   int i;
4692
4693   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4694   gtk_widget_set_name (window, "main window");
4695   gtk_widget_set_usize (window, 200, 400);
4696   gtk_widget_set_uposition (window, 20, 20);
4697
4698   gtk_signal_connect (GTK_OBJECT (window), "destroy",
4699                       GTK_SIGNAL_FUNC(gtk_main_quit),
4700                       NULL);
4701   gtk_signal_connect (GTK_OBJECT (window), "delete_event",
4702                       GTK_SIGNAL_FUNC(gtk_main_quit),
4703                       NULL);
4704
4705   box1 = gtk_vbox_new (FALSE, 0);
4706   gtk_container_add (GTK_CONTAINER (window), box1);
4707   gtk_widget_show (box1);
4708
4709   scrolled_window = gtk_scrolled_window_new (NULL, NULL);
4710   gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
4711   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
4712                                   GTK_POLICY_AUTOMATIC,
4713                                   GTK_POLICY_AUTOMATIC);
4714   gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
4715   gtk_widget_show (scrolled_window);
4716
4717   box2 = gtk_vbox_new (FALSE, 0);
4718   gtk_container_border_width (GTK_CONTAINER (box2), 10);
4719   gtk_container_add (GTK_CONTAINER (scrolled_window), box2);
4720   gtk_widget_show (box2);
4721
4722   for (i = 0; i < nbuttons; i++)
4723     {
4724       button = gtk_button_new_with_label (buttons[i].label);
4725       if (buttons[i].func)
4726         gtk_signal_connect (GTK_OBJECT (button),
4727                             "clicked",
4728                             GTK_SIGNAL_FUNC(buttons[i].func),
4729                             NULL);
4730       else
4731         gtk_widget_set_sensitive (button, FALSE);
4732       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4733       gtk_widget_show (button);
4734     }
4735
4736   separator = gtk_hseparator_new ();
4737   gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4738   gtk_widget_show (separator);
4739
4740   box2 = gtk_vbox_new (FALSE, 10);
4741   gtk_container_border_width (GTK_CONTAINER (box2), 10);
4742   gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4743   gtk_widget_show (box2);
4744
4745   button = gtk_button_new_with_label ("close");
4746   gtk_signal_connect (GTK_OBJECT (button), "clicked",
4747                       GTK_SIGNAL_FUNC (do_exit),
4748                       window);
4749   gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4750   GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4751   gtk_widget_grab_default (button);
4752   gtk_widget_show (button);
4753
4754   gtk_widget_show (window);
4755 }
4756
4757 int
4758 main (int argc, char *argv[])
4759 {
4760   gtk_set_locale ();
4761
4762   gtk_init (&argc, &argv);
4763
4764 #ifdef HAVE_LIBGLE
4765   gle_init (&argc, &argv);
4766 #endif /* !HAVE_LIBGLE */
4767
4768   gtk_rc_parse ("testgtkrc");
4769
4770   create_main_window ();
4771
4772   gtk_main ();
4773
4774   return 0;
4775 }