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