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