Pileus Git - ~andy/gtk/blob - gtk/testgtk.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  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 (void)
  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 (void)
 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 (void)
 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 (void)
 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 (void)
 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 (void)
 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 (void)
 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 (void)
 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 (void)
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 (void)
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 (void)
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 (void)
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 (void)
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 (void)
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 (void)
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 (void)
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 (void)
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 (void)
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 (void)
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 /*
3397  * GtkCTree
3398  */
3399
3400 static char * book_open_xpm[] = {
3401 "16 16 4 1",
3402 "       c None s None",
3403 ".      c black",
3404 "X      c #808080",
3405 "o      c white",
3406 "                ",
3407 "  ..            ",
3408 " .Xo.    ...    ",
3409 " .Xoo. ..oo.    ",
3410 " .Xooo.Xooo...  ",
3411 " .Xooo.oooo.X.  ",
3412 " .Xooo.Xooo.X.  ",
3413 " .Xooo.oooo.X.  ",
3414 " .Xooo.Xooo.X.  ",
3415 " .Xooo.oooo.X.  ",
3416 "  .Xoo.Xoo..X.  ",
3417 "   .Xo.o..ooX.  ",
3418 "    .X..XXXXX.  ",
3419 "    ..X.......  ",
3420 "     ..         ",
3421 "                "};
3422
3423 static char * book_closed_xpm[] = {
3424 "16 16 6 1",
3425 "       c None s None",
3426 ".      c black",
3427 "X      c red",
3428 "o      c yellow",
3429 "O      c #808080",
3430 "#      c white",
3431 "                ",
3432 "       ..       ",
3433 "     ..XX.      ",
3434 "   ..XXXXX.     ",
3435 " ..XXXXXXXX.    ",
3436 ".ooXXXXXXXXX.   ",
3437 "..ooXXXXXXXXX.  ",
3438 ".X.ooXXXXXXXXX. ",
3439 ".XX.ooXXXXXX..  ",
3440 " .XX.ooXXX..#O  ",
3441 "  .XX.oo..##OO. ",
3442 "   .XX..##OO..  ",
3443 "    .X.#OO..    ",
3444 "     ..O..      ",
3445 "      ..        ",
3446 "                "};
3447
3448 static char * mini_page_xpm[] = {
3449 "16 16 4 1",
3450 "       c None s None",
3451 ".      c black",
3452 "X      c white",
3453 "o      c #808080",
3454 "                ",
3455 "   .......      ",
3456 "   .XXXXX..     ",
3457 "   .XoooX.X.    ",
3458 "   .XXXXX....   ",
3459 "   .XooooXoo.o  ",
3460 "   .XXXXXXXX.o  ",
3461 "   .XooooooX.o  ",
3462 "   .XXXXXXXX.o  ",
3463 "   .XooooooX.o  ",
3464 "   .XXXXXXXX.o  ",
3465 "   .XooooooX.o  ",
3466 "   .XXXXXXXX.o  ",
3467 "   ..........o  ",
3468 "    oooooooooo  ",
3469 "                "};
3470
3471 GdkPixmap *pixmap1;
3472 GdkPixmap *pixmap2;
3473 GdkPixmap *pixmap3;
3474 GdkBitmap *mask1;
3475 GdkBitmap *mask2;
3476 GdkBitmap *mask3;
3477
3478 static gint books = 0;
3479 static gint pages = 0;
3480
3481 static GtkWidget *book_label;
3482 static GtkWidget *page_label;
3483 static GtkWidget *sel_label;
3484 static GtkWidget *vis_label;
3485 static GtkWidget *omenu;
3486 static GtkWidget *omenu2;
3487 static GtkWidget *omenu3;
3488 static GtkWidget *spin1;
3489 static GtkWidget *spin2;
3490 static GtkWidget *spin3;
3491
3492 #define RADIOMENUTOGGLED(_rmi_, __i) { \
3493   GSList * __g; \
3494   __i = 0; \
3495   __g = gtk_radio_menu_item_group(_rmi_); \
3496   while( __g  && !((GtkCheckMenuItem *)(__g->data))->active) { \
3497     __g = __g->next; \
3498     __i++; \
3499   }\
3500 }
3501
3502 #define RADIOBUTTONTOGGLED(_rb_, __i) { \
3503   GSList * __g; \
3504   __i = 0; \
3505   __g = gtk_radio_button_group(_rb_); \
3506   while( __g  && !((GtkToggleButton *)(__g->data))->active) { \
3507     __g = __g->next; \
3508     __i++; \
3509   }\
3510 }
3511
3512 void after_press (GtkCTree *ctree, gpointer data)
3513 {
3514   char buf[80];
3515
3516   sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection));
3517   gtk_label_set (GTK_LABEL (sel_label), buf);
3518
3519   sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list));
3520   gtk_label_set (GTK_LABEL (vis_label), buf);
3521
3522   sprintf (buf, "%d", books);
3523   gtk_label_set (GTK_LABEL (book_label), buf);
3524
3525   sprintf (buf, "%d", pages);
3526   gtk_label_set (GTK_LABEL (page_label), buf);
3527 }
3528
3529 void after_move (GtkCTree *ctree, GList *child, GList *parent,
3530                  GList *sibling, gpointer data)
3531 {
3532   char *source;
3533   char *target1;
3534   char *target2;
3535
3536   gtk_ctree_get_node_info (ctree, child, &source,
3537                            NULL, NULL, NULL, NULL, NULL, NULL, NULL);
3538   if (parent)
3539     gtk_ctree_get_node_info (ctree, parent, &target1,
3540                              NULL, NULL, NULL, NULL, NULL, NULL, NULL);
3541   if (sibling)
3542     gtk_ctree_get_node_info (ctree, sibling, &target2,
3543                              NULL, NULL, NULL, NULL, NULL, NULL, NULL);
3544
3545   g_print ("Moving \"%s\" to \"%s\" with sibling \"%s\".\n", source,
3546            (parent) ? target1 : "nil", (sibling) ? target2 : "nil");
3547 }
3548
3549 gint button_press (GtkCTree *ctree, GdkEventButton *event, gpointer data)
3550 {
3551   gint row;
3552   gint column;
3553   GList *work;
3554   gint res;
3555
3556   res = gtk_clist_get_selection_info (GTK_CLIST (ctree), event->x, event->y,
3557                                       &row, &column);
3558   if (!res && event->button != 3)
3559     return FALSE;
3560
3561   work = g_list_nth (GTK_CLIST (ctree)->row_list, row);
3562
3563   switch (event->button)
3564     {
3565     case 1:
3566       if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_MULTIPLE &&
3567           event->state & GDK_SHIFT_MASK)
3568         gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),"button_press_event");
3569       break;
3570     case  2:
3571       if (GTK_CTREE_ROW (work)->children &&
3572           gtk_ctree_is_hot_spot (ctree, event->x, event->y))
3573         {
3574           if (GTK_CTREE_ROW (work)->expanded)
3575             gtk_ctree_collapse_recursive (ctree, work);
3576           else
3577             gtk_ctree_expand_recursive (ctree, work);
3578           after_press (ctree, NULL);
3579           gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),
3580                                         "button_press_event");
3581         }
3582       break;
3583     default:
3584       break;
3585     }
3586   return FALSE;
3587 }
3588
3589 gint button_release (GtkCTree *ctree, GdkEventButton *event, gpointer data)
3590 {
3591   gint row;
3592   gint column;
3593   GList *work;
3594   gint res;
3595
3596   res = gtk_clist_get_selection_info (GTK_CLIST (ctree), event->x, event->y,
3597                                       &row, &column);
3598   if (!res || event->button != 1)
3599     return FALSE;
3600
3601   work = g_list_nth (GTK_CLIST (ctree)->row_list, row);
3602
3603   if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_MULTIPLE &&
3604       event->state & GDK_SHIFT_MASK)
3605     {
3606       if (GTK_CTREE_ROW (work)->row.state == GTK_STATE_SELECTED)
3607             gtk_ctree_unselect_recursive (ctree, work);
3608       else
3609         gtk_ctree_select_recursive (ctree, work);
3610       after_press (ctree, NULL);
3611       gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),
3612                                     "button_release_event");
3613     }
3614   return FALSE;
3615 }
3616
3617 void count_items (GtkCTree *ctree, GList *list)
3618 {
3619   if (GTK_CTREE_ROW (list)->is_leaf)
3620     pages--;
3621   else
3622     books--;
3623 }
3624
3625 void expand_all (GtkWidget *widget, GtkCTree *ctree)
3626 {
3627   gtk_ctree_expand_recursive (ctree, NULL);
3628   after_press (ctree, NULL);
3629 }
3630
3631 void collapse_all (GtkWidget *widget, GtkCTree *ctree)
3632 {
3633   gtk_ctree_collapse_recursive (ctree, NULL);
3634   after_press (ctree, NULL);
3635 }
3636
3637 void select_all (GtkWidget *widget, GtkCTree *ctree)
3638 {
3639   gtk_ctree_select_recursive (ctree, NULL);
3640   after_press (ctree, NULL);
3641 }
3642
3643 void unselect_all (GtkWidget *widget, GtkCTree *ctree)
3644 {
3645   gtk_ctree_unselect_recursive (ctree, NULL);
3646   after_press (ctree, NULL);
3647 }
3648
3649 void remove_selection (GtkWidget *widget, GtkCTree *ctree)
3650 {
3651   GList *work;
3652   GList *selection;
3653   GList *new_sel;
3654
3655   selection = GTK_CLIST (ctree)->selection;
3656   new_sel = NULL;
3657
3658   gtk_clist_freeze (GTK_CLIST (ctree));
3659
3660   while (selection)
3661     {
3662       work = selection->data;
3663       if (GTK_CTREE_ROW (work)->is_leaf)
3664         pages--;
3665       else
3666         gtk_ctree_post_recursive (ctree, work,
3667                                   (GtkCTreeFunc) count_items, NULL);
3668
3669       if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_BROWSE)
3670         {
3671           if (GTK_CTREE_ROW (work)->children)
3672             {
3673               new_sel = GTK_CTREE_ROW (work)->sibling;
3674               if (!new_sel)
3675                 new_sel = work->prev;
3676             }
3677           else
3678             {
3679               if (work->next)
3680                 new_sel = work->next;
3681               else
3682                 new_sel = work->prev;
3683             }
3684         }
3685
3686       gtk_ctree_remove (ctree, work);
3687       selection = GTK_CLIST (ctree)->selection;
3688     }
3689
3690   if (new_sel)
3691     gtk_ctree_select (ctree, new_sel);
3692
3693   gtk_clist_thaw (GTK_CLIST (ctree));
3694   after_press (ctree, NULL);
3695 }
3696
3697 void sort_all (GtkWidget *widget, GtkCTree *ctree)
3698 {
3699   gtk_ctree_sort_recursive (ctree, NULL);
3700 }
3701
3702 void change_indent (GtkWidget *widget, GtkCTree *ctree)
3703 {
3704   gtk_ctree_set_indent (ctree, GTK_ADJUSTMENT (widget)->value);
3705 }
3706
3707 void toggle_reorderable (GtkWidget *widget, GtkCTree *ctree)
3708 {
3709   gtk_ctree_set_reorderable (ctree, GTK_TOGGLE_BUTTON (widget)->active);
3710 }
3711
3712 void toggle_line_style (GtkWidget *widget, GtkCTree *ctree)
3713 {
3714   gint i;
3715
3716
3717   if (!GTK_WIDGET_MAPPED (widget))
3718     return;
3719
3720   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
3721                     (((GtkOptionMenu *)omenu2)->menu_item),i);
3722
3723   gtk_ctree_set_line_style (ctree, (GtkCTreeLineStyle) (2-i));
3724 }
3725
3726 void toggle_justify (GtkWidget *widget, GtkCTree *ctree)
3727 {
3728   gint i;
3729
3730   if (!GTK_WIDGET_MAPPED (widget))
3731     return;
3732
3733   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
3734                     (((GtkOptionMenu *)omenu3)->menu_item),i);
3735
3736   gtk_clist_set_column_justification (GTK_CLIST (ctree), 0,
3737                                       (GtkJustification) (1-i));
3738 }
3739
3740 void toggle_sel_mode (GtkWidget *widget, GtkCTree *ctree)
3741 {
3742   gint i;
3743
3744   if (!GTK_WIDGET_MAPPED (widget))
3745     return;
3746
3747   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
3748                     (((GtkOptionMenu *)omenu)->menu_item), i);
3749
3750   gtk_ctree_set_selection_mode (ctree, (GtkSelectionMode) (3-i));
3751   after_press (ctree, NULL);
3752 }
3753
3754
3755 void build_recursive (GtkCTree *ctree, gint cur_depth, gint depth,
3756                       gint num_books, gint num_pages, GList *parent)
3757 {
3758   gchar *text [2];
3759   gchar buf1[60];
3760   gchar buf2[60];
3761   GList *sibling;
3762   gint i;
3763
3764   text[0] = buf1;
3765   text[1] = buf2;
3766   sibling = NULL;
3767
3768   for (i = num_pages + num_books; i > num_books; i--)
3769     {
3770       pages++;
3771       sprintf (buf1, "Page %02d", random() % 100);
3772       sprintf (buf2, "Item %d-%d", cur_depth, i);
3773       sibling = gtk_ctree_insert (ctree, parent, sibling, text, 5, pixmap3,
3774                                   mask3, NULL, NULL, TRUE, FALSE);
3775     }
3776
3777   if (cur_depth == depth)
3778     return;
3779
3780   for (i = num_books; i > 0; i--)
3781     {
3782       books++;
3783       sprintf (buf1, "Book %02d", random() % 100);
3784       sprintf (buf2, "Item %d-%d", cur_depth, i);
3785       sibling = gtk_ctree_insert (ctree, parent, sibling, text, 5, pixmap1,
3786                                   mask1, pixmap2, mask2, FALSE, FALSE);
3787       build_recursive (ctree, cur_depth + 1, depth, num_books, num_pages, sibling);
3788     }
3789 }
3790
3791 void rebuild_tree (GtkWidget *widget, GtkCTree *ctree)
3792 {
3793   gchar *text [2];
3794   gchar label1[] = "Root";
3795   gchar label2[] = "";
3796   GList *parent;
3797   guint b, d, p, n;
3798
3799   text[0] = label1;
3800   text[1] = label2;
3801
3802   d = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin1));
3803   b = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin2));
3804   p = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin3));
3805
3806   n = ((pow (b, d) - 1) / (b - 1)) * (p + 1);
3807
3808   if (n > 200000)
3809     {
3810       g_print ("%d total items? Try less\n",n);
3811       return;
3812     }
3813
3814   gtk_clist_freeze (GTK_CLIST (ctree));
3815   gtk_ctree_clear (ctree);
3816
3817   books = 1;
3818   pages = 0;
3819
3820   parent = gtk_ctree_insert (ctree, NULL, NULL, text, 5, pixmap1,
3821                              mask1, pixmap2, mask2, FALSE, TRUE);
3822
3823   build_recursive (ctree, 1, d, b, p, parent);
3824   gtk_clist_thaw (GTK_CLIST (ctree));
3825   after_press (ctree, NULL);
3826 }
3827
3828 void create_ctree (void)
3829 {
3830   static GtkWidget *window = NULL;
3831   GtkTooltips *tooltips;
3832   GtkCTree *ctree;
3833   GtkWidget *vbox;
3834   GtkWidget *hbox;
3835   GtkWidget *hbox2;
3836   GtkWidget *frame;
3837   GtkWidget *label;
3838   GtkWidget *button;
3839   GtkWidget *menu_item;
3840   GtkWidget *menu;
3841   GtkWidget *submenu;
3842   GtkWidget *check;
3843   GtkAdjustment *adj;
3844   GtkWidget *spinner;
3845   GSList *group;
3846   GdkColor transparent;
3847
3848   char *title[] = { "Tree" , "Info" };
3849   char buf[80];
3850
3851   if (!window)
3852     {
3853       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3854
3855       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3856                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
3857                           &window);
3858
3859       gtk_window_set_title (GTK_WINDOW (window), "GtkCTree");
3860       gtk_container_border_width (GTK_CONTAINER (window), 0);
3861
3862       tooltips = gtk_tooltips_new ();
3863       gtk_object_ref (GTK_OBJECT (tooltips));
3864       gtk_object_sink (GTK_OBJECT (tooltips));
3865
3866       gtk_object_set_data_full (GTK_OBJECT (window),
3867                                 "tooltips",
3868                                 tooltips,
3869                                 (GtkDestroyNotify) gtk_object_unref);
3870
3871       vbox = gtk_vbox_new (FALSE, 0);
3872       gtk_container_add (GTK_CONTAINER (window), vbox);
3873
3874       hbox = gtk_hbox_new (FALSE, 5);
3875       gtk_container_border_width (GTK_CONTAINER (hbox), 5);
3876       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
3877
3878       label = gtk_label_new ("Depth :");
3879       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
3880
3881       adj = (GtkAdjustment *) gtk_adjustment_new (4, 1, 10, 1, 5, 0);
3882       spin1 = gtk_spin_button_new (adj, 0, 0);
3883       gtk_box_pack_start (GTK_BOX (hbox), spin1, FALSE, TRUE, 5);
3884
3885       label = gtk_label_new ("Books :");
3886       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
3887
3888       adj = (GtkAdjustment *) gtk_adjustment_new (3, 1, 20, 1, 5, 0);
3889       spin2 = gtk_spin_button_new (adj, 0, 0);
3890       gtk_box_pack_start (GTK_BOX (hbox), spin2, FALSE, TRUE, 5);
3891
3892       label = gtk_label_new ("Pages :");
3893       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
3894
3895       adj = (GtkAdjustment *) gtk_adjustment_new (5, 1, 20, 1, 5, 0);
3896       spin3 = gtk_spin_button_new (adj, 0, 0);
3897       gtk_box_pack_start (GTK_BOX (hbox), spin3, FALSE, TRUE, 5);
3898
3899       button = gtk_button_new_with_label ("Close");
3900       gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3901
3902       gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
3903                                 (GtkSignalFunc) gtk_widget_destroy,
3904                                 GTK_OBJECT(window));
3905
3906       button = gtk_button_new_with_label ("Rebuild tree");
3907       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3908
3909       ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title));
3910       gtk_ctree_set_line_style (ctree, GTK_CTREE_LINES_DOTTED);
3911       gtk_ctree_set_reorderable (ctree, TRUE);
3912       gtk_signal_connect (GTK_OBJECT (ctree), "button_press_event",
3913                           GTK_SIGNAL_FUNC (button_press), NULL);
3914       gtk_signal_connect_after (GTK_OBJECT (ctree), "button_press_event",
3915                                 GTK_SIGNAL_FUNC (after_press), NULL);
3916       gtk_signal_connect (GTK_OBJECT (ctree), "button_release_event",
3917                           GTK_SIGNAL_FUNC (button_release), NULL);
3918       gtk_signal_connect_after (GTK_OBJECT (ctree), "button_release_event",
3919                                 GTK_SIGNAL_FUNC (after_press), NULL);
3920       gtk_signal_connect_after (GTK_OBJECT (ctree), "tree_move",
3921                                 GTK_SIGNAL_FUNC (after_move), NULL);
3922       gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (ctree), TRUE, TRUE, 0);
3923       gtk_clist_column_titles_passive (GTK_CLIST (ctree));
3924       gtk_clist_set_column_justification (GTK_CLIST (ctree), 2, GTK_JUSTIFY_RIGHT);
3925       gtk_clist_set_selection_mode (GTK_CLIST (ctree), GTK_SELECTION_MULTIPLE);
3926       gtk_clist_set_policy (GTK_CLIST (ctree), GTK_POLICY_ALWAYS,
3927                             GTK_POLICY_AUTOMATIC);
3928       gtk_clist_set_column_width (GTK_CLIST (ctree), 0, 200);
3929       gtk_clist_set_column_width (GTK_CLIST (ctree), 1, 200);
3930
3931       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3932                           GTK_SIGNAL_FUNC (rebuild_tree), ctree);
3933
3934       hbox = gtk_hbox_new (FALSE, 5);
3935       gtk_container_border_width (GTK_CONTAINER (hbox), 5);
3936       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
3937
3938       button = gtk_button_new_with_label ("Expand all");
3939       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3940                           GTK_SIGNAL_FUNC (expand_all), ctree);
3941       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3942
3943       button = gtk_button_new_with_label ("Collapse all");
3944       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3945                           GTK_SIGNAL_FUNC (collapse_all), ctree);
3946       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3947
3948       button = gtk_button_new_with_label ("Sort tree");
3949       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3950                           GTK_SIGNAL_FUNC (sort_all), ctree);
3951       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3952
3953       hbox = gtk_hbox_new (FALSE, 5);
3954       gtk_container_border_width (GTK_CONTAINER (hbox), 5);
3955       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
3956
3957       button = gtk_button_new_with_label ("Select all");
3958       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3959                           GTK_SIGNAL_FUNC (select_all), ctree);
3960       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3961
3962       button = gtk_button_new_with_label ("Unselect all");
3963       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3964                           GTK_SIGNAL_FUNC (unselect_all), ctree);
3965       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3966
3967       button = gtk_button_new_with_label ("Remove selection");
3968       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3969                           GTK_SIGNAL_FUNC (remove_selection), ctree);
3970       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3971
3972       hbox = gtk_hbox_new (TRUE, 5);
3973       gtk_container_border_width (GTK_CONTAINER (hbox), 5);
3974       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
3975
3976       hbox2 = gtk_hbox_new (FALSE, 0);
3977       gtk_box_pack_start (GTK_BOX (hbox), hbox2, FALSE, TRUE, 0);
3978
3979       label = gtk_label_new ("Indent :");
3980       gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
3981
3982       adj = (GtkAdjustment *) gtk_adjustment_new (20, 0, 60, 1, 10, 0);
3983       spinner = gtk_spin_button_new (adj, 0, 0);
3984       gtk_tooltips_set_tip (tooltips, spinner, "Tree indentation.", NULL);
3985       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
3986                           GTK_SIGNAL_FUNC (change_indent), ctree);
3987       gtk_box_pack_start (GTK_BOX (hbox2), spinner, FALSE, TRUE, 5);
3988
3989       check = gtk_check_button_new_with_label ("Reorderable");
3990       gtk_tooltips_set_tip (tooltips, check,
3991                             "Tree items can be reordered by dragging.", NULL);
3992       gtk_signal_connect (GTK_OBJECT (check), "clicked",
3993                           GTK_SIGNAL_FUNC (toggle_reorderable), ctree);
3994       gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
3995       gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (check), TRUE);
3996
3997       omenu2 = gtk_option_menu_new ();
3998       gtk_tooltips_set_tip (tooltips, omenu2, "The tree's line style.", NULL);
3999
4000       menu = gtk_menu_new ();
4001       submenu = NULL;
4002       group = NULL;
4003
4004       menu_item = gtk_radio_menu_item_new_with_label (group, "Solid");
4005       gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
4006                           GTK_SIGNAL_FUNC (toggle_line_style), ctree);
4007       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
4008       gtk_menu_append (GTK_MENU (menu), menu_item);
4009       gtk_widget_show (menu_item);
4010
4011       menu_item = gtk_radio_menu_item_new_with_label (group, "Dotted");
4012       gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
4013                           GTK_SIGNAL_FUNC (toggle_line_style), ctree);
4014       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
4015       gtk_menu_append (GTK_MENU (menu), menu_item);
4016       gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
4017       gtk_widget_show (menu_item);
4018
4019       menu_item = gtk_radio_menu_item_new_with_label (group, "No lines");
4020       gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
4021                           GTK_SIGNAL_FUNC (toggle_line_style), ctree);
4022       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
4023       gtk_menu_append (GTK_MENU (menu), menu_item);
4024       gtk_widget_show (menu_item);
4025
4026       gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu2), menu);
4027       gtk_box_pack_start (GTK_BOX (hbox), omenu2, FALSE, TRUE, 0);
4028
4029       gtk_option_menu_set_history (GTK_OPTION_MENU (omenu2), 1);
4030
4031       omenu3 = gtk_option_menu_new ();
4032       gtk_tooltips_set_tip (tooltips, omenu3, "The tree's justification.", NULL);
4033
4034       menu = gtk_menu_new ();
4035       submenu = NULL;
4036       group = NULL;
4037
4038       menu_item = gtk_radio_menu_item_new_with_label (group, "Left");
4039       gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
4040                           GTK_SIGNAL_FUNC (toggle_justify), ctree);
4041       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
4042       gtk_menu_append (GTK_MENU (menu), menu_item);
4043       gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
4044       gtk_widget_show (menu_item);
4045
4046       menu_item = gtk_radio_menu_item_new_with_label (group, "Right");
4047       gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
4048                           GTK_SIGNAL_FUNC (toggle_justify), ctree);
4049       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
4050       gtk_menu_append (GTK_MENU (menu), menu_item);
4051       gtk_widget_show (menu_item);
4052
4053       gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu3), menu);
4054       gtk_box_pack_start (GTK_BOX (hbox), omenu3, FALSE, TRUE, 0);
4055
4056       gtk_option_menu_set_history (GTK_OPTION_MENU (omenu3), 0);
4057
4058       omenu = gtk_option_menu_new ();
4059       gtk_tooltips_set_tip (tooltips, omenu, "The list's selection mode.", NULL);
4060
4061       menu = gtk_menu_new ();
4062       submenu = NULL;
4063       group = NULL;
4064
4065       menu_item = gtk_radio_menu_item_new_with_label (group, "Single");
4066       gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
4067                           GTK_SIGNAL_FUNC (toggle_sel_mode), ctree);
4068       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
4069       gtk_menu_append (GTK_MENU (menu), menu_item);
4070       gtk_widget_show (menu_item);
4071
4072       menu_item = gtk_radio_menu_item_new_with_label (group, "Browse");
4073       gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
4074                           GTK_SIGNAL_FUNC (toggle_sel_mode), ctree);
4075       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
4076       gtk_menu_append (GTK_MENU (menu), menu_item);
4077       gtk_widget_show (menu_item);
4078
4079       menu_item = gtk_radio_menu_item_new_with_label (group, "Multiple");
4080       gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
4081                       GTK_SIGNAL_FUNC (toggle_sel_mode), ctree);
4082       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
4083       gtk_menu_append (GTK_MENU (menu), menu_item);
4084       gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
4085       gtk_widget_show (menu_item);
4086
4087       menu_item = gtk_radio_menu_item_new_with_label (group, "Extended");
4088       gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
4089                           GTK_SIGNAL_FUNC (toggle_sel_mode), ctree);
4090       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
4091       gtk_menu_append (GTK_MENU (menu), menu_item);
4092       gtk_widget_show (menu_item);
4093
4094       gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
4095       gtk_box_pack_start (GTK_BOX (hbox), omenu, FALSE, TRUE, 0);
4096
4097       gtk_option_menu_set_history (GTK_OPTION_MENU (omenu), 2);
4098
4099       gtk_widget_realize (window);
4100
4101       pixmap1 = gdk_pixmap_create_from_xpm_d (window->window, &mask1,
4102                                               &transparent, book_closed_xpm);
4103       pixmap2 = gdk_pixmap_create_from_xpm_d (window->window, &mask2,
4104                                               &transparent, book_open_xpm);
4105       pixmap3 = gdk_pixmap_create_from_xpm_d (window->window, &mask3,
4106                                               &transparent, mini_page_xpm);
4107
4108       gtk_widget_set_usize (GTK_WIDGET (ctree), 0, 300);
4109
4110       frame = gtk_frame_new (NULL);
4111       gtk_container_border_width (GTK_CONTAINER (frame), 0);
4112       gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
4113       gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
4114
4115       hbox = gtk_hbox_new (TRUE, 2);
4116       gtk_container_border_width (GTK_CONTAINER (hbox), 2);
4117       gtk_container_add (GTK_CONTAINER (frame), hbox);
4118
4119       frame = gtk_frame_new (NULL);
4120       gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
4121       gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
4122
4123       hbox2 = gtk_hbox_new (FALSE, 0);
4124       gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
4125       gtk_container_add (GTK_CONTAINER (frame), hbox2);
4126
4127       label = gtk_label_new ("Books :");
4128       gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
4129
4130       sprintf (buf, "%d", books);
4131       book_label = gtk_label_new (buf);
4132       gtk_box_pack_end (GTK_BOX (hbox2), book_label, FALSE, TRUE, 5);
4133
4134       frame = gtk_frame_new (NULL);
4135       gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
4136       gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
4137
4138       hbox2 = gtk_hbox_new (FALSE, 0);
4139       gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
4140       gtk_container_add (GTK_CONTAINER (frame), hbox2);
4141
4142       label = gtk_label_new ("Pages :");
4143       gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
4144
4145       sprintf (buf, "%d", pages);
4146       page_label = gtk_label_new (buf);
4147       gtk_box_pack_end (GTK_BOX (hbox2), page_label, FALSE, TRUE, 5);
4148
4149       frame = gtk_frame_new (NULL);
4150       gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
4151       gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
4152
4153       hbox2 = gtk_hbox_new (FALSE, 0);
4154       gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
4155       gtk_container_add (GTK_CONTAINER (frame), hbox2);
4156
4157       label = gtk_label_new ("Selected :");
4158       gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
4159
4160       sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection));
4161       sel_label = gtk_label_new (buf);
4162       gtk_box_pack_end (GTK_BOX (hbox2), sel_label, FALSE, TRUE, 5);
4163
4164       frame = gtk_frame_new (NULL);
4165       gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
4166       gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
4167
4168       hbox2 = gtk_hbox_new (FALSE, 0);
4169       gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
4170       gtk_container_add (GTK_CONTAINER (frame), hbox2);
4171
4172       label = gtk_label_new ("Visible :");
4173       gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
4174
4175       sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list));
4176       vis_label = gtk_label_new (buf);
4177       gtk_box_pack_end (GTK_BOX (hbox2), vis_label, FALSE, TRUE, 5);
4178
4179       rebuild_tree (NULL, ctree);
4180     }
4181
4182   if (!GTK_WIDGET_VISIBLE (window))
4183     gtk_widget_show_all (window);
4184   else
4185     gtk_widget_destroy (window);
4186 }
4187
4188
4189 /*
4190  * GtkColorSelect
4191  */
4192 void
4193 color_selection_ok (GtkWidget               *w,
4194                     GtkColorSelectionDialog *cs)
4195 {
4196   GtkColorSelection *colorsel;
4197   gdouble color[4];
4198
4199   colorsel=GTK_COLOR_SELECTION(cs->colorsel);
4200
4201   gtk_color_selection_get_color(colorsel,color);
4202   gtk_color_selection_set_color(colorsel,color);
4203 }
4204
4205 void
4206 color_selection_changed (GtkWidget *w,
4207                          GtkColorSelectionDialog *cs)
4208 {
4209   GtkColorSelection *colorsel;
4210   gdouble color[4];
4211
4212   colorsel=GTK_COLOR_SELECTION(cs->colorsel);
4213   gtk_color_selection_get_color(colorsel,color);
4214 }
4215
4216 void
4217 create_color_selection (void)
4218 {
4219   static GtkWidget *window = NULL;
4220
4221   if (!window)
4222     {
4223       gtk_preview_set_install_cmap (TRUE);
4224       gtk_widget_push_visual (gtk_preview_get_visual ());
4225       gtk_widget_push_colormap (gtk_preview_get_cmap ());
4226
4227       window = gtk_color_selection_dialog_new ("color selection dialog");
4228
4229       gtk_color_selection_set_opacity (
4230         GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
4231         TRUE);
4232
4233       gtk_color_selection_set_update_policy(
4234         GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
4235         GTK_UPDATE_CONTINUOUS);
4236
4237       gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
4238
4239       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4240                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4241                           &window);
4242
4243       gtk_signal_connect (
4244         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
4245         "color_changed",
4246         GTK_SIGNAL_FUNC(color_selection_changed),
4247         window);
4248
4249       gtk_signal_connect (
4250         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->ok_button),
4251         "clicked",
4252         GTK_SIGNAL_FUNC(color_selection_ok),
4253         window);
4254
4255       gtk_signal_connect_object (
4256         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->cancel_button),
4257         "clicked",
4258         GTK_SIGNAL_FUNC(gtk_widget_destroy),
4259         GTK_OBJECT (window));
4260
4261       gtk_widget_pop_colormap ();
4262       gtk_widget_pop_visual ();
4263     }
4264
4265   if (!GTK_WIDGET_VISIBLE (window))
4266     gtk_widget_show (window);
4267   else
4268     gtk_widget_destroy (window);
4269 }
4270
4271 void
4272 file_selection_hide_fileops (GtkWidget *widget,
4273                              GtkFileSelection *fs)
4274 {
4275   gtk_file_selection_hide_fileop_buttons (fs);
4276 }
4277
4278 void
4279 file_selection_ok (GtkWidget        *w,
4280                    GtkFileSelection *fs)
4281 {
4282   g_print ("%s\n", gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs)));
4283   gtk_widget_destroy (GTK_WIDGET (fs));
4284 }
4285
4286 void
4287 create_file_selection (void)
4288 {
4289   static GtkWidget *window = NULL;
4290   GtkWidget *button;
4291
4292   if (!window)
4293     {
4294       window = gtk_file_selection_new ("file selection dialog");
4295
4296       gtk_file_selection_hide_fileop_buttons (GTK_FILE_SELECTION (window));
4297
4298       gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
4299
4300       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4301                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4302                           &window);
4303
4304       gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (window)->ok_button),
4305                           "clicked", GTK_SIGNAL_FUNC(file_selection_ok),
4306                           window);
4307       gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (window)->cancel_button),
4308                                  "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
4309                                  GTK_OBJECT (window));
4310
4311       button = gtk_button_new_with_label ("Hide Fileops");
4312       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4313                           (GtkSignalFunc) file_selection_hide_fileops,
4314                           (gpointer) window);
4315       gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
4316                           button, FALSE, FALSE, 0);
4317       gtk_widget_show (button);
4318
4319       button = gtk_button_new_with_label ("Show Fileops");
4320       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4321                                  (GtkSignalFunc) gtk_file_selection_show_fileop_buttons,
4322                                  (gpointer) window);
4323       gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
4324                           button, FALSE, FALSE, 0);
4325       gtk_widget_show (button);
4326
4327
4328
4329     }
4330
4331   if (!GTK_WIDGET_VISIBLE (window))
4332     gtk_widget_show (window);
4333   else
4334     gtk_widget_destroy (window);
4335 }
4336
4337
4338 /*
4339  * GtkDialog
4340  */
4341 static GtkWidget *dialog_window = NULL;
4342
4343 void
4344 label_toggle (GtkWidget  *widget,
4345               GtkWidget **label)
4346 {
4347   if (!(*label))
4348     {
4349       *label = gtk_label_new ("Dialog Test");
4350       gtk_signal_connect (GTK_OBJECT (*label),
4351                           "destroy",
4352                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
4353                           label);
4354       gtk_misc_set_padding (GTK_MISC (*label), 10, 10);
4355       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
4356                           *label, TRUE, TRUE, 0);
4357       gtk_widget_show (*label);
4358     }
4359   else
4360     gtk_widget_destroy (*label);
4361 }
4362
4363 void
4364 create_dialog (void)
4365 {
4366   static GtkWidget *label;
4367   GtkWidget *button;
4368
4369   if (!dialog_window)
4370     {
4371       dialog_window = gtk_dialog_new ();
4372
4373       gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
4374                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4375                           &dialog_window);
4376
4377       gtk_window_set_title (GTK_WINDOW (dialog_window), "dialog");
4378       gtk_container_border_width (GTK_CONTAINER (dialog_window), 0);
4379
4380       button = gtk_button_new_with_label ("OK");
4381       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4382       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
4383                           button, TRUE, TRUE, 0);
4384       gtk_widget_grab_default (button);
4385       gtk_widget_show (button);
4386
4387       button = gtk_button_new_with_label ("Toggle");
4388       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4389                           GTK_SIGNAL_FUNC (label_toggle),
4390                           &label);
4391       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4392       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
4393                           button, TRUE, TRUE, 0);
4394       gtk_widget_show (button);
4395
4396       label = NULL;
4397     }
4398
4399   if (!GTK_WIDGET_VISIBLE (dialog_window))
4400     gtk_widget_show (dialog_window);
4401   else
4402     gtk_widget_destroy (dialog_window);
4403 }
4404
4405
4406 /*
4407  * GtkRange
4408  */
4409 void
4410 create_range_controls (void)
4411 {
4412   static GtkWidget *window = NULL;
4413   GtkWidget *box1;
4414   GtkWidget *box2;
4415   GtkWidget *button;
4416   GtkWidget *scrollbar;
4417   GtkWidget *scale;
4418   GtkWidget *separator;
4419   GtkObject *adjustment;
4420
4421   if (!window)
4422     {
4423       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4424
4425       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4426                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4427                           &window);
4428
4429       gtk_window_set_title (GTK_WINDOW (window), "range controls");
4430       gtk_container_border_width (GTK_CONTAINER (window), 0);
4431
4432
4433       box1 = gtk_vbox_new (FALSE, 0);
4434       gtk_container_add (GTK_CONTAINER (window), box1);
4435       gtk_widget_show (box1);
4436
4437
4438       box2 = gtk_vbox_new (FALSE, 10);
4439       gtk_container_border_width (GTK_CONTAINER (box2), 10);
4440       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
4441       gtk_widget_show (box2);
4442
4443
4444       adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
4445
4446       scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
4447       gtk_widget_set_usize (GTK_WIDGET (scale), 150, 30);
4448       gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
4449       gtk_scale_set_digits (GTK_SCALE (scale), 1);
4450       gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
4451       gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
4452       gtk_widget_show (scale);
4453
4454       scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adjustment));
4455       gtk_range_set_update_policy (GTK_RANGE (scrollbar),
4456                                    GTK_UPDATE_CONTINUOUS);
4457       gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0);
4458       gtk_widget_show (scrollbar);
4459
4460
4461       separator = gtk_hseparator_new ();
4462       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4463       gtk_widget_show (separator);
4464
4465
4466       box2 = gtk_vbox_new (FALSE, 10);
4467       gtk_container_border_width (GTK_CONTAINER (box2), 10);
4468       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4469       gtk_widget_show (box2);
4470
4471
4472       button = gtk_button_new_with_label ("close");
4473       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4474                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
4475                                  GTK_OBJECT (window));
4476       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4477       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4478       gtk_widget_grab_default (button);
4479       gtk_widget_show (button);
4480     }
4481
4482   if (!GTK_WIDGET_VISIBLE (window))
4483     gtk_widget_show (window);
4484   else
4485     gtk_widget_destroy (window);
4486 }
4487
4488
4489 /*
4490  * GtkRulers
4491  */
4492 void
4493 create_rulers (void)
4494 {
4495   static GtkWidget *window = NULL;
4496   GtkWidget *table;
4497   GtkWidget *ruler;
4498
4499   if (!window)
4500     {
4501       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4502
4503       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4504                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4505                           &window);
4506
4507       gtk_window_set_title (GTK_WINDOW (window), "rulers");
4508       gtk_widget_set_usize (window, 300, 300);
4509       gtk_widget_set_events (window,
4510                              GDK_POINTER_MOTION_MASK
4511                              | GDK_POINTER_MOTION_HINT_MASK);
4512       gtk_container_border_width (GTK_CONTAINER (window), 0);
4513
4514       table = gtk_table_new (2, 2, FALSE);
4515       gtk_container_add (GTK_CONTAINER (window), table);
4516       gtk_widget_show (table);
4517
4518       ruler = gtk_hruler_new ();
4519       gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
4520
4521       gtk_signal_connect_object (
4522         GTK_OBJECT (window),
4523         "motion_notify_event",
4524         GTK_SIGNAL_FUNC(
4525           GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
4526         GTK_OBJECT (ruler));
4527
4528       gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
4529                         GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
4530       gtk_widget_show (ruler);
4531
4532
4533       ruler = gtk_vruler_new ();
4534       gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
4535
4536       gtk_signal_connect_object (
4537         GTK_OBJECT (window),
4538         "motion_notify_event",
4539         GTK_SIGNAL_FUNC (GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
4540         GTK_OBJECT (ruler));
4541
4542       gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
4543                         GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
4544       gtk_widget_show (ruler);
4545     }
4546
4547   if (!GTK_WIDGET_VISIBLE (window))
4548     gtk_widget_show (window);
4549   else
4550     gtk_widget_destroy (window);
4551 }
4552
4553
4554 static void
4555 text_toggle_editable (GtkWidget *checkbutton,
4556                        GtkWidget *text)
4557 {
4558    gtk_text_set_editable(GTK_TEXT(text),
4559                           GTK_TOGGLE_BUTTON(checkbutton)->active);
4560 }
4561
4562 static void
4563 text_toggle_word_wrap (GtkWidget *checkbutton,
4564                        GtkWidget *text)
4565 {
4566    gtk_text_set_word_wrap(GTK_TEXT(text),
4567                           GTK_TOGGLE_BUTTON(checkbutton)->active);
4568 }
4569
4570 /*
4571  * GtkText
4572  */
4573 void
4574 create_text (void)
4575 {
4576   static GtkWidget *window = NULL;
4577   GtkWidget *box1;
4578   GtkWidget *box2;
4579   GtkWidget *hbox;
4580   GtkWidget *button;
4581   GtkWidget *check;
4582   GtkWidget *separator;
4583   GtkWidget *table;
4584   GtkWidget *hscrollbar;
4585   GtkWidget *vscrollbar;
4586   GtkWidget *text;
4587
4588   FILE *infile;
4589
4590   if (!window)
4591     {
4592       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4593       gtk_widget_set_name (window, "text window");
4594       gtk_widget_set_usize (window, 500, 500);
4595       gtk_window_set_policy (GTK_WINDOW(window), TRUE, TRUE, FALSE);
4596
4597       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4598                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4599                           &window);
4600
4601       gtk_window_set_title (GTK_WINDOW (window), "test");
4602       gtk_container_border_width (GTK_CONTAINER (window), 0);
4603
4604
4605       box1 = gtk_vbox_new (FALSE, 0);
4606       gtk_container_add (GTK_CONTAINER (window), box1);
4607       gtk_widget_show (box1);
4608
4609
4610       box2 = gtk_vbox_new (FALSE, 10);
4611       gtk_container_border_width (GTK_CONTAINER (box2), 10);
4612       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
4613       gtk_widget_show (box2);
4614
4615
4616       table = gtk_table_new (2, 2, FALSE);
4617       gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2);
4618       gtk_table_set_col_spacing (GTK_TABLE (table), 0, 2);
4619       gtk_box_pack_start (GTK_BOX (box2), table, TRUE, TRUE, 0);
4620       gtk_widget_show (table);
4621
4622       text = gtk_text_new (NULL, NULL);
4623       gtk_text_set_editable (GTK_TEXT (text), TRUE);
4624       gtk_table_attach (GTK_TABLE (table), text, 0, 1, 0, 1,
4625                         GTK_EXPAND | GTK_SHRINK | GTK_FILL,
4626                         GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
4627       gtk_widget_show (text);
4628
4629       hscrollbar = gtk_hscrollbar_new (GTK_TEXT (text)->hadj);
4630       gtk_table_attach (GTK_TABLE (table), hscrollbar, 0, 1, 1, 2,
4631                         GTK_EXPAND | GTK_FILL | GTK_SHRINK, GTK_FILL, 0, 0);
4632       gtk_widget_show (hscrollbar);
4633
4634       vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
4635       gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 0, 1,
4636                         GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
4637       gtk_widget_show (vscrollbar);
4638
4639       gtk_text_freeze (GTK_TEXT (text));
4640
4641       gtk_widget_realize (text);
4642
4643       infile = fopen("testgtk.c", "r");
4644
4645       if (infile)
4646         {
4647           char buffer[1024];
4648           int nchars;
4649
4650           while (1)
4651             {
4652               nchars = fread(buffer, 1, 1024, infile);
4653               gtk_text_insert (GTK_TEXT (text), NULL, NULL,
4654                                NULL, buffer, nchars);
4655
4656               if (nchars < 1024)
4657                 break;
4658             }
4659
4660           fclose (infile);
4661         }
4662
4663       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
4664                        "And even ", -1);
4665       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->bg[GTK_STATE_NORMAL], NULL,
4666                        "colored", -1);
4667       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
4668                        "text", -1);
4669
4670       gtk_text_thaw (GTK_TEXT (text));
4671
4672       hbox = gtk_hbutton_box_new ();
4673       gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, FALSE, 0);
4674       gtk_widget_show (hbox);
4675
4676       check = gtk_check_button_new_with_label("Editable");
4677       gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, FALSE, 0);
4678       gtk_signal_connect (GTK_OBJECT(check), "toggled",
4679                           GTK_SIGNAL_FUNC(text_toggle_editable), text);
4680       gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), TRUE);
4681       gtk_widget_show (check);
4682
4683       check = gtk_check_button_new_with_label("Wrap Words");
4684       gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
4685       gtk_signal_connect (GTK_OBJECT(check), "toggled",
4686                           GTK_SIGNAL_FUNC(text_toggle_word_wrap), text);
4687       gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), FALSE);
4688       gtk_widget_show (check);
4689
4690       separator = gtk_hseparator_new ();
4691       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4692       gtk_widget_show (separator);
4693
4694
4695       box2 = gtk_vbox_new (FALSE, 10);
4696       gtk_container_border_width (GTK_CONTAINER (box2), 10);
4697       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4698       gtk_widget_show (box2);
4699
4700
4701       button = gtk_button_new_with_label ("close");
4702       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4703                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
4704                                  GTK_OBJECT (window));
4705       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4706       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4707       gtk_widget_grab_default (button);
4708       gtk_widget_show (button);
4709     }
4710
4711   if (!GTK_WIDGET_VISIBLE (window))
4712     gtk_widget_show (window);
4713   else
4714     gtk_widget_destroy (window);
4715 }
4716
4717
4718 /*
4719  * GtkNotebook
4720  */
4721
4722 GdkPixmap *book_open;
4723 GdkPixmap *book_closed;
4724 GdkBitmap *book_open_mask;
4725 GdkBitmap *book_closed_mask;
4726
4727
4728 static void
4729 notebook_reparent (GtkWidget *widget, GtkWidget *scrollwin)
4730 {
4731   static GtkWidget *parent = NULL;
4732   static GtkWidget *float_parent;
4733
4734   if (parent)
4735     {
4736       gtk_widget_reparent (scrollwin, parent);
4737       gtk_widget_destroy (float_parent);
4738       float_parent = NULL;
4739       parent = NULL;
4740     }
4741   else
4742     {
4743       parent = widget->parent;
4744       float_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4745       gtk_widget_show (float_parent);
4746       gtk_widget_reparent (scrollwin, float_parent);
4747     }
4748 }
4749
4750 static void
4751 page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num)
4752 {
4753   GtkNotebookPage *oldpage;
4754   GtkWidget *pixwid;
4755
4756   oldpage = GTK_NOTEBOOK (widget)->cur_page;
4757
4758   if (page == oldpage)
4759     return;
4760
4761   pixwid = ((GtkBoxChild*)(GTK_BOX (page->tab_label)->children->data))->widget;
4762   gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
4763   pixwid = ((GtkBoxChild*) (GTK_BOX (page->menu_label)->children->data))->widget;
4764   gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
4765
4766   if (oldpage)
4767     {
4768       pixwid = ((GtkBoxChild*) (GTK_BOX
4769                                 (oldpage->tab_label)->children->data))->widget;
4770       gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
4771       pixwid = ((GtkBoxChild*) (GTK_BOX (oldpage->menu_label)->children->data))->widget;
4772       gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
4773     }
4774 }
4775
4776 static void
4777 create_pages (GtkNotebook *notebook, gint start, gint end)
4778 {
4779   GtkWidget *child = NULL;
4780   GtkWidget *label;
4781   GtkWidget *entry;
4782   GtkWidget *box;
4783   GtkWidget *hbox;
4784   GtkWidget *label_box;
4785   GtkWidget *menu_box;
4786   GtkWidget *button;
4787   GtkWidget *pixwid;
4788   gint i;
4789   char buffer[32];
4790
4791   for (i = start; i <= end; i++)
4792     {
4793       sprintf (buffer, "Page %d", i);
4794
4795       switch (i%4)
4796         {
4797         case 3:
4798           child = gtk_button_new_with_label (buffer);
4799           gtk_container_border_width (GTK_CONTAINER(child), 10);
4800           break;
4801         case 2:
4802           child = gtk_label_new (buffer);
4803           break;
4804         case 1:
4805           child = gtk_frame_new (buffer);
4806           gtk_container_border_width (GTK_CONTAINER (child), 10);
4807
4808           box = gtk_vbox_new (TRUE,0);
4809           gtk_container_border_width (GTK_CONTAINER (box), 10);
4810           gtk_container_add (GTK_CONTAINER (child), box);
4811
4812           label = gtk_label_new (buffer);
4813           gtk_box_pack_start (GTK_BOX(box), label, TRUE, TRUE, 5);
4814
4815           entry = gtk_entry_new ();
4816           gtk_box_pack_start (GTK_BOX(box), entry, TRUE, TRUE, 5);
4817
4818           hbox = gtk_hbox_new (TRUE,0);
4819           gtk_box_pack_start (GTK_BOX(box), hbox, TRUE, TRUE, 5);
4820
4821           button = gtk_button_new_with_label ("Ok");
4822           gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
4823
4824           button = gtk_button_new_with_label ("Cancel");
4825           gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
4826           break;
4827         case 0:
4828           child = gtk_frame_new (buffer);
4829           gtk_container_border_width (GTK_CONTAINER (child), 10);
4830
4831           label = gtk_label_new (buffer);
4832           gtk_container_add (GTK_CONTAINER (child), label);
4833           break;
4834         }
4835
4836       gtk_widget_show_all (child);
4837
4838       label_box = gtk_hbox_new (FALSE, 0);
4839       pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
4840       gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
4841       gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
4842       label = gtk_label_new (buffer);
4843       gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
4844       gtk_widget_show_all (label_box);
4845
4846       menu_box = gtk_hbox_new (FALSE, 0);
4847       pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
4848       gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
4849       gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
4850       label = gtk_label_new (buffer);
4851       gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0);
4852       gtk_widget_show_all (menu_box);
4853
4854       gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
4855     }
4856 }
4857
4858 static void
4859 rotate_notebook (GtkButton   *button,
4860                  GtkNotebook *notebook)
4861 {
4862   gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos + 1) % 4);
4863 }
4864
4865 static void
4866 standard_notebook (GtkButton   *button,
4867                    GtkNotebook *notebook)
4868 {
4869   gint i;
4870
4871   gtk_notebook_set_show_tabs (notebook, TRUE);
4872   gtk_notebook_set_scrollable (notebook, FALSE);
4873   if (g_list_length (notebook->children) == 15)
4874     for (i = 0; i < 10; i++)
4875       gtk_notebook_remove_page (notebook, 5);
4876 }
4877
4878 static void
4879 notabs_notebook (GtkButton   *button,
4880                  GtkNotebook *notebook)
4881 {
4882   gint i;
4883
4884   gtk_notebook_set_show_tabs (notebook, FALSE);
4885   if (g_list_length (notebook->children) == 15)
4886     for (i = 0; i < 10; i++)
4887       gtk_notebook_remove_page (notebook, 5);
4888 }
4889
4890 static void
4891 scrollable_notebook (GtkButton   *button,
4892                      GtkNotebook *notebook)
4893 {
4894   gtk_notebook_set_show_tabs (notebook, TRUE);
4895   gtk_notebook_set_scrollable (notebook, TRUE);
4896   if (g_list_length (notebook->children) == 5)
4897     create_pages (notebook, 6, 15);
4898 }
4899
4900 static void
4901 notebook_popup (GtkToggleButton *button,
4902                 GtkNotebook     *notebook)
4903 {
4904   if (button->active)
4905     gtk_notebook_popup_enable (notebook);
4906   else
4907     gtk_notebook_popup_disable (notebook);
4908 }
4909
4910 static void
4911 create_notebook (void)
4912 {
4913   static GtkWidget *window = NULL;
4914   GtkWidget *box1;
4915   GtkWidget *box2;
4916   GtkWidget *button;
4917   GtkWidget *separator;
4918   GtkWidget *notebook;
4919   GtkWidget *omenu;
4920   GtkWidget *menu;
4921   GtkWidget *submenu;
4922   GtkWidget *menuitem;
4923   GSList *group;
4924   GdkColor *transparent = NULL;
4925
4926   if (!window)
4927     {
4928       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4929
4930       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4931                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4932                           &window);
4933
4934       gtk_window_set_title (GTK_WINDOW (window), "notebook");
4935       gtk_container_border_width (GTK_CONTAINER (window), 0);
4936
4937       box1 = gtk_vbox_new (FALSE, 0);
4938       gtk_container_add (GTK_CONTAINER (window), box1);
4939
4940       notebook = gtk_notebook_new ();
4941       gtk_signal_connect (GTK_OBJECT (notebook), "switch_page",
4942                           GTK_SIGNAL_FUNC (page_switch), NULL);
4943       gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
4944       gtk_box_pack_start (GTK_BOX (box1), notebook, TRUE, TRUE, 0);
4945       gtk_container_border_width (GTK_CONTAINER (notebook), 10);
4946
4947       gtk_widget_realize (notebook);
4948       book_open = gdk_pixmap_create_from_xpm_d (notebook->window,
4949                                                 &book_open_mask,
4950                                                 transparent,
4951                                                 book_open_xpm);
4952       book_closed = gdk_pixmap_create_from_xpm_d (notebook->window,
4953                                                   &book_closed_mask,
4954                                                   transparent,
4955                                                   book_closed_xpm);
4956
4957       create_pages (GTK_NOTEBOOK (notebook), 1, 5);
4958
4959       separator = gtk_hseparator_new ();
4960       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10);
4961
4962       box2 = gtk_hbox_new (TRUE, 5);
4963       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4964
4965       omenu = gtk_option_menu_new ();
4966       menu = gtk_menu_new ();
4967       submenu = NULL;
4968       group = NULL;
4969
4970       menuitem = gtk_radio_menu_item_new_with_label (group, "Standard");
4971       gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
4972                                  GTK_SIGNAL_FUNC (standard_notebook),
4973                                  GTK_OBJECT (notebook));
4974       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
4975       gtk_menu_append (GTK_MENU (menu), menuitem);
4976       gtk_widget_show (menuitem);
4977       menuitem = gtk_radio_menu_item_new_with_label (group, "w/o Tabs");
4978       gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
4979                                  GTK_SIGNAL_FUNC (notabs_notebook),
4980                                  GTK_OBJECT (notebook));
4981       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
4982       gtk_menu_append (GTK_MENU (menu), menuitem);
4983       gtk_widget_show (menuitem);
4984       menuitem = gtk_radio_menu_item_new_with_label (group, "Scrollable");
4985       gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
4986                                  GTK_SIGNAL_FUNC (scrollable_notebook),
4987                                  GTK_OBJECT (notebook));
4988       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
4989       gtk_menu_append (GTK_MENU (menu), menuitem);
4990       gtk_widget_show (menuitem);
4991
4992       gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
4993       gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, FALSE, 0);
4994       button = gtk_check_button_new_with_label ("enable popup menu");
4995       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
4996       gtk_signal_connect (GTK_OBJECT(button), "clicked",
4997                           GTK_SIGNAL_FUNC (notebook_popup),
4998                           GTK_OBJECT (notebook));
4999
5000       box2 = gtk_hbox_new (FALSE, 10);
5001       gtk_container_border_width (GTK_CONTAINER (box2), 10);
5002       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5003
5004       button = gtk_button_new_with_label ("close");
5005       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5006                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
5007                                  GTK_OBJECT (window));
5008       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5009       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5010       gtk_widget_grab_default (button);
5011
5012       button = gtk_button_new_with_label ("next");
5013       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5014                                  GTK_SIGNAL_FUNC (gtk_notebook_next_page),
5015                                  GTK_OBJECT (notebook));
5016       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5017       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5018
5019       button = gtk_button_new_with_label ("prev");
5020       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5021                                  GTK_SIGNAL_FUNC (gtk_notebook_prev_page),
5022                                  GTK_OBJECT (notebook));
5023       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5024       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5025
5026       button = gtk_button_new_with_label ("rotate");
5027       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5028                           GTK_SIGNAL_FUNC (rotate_notebook),
5029                           notebook);
5030       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5031       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5032
5033       button = gtk_button_new_with_label ("reparent");
5034       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5035                           GTK_SIGNAL_FUNC (notebook_reparent),
5036                           notebook);
5037       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5038       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5039     }
5040
5041   if (!GTK_WIDGET_VISIBLE (window))
5042     gtk_widget_show_all (window);
5043   else
5044     gtk_widget_destroy (window);
5045 }
5046
5047
5048 /*
5049  * GtkPanes
5050  */
5051 void
5052 create_panes (void)
5053 {
5054   static GtkWidget *window = NULL;
5055   GtkWidget *frame;
5056   GtkWidget *hpaned;
5057   GtkWidget *vpaned;
5058   GtkWidget *button;
5059
5060   if (!window)
5061     {
5062       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5063
5064       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5065                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5066                           &window);
5067
5068       gtk_window_set_title (GTK_WINDOW (window), "Panes");
5069       gtk_container_border_width (GTK_CONTAINER (window), 0);
5070
5071       vpaned = gtk_vpaned_new ();
5072       gtk_container_add (GTK_CONTAINER (window), vpaned);
5073       gtk_container_border_width (GTK_CONTAINER(vpaned), 5);
5074       gtk_widget_show (vpaned);
5075
5076       hpaned = gtk_hpaned_new ();
5077       gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
5078
5079       frame = gtk_frame_new (NULL);
5080       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
5081       gtk_widget_set_usize (frame, 60, 60);
5082       gtk_paned_add1 (GTK_PANED (hpaned), frame);
5083       gtk_widget_show (frame);
5084
5085       button = gtk_button_new_with_label ("Hi there");
5086       gtk_container_add (GTK_CONTAINER(frame), button);
5087       gtk_widget_show (button);
5088
5089       frame = gtk_frame_new (NULL);
5090       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
5091       gtk_widget_set_usize (frame, 80, 60);
5092       gtk_paned_add2 (GTK_PANED (hpaned), frame);
5093       gtk_widget_show (frame);
5094
5095       gtk_widget_show (hpaned);
5096
5097       frame = gtk_frame_new (NULL);
5098       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
5099       gtk_widget_set_usize (frame, 60, 80);
5100       gtk_paned_add2 (GTK_PANED (vpaned), frame);
5101       gtk_widget_show (frame);
5102     }
5103
5104   if (!GTK_WIDGET_VISIBLE (window))
5105     gtk_widget_show (window);
5106   else
5107     gtk_widget_destroy (window);
5108 }
5109
5110
5111 /*
5112  * Drag -N- Drop
5113  */
5114
5115 gint
5116 dnd_drop_destroy_popup (GtkWidget *widget, GtkWindow **window)
5117 {
5118   if(GTK_IS_BUTTON(widget)) /* I.e. they clicked the close button */
5119     gtk_widget_destroy(GTK_WIDGET(*window));
5120   else {
5121     gtk_grab_remove(GTK_WIDGET(*window));
5122     *window = NULL;
5123   }
5124
5125   return FALSE;
5126 }
5127
5128 void
5129 dnd_drop (GtkWidget *button, GdkEvent *event)
5130 {
5131   static GtkWidget *window = NULL;
5132   GtkWidget *vbox, *lbl, *btn;
5133   gchar *msg;
5134
5135   /* DND doesn't obey gtk_grab's, so check if we're already displaying
5136    * drop modal dialog first
5137    */
5138   if (window)
5139     return;
5140
5141   window = gtk_window_new(GTK_WINDOW_DIALOG);
5142   gtk_container_border_width (GTK_CONTAINER(window), 10);
5143
5144   gtk_signal_connect (GTK_OBJECT (window), "destroy",
5145                       GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
5146                       &window);
5147   gtk_signal_connect (GTK_OBJECT (window), "delete-event",
5148                       GTK_SIGNAL_FUNC(gtk_false),
5149                       &window);
5150
5151   vbox = gtk_vbox_new(FALSE, 5);
5152
5153   /* Display message that we got from drop source */
5154   msg = g_malloc(strlen(event->dropdataavailable.data)
5155                  + strlen(event->dropdataavailable.data_type) + 100);
5156   sprintf(msg, "Drop data of type %s was:\n\n%s",
5157           event->dropdataavailable.data_type,
5158           (char *)event->dropdataavailable.data);
5159   lbl = gtk_label_new(msg);
5160   gtk_label_set_justify(GTK_LABEL(lbl), GTK_JUSTIFY_FILL);
5161   g_free(msg);
5162   gtk_widget_show(lbl);
5163   gtk_box_pack_start_defaults(GTK_BOX(vbox), lbl);
5164
5165   /* Provide an obvious way out of this heinousness */
5166   btn = gtk_button_new_with_label("Continue with life in\nspite of this oppression");
5167   gtk_signal_connect_object (GTK_OBJECT (btn), "clicked",
5168                              GTK_SIGNAL_FUNC(gtk_widget_destroy),
5169                              GTK_OBJECT (window));
5170   gtk_widget_show(btn);
5171   gtk_box_pack_start_defaults(GTK_BOX(vbox), btn);
5172
5173   gtk_container_add(GTK_CONTAINER(window), vbox);
5174
5175   gtk_widget_show(vbox);
5176   gtk_grab_add(window);
5177   gtk_widget_show(window);
5178 }
5179
5180 void
5181 dnd_drag_request (GtkWidget *button, GdkEvent *event)
5182 {
5183 #define DND_STRING "Bill Gates demands royalties for\nyour use of his innovation."
5184   gtk_widget_dnd_data_set (button, event, DND_STRING, strlen(DND_STRING) + 1);
5185 }
5186
5187 void
5188 create_dnd (void)
5189 {
5190   static GtkWidget *window = NULL;
5191   GtkWidget *box1;
5192   GtkWidget *box2;
5193   GtkWidget *box3;
5194   GtkWidget *frame;
5195   GtkWidget *button;
5196   GtkWidget *separator;
5197
5198   /* For clarity... */
5199   char *possible_drag_types[] = {"text/plain"};
5200   char *accepted_drop_types[] = {"text/plain"};
5201
5202   static GtkWidget *drag_icon = NULL;
5203   static GtkWidget *drop_icon = NULL;
5204
5205   if (!window)
5206     {
5207       GdkPoint hotspot = {5,5};
5208
5209       if (!drag_icon)
5210         {
5211           drag_icon = shape_create_icon ("Modeller.xpm",
5212                                          440, 140, 0,0, GTK_WINDOW_POPUP);
5213
5214           gtk_signal_connect (GTK_OBJECT (drag_icon), "destroy",
5215                               GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5216                               &drag_icon);
5217
5218           gtk_widget_hide (drag_icon);
5219         }
5220
5221       if (!drop_icon)
5222         {
5223           drop_icon = shape_create_icon ("3DRings.xpm",
5224                                          440, 140, 0,0, GTK_WINDOW_POPUP);
5225
5226           gtk_signal_connect (GTK_OBJECT (drop_icon), "destroy",
5227                               GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5228                               &drop_icon);
5229
5230           gtk_widget_hide (drop_icon);
5231         }
5232
5233       gdk_dnd_set_drag_shape(drag_icon->window,
5234                              &hotspot,
5235                              drop_icon->window,
5236                              &hotspot);
5237
5238       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5239
5240       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5241                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5242                           &window);
5243
5244       gtk_window_set_title (GTK_WINDOW (window), "Drag -N- Drop");
5245       gtk_container_border_width (GTK_CONTAINER (window), 0);
5246
5247       box1 = gtk_vbox_new (FALSE, 0);
5248       gtk_container_add (GTK_CONTAINER (window), box1);
5249       gtk_widget_show (box1);
5250
5251       box2 = gtk_hbox_new (FALSE, 5);
5252       gtk_container_border_width (GTK_CONTAINER (box2), 10);
5253       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
5254       gtk_widget_show (box2);
5255
5256       frame = gtk_frame_new ("Drag");
5257       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
5258       gtk_widget_show (frame);
5259
5260       box3 = gtk_vbox_new (FALSE, 5);
5261       gtk_container_border_width (GTK_CONTAINER (box3), 5);
5262       gtk_container_add (GTK_CONTAINER (frame), box3);
5263       gtk_widget_show (box3);
5264
5265       /*
5266        * FROM Button
5267        */
5268       button = gtk_button_new_with_label ("Drag me!");
5269       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
5270       gtk_widget_show (button);
5271
5272       /*
5273        * currently, the widget has to be realized to
5274        * set dnd on it, this needs to change
5275        */
5276       gtk_widget_realize (button);
5277       gtk_signal_connect (GTK_OBJECT (button),
5278                           "drag_request_event",
5279                           GTK_SIGNAL_FUNC(dnd_drag_request),
5280                           button);
5281
5282       gtk_widget_dnd_drag_set (button, TRUE, possible_drag_types, 1);
5283
5284
5285       frame = gtk_frame_new ("Drop");
5286       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
5287       gtk_widget_show (frame);
5288
5289       box3 = gtk_vbox_new (FALSE, 5);
5290       gtk_container_border_width (GTK_CONTAINER (box3), 5);
5291       gtk_container_add (GTK_CONTAINER (frame), box3);
5292       gtk_widget_show (box3);
5293
5294
5295       /*
5296        * TO Button
5297        */
5298       button = gtk_button_new_with_label ("To");
5299       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
5300       gtk_widget_show (button);
5301
5302       gtk_widget_realize (button);
5303       gtk_signal_connect (GTK_OBJECT (button),
5304                           "drop_data_available_event",
5305                           GTK_SIGNAL_FUNC(dnd_drop),
5306                           button);
5307
5308       gtk_widget_dnd_drop_set (button, TRUE, accepted_drop_types, 1, FALSE);
5309
5310
5311       separator = gtk_hseparator_new ();
5312       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5313       gtk_widget_show (separator);
5314
5315
5316       box2 = gtk_vbox_new (FALSE, 10);
5317       gtk_container_border_width (GTK_CONTAINER (box2), 10);
5318       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5319       gtk_widget_show (box2);
5320
5321
5322       button = gtk_button_new_with_label ("close");
5323
5324       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5325                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
5326                                  GTK_OBJECT (window));
5327
5328       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5329       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5330       gtk_widget_grab_default (button);
5331       gtk_widget_show (button);
5332     }
5333
5334   if (!GTK_WIDGET_VISIBLE (window))
5335     gtk_widget_show (window);
5336   else
5337     gtk_widget_destroy (window);
5338 }
5339
5340 /*
5341  * Shaped Windows
5342  */
5343 static GdkWindow *root_win = NULL;
5344
5345 typedef struct _cursoroffset {gint x,y;} CursorOffset;
5346
5347 static void
5348 shape_pressed (GtkWidget *widget, GdkEventButton *event)
5349 {
5350   CursorOffset *p;
5351
5352   /* ignore double and triple click */
5353   if (event->type != GDK_BUTTON_PRESS)
5354     return;
5355
5356   p = gtk_object_get_user_data (GTK_OBJECT(widget));
5357   p->x = (int) event->x;
5358   p->y = (int) event->y;
5359
5360   gtk_grab_add (widget);
5361   gdk_pointer_grab (widget->window, TRUE,
5362                     GDK_BUTTON_RELEASE_MASK |
5363                     GDK_BUTTON_MOTION_MASK |
5364                     GDK_POINTER_MOTION_HINT_MASK,
5365                     NULL, NULL, 0);
5366 }
5367
5368
5369 static void
5370 shape_released (GtkWidget *widget)
5371 {
5372   gtk_grab_remove (widget);
5373   gdk_pointer_ungrab (0);
5374 }
5375
5376 static void
5377 shape_motion (GtkWidget      *widget,
5378               GdkEventMotion *event)
5379 {
5380   gint xp, yp;
5381   CursorOffset * p;
5382   GdkModifierType mask;
5383
5384   p = gtk_object_get_user_data (GTK_OBJECT (widget));
5385
5386   /*
5387    * Can't use event->x / event->y here
5388    * because I need absolute coordinates.
5389    */
5390   gdk_window_get_pointer (root_win, &xp, &yp, &mask);
5391   gtk_widget_set_uposition (widget, xp  - p->x, yp  - p->y);
5392 }
5393
5394 GtkWidget *
5395 shape_create_icon (char     *xpm_file,
5396                    gint      x,
5397                    gint      y,
5398                    gint      px,
5399                    gint      py,
5400                    gint      window_type)
5401 {
5402   GtkWidget *window;
5403   GtkWidget *pixmap;
5404   GtkWidget *fixed;
5405   CursorOffset* icon_pos;
5406   GdkGC* gc;
5407   GdkBitmap *gdk_pixmap_mask;
5408   GdkPixmap *gdk_pixmap;
5409   GtkStyle *style;
5410
5411   style = gtk_widget_get_default_style ();
5412   gc = style->black_gc;
5413
5414   /*
5415    * GDK_WINDOW_TOPLEVEL works also, giving you a title border
5416    */
5417   window = gtk_window_new (window_type);
5418
5419   fixed = gtk_fixed_new ();
5420   gtk_widget_set_usize (fixed, 100,100);
5421   gtk_container_add (GTK_CONTAINER (window), fixed);
5422   gtk_widget_show (fixed);
5423
5424   gtk_widget_set_events (window,
5425                          gtk_widget_get_events (window) |
5426                          GDK_BUTTON_MOTION_MASK |
5427                          GDK_POINTER_MOTION_HINT_MASK |
5428                          GDK_BUTTON_PRESS_MASK);
5429
5430   gtk_widget_realize (window);
5431   gdk_pixmap = gdk_pixmap_create_from_xpm (window->window, &gdk_pixmap_mask,
5432                                            &style->bg[GTK_STATE_NORMAL],
5433                                            xpm_file);
5434
5435   pixmap = gtk_pixmap_new (gdk_pixmap, gdk_pixmap_mask);
5436   gtk_fixed_put (GTK_FIXED (fixed), pixmap, px,py);
5437   gtk_widget_show (pixmap);
5438
5439   gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px,py);
5440
5441
5442   gtk_signal_connect (GTK_OBJECT (window), "button_press_event",
5443                       GTK_SIGNAL_FUNC (shape_pressed),NULL);
5444   gtk_signal_connect (GTK_OBJECT (window), "button_release_event",
5445                       GTK_SIGNAL_FUNC (shape_released),NULL);
5446   gtk_signal_connect (GTK_OBJECT (window), "motion_notify_event",
5447                       GTK_SIGNAL_FUNC (shape_motion),NULL);
5448
5449   icon_pos = g_new (CursorOffset, 1);
5450   gtk_object_set_user_data(GTK_OBJECT(window), icon_pos);
5451
5452   gtk_widget_set_uposition (window, x, y);
5453   gtk_widget_show (window);
5454
5455   return window;
5456 }
5457
5458 void
5459 create_shapes (void)
5460 {
5461   /* Variables used by the Drag/Drop and Shape Window demos */
5462   static GtkWidget *modeller = NULL;
5463   static GtkWidget *sheets = NULL;
5464   static GtkWidget *rings = NULL;
5465
5466   root_win = gdk_window_foreign_new (GDK_ROOT_WINDOW ());
5467
5468   if (!modeller)
5469     {
5470       modeller = shape_create_icon ("Modeller.xpm",
5471                                     440, 140, 0,0, GTK_WINDOW_POPUP);
5472
5473       gtk_signal_connect (GTK_OBJECT (modeller), "destroy",
5474                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5475                           &modeller);
5476     }
5477   else
5478     gtk_widget_destroy (modeller);
5479
5480   if (!sheets)
5481     {
5482       sheets = shape_create_icon ("FilesQueue.xpm",
5483                                   580, 170, 0,0, GTK_WINDOW_POPUP);
5484
5485       gtk_signal_connect (GTK_OBJECT (sheets), "destroy",
5486                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5487                           &sheets);
5488
5489     }
5490   else
5491     gtk_widget_destroy (sheets);
5492
5493   if (!rings)
5494     {
5495       rings = shape_create_icon ("3DRings.xpm",
5496                                  460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
5497
5498       gtk_signal_connect (GTK_OBJECT (rings), "destroy",
5499                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5500                           &rings);
5501     }
5502   else
5503     gtk_widget_destroy (rings);
5504 }
5505
5506 void
5507 create_wmhints (void)
5508 {
5509   static GtkWidget *window = NULL;
5510   GtkWidget *label;
5511   GtkWidget *separator;
5512   GtkWidget *button;
5513   GtkWidget *box1;
5514   GtkWidget *box2;
5515
5516   GdkBitmap *circles;
5517
5518   if (!window)
5519     {
5520       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5521
5522       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5523                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5524                           &window);
5525
5526       gtk_window_set_title (GTK_WINDOW (window), "WM Hints");
5527       gtk_container_border_width (GTK_CONTAINER (window), 0);
5528
5529       gtk_widget_realize (window);
5530
5531       circles = gdk_bitmap_create_from_data (window->window,
5532                                              circles_bits,
5533                                              circles_width,
5534                                              circles_height);
5535       gdk_window_set_icon (window->window, NULL,
5536                            circles, circles);
5537
5538       gdk_window_set_icon_name (window->window, "WMHints Test Icon");
5539
5540       gdk_window_set_decorations (window->window, GDK_DECOR_ALL | GDK_DECOR_MENU);
5541       gdk_window_set_functions (window->window, GDK_FUNC_ALL | GDK_FUNC_RESIZE);
5542
5543       box1 = gtk_vbox_new (FALSE, 0);
5544       gtk_container_add (GTK_CONTAINER (window), box1);
5545       gtk_widget_show (box1);
5546
5547       label = gtk_label_new ("Try iconizing me!");
5548       gtk_widget_set_usize (label, 150, 50);
5549       gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
5550       gtk_widget_show (label);
5551
5552
5553       separator = gtk_hseparator_new ();
5554       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5555       gtk_widget_show (separator);
5556
5557
5558       box2 = gtk_vbox_new (FALSE, 10);
5559       gtk_container_border_width (GTK_CONTAINER (box2), 10);
5560       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5561       gtk_widget_show (box2);
5562
5563
5564       button = gtk_button_new_with_label ("close");
5565
5566       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5567                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
5568                                  GTK_OBJECT (window));
5569
5570       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5571       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5572       gtk_widget_grab_default (button);
5573       gtk_widget_show (button);
5574     }
5575
5576   if (!GTK_WIDGET_VISIBLE (window))
5577     gtk_widget_show (window);
5578   else
5579     gtk_widget_destroy (window);
5580 }
5581
5582 /*
5583  * Progress Bar
5584  */
5585 static int progress_timer = 0;
5586
5587 gint
5588 progress_timeout (gpointer data)
5589 {
5590   gfloat new_val;
5591
5592   new_val = GTK_PROGRESS_BAR (data)->percentage;
5593   if (new_val >= 1.0)
5594     new_val = 0.0;
5595   new_val += 0.02;
5596
5597   gtk_progress_bar_update (GTK_PROGRESS_BAR (data), new_val);
5598
5599   return TRUE;
5600 }
5601
5602 static void
5603 destroy_progress (GtkWidget  *widget,
5604                   GtkWidget **window)
5605 {
5606   gtk_timeout_remove (progress_timer);
5607   progress_timer = 0;
5608   *window = NULL;
5609 }
5610
5611 void
5612 create_progress_bar (void)
5613 {
5614   static GtkWidget *window = NULL;
5615   GtkWidget *button;
5616   GtkWidget *vbox;
5617   GtkWidget *pbar;
5618   GtkWidget *label;
5619   GtkTooltips *tooltips;
5620
5621   if (!window)
5622     {
5623       window = gtk_dialog_new ();
5624
5625       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5626                           GTK_SIGNAL_FUNC(destroy_progress),
5627                           &window);
5628
5629       gtk_window_set_title (GTK_WINDOW (window), "dialog");
5630       gtk_container_border_width (GTK_CONTAINER (window), 0);
5631
5632       tooltips = gtk_tooltips_new();
5633
5634       vbox = gtk_vbox_new (FALSE, 5);
5635       gtk_container_border_width (GTK_CONTAINER (vbox), 10);
5636       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
5637                           vbox, TRUE, TRUE, 0);
5638       gtk_widget_show (vbox);
5639
5640       label = gtk_label_new ("progress...");
5641       gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
5642       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
5643       gtk_widget_show (label);
5644
5645       pbar = gtk_progress_bar_new ();
5646       gtk_widget_set_events (pbar, GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK);
5647       gtk_widget_set_usize (pbar, 200, 20);
5648       gtk_box_pack_start (GTK_BOX (vbox), pbar, TRUE, TRUE, 0);
5649       gtk_widget_show (pbar);
5650       gtk_tooltips_set_tip (tooltips, pbar, "Countdown is progressing yet!", "Secret!");
5651       gtk_tooltips_set_delay (tooltips, 0);
5652
5653       progress_timer = gtk_timeout_add (100, progress_timeout, pbar);
5654
5655       button = gtk_button_new_with_label ("close");
5656       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5657                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
5658                                  GTK_OBJECT (window));
5659       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5660       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5661                           button, TRUE, TRUE, 0);
5662       gtk_widget_grab_default (button);
5663       gtk_widget_show (button);
5664     }
5665
5666   if (!GTK_WIDGET_VISIBLE (window))
5667     gtk_widget_show (window);
5668   else
5669     gtk_widget_destroy (window);
5670 }
5671
5672
5673 /*
5674  * Color Preview
5675  */
5676 static int color_idle = 0;
5677
5678 gint
5679 color_idle_func (GtkWidget *preview)
5680 {
5681   static int count = 1;
5682   guchar buf[768];
5683   int i, j, k;
5684
5685   for (i = 0; i < 256; i++)
5686     {
5687       for (j = 0, k = 0; j < 256; j++)
5688         {
5689           buf[k+0] = i + count;
5690           buf[k+1] = 0;
5691           buf[k+2] = j + count;
5692           k += 3;
5693         }
5694
5695       gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
5696     }
5697
5698   count += 1;
5699
5700   gtk_widget_draw (preview, NULL);
5701
5702   return TRUE;
5703 }
5704
5705 static void
5706 color_preview_destroy (GtkWidget  *widget,
5707                        GtkWidget **window)
5708 {
5709   gtk_idle_remove (color_idle);
5710   color_idle = 0;
5711
5712   *window = NULL;
5713 }
5714
5715 void
5716 create_color_preview (void)
5717 {
5718   static GtkWidget *window = NULL;
5719   GtkWidget *preview;
5720   guchar buf[768];
5721   int i, j, k;
5722
5723   if (!window)
5724     {
5725       gtk_widget_push_visual (gtk_preview_get_visual ());
5726       gtk_widget_push_colormap (gtk_preview_get_cmap ());
5727
5728       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5729
5730       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5731                           GTK_SIGNAL_FUNC(color_preview_destroy),
5732                           &window);
5733
5734       gtk_window_set_title (GTK_WINDOW (window), "test");
5735       gtk_container_border_width (GTK_CONTAINER (window), 10);
5736
5737       preview = gtk_preview_new (GTK_PREVIEW_COLOR);
5738       gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
5739       gtk_container_add (GTK_CONTAINER (window), preview);
5740       gtk_widget_show (preview);
5741
5742       for (i = 0; i < 256; i++)
5743         {
5744           for (j = 0, k = 0; j < 256; j++)
5745             {
5746               buf[k+0] = i;
5747               buf[k+1] = 0;
5748               buf[k+2] = j;
5749               k += 3;
5750             }
5751
5752           gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
5753         }
5754
5755       color_idle = gtk_idle_add ((GtkFunction) color_idle_func, preview);
5756
5757       gtk_widget_pop_colormap ();
5758       gtk_widget_pop_visual ();
5759     }
5760
5761   if (!GTK_WIDGET_VISIBLE (window))
5762     gtk_widget_show (window);
5763   else
5764     gtk_widget_destroy (window);
5765 }
5766
5767
5768 /*
5769  * Gray Preview
5770  */
5771 static int gray_idle = 0;
5772
5773 gint
5774 gray_idle_func (GtkWidget *preview)
5775 {
5776   static int count = 1;
5777   guchar buf[256];
5778   int i, j;
5779
5780   for (i = 0; i < 256; i++)
5781     {
5782       for (j = 0; j < 256; j++)
5783         buf[j] = i + j + count;
5784
5785       gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
5786     }
5787
5788   count += 1;
5789
5790   gtk_widget_draw (preview, NULL);
5791
5792   return TRUE;
5793 }
5794
5795 static void
5796 gray_preview_destroy (GtkWidget  *widget,
5797                       GtkWidget **window)
5798 {
5799   gtk_idle_remove (gray_idle);
5800   gray_idle = 0;
5801
5802   *window = NULL;
5803 }
5804
5805 void
5806 create_gray_preview (void)
5807 {
5808   static GtkWidget *window = NULL;
5809   GtkWidget *preview;
5810   guchar buf[256];
5811   int i, j;
5812
5813   if (!window)
5814     {
5815       gtk_widget_push_visual (gtk_preview_get_visual ());
5816       gtk_widget_push_colormap (gtk_preview_get_cmap ());
5817
5818       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5819
5820       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5821                           GTK_SIGNAL_FUNC(gray_preview_destroy),
5822                           &window);
5823
5824       gtk_window_set_title (GTK_WINDOW (window), "test");
5825       gtk_container_border_width (GTK_CONTAINER (window), 10);
5826
5827       preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
5828       gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
5829       gtk_container_add (GTK_CONTAINER (window), preview);
5830       gtk_widget_show (preview);
5831
5832       for (i = 0; i < 256; i++)
5833         {
5834           for (j = 0; j < 256; j++)
5835             buf[j] = i + j;
5836
5837           gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
5838         }
5839
5840       gray_idle = gtk_idle_add ((GtkFunction) gray_idle_func, preview);
5841
5842       gtk_widget_pop_colormap ();
5843       gtk_widget_pop_visual ();
5844     }
5845
5846   if (!GTK_WIDGET_VISIBLE (window))
5847     gtk_widget_show (window);
5848   else
5849     gtk_widget_destroy (window);
5850 }
5851
5852
5853 /*
5854  * Selection Test
5855  */
5856 void
5857 selection_test_received (GtkWidget *list, GtkSelectionData *data)
5858 {
5859   GdkAtom *atoms;
5860   GtkWidget *list_item;
5861   GList *item_list;
5862   int i, l;
5863
5864   if (data->length < 0)
5865     {
5866       g_print ("Selection retrieval failed\n");
5867       return;
5868     }
5869   if (data->type != GDK_SELECTION_TYPE_ATOM)
5870     {
5871       g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
5872       return;
5873     }
5874
5875   /* Clear out any current list items */
5876
5877   gtk_list_clear_items (GTK_LIST(list), 0, -1);
5878
5879   /* Add new items to list */
5880
5881   atoms = (GdkAtom *)data->data;
5882
5883   item_list = NULL;
5884   l = data->length / sizeof (GdkAtom);
5885   for (i = 0; i < l; i++)
5886     {
5887       char *name;
5888       name = gdk_atom_name (atoms[i]);
5889       if (name != NULL)
5890         {
5891           list_item = gtk_list_item_new_with_label (name);
5892           g_free (name);
5893         }
5894       else
5895         list_item = gtk_list_item_new_with_label ("(bad atom)");
5896
5897       gtk_widget_show (list_item);
5898       item_list = g_list_append (item_list, list_item);
5899     }
5900
5901   gtk_list_append_items (GTK_LIST (list), item_list);
5902
5903   return;
5904 }
5905
5906 void
5907 selection_test_get_targets (GtkWidget *widget, GtkWidget *list)
5908 {
5909   static GdkAtom targets_atom = GDK_NONE;
5910
5911   if (targets_atom == GDK_NONE)
5912     targets_atom = gdk_atom_intern ("TARGETS", FALSE);
5913
5914   gtk_selection_convert (list, GDK_SELECTION_PRIMARY, targets_atom,
5915                          GDK_CURRENT_TIME);
5916 }
5917
5918 void
5919 create_selection_test (void)
5920 {
5921   static GtkWidget *window = NULL;
5922   GtkWidget *button;
5923   GtkWidget *vbox;
5924   GtkWidget *scrolled_win;
5925   GtkWidget *list;
5926   GtkWidget *label;
5927
5928   if (!window)
5929     {
5930       window = gtk_dialog_new ();
5931
5932       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5933                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5934                           &window);
5935
5936       gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
5937       gtk_container_border_width (GTK_CONTAINER (window), 0);
5938
5939       /* Create the list */
5940
5941       vbox = gtk_vbox_new (FALSE, 5);
5942       gtk_container_border_width (GTK_CONTAINER (vbox), 10);
5943       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox,
5944                           TRUE, TRUE, 0);
5945       gtk_widget_show (vbox);
5946
5947       label = gtk_label_new ("Gets available targets for current selection");
5948       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
5949       gtk_widget_show (label);
5950
5951       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
5952       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
5953                                       GTK_POLICY_AUTOMATIC,
5954                                       GTK_POLICY_AUTOMATIC);
5955       gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
5956       gtk_widget_set_usize (scrolled_win, 100, 200);
5957       gtk_widget_show (scrolled_win);
5958
5959       list = gtk_list_new ();
5960       gtk_container_add (GTK_CONTAINER (scrolled_win), list);
5961
5962       gtk_signal_connect (GTK_OBJECT(list), "selection_received",
5963                           GTK_SIGNAL_FUNC (selection_test_received), NULL);
5964       gtk_widget_show (list);
5965
5966       /* .. And create some buttons */
5967       button = gtk_button_new_with_label ("Get Targets");
5968       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5969                           button, TRUE, TRUE, 0);
5970
5971       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5972                           GTK_SIGNAL_FUNC (selection_test_get_targets), list);
5973       gtk_widget_show (button);
5974
5975       button = gtk_button_new_with_label ("Quit");
5976       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5977                           button, TRUE, TRUE, 0);
5978
5979       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5980                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
5981                                  GTK_OBJECT (window));
5982       gtk_widget_show (button);
5983     }
5984
5985   if (!GTK_WIDGET_VISIBLE (window))
5986     gtk_widget_show (window);
5987   else
5988     gtk_widget_destroy (window);
5989 }
5990
5991
5992 /*
5993  * Gamma Curve
5994  */
5995 void
5996 create_gamma_curve (void)
5997 {
5998   static GtkWidget *window = NULL, *curve;
5999   static int count = 0;
6000   gfloat vec[256];
6001   gint max;
6002   gint i;
6003
6004   if (!window)
6005     {
6006       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6007       gtk_window_set_title (GTK_WINDOW (window), "test");
6008       gtk_container_border_width (GTK_CONTAINER (window), 10);
6009
6010       gtk_signal_connect (GTK_OBJECT (window), "destroy",
6011                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6012                           &window);
6013
6014       curve = gtk_gamma_curve_new ();
6015       gtk_container_add (GTK_CONTAINER (window), curve);
6016       gtk_widget_show (curve);
6017     }
6018
6019   max = 127 + (count % 2)*128;
6020   gtk_curve_set_range (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
6021                        0, max, 0, max);
6022   for (i = 0; i < max; ++i)
6023     vec[i] = (127 / sqrt (max)) * sqrt (i);
6024   gtk_curve_set_vector (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
6025                         max, vec);
6026
6027   if (!GTK_WIDGET_VISIBLE (window))
6028     gtk_widget_show (window);
6029   else if (count % 4 == 3)
6030     {
6031       gtk_widget_destroy (window);
6032       window = NULL;
6033     }
6034
6035   ++count;
6036 }
6037
6038 static int scroll_test_pos = 0.0;
6039 static GdkGC *scroll_test_gc = NULL;
6040
6041 static gint
6042 scroll_test_expose (GtkWidget *widget, GdkEventExpose *event,
6043                     GtkAdjustment *adj)
6044 {
6045   gint i,j;
6046   gint imin, imax, jmin, jmax;
6047
6048   imin = (event->area.x) / 10;
6049   imax = (event->area.x + event->area.width + 9) / 10;
6050
6051   jmin = ((int)adj->value + event->area.y) / 10;
6052   jmax = ((int)adj->value + event->area.y + event->area.height + 9) / 10;
6053
6054   gdk_window_clear_area (widget->window,
6055                          event->area.x, event->area.y,
6056                          event->area.width, event->area.height);
6057
6058   for (i=imin; i<imax; i++)
6059     for (j=jmin; j<jmax; j++)
6060       if ((i+j) % 2)
6061         gdk_draw_rectangle (widget->window,
6062                             widget->style->black_gc,
6063                             TRUE,
6064                             10*i, 10*j - (int)adj->value, 1+i%10, 1+j%10);
6065
6066   return TRUE;
6067 }
6068
6069 static void
6070 scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
6071                        GtkAdjustment *adj)
6072 {
6073   adj->page_increment = 0.9 * widget->allocation.height;
6074   adj->page_size = widget->allocation.height;
6075
6076   gtk_signal_emit_by_name (GTK_OBJECT (adj), "changed");
6077 }
6078
6079 static void
6080 scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
6081 {
6082   gint source_min = (int)adj->value - scroll_test_pos;
6083   gint source_max = source_min + widget->allocation.height;
6084   gint dest_min = 0;
6085   gint dest_max = widget->allocation.height;
6086   GdkRectangle rect;
6087   GdkEvent *event;
6088
6089   scroll_test_pos = adj->value;
6090
6091   if (!GTK_WIDGET_DRAWABLE (widget))
6092     return;
6093
6094   if (source_min < 0)
6095     {
6096       rect.x = 0;
6097       rect.y = 0;
6098       rect.width = widget->allocation.width;
6099       rect.height = -source_min;
6100       if (rect.height > widget->allocation.height)
6101         rect.height = widget->allocation.height;
6102
6103       source_min = 0;
6104       dest_min = rect.height;
6105     }
6106   else
6107     {
6108       rect.x = 0;
6109       rect.y = 2*widget->allocation.height - source_max;
6110       if (rect.y < 0)
6111         rect.y = 0;
6112       rect.width = widget->allocation.width;
6113       rect.height = widget->allocation.height - rect.y;
6114
6115       source_max = widget->allocation.height;
6116       dest_max = rect.y;
6117     }
6118
6119   if (source_min != source_max)
6120     {
6121       if (scroll_test_gc == NULL)
6122         {
6123           scroll_test_gc = gdk_gc_new (widget->window);
6124           gdk_gc_set_exposures (scroll_test_gc, TRUE);
6125         }
6126
6127       gdk_draw_pixmap (widget->window,
6128                        scroll_test_gc,
6129                        widget->window,
6130                        0, source_min,
6131                        0, dest_min,
6132                        widget->allocation.width,
6133                        source_max - source_min);
6134
6135       /* Make sure graphics expose events are processed before scrolling
6136        * again */
6137
6138       while ((event = gdk_event_get_graphics_expose (widget->window)) != NULL)
6139         {
6140           gtk_widget_event (widget, event);
6141           if (event->expose.count == 0)
6142             {
6143               gdk_event_free (event);
6144               break;
6145             }
6146           gdk_event_free (event);
6147         }
6148     }
6149
6150
6151   if (rect.height != 0)
6152     gtk_widget_draw (widget, &rect);
6153 }
6154
6155
6156 void
6157 create_scroll_test (void)
6158 {
6159   static GtkWidget *window = NULL;
6160   GtkWidget *hbox;
6161   GtkWidget *drawing_area;
6162   GtkWidget *scrollbar;
6163   GtkWidget *button;
6164   GtkAdjustment *adj;
6165
6166   if (!window)
6167     {
6168       window = gtk_dialog_new ();
6169
6170       gtk_signal_connect (GTK_OBJECT (window), "destroy",
6171                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6172                           &window);
6173
6174       gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
6175       gtk_container_border_width (GTK_CONTAINER (window), 0);
6176
6177       hbox = gtk_hbox_new (FALSE, 0);
6178       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox,
6179                           TRUE, TRUE, 0);
6180       gtk_widget_show (hbox);
6181
6182       drawing_area = gtk_drawing_area_new ();
6183       gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 200, 200);
6184       gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
6185       gtk_widget_show (drawing_area);
6186
6187       gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK);
6188
6189       adj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0));
6190       scroll_test_pos = 0.0;
6191
6192       scrollbar = gtk_vscrollbar_new (adj);
6193       gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
6194       gtk_widget_show (scrollbar);
6195
6196       gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
6197                           GTK_SIGNAL_FUNC (scroll_test_expose), adj);
6198       gtk_signal_connect (GTK_OBJECT (drawing_area), "configure_event",
6199                           GTK_SIGNAL_FUNC (scroll_test_configure), adj);
6200
6201
6202       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6203                           GTK_SIGNAL_FUNC (scroll_test_adjustment_changed),
6204                           drawing_area);
6205
6206       /* .. And create some buttons */
6207
6208       button = gtk_button_new_with_label ("Quit");
6209       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6210                           button, TRUE, TRUE, 0);
6211
6212       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6213                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
6214                                  GTK_OBJECT (window));
6215       gtk_widget_show (button);
6216     }
6217
6218   if (!GTK_WIDGET_VISIBLE (window))
6219     gtk_widget_show (window);
6220   else
6221     gtk_widget_destroy (window);
6222 }
6223
6224 /*
6225  * Timeout Test
6226  */
6227 static int timer = 0;
6228
6229 gint
6230 timeout_test (GtkWidget *label)
6231 {
6232   static int count = 0;
6233   static char buffer[32];
6234
6235   sprintf (buffer, "count: %d", ++count);
6236   gtk_label_set (GTK_LABEL (label), buffer);
6237
6238   return TRUE;
6239 }
6240
6241 void
6242 start_timeout_test (GtkWidget *widget,
6243                     GtkWidget *label)
6244 {
6245   if (!timer)
6246     {
6247       timer = gtk_timeout_add (100, (GtkFunction) timeout_test, label);
6248     }
6249 }
6250
6251 void
6252 stop_timeout_test (GtkWidget *widget,
6253                    gpointer   data)
6254 {
6255   if (timer)
6256     {
6257       gtk_timeout_remove (timer);
6258       timer = 0;
6259     }
6260 }
6261
6262 void
6263 destroy_timeout_test (GtkWidget  *widget,
6264                       GtkWidget **window)
6265 {
6266   stop_timeout_test (NULL, NULL);
6267
6268   *window = NULL;
6269 }
6270
6271 void
6272 create_timeout_test (void)
6273 {
6274   static GtkWidget *window = NULL;
6275   GtkWidget *button;
6276   GtkWidget *label;
6277
6278   if (!window)
6279     {
6280       window = gtk_dialog_new ();
6281
6282       gtk_signal_connect (GTK_OBJECT (window), "destroy",
6283                           GTK_SIGNAL_FUNC(destroy_timeout_test),
6284                           &window);
6285
6286       gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
6287       gtk_container_border_width (GTK_CONTAINER (window), 0);
6288
6289       label = gtk_label_new ("count: 0");
6290       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
6291       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
6292                           label, TRUE, TRUE, 0);
6293       gtk_widget_show (label);
6294
6295       button = gtk_button_new_with_label ("close");
6296       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6297                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
6298                                  GTK_OBJECT (window));
6299       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6300       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6301                           button, TRUE, TRUE, 0);
6302       gtk_widget_grab_default (button);
6303       gtk_widget_show (button);
6304
6305       button = gtk_button_new_with_label ("start");
6306       gtk_signal_connect (GTK_OBJECT (button), "clicked",
6307                           GTK_SIGNAL_FUNC(start_timeout_test),
6308                           label);
6309       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6310       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6311                           button, TRUE, TRUE, 0);
6312       gtk_widget_show (button);
6313
6314       button = gtk_button_new_with_label ("stop");
6315       gtk_signal_connect (GTK_OBJECT (button), "clicked",
6316                           GTK_SIGNAL_FUNC(stop_timeout_test),
6317                           NULL);
6318       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6319       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6320                           button, TRUE, TRUE, 0);
6321       gtk_widget_show (button);
6322     }
6323
6324   if (!GTK_WIDGET_VISIBLE (window))
6325     gtk_widget_show (window);
6326   else
6327     gtk_widget_destroy (window);
6328 }
6329
6330
6331 /*
6332  * Idle Test
6333  */
6334 static int idle = 0;
6335
6336 gint
6337 idle_test (GtkWidget *label)
6338 {
6339   static int count = 0;
6340   static char buffer[32];
6341
6342   sprintf (buffer, "count: %d", ++count);
6343   gtk_label_set (GTK_LABEL (label), buffer);
6344
6345   return TRUE;
6346 }
6347
6348 void
6349 start_idle_test (GtkWidget *widget,
6350                  GtkWidget *label)
6351 {
6352   if (!idle)
6353     {
6354       idle = gtk_idle_add ((GtkFunction) idle_test, label);
6355     }
6356 }
6357
6358 void
6359 stop_idle_test (GtkWidget *widget,
6360                 gpointer   data)
6361 {
6362   if (idle)
6363     {
6364       gtk_idle_remove (idle);
6365       idle = 0;
6366     }
6367 }
6368
6369 void
6370 destroy_idle_test (GtkWidget  *widget,
6371                    GtkWidget **window)
6372 {
6373   stop_idle_test (NULL, NULL);
6374
6375   *window = NULL;
6376 }
6377
6378 void
6379 create_idle_test (void)
6380 {
6381   static GtkWidget *window = NULL;
6382   GtkWidget *button;
6383   GtkWidget *label;
6384
6385   if (!window)
6386     {
6387       window = gtk_dialog_new ();
6388
6389       gtk_signal_connect (GTK_OBJECT (window), "destroy",
6390                           GTK_SIGNAL_FUNC(destroy_idle_test),
6391                           &window);
6392
6393       gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
6394       gtk_container_border_width (GTK_CONTAINER (window), 0);
6395
6396       label = gtk_label_new ("count: 0");
6397       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
6398       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
6399                           label, TRUE, TRUE, 0);
6400       gtk_widget_show (label);
6401
6402       button = gtk_button_new_with_label ("close");
6403       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6404                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
6405                                  GTK_OBJECT (window));
6406       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6407       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6408                           button, TRUE, TRUE, 0);
6409       gtk_widget_grab_default (button);
6410       gtk_widget_show (button);
6411
6412       button = gtk_button_new_with_label ("start");
6413       gtk_signal_connect (GTK_OBJECT (button), "clicked",
6414                           GTK_SIGNAL_FUNC(start_idle_test),
6415                           label);
6416       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6417       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6418                           button, TRUE, TRUE, 0);
6419       gtk_widget_show (button);
6420
6421       button = gtk_button_new_with_label ("stop");
6422       gtk_signal_connect (GTK_OBJECT (button), "clicked",
6423                           GTK_SIGNAL_FUNC(stop_idle_test),
6424                           NULL);
6425       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6426       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6427                           button, TRUE, TRUE, 0);
6428       gtk_widget_show (button);
6429     }
6430
6431   if (!GTK_WIDGET_VISIBLE (window))
6432     gtk_widget_show (window);
6433   else
6434     gtk_widget_destroy (window);
6435 }
6436
6437 void
6438 reload_rc_file (void)
6439 {
6440   GList *toplevels;
6441
6442   if (gtk_rc_reparse_all ())
6443     {
6444       toplevels = gdk_window_get_toplevels();
6445       while (toplevels)
6446         {
6447           GtkWidget *widget;
6448           gdk_window_get_user_data (toplevels->data, (gpointer *)&widget);
6449
6450           if (widget)
6451             gtk_widget_reset_rc_styles (widget);
6452
6453           toplevels = toplevels->next;
6454         }
6455       g_list_free (toplevels);
6456     }
6457 }
6458
6459 void
6460 reload_all_rc_files (void)
6461 {
6462   static GdkAtom atom_rcfiles = GDK_NONE;
6463
6464   GdkEventClient sev;
6465   int i;
6466
6467   if (!atom_rcfiles)
6468     atom_rcfiles = gdk_atom_intern("_GTK_READ_RCFILES", FALSE);
6469
6470   for(i = 0; i < 5; i++)
6471     sev.data.l[i] = 0;
6472   sev.data_format = 32;
6473   sev.message_type = atom_rcfiles;
6474   gdk_event_send_clientmessage_toall ((GdkEvent *) &sev);
6475 }
6476
6477 void
6478 create_rc_file (void)
6479 {
6480   static GtkWidget *window = NULL;
6481   GtkWidget *button;
6482
6483   if (!window)
6484     {
6485       window = gtk_dialog_new ();
6486
6487       gtk_signal_connect (GTK_OBJECT (window), "destroy",
6488                           GTK_SIGNAL_FUNC(destroy_idle_test),
6489                           &window);
6490
6491       gtk_window_set_title (GTK_WINDOW (window), "Reload Rc file");
6492       gtk_container_border_width (GTK_CONTAINER (window), 0);
6493
6494       button = gtk_button_new_with_label ("Reload");
6495       gtk_signal_connect (GTK_OBJECT (button), "clicked",
6496                           GTK_SIGNAL_FUNC(reload_rc_file), NULL);
6497       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6498       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6499                           button, TRUE, TRUE, 0);
6500       gtk_widget_grab_default (button);
6501       gtk_widget_show (button);
6502
6503       button = gtk_button_new_with_label ("Reload All");
6504       gtk_signal_connect (GTK_OBJECT (button), "clicked",
6505                           GTK_SIGNAL_FUNC(reload_all_rc_files), NULL);
6506       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6507       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6508                           button, TRUE, TRUE, 0);
6509       gtk_widget_show (button);
6510
6511       button = gtk_button_new_with_label ("Close");
6512       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6513                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
6514                                  GTK_OBJECT (window));
6515       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6516       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6517                           button, TRUE, TRUE, 0);
6518       gtk_widget_show (button);
6519
6520     }
6521
6522   if (!GTK_WIDGET_VISIBLE (window))
6523     gtk_widget_show (window);
6524   else
6525     gtk_widget_destroy (window);
6526 }
6527
6528 /*
6529  * Test of recursive mainloop
6530  */
6531
6532 void
6533 mainloop_destroyed (GtkWidget *w, GtkWidget **window)
6534 {
6535   *window = NULL;
6536   gtk_main_quit ();
6537 }
6538
6539 void
6540 create_mainloop (void)
6541 {
6542   static GtkWidget *window = NULL;
6543   GtkWidget *label;
6544   GtkWidget *button;
6545
6546   if (!window)
6547     {
6548       window = gtk_dialog_new ();
6549
6550       gtk_window_set_title (GTK_WINDOW (window), "Test Main Loop");
6551
6552       gtk_signal_connect (GTK_OBJECT (window), "destroy",
6553                           GTK_SIGNAL_FUNC(mainloop_destroyed),
6554                           &window);
6555
6556       label = gtk_label_new ("In recursive main loop...");
6557       gtk_misc_set_padding (GTK_MISC(label), 20, 20);
6558
6559       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), label,
6560                           TRUE, TRUE, 0);
6561       gtk_widget_show (label);
6562
6563       button = gtk_button_new_with_label ("Leave");
6564       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button,
6565                           FALSE, TRUE, 0);
6566
6567       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6568                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
6569                                  GTK_OBJECT (window));
6570
6571       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6572       gtk_widget_grab_default (button);
6573
6574       gtk_widget_show (button);
6575     }
6576
6577   if (!GTK_WIDGET_VISIBLE (window))
6578     {
6579       gtk_widget_show (window);
6580
6581       g_print ("create_mainloop: start\n");
6582       gtk_main ();
6583       g_print ("create_mainloop: done\n");
6584     }
6585   else
6586     gtk_widget_destroy (window);
6587 }
6588
6589
6590 /*
6591  * Main Window and Exit
6592  */
6593 void
6594 do_exit (GtkWidget *widget, GtkWidget *window)
6595 {
6596   gtk_widget_destroy (window);
6597   gtk_main_quit ();
6598 }
6599
6600 void
6601 create_main_window (void)
6602 {
6603   struct {
6604     char *label;
6605     void (*func) ();
6606   } buttons[] =
6607     {
6608       { "button box", create_button_box },
6609       { "buttons", create_buttons },
6610       { "check buttons", create_check_buttons },
6611       { "clist", create_clist},
6612       { "color selection", create_color_selection },
6613       { "ctree", create_ctree },
6614       { "cursors", create_cursors },
6615       { "dialog", create_dialog },
6616       { "dnd", create_dnd },
6617       { "entry", create_entry },
6618       { "file selection", create_file_selection },
6619       { "gamma curve", create_gamma_curve },
6620       { "handle box", create_handle_box },
6621       { "list", create_list },
6622       { "menus", create_menus },
6623       { "miscellaneous", NULL },
6624       { "notebook", create_notebook },
6625       { "panes", create_panes },
6626       { "pixmap", create_pixmap },
6627       { "preview color", create_color_preview },
6628       { "preview gray", create_gray_preview },
6629       { "progress bar", create_progress_bar },
6630       { "radio buttons", create_radio_buttons },
6631       { "range controls", create_range_controls },
6632       { "rc file", create_rc_file },
6633       { "reparent", create_reparent },
6634       { "rulers", create_rulers },
6635       { "scrolled windows", create_scrolled_windows },
6636       { "shapes", create_shapes },
6637       { "spinbutton", create_spins },
6638       { "statusbar", create_statusbar },
6639       { "test idle", create_idle_test },
6640       { "test mainloop", create_mainloop },
6641       { "test scrolling", create_scroll_test },
6642       { "test selection", create_selection_test },
6643       { "test timeout", create_timeout_test },
6644       { "text", create_text },
6645       { "toggle buttons", create_toggle_buttons },
6646       { "toolbar", create_toolbar },
6647       { "tooltips", create_tooltips },
6648       { "tree", create_tree_mode_window},
6649       { "WM hints", create_wmhints },
6650     };
6651   int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
6652   GtkWidget *window;
6653   GtkWidget *box1;
6654   GtkWidget *box2;
6655   GtkWidget *scrolled_window;
6656   GtkWidget *button;
6657   GtkWidget *label;
6658   gchar buffer[64];
6659   GtkWidget *separator;
6660   int i;
6661
6662   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6663   gtk_window_set_policy (GTK_WINDOW (window), FALSE, FALSE, FALSE);
6664   gtk_widget_set_name (window, "main window");
6665   gtk_widget_set_usize (window, 200, 400);
6666   gtk_widget_set_uposition (window, 20, 20);
6667
6668   gtk_signal_connect (GTK_OBJECT (window), "destroy",
6669                       GTK_SIGNAL_FUNC(gtk_main_quit),
6670                       NULL);
6671   gtk_signal_connect (GTK_OBJECT (window), "delete-event",
6672                       GTK_SIGNAL_FUNC (gtk_false),
6673                       NULL);
6674
6675   box1 = gtk_vbox_new (FALSE, 0);
6676   gtk_container_add (GTK_CONTAINER (window), box1);
6677   gtk_widget_show (box1);
6678
6679   if (gtk_micro_version > 0)
6680     sprintf (buffer,
6681              "Gtk+ v%d.%d.%d",
6682              gtk_major_version,
6683              gtk_minor_version,
6684              gtk_micro_version);
6685   else
6686     sprintf (buffer,
6687              "Gtk+ v%d.%d",
6688              gtk_major_version,
6689              gtk_minor_version);
6690
6691   label = gtk_label_new (buffer);
6692   gtk_widget_show (label);
6693   gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
6694
6695   scrolled_window = gtk_scrolled_window_new (NULL, NULL);
6696   gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
6697   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
6698                                   GTK_POLICY_AUTOMATIC,
6699                                   GTK_POLICY_AUTOMATIC);
6700   GTK_WIDGET_UNSET_FLAGS (GTK_SCROLLED_WINDOW (scrolled_window)->vscrollbar, GTK_CAN_FOCUS);
6701   gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
6702   gtk_widget_show (scrolled_window);
6703
6704   box2 = gtk_vbox_new (FALSE, 0);
6705   gtk_container_border_width (GTK_CONTAINER (box2), 10);
6706   gtk_container_add (GTK_CONTAINER (scrolled_window), box2);
6707   gtk_container_set_focus_vadjustment (GTK_CONTAINER (box2),
6708                                        gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
6709   gtk_widget_show (box2);
6710
6711   for (i = 0; i < nbuttons; i++)
6712     {
6713       button = gtk_button_new_with_label (buttons[i].label);
6714       if (buttons[i].func)
6715         gtk_signal_connect (GTK_OBJECT (button),
6716                             "clicked",
6717                             GTK_SIGNAL_FUNC(buttons[i].func),
6718                             NULL);
6719       else
6720         gtk_widget_set_sensitive (button, FALSE);
6721       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6722       gtk_widget_show (button);
6723     }
6724
6725   separator = gtk_hseparator_new ();
6726   gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
6727   gtk_widget_show (separator);
6728
6729   box2 = gtk_vbox_new (FALSE, 10);
6730   gtk_container_border_width (GTK_CONTAINER (box2), 10);
6731   gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6732   gtk_widget_show (box2);
6733
6734   button = gtk_button_new_with_label ("close");
6735   gtk_signal_connect (GTK_OBJECT (button), "clicked",
6736                       GTK_SIGNAL_FUNC (do_exit),
6737                       window);
6738   gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6739   GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6740   gtk_widget_grab_default (button);
6741   gtk_widget_show (button);
6742
6743   gtk_widget_show (window);
6744 }
6745
6746 int
6747 main (int argc, char *argv[])
6748 {
6749   gtk_set_locale ();
6750
6751   gtk_init (&argc, &argv);
6752
6753 #ifdef HAVE_LIBGLE
6754   gle_init (&argc, &argv);
6755 #endif /* !HAVE_LIBGLE */
6756
6757   gtk_rc_parse ("testgtkrc");
6758
6759   create_main_window ();
6760
6761   gtk_main ();
6762
6763   return 0;
6764 }