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