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 #undef  G_LOG_DOMAIN
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <math.h>
  25 #include <time.h>
  26 #include "gtk.h"
  27 #include "../gdk/gdk.h"
  28 #include "../gdk/gdkx.h"
  29 #include "../gdk/gdkkeysyms.h"
  30
  31 #include "circles.xbm"
  32
  33 typedef struct _OptionMenuItem
  34 {
  35   gchar        *name;
  36   GtkSignalFunc func;
  37 } OptionMenuItem;
  38
  39 GtkWidget *
  40 shape_create_icon (char     *xpm_file,
  41                    gint      x,
  42                    gint      y,
  43                    gint      px,
  44                    gint      py,
  45                    gint      window_type);
  46
  47 static GtkWidget *
  48 build_option_menu (OptionMenuItem items[],
  49                    gint           num_items,
  50                    gint           history,
  51                    gpointer       data);
  52
  53 /* macro, structure and variables used by tree window demos */
  54 #define DEFAULT_NUMBER_OF_ITEM  3
  55 #define DEFAULT_RECURSION_LEVEL 3
  56
  57 struct {
  58   GSList* selection_mode_group;
  59   GtkWidget* single_button;
  60   GtkWidget* browse_button;
  61   GtkWidget* multiple_button;
  62   GtkWidget* draw_line_button;
  63   GtkWidget* view_line_button;
  64   GtkWidget* no_root_item_button;
  65   GtkWidget* nb_item_spinner;
  66   GtkWidget* recursion_spinner;
  67 } sTreeSampleSelection;
  68
  69 typedef struct sTreeButtons {
  70   guint nb_item_add;
  71   GtkWidget* add_button;
  72   GtkWidget* remove_button;
  73   GtkWidget* subtree_button;
  74 } sTreeButtons;
  75 /* end of tree section */
  76
  77 static GtkWidget *
  78 build_option_menu (OptionMenuItem items[],
  79                    gint           num_items,
  80                    gint           history,
  81                    gpointer       data)
  82 {
  83   GtkWidget *omenu;
  84   GtkWidget *menu;
  85   GtkWidget *menu_item;
  86   GSList *group;
  87   gint i;
  88
  89   omenu = gtk_option_menu_new ();
  90
  91   menu = gtk_menu_new ();
  92   group = NULL;
  93
  94   for (i = 0; i < num_items; i++)
  95     {
  96       menu_item = gtk_radio_menu_item_new_with_label (group, items[i].name);
  97       gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
  98                           (GtkSignalFunc) items[i].func, data);
  99       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
 100       gtk_menu_append (GTK_MENU (menu), menu_item);
 101       if (i == history)
 102         gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
 103       gtk_widget_show (menu_item);
 104     }
 105
 106   gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
 107   gtk_option_menu_set_history (GTK_OPTION_MENU (omenu), history);
 108
 109   return omenu;
 110 }
 111
 112 static void
 113 destroy_tooltips (GtkWidget *widget, GtkWindow **window)
 114 {
 115   GtkTooltips *tt = gtk_object_get_data (GTK_OBJECT (*window), "tooltips");
 116   gtk_object_unref (GTK_OBJECT (tt));
 117   *window = NULL;
 118 }
 119
 120 /*
 121  * GtkButton
 122  */
 123
 124 static void
 125 button_window (GtkWidget *widget,
 126                GtkWidget *button)
 127 {
 128   if (!GTK_WIDGET_VISIBLE (button))
 129     gtk_widget_show (button);
 130   else
 131     gtk_widget_hide (button);
 132 }
 133
 134 static void
 135 create_buttons (void)
 136 {
 137   static GtkWidget *window = NULL;
 138   GtkWidget *box1;
 139   GtkWidget *box2;
 140   GtkWidget *table;
 141   GtkWidget *button[10];
 142   GtkWidget *separator;
 143
 144   if (!window)
 145     {
 146       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 147
 148       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 149                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
 150                           &window);
 151
 152       gtk_window_set_title (GTK_WINDOW (window), "GtkButton");
 153       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
 154
 155       box1 = gtk_vbox_new (FALSE, 0);
 156       gtk_container_add (GTK_CONTAINER (window), box1);
 157
 158       table = gtk_table_new (3, 3, FALSE);
 159       gtk_table_set_row_spacings (GTK_TABLE (table), 5);
 160       gtk_table_set_col_spacings (GTK_TABLE (table), 5);
 161       gtk_container_set_border_width (GTK_CONTAINER (table), 10);
 162       gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
 163
 164       button[0] = gtk_button_new_with_label ("button1");
 165       button[1] = gtk_button_new_with_label ("button2");
 166       button[2] = gtk_button_new_with_label ("button3");
 167       button[3] = gtk_button_new_with_label ("button4");
 168       button[4] = gtk_button_new_with_label ("button5");
 169       button[5] = gtk_button_new_with_label ("button6");
 170       button[6] = gtk_button_new_with_label ("button7");
 171       button[7] = gtk_button_new_with_label ("button8");
 172       button[8] = gtk_button_new_with_label ("button9");
 173
 174       gtk_signal_connect (GTK_OBJECT (button[0]), "clicked",
 175                           GTK_SIGNAL_FUNC(button_window),
 176                           button[1]);
 177
 178       gtk_table_attach (GTK_TABLE (table), button[0], 0, 1, 0, 1,
 179                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 180
 181       gtk_signal_connect (GTK_OBJECT (button[1]), "clicked",
 182                           GTK_SIGNAL_FUNC(button_window),
 183                           button[2]);
 184
 185       gtk_table_attach (GTK_TABLE (table), button[1], 1, 2, 1, 2,
 186                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 187
 188       gtk_signal_connect (GTK_OBJECT (button[2]), "clicked",
 189                           GTK_SIGNAL_FUNC(button_window),
 190                           button[3]);
 191       gtk_table_attach (GTK_TABLE (table), button[2], 2, 3, 2, 3,
 192                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 193
 194       gtk_signal_connect (GTK_OBJECT (button[3]), "clicked",
 195                           GTK_SIGNAL_FUNC(button_window),
 196                           button[4]);
 197       gtk_table_attach (GTK_TABLE (table), button[3], 0, 1, 2, 3,
 198                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 199
 200       gtk_signal_connect (GTK_OBJECT (button[4]), "clicked",
 201                           GTK_SIGNAL_FUNC(button_window),
 202                           button[5]);
 203       gtk_table_attach (GTK_TABLE (table), button[4], 2, 3, 0, 1,
 204                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 205
 206       gtk_signal_connect (GTK_OBJECT (button[5]), "clicked",
 207                           GTK_SIGNAL_FUNC(button_window),
 208                           button[6]);
 209       gtk_table_attach (GTK_TABLE (table), button[5], 1, 2, 2, 3,
 210                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 211
 212       gtk_signal_connect (GTK_OBJECT (button[6]), "clicked",
 213                           GTK_SIGNAL_FUNC(button_window),
 214                           button[7]);
 215       gtk_table_attach (GTK_TABLE (table), button[6], 1, 2, 0, 1,
 216                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 217
 218       gtk_signal_connect (GTK_OBJECT (button[7]), "clicked",
 219                           GTK_SIGNAL_FUNC(button_window),
 220                           button[8]);
 221       gtk_table_attach (GTK_TABLE (table), button[7], 2, 3, 1, 2,
 222                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 223
 224       gtk_signal_connect (GTK_OBJECT (button[8]), "clicked",
 225                           GTK_SIGNAL_FUNC(button_window),
 226                           button[0]);
 227       gtk_table_attach (GTK_TABLE (table), button[8], 0, 1, 1, 2,
 228                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 229
 230       separator = gtk_hseparator_new ();
 231       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 232
 233       box2 = gtk_vbox_new (FALSE, 10);
 234       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
 235       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 236
 237       button[9] = gtk_button_new_with_label ("close");
 238       gtk_signal_connect_object (GTK_OBJECT (button[9]), "clicked",
 239                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
 240                                  GTK_OBJECT (window));
 241       gtk_box_pack_start (GTK_BOX (box2), button[9], TRUE, TRUE, 0);
 242       GTK_WIDGET_SET_FLAGS (button[9], GTK_CAN_DEFAULT);
 243       gtk_widget_grab_default (button[9]);
 244     }
 245
 246   if (!GTK_WIDGET_VISIBLE (window))
 247     gtk_widget_show_all (window);
 248   else
 249     gtk_widget_destroy (window);
 250 }
 251
 252 /*
 253  * GtkToggleButton
 254  */
 255
 256 static void
 257 create_toggle_buttons (void)
 258 {
 259   static GtkWidget *window = NULL;
 260   GtkWidget *box1;
 261   GtkWidget *box2;
 262   GtkWidget *button;
 263   GtkWidget *separator;
 264
 265   if (!window)
 266     {
 267       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 268
 269       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 270                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
 271                           &window);
 272
 273       gtk_window_set_title (GTK_WINDOW (window), "GtkToggleButton");
 274       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
 275
 276       box1 = gtk_vbox_new (FALSE, 0);
 277       gtk_container_add (GTK_CONTAINER (window), box1);
 278
 279       box2 = gtk_vbox_new (FALSE, 10);
 280       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
 281       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
 282
 283       button = gtk_toggle_button_new_with_label ("button1");
 284       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 285
 286       button = gtk_toggle_button_new_with_label ("button2");
 287       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 288
 289       button = gtk_toggle_button_new_with_label ("button3");
 290       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 291
 292       separator = gtk_hseparator_new ();
 293       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 294
 295       box2 = gtk_vbox_new (FALSE, 10);
 296       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
 297       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 298
 299       button = gtk_button_new_with_label ("close");
 300       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
 301                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
 302                                  GTK_OBJECT (window));
 303       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 304       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 305       gtk_widget_grab_default (button);
 306     }
 307
 308   if (!GTK_WIDGET_VISIBLE (window))
 309     gtk_widget_show_all (window);
 310   else
 311     gtk_widget_destroy (window);
 312 }
 313
 314 /*
 315  * GtkCheckButton
 316  */
 317
 318 static void
 319 create_check_buttons (void)
 320 {
 321   static GtkWidget *window = NULL;
 322   GtkWidget *box1;
 323   GtkWidget *box2;
 324   GtkWidget *button;
 325   GtkWidget *separator;
 326
 327   if (!window)
 328     {
 329       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 330
 331       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 332                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
 333                           &window);
 334
 335       gtk_window_set_title (GTK_WINDOW (window), "GtkCheckButton");
 336       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
 337
 338       box1 = gtk_vbox_new (FALSE, 0);
 339       gtk_container_add (GTK_CONTAINER (window), box1);
 340
 341       box2 = gtk_vbox_new (FALSE, 10);
 342       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
 343       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
 344
 345       button = gtk_check_button_new_with_label ("button1");
 346       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 347
 348       button = gtk_check_button_new_with_label ("button2");
 349       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 350
 351       button = gtk_check_button_new_with_label ("button3");
 352       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 353
 354       separator = gtk_hseparator_new ();
 355       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 356
 357       box2 = gtk_vbox_new (FALSE, 10);
 358       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
 359       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 360
 361       button = gtk_button_new_with_label ("close");
 362       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
 363                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
 364                                  GTK_OBJECT (window));
 365       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 366       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 367       gtk_widget_grab_default (button);
 368     }
 369
 370   if (!GTK_WIDGET_VISIBLE (window))
 371     gtk_widget_show_all (window);
 372   else
 373     gtk_widget_destroy (window);
 374 }
 375
 376 /*
 377  * GtkRadioButton
 378  */
 379
 380 static void
 381 create_radio_buttons (void)
 382 {
 383   static GtkWidget *window = NULL;
 384   GtkWidget *box1;
 385   GtkWidget *box2;
 386   GtkWidget *button;
 387   GtkWidget *separator;
 388
 389   if (!window)
 390     {
 391       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 392
 393       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 394                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
 395                           &window);
 396
 397       gtk_window_set_title (GTK_WINDOW (window), "radio buttons");
 398       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
 399
 400       box1 = gtk_vbox_new (FALSE, 0);
 401       gtk_container_add (GTK_CONTAINER (window), box1);
 402
 403       box2 = gtk_vbox_new (FALSE, 10);
 404       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
 405       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
 406
 407       button = gtk_radio_button_new_with_label (NULL, "button1");
 408       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 409
 410       button = gtk_radio_button_new_with_label (
 411                  gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
 412                  "button2");
 413       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
 414       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 415
 416       button = gtk_radio_button_new_with_label (
 417                  gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
 418                  "button3");
 419       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 420
 421       separator = gtk_hseparator_new ();
 422       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 423
 424       box2 = gtk_vbox_new (FALSE, 10);
 425       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
 426       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 427
 428       button = gtk_button_new_with_label ("close");
 429       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
 430                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
 431                                  GTK_OBJECT (window));
 432       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 433       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 434       gtk_widget_grab_default (button);
 435     }
 436
 437   if (!GTK_WIDGET_VISIBLE (window))
 438     gtk_widget_show_all (window);
 439   else
 440     gtk_widget_destroy (window);
 441 }
 442
 443 /*
 444  * GtkButtonBox
 445  */
 446
 447 static GtkWidget *
 448 create_bbox (gint  horizontal,
 449              char* title,
 450              gint  spacing,
 451              gint  child_w,
 452              gint  child_h,
 453              gint  layout)
 454 {
 455   GtkWidget *frame;
 456   GtkWidget *bbox;
 457   GtkWidget *button;
 458
 459   frame = gtk_frame_new (title);
 460
 461   if (horizontal)
 462     bbox = gtk_hbutton_box_new ();
 463   else
 464     bbox = gtk_vbutton_box_new ();
 465
 466   gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
 467   gtk_container_add (GTK_CONTAINER (frame), bbox);
 468
 469   gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), layout);
 470   gtk_button_box_set_spacing (GTK_BUTTON_BOX (bbox), spacing);
 471   gtk_button_box_set_child_size (GTK_BUTTON_BOX (bbox), child_w, child_h);
 472
 473   button = gtk_button_new_with_label ("OK");
 474   gtk_container_add (GTK_CONTAINER (bbox), button);
 475
 476   button = gtk_button_new_with_label ("Cancel");
 477   gtk_container_add (GTK_CONTAINER (bbox), button);
 478
 479   button = gtk_button_new_with_label ("Help");
 480   gtk_container_add (GTK_CONTAINER (bbox), button);
 481
 482   return frame;
 483 }
 484
 485 static void
 486 create_button_box (void)
 487 {
 488   static GtkWidget* window = NULL;
 489   GtkWidget *main_vbox;
 490   GtkWidget *vbox;
 491   GtkWidget *hbox;
 492   GtkWidget *frame_horz;
 493   GtkWidget *frame_vert;
 494
 495   if (!window)
 496   {
 497     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 498     gtk_window_set_title (GTK_WINDOW (window), "Button Boxes");
 499
 500     gtk_signal_connect (GTK_OBJECT (window), "destroy",
 501                         GTK_SIGNAL_FUNC(gtk_widget_destroyed),
 502                         &window);
 503
 504     gtk_container_set_border_width (GTK_CONTAINER (window), 10);
 505
 506     main_vbox = gtk_vbox_new (FALSE, 0);
 507     gtk_container_add (GTK_CONTAINER (window), main_vbox);
 508
 509     frame_horz = gtk_frame_new ("Horizontal Button Boxes");
 510     gtk_box_pack_start (GTK_BOX (main_vbox), frame_horz, TRUE, TRUE, 10);
 511
 512     vbox = gtk_vbox_new (FALSE, 0);
 513     gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
 514     gtk_container_add (GTK_CONTAINER (frame_horz), vbox);
 515
 516     gtk_box_pack_start (GTK_BOX (vbox),
 517            create_bbox (TRUE, "Spread", 40, 85, 20, GTK_BUTTONBOX_SPREAD),
 518                         TRUE, TRUE, 0);
 519
 520     gtk_box_pack_start (GTK_BOX (vbox),
 521            create_bbox (TRUE, "Edge", 40, 85, 20, GTK_BUTTONBOX_EDGE),
 522                         TRUE, TRUE, 5);
 523
 524     gtk_box_pack_start (GTK_BOX (vbox),
 525            create_bbox (TRUE, "Start", 40, 85, 20, GTK_BUTTONBOX_START),
 526                         TRUE, TRUE, 5);
 527
 528     gtk_box_pack_start (GTK_BOX (vbox),
 529            create_bbox (TRUE, "End", 40, 85, 20, GTK_BUTTONBOX_END),
 530                         TRUE, TRUE, 5);
 531
 532     frame_vert = gtk_frame_new ("Vertical Button Boxes");
 533     gtk_box_pack_start (GTK_BOX (main_vbox), frame_vert, TRUE, TRUE, 10);
 534
 535     hbox = gtk_hbox_new (FALSE, 0);
 536     gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
 537     gtk_container_add (GTK_CONTAINER (frame_vert), hbox);
 538
 539     gtk_box_pack_start (GTK_BOX (hbox),
 540            create_bbox (FALSE, "Spread", 30, 85, 20, GTK_BUTTONBOX_SPREAD),
 541                         TRUE, TRUE, 0);
 542
 543     gtk_box_pack_start (GTK_BOX (hbox),
 544            create_bbox (FALSE, "Edge", 30, 85, 20, GTK_BUTTONBOX_EDGE),
 545                         TRUE, TRUE, 5);
 546
 547     gtk_box_pack_start (GTK_BOX (hbox),
 548            create_bbox (FALSE, "Start", 30, 85, 20, GTK_BUTTONBOX_START),
 549                         TRUE, TRUE, 5);
 550
 551     gtk_box_pack_start (GTK_BOX (hbox),
 552            create_bbox (FALSE, "End", 30, 85, 20, GTK_BUTTONBOX_END),
 553                         TRUE, TRUE, 5);
 554   }
 555
 556   if (!GTK_WIDGET_VISIBLE (window))
 557     gtk_widget_show_all (window);
 558   else
 559     gtk_widget_destroy (window);
 560 }
 561
 562 /*
 563  * GtkToolBar
 564  */
 565
 566 static GtkWidget*
 567 new_pixmap (char      *filename,
 568             GdkWindow *window,
 569             GdkColor  *background)
 570 {
 571   GtkWidget *wpixmap;
 572   GdkPixmap *pixmap;
 573   GdkBitmap *mask;
 574
 575   pixmap = gdk_pixmap_create_from_xpm (window, &mask,
 576                                        background,
 577                                        filename);
 578   wpixmap = gtk_pixmap_new (pixmap, mask);
 579
 580   return wpixmap;
 581 }
 582
 583 static void
 584 set_toolbar_horizontal (GtkWidget *widget,
 585                         gpointer   data)
 586 {
 587   gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_HORIZONTAL);
 588 }
 589
 590 static void
 591 set_toolbar_vertical (GtkWidget *widget,
 592                       gpointer   data)
 593 {
 594   gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_VERTICAL);
 595 }
 596
 597 static void
 598 set_toolbar_icons (GtkWidget *widget,
 599                    gpointer   data)
 600 {
 601   gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_ICONS);
 602 }
 603
 604 static void
 605 set_toolbar_text (GtkWidget *widget,
 606                   gpointer   data)
 607 {
 608   gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_TEXT);
 609 }
 610
 611 static void
 612 set_toolbar_both (GtkWidget *widget,
 613                   gpointer   data)
 614 {
 615   gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH);
 616 }
 617
 618 static void
 619 set_toolbar_small_space (GtkWidget *widget,
 620                          gpointer   data)
 621 {
 622   gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 5);
 623 }
 624
 625 static void
 626 set_toolbar_big_space (GtkWidget *widget,
 627                        gpointer   data)
 628 {
 629   gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 10);
 630 }
 631
 632 static void
 633 set_toolbar_enable (GtkWidget *widget,
 634                     gpointer   data)
 635 {
 636   gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), TRUE);
 637 }
 638
 639 static void
 640 set_toolbar_disable (GtkWidget *widget,
 641                      gpointer   data)
 642 {
 643   gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), FALSE);
 644 }
 645
 646 static void
 647 set_toolbar_borders (GtkWidget *widget,
 648                      gpointer   data)
 649 {
 650   gtk_toolbar_set_button_relief (GTK_TOOLBAR (data), GTK_RELIEF_NORMAL);
 651 }
 652
 653 static void
 654 set_toolbar_borderless (GtkWidget *widget,
 655                         gpointer   data)
 656 {
 657   gtk_toolbar_set_button_relief (GTK_TOOLBAR (data), GTK_RELIEF_NONE);
 658 }
 659
 660 static void
 661 set_toolbar_space_style_empty (GtkWidget *widget,
 662                                gpointer   data)
 663 {
 664   gtk_toolbar_set_space_style (GTK_TOOLBAR (data), GTK_TOOLBAR_SPACE_EMPTY);
 665 }
 666
 667 static void
 668 set_toolbar_space_style_line (GtkWidget *widget,
 669                               gpointer   data)
 670 {
 671   gtk_toolbar_set_space_style (GTK_TOOLBAR (data), GTK_TOOLBAR_SPACE_LINE);
 672 }
 673
 674 static void
 675 create_toolbar (void)
 676 {
 677   static GtkWidget *window = NULL;
 678   GtkWidget *toolbar;
 679   GtkWidget *entry;
 680
 681   if (!window)
 682     {
 683       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 684       gtk_window_set_title (GTK_WINDOW (window), "Toolbar test");
 685       gtk_window_set_policy (GTK_WINDOW (window), FALSE, TRUE, TRUE);
 686
 687       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 688                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
 689                           &window);
 690
 691       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
 692       gtk_widget_realize (window);
 693
 694       toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
 695       gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NONE);
 696
 697       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 698                                "Horizontal", "Horizontal toolbar layout", "Toolbar/Horizontal",
 699                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 700                                (GtkSignalFunc) set_toolbar_horizontal, toolbar);
 701       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 702                                "Vertical", "Vertical toolbar layout", "Toolbar/Vertical",
 703                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 704                                (GtkSignalFunc) set_toolbar_vertical, toolbar);
 705
 706       gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
 707
 708       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 709                                "Icons", "Only show toolbar icons", "Toolbar/IconsOnly",
 710                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 711                                (GtkSignalFunc) set_toolbar_icons, toolbar);
 712       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 713                                "Text", "Only show toolbar text", "Toolbar/TextOnly",
 714                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 715                                (GtkSignalFunc) set_toolbar_text, toolbar);
 716       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 717                                "Both", "Show toolbar icons and text", "Toolbar/Both",
 718                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 719                                (GtkSignalFunc) set_toolbar_both, toolbar);
 720
 721       gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 722
 723       entry = gtk_entry_new ();
 724
 725       gtk_toolbar_append_widget (GTK_TOOLBAR (toolbar), entry, "This is an unusable GtkEntry ;)", "Hey don't click me!!!");
 726
 727       gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 728
 729       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 730                                "Small", "Use small spaces", "Toolbar/Small",
 731                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 732                                (GtkSignalFunc) set_toolbar_small_space, toolbar);
 733       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 734                                "Big", "Use big spaces", "Toolbar/Big",
 735                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 736                                (GtkSignalFunc) set_toolbar_big_space, toolbar);
 737
 738       gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 739
 740       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 741                                "Enable", "Enable tooltips", NULL,
 742                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 743                                (GtkSignalFunc) set_toolbar_enable, toolbar);
 744       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 745                                "Disable", "Disable tooltips", NULL,
 746                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 747                                (GtkSignalFunc) set_toolbar_disable, toolbar);
 748
 749       gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 750
 751       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 752                                "Borders", "Show Borders", NULL,
 753                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 754                                (GtkSignalFunc) set_toolbar_borders, toolbar);
 755       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 756                                "Borderless", "Hide Borders", NULL,
 757                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 758                                (GtkSignalFunc) set_toolbar_borderless, toolbar);
 759
 760       gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 761
 762       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 763                                "Empty", "Empty spaces", NULL,
 764                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 765                                (GtkSignalFunc) set_toolbar_space_style_empty, toolbar);
 766       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 767                                "Lines", "Lines in spaces", NULL,
 768                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 769                                (GtkSignalFunc) set_toolbar_space_style_line, toolbar);
 770
 771       gtk_container_add (GTK_CONTAINER (window), toolbar);
 772     }
 773
 774   if (!GTK_WIDGET_VISIBLE (window))
 775     gtk_widget_show_all (window);
 776   else
 777     gtk_widget_destroy (window);
 778 }
 779
 780 static GtkWidget*
 781 make_toolbar (GtkWidget *window)
 782 {
 783   GtkWidget *toolbar;
 784
 785   if (!GTK_WIDGET_REALIZED (window))
 786     gtk_widget_realize (window);
 787
 788   toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
 789   gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NONE);
 790
 791   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 792                            "Horizontal", "Horizontal toolbar layout", NULL,
 793                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 794                            (GtkSignalFunc) set_toolbar_horizontal, toolbar);
 795   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 796                            "Vertical", "Vertical toolbar layout", NULL,
 797                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 798                            (GtkSignalFunc) set_toolbar_vertical, toolbar);
 799
 800   gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
 801
 802   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 803                            "Icons", "Only show toolbar icons", NULL,
 804                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 805                            (GtkSignalFunc) set_toolbar_icons, toolbar);
 806   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 807                            "Text", "Only show toolbar text", NULL,
 808                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 809                            (GtkSignalFunc) set_toolbar_text, toolbar);
 810   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 811                            "Both", "Show toolbar icons and text", NULL,
 812                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 813                            (GtkSignalFunc) set_toolbar_both, toolbar);
 814
 815   gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 816
 817   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 818                            "Small", "Use small spaces", NULL,
 819                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 820                            (GtkSignalFunc) set_toolbar_small_space, toolbar);
 821   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 822                            "Big", "Use big spaces", "Toolbar/Big",
 823                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 824                            (GtkSignalFunc) set_toolbar_big_space, toolbar);
 825
 826   gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 827
 828   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 829                            "Enable", "Enable tooltips", NULL,
 830                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 831                            (GtkSignalFunc) set_toolbar_enable, toolbar);
 832   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 833                            "Disable", "Disable tooltips", NULL,
 834                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 835                            (GtkSignalFunc) set_toolbar_disable, toolbar);
 836
 837   gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 838
 839   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 840                            "Borders", "Show Borders", NULL,
 841                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 842                            (GtkSignalFunc) set_toolbar_borders, toolbar);
 843   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 844                            "Borderless", "Hide Borders", NULL,
 845                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 846                            (GtkSignalFunc) set_toolbar_borderless, toolbar);
 847
 848   return toolbar;
 849 }
 850
 851 /*
 852  * GtkStatusBar
 853  */
 854
 855 static guint statusbar_counter = 1;
 856
 857 static void
 858 statusbar_push (GtkWidget *button,
 859                 GtkStatusbar *statusbar)
 860 {
 861   gchar text[1024];
 862
 863   sprintf (text, "something %d", statusbar_counter++);
 864
 865   gtk_statusbar_push (statusbar, 1, text);
 866 }
 867
 868 static void
 869 statusbar_pop (GtkWidget *button,
 870                GtkStatusbar *statusbar)
 871 {
 872   gtk_statusbar_pop (statusbar, 1);
 873 }
 874
 875 static void
 876 statusbar_steal (GtkWidget *button,
 877                  GtkStatusbar *statusbar)
 878 {
 879   gtk_statusbar_remove (statusbar, 1, 4);
 880 }
 881
 882 static void
 883 statusbar_popped (GtkStatusbar  *statusbar,
 884                   guint          context_id,
 885                   const gchar   *text)
 886 {
 887   if (!statusbar->messages)
 888     statusbar_counter = 1;
 889 }
 890
 891 static void
 892 statusbar_contexts (GtkStatusbar *statusbar)
 893 {
 894   gchar *string;
 895
 896   string = "any context";
 897   g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
 898            string,
 899            gtk_statusbar_get_context_id (statusbar, string));
 900
 901   string = "idle messages";
 902   g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
 903            string,
 904            gtk_statusbar_get_context_id (statusbar, string));
 905
 906   string = "some text";
 907   g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
 908            string,
 909            gtk_statusbar_get_context_id (statusbar, string));
 910
 911   string = "hit the mouse";
 912   g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
 913            string,
 914            gtk_statusbar_get_context_id (statusbar, string));
 915
 916   string = "hit the mouse2";
 917   g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
 918            string,
 919            gtk_statusbar_get_context_id (statusbar, string));
 920 }
 921
 922 static void
 923 statusbar_dump_stack (GtkStatusbar *statusbar)
 924 {
 925   GSList *list;
 926
 927   for (list = statusbar->messages; list; list = list->next)
 928     {
 929       GtkStatusbarMsg *msg;
 930
 931       msg = list->data;
 932       g_print ("context_id: %d, message_id: %d, status_text: \"%s\"\n",
 933                msg->context_id,
 934                msg->message_id,
 935                msg->text);
 936     }
 937 }
 938
 939 static void
 940 create_statusbar (void)
 941 {
 942   static GtkWidget *window = NULL;
 943   GtkWidget *box1;
 944   GtkWidget *box2;
 945   GtkWidget *button;
 946   GtkWidget *separator;
 947   GtkWidget *statusbar;
 948
 949   if (!window)
 950     {
 951       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 952
 953       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 954                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
 955                           &window);
 956
 957       gtk_window_set_title (GTK_WINDOW (window), "statusbar");
 958       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
 959
 960       box1 = gtk_vbox_new (FALSE, 0);
 961       gtk_container_add (GTK_CONTAINER (window), box1);
 962
 963       box2 = gtk_vbox_new (FALSE, 10);
 964       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
 965       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
 966
 967       statusbar = gtk_statusbar_new ();
 968       gtk_box_pack_end (GTK_BOX (box1), statusbar, TRUE, TRUE, 0);
 969       gtk_signal_connect (GTK_OBJECT (statusbar),
 970                           "text_popped",
 971                           GTK_SIGNAL_FUNC (statusbar_popped),
 972                           NULL);
 973
 974       button = gtk_widget_new (gtk_button_get_type (),
 975                                "label", "push something",
 976                                "visible", TRUE,
 977                                "parent", box2,
 978                                "signal::clicked", statusbar_push, statusbar,
 979                                NULL);
 980
 981       button = gtk_widget_new (gtk_button_get_type (),
 982                                "label", "pop",
 983                                "visible", TRUE,
 984                                "parent", box2,
 985                                "signal_after::clicked", statusbar_pop, statusbar,
 986                                NULL);
 987
 988       button = gtk_widget_new (gtk_button_get_type (),
 989                                "label", "steal #4",
 990                                "visible", TRUE,
 991                                "parent", box2,
 992                                "signal_after::clicked", statusbar_steal, statusbar,
 993                                NULL);
 994
 995       button = gtk_widget_new (gtk_button_get_type (),
 996                                "label", "dump stack",
 997                                "visible", TRUE,
 998                                "parent", box2,
 999                                "object_signal::clicked", statusbar_dump_stack, statusbar,
1000                                NULL);
1001
1002       button = gtk_widget_new (gtk_button_get_type (),
1003                                "label", "test contexts",
1004                                "visible", TRUE,
1005                                "parent", box2,
1006                                "object_signal_after::clicked", statusbar_contexts, statusbar,
1007                                NULL);
1008
1009       separator = gtk_hseparator_new ();
1010       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1011
1012       box2 = gtk_vbox_new (FALSE, 10);
1013       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1014       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1015
1016       button = gtk_button_new_with_label ("close");
1017       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1018                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1019                                  GTK_OBJECT (window));
1020       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1021       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1022       gtk_widget_grab_default (button);
1023     }
1024
1025   if (!GTK_WIDGET_VISIBLE (window))
1026     gtk_widget_show_all (window);
1027   else
1028     gtk_widget_destroy (window);
1029 }
1030
1031 /*
1032  * GtkTree
1033  */
1034
1035 static void
1036 cb_tree_destroy_event(GtkWidget* w)
1037 {
1038   sTreeButtons* tree_buttons;
1039
1040   /* free buttons structure associate at this tree */
1041   tree_buttons = gtk_object_get_user_data (GTK_OBJECT (w));
1042   g_free (tree_buttons);
1043 }
1044
1045 static void
1046 cb_add_new_item(GtkWidget* w, GtkTree* tree)
1047 {
1048   sTreeButtons* tree_buttons;
1049   GList* selected_list;
1050   GtkWidget* selected_item;
1051   GtkWidget* subtree;
1052   GtkWidget* item_new;
1053   char buffer[255];
1054
1055   tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree));
1056
1057   selected_list = GTK_TREE_SELECTION(tree);
1058
1059   if(selected_list == NULL)
1060     {
1061       /* there is no item in tree */
1062       subtree = GTK_WIDGET(tree);
1063     }
1064   else
1065     {
1066       /* list can have only one element */
1067       selected_item = GTK_WIDGET(selected_list->data);
1068
1069       subtree = GTK_TREE_ITEM_SUBTREE(selected_item);
1070
1071       if(subtree == NULL)
1072         {
1073           /* current selected item have not subtree ... create it */
1074           subtree = gtk_tree_new();
1075           gtk_tree_item_set_subtree(GTK_TREE_ITEM(selected_item),
1076                                     subtree);
1077         }
1078     }
1079
1080   /* at this point, we know which subtree will be used to add new item */
1081   /* create a new item */
1082   sprintf(buffer, "item add %d", tree_buttons->nb_item_add);
1083   item_new = gtk_tree_item_new_with_label(buffer);
1084   gtk_tree_append(GTK_TREE(subtree), item_new);
1085   gtk_widget_show(item_new);
1086
1087   tree_buttons->nb_item_add++;
1088 }
1089
1090 static void
1091 cb_remove_item(GtkWidget*w, GtkTree* tree)
1092 {
1093   GList* selected_list;
1094   GList* clear_list;
1095
1096   selected_list = GTK_TREE_SELECTION(tree);
1097
1098   clear_list = NULL;
1099
1100   while (selected_list)
1101     {
1102       clear_list = g_list_prepend (clear_list, selected_list->data);
1103       selected_list = selected_list->next;
1104     }
1105
1106   clear_list = g_list_reverse (clear_list);
1107   gtk_tree_remove_items(tree, clear_list);
1108
1109   g_list_free (clear_list);
1110 }
1111
1112 static void
1113 cb_remove_subtree(GtkWidget*w, GtkTree* tree)
1114 {
1115   GList* selected_list;
1116   GtkTreeItem *item;
1117
1118   selected_list = GTK_TREE_SELECTION(tree);
1119
1120   if (selected_list)
1121     {
1122       item = GTK_TREE_ITEM (selected_list->data);
1123       if (item->subtree)
1124         gtk_tree_item_remove_subtree (item);
1125     }
1126 }
1127
1128 static void
1129 cb_tree_changed(GtkTree* tree)
1130 {
1131   sTreeButtons* tree_buttons;
1132   GList* selected_list;
1133   guint nb_selected;
1134
1135   tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree));
1136
1137   selected_list = GTK_TREE_SELECTION(tree);
1138   nb_selected = g_list_length(selected_list);
1139
1140   if(nb_selected == 0)
1141     {
1142       if(tree->children == NULL)
1143         gtk_widget_set_sensitive(tree_buttons->add_button, TRUE);
1144       else
1145         gtk_widget_set_sensitive(tree_buttons->add_button, FALSE);
1146       gtk_widget_set_sensitive(tree_buttons->remove_button, FALSE);
1147       gtk_widget_set_sensitive(tree_buttons->subtree_button, FALSE);
1148     }
1149   else
1150     {
1151       gtk_widget_set_sensitive(tree_buttons->remove_button, TRUE);
1152       gtk_widget_set_sensitive(tree_buttons->add_button, (nb_selected == 1));
1153       gtk_widget_set_sensitive(tree_buttons->subtree_button, (nb_selected == 1));
1154     }
1155 }
1156
1157 static void
1158 create_subtree(GtkWidget* item, guint level, guint nb_item_max, guint recursion_level_max)
1159 {
1160   GtkWidget* item_subtree;
1161   GtkWidget* item_new;
1162   guint nb_item;
1163   char buffer[255];
1164   int no_root_item;
1165
1166   if(level == recursion_level_max) return;
1167
1168   if(level == -1)
1169     {
1170       /* query with no root item */
1171       level = 0;
1172       item_subtree = item;
1173       no_root_item = 1;
1174     }
1175   else
1176     {
1177       /* query with no root item */
1178       /* create subtree and associate it with current item */
1179       item_subtree = gtk_tree_new();
1180       no_root_item = 0;
1181     }
1182
1183   for(nb_item = 0; nb_item < nb_item_max; nb_item++)
1184     {
1185       sprintf(buffer, "item %d-%d", level, nb_item);
1186       item_new = gtk_tree_item_new_with_label(buffer);
1187       gtk_tree_append(GTK_TREE(item_subtree), item_new);
1188       create_subtree(item_new, level+1, nb_item_max, recursion_level_max);
1189       gtk_widget_show(item_new);
1190     }
1191
1192   if(!no_root_item)
1193     gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), item_subtree);
1194 }
1195
1196 static void
1197 create_tree_sample(guint selection_mode,
1198                    guint draw_line, guint view_line, guint no_root_item,
1199                    guint nb_item_max, guint recursion_level_max)
1200 {
1201   GtkWidget* window;
1202   GtkWidget* box1;
1203   GtkWidget* box2;
1204   GtkWidget* separator;
1205   GtkWidget* button;
1206   GtkWidget* scrolled_win;
1207   GtkWidget* root_tree;
1208   GtkWidget* root_item;
1209   sTreeButtons* tree_buttons;
1210
1211   /* create tree buttons struct */
1212   if ((tree_buttons = g_malloc (sizeof (sTreeButtons))) == NULL)
1213     {
1214       g_error("can't allocate memory for tree structure !\n");
1215       return;
1216     }
1217   tree_buttons->nb_item_add = 0;
1218
1219   /* create top level window */
1220   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1221   gtk_window_set_title(GTK_WINDOW(window), "Tree Sample");
1222   gtk_signal_connect(GTK_OBJECT(window), "destroy",
1223                      (GtkSignalFunc) cb_tree_destroy_event, NULL);
1224   gtk_object_set_user_data(GTK_OBJECT(window), tree_buttons);
1225
1226   box1 = gtk_vbox_new(FALSE, 0);
1227   gtk_container_add(GTK_CONTAINER(window), box1);
1228   gtk_widget_show(box1);
1229
1230   /* create tree box */
1231   box2 = gtk_vbox_new(FALSE, 0);
1232   gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);
1233   gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
1234   gtk_widget_show(box2);
1235
1236   /* create scrolled window */
1237   scrolled_win = gtk_scrolled_window_new (NULL, NULL);
1238   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
1239                                   GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1240   gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
1241   gtk_widget_set_usize (scrolled_win, 200, 200);
1242   gtk_widget_show (scrolled_win);
1243
1244   /* create root tree widget */
1245   root_tree = gtk_tree_new();
1246   gtk_signal_connect(GTK_OBJECT(root_tree), "selection_changed",
1247                      (GtkSignalFunc)cb_tree_changed,
1248                      (gpointer)NULL);
1249   gtk_object_set_user_data(GTK_OBJECT(root_tree), tree_buttons);
1250   gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), root_tree);
1251   gtk_tree_set_selection_mode(GTK_TREE(root_tree), selection_mode);
1252   gtk_tree_set_view_lines(GTK_TREE(root_tree), draw_line);
1253   gtk_tree_set_view_mode(GTK_TREE(root_tree), !view_line);
1254   gtk_widget_show(root_tree);
1255
1256   if ( no_root_item )
1257     {
1258       /* set root tree to subtree function with root item variable */
1259       root_item = GTK_WIDGET(root_tree);
1260     }
1261   else
1262     {
1263       /* create root tree item widget */
1264       root_item = gtk_tree_item_new_with_label("root item");
1265       gtk_tree_append(GTK_TREE(root_tree), root_item);
1266       gtk_widget_show(root_item);
1267      }
1268   create_subtree(root_item, -no_root_item, nb_item_max, recursion_level_max);
1269
1270   box2 = gtk_vbox_new(FALSE, 0);
1271   gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1272   gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
1273   gtk_widget_show(box2);
1274
1275   button = gtk_button_new_with_label("Add Item");
1276   gtk_widget_set_sensitive(button, FALSE);
1277   gtk_signal_connect(GTK_OBJECT (button), "clicked",
1278                      (GtkSignalFunc) cb_add_new_item,
1279                      (gpointer)root_tree);
1280   gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1281   gtk_widget_show(button);
1282   tree_buttons->add_button = button;
1283
1284   button = gtk_button_new_with_label("Remove Item(s)");
1285   gtk_widget_set_sensitive(button, FALSE);
1286   gtk_signal_connect(GTK_OBJECT (button), "clicked",
1287                      (GtkSignalFunc) cb_remove_item,
1288                      (gpointer)root_tree);
1289   gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1290   gtk_widget_show(button);
1291   tree_buttons->remove_button = button;
1292
1293   button = gtk_button_new_with_label("Remove Subtree");
1294   gtk_widget_set_sensitive(button, FALSE);
1295   gtk_signal_connect(GTK_OBJECT (button), "clicked",
1296                      (GtkSignalFunc) cb_remove_subtree,
1297                      (gpointer)root_tree);
1298   gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1299   gtk_widget_show(button);
1300   tree_buttons->subtree_button = button;
1301
1302   /* create separator */
1303   separator = gtk_hseparator_new();
1304   gtk_box_pack_start(GTK_BOX(box1), separator, FALSE, FALSE, 0);
1305   gtk_widget_show(separator);
1306
1307   /* create button box */
1308   box2 = gtk_vbox_new(FALSE, 0);
1309   gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1310   gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
1311   gtk_widget_show(box2);
1312
1313   button = gtk_button_new_with_label("Close");
1314   gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1315   gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
1316                             (GtkSignalFunc) gtk_widget_destroy,
1317                             GTK_OBJECT(window));
1318   gtk_widget_show(button);
1319
1320   gtk_widget_show(window);
1321 }
1322
1323 static void
1324 cb_create_tree(GtkWidget* w)
1325 {
1326   guint selection_mode = GTK_SELECTION_SINGLE;
1327   guint view_line;
1328   guint draw_line;
1329   guint no_root_item;
1330   guint nb_item;
1331   guint recursion_level;
1332
1333   /* get selection mode choice */
1334   if(GTK_TOGGLE_BUTTON(sTreeSampleSelection.single_button)->active)
1335     selection_mode = GTK_SELECTION_SINGLE;
1336   else
1337     if(GTK_TOGGLE_BUTTON(sTreeSampleSelection.browse_button)->active)
1338       selection_mode = GTK_SELECTION_BROWSE;
1339     else
1340       selection_mode = GTK_SELECTION_MULTIPLE;
1341
1342   /* get options choice */
1343   draw_line = GTK_TOGGLE_BUTTON(sTreeSampleSelection.draw_line_button)->active;
1344   view_line = GTK_TOGGLE_BUTTON(sTreeSampleSelection.view_line_button)->active;
1345   no_root_item = GTK_TOGGLE_BUTTON(sTreeSampleSelection.no_root_item_button)->active;
1346
1347   /* get levels */
1348   nb_item = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sTreeSampleSelection.nb_item_spinner));
1349   recursion_level = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sTreeSampleSelection.recursion_spinner));
1350
1351   if (pow (nb_item, recursion_level) > 10000)
1352     {
1353       g_print ("%g total items? That will take a very long time. Try less\n",
1354                pow (nb_item, recursion_level));
1355       return;
1356     }
1357
1358   create_tree_sample(selection_mode, draw_line, view_line, no_root_item, nb_item, recursion_level);
1359 }
1360
1361 void
1362 create_tree_mode_window(void)
1363 {
1364   static GtkWidget* window;
1365   GtkWidget* box1;
1366   GtkWidget* box2;
1367   GtkWidget* box3;
1368   GtkWidget* box4;
1369   GtkWidget* box5;
1370   GtkWidget* button;
1371   GtkWidget* frame;
1372   GtkWidget* separator;
1373   GtkWidget* label;
1374   GtkWidget* spinner;
1375   GtkAdjustment *adj;
1376
1377   if (!window)
1378     {
1379       /* create toplevel window  */
1380       window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1381       gtk_window_set_title(GTK_WINDOW(window), "Set Tree Parameters");
1382       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1383                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1384                           &window);
1385       box1 = gtk_vbox_new(FALSE, 0);
1386       gtk_container_add(GTK_CONTAINER(window), box1);
1387
1388       /* create upper box - selection box */
1389       box2 = gtk_vbox_new(FALSE, 5);
1390       gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);
1391       gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
1392
1393       box3 = gtk_hbox_new(FALSE, 5);
1394       gtk_box_pack_start(GTK_BOX(box2), box3, TRUE, TRUE, 0);
1395
1396       /* create selection mode frame */
1397       frame = gtk_frame_new("Selection Mode");
1398       gtk_box_pack_start(GTK_BOX(box3), frame, TRUE, TRUE, 0);
1399
1400       box4 = gtk_vbox_new(FALSE, 0);
1401       gtk_container_add(GTK_CONTAINER(frame), box4);
1402       gtk_container_set_border_width(GTK_CONTAINER(box4), 5);
1403
1404       /* create radio button */
1405       button = gtk_radio_button_new_with_label(NULL, "SINGLE");
1406       gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1407       sTreeSampleSelection.single_button = button;
1408
1409       button = gtk_radio_button_new_with_label(gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
1410                                                "BROWSE");
1411       gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1412       sTreeSampleSelection.browse_button = button;
1413
1414       button = gtk_radio_button_new_with_label(gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
1415                                                "MULTIPLE");
1416       gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1417       sTreeSampleSelection.multiple_button = button;
1418
1419       sTreeSampleSelection.selection_mode_group = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
1420
1421       /* create option mode frame */
1422       frame = gtk_frame_new("Options");
1423       gtk_box_pack_start(GTK_BOX(box3), frame, TRUE, TRUE, 0);
1424
1425       box4 = gtk_vbox_new(FALSE, 0);
1426       gtk_container_add(GTK_CONTAINER(frame), box4);
1427       gtk_container_set_border_width(GTK_CONTAINER(box4), 5);
1428
1429       /* create check button */
1430       button = gtk_check_button_new_with_label("Draw line");
1431       gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1432       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
1433       sTreeSampleSelection.draw_line_button = button;
1434
1435       button = gtk_check_button_new_with_label("View Line mode");
1436       gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1437       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
1438       sTreeSampleSelection.view_line_button = button;
1439
1440       button = gtk_check_button_new_with_label("Without Root item");
1441       gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1442       sTreeSampleSelection.no_root_item_button = button;
1443
1444       /* create recursion parameter */
1445       frame = gtk_frame_new("Size Parameters");
1446       gtk_box_pack_start(GTK_BOX(box2), frame, TRUE, TRUE, 0);
1447
1448       box4 = gtk_hbox_new(FALSE, 5);
1449       gtk_container_add(GTK_CONTAINER(frame), box4);
1450       gtk_container_set_border_width(GTK_CONTAINER(box4), 5);
1451
1452       /* create number of item spin button */
1453       box5 = gtk_hbox_new(FALSE, 5);
1454       gtk_box_pack_start(GTK_BOX(box4), box5, FALSE, FALSE, 0);
1455
1456       label = gtk_label_new("Number of items : ");
1457       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1458       gtk_box_pack_start (GTK_BOX (box5), label, FALSE, TRUE, 0);
1459
1460       adj = (GtkAdjustment *) gtk_adjustment_new ((gfloat)DEFAULT_NUMBER_OF_ITEM, 1.0, 255.0, 1.0,
1461                                                   5.0, 0.0);
1462       spinner = gtk_spin_button_new (adj, 0, 0);
1463       gtk_box_pack_start (GTK_BOX (box5), spinner, FALSE, TRUE, 0);
1464       sTreeSampleSelection.nb_item_spinner = spinner;
1465
1466       /* create recursion level spin button */
1467       box5 = gtk_hbox_new(FALSE, 5);
1468       gtk_box_pack_start(GTK_BOX(box4), box5, FALSE, FALSE, 0);
1469
1470       label = gtk_label_new("Depth : ");
1471       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1472       gtk_box_pack_start (GTK_BOX (box5), label, FALSE, TRUE, 0);
1473
1474       adj = (GtkAdjustment *) gtk_adjustment_new ((gfloat)DEFAULT_RECURSION_LEVEL, 0.0, 255.0, 1.0,
1475                                                   5.0, 0.0);
1476       spinner = gtk_spin_button_new (adj, 0, 0);
1477       gtk_box_pack_start (GTK_BOX (box5), spinner, FALSE, TRUE, 0);
1478       sTreeSampleSelection.recursion_spinner = spinner;
1479
1480       /* create horizontal separator */
1481       separator = gtk_hseparator_new();
1482       gtk_box_pack_start(GTK_BOX(box1), separator, FALSE, FALSE, 0);
1483
1484       /* create bottom button box */
1485       box2 = gtk_hbox_new(TRUE, 10);
1486       gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1487       gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
1488
1489       button = gtk_button_new_with_label("Create Tree");
1490       gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1491       gtk_signal_connect(GTK_OBJECT (button), "clicked",
1492                          (GtkSignalFunc) cb_create_tree, NULL);
1493
1494       button = gtk_button_new_with_label("Close");
1495       gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1496       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1497                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1498                                  GTK_OBJECT (window));
1499     }
1500   if (!GTK_WIDGET_VISIBLE (window))
1501     gtk_widget_show_all (window);
1502   else
1503     gtk_widget_destroy (window);
1504 }
1505
1506 /*
1507  * GtkHandleBox
1508  */
1509
1510 static void
1511 handle_box_child_signal (GtkHandleBox *hb,
1512                          GtkWidget    *child,
1513                          const gchar  *action)
1514 {
1515   printf ("%s: child <%s> %sed\n",
1516           gtk_type_name (GTK_OBJECT_TYPE (hb)),
1517           gtk_type_name (GTK_OBJECT_TYPE (child)),
1518           action);
1519 }
1520
1521 static void
1522 create_handle_box (void)
1523 {
1524   static GtkWidget* window = NULL;
1525   GtkWidget *handle_box;
1526   GtkWidget *handle_box2;
1527   GtkWidget *vbox;
1528   GtkWidget *hbox;
1529   GtkWidget *toolbar;
1530   GtkWidget *label;
1531   GtkWidget *separator;
1532
1533   if (!window)
1534   {
1535     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1536     gtk_window_set_title (GTK_WINDOW (window),
1537                           "Handle Box Test");
1538     gtk_window_set_policy (GTK_WINDOW (window),
1539                            TRUE,
1540                            TRUE,
1541                            FALSE);
1542
1543     gtk_signal_connect (GTK_OBJECT (window), "destroy",
1544                         GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1545                         &window);
1546
1547     gtk_container_set_border_width (GTK_CONTAINER (window), 20);
1548
1549     vbox = gtk_vbox_new (FALSE, 0);
1550     gtk_container_add (GTK_CONTAINER (window), vbox);
1551     gtk_widget_show (vbox);
1552
1553     label = gtk_label_new ("Above");
1554     gtk_container_add (GTK_CONTAINER (vbox), label);
1555     gtk_widget_show (label);
1556
1557     separator = gtk_hseparator_new ();
1558     gtk_container_add (GTK_CONTAINER (vbox), separator);
1559     gtk_widget_show (separator);
1560
1561     hbox = gtk_hbox_new (FALSE, 10);
1562     gtk_container_add (GTK_CONTAINER (vbox), hbox);
1563     gtk_widget_show (hbox);
1564
1565     separator = gtk_hseparator_new ();
1566     gtk_container_add (GTK_CONTAINER (vbox), separator);
1567     gtk_widget_show (separator);
1568
1569     label = gtk_label_new ("Below");
1570     gtk_container_add (GTK_CONTAINER (vbox), label);
1571     gtk_widget_show (label);
1572
1573     handle_box = gtk_handle_box_new ();
1574     gtk_box_pack_start (GTK_BOX (hbox), handle_box, FALSE, FALSE, 0);
1575     gtk_signal_connect (GTK_OBJECT (handle_box),
1576                         "child_attached",
1577                         GTK_SIGNAL_FUNC (handle_box_child_signal),
1578                         "attached");
1579     gtk_signal_connect (GTK_OBJECT (handle_box),
1580                         "child_detached",
1581                         GTK_SIGNAL_FUNC (handle_box_child_signal),
1582                         "detached");
1583     gtk_widget_show (handle_box);
1584
1585     toolbar = make_toolbar (window);
1586     gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NORMAL);
1587     gtk_container_add (GTK_CONTAINER (handle_box), toolbar);
1588     gtk_widget_show (toolbar);
1589
1590     handle_box = gtk_handle_box_new ();
1591     gtk_box_pack_start (GTK_BOX (hbox), handle_box, FALSE, FALSE, 0);
1592     gtk_signal_connect (GTK_OBJECT (handle_box),
1593                         "child_attached",
1594                         GTK_SIGNAL_FUNC (handle_box_child_signal),
1595                         "attached");
1596     gtk_signal_connect (GTK_OBJECT (handle_box),
1597                         "child_detached",
1598                         GTK_SIGNAL_FUNC (handle_box_child_signal),
1599                         "detached");
1600     gtk_widget_show (handle_box);
1601
1602     handle_box2 = gtk_handle_box_new ();
1603     gtk_container_add (GTK_CONTAINER (handle_box), handle_box2);
1604     gtk_signal_connect (GTK_OBJECT (handle_box2),
1605                         "child_attached",
1606                         GTK_SIGNAL_FUNC (handle_box_child_signal),
1607                         "attached");
1608     gtk_signal_connect (GTK_OBJECT (handle_box2),
1609                         "child_detached",
1610                         GTK_SIGNAL_FUNC (handle_box_child_signal),
1611                         "detached");
1612     gtk_widget_show (handle_box2);
1613
1614     label = gtk_label_new ("Fooo!");
1615     gtk_container_add (GTK_CONTAINER (handle_box2), label);
1616     gtk_widget_show (label);
1617   }
1618
1619   if (!GTK_WIDGET_VISIBLE (window))
1620     gtk_widget_show (window);
1621   else
1622     gtk_widget_destroy (window);
1623 }
1624
1625 /*
1626  * Label Demo
1627  */
1628 void create_labels (void)
1629 {
1630   static GtkWidget *window = NULL;
1631   GtkWidget *hbox;
1632   GtkWidget *vbox;
1633   GtkWidget *frame;
1634   GtkWidget *label;
1635
1636   if (!window)
1637     {
1638       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1639       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1640                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1641                           &window);
1642
1643       gtk_window_set_title (GTK_WINDOW (window), "Label");
1644       vbox = gtk_vbox_new (FALSE, 5);
1645       hbox = gtk_hbox_new (FALSE, 5);
1646       gtk_container_add (GTK_CONTAINER (window), hbox);
1647       gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
1648       gtk_container_set_border_width (GTK_CONTAINER (window), 5);
1649
1650       frame = gtk_frame_new ("Normal Label");
1651       label = gtk_label_new ("This is a Normal label");
1652       gtk_container_add (GTK_CONTAINER (frame), label);
1653       gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1654
1655       frame = gtk_frame_new ("Multi-line Label");
1656       label = gtk_label_new ("This is a Multi-line label.\nSecond line\nThird line");
1657       gtk_container_add (GTK_CONTAINER (frame), label);
1658       gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1659
1660       frame = gtk_frame_new ("Left Justified Label");
1661       label = gtk_label_new ("This is a Left-Justified\nMulti-line label.\nThird      line");
1662       gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1663       gtk_container_add (GTK_CONTAINER (frame), label);
1664       gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1665
1666       frame = gtk_frame_new ("Right Justified Label");
1667       label = gtk_label_new ("This is a Right-Justified\nMulti-line label.\nFourth line, (j/k)");
1668       gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);
1669       gtk_container_add (GTK_CONTAINER (frame), label);
1670       gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1671
1672       vbox = gtk_vbox_new (FALSE, 5);
1673       gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
1674       frame = gtk_frame_new ("Line wrapped label");
1675       label = gtk_label_new ("This is an example of a line-wrapped label.  It should not be taking "\
1676                              "up the entire             "/* big space to test spacing */\
1677                              "width allocated to it, but automatically wraps the words to fit.  "\
1678                              "The time has come, for all good men, to come to the aid of their party.  "\
1679                              "The sixth sheik's six sheep's sick.\n"\
1680                              "     It supports multiple paragraphs correctly, and  correctly   adds "\
1681                              "many          extra  spaces. ");
1682
1683       gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
1684       gtk_container_add (GTK_CONTAINER (frame), label);
1685       gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1686
1687       frame = gtk_frame_new ("Filled, wrapped label");
1688       label = gtk_label_new ("This is an example of a line-wrapped, filled label.  It should be taking "\
1689                              "up the entire              width allocated to it.  Here is a seneance to prove "\
1690                              "my point.  Here is another sentence. "\
1691                              "Here comes the sun, do de do de do.\n"\
1692                              "    This is a new paragraph.\n"\
1693                              "    This is another newer, longer, better paragraph.  It is coming to an end, "\
1694                              "unfortunately.");
1695       gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_FILL);
1696       gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
1697       gtk_container_add (GTK_CONTAINER (frame), label);
1698       gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1699
1700       frame = gtk_frame_new ("Underlined label");
1701       label = gtk_label_new ("This label is underlined!\n"
1702                              "This one is underlined in ÆüËÜ¸ì¤ÎÆþÍÑquite a funky fashion");
1703       gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1704       gtk_label_set_pattern (GTK_LABEL (label), "_________________________ _ _________ _ _____ _ __ __  ___ ____ _____");
1705       gtk_container_add (GTK_CONTAINER (frame), label);
1706       gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1707
1708     }
1709   if (!GTK_WIDGET_VISIBLE (window))
1710     gtk_widget_show_all (window);
1711   else
1712     gtk_widget_destroy (window);
1713 }
1714
1715 /*
1716  * Reparent demo
1717  */
1718
1719 static void
1720 reparent_label (GtkWidget *widget,
1721                 GtkWidget *new_parent)
1722 {
1723   GtkWidget *label;
1724
1725   label = gtk_object_get_user_data (GTK_OBJECT (widget));
1726
1727   gtk_widget_reparent (label, new_parent);
1728 }
1729
1730 static void
1731 set_parent_signal (GtkWidget *child,
1732                    GtkWidget *old_parent,
1733                    gpointer   func_data)
1734 {
1735   g_print ("set_parent for \"%s\": new parent: \"%s\", old parent: \"%s\", data: %d\n",
1736            gtk_type_name (GTK_OBJECT_TYPE (child)),
1737            child->parent ? gtk_type_name (GTK_OBJECT_TYPE (child->parent)) : "NULL",
1738            old_parent ? gtk_type_name (GTK_OBJECT_TYPE (old_parent)) : "NULL",
1739            GPOINTER_TO_INT (func_data));
1740 }
1741
1742 static void
1743 create_reparent (void)
1744 {
1745   static GtkWidget *window = NULL;
1746   GtkWidget *box1;
1747   GtkWidget *box2;
1748   GtkWidget *box3;
1749   GtkWidget *frame;
1750   GtkWidget *button;
1751   GtkWidget *label;
1752   GtkWidget *separator;
1753
1754   if (!window)
1755     {
1756       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1757
1758       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1759                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1760                           &window);
1761
1762       gtk_window_set_title (GTK_WINDOW (window), "reparent");
1763       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
1764
1765       box1 = gtk_vbox_new (FALSE, 0);
1766       gtk_container_add (GTK_CONTAINER (window), box1);
1767
1768       box2 = gtk_hbox_new (FALSE, 5);
1769       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1770       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1771
1772       label = gtk_label_new ("Hello World");
1773
1774       frame = gtk_frame_new ("Frame 1");
1775       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
1776
1777       box3 = gtk_vbox_new (FALSE, 5);
1778       gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
1779       gtk_container_add (GTK_CONTAINER (frame), box3);
1780
1781       button = gtk_button_new_with_label ("switch");
1782       gtk_signal_connect (GTK_OBJECT (button), "clicked",
1783                           GTK_SIGNAL_FUNC(reparent_label),
1784                           box3);
1785       gtk_object_set_user_data (GTK_OBJECT (button), label);
1786       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
1787
1788       gtk_box_pack_start (GTK_BOX (box3), label, FALSE, TRUE, 0);
1789       gtk_signal_connect (GTK_OBJECT (label),
1790                           "parent_set",
1791                           GTK_SIGNAL_FUNC (set_parent_signal),
1792                           GINT_TO_POINTER (42));
1793
1794       frame = gtk_frame_new ("Frame 2");
1795       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
1796
1797       box3 = gtk_vbox_new (FALSE, 5);
1798       gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
1799       gtk_container_add (GTK_CONTAINER (frame), box3);
1800
1801       button = gtk_button_new_with_label ("switch");
1802       gtk_signal_connect (GTK_OBJECT (button), "clicked",
1803                           GTK_SIGNAL_FUNC(reparent_label),
1804                           box3);
1805       gtk_object_set_user_data (GTK_OBJECT (button), label);
1806       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
1807
1808       separator = gtk_hseparator_new ();
1809       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1810
1811       box2 = gtk_vbox_new (FALSE, 10);
1812       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1813       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1814
1815       button = gtk_button_new_with_label ("close");
1816       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1817                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1818                                  GTK_OBJECT (window));
1819       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1820       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1821       gtk_widget_grab_default (button);
1822     }
1823
1824   if (!GTK_WIDGET_VISIBLE (window))
1825     gtk_widget_show_all (window);
1826   else
1827     gtk_widget_destroy (window);
1828 }
1829
1830 /*
1831  * Saved Position
1832  */
1833 gint upositionx = 0;
1834 gint upositiony = 0;
1835
1836 static gint
1837 uposition_configure (GtkWidget *window)
1838 {
1839   GtkLabel *lx;
1840   GtkLabel *ly;
1841   gchar buffer[64];
1842
1843   lx = gtk_object_get_data (GTK_OBJECT (window), "x");
1844   ly = gtk_object_get_data (GTK_OBJECT (window), "y");
1845
1846   gdk_window_get_root_origin (window->window, &upositionx, &upositiony);
1847   sprintf (buffer, "%d", upositionx);
1848   gtk_label_set_text (lx, buffer);
1849   sprintf (buffer, "%d", upositiony);
1850   gtk_label_set_text (ly, buffer);
1851
1852   return FALSE;
1853 }
1854
1855 static void
1856 create_saved_position (void)
1857 {
1858   static GtkWidget *window = NULL;
1859
1860   if (!window)
1861     {
1862       GtkWidget *hbox;
1863       GtkWidget *main_vbox;
1864       GtkWidget *vbox;
1865       GtkWidget *x_label;
1866       GtkWidget *y_label;
1867       GtkWidget *button;
1868       GtkWidget *label;
1869       GtkWidget *any;
1870
1871       window = gtk_widget_new (GTK_TYPE_WINDOW,
1872                                "type", GTK_WINDOW_TOPLEVEL,
1873                                "signal::configure_event", uposition_configure, NULL,
1874                                "x", upositionx,
1875                                "y", upositiony,
1876                                "title", "Saved Position",
1877                                NULL);
1878
1879       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1880                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
1881                           &window);
1882
1883       main_vbox = gtk_vbox_new (FALSE, 5);
1884       gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
1885       gtk_container_add (GTK_CONTAINER (window), main_vbox);
1886
1887       vbox =
1888         gtk_widget_new (gtk_vbox_get_type (),
1889                         "GtkBox::homogeneous", FALSE,
1890                         "GtkBox::spacing", 5,
1891                         "GtkContainer::border_width", 10,
1892                         "GtkWidget::parent", main_vbox,
1893                         "GtkWidget::visible", TRUE,
1894                         NULL);
1895
1896       hbox = gtk_hbox_new (FALSE, 0);
1897       gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
1898       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
1899
1900       label = gtk_label_new ("X Origin : ");
1901       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1902       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
1903
1904       x_label = gtk_label_new ("");
1905       gtk_box_pack_start (GTK_BOX (hbox), x_label, TRUE, TRUE, 0);
1906       gtk_object_set_data (GTK_OBJECT (window), "x", x_label);
1907
1908       hbox = gtk_hbox_new (FALSE, 0);
1909       gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
1910       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
1911
1912       label = gtk_label_new ("Y Origin : ");
1913       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1914       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
1915
1916       y_label = gtk_label_new ("");
1917       gtk_box_pack_start (GTK_BOX (hbox), y_label, TRUE, TRUE, 0);
1918       gtk_object_set_data (GTK_OBJECT (window), "y", y_label);
1919
1920       any =
1921         gtk_widget_new (gtk_hseparator_get_type (),
1922                         "GtkWidget::visible", TRUE,
1923                         NULL);
1924       gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
1925
1926       hbox = gtk_hbox_new (FALSE, 0);
1927       gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
1928       gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
1929
1930       button = gtk_button_new_with_label ("Close");
1931       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1932                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
1933                                  GTK_OBJECT (window));
1934       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
1935       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1936       gtk_widget_grab_default (button);
1937
1938       gtk_widget_show_all (window);
1939     }
1940   else
1941     gtk_widget_destroy (window);
1942 }
1943
1944 /*
1945  * GtkPixmap
1946  */
1947
1948 static void
1949 create_pixmap (void)
1950 {
1951   static GtkWidget *window = NULL;
1952   GtkWidget *box1;
1953   GtkWidget *box2;
1954   GtkWidget *box3;
1955   GtkWidget *button;
1956   GtkWidget *label;
1957   GtkWidget *separator;
1958   GtkWidget *pixmapwid;
1959   GdkPixmap *pixmap;
1960   GdkBitmap *mask;
1961
1962   if (!window)
1963     {
1964       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1965
1966       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1967                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1968                           &window);
1969
1970       gtk_window_set_title (GTK_WINDOW (window), "GtkPixmap");
1971       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
1972       gtk_widget_realize(window);
1973
1974       box1 = gtk_vbox_new (FALSE, 0);
1975       gtk_container_add (GTK_CONTAINER (window), box1);
1976
1977       box2 = gtk_vbox_new (FALSE, 10);
1978       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1979       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1980
1981       button = gtk_button_new ();
1982       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
1983
1984       pixmap = gdk_pixmap_create_from_xpm (window->window, &mask, NULL,
1985                                            "test.xpm");
1986       pixmapwid = gtk_pixmap_new (pixmap, mask);
1987       gdk_pixmap_unref (pixmap);
1988       gdk_pixmap_unref (mask);
1989
1990       label = gtk_label_new ("Pixmap\ntest");
1991       box3 = gtk_hbox_new (FALSE, 0);
1992       gtk_container_set_border_width (GTK_CONTAINER (box3), 2);
1993       gtk_container_add (GTK_CONTAINER (box3), pixmapwid);
1994       gtk_container_add (GTK_CONTAINER (box3), label);
1995       gtk_container_add (GTK_CONTAINER (button), box3);
1996
1997       separator = gtk_hseparator_new ();
1998       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1999
2000       box2 = gtk_vbox_new (FALSE, 10);
2001       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2002       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2003
2004       button = gtk_button_new_with_label ("close");
2005       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2006                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2007                                  GTK_OBJECT (window));
2008       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2009       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2010       gtk_widget_grab_default (button);
2011     }
2012
2013   if (!GTK_WIDGET_VISIBLE (window))
2014     gtk_widget_show_all (window);
2015   else
2016     gtk_widget_destroy (window);
2017 }
2018
2019 static void
2020 tips_query_widget_entered (GtkTipsQuery   *tips_query,
2021                            GtkWidget      *widget,
2022                            const gchar    *tip_text,
2023                            const gchar    *tip_private,
2024                            GtkWidget      *toggle)
2025 {
2026   if (GTK_TOGGLE_BUTTON (toggle)->active)
2027     {
2028       gtk_label_set_text (GTK_LABEL (tips_query), tip_text ? "There is a Tip!" : "There is no Tip!");
2029       /* don't let GtkTipsQuery reset it's label */
2030       gtk_signal_emit_stop_by_name (GTK_OBJECT (tips_query), "widget_entered");
2031     }
2032 }
2033
2034 static gint
2035 tips_query_widget_selected (GtkWidget      *tips_query,
2036                             GtkWidget      *widget,
2037                             const gchar    *tip_text,
2038                             const gchar    *tip_private,
2039                             GdkEventButton *event,
2040                             gpointer        func_data)
2041 {
2042   if (widget)
2043     g_print ("Help \"%s\" requested for <%s>\n",
2044              tip_private ? tip_private : "None",
2045              gtk_type_name (GTK_OBJECT_TYPE (widget)));
2046   return TRUE;
2047 }
2048
2049 static void
2050 create_tooltips (void)
2051 {
2052   static GtkWidget *window = NULL;
2053   GtkWidget *box1;
2054   GtkWidget *box2;
2055   GtkWidget *box3;
2056   GtkWidget *button;
2057   GtkWidget *toggle;
2058   GtkWidget *frame;
2059   GtkWidget *tips_query;
2060   GtkWidget *separator;
2061   GtkTooltips *tooltips;
2062
2063   if (!window)
2064     {
2065       window =
2066         gtk_widget_new (gtk_window_get_type (),
2067                         "GtkWindow::type", GTK_WINDOW_TOPLEVEL,
2068                         "GtkContainer::border_width", 0,
2069                         "GtkWindow::title", "Tooltips",
2070                         "GtkWindow::allow_shrink", TRUE,
2071                         "GtkWindow::allow_grow", FALSE,
2072                         "GtkWindow::auto_shrink", TRUE,
2073                         "GtkWidget::width", 200,
2074                         NULL);
2075
2076       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2077                           GTK_SIGNAL_FUNC (destroy_tooltips),
2078                           &window);
2079
2080       tooltips=gtk_tooltips_new();
2081       gtk_object_set_data (GTK_OBJECT (window), "tooltips", tooltips);
2082
2083       box1 = gtk_vbox_new (FALSE, 0);
2084       gtk_container_add (GTK_CONTAINER (window), box1);
2085
2086       box2 = gtk_vbox_new (FALSE, 10);
2087       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2088       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2089
2090       button = gtk_toggle_button_new_with_label ("button1");
2091       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2092
2093       gtk_tooltips_set_tip (tooltips,button,"This is button 1", "ContextHelp/buttons/1");
2094
2095       button = gtk_toggle_button_new_with_label ("button2");
2096       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2097
2098       gtk_tooltips_set_tip (tooltips,
2099                             button,
2100                             "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.",
2101                             "ContextHelp/buttons/2_long");
2102
2103       toggle = gtk_toggle_button_new_with_label ("Override TipsQuery Label");
2104       gtk_box_pack_start (GTK_BOX (box2), toggle, TRUE, TRUE, 0);
2105
2106       gtk_tooltips_set_tip (tooltips, toggle, "Toggle TipsQuery view.", "Hi msw! ;)");
2107
2108       box3 =
2109         gtk_widget_new (gtk_vbox_get_type (),
2110                         "GtkBox::homogeneous", FALSE,
2111                         "GtkBox::spacing", 5,
2112                         "GtkContainer::border_width", 5,
2113                         "GtkWidget::visible", TRUE,
2114                         NULL);
2115
2116       tips_query = gtk_tips_query_new ();
2117
2118       button =
2119         gtk_widget_new (gtk_button_get_type (),
2120                         "GtkButton::label", "[?]",
2121                         "GtkWidget::visible", TRUE,
2122                         "GtkWidget::parent", box3,
2123                         "GtkObject::object_signal::clicked", gtk_tips_query_start_query, tips_query,
2124                         NULL);
2125       gtk_box_set_child_packing (GTK_BOX (box3), button, FALSE, FALSE, 0, GTK_PACK_START);
2126       gtk_tooltips_set_tip (tooltips,
2127                             button,
2128                             "Start the Tooltips Inspector",
2129                             "ContextHelp/buttons/?");
2130
2131
2132       gtk_widget_set (tips_query,
2133                       "GtkWidget::visible", TRUE,
2134                       "GtkWidget::parent", box3,
2135                       "GtkTipsQuery::caller", button,
2136                       "GtkObject::signal::widget_entered", tips_query_widget_entered, toggle,
2137                       "GtkObject::signal::widget_selected", tips_query_widget_selected, NULL,
2138                       NULL);
2139
2140       frame =
2141         gtk_widget_new (gtk_frame_get_type (),
2142                         "GtkFrame::label", "ToolTips Inspector",
2143                         "GtkFrame::label_xalign", (double) 0.5,
2144                         "GtkContainer::border_width", 0,
2145                         "GtkWidget::visible", TRUE,
2146                         "GtkWidget::parent", box2,
2147                         "GtkContainer::child", box3,
2148                         NULL);
2149       gtk_box_set_child_packing (GTK_BOX (box2), frame, TRUE, TRUE, 10, GTK_PACK_START);
2150
2151       separator = gtk_hseparator_new ();
2152       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2153
2154       box2 = gtk_vbox_new (FALSE, 10);
2155       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2156       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2157
2158       button = gtk_button_new_with_label ("close");
2159       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2160                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2161                                  GTK_OBJECT (window));
2162       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2163       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2164       gtk_widget_grab_default (button);
2165
2166       gtk_tooltips_set_tip (tooltips, button, "Push this button to close window", "ContextHelp/buttons/Close");
2167     }
2168
2169   if (!GTK_WIDGET_VISIBLE (window))
2170     gtk_widget_show_all (window);
2171   else
2172     gtk_widget_destroy (window);
2173 }
2174
2175 /*
2176  * Menu demo
2177  */
2178
2179 static GtkWidget*
2180 create_menu (gint depth, gboolean tearoff)
2181 {
2182   GtkWidget *menu;
2183   GtkWidget *menuitem;
2184   GSList *group;
2185   char buf[32];
2186   int i, j;
2187
2188   if (depth < 1)
2189     return NULL;
2190
2191   menu = gtk_menu_new ();
2192   group = NULL;
2193
2194   if (tearoff)
2195     {
2196       menuitem = gtk_tearoff_menu_item_new ();
2197       gtk_menu_append (GTK_MENU (menu), menuitem);
2198       gtk_widget_show (menuitem);
2199     }
2200
2201   for (i = 0, j = 1; i < 5; i++, j++)
2202     {
2203       sprintf (buf, "item %2d - %d", depth, j);
2204       menuitem = gtk_radio_menu_item_new_with_label (group, buf);
2205       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
2206       if (depth % 2)
2207         gtk_check_menu_item_set_show_toggle (GTK_CHECK_MENU_ITEM (menuitem), TRUE);
2208       gtk_menu_append (GTK_MENU (menu), menuitem);
2209       gtk_widget_show (menuitem);
2210       if (i == 3)
2211         gtk_widget_set_sensitive (menuitem, FALSE);
2212
2213       gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (depth - 1, TRUE));
2214     }
2215
2216   return menu;
2217 }
2218
2219 static void
2220 create_menus (void)
2221 {
2222   static GtkWidget *window = NULL;
2223   GtkWidget *box1;
2224   GtkWidget *box2;
2225   GtkWidget *button;
2226   GtkWidget *optionmenu;
2227   GtkWidget *separator;
2228
2229   if (!window)
2230     {
2231       GtkWidget *menubar;
2232       GtkWidget *menu;
2233       GtkWidget *menuitem;
2234       GtkAccelGroup *accel_group;
2235
2236       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2237
2238       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2239                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2240                           &window);
2241       gtk_signal_connect (GTK_OBJECT (window), "delete-event",
2242                           GTK_SIGNAL_FUNC (gtk_true),
2243                           NULL);
2244
2245       accel_group = gtk_accel_group_new ();
2246       gtk_accel_group_attach (accel_group, GTK_OBJECT (window));
2247
2248       gtk_window_set_title (GTK_WINDOW (window), "menus");
2249       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2250
2251
2252       box1 = gtk_vbox_new (FALSE, 0);
2253       gtk_container_add (GTK_CONTAINER (window), box1);
2254       gtk_widget_show (box1);
2255
2256       menubar = gtk_menu_bar_new ();
2257       gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
2258       gtk_widget_show (menubar);
2259
2260       menu = create_menu (2, TRUE);
2261
2262       menuitem = gtk_menu_item_new_with_label ("test\nline2");
2263       gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
2264       gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2265       gtk_widget_show (menuitem);
2266
2267       menuitem = gtk_menu_item_new_with_label ("foo");
2268       gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (3, TRUE));
2269       gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2270       gtk_widget_show (menuitem);
2271
2272       menuitem = gtk_menu_item_new_with_label ("bar");
2273       gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4, TRUE));
2274       gtk_menu_item_right_justify (GTK_MENU_ITEM (menuitem));
2275       gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2276       gtk_widget_show (menuitem);
2277
2278       box2 = gtk_vbox_new (FALSE, 10);
2279       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2280       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2281       gtk_widget_show (box2);
2282
2283       menu = create_menu (1, FALSE);
2284       gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);
2285
2286       menuitem = gtk_check_menu_item_new_with_label ("Accelerate Me");
2287       gtk_menu_append (GTK_MENU (menu), menuitem);
2288       gtk_widget_show (menuitem);
2289       gtk_widget_add_accelerator (menuitem,
2290                                   "activate",
2291                                   accel_group,
2292                                   GDK_F1,
2293                                   0,
2294                                   GTK_ACCEL_VISIBLE | GTK_ACCEL_SIGNAL_VISIBLE);
2295       menuitem = gtk_check_menu_item_new_with_label ("Accelerator Locked");
2296       gtk_menu_append (GTK_MENU (menu), menuitem);
2297       gtk_widget_show (menuitem);
2298       gtk_widget_add_accelerator (menuitem,
2299                                   "activate",
2300                                   accel_group,
2301                                   GDK_F2,
2302                                   0,
2303                                   GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
2304       menuitem = gtk_check_menu_item_new_with_label ("Accelerators Frozen");
2305       gtk_menu_append (GTK_MENU (menu), menuitem);
2306       gtk_widget_show (menuitem);
2307       gtk_widget_add_accelerator (menuitem,
2308                                   "activate",
2309                                   accel_group,
2310                                   GDK_F2,
2311                                   0,
2312                                   GTK_ACCEL_VISIBLE);
2313       gtk_widget_add_accelerator (menuitem,
2314                                   "activate",
2315                                   accel_group,
2316                                   GDK_F3,
2317                                   0,
2318                                   GTK_ACCEL_VISIBLE);
2319       gtk_widget_lock_accelerators (menuitem);
2320
2321       optionmenu = gtk_option_menu_new ();
2322       gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), menu);
2323       gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu), 3);
2324       gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0);
2325       gtk_widget_show (optionmenu);
2326
2327       separator = gtk_hseparator_new ();
2328       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2329       gtk_widget_show (separator);
2330
2331       box2 = gtk_vbox_new (FALSE, 10);
2332       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2333       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2334       gtk_widget_show (box2);
2335
2336       button = gtk_button_new_with_label ("close");
2337       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2338                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2339                                  GTK_OBJECT (window));
2340       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2341       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2342       gtk_widget_grab_default (button);
2343       gtk_widget_show (button);
2344     }
2345
2346   if (!GTK_WIDGET_VISIBLE (window))
2347     gtk_widget_show (window);
2348   else
2349     gtk_widget_destroy (window);
2350 }
2351
2352 static void
2353 gtk_ifactory_cb (gpointer             callback_data,
2354                  guint                callback_action,
2355                  GtkWidget           *widget)
2356 {
2357   g_message ("ItemFactory: activated \"%s\"", gtk_item_factory_path_from_widget (widget));
2358 }
2359
2360 static GtkItemFactoryEntry menu_items[] =
2361 {
2362   { "/_File",            NULL,         0,                     0, "<Branch>" },
2363   { "/File/tearoff1",    NULL,         gtk_ifactory_cb,       0, "<Tearoff>" },
2364   { "/File/_New",        "<control>N", gtk_ifactory_cb,       0 },
2365   { "/File/_Open",       "<control>O", gtk_ifactory_cb,       0 },
2366   { "/File/_Save",       "<control>S", gtk_ifactory_cb,       0 },
2367   { "/File/Save _As...", NULL,         gtk_ifactory_cb,       0 },
2368   { "/File/sep1",        NULL,         gtk_ifactory_cb,       0, "<Separator>" },
2369   { "/File/_Quit",       "<control>Q", gtk_ifactory_cb,       0 },
2370
2371   { "/_Preferences",                    NULL, 0,               0, "<Branch>" },
2372   { "/_Preferences/_Color",             NULL, 0,               0, "<Branch>" },
2373   { "/_Preferences/Color/_Red",         NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2374   { "/_Preferences/Color/_Green",       NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2375   { "/_Preferences/Color/_Blue",        NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2376   { "/_Preferences/_Shape",             NULL, 0,               0, "<Branch>" },
2377   { "/_Preferences/Shape/_Square",      NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2378   { "/_Preferences/Shape/_Rectangle",   NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2379   { "/_Preferences/Shape/_Oval",        NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2380
2381   { "/_Help",            NULL,         0,                     0, "<LastBranch>" },
2382   { "/Help/_About",      NULL,         gtk_ifactory_cb,       0 },
2383 };
2384
2385 static int nmenu_items = sizeof (menu_items) / sizeof (menu_items[0]);
2386
2387 static void
2388 create_item_factory (void)
2389 {
2390   static GtkWidget *window = NULL;
2391
2392   if (!window)
2393     {
2394       GtkWidget *box1;
2395       GtkWidget *box2;
2396       GtkWidget *separator;
2397       GtkWidget *label;
2398       GtkWidget *button;
2399       GtkAccelGroup *accel_group;
2400       GtkItemFactory *item_factory;
2401
2402       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2403
2404       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2405                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2406                           &window);
2407       gtk_signal_connect (GTK_OBJECT (window), "delete-event",
2408                           GTK_SIGNAL_FUNC (gtk_true),
2409                           NULL);
2410
2411       accel_group = gtk_accel_group_new ();
2412       item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group);
2413       gtk_item_factory_create_items (item_factory, nmenu_items, menu_items, NULL);
2414       gtk_accel_group_attach (accel_group, GTK_OBJECT (window));
2415       gtk_window_set_title (GTK_WINDOW (window), "Item Factory");
2416       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2417
2418       box1 = gtk_vbox_new (FALSE, 0);
2419       gtk_container_add (GTK_CONTAINER (window), box1);
2420
2421       gtk_box_pack_start (GTK_BOX (box1),
2422                           gtk_item_factory_get_widget (item_factory, "<main>"),
2423                           FALSE, FALSE, 0);
2424
2425       label = gtk_label_new ("Type\n<alt>\nto start");
2426       gtk_widget_set_usize (label, 200, 200);
2427       gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5);
2428       gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
2429
2430
2431       separator = gtk_hseparator_new ();
2432       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2433
2434
2435       box2 = gtk_vbox_new (FALSE, 10);
2436       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2437       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2438
2439       button = gtk_button_new_with_label ("close");
2440       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2441                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2442                                  GTK_OBJECT (window));
2443       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2444       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2445       gtk_widget_grab_default (button);
2446
2447       gtk_widget_show_all (window);
2448     }
2449   else
2450     gtk_widget_destroy (window);
2451 }
2452
2453 /*
2454  * GtkScrolledWindow
2455  */
2456
2457 static void
2458 scrolled_windows_remove (GtkWidget *widget, GtkWidget *scrollwin)
2459 {
2460   static GtkWidget *parent = NULL;
2461   static GtkWidget *float_parent;
2462
2463   if (parent)
2464     {
2465       gtk_widget_reparent (scrollwin, parent);
2466       gtk_widget_destroy (float_parent);
2467       float_parent = NULL;
2468       parent = NULL;
2469     }
2470   else
2471     {
2472       parent = widget->parent;
2473       float_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2474       gtk_widget_reparent (scrollwin, float_parent);
2475       gtk_widget_show (float_parent);
2476     }
2477 }
2478
2479 /*
2480  create_modal_window
2481  */
2482
2483 static gboolean
2484 cmw_destroy_cb(GtkWidget *widget)
2485 {
2486   /* This is needed to get out of gtk_main */
2487   gtk_main_quit ();
2488
2489   return FALSE;
2490 }
2491
2492 static void
2493 cmw_color (GtkWidget *widget, GtkWidget *parent)
2494 {
2495     GtkWidget *csd;
2496
2497     csd=gtk_color_selection_dialog_new ("This is a modal color selection dialog");
2498
2499     /* Set as modal */
2500     gtk_window_set_modal (GTK_WINDOW(csd),TRUE);
2501
2502     /* And mark it as a transient dialog */
2503     gtk_window_set_transient_for (GTK_WINDOW (csd), GTK_WINDOW (parent));
2504
2505     gtk_signal_connect (GTK_OBJECT(csd), "destroy",
2506                         GTK_SIGNAL_FUNC(cmw_destroy_cb),NULL);
2507
2508     gtk_signal_connect_object (GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(csd)->ok_button),
2509                                "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
2510                                GTK_OBJECT (csd));
2511     gtk_signal_connect_object (GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(csd)->cancel_button),
2512                                "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
2513                                GTK_OBJECT (csd));
2514
2515     /* wait until destroy calls gtk_main_quit */
2516     gtk_widget_show (csd);
2517     gtk_main ();
2518 }
2519
2520 static void
2521 cmw_file (GtkWidget *widget, GtkWidget *parent)
2522 {
2523     GtkWidget *fs;
2524
2525     fs = gtk_file_selection_new("This is a modal file selection dialog");
2526
2527     /* Set as modal */
2528     gtk_window_set_modal (GTK_WINDOW(fs),TRUE);
2529
2530     /* And mark it as a transient dialog */
2531     gtk_window_set_transient_for (GTK_WINDOW (fs), GTK_WINDOW (parent));
2532
2533     gtk_signal_connect (GTK_OBJECT(fs), "destroy",
2534                         GTK_SIGNAL_FUNC(cmw_destroy_cb),NULL);
2535
2536     gtk_signal_connect_object (GTK_OBJECT(GTK_FILE_SELECTION(fs)->ok_button),
2537                                "clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy),
2538                                GTK_OBJECT (fs));
2539     gtk_signal_connect_object (GTK_OBJECT(GTK_FILE_SELECTION(fs)->cancel_button),
2540                                "clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy),
2541                                GTK_OBJECT (fs));
2542
2543     /* wait until destroy calls gtk_main_quit */
2544     gtk_widget_show (fs);
2545
2546     gtk_main();
2547 }
2548
2549
2550 static void
2551 create_modal_window (void)
2552 {
2553   GtkWidget *window = NULL;
2554   GtkWidget *box1,*box2;
2555   GtkWidget *frame1;
2556   GtkWidget *btnColor,*btnFile,*btnClose;
2557
2558   /* Create modal window (Here you can use any window descendent )*/
2559   window=gtk_window_new (GTK_WINDOW_TOPLEVEL);
2560   gtk_window_set_title (GTK_WINDOW(window),"This window is modal");
2561
2562   /* Set window as modal */
2563   gtk_window_set_modal (GTK_WINDOW(window),TRUE);
2564
2565   /* Create widgets */
2566   box1 = gtk_vbox_new (FALSE,5);
2567    frame1 = gtk_frame_new ("Standard dialogs in modal form");
2568     box2 = gtk_vbox_new (TRUE,5);
2569      btnColor = gtk_button_new_with_label ("Color");
2570      btnFile = gtk_button_new_with_label ("File Selection");
2571      btnClose = gtk_button_new_with_label ("Close");
2572
2573   /* Init widgets */
2574   gtk_container_set_border_width (GTK_CONTAINER(box1),3);
2575   gtk_container_set_border_width (GTK_CONTAINER(box2),3);
2576
2577   /* Pack widgets */
2578   gtk_container_add (GTK_CONTAINER (window), box1);
2579    gtk_box_pack_start (GTK_BOX (box1), frame1, TRUE, TRUE, 4);
2580     gtk_container_add (GTK_CONTAINER (frame1), box2);
2581      gtk_box_pack_start (GTK_BOX (box2), btnColor, FALSE, FALSE, 4);
2582      gtk_box_pack_start (GTK_BOX (box2), btnFile, FALSE, FALSE, 4);
2583    gtk_box_pack_start (GTK_BOX (box1), gtk_hseparator_new (), FALSE, FALSE, 4);
2584    gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4);
2585
2586   /* connect signals */
2587   gtk_signal_connect_object (GTK_OBJECT (btnClose), "clicked",
2588                              GTK_SIGNAL_FUNC (gtk_widget_destroy),
2589                              GTK_OBJECT (window));
2590
2591   gtk_signal_connect (GTK_OBJECT (window), "destroy",
2592                       GTK_SIGNAL_FUNC (cmw_destroy_cb),NULL);
2593
2594   gtk_signal_connect (GTK_OBJECT (btnColor), "clicked",
2595                       GTK_SIGNAL_FUNC (cmw_color),window);
2596   gtk_signal_connect (GTK_OBJECT (btnFile), "clicked",
2597                       GTK_SIGNAL_FUNC (cmw_file),window);
2598
2599   /* Show widgets */
2600   gtk_widget_show_all (window);
2601
2602   /* wait until dialog get destroyed */
2603   gtk_main();
2604 }
2605
2606 /*
2607  * GtkScrolledWindow
2608  */
2609
2610 static void
2611 create_scrolled_windows (void)
2612 {
2613   static GtkWidget *window;
2614   GtkWidget *scrolled_window;
2615   GtkWidget *table;
2616   GtkWidget *button;
2617   char buffer[32];
2618   int i, j;
2619
2620   if (!window)
2621     {
2622       window = gtk_dialog_new ();
2623
2624       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2625                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2626                           &window);
2627
2628       gtk_window_set_title (GTK_WINDOW (window), "dialog");
2629       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2630
2631
2632       scrolled_window = gtk_scrolled_window_new (NULL, NULL);
2633       gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
2634       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
2635                                       GTK_POLICY_AUTOMATIC,
2636                                       GTK_POLICY_AUTOMATIC);
2637       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
2638                           scrolled_window, TRUE, TRUE, 0);
2639       gtk_widget_show (scrolled_window);
2640
2641       table = gtk_table_new (20, 20, FALSE);
2642       gtk_table_set_row_spacings (GTK_TABLE (table), 10);
2643       gtk_table_set_col_spacings (GTK_TABLE (table), 10);
2644       gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), table);
2645       gtk_container_set_focus_hadjustment (GTK_CONTAINER (table),
2646                                            gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
2647       gtk_container_set_focus_vadjustment (GTK_CONTAINER (table),
2648                                            gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
2649       gtk_widget_show (table);
2650
2651       for (i = 0; i < 20; i++)
2652         for (j = 0; j < 20; j++)
2653           {
2654             sprintf (buffer, "button (%d,%d)\n", i, j);
2655             button = gtk_toggle_button_new_with_label (buffer);
2656             gtk_table_attach_defaults (GTK_TABLE (table), button,
2657                                        i, i+1, j, j+1);
2658             gtk_widget_show (button);
2659           }
2660
2661
2662       button = gtk_button_new_with_label ("close");
2663       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2664                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2665                                  GTK_OBJECT (window));
2666       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2667       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
2668                           button, TRUE, TRUE, 0);
2669       gtk_widget_grab_default (button);
2670       gtk_widget_show (button);
2671
2672       button = gtk_button_new_with_label ("remove");
2673       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2674                                  GTK_SIGNAL_FUNC(scrolled_windows_remove),
2675                                  GTK_OBJECT (scrolled_window));
2676       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2677       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
2678                           button, TRUE, TRUE, 0);
2679       gtk_widget_grab_default (button);
2680       gtk_widget_show (button);
2681
2682       gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
2683     }
2684
2685   if (!GTK_WIDGET_VISIBLE (window))
2686     gtk_widget_show (window);
2687   else
2688     gtk_widget_destroy (window);
2689 }
2690
2691 /*
2692  * GtkEntry
2693  */
2694
2695 static void
2696 entry_toggle_editable (GtkWidget *checkbutton,
2697                        GtkWidget *entry)
2698 {
2699    gtk_entry_set_editable(GTK_ENTRY(entry),
2700                           GTK_TOGGLE_BUTTON(checkbutton)->active);
2701 }
2702
2703 static void
2704 entry_toggle_sensitive (GtkWidget *checkbutton,
2705                         GtkWidget *entry)
2706 {
2707    gtk_widget_set_sensitive (entry, GTK_TOGGLE_BUTTON(checkbutton)->active);
2708 }
2709
2710 static void
2711 entry_toggle_visibility (GtkWidget *checkbutton,
2712                         GtkWidget *entry)
2713 {
2714    gtk_entry_set_visibility(GTK_ENTRY(entry),
2715                          GTK_TOGGLE_BUTTON(checkbutton)->active);
2716 }
2717
2718 static void
2719 create_entry (void)
2720 {
2721   static GtkWidget *window = NULL;
2722   GtkWidget *box1;
2723   GtkWidget *box2;
2724   GtkWidget *editable_check;
2725   GtkWidget *sensitive_check;
2726   GtkWidget *entry, *cb;
2727   GtkWidget *button;
2728   GtkWidget *separator;
2729   GList *cbitems = NULL;
2730
2731   if (!window)
2732     {
2733       cbitems = g_list_append(cbitems, "item0");
2734       cbitems = g_list_append(cbitems, "item1 item1");
2735       cbitems = g_list_append(cbitems, "item2 item2 item2");
2736       cbitems = g_list_append(cbitems, "item3 item3 item3 item3");
2737       cbitems = g_list_append(cbitems, "item4 item4 item4 item4 item4");
2738       cbitems = g_list_append(cbitems, "item5 item5 item5 item5 item5 item5");
2739       cbitems = g_list_append(cbitems, "item6 item6 item6 item6 item6");
2740       cbitems = g_list_append(cbitems, "item7 item7 item7 item7");
2741       cbitems = g_list_append(cbitems, "item8 item8 item8");
2742       cbitems = g_list_append(cbitems, "item9 item9");
2743
2744       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2745
2746       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2747                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2748                           &window);
2749
2750       gtk_window_set_title (GTK_WINDOW (window), "entry");
2751       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2752
2753
2754       box1 = gtk_vbox_new (FALSE, 0);
2755       gtk_container_add (GTK_CONTAINER (window), box1);
2756       gtk_widget_show (box1);
2757
2758
2759       box2 = gtk_vbox_new (FALSE, 10);
2760       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2761       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2762       gtk_widget_show (box2);
2763
2764       entry = gtk_entry_new ();
2765       gtk_entry_set_text (GTK_ENTRY (entry), "hello world");
2766       gtk_editable_select_region (GTK_EDITABLE (entry), 0, 5);
2767       gtk_box_pack_start (GTK_BOX (box2), entry, TRUE, TRUE, 0);
2768       gtk_widget_show (entry);
2769
2770       cb = gtk_combo_new ();
2771       gtk_combo_set_popdown_strings (GTK_COMBO (cb), cbitems);
2772       gtk_entry_set_text (GTK_ENTRY (GTK_COMBO(cb)->entry), "hello world");
2773       gtk_editable_select_region (GTK_EDITABLE (GTK_COMBO(cb)->entry),
2774                                   0, -1);
2775       gtk_box_pack_start (GTK_BOX (box2), cb, TRUE, TRUE, 0);
2776       gtk_widget_show (cb);
2777
2778       editable_check = gtk_check_button_new_with_label("Editable");
2779       gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
2780       gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
2781                           GTK_SIGNAL_FUNC(entry_toggle_editable), entry);
2782       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(editable_check), TRUE);
2783       gtk_widget_show (editable_check);
2784
2785       editable_check = gtk_check_button_new_with_label("Visible");
2786       gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
2787       gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
2788                           GTK_SIGNAL_FUNC(entry_toggle_visibility), entry);
2789       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(editable_check), TRUE);
2790       gtk_widget_show (editable_check);
2791
2792       sensitive_check = gtk_check_button_new_with_label("Sensitive");
2793       gtk_box_pack_start (GTK_BOX (box2), sensitive_check, FALSE, TRUE, 0);
2794       gtk_signal_connect (GTK_OBJECT(sensitive_check), "toggled",
2795                           GTK_SIGNAL_FUNC(entry_toggle_sensitive), entry);
2796       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sensitive_check), TRUE);
2797       gtk_widget_show (sensitive_check);
2798
2799       separator = gtk_hseparator_new ();
2800       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2801       gtk_widget_show (separator);
2802
2803
2804       box2 = gtk_vbox_new (FALSE, 10);
2805       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2806       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2807       gtk_widget_show (box2);
2808
2809
2810       button = gtk_button_new_with_label ("close");
2811       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2812                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2813                                  GTK_OBJECT (window));
2814       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2815       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2816       gtk_widget_grab_default (button);
2817       gtk_widget_show (button);
2818     }
2819
2820   if (!GTK_WIDGET_VISIBLE (window))
2821     gtk_widget_show (window);
2822   else
2823     gtk_widget_destroy (window);
2824 }
2825
2826 /*
2827  * GtkSpinButton
2828  */
2829
2830 static GtkWidget *spinner1;
2831
2832 static void
2833 toggle_snap (GtkWidget *widget, GtkSpinButton *spin)
2834 {
2835   gtk_spin_button_set_snap_to_ticks (spin, GTK_TOGGLE_BUTTON (widget)->active);
2836 }
2837
2838 static void
2839 toggle_numeric (GtkWidget *widget, GtkSpinButton *spin)
2840 {
2841   gtk_spin_button_set_numeric (spin, GTK_TOGGLE_BUTTON (widget)->active);
2842 }
2843
2844 static void
2845 change_digits (GtkWidget *widget, GtkSpinButton *spin)
2846 {
2847   gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spinner1),
2848                               gtk_spin_button_get_value_as_int (spin));
2849 }
2850
2851 static void
2852 get_value (GtkWidget *widget, gpointer data)
2853 {
2854   gchar buf[32];
2855   GtkLabel *label;
2856   GtkSpinButton *spin;
2857
2858   spin = GTK_SPIN_BUTTON (spinner1);
2859   label = GTK_LABEL (gtk_object_get_user_data (GTK_OBJECT (widget)));
2860   if (GPOINTER_TO_INT (data) == 1)
2861     sprintf (buf, "%d", gtk_spin_button_get_value_as_int (spin));
2862   else
2863     sprintf (buf, "%0.*f", spin->digits,
2864              gtk_spin_button_get_value_as_float (spin));
2865   gtk_label_set_text (label, buf);
2866 }
2867
2868 static void
2869 create_spins (void)
2870 {
2871   static GtkWidget *window = NULL;
2872   GtkWidget *frame;
2873   GtkWidget *hbox;
2874   GtkWidget *main_vbox;
2875   GtkWidget *vbox;
2876   GtkWidget *vbox2;
2877   GtkWidget *spinner2;
2878   GtkWidget *spinner;
2879   GtkWidget *button;
2880   GtkWidget *label;
2881   GtkWidget *val_label;
2882   GtkAdjustment *adj;
2883
2884   if (!window)
2885     {
2886       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2887
2888       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2889                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
2890                           &window);
2891
2892       gtk_window_set_title (GTK_WINDOW (window), "GtkSpinButton");
2893
2894       main_vbox = gtk_vbox_new (FALSE, 5);
2895       gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 10);
2896       gtk_container_add (GTK_CONTAINER (window), main_vbox);
2897
2898       frame = gtk_frame_new ("Not accelerated");
2899       gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
2900
2901       vbox = gtk_vbox_new (FALSE, 0);
2902       gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
2903       gtk_container_add (GTK_CONTAINER (frame), vbox);
2904
2905       /* Day, month, year spinners */
2906
2907       hbox = gtk_hbox_new (FALSE, 0);
2908       gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
2909
2910       vbox2 = gtk_vbox_new (FALSE, 0);
2911       gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2912
2913       label = gtk_label_new ("Day :");
2914       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2915       gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2916
2917       adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 31.0, 1.0,
2918                                                   5.0, 0.0);
2919       spinner = gtk_spin_button_new (adj, 0, 0);
2920       gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
2921       gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
2922                                        GTK_SHADOW_OUT);
2923       gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2924
2925       vbox2 = gtk_vbox_new (FALSE, 0);
2926       gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2927
2928       label = gtk_label_new ("Month :");
2929       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2930       gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2931
2932       adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 12.0, 1.0,
2933                                                   5.0, 0.0);
2934       spinner = gtk_spin_button_new (adj, 0, 0);
2935       gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
2936       gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
2937                                        GTK_SHADOW_ETCHED_IN);
2938       gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2939
2940       vbox2 = gtk_vbox_new (FALSE, 0);
2941       gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2942
2943       label = gtk_label_new ("Year :");
2944       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2945       gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2946
2947       adj = (GtkAdjustment *) gtk_adjustment_new (1998.0, 0.0, 2100.0,
2948                                                   1.0, 100.0, 0.0);
2949       spinner = gtk_spin_button_new (adj, 0, 0);
2950       gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
2951       gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
2952                                        GTK_SHADOW_IN);
2953       gtk_widget_set_usize (spinner, 55, 0);
2954       gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2955
2956       frame = gtk_frame_new ("Accelerated");
2957       gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
2958
2959       vbox = gtk_vbox_new (FALSE, 0);
2960       gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
2961       gtk_container_add (GTK_CONTAINER (frame), vbox);
2962
2963       hbox = gtk_hbox_new (FALSE, 0);
2964       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2965
2966       vbox2 = gtk_vbox_new (FALSE, 0);
2967       gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2968
2969       label = gtk_label_new ("Value :");
2970       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2971       gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2972
2973       adj = (GtkAdjustment *) gtk_adjustment_new (0.0, -10000.0, 10000.0,
2974                                                   0.5, 100.0, 0.0);
2975       spinner1 = gtk_spin_button_new (adj, 1.0, 2);
2976       gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner1), TRUE);
2977       gtk_widget_set_usize (spinner1, 100, 0);
2978       gtk_box_pack_start (GTK_BOX (vbox2), spinner1, FALSE, TRUE, 0);
2979
2980       vbox2 = gtk_vbox_new (FALSE, 0);
2981       gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2982
2983       label = gtk_label_new ("Digits :");
2984       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2985       gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2986
2987       adj = (GtkAdjustment *) gtk_adjustment_new (2, 1, 5, 1, 1, 0);
2988       spinner2 = gtk_spin_button_new (adj, 0.0, 0);
2989       gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner2), TRUE);
2990       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
2991                           GTK_SIGNAL_FUNC (change_digits),
2992                           (gpointer) spinner2);
2993       gtk_box_pack_start (GTK_BOX (vbox2), spinner2, FALSE, TRUE, 0);
2994
2995       hbox = gtk_hbox_new (FALSE, 0);
2996       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2997
2998       button = gtk_check_button_new_with_label ("Snap to 0.5-ticks");
2999       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3000                           GTK_SIGNAL_FUNC (toggle_snap),
3001                           spinner1);
3002       gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
3003       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
3004
3005       button = gtk_check_button_new_with_label ("Numeric only input mode");
3006       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3007                           GTK_SIGNAL_FUNC (toggle_numeric),
3008                           spinner1);
3009       gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
3010       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
3011
3012       val_label = gtk_label_new ("");
3013
3014       hbox = gtk_hbox_new (FALSE, 0);
3015       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
3016
3017       button = gtk_button_new_with_label ("Value as Int");
3018       gtk_object_set_user_data (GTK_OBJECT (button), val_label);
3019       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3020                           GTK_SIGNAL_FUNC (get_value),
3021                           GINT_TO_POINTER (1));
3022       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
3023
3024       button = gtk_button_new_with_label ("Value as Float");
3025       gtk_object_set_user_data (GTK_OBJECT (button), val_label);
3026       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3027                           GTK_SIGNAL_FUNC (get_value),
3028                           GINT_TO_POINTER (2));
3029       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
3030
3031       gtk_box_pack_start (GTK_BOX (vbox), val_label, TRUE, TRUE, 0);
3032       gtk_label_set_text (GTK_LABEL (val_label), "0");
3033
3034       hbox = gtk_hbox_new (FALSE, 0);
3035       gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
3036
3037       button = gtk_button_new_with_label ("Close");
3038       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3039                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
3040                                  GTK_OBJECT (window));
3041       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
3042     }
3043
3044   if (!GTK_WIDGET_VISIBLE (window))
3045     gtk_widget_show_all (window);
3046   else
3047     gtk_widget_destroy (window);
3048 }
3049
3050 /*
3051  * Cursors
3052  */
3053
3054 static gint
3055 cursor_expose_event (GtkWidget *widget,
3056                      GdkEvent  *event,
3057                      gpointer   user_data)
3058 {
3059   GtkDrawingArea *darea;
3060   GdkDrawable *drawable;
3061   GdkGC *black_gc;
3062   GdkGC *gray_gc;
3063   GdkGC *white_gc;
3064   guint max_width;
3065   guint max_height;
3066
3067   g_return_val_if_fail (widget != NULL, TRUE);
3068   g_return_val_if_fail (GTK_IS_DRAWING_AREA (widget), TRUE);
3069
3070   darea = GTK_DRAWING_AREA (widget);
3071   drawable = widget->window;
3072   white_gc = widget->style->white_gc;
3073   gray_gc = widget->style->bg_gc[GTK_STATE_NORMAL];
3074   black_gc = widget->style->black_gc;
3075   max_width = widget->allocation.width;
3076   max_height = widget->allocation.height;
3077
3078   gdk_draw_rectangle (drawable, white_gc,
3079                       TRUE,
3080                       0,
3081                       0,
3082                       max_width,
3083                       max_height / 2);
3084
3085   gdk_draw_rectangle (drawable, black_gc,
3086                       TRUE,
3087                       0,
3088                       max_height / 2,
3089                       max_width,
3090                       max_height / 2);
3091
3092   gdk_draw_rectangle (drawable, gray_gc,
3093                       TRUE,
3094                       max_width / 3,
3095                       max_height / 3,
3096                       max_width / 3,
3097                       max_height / 3);
3098
3099   return TRUE;
3100 }
3101
3102 static void
3103 set_cursor (GtkWidget *spinner,
3104             GtkWidget *widget)
3105 {
3106   guint c;
3107   GdkCursor *cursor;
3108   GtkWidget *label;
3109   GtkFlagValue *vals;
3110
3111   c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152);
3112   c &= 0xfe;
3113
3114   label = gtk_object_get_user_data (GTK_OBJECT (spinner));
3115   vals = gtk_type_enum_get_values (GTK_TYPE_GDK_CURSOR_TYPE);
3116   while (vals && vals->value != c)
3117     vals++;
3118   if (vals)
3119     gtk_label_set_text (GTK_LABEL (label), vals->value_nick);
3120   else
3121     gtk_label_set_text (GTK_LABEL (label), "<unknown>");
3122
3123   cursor = gdk_cursor_new (c);
3124   gdk_window_set_cursor (widget->window, cursor);
3125   gdk_cursor_destroy (cursor);
3126 }
3127
3128 static gint
3129 cursor_event (GtkWidget          *widget,
3130               GdkEvent           *event,
3131               GtkSpinButton      *spinner)
3132 {
3133   if ((event->type == GDK_BUTTON_PRESS) &&
3134       ((event->button.button == 1) ||
3135        (event->button.button == 3)))
3136     {
3137       gtk_spin_button_spin (spinner, event->button.button == 1 ?
3138                             GTK_SPIN_STEP_FORWARD : GTK_SPIN_STEP_BACKWARD, 0);
3139       return TRUE;
3140     }
3141
3142   return FALSE;
3143 }
3144
3145 static void
3146 create_cursors (void)
3147 {
3148   static GtkWidget *window = NULL;
3149   GtkWidget *frame;
3150   GtkWidget *hbox;
3151   GtkWidget *main_vbox;
3152   GtkWidget *vbox;
3153   GtkWidget *darea;
3154   GtkWidget *spinner;
3155   GtkWidget *button;
3156   GtkWidget *label;
3157   GtkWidget *any;
3158   GtkAdjustment *adj;
3159
3160   if (!window)
3161     {
3162       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3163
3164       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3165                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
3166                           &window);
3167
3168       gtk_window_set_title (GTK_WINDOW (window), "Cursors");
3169
3170       main_vbox = gtk_vbox_new (FALSE, 5);
3171       gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
3172       gtk_container_add (GTK_CONTAINER (window), main_vbox);
3173
3174       vbox =
3175         gtk_widget_new (gtk_vbox_get_type (),
3176                         "GtkBox::homogeneous", FALSE,
3177                         "GtkBox::spacing", 5,
3178                         "GtkContainer::border_width", 10,
3179                         "GtkWidget::parent", main_vbox,
3180                         "GtkWidget::visible", TRUE,
3181                         NULL);
3182
3183       hbox = gtk_hbox_new (FALSE, 0);
3184       gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
3185       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
3186
3187       label = gtk_label_new ("Cursor Value : ");
3188       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
3189       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
3190
3191       adj = (GtkAdjustment *) gtk_adjustment_new (0,
3192                                                   0, 152,
3193                                                   2,
3194                                                   10, 0);
3195       spinner = gtk_spin_button_new (adj, 0, 0);
3196       gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 0);
3197
3198       frame =
3199         gtk_widget_new (gtk_frame_get_type (),
3200                         "GtkFrame::shadow", GTK_SHADOW_ETCHED_IN,
3201                         "GtkFrame::label_xalign", 0.5,
3202                         "GtkFrame::label", "Cursor Area",
3203                         "GtkContainer::border_width", 10,
3204                         "GtkWidget::parent", vbox,
3205                         "GtkWidget::visible", TRUE,
3206                         NULL);
3207
3208       darea = gtk_drawing_area_new ();
3209       gtk_widget_set_usize (darea, 80, 80);
3210       gtk_container_add (GTK_CONTAINER (frame), darea);
3211       gtk_signal_connect (GTK_OBJECT (darea),
3212                           "expose_event",
3213                           GTK_SIGNAL_FUNC (cursor_expose_event),
3214                           NULL);
3215       gtk_widget_set_events (darea, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
3216       gtk_signal_connect (GTK_OBJECT (darea),
3217                           "button_press_event",
3218                           GTK_SIGNAL_FUNC (cursor_event),
3219                           spinner);
3220       gtk_widget_show (darea);
3221
3222       gtk_signal_connect (GTK_OBJECT (spinner), "changed",
3223                           GTK_SIGNAL_FUNC (set_cursor),
3224                           darea);
3225
3226       label = gtk_widget_new (GTK_TYPE_LABEL,
3227                               "visible", TRUE,
3228                               "label", "XXX",
3229                               "parent", vbox,
3230                               NULL);
3231       gtk_container_child_set (GTK_CONTAINER (vbox), label,
3232                                "expand", FALSE,
3233                                NULL);
3234       gtk_object_set_user_data (GTK_OBJECT (spinner), label);
3235
3236       any =
3237         gtk_widget_new (gtk_hseparator_get_type (),
3238                         "GtkWidget::visible", TRUE,
3239                         NULL);
3240       gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
3241
3242       hbox = gtk_hbox_new (FALSE, 0);
3243       gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
3244       gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
3245
3246       button = gtk_button_new_with_label ("Close");
3247       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3248                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
3249                                  GTK_OBJECT (window));
3250       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
3251
3252       gtk_widget_show_all (window);
3253
3254       set_cursor (spinner, darea);
3255     }
3256   else
3257     gtk_widget_destroy (window);
3258 }
3259
3260 /*
3261  * GtkList
3262  */
3263
3264 static void
3265 list_add (GtkWidget *widget,
3266           GtkWidget *list)
3267 {
3268   static int i = 1;
3269   gchar buffer[64];
3270   GtkWidget *list_item;
3271   GtkContainer *container;
3272
3273   container = GTK_CONTAINER (list);
3274
3275   sprintf (buffer, "added item %d", i++);
3276   list_item = gtk_list_item_new_with_label (buffer);
3277   gtk_widget_show (list_item);
3278
3279   gtk_container_add (container, list_item);
3280 }
3281
3282 static void
3283 list_remove (GtkWidget *widget,
3284              GtkList   *list)
3285 {
3286   GList *clear_list = NULL;
3287   GList *sel_row = NULL;
3288   GList *work = NULL;
3289
3290   if (list->selection_mode == GTK_SELECTION_EXTENDED)
3291     {
3292       GtkWidget *item;
3293
3294       item = GTK_CONTAINER (list)->focus_child;
3295       if (!item && list->selection)
3296         item = list->selection->data;
3297
3298       if (item)
3299         {
3300           work = g_list_find (list->children, item);
3301           for (sel_row = work; sel_row; sel_row = sel_row->next)
3302             if (GTK_WIDGET (sel_row->data)->state != GTK_STATE_SELECTED)
3303               break;
3304
3305           if (!sel_row)
3306             {
3307               for (sel_row = work; sel_row; sel_row = sel_row->prev)
3308                 if (GTK_WIDGET (sel_row->data)->state != GTK_STATE_SELECTED)
3309                   break;
3310             }
3311         }
3312     }
3313
3314   for (work = list->selection; work; work = work->next)
3315     clear_list = g_list_prepend (clear_list, work->data);
3316
3317   clear_list = g_list_reverse (clear_list);
3318   gtk_list_remove_items (GTK_LIST (list), clear_list);
3319   g_list_free (clear_list);
3320
3321   if (list->selection_mode == GTK_SELECTION_EXTENDED && sel_row)
3322     gtk_list_select_child (list, GTK_WIDGET(sel_row->data));
3323 }
3324
3325 static void
3326 list_clear (GtkWidget *widget,
3327             GtkWidget *list)
3328 {
3329   gtk_list_clear_items (GTK_LIST (list), 0, -1);
3330 }
3331
3332 #define RADIOMENUTOGGLED(_rmi_, __i) { \
3333   GSList * __g; \
3334   __i = 0; \
3335   __g = gtk_radio_menu_item_group(_rmi_); \
3336   while( __g  && !((GtkCheckMenuItem *)(__g->data))->active) { \
3337     __g = __g->next; \
3338     __i++; \
3339   }\
3340 }
3341
3342 static GtkWidget *list_omenu;
3343
3344 static void
3345 list_toggle_sel_mode (GtkWidget *widget, GtkList *list)
3346 {
3347   gint i;
3348
3349   if (!GTK_WIDGET_MAPPED (widget))
3350     return;
3351
3352   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
3353                     (((GtkOptionMenu *)list_omenu)->menu_item), i);
3354
3355   gtk_list_set_selection_mode (list, (GtkSelectionMode) (3-i));
3356 }
3357
3358 static void
3359 create_list (void)
3360 {
3361   static GtkWidget *window = NULL;
3362
3363   static OptionMenuItem items[] =
3364   {
3365     { "Single",   list_toggle_sel_mode },
3366     { "Browse",   list_toggle_sel_mode },
3367     { "Multiple", list_toggle_sel_mode },
3368     { "Extended", list_toggle_sel_mode }
3369   };
3370
3371   if (!window)
3372     {
3373       GtkWidget *cbox;
3374       GtkWidget *vbox;
3375       GtkWidget *hbox;
3376       GtkWidget *label;
3377       GtkWidget *scrolled_win;
3378       GtkWidget *list;
3379       GtkWidget *button;
3380       GtkWidget *separator;
3381       FILE *infile;
3382
3383       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3384
3385       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3386                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3387                           &window);
3388
3389       gtk_window_set_title (GTK_WINDOW (window), "list");
3390       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
3391
3392       vbox = gtk_vbox_new (FALSE, 0);
3393       gtk_container_add (GTK_CONTAINER (window), vbox);
3394
3395       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
3396       gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
3397       gtk_widget_set_usize (scrolled_win, -1, 300);
3398       gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
3399       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
3400                                       GTK_POLICY_AUTOMATIC,
3401                                       GTK_POLICY_AUTOMATIC);
3402
3403       list = gtk_list_new ();
3404       gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_EXTENDED);
3405       gtk_scrolled_window_add_with_viewport
3406         (GTK_SCROLLED_WINDOW (scrolled_win), list);
3407       gtk_container_set_focus_vadjustment
3408         (GTK_CONTAINER (list),
3409          gtk_scrolled_window_get_vadjustment
3410          (GTK_SCROLLED_WINDOW (scrolled_win)));
3411       gtk_container_set_focus_hadjustment
3412         (GTK_CONTAINER (list),
3413          gtk_scrolled_window_get_hadjustment
3414          (GTK_SCROLLED_WINDOW (scrolled_win)));
3415
3416       if ((infile = fopen("gtkenums.h", "r")))
3417         {
3418           char buffer[256];
3419           char *pos;
3420           GtkWidget *item;
3421
3422           while (fgets (buffer, 256, infile))
3423             {
3424               if ((pos = strchr (buffer, '\n')))
3425                 *pos = 0;
3426               item = gtk_list_item_new_with_label (buffer);
3427               gtk_container_add (GTK_CONTAINER (list), item);
3428             }
3429
3430           fclose (infile);
3431         }
3432
3433
3434       hbox = gtk_hbox_new (TRUE, 5);
3435       gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
3436       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
3437
3438       button = gtk_button_new_with_label ("Insert Row");
3439       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3440       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3441                           GTK_SIGNAL_FUNC (list_add),
3442                           list);
3443
3444       button = gtk_button_new_with_label ("Clear List");
3445       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3446       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3447                           GTK_SIGNAL_FUNC (list_clear),
3448                           list);
3449
3450       button = gtk_button_new_with_label ("Remove Selection");
3451       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3452       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3453                           GTK_SIGNAL_FUNC (list_remove),
3454                           list);
3455
3456       cbox = gtk_hbox_new (FALSE, 0);
3457       gtk_box_pack_start (GTK_BOX (vbox), cbox, FALSE, TRUE, 0);
3458
3459       hbox = gtk_hbox_new (FALSE, 5);
3460       gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
3461       gtk_box_pack_start (GTK_BOX (cbox), hbox, TRUE, FALSE, 0);
3462
3463       label = gtk_label_new ("Selection Mode :");
3464       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
3465
3466       list_omenu = build_option_menu (items, 4, 3, list);
3467       gtk_box_pack_start (GTK_BOX (hbox), list_omenu, FALSE, TRUE, 0);
3468
3469       separator = gtk_hseparator_new ();
3470       gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, TRUE, 0);
3471
3472       cbox = gtk_hbox_new (FALSE, 0);
3473       gtk_box_pack_start (GTK_BOX (vbox), cbox, FALSE, TRUE, 0);
3474
3475       button = gtk_button_new_with_label ("close");
3476       gtk_container_set_border_width (GTK_CONTAINER (button), 10);
3477       gtk_box_pack_start (GTK_BOX (cbox), button, TRUE, TRUE, 0);
3478       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3479                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
3480                                  GTK_OBJECT (window));
3481
3482       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3483       gtk_widget_grab_default (button);
3484     }
3485
3486   if (!GTK_WIDGET_VISIBLE (window))
3487     gtk_widget_show_all (window);
3488   else
3489     gtk_widget_destroy (window);
3490 }
3491
3492 /*
3493  * GtkCList
3494  */
3495
3496 static char * book_open_xpm[] = {
3497 "16 16 4 1",
3498 "       c None s None",
3499 ".      c black",
3500 "X      c #808080",
3501 "o      c white",
3502 "                ",
3503 "  ..            ",
3504 " .Xo.    ...    ",
3505 " .Xoo. ..oo.    ",
3506 " .Xooo.Xooo...  ",
3507 " .Xooo.oooo.X.  ",
3508 " .Xooo.Xooo.X.  ",
3509 " .Xooo.oooo.X.  ",
3510 " .Xooo.Xooo.X.  ",
3511 " .Xooo.oooo.X.  ",
3512 "  .Xoo.Xoo..X.  ",
3513 "   .Xo.o..ooX.  ",
3514 "    .X..XXXXX.  ",
3515 "    ..X.......  ",
3516 "     ..         ",
3517 "                "};
3518
3519 static char * book_closed_xpm[] = {
3520 "16 16 6 1",
3521 "       c None s None",
3522 ".      c black",
3523 "X      c red",
3524 "o      c yellow",
3525 "O      c #808080",
3526 "#      c white",
3527 "                ",
3528 "       ..       ",
3529 "     ..XX.      ",
3530 "   ..XXXXX.     ",
3531 " ..XXXXXXXX.    ",
3532 ".ooXXXXXXXXX.   ",
3533 "..ooXXXXXXXXX.  ",
3534 ".X.ooXXXXXXXXX. ",
3535 ".XX.ooXXXXXX..  ",
3536 " .XX.ooXXX..#O  ",
3537 "  .XX.oo..##OO. ",
3538 "   .XX..##OO..  ",
3539 "    .X.#OO..    ",
3540 "     ..O..      ",
3541 "      ..        ",
3542 "                "};
3543
3544 static char * mini_page_xpm[] = {
3545 "16 16 4 1",
3546 "       c None s None",
3547 ".      c black",
3548 "X      c white",
3549 "o      c #808080",
3550 "                ",
3551 "   .......      ",
3552 "   .XXXXX..     ",
3553 "   .XoooX.X.    ",
3554 "   .XXXXX....   ",
3555 "   .XooooXoo.o  ",
3556 "   .XXXXXXXX.o  ",
3557 "   .XooooooX.o  ",
3558 "   .XXXXXXXX.o  ",
3559 "   .XooooooX.o  ",
3560 "   .XXXXXXXX.o  ",
3561 "   .XooooooX.o  ",
3562 "   .XXXXXXXX.o  ",
3563 "   ..........o  ",
3564 "    oooooooooo  ",
3565 "                "};
3566
3567 static char * gtk_mini_xpm[] = {
3568 "15 20 17 1",
3569 "       c None",
3570 ".      c #14121F",
3571 "+      c #278828",
3572 "@      c #9B3334",
3573 "#      c #284C72",
3574 "$      c #24692A",
3575 "%      c #69282E",
3576 "&      c #37C539",
3577 "*      c #1D2F4D",
3578 "=      c #6D7076",
3579 "-      c #7D8482",
3580 ";      c #E24A49",
3581 ">      c #515357",
3582 ",      c #9B9C9B",
3583 "'      c #2FA232",
3584 ")      c #3CE23D",
3585 "!      c #3B6CCB",
3586 "               ",
3587 "      ***>     ",
3588 "    >.*!!!*    ",
3589 "   ***....#*=  ",
3590 "  *!*.!!!**!!# ",
3591 " .!!#*!#*!!!!# ",
3592 " @%#!.##.*!!$& ",
3593 " @;%*!*.#!#')) ",
3594 " @;;@%!!*$&)'' ",
3595 " @%.%@%$'&)$+' ",
3596 " @;...@$'*'*)+ ",
3597 " @;%..@$+*.')$ ",
3598 " @;%%;;$+..$)# ",
3599 " @;%%;@$$$'.$# ",
3600 " %;@@;;$$+))&* ",
3601 "  %;;;@+$&)&*  ",
3602 "   %;;@'))+>   ",
3603 "    %;@'&#     ",
3604 "     >%$$      ",
3605 "      >=       "};
3606
3607 #define TESTGTK_CLIST_COLUMNS 12
3608 static gint clist_rows = 0;
3609 static GtkWidget *clist_omenu;
3610
3611 static void
3612 add1000_clist (GtkWidget *widget, gpointer data)
3613 {
3614   gint i, row;
3615   char text[TESTGTK_CLIST_COLUMNS][50];
3616   char *texts[TESTGTK_CLIST_COLUMNS];
3617   GdkBitmap *mask;
3618   GdkPixmap *pixmap;
3619   GtkCList  *clist;
3620
3621   clist = GTK_CLIST (data);
3622
3623   pixmap = gdk_pixmap_create_from_xpm_d (clist->clist_window,
3624                                          &mask,
3625                                          &GTK_WIDGET (data)->style->white,
3626                                          gtk_mini_xpm);
3627
3628   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3629     {
3630       texts[i] = text[i];
3631       sprintf (text[i], "Column %d", i);
3632     }
3633
3634   texts[3] = NULL;
3635   sprintf (text[1], "Right");
3636   sprintf (text[2], "Center");
3637
3638   gtk_clist_freeze (GTK_CLIST (data));
3639   for (i = 0; i < 1000; i++)
3640     {
3641       sprintf (text[0], "CListRow %d", rand() % 10000);
3642       row = gtk_clist_append (clist, texts);
3643       gtk_clist_set_pixtext (clist, row, 3, "gtk+", 5, pixmap, mask);
3644     }
3645
3646   gtk_clist_thaw (GTK_CLIST (data));
3647
3648   gdk_pixmap_unref (pixmap);
3649   gdk_bitmap_unref (mask);
3650 }
3651
3652 static void
3653 add10000_clist (GtkWidget *widget, gpointer data)
3654 {
3655   gint i;
3656   char text[TESTGTK_CLIST_COLUMNS][50];
3657   char *texts[TESTGTK_CLIST_COLUMNS];
3658
3659   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3660     {
3661       texts[i] = text[i];
3662       sprintf (text[i], "Column %d", i);
3663     }
3664
3665   sprintf (text[1], "Right");
3666   sprintf (text[2], "Center");
3667
3668   gtk_clist_freeze (GTK_CLIST (data));
3669   for (i = 0; i < 10000; i++)
3670     {
3671       sprintf (text[0], "CListRow %d", rand() % 10000);
3672       gtk_clist_append (GTK_CLIST (data), texts);
3673     }
3674   gtk_clist_thaw (GTK_CLIST (data));
3675 }
3676
3677 void
3678 clear_clist (GtkWidget *widget, gpointer data)
3679 {
3680   gtk_clist_clear (GTK_CLIST (data));
3681   clist_rows = 0;
3682 }
3683
3684 void clist_remove_selection (GtkWidget *widget, GtkCList *clist)
3685 {
3686   gtk_clist_freeze (clist);
3687
3688   while (clist->selection)
3689     {
3690       gint row;
3691
3692       clist_rows--;
3693       row = GPOINTER_TO_INT (clist->selection->data);
3694
3695       gtk_clist_remove (clist, row);
3696
3697       if (clist->selection_mode == GTK_SELECTION_BROWSE)
3698         break;
3699     }
3700
3701   if (clist->selection_mode == GTK_SELECTION_EXTENDED && !clist->selection &&
3702       clist->focus_row >= 0)
3703     gtk_clist_select_row (clist, clist->focus_row, -1);
3704
3705   gtk_clist_thaw (clist);
3706 }
3707
3708 void toggle_title_buttons (GtkWidget *widget, GtkCList *clist)
3709 {
3710   if (GTK_TOGGLE_BUTTON (widget)->active)
3711     gtk_clist_column_titles_show (clist);
3712   else
3713     gtk_clist_column_titles_hide (clist);
3714 }
3715
3716 void toggle_reorderable (GtkWidget *widget, GtkCList *clist)
3717 {
3718   gtk_clist_set_reorderable (clist, GTK_TOGGLE_BUTTON (widget)->active);
3719 }
3720
3721 static void
3722 insert_row_clist (GtkWidget *widget, gpointer data)
3723 {
3724   static char *text[] =
3725   {
3726     "This", "is an", "inserted", "row.",
3727     "This", "is an", "inserted", "row.",
3728     "This", "is an", "inserted", "row."
3729   };
3730
3731   static GtkStyle *style1 = NULL;
3732   static GtkStyle *style2 = NULL;
3733   static GtkStyle *style3 = NULL;
3734   gint row;
3735
3736   if (GTK_CLIST (data)->focus_row >= 0)
3737     row = gtk_clist_insert (GTK_CLIST (data), GTK_CLIST (data)->focus_row,
3738                             text);
3739   else
3740     row = gtk_clist_prepend (GTK_CLIST (data), text);
3741
3742   if (!style1)
3743     {
3744       GdkColor col1;
3745       GdkColor col2;
3746
3747       col1.red   = 0;
3748       col1.green = 56000;
3749       col1.blue  = 0;
3750       col2.red   = 32000;
3751       col2.green = 0;
3752       col2.blue  = 56000;
3753
3754       style1 = gtk_style_copy (GTK_WIDGET (data)->style);
3755       style1->base[GTK_STATE_NORMAL] = col1;
3756       style1->base[GTK_STATE_SELECTED] = col2;
3757
3758       style2 = gtk_style_copy (GTK_WIDGET (data)->style);
3759       style2->fg[GTK_STATE_NORMAL] = col1;
3760       style2->fg[GTK_STATE_SELECTED] = col2;
3761
3762       style3 = gtk_style_copy (GTK_WIDGET (data)->style);
3763       style3->fg[GTK_STATE_NORMAL] = col1;
3764       style3->base[GTK_STATE_NORMAL] = col2;
3765       gdk_font_unref (style3->font);
3766       style3->font =
3767         gdk_font_load ("-*-courier-medium-*-*-*-*-120-*-*-*-*-*-*");
3768     }
3769
3770   gtk_clist_set_cell_style (GTK_CLIST (data), row, 3, style1);
3771   gtk_clist_set_cell_style (GTK_CLIST (data), row, 4, style2);
3772   gtk_clist_set_cell_style (GTK_CLIST (data), row, 0, style3);
3773
3774   clist_rows++;
3775 }
3776
3777 static void
3778 clist_warning_test (GtkWidget *button,
3779                     GtkWidget *clist)
3780 {
3781   GtkWidget *child;
3782   static gboolean add_remove = FALSE;
3783
3784   add_remove = !add_remove;
3785
3786   child = gtk_label_new ("Test");
3787   gtk_widget_ref (child);
3788   gtk_object_sink (GTK_OBJECT (child));
3789
3790   if (add_remove)
3791     gtk_container_add (GTK_CONTAINER (clist), child);
3792   else
3793     {
3794       child->parent = clist;
3795       gtk_container_remove (GTK_CONTAINER (clist), child);
3796       child->parent = NULL;
3797     }
3798
3799   gtk_widget_destroy (child);
3800   gtk_widget_unref (child);
3801 }
3802
3803 static void
3804 undo_selection (GtkWidget *button, GtkCList *clist)
3805 {
3806   gtk_clist_undo_selection (clist);
3807 }
3808
3809 static void
3810 clist_toggle_sel_mode (GtkWidget *widget, GtkCList *clist)
3811 {
3812   gint i;
3813
3814   if (!GTK_WIDGET_MAPPED (widget))
3815     return;
3816
3817   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
3818                     (((GtkOptionMenu *)clist_omenu)->menu_item), i);
3819
3820   gtk_clist_set_selection_mode (clist, (GtkSelectionMode) (3-i));
3821 }
3822
3823 static void
3824 clist_click_column (GtkCList *clist, gint column, gpointer data)
3825 {
3826   if (column == 4)
3827     gtk_clist_set_column_visibility (clist, column, FALSE);
3828   else if (column == clist->sort_column)
3829     {
3830       if (clist->sort_type == GTK_SORT_ASCENDING)
3831         clist->sort_type = GTK_SORT_DESCENDING;
3832       else
3833         clist->sort_type = GTK_SORT_ASCENDING;
3834     }
3835   else
3836     gtk_clist_set_sort_column (clist, column);
3837
3838   gtk_clist_sort (clist);
3839 }
3840
3841 static void
3842 create_clist (void)
3843 {
3844   gint i;
3845   static GtkWidget *window = NULL;
3846
3847   static char *titles[] =
3848   {
3849     "auto resize", "not resizeable", "max width 100", "min width 50",
3850     "hide column", "Title 5", "Title 6", "Title 7",
3851     "Title 8",  "Title 9",  "Title 10", "Title 11"
3852   };
3853
3854   static OptionMenuItem items[] =
3855   {
3856     { "Single",   clist_toggle_sel_mode },
3857     { "Browse",   clist_toggle_sel_mode },
3858     { "Multiple", clist_toggle_sel_mode },
3859     { "Extended", clist_toggle_sel_mode }
3860   };
3861
3862   char text[TESTGTK_CLIST_COLUMNS][50];
3863   char *texts[TESTGTK_CLIST_COLUMNS];
3864
3865   GtkWidget *vbox;
3866   GtkWidget *hbox;
3867   GtkWidget *clist;
3868   GtkWidget *button;
3869   GtkWidget *separator;
3870   GtkWidget *scrolled_win;
3871   GtkWidget *check;
3872
3873   GtkWidget *undo_button;
3874   GtkWidget *label;
3875
3876   GtkStyle *style;
3877   GdkColor col1;
3878   GdkColor col2;
3879
3880   if (!window)
3881     {
3882       clist_rows = 0;
3883       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3884
3885       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3886                           GTK_SIGNAL_FUNC (gtk_widget_destroyed), &window);
3887
3888       gtk_window_set_title (GTK_WINDOW (window), "clist");
3889       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
3890
3891       vbox = gtk_vbox_new (FALSE, 0);
3892       gtk_container_add (GTK_CONTAINER (window), vbox);
3893
3894       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
3895       gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
3896       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
3897                                       GTK_POLICY_AUTOMATIC,
3898                                       GTK_POLICY_AUTOMATIC);
3899
3900       /* create GtkCList here so we have a pointer to throw at the
3901        * button callbacks -- more is done with it later */
3902       clist = gtk_clist_new_with_titles (TESTGTK_CLIST_COLUMNS, titles);
3903       gtk_container_add (GTK_CONTAINER (scrolled_win), clist);
3904       gtk_signal_connect (GTK_OBJECT (clist), "click_column",
3905                           (GtkSignalFunc) clist_click_column, NULL);
3906
3907       /* control buttons */
3908       hbox = gtk_hbox_new (FALSE, 5);
3909       gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
3910       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
3911
3912       button = gtk_button_new_with_label ("Insert Row");
3913       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3914       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3915                           (GtkSignalFunc) insert_row_clist, (gpointer) clist);
3916
3917       button = gtk_button_new_with_label ("Add 1,000 Rows With Pixmaps");
3918       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3919       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3920                           (GtkSignalFunc) add1000_clist, (gpointer) clist);
3921
3922       button = gtk_button_new_with_label ("Add 10,000 Rows");
3923       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3924       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3925                           (GtkSignalFunc) add10000_clist, (gpointer) clist);
3926
3927       /* second layer of buttons */
3928       hbox = gtk_hbox_new (FALSE, 5);
3929       gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
3930       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
3931
3932       button = gtk_button_new_with_label ("Clear List");
3933       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3934       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3935                           (GtkSignalFunc) clear_clist, (gpointer) clist);
3936
3937       button = gtk_button_new_with_label ("Remove Selection");
3938       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3939       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3940                           (GtkSignalFunc) clist_remove_selection,
3941                           (gpointer) clist);
3942
3943       undo_button = gtk_button_new_with_label ("Undo Selection");
3944       gtk_box_pack_start (GTK_BOX (hbox), undo_button, TRUE, TRUE, 0);
3945       gtk_signal_connect (GTK_OBJECT (undo_button), "clicked",
3946                           (GtkSignalFunc) undo_selection, (gpointer) clist);
3947
3948       button = gtk_button_new_with_label ("Warning Test");
3949       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3950       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3951                           (GtkSignalFunc) clist_warning_test,(gpointer) clist);
3952
3953       /* third layer of buttons */
3954       hbox = gtk_hbox_new (FALSE, 5);
3955       gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
3956       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
3957
3958       check = gtk_check_button_new_with_label ("Show Title Buttons");
3959       gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
3960       gtk_signal_connect (GTK_OBJECT (check), "clicked",
3961                           GTK_SIGNAL_FUNC (toggle_title_buttons), clist);
3962       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
3963
3964       check = gtk_check_button_new_with_label ("Reorderable");
3965       gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
3966       gtk_signal_connect (GTK_OBJECT (check), "clicked",
3967                           GTK_SIGNAL_FUNC (toggle_reorderable), clist);
3968       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
3969
3970       label = gtk_label_new ("Selection Mode :");
3971       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
3972
3973       clist_omenu = build_option_menu (items, 4, 3, clist);
3974       gtk_box_pack_start (GTK_BOX (hbox), clist_omenu, FALSE, TRUE, 0);
3975
3976       /*
3977        * the rest of the clist configuration
3978        */
3979
3980       gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
3981       gtk_clist_set_row_height (GTK_CLIST (clist), 18);
3982       gtk_widget_set_usize (clist, -1, 300);
3983
3984       for (i = 1; i < TESTGTK_CLIST_COLUMNS; i++)
3985         gtk_clist_set_column_width (GTK_CLIST (clist), i, 80);
3986
3987       gtk_clist_set_column_auto_resize (GTK_CLIST (clist), 0, TRUE);
3988       gtk_clist_set_column_resizeable (GTK_CLIST (clist), 1, FALSE);
3989       gtk_clist_set_column_max_width (GTK_CLIST (clist), 2, 100);
3990       gtk_clist_set_column_min_width (GTK_CLIST (clist), 3, 50);
3991       gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_EXTENDED);
3992       gtk_clist_set_column_justification (GTK_CLIST (clist), 1,
3993                                           GTK_JUSTIFY_RIGHT);
3994       gtk_clist_set_column_justification (GTK_CLIST (clist), 2,
3995                                           GTK_JUSTIFY_CENTER);
3996
3997       for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3998         {
3999           texts[i] = text[i];
4000           sprintf (text[i], "Column %d", i);
4001         }
4002
4003       sprintf (text[1], "Right");
4004       sprintf (text[2], "Center");
4005
4006       col1.red   = 56000;
4007       col1.green = 0;
4008       col1.blue  = 0;
4009       col2.red   = 0;
4010       col2.green = 56000;
4011       col2.blue  = 32000;
4012
4013       style = gtk_style_new ();
4014       style->fg[GTK_STATE_NORMAL] = col1;
4015       style->base[GTK_STATE_NORMAL] = col2;
4016
4017       gdk_font_unref (style->font);
4018       style->font =
4019         gdk_font_load ("-adobe-helvetica-bold-r-*-*-*-140-*-*-*-*-*-*");
4020
4021       for (i = 0; i < 10; i++)
4022         {
4023           sprintf (text[0], "CListRow %d", clist_rows++);
4024           gtk_clist_append (GTK_CLIST (clist), texts);
4025
4026           switch (i % 4)
4027             {
4028             case 2:
4029               gtk_clist_set_row_style (GTK_CLIST (clist), i, style);
4030               break;
4031             default:
4032               gtk_clist_set_cell_style (GTK_CLIST (clist), i, i % 4, style);
4033               break;
4034             }
4035         }
4036
4037       separator = gtk_hseparator_new ();
4038       gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, TRUE, 0);
4039
4040       hbox = gtk_hbox_new (FALSE, 0);
4041       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4042
4043       button = gtk_button_new_with_label ("close");
4044       gtk_container_set_border_width (GTK_CONTAINER (button), 10);
4045       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4046       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4047                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
4048                                  GTK_OBJECT (window));
4049
4050       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4051       gtk_widget_grab_default (button);
4052     }
4053
4054   if (!GTK_WIDGET_VISIBLE (window))
4055     gtk_widget_show_all (window);
4056   else
4057     {
4058       clist_rows = 0;
4059       gtk_widget_destroy (window);
4060     }
4061 }
4062
4063 /*
4064  * GtkCTree
4065  */
4066
4067 GdkPixmap *pixmap1;
4068 GdkPixmap *pixmap2;
4069 GdkPixmap *pixmap3;
4070 GdkBitmap *mask1;
4071 GdkBitmap *mask2;
4072 GdkBitmap *mask3;
4073
4074 static gint books = 0;
4075 static gint pages = 0;
4076
4077 static GtkWidget *book_label;
4078 static GtkWidget *page_label;
4079 static GtkWidget *sel_label;
4080 static GtkWidget *vis_label;
4081 static GtkWidget *omenu1;
4082 static GtkWidget *omenu2;
4083 static GtkWidget *omenu3;
4084 static GtkWidget *omenu4;
4085 static GtkWidget *spin1;
4086 static GtkWidget *spin2;
4087 static GtkWidget *spin3;
4088 static gint line_style;
4089
4090 void after_press (GtkCTree *ctree, gpointer data)
4091 {
4092   char buf[80];
4093
4094   sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection));
4095   gtk_label_set_text (GTK_LABEL (sel_label), buf);
4096
4097   sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list));
4098   gtk_label_set_text (GTK_LABEL (vis_label), buf);
4099
4100   sprintf (buf, "%d", books);
4101   gtk_label_set_text (GTK_LABEL (book_label), buf);
4102
4103   sprintf (buf, "%d", pages);
4104   gtk_label_set_text (GTK_LABEL (page_label), buf);
4105 }
4106
4107 void after_move (GtkCTree *ctree, GtkCTreeNode *child, GtkCTreeNode *parent,
4108                  GtkCTreeNode *sibling, gpointer data)
4109 {
4110   char *source;
4111   char *target1;
4112   char *target2;
4113
4114   gtk_ctree_get_node_info (ctree, child, &source,
4115                            NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4116   if (parent)
4117     gtk_ctree_get_node_info (ctree, parent, &target1,
4118                              NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4119   if (sibling)
4120     gtk_ctree_get_node_info (ctree, sibling, &target2,
4121                              NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4122
4123   g_print ("Moving \"%s\" to \"%s\" with sibling \"%s\".\n", source,
4124            (parent) ? target1 : "nil", (sibling) ? target2 : "nil");
4125 }
4126
4127 void count_items (GtkCTree *ctree, GtkCTreeNode *list)
4128 {
4129   if (GTK_CTREE_ROW (list)->is_leaf)
4130     pages--;
4131   else
4132     books--;
4133 }
4134
4135 void expand_all (GtkWidget *widget, GtkCTree *ctree)
4136 {
4137   gtk_ctree_expand_recursive (ctree, NULL);
4138   after_press (ctree, NULL);
4139 }
4140
4141 void collapse_all (GtkWidget *widget, GtkCTree *ctree)
4142 {
4143   gtk_ctree_collapse_recursive (ctree, NULL);
4144   after_press (ctree, NULL);
4145 }
4146
4147 void select_all (GtkWidget *widget, GtkCTree *ctree)
4148 {
4149   gtk_ctree_select_recursive (ctree, NULL);
4150   after_press (ctree, NULL);
4151 }
4152
4153 void change_style (GtkWidget *widget, GtkCTree *ctree)
4154 {
4155   static GtkStyle *style1 = NULL;
4156   static GtkStyle *style2 = NULL;
4157
4158   GtkCTreeNode *node;
4159   GdkColor col1;
4160   GdkColor col2;
4161
4162   if (GTK_CLIST (ctree)->focus_row >= 0)
4163     node = GTK_CTREE_NODE
4164       (g_list_nth (GTK_CLIST (ctree)->row_list,GTK_CLIST (ctree)->focus_row));
4165   else
4166     node = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list);
4167
4168   if (!node)
4169     return;
4170
4171   if (!style1)
4172     {
4173       col1.red   = 0;
4174       col1.green = 56000;
4175       col1.blue  = 0;
4176       col2.red   = 32000;
4177       col2.green = 0;
4178       col2.blue  = 56000;
4179
4180       style1 = gtk_style_new ();
4181       style1->base[GTK_STATE_NORMAL] = col1;
4182       style1->fg[GTK_STATE_SELECTED] = col2;
4183
4184       style2 = gtk_style_new ();
4185       style2->base[GTK_STATE_SELECTED] = col2;
4186       style2->fg[GTK_STATE_NORMAL] = col1;
4187       style2->base[GTK_STATE_NORMAL] = col2;
4188       gdk_font_unref (style2->font);
4189       style2->font =
4190         gdk_font_load ("-*-courier-medium-*-*-*-*-300-*-*-*-*-*-*");
4191     }
4192
4193   gtk_ctree_node_set_cell_style (ctree, node, 1, style1);
4194   gtk_ctree_node_set_cell_style (ctree, node, 0, style2);
4195
4196   if (GTK_CTREE_ROW (node)->children)
4197     gtk_ctree_node_set_row_style (ctree, GTK_CTREE_ROW (node)->children,
4198                                   style2);
4199 }
4200
4201 void unselect_all (GtkWidget *widget, GtkCTree *ctree)
4202 {
4203   gtk_ctree_unselect_recursive (ctree, NULL);
4204   after_press (ctree, NULL);
4205 }
4206
4207 void remove_selection (GtkWidget *widget, GtkCTree *ctree)
4208 {
4209   GtkCList *clist;
4210   GtkCTreeNode *node;
4211
4212   clist = GTK_CLIST (ctree);
4213
4214   gtk_clist_freeze (clist);
4215
4216   while (clist->selection)
4217     {
4218       node = clist->selection->data;
4219
4220       if (GTK_CTREE_ROW (node)->is_leaf)
4221         pages--;
4222       else
4223         gtk_ctree_post_recursive (ctree, node,
4224                                   (GtkCTreeFunc) count_items, NULL);
4225
4226       gtk_ctree_remove_node (ctree, node);
4227
4228       if (clist->selection_mode == GTK_SELECTION_BROWSE)
4229         break;
4230     }
4231
4232   if (clist->selection_mode == GTK_SELECTION_EXTENDED && !clist->selection &&
4233       clist->focus_row >= 0)
4234     {
4235       node = gtk_ctree_node_nth (ctree, clist->focus_row);
4236
4237       if (node)
4238         gtk_ctree_select (ctree, node);
4239     }
4240
4241   gtk_clist_thaw (clist);
4242   after_press (ctree, NULL);
4243 }
4244
4245 struct _ExportStruct {
4246   gchar *tree;
4247   gchar *info;
4248   gboolean is_leaf;
4249 };
4250
4251 typedef struct _ExportStruct ExportStruct;
4252
4253 gboolean
4254 gnode2ctree (GtkCTree   *ctree,
4255              guint       depth,
4256              GNode        *gnode,
4257              GtkCTreeNode *cnode,
4258              gpointer    data)
4259 {
4260   ExportStruct *es;
4261   GdkPixmap *pixmap_closed;
4262   GdkBitmap *mask_closed;
4263   GdkPixmap *pixmap_opened;
4264   GdkBitmap *mask_opened;
4265
4266   if (!cnode || !gnode || (!(es = gnode->data)))
4267     return FALSE;
4268
4269   if (es->is_leaf)
4270     {
4271       pixmap_closed = pixmap3;
4272       mask_closed = mask3;
4273       pixmap_opened = NULL;
4274       mask_opened = NULL;
4275     }
4276   else
4277     {
4278       pixmap_closed = pixmap1;
4279       mask_closed = mask1;
4280       pixmap_opened = pixmap2;
4281       mask_opened = mask2;
4282     }
4283
4284   gtk_ctree_set_node_info (ctree, cnode, es->tree, 2, pixmap_closed,
4285                            mask_closed, pixmap_opened, mask_opened,
4286                            es->is_leaf, (depth < 3));
4287   gtk_ctree_node_set_text (ctree, cnode, 1, es->info);
4288   g_free (es);
4289   gnode->data = NULL;
4290
4291   return TRUE;
4292 }
4293
4294 gboolean
4295 ctree2gnode (GtkCTree   *ctree,
4296              guint       depth,
4297              GNode        *gnode,
4298              GtkCTreeNode *cnode,
4299              gpointer    data)
4300 {
4301   ExportStruct *es;
4302
4303   if (!cnode || !gnode)
4304     return FALSE;
4305
4306   es = g_new (ExportStruct, 1);
4307   gnode->data = es;
4308   es->is_leaf = GTK_CTREE_ROW (cnode)->is_leaf;
4309   es->tree = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[0])->text;
4310   es->info = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[1])->text;
4311   return TRUE;
4312 }
4313
4314 void export_ctree (GtkWidget *widget, GtkCTree *ctree)
4315 {
4316   char *title[] = { "Tree" , "Info" };
4317   static GtkWidget *export_window = NULL;
4318   static GtkCTree *export_ctree;
4319   GtkWidget *vbox;
4320   GtkWidget *scrolled_win;
4321   GtkWidget *button;
4322   GtkWidget *sep;
4323   GNode *gnode;
4324   GtkCTreeNode *node;
4325
4326   if (!export_window)
4327     {
4328       export_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4329
4330       gtk_signal_connect (GTK_OBJECT (export_window), "destroy",
4331                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
4332                           &export_window);
4333
4334       gtk_window_set_title (GTK_WINDOW (export_window), "exported ctree");
4335       gtk_container_set_border_width (GTK_CONTAINER (export_window), 5);
4336
4337       vbox = gtk_vbox_new (FALSE, 0);
4338       gtk_container_add (GTK_CONTAINER (export_window), vbox);
4339
4340       button = gtk_button_new_with_label ("Close");
4341       gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, TRUE, 0);
4342
4343       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4344                                  (GtkSignalFunc) gtk_widget_destroy,
4345                                  GTK_OBJECT(export_window));
4346
4347       sep = gtk_hseparator_new ();
4348       gtk_box_pack_end (GTK_BOX (vbox), sep, FALSE, TRUE, 10);
4349
4350       export_ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title));
4351       gtk_ctree_set_line_style (export_ctree, GTK_CTREE_LINES_DOTTED);
4352
4353       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
4354       gtk_container_add (GTK_CONTAINER (scrolled_win),
4355                          GTK_WIDGET (export_ctree));
4356       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
4357                                       GTK_POLICY_AUTOMATIC,
4358                                       GTK_POLICY_AUTOMATIC);
4359       gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
4360       gtk_clist_set_selection_mode (GTK_CLIST (export_ctree),
4361                                     GTK_SELECTION_EXTENDED);
4362       gtk_clist_set_column_width (GTK_CLIST (export_ctree), 0, 200);
4363       gtk_clist_set_column_width (GTK_CLIST (export_ctree), 1, 200);
4364       gtk_widget_set_usize (GTK_WIDGET (export_ctree), 300, 200);
4365     }
4366
4367   if (!GTK_WIDGET_VISIBLE (export_window))
4368     gtk_widget_show_all (export_window);
4369
4370   gtk_clist_clear (GTK_CLIST (export_ctree));
4371
4372   node = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list,
4373                                      GTK_CLIST (ctree)->focus_row));
4374   if (!node)
4375     return;
4376
4377   gnode = gtk_ctree_export_to_gnode (ctree, NULL, NULL, node,
4378                                      ctree2gnode, NULL);
4379   if (gnode)
4380     {
4381       gtk_ctree_insert_gnode (export_ctree, NULL, NULL, gnode,
4382                               gnode2ctree, NULL);
4383       g_node_destroy (gnode);
4384     }
4385 }
4386
4387 void change_indent (GtkWidget *widget, GtkCTree *ctree)
4388 {
4389   gtk_ctree_set_indent (ctree, GTK_ADJUSTMENT (widget)->value);
4390 }
4391
4392 void change_spacing (GtkWidget *widget, GtkCTree *ctree)
4393 {
4394   gtk_ctree_set_spacing (ctree, GTK_ADJUSTMENT (widget)->value);
4395 }
4396
4397 void change_row_height (GtkWidget *widget, GtkCList *clist)
4398 {
4399   gtk_clist_set_row_height (clist, GTK_ADJUSTMENT (widget)->value);
4400 }
4401
4402 void set_background (GtkCTree *ctree, GtkCTreeNode *node, gpointer data)
4403 {
4404   GtkStyle *style = NULL;
4405
4406   if (!node)
4407     return;
4408
4409   if (ctree->line_style != GTK_CTREE_LINES_TABBED)
4410     {
4411       if (!GTK_CTREE_ROW (node)->is_leaf)
4412         style = GTK_CTREE_ROW (node)->row.data;
4413       else if (GTK_CTREE_ROW (node)->parent)
4414         style = GTK_CTREE_ROW (GTK_CTREE_ROW (node)->parent)->row.data;
4415     }
4416
4417   gtk_ctree_node_set_row_style (ctree, node, style);
4418 }
4419
4420 void ctree_toggle_line_style (GtkWidget *widget, GtkCTree *ctree)
4421 {
4422   gint i;
4423
4424   if (!GTK_WIDGET_MAPPED (widget))
4425     return;
4426
4427   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4428                     (((GtkOptionMenu *)omenu1)->menu_item), i);
4429
4430   if ((ctree->line_style == GTK_CTREE_LINES_TABBED &&
4431        ((GtkCTreeLineStyle) (3 - i)) != GTK_CTREE_LINES_TABBED) ||
4432       (ctree->line_style != GTK_CTREE_LINES_TABBED &&
4433        ((GtkCTreeLineStyle) (3 - i)) == GTK_CTREE_LINES_TABBED))
4434     gtk_ctree_pre_recursive (ctree, NULL, set_background, NULL);
4435   gtk_ctree_set_line_style (ctree, 3 - i);
4436   line_style = 3 - i;
4437 }
4438
4439 void ctree_toggle_expander_style (GtkWidget *widget, GtkCTree *ctree)
4440 {
4441   gint i;
4442
4443   if (!GTK_WIDGET_MAPPED (widget))
4444     return;
4445
4446   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4447                     (((GtkOptionMenu *)omenu2)->menu_item), i);
4448
4449   gtk_ctree_set_expander_style (ctree, (GtkCTreeExpanderStyle) (3 - i));
4450 }
4451
4452 void ctree_toggle_justify (GtkWidget *widget, GtkCTree *ctree)
4453 {
4454   gint i;
4455
4456   if (!GTK_WIDGET_MAPPED (widget))
4457     return;
4458
4459   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4460                     (((GtkOptionMenu *)omenu3)->menu_item), i);
4461
4462   gtk_clist_set_column_justification (GTK_CLIST (ctree), ctree->tree_column,
4463                                       (GtkJustification) (1 - i));
4464 }
4465
4466 void ctree_toggle_sel_mode (GtkWidget *widget, GtkCTree *ctree)
4467 {
4468   gint i;
4469
4470   if (!GTK_WIDGET_MAPPED (widget))
4471     return;
4472
4473   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4474                     (((GtkOptionMenu *)omenu4)->menu_item), i);
4475
4476   gtk_clist_set_selection_mode (GTK_CLIST (ctree), (GtkSelectionMode) (3 - i));
4477   after_press (ctree, NULL);
4478 }
4479
4480 void build_recursive (GtkCTree *ctree, gint cur_depth, gint depth,
4481                       gint num_books, gint num_pages, GtkCTreeNode *parent)
4482 {
4483   gchar *text[2];
4484   gchar buf1[60];
4485   gchar buf2[60];
4486   GtkCTreeNode *sibling;
4487   gint i;
4488
4489   text[0] = buf1;
4490   text[1] = buf2;
4491   sibling = NULL;
4492
4493   for (i = num_pages + num_books; i > num_books; i--)
4494     {
4495       pages++;
4496       sprintf (buf1, "Page %02d", (gint) rand() % 100);
4497       sprintf (buf2, "Item %d-%d", cur_depth, i);
4498       sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
4499                                        pixmap3, mask3, NULL, NULL,
4500                                        TRUE, FALSE);
4501
4502       if (parent && ctree->line_style == GTK_CTREE_LINES_TABBED)
4503         gtk_ctree_node_set_row_style (ctree, sibling,
4504                                       GTK_CTREE_ROW (parent)->row.style);
4505     }
4506
4507   if (cur_depth == depth)
4508     return;
4509
4510   for (i = num_books; i > 0; i--)
4511     {
4512       GtkStyle *style;
4513
4514       books++;
4515       sprintf (buf1, "Book %02d", (gint) rand() % 100);
4516       sprintf (buf2, "Item %d-%d", cur_depth, i);
4517       sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
4518                                        pixmap1, mask1, pixmap2, mask2,
4519                                        FALSE, FALSE);
4520
4521       style = gtk_style_new ();
4522       switch (cur_depth % 3)
4523         {
4524         case 0:
4525           style->base[GTK_STATE_NORMAL].red   = 10000 * (cur_depth % 6);
4526           style->base[GTK_STATE_NORMAL].green = 0;
4527           style->base[GTK_STATE_NORMAL].blue  = 65535 - ((i * 10000) % 65535);
4528           break;
4529         case 1:
4530           style->base[GTK_STATE_NORMAL].red   = 10000 * (cur_depth % 6);
4531           style->base[GTK_STATE_NORMAL].green = 65535 - ((i * 10000) % 65535);
4532           style->base[GTK_STATE_NORMAL].blue  = 0;
4533           break;
4534         default:
4535           style->base[GTK_STATE_NORMAL].red   = 65535 - ((i * 10000) % 65535);
4536           style->base[GTK_STATE_NORMAL].green = 0;
4537           style->base[GTK_STATE_NORMAL].blue  = 10000 * (cur_depth % 6);
4538           break;
4539         }
4540       gtk_ctree_node_set_row_data_full (ctree, sibling, style,
4541                                         (GtkDestroyNotify) gtk_style_unref);
4542
4543       if (ctree->line_style == GTK_CTREE_LINES_TABBED)
4544         gtk_ctree_node_set_row_style (ctree, sibling, style);
4545
4546       build_recursive (ctree, cur_depth + 1, depth, num_books, num_pages,
4547                        sibling);
4548     }
4549 }
4550
4551 void rebuild_tree (GtkWidget *widget, GtkCTree *ctree)
4552 {
4553   gchar *text [2];
4554   gchar label1[] = "Root";
4555   gchar label2[] = "";
4556   GtkCTreeNode *parent;
4557   GtkStyle *style;
4558   guint b, d, p, n;
4559
4560   text[0] = label1;
4561   text[1] = label2;
4562
4563   d = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin1));
4564   b = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin2));
4565   p = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin3));
4566
4567   n = ((pow (b, d) - 1) / (b - 1)) * (p + 1);
4568
4569   if (n > 100000)
4570     {
4571       g_print ("%d total items? Try less\n",n);
4572       return;
4573     }
4574
4575   gtk_clist_freeze (GTK_CLIST (ctree));
4576   gtk_clist_clear (GTK_CLIST (ctree));
4577
4578   books = 1;
4579   pages = 0;
4580
4581   parent = gtk_ctree_insert_node (ctree, NULL, NULL, text, 5, pixmap1,
4582                                   mask1, pixmap2, mask2, FALSE, TRUE);
4583
4584   style = gtk_style_new ();
4585   style->base[GTK_STATE_NORMAL].red   = 0;
4586   style->base[GTK_STATE_NORMAL].green = 45000;
4587   style->base[GTK_STATE_NORMAL].blue  = 55000;
4588   gtk_ctree_node_set_row_data_full (ctree, parent, style,
4589                                     (GtkDestroyNotify) gtk_style_unref);
4590
4591   if (ctree->line_style == GTK_CTREE_LINES_TABBED)
4592     gtk_ctree_node_set_row_style (ctree, parent, style);
4593
4594   build_recursive (ctree, 1, d, b, p, parent);
4595   gtk_clist_thaw (GTK_CLIST (ctree));
4596   after_press (ctree, NULL);
4597 }
4598
4599 static void
4600 ctree_click_column (GtkCTree *ctree, gint column, gpointer data)
4601 {
4602   GtkCList *clist;
4603
4604   clist = GTK_CLIST (ctree);
4605
4606   if (column == clist->sort_column)
4607     {
4608       if (clist->sort_type == GTK_SORT_ASCENDING)
4609         clist->sort_type = GTK_SORT_DESCENDING;
4610       else
4611         clist->sort_type = GTK_SORT_ASCENDING;
4612     }
4613   else
4614     gtk_clist_set_sort_column (clist, column);
4615
4616   gtk_ctree_sort_recursive (ctree, NULL);
4617 }
4618
4619 void create_ctree (void)
4620 {
4621   static GtkWidget *window = NULL;
4622   GtkTooltips *tooltips;
4623   GtkCTree *ctree;
4624   GtkWidget *scrolled_win;
4625   GtkWidget *vbox;
4626   GtkWidget *bbox;
4627   GtkWidget *mbox;
4628   GtkWidget *hbox;
4629   GtkWidget *hbox2;
4630   GtkWidget *frame;
4631   GtkWidget *label;
4632   GtkWidget *button;
4633   GtkWidget *check;
4634   GtkAdjustment *adj;
4635   GtkWidget *spinner;
4636   GdkColor transparent;
4637
4638   char *title[] = { "Tree" , "Info" };
4639   char buf[80];
4640
4641   static OptionMenuItem items1[] =
4642   {
4643     { "No lines", ctree_toggle_line_style },
4644     { "Solid",    ctree_toggle_line_style },
4645     { "Dotted",   ctree_toggle_line_style },
4646     { "Tabbed",   ctree_toggle_line_style }
4647   };
4648
4649   static OptionMenuItem items2[] =
4650   {
4651     { "None",     ctree_toggle_expander_style },
4652     { "Square",   ctree_toggle_expander_style },
4653     { "Triangle", ctree_toggle_expander_style },
4654     { "Circular", ctree_toggle_expander_style }
4655   };
4656
4657   static OptionMenuItem items3[] =
4658   {
4659     { "Left",  ctree_toggle_justify },
4660     { "Right", ctree_toggle_justify }
4661   };
4662
4663   static OptionMenuItem items4[] =
4664   {
4665     { "Single",   ctree_toggle_sel_mode },
4666     { "Browse",   ctree_toggle_sel_mode },
4667     { "Multiple", ctree_toggle_sel_mode },
4668     { "Extended", ctree_toggle_sel_mode }
4669   };
4670
4671   if (!window)
4672     {
4673       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4674
4675       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4676                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
4677                           &window);
4678
4679       gtk_window_set_title (GTK_WINDOW (window), "GtkCTree");
4680       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
4681
4682       tooltips = gtk_tooltips_new ();
4683       gtk_object_ref (GTK_OBJECT (tooltips));
4684       gtk_object_sink (GTK_OBJECT (tooltips));
4685
4686       gtk_object_set_data_full (GTK_OBJECT (window), "tooltips", tooltips,
4687                                 (GtkDestroyNotify) gtk_object_unref);
4688
4689       vbox = gtk_vbox_new (FALSE, 0);
4690       gtk_container_add (GTK_CONTAINER (window), vbox);
4691
4692       hbox = gtk_hbox_new (FALSE, 5);
4693       gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
4694       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4695
4696       label = gtk_label_new ("Depth :");
4697       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4698
4699       adj = (GtkAdjustment *) gtk_adjustment_new (4, 1, 10, 1, 5, 0);
4700       spin1 = gtk_spin_button_new (adj, 0, 0);
4701       gtk_box_pack_start (GTK_BOX (hbox), spin1, FALSE, TRUE, 5);
4702
4703       label = gtk_label_new ("Books :");
4704       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4705
4706       adj = (GtkAdjustment *) gtk_adjustment_new (3, 1, 20, 1, 5, 0);
4707       spin2 = gtk_spin_button_new (adj, 0, 0);
4708       gtk_box_pack_start (GTK_BOX (hbox), spin2, FALSE, TRUE, 5);
4709
4710       label = gtk_label_new ("Pages :");
4711       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4712
4713       adj = (GtkAdjustment *) gtk_adjustment_new (5, 1, 20, 1, 5, 0);
4714       spin3 = gtk_spin_button_new (adj, 0, 0);
4715       gtk_box_pack_start (GTK_BOX (hbox), spin3, FALSE, TRUE, 5);
4716
4717       button = gtk_button_new_with_label ("Close");
4718       gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4719
4720       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4721                                  (GtkSignalFunc) gtk_widget_destroy,
4722                                  GTK_OBJECT(window));
4723
4724       button = gtk_button_new_with_label ("Rebuild Tree");
4725       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4726
4727       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
4728       gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
4729       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
4730                                       GTK_POLICY_AUTOMATIC,
4731                                       GTK_POLICY_ALWAYS);
4732       gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
4733
4734       ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title));
4735       gtk_container_add (GTK_CONTAINER (scrolled_win), GTK_WIDGET (ctree));
4736
4737       gtk_clist_set_column_auto_resize (GTK_CLIST (ctree), 0, TRUE);
4738       gtk_clist_set_column_width (GTK_CLIST (ctree), 1, 200);
4739       gtk_clist_set_selection_mode (GTK_CLIST (ctree), GTK_SELECTION_EXTENDED);
4740       gtk_ctree_set_line_style (ctree, GTK_CTREE_LINES_DOTTED);
4741       line_style = GTK_CTREE_LINES_DOTTED;
4742
4743       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4744                           GTK_SIGNAL_FUNC (rebuild_tree), ctree);
4745       gtk_signal_connect (GTK_OBJECT (ctree), "click_column",
4746                           (GtkSignalFunc) ctree_click_column, NULL);
4747
4748       gtk_signal_connect_after (GTK_OBJECT (ctree), "button_press_event",
4749                                 GTK_SIGNAL_FUNC (after_press), NULL);
4750       gtk_signal_connect_after (GTK_OBJECT (ctree), "button_release_event",
4751                                 GTK_SIGNAL_FUNC (after_press), NULL);
4752       gtk_signal_connect_after (GTK_OBJECT (ctree), "tree_move",
4753                                 GTK_SIGNAL_FUNC (after_move), NULL);
4754       gtk_signal_connect_after (GTK_OBJECT (ctree), "end_selection",
4755                                 GTK_SIGNAL_FUNC (after_press), NULL);
4756       gtk_signal_connect_after (GTK_OBJECT (ctree), "toggle_focus_row",
4757                                 GTK_SIGNAL_FUNC (after_press), NULL);
4758       gtk_signal_connect_after (GTK_OBJECT (ctree), "select_all",
4759                                 GTK_SIGNAL_FUNC (after_press), NULL);
4760       gtk_signal_connect_after (GTK_OBJECT (ctree), "unselect_all",
4761                                 GTK_SIGNAL_FUNC (after_press), NULL);
4762       gtk_signal_connect_after (GTK_OBJECT (ctree), "scroll_vertical",
4763                                 GTK_SIGNAL_FUNC (after_press), NULL);
4764
4765       bbox = gtk_hbox_new (FALSE, 5);
4766       gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
4767       gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, TRUE, 0);
4768
4769       mbox = gtk_vbox_new (TRUE, 5);
4770       gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
4771
4772       label = gtk_label_new ("Row Height :");
4773       gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
4774
4775       label = gtk_label_new ("Indent :");
4776       gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
4777
4778       label = gtk_label_new ("Spacing :");
4779       gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
4780
4781       mbox = gtk_vbox_new (TRUE, 5);
4782       gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
4783
4784       adj = (GtkAdjustment *) gtk_adjustment_new (20, 12, 100, 1, 10, 0);
4785       spinner = gtk_spin_button_new (adj, 0, 0);
4786       gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
4787       gtk_tooltips_set_tip (tooltips, spinner,
4788                             "Row height of list items", NULL);
4789       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
4790                           GTK_SIGNAL_FUNC (change_row_height), ctree);
4791       gtk_clist_set_row_height ( GTK_CLIST (ctree), adj->value);
4792
4793       adj = (GtkAdjustment *) gtk_adjustment_new (20, 0, 60, 1, 10, 0);
4794       spinner = gtk_spin_button_new (adj, 0, 0);
4795       gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
4796       gtk_tooltips_set_tip (tooltips, spinner, "Tree Indentation.", NULL);
4797       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
4798                           GTK_SIGNAL_FUNC (change_indent), ctree);
4799
4800       adj = (GtkAdjustment *) gtk_adjustment_new (5, 0, 60, 1, 10, 0);
4801       spinner = gtk_spin_button_new (adj, 0, 0);
4802       gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
4803       gtk_tooltips_set_tip (tooltips, spinner, "Tree Spacing.", NULL);
4804       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
4805                           GTK_SIGNAL_FUNC (change_spacing), ctree);
4806
4807       mbox = gtk_vbox_new (TRUE, 5);
4808       gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
4809
4810       hbox = gtk_hbox_new (FALSE, 5);
4811       gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
4812
4813       button = gtk_button_new_with_label ("Expand All");
4814       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4815       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4816                           GTK_SIGNAL_FUNC (expand_all), ctree);
4817
4818       button = gtk_button_new_with_label ("Collapse All");
4819       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4820       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4821                           GTK_SIGNAL_FUNC (collapse_all), ctree);
4822
4823       button = gtk_button_new_with_label ("Change Style");
4824       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4825       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4826                           GTK_SIGNAL_FUNC (change_style), ctree);
4827
4828       button = gtk_button_new_with_label ("Export Tree");
4829       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4830       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4831                           GTK_SIGNAL_FUNC (export_ctree), ctree);
4832
4833       hbox = gtk_hbox_new (FALSE, 5);
4834       gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
4835
4836       button = gtk_button_new_with_label ("Select All");
4837       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4838       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4839                           GTK_SIGNAL_FUNC (select_all), ctree);
4840
4841       button = gtk_button_new_with_label ("Unselect All");
4842       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4843       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4844                           GTK_SIGNAL_FUNC (unselect_all), ctree);
4845
4846       button = gtk_button_new_with_label ("Remove Selection");
4847       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4848       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4849                           GTK_SIGNAL_FUNC (remove_selection), ctree);
4850
4851       check = gtk_check_button_new_with_label ("Reorderable");
4852       gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
4853       gtk_tooltips_set_tip (tooltips, check,
4854                             "Tree items can be reordered by dragging.", NULL);
4855       gtk_signal_connect (GTK_OBJECT (check), "clicked",
4856                           GTK_SIGNAL_FUNC (toggle_reorderable), ctree);
4857       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
4858
4859       hbox = gtk_hbox_new (TRUE, 5);
4860       gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
4861
4862       omenu1 = build_option_menu (items1, 4, 2, ctree);
4863       gtk_box_pack_start (GTK_BOX (hbox), omenu1, FALSE, TRUE, 0);
4864       gtk_tooltips_set_tip (tooltips, omenu1, "The tree's line style.", NULL);
4865
4866       omenu2 = build_option_menu (items2, 4, 1, ctree);
4867       gtk_box_pack_start (GTK_BOX (hbox), omenu2, FALSE, TRUE, 0);
4868       gtk_tooltips_set_tip (tooltips, omenu2, "The tree's expander style.",
4869                             NULL);
4870
4871       omenu3 = build_option_menu (items3, 2, 0, ctree);
4872       gtk_box_pack_start (GTK_BOX (hbox), omenu3, FALSE, TRUE, 0);
4873       gtk_tooltips_set_tip (tooltips, omenu3, "The tree's justification.",
4874                             NULL);
4875
4876       omenu4 = build_option_menu (items4, 4, 3, ctree);
4877       gtk_box_pack_start (GTK_BOX (hbox), omenu4, FALSE, TRUE, 0);
4878       gtk_tooltips_set_tip (tooltips, omenu4, "The list's selection mode.",
4879                             NULL);
4880
4881       gtk_widget_realize (window);
4882
4883       pixmap1 = gdk_pixmap_create_from_xpm_d (window->window, &mask1,
4884                                               &transparent, book_closed_xpm);
4885       pixmap2 = gdk_pixmap_create_from_xpm_d (window->window, &mask2,
4886                                               &transparent, book_open_xpm);
4887       pixmap3 = gdk_pixmap_create_from_xpm_d (window->window, &mask3,
4888                                               &transparent, mini_page_xpm);
4889
4890       gtk_widget_set_usize (GTK_WIDGET (ctree), 0, 300);
4891
4892       frame = gtk_frame_new (NULL);
4893       gtk_container_set_border_width (GTK_CONTAINER (frame), 0);
4894       gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
4895       gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
4896
4897       hbox = gtk_hbox_new (TRUE, 2);
4898       gtk_container_set_border_width (GTK_CONTAINER (hbox), 2);
4899       gtk_container_add (GTK_CONTAINER (frame), hbox);
4900
4901       frame = gtk_frame_new (NULL);
4902       gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
4903       gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
4904
4905       hbox2 = gtk_hbox_new (FALSE, 0);
4906       gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
4907       gtk_container_add (GTK_CONTAINER (frame), hbox2);
4908
4909       label = gtk_label_new ("Books :");
4910       gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
4911
4912       sprintf (buf, "%d", books);
4913       book_label = gtk_label_new (buf);
4914       gtk_box_pack_end (GTK_BOX (hbox2), book_label, FALSE, TRUE, 5);
4915
4916       frame = gtk_frame_new (NULL);
4917       gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
4918       gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
4919
4920       hbox2 = gtk_hbox_new (FALSE, 0);
4921       gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
4922       gtk_container_add (GTK_CONTAINER (frame), hbox2);
4923
4924       label = gtk_label_new ("Pages :");
4925       gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
4926
4927       sprintf (buf, "%d", pages);
4928       page_label = gtk_label_new (buf);
4929       gtk_box_pack_end (GTK_BOX (hbox2), page_label, FALSE, TRUE, 5);
4930
4931       frame = gtk_frame_new (NULL);
4932       gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
4933       gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
4934
4935       hbox2 = gtk_hbox_new (FALSE, 0);
4936       gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
4937       gtk_container_add (GTK_CONTAINER (frame), hbox2);
4938
4939       label = gtk_label_new ("Selected :");
4940       gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
4941
4942       sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection));
4943       sel_label = gtk_label_new (buf);
4944       gtk_box_pack_end (GTK_BOX (hbox2), sel_label, FALSE, TRUE, 5);
4945
4946       frame = gtk_frame_new (NULL);
4947       gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
4948       gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
4949
4950       hbox2 = gtk_hbox_new (FALSE, 0);
4951       gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
4952       gtk_container_add (GTK_CONTAINER (frame), hbox2);
4953
4954       label = gtk_label_new ("Visible :");
4955       gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
4956
4957       sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list));
4958       vis_label = gtk_label_new (buf);
4959       gtk_box_pack_end (GTK_BOX (hbox2), vis_label, FALSE, TRUE, 5);
4960
4961       rebuild_tree (NULL, ctree);
4962     }
4963
4964   if (!GTK_WIDGET_VISIBLE (window))
4965     gtk_widget_show_all (window);
4966   else
4967     gtk_widget_destroy (window);
4968 }
4969
4970 /*
4971  * GtkColorSelection
4972  */
4973
4974 void
4975 color_selection_ok (GtkWidget               *w,
4976                     GtkColorSelectionDialog *cs)
4977 {
4978   GtkColorSelection *colorsel;
4979   gdouble color[4];
4980
4981   colorsel=GTK_COLOR_SELECTION(cs->colorsel);
4982
4983   gtk_color_selection_get_color(colorsel,color);
4984   gtk_color_selection_set_color(colorsel,color);
4985 }
4986
4987 void
4988 color_selection_changed (GtkWidget *w,
4989                          GtkColorSelectionDialog *cs)
4990 {
4991   GtkColorSelection *colorsel;
4992   gdouble color[4];
4993
4994   colorsel=GTK_COLOR_SELECTION(cs->colorsel);
4995   gtk_color_selection_get_color(colorsel,color);
4996 }
4997
4998 void
4999 create_color_selection (void)
5000 {
5001   static GtkWidget *window = NULL;
5002
5003   if (!window)
5004     {
5005       window = gtk_color_selection_dialog_new ("color selection dialog");
5006
5007       gtk_color_selection_set_opacity (
5008         GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
5009         TRUE);
5010
5011       gtk_color_selection_set_update_policy(
5012         GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
5013         GTK_UPDATE_CONTINUOUS);
5014
5015       gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
5016
5017       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5018                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5019                           &window);
5020
5021       gtk_signal_connect (
5022         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
5023         "color_changed",
5024         GTK_SIGNAL_FUNC(color_selection_changed),
5025         window);
5026
5027       gtk_signal_connect (
5028         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->ok_button),
5029         "clicked",
5030         GTK_SIGNAL_FUNC(color_selection_ok),
5031         window);
5032
5033       gtk_signal_connect_object (
5034         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->cancel_button),
5035         "clicked",
5036         GTK_SIGNAL_FUNC(gtk_widget_destroy),
5037         GTK_OBJECT (window));
5038     }
5039
5040   if (!GTK_WIDGET_VISIBLE (window))
5041     gtk_widget_show (window);
5042   else
5043     gtk_widget_destroy (window);
5044 }
5045
5046 /*
5047  * GtkFileSelection
5048  */
5049
5050 void
5051 file_selection_hide_fileops (GtkWidget *widget,
5052                              GtkFileSelection *fs)
5053 {
5054   gtk_file_selection_hide_fileop_buttons (fs);
5055 }
5056
5057 void
5058 file_selection_ok (GtkWidget        *w,
5059                    GtkFileSelection *fs)
5060 {
5061   g_print ("%s\n", gtk_file_selection_get_filename (fs));
5062   gtk_widget_destroy (GTK_WIDGET (fs));
5063 }
5064
5065 void
5066 create_file_selection (void)
5067 {
5068   static GtkWidget *window = NULL;
5069   GtkWidget *button;
5070
5071   if (!window)
5072     {
5073       window = gtk_file_selection_new ("file selection dialog");
5074
5075       gtk_file_selection_hide_fileop_buttons (GTK_FILE_SELECTION (window));
5076
5077       gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
5078
5079       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5080                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5081                           &window);
5082
5083       gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (window)->ok_button),
5084                           "clicked", GTK_SIGNAL_FUNC(file_selection_ok),
5085                           window);
5086       gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (window)->cancel_button),
5087                                  "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
5088                                  GTK_OBJECT (window));
5089
5090       button = gtk_button_new_with_label ("Hide Fileops");
5091       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5092                           (GtkSignalFunc) file_selection_hide_fileops,
5093                           (gpointer) window);
5094       gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
5095                           button, FALSE, FALSE, 0);
5096       gtk_widget_show (button);
5097
5098       button = gtk_button_new_with_label ("Show Fileops");
5099       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5100                                  (GtkSignalFunc) gtk_file_selection_show_fileop_buttons,
5101                                  (gpointer) window);
5102       gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
5103                           button, FALSE, FALSE, 0);
5104       gtk_widget_show (button);
5105     }
5106
5107   if (!GTK_WIDGET_VISIBLE (window))
5108     gtk_widget_show (window);
5109   else
5110     gtk_widget_destroy (window);
5111 }
5112
5113 /*
5114  * GtkFontSelection
5115  */
5116
5117 void
5118 font_selection_ok (GtkWidget              *w,
5119                    GtkFontSelectionDialog *fs)
5120 {
5121   g_print ("%s\n", gtk_font_selection_dialog_get_font_name (fs));
5122   gtk_widget_destroy (GTK_WIDGET (fs));
5123 }
5124
5125 void
5126 create_font_selection (void)
5127 {
5128   static GtkWidget *window = NULL;
5129
5130   if (!window)
5131     {
5132       window = gtk_font_selection_dialog_new ("Font Selection Dialog");
5133
5134       gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
5135
5136       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5137                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5138                           &window);
5139
5140       gtk_signal_connect (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->ok_button),
5141                           "clicked", GTK_SIGNAL_FUNC(font_selection_ok),
5142                           GTK_FONT_SELECTION_DIALOG (window));
5143       gtk_signal_connect_object (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->cancel_button),
5144                                  "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
5145                                  GTK_OBJECT (window));
5146     }
5147
5148   if (!GTK_WIDGET_VISIBLE (window))
5149     gtk_widget_show (window);
5150   else
5151     gtk_widget_destroy (window);
5152 }
5153
5154 /*
5155  * GtkDialog
5156  */
5157
5158 static GtkWidget *dialog_window = NULL;
5159
5160 static void
5161 label_toggle (GtkWidget  *widget,
5162               GtkWidget **label)
5163 {
5164   if (!(*label))
5165     {
5166       *label = gtk_label_new ("Dialog Test");
5167       gtk_signal_connect (GTK_OBJECT (*label),
5168                           "destroy",
5169                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
5170                           label);
5171       gtk_misc_set_padding (GTK_MISC (*label), 10, 10);
5172       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
5173                           *label, TRUE, TRUE, 0);
5174       gtk_widget_show (*label);
5175     }
5176   else
5177     gtk_widget_destroy (*label);
5178 }
5179
5180 static void
5181 create_dialog (void)
5182 {
5183   static GtkWidget *label;
5184   GtkWidget *button;
5185
5186   if (!dialog_window)
5187     {
5188       dialog_window = gtk_dialog_new ();
5189
5190       gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
5191                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5192                           &dialog_window);
5193
5194       gtk_window_set_title (GTK_WINDOW (dialog_window), "GtkDialog");
5195       gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
5196       gtk_widget_set_usize (dialog_window, 200, 110);
5197
5198       button = gtk_button_new_with_label ("OK");
5199       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5200       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
5201                           button, TRUE, TRUE, 0);
5202       gtk_widget_grab_default (button);
5203       gtk_widget_show (button);
5204
5205       button = gtk_button_new_with_label ("Toggle");
5206       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5207                           GTK_SIGNAL_FUNC (label_toggle),
5208                           &label);
5209       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5210       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
5211                           button, TRUE, TRUE, 0);
5212       gtk_widget_show (button);
5213
5214       label = NULL;
5215     }
5216
5217   if (!GTK_WIDGET_VISIBLE (dialog_window))
5218     gtk_widget_show (dialog_window);
5219   else
5220     gtk_widget_destroy (dialog_window);
5221 }
5222
5223 /* Event Watcher
5224  */
5225 static gboolean event_watcher_enter_id = 0;
5226 static gboolean event_watcher_leave_id = 0;
5227
5228 static gboolean
5229 event_watcher (GtkObject      *object,
5230                guint           signal_id,
5231                guint           n_params,
5232                GtkArg         *params,
5233                gpointer        data)
5234 {
5235   g_print ("Watch: \"%s\" emitted for %s\n",
5236            gtk_signal_name (signal_id),
5237            gtk_type_name (GTK_OBJECT_TYPE (object)));
5238
5239   return TRUE;
5240 }
5241
5242 static void
5243 event_watcher_down (void)
5244 {
5245   if (event_watcher_enter_id)
5246     {
5247       guint signal_id;
5248
5249       signal_id = gtk_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
5250       gtk_signal_remove_emission_hook (signal_id, event_watcher_enter_id);
5251       event_watcher_enter_id = 0;
5252       signal_id = gtk_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
5253       gtk_signal_remove_emission_hook (signal_id, event_watcher_leave_id);
5254       event_watcher_leave_id = 0;
5255     }
5256 }
5257
5258 static void
5259 event_watcher_toggle (void)
5260 {
5261   if (event_watcher_enter_id)
5262     event_watcher_down ();
5263   else
5264     {
5265       guint signal_id;
5266
5267       signal_id = gtk_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
5268       event_watcher_enter_id = gtk_signal_add_emission_hook (signal_id, event_watcher, NULL);
5269       signal_id = gtk_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
5270       event_watcher_leave_id = gtk_signal_add_emission_hook (signal_id, event_watcher, NULL);
5271     }
5272 }
5273
5274 static void
5275 create_event_watcher (void)
5276 {
5277   GtkWidget *button;
5278
5279   if (!dialog_window)
5280     {
5281       dialog_window = gtk_dialog_new ();
5282
5283       gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
5284                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
5285                           &dialog_window);
5286       gtk_signal_connect (GTK_OBJECT (dialog_window),
5287                           "destroy",
5288                           GTK_SIGNAL_FUNC (event_watcher_down),
5289                           NULL);
5290
5291       gtk_window_set_title (GTK_WINDOW (dialog_window), "Event Watcher");
5292       gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
5293       gtk_widget_set_usize (dialog_window, 200, 110);
5294
5295       button = gtk_toggle_button_new_with_label ("Activate Watch");
5296       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5297                           GTK_SIGNAL_FUNC (event_watcher_toggle),
5298                           NULL);
5299       gtk_container_set_border_width (GTK_CONTAINER (button), 10);
5300       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
5301                           button, TRUE, TRUE, 0);
5302       gtk_widget_show (button);
5303
5304       button = gtk_button_new_with_label ("Close");
5305       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5306                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
5307                                  (GtkObject*) dialog_window);
5308       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5309       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
5310                           button, TRUE, TRUE, 0);
5311       gtk_widget_grab_default (button);
5312       gtk_widget_show (button);
5313     }
5314
5315   if (!GTK_WIDGET_VISIBLE (dialog_window))
5316     gtk_widget_show (dialog_window);
5317   else
5318     gtk_widget_destroy (dialog_window);
5319 }
5320
5321 /*
5322  * GtkRange
5323  */
5324
5325 static void
5326 create_range_controls (void)
5327 {
5328   static GtkWidget *window = NULL;
5329   GtkWidget *box1;
5330   GtkWidget *box2;
5331   GtkWidget *button;
5332   GtkWidget *scrollbar;
5333   GtkWidget *scale;
5334   GtkWidget *separator;
5335   GtkObject *adjustment;
5336
5337   if (!window)
5338     {
5339       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5340
5341       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5342                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5343                           &window);
5344
5345       gtk_window_set_title (GTK_WINDOW (window), "range controls");
5346       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5347
5348
5349       box1 = gtk_vbox_new (FALSE, 0);
5350       gtk_container_add (GTK_CONTAINER (window), box1);
5351       gtk_widget_show (box1);
5352
5353
5354       box2 = gtk_vbox_new (FALSE, 10);
5355       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5356       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
5357       gtk_widget_show (box2);
5358
5359
5360       adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
5361
5362       scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
5363       gtk_widget_set_usize (GTK_WIDGET (scale), 150, 30);
5364       gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
5365       gtk_scale_set_digits (GTK_SCALE (scale), 1);
5366       gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5367       gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
5368       gtk_widget_show (scale);
5369
5370       scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adjustment));
5371       gtk_range_set_update_policy (GTK_RANGE (scrollbar),
5372                                    GTK_UPDATE_CONTINUOUS);
5373       gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0);
5374       gtk_widget_show (scrollbar);
5375
5376
5377       separator = gtk_hseparator_new ();
5378       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5379       gtk_widget_show (separator);
5380
5381
5382       box2 = gtk_vbox_new (FALSE, 10);
5383       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5384       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5385       gtk_widget_show (box2);
5386
5387
5388       button = gtk_button_new_with_label ("close");
5389       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5390                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
5391                                  GTK_OBJECT (window));
5392       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5393       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5394       gtk_widget_grab_default (button);
5395       gtk_widget_show (button);
5396     }
5397
5398   if (!GTK_WIDGET_VISIBLE (window))
5399     gtk_widget_show (window);
5400   else
5401     gtk_widget_destroy (window);
5402 }
5403
5404 /*
5405  * GtkRulers
5406  */
5407
5408 void
5409 create_rulers (void)
5410 {
5411   static GtkWidget *window = NULL;
5412   GtkWidget *table;
5413   GtkWidget *ruler;
5414
5415   if (!window)
5416     {
5417       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5418       gtk_window_set_policy (GTK_WINDOW (window), TRUE, TRUE, FALSE);
5419
5420       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5421                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5422                           &window);
5423
5424       gtk_window_set_title (GTK_WINDOW (window), "rulers");
5425       gtk_widget_set_usize (window, 300, 300);
5426       gtk_widget_set_events (window,
5427                              GDK_POINTER_MOTION_MASK
5428                              | GDK_POINTER_MOTION_HINT_MASK);
5429       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5430
5431       table = gtk_table_new (2, 2, FALSE);
5432       gtk_container_add (GTK_CONTAINER (window), table);
5433       gtk_widget_show (table);
5434
5435       ruler = gtk_hruler_new ();
5436       gtk_ruler_set_metric (GTK_RULER (ruler), GTK_CENTIMETERS);
5437       gtk_ruler_set_range (GTK_RULER (ruler), 100, 0, 0, 20);
5438
5439       gtk_signal_connect_object (
5440         GTK_OBJECT (window),
5441         "motion_notify_event",
5442         GTK_SIGNAL_FUNC(
5443           GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
5444         GTK_OBJECT (ruler));
5445
5446       gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
5447                         GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
5448       gtk_widget_show (ruler);
5449
5450
5451       ruler = gtk_vruler_new ();
5452       gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
5453
5454       gtk_signal_connect_object (
5455         GTK_OBJECT (window),
5456         "motion_notify_event",
5457         GTK_SIGNAL_FUNC (GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
5458         GTK_OBJECT (ruler));
5459
5460       gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
5461                         GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
5462       gtk_widget_show (ruler);
5463     }
5464
5465   if (!GTK_WIDGET_VISIBLE (window))
5466     gtk_widget_show (window);
5467   else
5468     gtk_widget_destroy (window);
5469 }
5470
5471 static void
5472 text_toggle_editable (GtkWidget *checkbutton,
5473                        GtkWidget *text)
5474 {
5475    gtk_text_set_editable(GTK_TEXT(text),
5476                           GTK_TOGGLE_BUTTON(checkbutton)->active);
5477 }
5478
5479 static void
5480 text_toggle_word_wrap (GtkWidget *checkbutton,
5481                        GtkWidget *text)
5482 {
5483    gtk_text_set_word_wrap(GTK_TEXT(text),
5484                           GTK_TOGGLE_BUTTON(checkbutton)->active);
5485 }
5486
5487 struct {
5488   GdkColor color;
5489   gchar *name;
5490 } text_colors[] = {
5491  { { 0, 0x0000, 0x0000, 0x0000 }, "black" },
5492  { { 0, 0xFFFF, 0xFFFF, 0xFFFF }, "white" },
5493  { { 0, 0xFFFF, 0x0000, 0x0000 }, "red" },
5494  { { 0, 0x0000, 0xFFFF, 0x0000 }, "green" },
5495  { { 0, 0x0000, 0x0000, 0xFFFF }, "blue" },
5496  { { 0, 0x0000, 0xFFFF, 0xFFFF }, "cyan" },
5497  { { 0, 0xFFFF, 0x0000, 0xFFFF }, "magenta" },
5498  { { 0, 0xFFFF, 0xFFFF, 0x0000 }, "yellow" }
5499 };
5500
5501 int ntext_colors = sizeof(text_colors) / sizeof(text_colors[0]);
5502
5503 /*
5504  * GtkText
5505  */
5506 void
5507 text_insert_random (GtkWidget *w, GtkText *text)
5508 {
5509   int i;
5510   char c;
5511    for (i=0; i<10; i++)
5512     {
5513       c = 'A' + rand() % ('Z' - 'A');
5514       gtk_text_set_point (text, rand() % gtk_text_get_length (text));
5515       gtk_text_insert (text, NULL, NULL, NULL, &c, 1);
5516     }
5517 }
5518
5519 void
5520 create_text (void)
5521 {
5522   int i, j;
5523
5524   static GtkWidget *window = NULL;
5525   GtkWidget *box1;
5526   GtkWidget *box2;
5527   GtkWidget *hbox;
5528   GtkWidget *button;
5529   GtkWidget *check;
5530   GtkWidget *separator;
5531   GtkWidget *scrolled_window;
5532   GtkWidget *text;
5533   GdkFont *font;
5534
5535   FILE *infile;
5536
5537   if (!window)
5538     {
5539       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5540       gtk_widget_set_name (window, "text window");
5541       gtk_widget_set_usize (window, 500, 500);
5542       gtk_window_set_policy (GTK_WINDOW(window), TRUE, TRUE, FALSE);
5543
5544       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5545                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5546                           &window);
5547
5548       gtk_window_set_title (GTK_WINDOW (window), "test");
5549       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5550
5551
5552       box1 = gtk_vbox_new (FALSE, 0);
5553       gtk_container_add (GTK_CONTAINER (window), box1);
5554       gtk_widget_show (box1);
5555
5556
5557       box2 = gtk_vbox_new (FALSE, 10);
5558       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5559       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
5560       gtk_widget_show (box2);
5561
5562
5563       scrolled_window = gtk_scrolled_window_new (NULL, NULL);
5564       gtk_box_pack_start (GTK_BOX (box2), scrolled_window, TRUE, TRUE, 0);
5565       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
5566                                       GTK_POLICY_NEVER,
5567                                       GTK_POLICY_ALWAYS);
5568       gtk_widget_show (scrolled_window);
5569
5570       text = gtk_text_new (NULL, NULL);
5571       gtk_text_set_editable (GTK_TEXT (text), TRUE);
5572       gtk_container_add (GTK_CONTAINER (scrolled_window), text);
5573       gtk_widget_grab_focus (text);
5574       gtk_widget_show (text);
5575
5576
5577       gtk_text_freeze (GTK_TEXT (text));
5578
5579       font = gdk_font_load ("-adobe-courier-medium-r-normal--*-120-*-*-*-*-*-*");
5580
5581       for (i=0; i<ntext_colors; i++)
5582         {
5583           gtk_text_insert (GTK_TEXT (text), font, NULL, NULL,
5584                            text_colors[i].name, -1);
5585           gtk_text_insert (GTK_TEXT (text), font, NULL, NULL, "\t", -1);
5586
5587           for (j=0; j<ntext_colors; j++)
5588             {
5589               gtk_text_insert (GTK_TEXT (text), font,
5590                                &text_colors[j].color, &text_colors[i].color,
5591                                "XYZ", -1);
5592             }
5593           gtk_text_insert (GTK_TEXT (text), NULL, NULL, NULL, "\n", -1);
5594         }
5595
5596       /* The Text widget will reference count the font, so we
5597        * unreference it here
5598        */
5599       gdk_font_unref (font);
5600
5601       infile = fopen("testgtk.c", "r");
5602
5603       if (infile)
5604         {
5605           char *buffer;
5606           int nbytes_read, nbytes_alloc;
5607
5608           nbytes_read = 0;
5609           nbytes_alloc = 1024;
5610           buffer = g_new (char, nbytes_alloc);
5611           while (1)
5612             {
5613               int len;
5614               if (nbytes_alloc < nbytes_read + 1024)
5615                 {
5616                   nbytes_alloc *= 2;
5617                   buffer = g_realloc (buffer, nbytes_alloc);
5618                 }
5619               len = fread (buffer + nbytes_read, 1, 1024, infile);
5620               nbytes_read += len;
5621               if (len < 1024)
5622                 break;
5623             }
5624
5625           gtk_text_insert (GTK_TEXT (text), NULL, NULL,
5626                            NULL, buffer, nbytes_read);
5627           g_free(buffer);
5628           fclose (infile);
5629         }
5630
5631       gtk_text_thaw (GTK_TEXT (text));
5632
5633       hbox = gtk_hbutton_box_new ();
5634       gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, FALSE, 0);
5635       gtk_widget_show (hbox);
5636
5637       check = gtk_check_button_new_with_label("Editable");
5638       gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, FALSE, 0);
5639       gtk_signal_connect (GTK_OBJECT(check), "toggled",
5640                           GTK_SIGNAL_FUNC(text_toggle_editable), text);
5641       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), TRUE);
5642       gtk_widget_show (check);
5643
5644       check = gtk_check_button_new_with_label("Wrap Words");
5645       gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
5646       gtk_signal_connect (GTK_OBJECT(check), "toggled",
5647                           GTK_SIGNAL_FUNC(text_toggle_word_wrap), text);
5648       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), FALSE);
5649       gtk_widget_show (check);
5650
5651       separator = gtk_hseparator_new ();
5652       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5653       gtk_widget_show (separator);
5654
5655
5656       box2 = gtk_vbox_new (FALSE, 10);
5657       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5658       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5659       gtk_widget_show (box2);
5660
5661
5662       button = gtk_button_new_with_label ("insert random");
5663       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5664                           GTK_SIGNAL_FUNC(text_insert_random),
5665                           GTK_TEXT (text));
5666       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5667       gtk_widget_show (button);
5668
5669       button = gtk_button_new_with_label ("close");
5670       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5671                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
5672                                  GTK_OBJECT (window));
5673       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5674       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5675       gtk_widget_grab_default (button);
5676       gtk_widget_show (button);
5677     }
5678
5679   if (!GTK_WIDGET_VISIBLE (window))
5680     gtk_widget_show (window);
5681   else
5682     gtk_widget_destroy (window);
5683 }
5684
5685 /*
5686  * GtkNotebook
5687  */
5688
5689 GdkPixmap *book_open;
5690 GdkPixmap *book_closed;
5691 GdkBitmap *book_open_mask;
5692 GdkBitmap *book_closed_mask;
5693 GtkWidget *sample_notebook;
5694
5695 static void
5696 page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num)
5697 {
5698   GtkNotebookPage *oldpage;
5699   GtkWidget *pixwid;
5700
5701   oldpage = GTK_NOTEBOOK (widget)->cur_page;
5702
5703   if (page == oldpage)
5704     return;
5705   pixwid = ((GtkBoxChild*)
5706             (GTK_BOX (page->tab_label)->children->data))->widget;
5707   gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
5708   pixwid = ((GtkBoxChild*)
5709             (GTK_BOX (page->menu_label)->children->data))->widget;
5710   gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
5711
5712   if (oldpage)
5713     {
5714       pixwid = ((GtkBoxChild*)
5715                 (GTK_BOX (oldpage->tab_label)->children->data))->widget;
5716       gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
5717       pixwid = ((GtkBoxChild*)
5718                 (GTK_BOX (oldpage->menu_label)->children->data))->widget;
5719       gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
5720     }
5721 }
5722
5723 static void
5724 tab_fill (GtkToggleButton *button, GtkWidget *child)
5725 {
5726   gboolean expand;
5727   GtkPackType pack_type;
5728
5729   gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
5730                                         &expand, NULL, &pack_type);
5731   gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
5732                                       expand, button->active, pack_type);
5733 }
5734
5735 static void
5736 tab_expand (GtkToggleButton *button, GtkWidget *child)
5737 {
5738   gboolean fill;
5739   GtkPackType pack_type;
5740
5741   gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
5742                                         NULL, &fill, &pack_type);
5743   gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
5744                                       button->active, fill, pack_type);
5745 }
5746
5747 static void
5748 tab_pack (GtkToggleButton *button, GtkWidget *child)
5749
5750 {
5751   gboolean expand;
5752   gboolean fill;
5753
5754   gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
5755                                         &expand, &fill, NULL);
5756   gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
5757                                       expand, fill, button->active);
5758 }
5759
5760 static void
5761 create_pages (GtkNotebook *notebook, gint start, gint end)
5762 {
5763   GtkWidget *child = NULL;
5764   GtkWidget *button;
5765   GtkWidget *label;
5766   GtkWidget *hbox;
5767   GtkWidget *vbox;
5768   GtkWidget *label_box;
5769   GtkWidget *menu_box;
5770   GtkWidget *pixwid;
5771   gint i;
5772   char buffer[32];
5773
5774   for (i = start; i <= end; i++)
5775     {
5776       sprintf (buffer, "Page %d", i);
5777
5778       child = gtk_frame_new (buffer);
5779       gtk_container_set_border_width (GTK_CONTAINER (child), 10);
5780
5781       vbox = gtk_vbox_new (TRUE,0);
5782       gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
5783       gtk_container_add (GTK_CONTAINER (child), vbox);
5784
5785       hbox = gtk_hbox_new (TRUE,0);
5786       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
5787
5788       button = gtk_check_button_new_with_label ("Fill Tab");
5789       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
5790       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
5791       gtk_signal_connect (GTK_OBJECT (button), "toggled",
5792                           GTK_SIGNAL_FUNC (tab_fill), child);
5793
5794       button = gtk_check_button_new_with_label ("Expand Tab");
5795       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
5796       gtk_signal_connect (GTK_OBJECT (button), "toggled",
5797       GTK_SIGNAL_FUNC (tab_expand), child);
5798
5799       button = gtk_check_button_new_with_label ("Pack end");
5800       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
5801       gtk_signal_connect (GTK_OBJECT (button), "toggled",
5802                           GTK_SIGNAL_FUNC (tab_pack), child);
5803
5804       button = gtk_button_new_with_label ("Hide Page");
5805       gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 5);
5806       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5807                                  GTK_SIGNAL_FUNC (gtk_widget_hide),
5808                                  GTK_OBJECT (child));
5809
5810       gtk_widget_show_all (child);
5811
5812       label_box = gtk_hbox_new (FALSE, 0);
5813       pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
5814       gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
5815       gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
5816       label = gtk_label_new (buffer);
5817       gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
5818       gtk_widget_show_all (label_box);
5819
5820       menu_box = gtk_hbox_new (FALSE, 0);
5821       pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
5822       gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
5823       gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
5824       label = gtk_label_new (buffer);
5825       gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0);
5826       gtk_widget_show_all (menu_box);
5827       gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
5828     }
5829 }
5830
5831 static void
5832 rotate_notebook (GtkButton   *button,
5833                  GtkNotebook *notebook)
5834 {
5835   gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos + 1) % 4);
5836 }
5837
5838 static void
5839 show_all_pages (GtkButton   *button,
5840                 GtkNotebook *notebook)
5841 {
5842   gtk_container_foreach (GTK_CONTAINER (notebook),
5843                          (GtkCallback) gtk_widget_show, NULL);
5844 }
5845
5846 static void
5847 standard_notebook (GtkButton   *button,
5848                    GtkNotebook *notebook)
5849 {
5850   gint i;
5851
5852   gtk_notebook_set_show_tabs (notebook, TRUE);
5853   gtk_notebook_set_scrollable (notebook, FALSE);
5854   if (g_list_length (notebook->children) == 15)
5855     for (i = 0; i < 10; i++)
5856       gtk_notebook_remove_page (notebook, 5);
5857 }
5858
5859 static void
5860 notabs_notebook (GtkButton   *button,
5861                  GtkNotebook *notebook)
5862 {
5863   gint i;
5864
5865   gtk_notebook_set_show_tabs (notebook, FALSE);
5866   if (g_list_length (notebook->children) == 15)
5867     for (i = 0; i < 10; i++)
5868       gtk_notebook_remove_page (notebook, 5);
5869 }
5870
5871 static void
5872 scrollable_notebook (GtkButton   *button,
5873                      GtkNotebook *notebook)
5874 {
5875   gtk_notebook_set_show_tabs (notebook, TRUE);
5876   gtk_notebook_set_scrollable (notebook, TRUE);
5877   if (g_list_length (notebook->children) == 5)
5878     create_pages (notebook, 6, 15);
5879 }
5880
5881 static void
5882 notebook_popup (GtkToggleButton *button,
5883                 GtkNotebook     *notebook)
5884 {
5885   if (button->active)
5886     gtk_notebook_popup_enable (notebook);
5887   else
5888     gtk_notebook_popup_disable (notebook);
5889 }
5890
5891 static void
5892 notebook_homogeneous (GtkToggleButton *button,
5893                       GtkNotebook     *notebook)
5894 {
5895   gtk_notebook_set_homogeneous_tabs (notebook, button->active);
5896 }
5897
5898 static void
5899 create_notebook (void)
5900 {
5901   static GtkWidget *window = NULL;
5902   GtkWidget *box1;
5903   GtkWidget *box2;
5904   GtkWidget *button;
5905   GtkWidget *separator;
5906   GtkWidget *omenu;
5907   GdkColor *transparent = NULL;
5908   GtkWidget *label;
5909
5910   static OptionMenuItem items[] =
5911   {
5912     { "Standard",   standard_notebook },
5913     { "No tabs",    notabs_notebook },
5914     { "Scrollable", scrollable_notebook }
5915   };
5916
5917   if (!window)
5918     {
5919       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5920
5921       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5922                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5923                           &window);
5924
5925       gtk_window_set_title (GTK_WINDOW (window), "notebook");
5926       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5927
5928       box1 = gtk_vbox_new (FALSE, 0);
5929       gtk_container_add (GTK_CONTAINER (window), box1);
5930
5931       sample_notebook = gtk_notebook_new ();
5932       gtk_signal_connect (GTK_OBJECT (sample_notebook), "switch_page",
5933                           GTK_SIGNAL_FUNC (page_switch), NULL);
5934       gtk_notebook_set_tab_pos (GTK_NOTEBOOK (sample_notebook), GTK_POS_TOP);
5935       gtk_box_pack_start (GTK_BOX (box1), sample_notebook, TRUE, TRUE, 0);
5936       gtk_container_set_border_width (GTK_CONTAINER (sample_notebook), 10);
5937
5938       gtk_widget_realize (sample_notebook);
5939       book_open = gdk_pixmap_create_from_xpm_d (sample_notebook->window,
5940                                                 &book_open_mask,
5941                                                 transparent,
5942                                                 book_open_xpm);
5943       book_closed = gdk_pixmap_create_from_xpm_d (sample_notebook->window,
5944                                                   &book_closed_mask,
5945                                                   transparent,
5946                                                   book_closed_xpm);
5947
5948       create_pages (GTK_NOTEBOOK (sample_notebook), 1, 5);
5949
5950       separator = gtk_hseparator_new ();
5951       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10);
5952
5953       box2 = gtk_hbox_new (FALSE, 5);
5954       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5955       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5956
5957       button = gtk_check_button_new_with_label ("popup menu");
5958       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, FALSE, 0);
5959       gtk_signal_connect (GTK_OBJECT(button), "clicked",
5960                           GTK_SIGNAL_FUNC (notebook_popup),
5961                           GTK_OBJECT (sample_notebook));
5962
5963       button = gtk_check_button_new_with_label ("homogeneous tabs");
5964       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, FALSE, 0);
5965       gtk_signal_connect (GTK_OBJECT(button), "clicked",
5966                           GTK_SIGNAL_FUNC (notebook_homogeneous),
5967                           GTK_OBJECT (sample_notebook));
5968
5969       box2 = gtk_hbox_new (FALSE, 5);
5970       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5971       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5972
5973       label = gtk_label_new ("Notebook Style :");
5974       gtk_box_pack_start (GTK_BOX (box2), label, FALSE, TRUE, 0);
5975
5976       omenu = build_option_menu (items, 3, 0, sample_notebook);
5977       gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, TRUE, 0);
5978
5979       button = gtk_button_new_with_label ("Show all Pages");
5980       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
5981       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5982                           GTK_SIGNAL_FUNC (show_all_pages), sample_notebook);
5983
5984       box2 = gtk_hbox_new (TRUE, 10);
5985       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5986       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5987
5988       button = gtk_button_new_with_label ("prev");
5989       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5990                                  GTK_SIGNAL_FUNC (gtk_notebook_prev_page),
5991                                  GTK_OBJECT (sample_notebook));
5992       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5993
5994       button = gtk_button_new_with_label ("next");
5995       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5996                                  GTK_SIGNAL_FUNC (gtk_notebook_next_page),
5997                                  GTK_OBJECT (sample_notebook));
5998       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5999
6000       button = gtk_button_new_with_label ("rotate");
6001       gtk_signal_connect (GTK_OBJECT (button), "clicked",
6002                           GTK_SIGNAL_FUNC (rotate_notebook), sample_notebook);
6003       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6004
6005       separator = gtk_hseparator_new ();
6006       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
6007
6008       button = gtk_button_new_with_label ("close");
6009       gtk_container_set_border_width (GTK_CONTAINER (button), 5);
6010       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6011                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
6012                                  GTK_OBJECT (window));
6013       gtk_box_pack_start (GTK_BOX (box1), button, FALSE, FALSE, 0);
6014       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6015       gtk_widget_grab_default (button);
6016     }
6017
6018   if (!GTK_WIDGET_VISIBLE (window))
6019     gtk_widget_show_all (window);
6020   else
6021     gtk_widget_destroy (window);
6022 }
6023
6024 /*
6025  * GtkPanes
6026  */
6027
6028 void
6029 toggle_resize (GtkWidget *widget, GtkWidget *child)
6030 {
6031   GtkPaned *paned = GTK_PANED (child->parent);
6032   gboolean is_child1 = (child == paned->child1);
6033   gboolean resize, shrink;
6034
6035   resize = is_child1 ? paned->child1_resize : paned->child2_resize;
6036   shrink = is_child1 ? paned->child1_shrink : paned->child2_shrink;
6037
6038   gtk_widget_ref (child);
6039   gtk_container_remove (GTK_CONTAINER (child->parent), child);
6040   if (is_child1)
6041     gtk_paned_pack1 (paned, child, !resize, shrink);
6042   else
6043     gtk_paned_pack2 (paned, child, !resize, shrink);
6044   gtk_widget_unref (child);
6045 }
6046
6047 void
6048 toggle_shrink (GtkWidget *widget, GtkWidget *child)
6049 {
6050   GtkPaned *paned = GTK_PANED (child->parent);
6051   gboolean is_child1 = (child == paned->child1);
6052   gboolean resize, shrink;
6053
6054   resize = is_child1 ? paned->child1_resize : paned->child2_resize;
6055   shrink = is_child1 ? paned->child1_shrink : paned->child2_shrink;
6056
6057   gtk_widget_ref (child);
6058   gtk_container_remove (GTK_CONTAINER (child->parent), child);
6059   if (is_child1)
6060     gtk_paned_pack1 (paned, child, resize, !shrink);
6061   else
6062     gtk_paned_pack2 (paned, child, resize, !shrink);
6063   gtk_widget_unref (child);
6064 }
6065
6066 GtkWidget *
6067 create_pane_options (GtkPaned *paned,
6068                      const gchar *frame_label,
6069                      const gchar *label1,
6070                      const gchar *label2)
6071 {
6072   GtkWidget *frame;
6073   GtkWidget *table;
6074   GtkWidget *label;
6075   GtkWidget *check_button;
6076
6077   frame = gtk_frame_new (frame_label);
6078   gtk_container_set_border_width (GTK_CONTAINER (frame), 4);
6079
6080   table = gtk_table_new (3, 2, 4);
6081   gtk_container_add (GTK_CONTAINER (frame), table);
6082
6083   label = gtk_label_new (label1);
6084   gtk_table_attach_defaults (GTK_TABLE (table), label,
6085                              0, 1, 0, 1);
6086
6087   check_button = gtk_check_button_new_with_label ("Resize");
6088   gtk_table_attach_defaults (GTK_TABLE (table), check_button,
6089                              0, 1, 1, 2);
6090   gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
6091                       GTK_SIGNAL_FUNC (toggle_resize),
6092                       paned->child1);
6093
6094   check_button = gtk_check_button_new_with_label ("Shrink");
6095   gtk_table_attach_defaults (GTK_TABLE (table), check_button,
6096                              0, 1, 2, 3);
6097   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
6098                                TRUE);
6099   gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
6100                       GTK_SIGNAL_FUNC (toggle_shrink),
6101                       paned->child1);
6102
6103   label = gtk_label_new (label2);
6104   gtk_table_attach_defaults (GTK_TABLE (table), label,
6105                              1, 2, 0, 1);
6106
6107   check_button = gtk_check_button_new_with_label ("Resize");
6108   gtk_table_attach_defaults (GTK_TABLE (table), check_button,
6109                              1, 2, 1, 2);
6110   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
6111                                TRUE);
6112   gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
6113                       GTK_SIGNAL_FUNC (toggle_resize),
6114                       paned->child2);
6115
6116   check_button = gtk_check_button_new_with_label ("Shrink");
6117   gtk_table_attach_defaults (GTK_TABLE (table), check_button,
6118                              1, 2, 2, 3);
6119   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
6120                                TRUE);
6121   gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
6122                       GTK_SIGNAL_FUNC (toggle_shrink),
6123                       paned->child2);
6124
6125   return frame;
6126 }
6127
6128 void
6129 create_panes (void)
6130 {
6131   static GtkWidget *window = NULL;
6132   GtkWidget *frame;
6133   GtkWidget *hpaned;
6134   GtkWidget *vpaned;
6135   GtkWidget *button;
6136   GtkWidget *vbox;
6137
6138   if (!window)
6139     {
6140       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6141
6142       gtk_signal_connect (GTK_OBJECT (window), "destroy",
6143                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6144                           &window);
6145
6146       gtk_window_set_title (GTK_WINDOW (window), "Panes");
6147       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6148
6149       vbox = gtk_vbox_new (FALSE, 0);
6150       gtk_container_add (GTK_CONTAINER (window), vbox);
6151
6152       vpaned = gtk_vpaned_new ();
6153       gtk_box_pack_start (GTK_BOX (vbox), vpaned, TRUE, TRUE, 0);
6154       gtk_container_set_border_width (GTK_CONTAINER(vpaned), 5);
6155
6156       hpaned = gtk_hpaned_new ();
6157       gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
6158
6159       frame = gtk_frame_new (NULL);
6160       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6161       gtk_widget_set_usize (frame, 60, 60);
6162       gtk_paned_add1 (GTK_PANED (hpaned), frame);
6163
6164       button = gtk_button_new_with_label ("Hi there");
6165       gtk_container_add (GTK_CONTAINER(frame), button);
6166
6167       frame = gtk_frame_new (NULL);
6168       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6169       gtk_widget_set_usize (frame, 80, 60);
6170       gtk_paned_add2 (GTK_PANED (hpaned), frame);
6171
6172       frame = gtk_frame_new (NULL);
6173       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6174       gtk_widget_set_usize (frame, 60, 80);
6175       gtk_paned_add2 (GTK_PANED (vpaned), frame);
6176
6177       /* Now create toggle buttons to control sizing */
6178
6179       gtk_box_pack_start (GTK_BOX (vbox),
6180                           create_pane_options (GTK_PANED (hpaned),
6181                                                "Horizontal",
6182                                                "Left",
6183                                                "Right"),
6184                           FALSE, FALSE, 0);
6185
6186       gtk_box_pack_start (GTK_BOX (vbox),
6187                           create_pane_options (GTK_PANED (vpaned),
6188                                                "Vertical",
6189                                                "Top",
6190                                                "Bottom"),
6191                           FALSE, FALSE, 0);
6192
6193       gtk_widget_show_all (vbox);
6194     }
6195
6196   if (!GTK_WIDGET_VISIBLE (window))
6197     gtk_widget_show (window);
6198   else
6199     gtk_widget_destroy (window);
6200 }
6201
6202 /*
6203  * Drag -N- Drop
6204  */
6205
6206 #if 0
6207 gint
6208 dnd_drop_destroy_popup (GtkWidget *widget, GtkWindow **window)
6209 {
6210   if(GTK_IS_BUTTON(widget)) /* I.e. they clicked the close button */
6211     gtk_widget_destroy(GTK_WIDGET(*window));
6212   else {
6213     gtk_grab_remove(GTK_WIDGET(*window));
6214     *window = NULL;
6215   }
6216
6217   return FALSE;
6218 }
6219
6220 void
6221 dnd_drop (GtkWidget *button, GdkEvent *event)
6222 {
6223   static GtkWidget *window = NULL;
6224   GtkWidget *vbox, *lbl, *btn;
6225   gchar *msg;
6226
6227   /* DND doesn't obey gtk_grab's, so check if we're already displaying
6228    * drop modal dialog first
6229    */
6230   if (window)
6231     return;
6232
6233   window = gtk_window_new(GTK_WINDOW_DIALOG);
6234   gtk_container_set_border_width (GTK_CONTAINER(window), 10);
6235
6236   gtk_signal_connect (GTK_OBJECT (window), "destroy",
6237                       GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
6238                       &window);
6239   gtk_signal_connect (GTK_OBJECT (window), "delete-event",
6240                       GTK_SIGNAL_FUNC(gtk_false),
6241                       &window);
6242
6243   vbox = gtk_vbox_new(FALSE, 5);
6244
6245   /* Display message that we got from drop source */
6246   msg = g_malloc(strlen(event->dropdataavailable.data)
6247                  + strlen(event->dropdataavailable.data_type) + 100);
6248   sprintf(msg, "Drop data of type %s was:\n\n%s",
6249           event->dropdataavailable.data_type,
6250           (char *)event->dropdataavailable.data);
6251   lbl = gtk_label_new(msg);
6252   gtk_label_set_justify(GTK_LABEL(lbl), GTK_JUSTIFY_FILL);
6253   g_free(msg);
6254   gtk_widget_show(lbl);
6255   gtk_box_pack_start_defaults(GTK_BOX(vbox), lbl);
6256
6257   /* Provide an obvious way out of this heinousness */
6258   btn = gtk_button_new_with_label("Continue with life in\nspite of this oppression");
6259   gtk_signal_connect_object (GTK_OBJECT (btn), "clicked",
6260                              GTK_SIGNAL_FUNC(gtk_widget_destroy),
6261                              GTK_OBJECT (window));
6262   gtk_widget_show(btn);
6263   gtk_box_pack_start_defaults(GTK_BOX(vbox), btn);
6264
6265   gtk_container_add(GTK_CONTAINER(window), vbox);
6266
6267   gtk_widget_show(vbox);
6268   gtk_grab_add(window);
6269   gtk_widget_show(window);
6270 }
6271
6272 void
6273 dnd_drag_request (GtkWidget *button, GdkEvent *event)
6274 {
6275 #define DND_STRING "Bill Gates demands royalties for\nyour use of his innovation."
6276   gtk_widget_dnd_data_set (button, event, DND_STRING, strlen(DND_STRING) + 1);
6277 }
6278
6279 void
6280 create_dnd (void)
6281 {
6282   static GtkWidget *window = NULL;
6283   GtkWidget *box1;
6284   GtkWidget *box2;
6285   GtkWidget *box3;
6286   GtkWidget *frame;
6287   GtkWidget *button;
6288   GtkWidget *separator;
6289
6290   /* For clarity... */
6291   char *possible_drag_types[] = {"text/plain"};
6292   char *accepted_drop_types[] = {"text/plain"};
6293
6294   static GtkWidget *drag_icon = NULL;
6295   static GtkWidget *drop_icon = NULL;
6296
6297   if (!window)
6298     {
6299       GdkPoint hotspot = {5,5};
6300
6301       if (!drag_icon)
6302         {
6303           drag_icon = shape_create_icon ("Modeller.xpm",
6304                                          440, 140, 0,0, GTK_WINDOW_POPUP);
6305
6306           gtk_signal_connect (GTK_OBJECT (drag_icon), "destroy",
6307                               GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6308                               &drag_icon);
6309
6310           gtk_widget_hide (drag_icon);
6311         }
6312
6313       if (!drop_icon)
6314         {
6315           drop_icon = shape_create_icon ("3DRings.xpm",
6316                                          440, 140, 0,0, GTK_WINDOW_POPUP);
6317
6318           gtk_signal_connect (GTK_OBJECT (drop_icon), "destroy",
6319                               GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6320                               &drop_icon);
6321
6322           gtk_widget_hide (drop_icon);
6323         }
6324
6325       gdk_dnd_set_drag_shape(drag_icon->window,
6326                              &hotspot,
6327                              drop_icon->window,
6328                              &hotspot);
6329
6330       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6331
6332       gtk_signal_connect (GTK_OBJECT (window), "destroy",
6333                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6334                           &window);
6335
6336       gtk_window_set_title (GTK_WINDOW (window), "Drag -N- Drop");
6337       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6338
6339       box1 = gtk_vbox_new (FALSE, 0);
6340       gtk_container_add (GTK_CONTAINER (window), box1);
6341       gtk_widget_show (box1);
6342
6343       box2 = gtk_hbox_new (FALSE, 5);
6344       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6345       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
6346       gtk_widget_show (box2);
6347
6348       frame = gtk_frame_new ("Drag");
6349       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
6350       gtk_widget_show (frame);
6351
6352       box3 = gtk_vbox_new (FALSE, 5);
6353       gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
6354       gtk_container_add (GTK_CONTAINER (frame), box3);
6355       gtk_widget_show (box3);
6356
6357       /*
6358        * FROM Button
6359        */
6360       button = gtk_button_new_with_label ("Drag me!");
6361       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
6362       gtk_widget_show (button);
6363
6364       /*
6365        * currently, the widget has to be realized to
6366        * set dnd on it, this needs to change
6367        */
6368       gtk_widget_realize (button);
6369       gtk_signal_connect (GTK_OBJECT (button),
6370                           "drag_request_event",
6371                           GTK_SIGNAL_FUNC(dnd_drag_request),
6372                           button);
6373
6374       gtk_widget_dnd_drag_set (button, TRUE, possible_drag_types, 1);
6375
6376
6377       frame = gtk_frame_new ("Drop");
6378       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
6379       gtk_widget_show (frame);
6380
6381       box3 = gtk_vbox_new (FALSE, 5);
6382       gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
6383       gtk_container_add (GTK_CONTAINER (frame), box3);
6384       gtk_widget_show (box3);
6385
6386
6387       /*
6388        * TO Button
6389        */
6390       button = gtk_button_new_with_label ("To");
6391       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
6392       gtk_widget_show (button);
6393
6394       gtk_widget_realize (button);
6395       gtk_signal_connect (GTK_OBJECT (button),
6396                           "drop_data_available_event",
6397                           GTK_SIGNAL_FUNC(dnd_drop),
6398                           button);
6399
6400       gtk_widget_dnd_drop_set (button, TRUE, accepted_drop_types, 1, FALSE);
6401
6402
6403       separator = gtk_hseparator_new ();
6404       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
6405       gtk_widget_show (separator);
6406
6407
6408       box2 = gtk_vbox_new (FALSE, 10);
6409       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6410       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6411       gtk_widget_show (box2);
6412
6413
6414       button = gtk_button_new_with_label ("close");
6415
6416       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6417                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
6418                                  GTK_OBJECT (window));
6419
6420       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6421       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6422       gtk_widget_grab_default (button);
6423       gtk_widget_show (button);
6424     }
6425
6426   if (!GTK_WIDGET_VISIBLE (window))
6427     gtk_widget_show (window);
6428   else
6429     gtk_widget_destroy (window);
6430 }
6431 #endif
6432
6433 /*
6434  * Shaped Windows
6435  */
6436
6437 static GdkWindow *root_win = NULL;
6438
6439 typedef struct _cursoroffset {gint x,y;} CursorOffset;
6440
6441 static void
6442 shape_pressed (GtkWidget *widget, GdkEventButton *event)
6443 {
6444   CursorOffset *p;
6445
6446   /* ignore double and triple click */
6447   if (event->type != GDK_BUTTON_PRESS)
6448     return;
6449
6450   p = gtk_object_get_user_data (GTK_OBJECT(widget));
6451   p->x = (int) event->x;
6452   p->y = (int) event->y;
6453
6454   gtk_grab_add (widget);
6455   gdk_pointer_grab (widget->window, TRUE,
6456                     GDK_BUTTON_RELEASE_MASK |
6457                     GDK_BUTTON_MOTION_MASK |
6458                     GDK_POINTER_MOTION_HINT_MASK,
6459                     NULL, NULL, 0);
6460 }
6461
6462 static void
6463 shape_released (GtkWidget *widget)
6464 {
6465   gtk_grab_remove (widget);
6466   gdk_pointer_ungrab (0);
6467 }
6468
6469 static void
6470 shape_motion (GtkWidget      *widget,
6471               GdkEventMotion *event)
6472 {
6473   gint xp, yp;
6474   CursorOffset * p;
6475   GdkModifierType mask;
6476
6477   p = gtk_object_get_user_data (GTK_OBJECT (widget));
6478
6479   /*
6480    * Can't use event->x / event->y here
6481    * because I need absolute coordinates.
6482    */
6483   gdk_window_get_pointer (root_win, &xp, &yp, &mask);
6484   gtk_widget_set_uposition (widget, xp  - p->x, yp  - p->y);
6485 }
6486
6487 GtkWidget *
6488 shape_create_icon (char     *xpm_file,
6489                    gint      x,
6490                    gint      y,
6491                    gint      px,
6492                    gint      py,
6493                    gint      window_type)
6494 {
6495   GtkWidget *window;
6496   GtkWidget *pixmap;
6497   GtkWidget *fixed;
6498   CursorOffset* icon_pos;
6499   GdkGC* gc;
6500   GdkBitmap *gdk_pixmap_mask;
6501   GdkPixmap *gdk_pixmap;
6502   GtkStyle *style;
6503
6504   style = gtk_widget_get_default_style ();
6505   gc = style->black_gc;
6506
6507   /*
6508    * GDK_WINDOW_TOPLEVEL works also, giving you a title border
6509    */
6510   window = gtk_window_new (window_type);
6511
6512   fixed = gtk_fixed_new ();
6513   gtk_widget_set_usize (fixed, 100,100);
6514   gtk_container_add (GTK_CONTAINER (window), fixed);
6515   gtk_widget_show (fixed);
6516
6517   gtk_widget_set_events (window,
6518                          gtk_widget_get_events (window) |
6519                          GDK_BUTTON_MOTION_MASK |
6520                          GDK_POINTER_MOTION_HINT_MASK |
6521                          GDK_BUTTON_PRESS_MASK);
6522
6523   gtk_widget_realize (window);
6524   gdk_pixmap = gdk_pixmap_create_from_xpm (window->window, &gdk_pixmap_mask,
6525                                            &style->bg[GTK_STATE_NORMAL],
6526                                            xpm_file);
6527
6528   pixmap = gtk_pixmap_new (gdk_pixmap, gdk_pixmap_mask);
6529   gtk_fixed_put (GTK_FIXED (fixed), pixmap, px,py);
6530   gtk_widget_show (pixmap);
6531
6532   gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px,py);
6533
6534
6535   gtk_signal_connect (GTK_OBJECT (window), "button_press_event",
6536                       GTK_SIGNAL_FUNC (shape_pressed),NULL);
6537   gtk_signal_connect (GTK_OBJECT (window), "button_release_event",
6538                       GTK_SIGNAL_FUNC (shape_released),NULL);
6539   gtk_signal_connect (GTK_OBJECT (window), "motion_notify_event",
6540                       GTK_SIGNAL_FUNC (shape_motion),NULL);
6541
6542   icon_pos = g_new (CursorOffset, 1);
6543   gtk_object_set_user_data(GTK_OBJECT(window), icon_pos);
6544
6545   gtk_widget_set_uposition (window, x, y);
6546   gtk_widget_show (window);
6547
6548   return window;
6549 }
6550
6551 void
6552 create_shapes (void)
6553 {
6554   /* Variables used by the Drag/Drop and Shape Window demos */
6555   static GtkWidget *modeller = NULL;
6556   static GtkWidget *sheets = NULL;
6557   static GtkWidget *rings = NULL;
6558
6559   root_win = gdk_window_foreign_new (GDK_ROOT_WINDOW ());
6560
6561   if (!modeller)
6562     {
6563       modeller = shape_create_icon ("Modeller.xpm",
6564                                     440, 140, 0,0, GTK_WINDOW_POPUP);
6565
6566       gtk_signal_connect (GTK_OBJECT (modeller), "destroy",
6567                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6568                           &modeller);
6569     }
6570   else
6571     gtk_widget_destroy (modeller);
6572
6573   if (!sheets)
6574     {
6575       sheets = shape_create_icon ("FilesQueue.xpm",
6576                                   580, 170, 0,0, GTK_WINDOW_POPUP);
6577
6578       gtk_signal_connect (GTK_OBJECT (sheets), "destroy",
6579                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6580                           &sheets);
6581
6582     }
6583   else
6584     gtk_widget_destroy (sheets);
6585
6586   if (!rings)
6587     {
6588       rings = shape_create_icon ("3DRings.xpm",
6589                                  460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
6590
6591       gtk_signal_connect (GTK_OBJECT (rings), "destroy",
6592                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6593                           &rings);
6594     }
6595   else
6596     gtk_widget_destroy (rings);
6597 }
6598
6599 /*
6600  * WM Hints demo
6601  */
6602
6603 void
6604 create_wmhints (void)
6605 {
6606   static GtkWidget *window = NULL;
6607   GtkWidget *label;
6608   GtkWidget *separator;
6609   GtkWidget *button;
6610   GtkWidget *box1;
6611   GtkWidget *box2;
6612
6613   GdkBitmap *circles;
6614
6615   if (!window)
6616     {
6617       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6618
6619       gtk_signal_connect (GTK_OBJECT (window), "destroy",
6620                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6621                           &window);
6622
6623       gtk_window_set_title (GTK_WINDOW (window), "WM Hints");
6624       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6625
6626       gtk_widget_realize (window);
6627
6628       circles = gdk_bitmap_create_from_data (window->window,
6629                                              circles_bits,
6630                                              circles_width,
6631                                              circles_height);
6632       gdk_window_set_icon (window->window, NULL,
6633                            circles, circles);
6634
6635       gdk_window_set_icon_name (window->window, "WMHints Test Icon");
6636
6637       gdk_window_set_decorations (window->window, GDK_DECOR_ALL | GDK_DECOR_MENU);
6638       gdk_window_set_functions (window->window, GDK_FUNC_ALL | GDK_FUNC_RESIZE);
6639
6640       box1 = gtk_vbox_new (FALSE, 0);
6641       gtk_container_add (GTK_CONTAINER (window), box1);
6642       gtk_widget_show (box1);
6643
6644       label = gtk_label_new ("Try iconizing me!");
6645       gtk_widget_set_usize (label, 150, 50);
6646       gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
6647       gtk_widget_show (label);
6648
6649
6650       separator = gtk_hseparator_new ();
6651       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
6652       gtk_widget_show (separator);
6653
6654
6655       box2 = gtk_vbox_new (FALSE, 10);
6656       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6657       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6658       gtk_widget_show (box2);
6659
6660
6661       button = gtk_button_new_with_label ("close");
6662
6663       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6664                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
6665                                  GTK_OBJECT (window));
6666
6667       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6668       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6669       gtk_widget_grab_default (button);
6670       gtk_widget_show (button);
6671     }
6672
6673   if (!GTK_WIDGET_VISIBLE (window))
6674     gtk_widget_show (window);
6675   else
6676     gtk_widget_destroy (window);
6677 }
6678
6679 /*
6680  * GtkProgressBar
6681  */
6682
6683 typedef struct _ProgressData {
6684   GtkWidget *window;
6685   GtkWidget *pbar;
6686   GtkWidget *block_spin;
6687   GtkWidget *x_align_spin;
6688   GtkWidget *y_align_spin;
6689   GtkWidget *step_spin;
6690   GtkWidget *act_blocks_spin;
6691   GtkWidget *label;
6692   GtkWidget *omenu1;
6693   GtkWidget *omenu2;
6694   GtkWidget *entry;
6695   int timer;
6696 } ProgressData;
6697
6698 gint
6699 progress_timeout (gpointer data)
6700 {
6701   gfloat new_val;
6702   GtkAdjustment *adj;
6703
6704   adj = GTK_PROGRESS (data)->adjustment;
6705
6706   new_val = adj->value + 1;
6707   if (new_val > adj->upper)
6708     new_val = adj->lower;
6709
6710   gtk_progress_set_value (GTK_PROGRESS (data), new_val);
6711
6712   return TRUE;
6713 }
6714
6715 static void
6716 destroy_progress (GtkWidget     *widget,
6717                   ProgressData **pdata)
6718 {
6719   gtk_timeout_remove ((*pdata)->timer);
6720   (*pdata)->timer = 0;
6721   (*pdata)->window = NULL;
6722   g_free (*pdata);
6723   *pdata = NULL;
6724 }
6725
6726 static void
6727 progressbar_toggle_orientation (GtkWidget *widget, ProgressData *pdata)
6728 {
6729   gint i;
6730
6731   if (!GTK_WIDGET_MAPPED (widget))
6732     return;
6733
6734   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
6735                     (((GtkOptionMenu *)(pdata->omenu1))->menu_item), i);
6736
6737   gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (pdata->pbar),
6738                             (GtkProgressBarOrientation) (3-i));
6739 }
6740
6741 static void
6742 toggle_show_text (GtkWidget *widget, ProgressData *pdata)
6743 {
6744   gtk_progress_set_show_text (GTK_PROGRESS (pdata->pbar),
6745                               GTK_TOGGLE_BUTTON (widget)->active);
6746   gtk_widget_set_sensitive (pdata->entry, GTK_TOGGLE_BUTTON (widget)->active);
6747   gtk_widget_set_sensitive (pdata->x_align_spin,
6748                             GTK_TOGGLE_BUTTON (widget)->active);
6749   gtk_widget_set_sensitive (pdata->y_align_spin,
6750                             GTK_TOGGLE_BUTTON (widget)->active);
6751 }
6752
6753 static void
6754 progressbar_toggle_bar_style (GtkWidget *widget, ProgressData *pdata)
6755 {
6756   gint i;
6757
6758   if (!GTK_WIDGET_MAPPED (widget))
6759     return;
6760
6761   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
6762                     (((GtkOptionMenu *)(pdata->omenu2))->menu_item), i);
6763
6764   i = 1 - i;
6765
6766   if (i == 1)
6767     gtk_widget_set_sensitive (pdata->block_spin, TRUE);
6768   else
6769     gtk_widget_set_sensitive (pdata->block_spin, FALSE);
6770
6771   gtk_progress_bar_set_bar_style (GTK_PROGRESS_BAR (pdata->pbar),
6772                                   (GtkProgressBarStyle) i);
6773 }
6774
6775 static void
6776 progress_value_changed (GtkAdjustment *adj, ProgressData *pdata)
6777 {
6778   char buf[20];
6779
6780   if (GTK_PROGRESS (pdata->pbar)->activity_mode)
6781     sprintf (buf, "???");
6782   else
6783     sprintf (buf, "%.0f%%", 100 *
6784              gtk_progress_get_current_percentage (GTK_PROGRESS (pdata->pbar)));
6785   gtk_label_set_text (GTK_LABEL (pdata->label), buf);
6786 }
6787
6788 static void
6789 adjust_blocks (GtkAdjustment *adj, ProgressData *pdata)
6790 {
6791   gtk_progress_set_percentage (GTK_PROGRESS (pdata->pbar), 0);
6792   gtk_progress_bar_set_discrete_blocks (GTK_PROGRESS_BAR (pdata->pbar),
6793      gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pdata->block_spin)));
6794 }
6795
6796 static void
6797 adjust_step (GtkAdjustment *adj, ProgressData *pdata)
6798 {
6799   gtk_progress_bar_set_activity_step (GTK_PROGRESS_BAR (pdata->pbar),
6800      gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pdata->step_spin)));
6801 }
6802
6803 static void
6804 adjust_act_blocks (GtkAdjustment *adj, ProgressData *pdata)
6805 {
6806   gtk_progress_bar_set_activity_blocks (GTK_PROGRESS_BAR (pdata->pbar),
6807                gtk_spin_button_get_value_as_int
6808                       (GTK_SPIN_BUTTON (pdata->act_blocks_spin)));
6809 }
6810
6811 static void
6812 adjust_align (GtkAdjustment *adj, ProgressData *pdata)
6813 {
6814   gtk_progress_set_text_alignment (GTK_PROGRESS (pdata->pbar),
6815          gtk_spin_button_get_value_as_float
6816                                    (GTK_SPIN_BUTTON (pdata->x_align_spin)),
6817          gtk_spin_button_get_value_as_float
6818                                    (GTK_SPIN_BUTTON (pdata->y_align_spin)));
6819 }
6820
6821 static void
6822 toggle_activity_mode (GtkWidget *widget, ProgressData *pdata)
6823 {
6824   gtk_progress_set_activity_mode (GTK_PROGRESS (pdata->pbar),
6825                                   GTK_TOGGLE_BUTTON (widget)->active);
6826   gtk_widget_set_sensitive (pdata->step_spin,
6827                             GTK_TOGGLE_BUTTON (widget)->active);
6828   gtk_widget_set_sensitive (pdata->act_blocks_spin,
6829                             GTK_TOGGLE_BUTTON (widget)->active);
6830 }
6831
6832 static void
6833 entry_changed (GtkWidget *widget, ProgressData *pdata)
6834 {
6835   gtk_progress_set_format_string (GTK_PROGRESS (pdata->pbar),
6836                           gtk_entry_get_text (GTK_ENTRY (pdata->entry)));
6837 }
6838
6839 void
6840 create_progress_bar (void)
6841 {
6842   GtkWidget *button;
6843   GtkWidget *vbox;
6844   GtkWidget *vbox2;
6845   GtkWidget *hbox;
6846   GtkWidget *check;
6847   GtkWidget *frame;
6848   GtkWidget *tab;
6849   GtkWidget *label;
6850   GtkWidget *align;
6851   GtkAdjustment *adj;
6852   static ProgressData *pdata = NULL;
6853
6854   static OptionMenuItem items1[] =
6855   {
6856     { "Left-Right", progressbar_toggle_orientation },
6857     { "Right-Left", progressbar_toggle_orientation },
6858     { "Bottom-Top", progressbar_toggle_orientation },
6859     { "Top-Bottom", progressbar_toggle_orientation }
6860   };
6861
6862   static OptionMenuItem items2[] =
6863   {
6864     { "Continuous", progressbar_toggle_bar_style },
6865     { "Discrete",   progressbar_toggle_bar_style }
6866   };
6867
6868   if (!pdata)
6869     pdata = g_new0 (ProgressData, 1);
6870
6871   if (!pdata->window)
6872     {
6873       pdata->window = gtk_dialog_new ();
6874
6875       gtk_window_set_policy (GTK_WINDOW (pdata->window), FALSE, FALSE, TRUE);
6876
6877       gtk_signal_connect (GTK_OBJECT (pdata->window), "destroy",
6878                           GTK_SIGNAL_FUNC (destroy_progress),
6879                           &pdata);
6880
6881       pdata->timer = 0;
6882
6883       gtk_window_set_title (GTK_WINDOW (pdata->window), "GtkProgressBar");
6884       gtk_container_set_border_width (GTK_CONTAINER (pdata->window), 0);
6885
6886       vbox = gtk_vbox_new (FALSE, 5);
6887       gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
6888       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pdata->window)->vbox),
6889                           vbox, FALSE, TRUE, 0);
6890
6891       frame = gtk_frame_new ("Progress");
6892       gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
6893
6894       vbox2 = gtk_vbox_new (FALSE, 5);
6895       gtk_container_add (GTK_CONTAINER (frame), vbox2);
6896
6897       align = gtk_alignment_new (0.5, 0.5, 0, 0);
6898       gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
6899
6900       adj = (GtkAdjustment *) gtk_adjustment_new (0, 1, 300, 0, 0, 0);
6901       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6902                           GTK_SIGNAL_FUNC (progress_value_changed), pdata);
6903
6904       pdata->pbar = gtk_progress_bar_new_with_adjustment (adj);
6905       gtk_progress_set_format_string (GTK_PROGRESS (pdata->pbar),
6906                                       "%v from [%l,%u] (=%p%%)");
6907       gtk_container_add (GTK_CONTAINER (align), pdata->pbar);
6908       pdata->timer = gtk_timeout_add (100, progress_timeout, pdata->pbar);
6909
6910       align = gtk_alignment_new (0.5, 0.5, 0, 0);
6911       gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
6912
6913       hbox = gtk_hbox_new (FALSE, 5);
6914       gtk_container_add (GTK_CONTAINER (align), hbox);
6915       label = gtk_label_new ("Label updated by user :");
6916       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
6917       pdata->label = gtk_label_new ("");
6918       gtk_box_pack_start (GTK_BOX (hbox), pdata->label, FALSE, TRUE, 0);
6919
6920       frame = gtk_frame_new ("Options");
6921       gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
6922
6923       vbox2 = gtk_vbox_new (FALSE, 5);
6924       gtk_container_add (GTK_CONTAINER (frame), vbox2);
6925
6926       tab = gtk_table_new (7, 2, FALSE);
6927       gtk_box_pack_start (GTK_BOX (vbox2), tab, FALSE, TRUE, 0);
6928
6929       label = gtk_label_new ("Orientation :");
6930       gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 0, 1,
6931                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6932                         5, 5);
6933       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
6934
6935       pdata->omenu1 = build_option_menu (items1, 4, 0, pdata);
6936       hbox = gtk_hbox_new (FALSE, 0);
6937       gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 0, 1,
6938                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6939                         5, 5);
6940       gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu1, TRUE, TRUE, 0);
6941
6942       check = gtk_check_button_new_with_label ("Show text");
6943       gtk_signal_connect (GTK_OBJECT (check), "clicked",
6944                           GTK_SIGNAL_FUNC (toggle_show_text),
6945                           pdata);
6946       gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 1, 2,
6947                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6948                         5, 5);
6949
6950       hbox = gtk_hbox_new (FALSE, 0);
6951       gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 1, 2,
6952                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6953                         5, 5);
6954
6955       label = gtk_label_new ("Format : ");
6956       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
6957
6958       pdata->entry = gtk_entry_new ();
6959       gtk_signal_connect (GTK_OBJECT (pdata->entry), "changed",
6960                           GTK_SIGNAL_FUNC (entry_changed),
6961                           pdata);
6962       gtk_box_pack_start (GTK_BOX (hbox), pdata->entry, TRUE, TRUE, 0);
6963       gtk_entry_set_text (GTK_ENTRY (pdata->entry), "%v from [%l,%u] (=%p%%)");
6964       gtk_widget_set_usize (pdata->entry, 100, -1);
6965       gtk_widget_set_sensitive (pdata->entry, FALSE);
6966
6967       label = gtk_label_new ("Text align :");
6968       gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 2, 3,
6969                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6970                         5, 5);
6971       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
6972
6973       hbox = gtk_hbox_new (FALSE, 0);
6974       gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 2, 3,
6975                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6976                         5, 5);
6977
6978       label = gtk_label_new ("x :");
6979       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 5);
6980
6981       adj = (GtkAdjustment *) gtk_adjustment_new (0.5, 0, 1, 0.1, 0.1, 0);
6982       pdata->x_align_spin = gtk_spin_button_new (adj, 0, 1);
6983       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6984                           GTK_SIGNAL_FUNC (adjust_align), pdata);
6985       gtk_box_pack_start (GTK_BOX (hbox), pdata->x_align_spin, FALSE, TRUE, 0);
6986       gtk_widget_set_sensitive (pdata->x_align_spin, FALSE);
6987
6988       label = gtk_label_new ("y :");
6989       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 5);
6990
6991       adj = (GtkAdjustment *) gtk_adjustment_new (0.5, 0, 1, 0.1, 0.1, 0);
6992       pdata->y_align_spin = gtk_spin_button_new (adj, 0, 1);
6993       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6994                           GTK_SIGNAL_FUNC (adjust_align), pdata);
6995       gtk_box_pack_start (GTK_BOX (hbox), pdata->y_align_spin, FALSE, TRUE, 0);
6996       gtk_widget_set_sensitive (pdata->y_align_spin, FALSE);
6997
6998       label = gtk_label_new ("Bar Style :");
6999       gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 3, 4,
7000                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7001                         5, 5);
7002       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
7003
7004       pdata->omenu2 = build_option_menu (items2, 2, 0, pdata);
7005       hbox = gtk_hbox_new (FALSE, 0);
7006       gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 3, 4,
7007                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7008                         5, 5);
7009       gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu2, TRUE, TRUE, 0);
7010
7011       label = gtk_label_new ("Block count :");
7012       gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 4, 5,
7013                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7014                         5, 5);
7015       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
7016
7017       hbox = gtk_hbox_new (FALSE, 0);
7018       gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 4, 5,
7019                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7020                         5, 5);
7021       adj = (GtkAdjustment *) gtk_adjustment_new (10, 2, 20, 1, 5, 0);
7022       pdata->block_spin = gtk_spin_button_new (adj, 0, 0);
7023       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7024                           GTK_SIGNAL_FUNC (adjust_blocks), pdata);
7025       gtk_box_pack_start (GTK_BOX (hbox), pdata->block_spin, FALSE, TRUE, 0);
7026       gtk_widget_set_sensitive (pdata->block_spin, FALSE);
7027
7028       check = gtk_check_button_new_with_label ("Activity mode");
7029       gtk_signal_connect (GTK_OBJECT (check), "clicked",
7030                           GTK_SIGNAL_FUNC (toggle_activity_mode),
7031                           pdata);
7032       gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 5, 6,
7033                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7034                         5, 5);
7035
7036       hbox = gtk_hbox_new (FALSE, 0);
7037       gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 5, 6,
7038                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7039                         5, 5);
7040       label = gtk_label_new ("Step size : ");
7041       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
7042       adj = (GtkAdjustment *) gtk_adjustment_new (3, 1, 20, 1, 5, 0);
7043       pdata->step_spin = gtk_spin_button_new (adj, 0, 0);
7044       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7045                           GTK_SIGNAL_FUNC (adjust_step), pdata);
7046       gtk_box_pack_start (GTK_BOX (hbox), pdata->step_spin, FALSE, TRUE, 0);
7047       gtk_widget_set_sensitive (pdata->step_spin, FALSE);
7048
7049       hbox = gtk_hbox_new (FALSE, 0);
7050       gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 6, 7,
7051                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7052                         5, 5);
7053       label = gtk_label_new ("Blocks :     ");
7054       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
7055       adj = (GtkAdjustment *) gtk_adjustment_new (5, 2, 10, 1, 5, 0);
7056       pdata->act_blocks_spin = gtk_spin_button_new (adj, 0, 0);
7057       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7058                           GTK_SIGNAL_FUNC (adjust_act_blocks), pdata);
7059       gtk_box_pack_start (GTK_BOX (hbox), pdata->act_blocks_spin, FALSE, TRUE,
7060                           0);
7061       gtk_widget_set_sensitive (pdata->act_blocks_spin, FALSE);
7062
7063       button = gtk_button_new_with_label ("close");
7064       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7065                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
7066                                  GTK_OBJECT (pdata->window));
7067       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7068       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pdata->window)->action_area),
7069                           button, TRUE, TRUE, 0);
7070       gtk_widget_grab_default (button);
7071     }
7072
7073   if (!GTK_WIDGET_VISIBLE (pdata->window))
7074     gtk_widget_show_all (pdata->window);
7075   else
7076     gtk_widget_destroy (pdata->window);
7077 }
7078
7079 /*
7080  * Color Preview
7081  */
7082
7083 static int color_idle = 0;
7084
7085 gint
7086 color_idle_func (GtkWidget *preview)
7087 {
7088   static int count = 1;
7089   guchar buf[768];
7090   int i, j, k;
7091
7092   for (i = 0; i < 256; i++)
7093     {
7094       for (j = 0, k = 0; j < 256; j++)
7095         {
7096           buf[k+0] = i + count;
7097           buf[k+1] = 0;
7098           buf[k+2] = j + count;
7099           k += 3;
7100         }
7101
7102       gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
7103     }
7104
7105   count += 1;
7106
7107   gtk_widget_draw (preview, NULL);
7108
7109   return TRUE;
7110 }
7111
7112 static void
7113 color_preview_destroy (GtkWidget  *widget,
7114                        GtkWidget **window)
7115 {
7116   gtk_idle_remove (color_idle);
7117   color_idle = 0;
7118
7119   *window = NULL;
7120 }
7121
7122 void
7123 create_color_preview (void)
7124 {
7125   static GtkWidget *window = NULL;
7126   GtkWidget *preview;
7127   guchar buf[768];
7128   int i, j, k;
7129
7130   if (!window)
7131     {
7132       gtk_widget_push_visual (gdk_rgb_get_visual ());
7133       gtk_widget_push_colormap (gdk_rgb_get_cmap ());
7134       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7135       gtk_widget_pop_colormap ();
7136       gtk_widget_pop_visual ();
7137
7138       gtk_signal_connect (GTK_OBJECT (window), "destroy",
7139                           GTK_SIGNAL_FUNC(color_preview_destroy),
7140                           &window);
7141
7142       gtk_window_set_title (GTK_WINDOW (window), "test");
7143       gtk_container_set_border_width (GTK_CONTAINER (window), 10);
7144
7145       preview = gtk_preview_new (GTK_PREVIEW_COLOR);
7146       gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
7147       gtk_container_add (GTK_CONTAINER (window), preview);
7148
7149       for (i = 0; i < 256; i++)
7150         {
7151           for (j = 0, k = 0; j < 256; j++)
7152             {
7153               buf[k+0] = i;
7154               buf[k+1] = 0;
7155               buf[k+2] = j;
7156               k += 3;
7157             }
7158
7159           gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
7160         }
7161
7162       color_idle = gtk_idle_add ((GtkFunction) color_idle_func, preview);
7163     }
7164
7165   if (!GTK_WIDGET_VISIBLE (window))
7166     gtk_widget_show_all (window);
7167   else
7168     gtk_widget_destroy (window);
7169 }
7170
7171 /*
7172  * Gray Preview
7173  */
7174
7175 static int gray_idle = 0;
7176
7177 gint
7178 gray_idle_func (GtkWidget *preview)
7179 {
7180   static int count = 1;
7181   guchar buf[256];
7182   int i, j;
7183
7184   for (i = 0; i < 256; i++)
7185     {
7186       for (j = 0; j < 256; j++)
7187         buf[j] = i + j + count;
7188
7189       gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
7190     }
7191
7192   count += 1;
7193
7194   gtk_widget_draw (preview, NULL);
7195
7196   return TRUE;
7197 }
7198
7199 static void
7200 gray_preview_destroy (GtkWidget  *widget,
7201                       GtkWidget **window)
7202 {
7203   gtk_idle_remove (gray_idle);
7204   gray_idle = 0;
7205
7206   *window = NULL;
7207 }
7208
7209 void
7210 create_gray_preview (void)
7211 {
7212   static GtkWidget *window = NULL;
7213   GtkWidget *preview;
7214   guchar buf[256];
7215   int i, j;
7216
7217   if (!window)
7218     {
7219       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7220
7221       gtk_signal_connect (GTK_OBJECT (window), "destroy",
7222                           GTK_SIGNAL_FUNC(gray_preview_destroy),
7223                           &window);
7224
7225       gtk_window_set_title (GTK_WINDOW (window), "test");
7226       gtk_container_set_border_width (GTK_CONTAINER (window), 10);
7227
7228       preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
7229       gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
7230       gtk_container_add (GTK_CONTAINER (window), preview);
7231
7232       for (i = 0; i < 256; i++)
7233         {
7234           for (j = 0; j < 256; j++)
7235             buf[j] = i + j;
7236
7237           gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
7238         }
7239
7240       gray_idle = gtk_idle_add ((GtkFunction) gray_idle_func, preview);
7241     }
7242
7243   if (!GTK_WIDGET_VISIBLE (window))
7244     gtk_widget_show_all (window);
7245   else
7246     gtk_widget_destroy (window);
7247 }
7248
7249
7250 /*
7251  * Selection Test
7252  */
7253
7254 void
7255 selection_test_received (GtkWidget *list, GtkSelectionData *data)
7256 {
7257   GdkAtom *atoms;
7258   GtkWidget *list_item;
7259   GList *item_list;
7260   int i, l;
7261
7262   if (data->length < 0)
7263     {
7264       g_print ("Selection retrieval failed\n");
7265       return;
7266     }
7267   if (data->type != GDK_SELECTION_TYPE_ATOM)
7268     {
7269       g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
7270       return;
7271     }
7272
7273   /* Clear out any current list items */
7274
7275   gtk_list_clear_items (GTK_LIST(list), 0, -1);
7276
7277   /* Add new items to list */
7278
7279   atoms = (GdkAtom *)data->data;
7280
7281   item_list = NULL;
7282   l = data->length / sizeof (GdkAtom);
7283   for (i = 0; i < l; i++)
7284     {
7285       char *name;
7286       name = gdk_atom_name (atoms[i]);
7287       if (name != NULL)
7288         {
7289           list_item = gtk_list_item_new_with_label (name);
7290           g_free (name);
7291         }
7292       else
7293         list_item = gtk_list_item_new_with_label ("(bad atom)");
7294
7295       gtk_widget_show (list_item);
7296       item_list = g_list_append (item_list, list_item);
7297     }
7298
7299   gtk_list_append_items (GTK_LIST (list), item_list);
7300
7301   return;
7302 }
7303
7304 void
7305 selection_test_get_targets (GtkWidget *widget, GtkWidget *list)
7306 {
7307   static GdkAtom targets_atom = GDK_NONE;
7308
7309   if (targets_atom == GDK_NONE)
7310     targets_atom = gdk_atom_intern ("TARGETS", FALSE);
7311
7312   gtk_selection_convert (list, GDK_SELECTION_PRIMARY, targets_atom,
7313                          GDK_CURRENT_TIME);
7314 }
7315
7316 void
7317 create_selection_test (void)
7318 {
7319   static GtkWidget *window = NULL;
7320   GtkWidget *button;
7321   GtkWidget *vbox;
7322   GtkWidget *scrolled_win;
7323   GtkWidget *list;
7324   GtkWidget *label;
7325
7326   if (!window)
7327     {
7328       window = gtk_dialog_new ();
7329
7330       gtk_signal_connect (GTK_OBJECT (window), "destroy",
7331                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7332                           &window);
7333
7334       gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
7335       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
7336
7337       /* Create the list */
7338
7339       vbox = gtk_vbox_new (FALSE, 5);
7340       gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
7341       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox,
7342                           TRUE, TRUE, 0);
7343
7344       label = gtk_label_new ("Gets available targets for current selection");
7345       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
7346
7347       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
7348       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
7349                                       GTK_POLICY_AUTOMATIC,
7350                                       GTK_POLICY_AUTOMATIC);
7351       gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
7352       gtk_widget_set_usize (scrolled_win, 100, 200);
7353
7354       list = gtk_list_new ();
7355       gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), list);
7356
7357       gtk_signal_connect (GTK_OBJECT(list), "selection_received",
7358                           GTK_SIGNAL_FUNC (selection_test_received), NULL);
7359
7360       /* .. And create some buttons */
7361       button = gtk_button_new_with_label ("Get Targets");
7362       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7363                           button, TRUE, TRUE, 0);
7364
7365       gtk_signal_connect (GTK_OBJECT (button), "clicked",
7366                           GTK_SIGNAL_FUNC (selection_test_get_targets), list);
7367
7368       button = gtk_button_new_with_label ("Quit");
7369       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7370                           button, TRUE, TRUE, 0);
7371
7372       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7373                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
7374                                  GTK_OBJECT (window));
7375     }
7376
7377   if (!GTK_WIDGET_VISIBLE (window))
7378     gtk_widget_show_all (window);
7379   else
7380     gtk_widget_destroy (window);
7381 }
7382
7383 /*
7384  * Gamma Curve
7385  */
7386
7387 void
7388 create_gamma_curve (void)
7389 {
7390   static GtkWidget *window = NULL, *curve;
7391   static int count = 0;
7392   gfloat vec[256];
7393   gint max;
7394   gint i;
7395
7396   if (!window)
7397     {
7398       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7399       gtk_window_set_title (GTK_WINDOW (window), "test");
7400       gtk_container_set_border_width (GTK_CONTAINER (window), 10);
7401
7402       gtk_signal_connect (GTK_OBJECT (window), "destroy",
7403                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7404                           &window);
7405
7406       curve = gtk_gamma_curve_new ();
7407       gtk_container_add (GTK_CONTAINER (window), curve);
7408       gtk_widget_show (curve);
7409     }
7410
7411   max = 127 + (count % 2)*128;
7412   gtk_curve_set_range (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
7413                        0, max, 0, max);
7414   for (i = 0; i < max; ++i)
7415     vec[i] = (127 / sqrt (max)) * sqrt (i);
7416   gtk_curve_set_vector (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
7417                         max, vec);
7418
7419   if (!GTK_WIDGET_VISIBLE (window))
7420     gtk_widget_show (window);
7421   else if (count % 4 == 3)
7422     {
7423       gtk_widget_destroy (window);
7424       window = NULL;
7425     }
7426
7427   ++count;
7428 }
7429
7430 /*
7431  * Test scrolling
7432  */
7433
7434 static int scroll_test_pos = 0.0;
7435 static GdkGC *scroll_test_gc = NULL;
7436
7437 static gint
7438 scroll_test_expose (GtkWidget *widget, GdkEventExpose *event,
7439                     GtkAdjustment *adj)
7440 {
7441   gint i,j;
7442   gint imin, imax, jmin, jmax;
7443
7444   imin = (event->area.x) / 10;
7445   imax = (event->area.x + event->area.width + 9) / 10;
7446
7447   jmin = ((int)adj->value + event->area.y) / 10;
7448   jmax = ((int)adj->value + event->area.y + event->area.height + 9) / 10;
7449
7450   gdk_window_clear_area (widget->window,
7451                          event->area.x, event->area.y,
7452                          event->area.width, event->area.height);
7453
7454   for (i=imin; i<imax; i++)
7455     for (j=jmin; j<jmax; j++)
7456       if ((i+j) % 2)
7457         gdk_draw_rectangle (widget->window,
7458                             widget->style->black_gc,
7459                             TRUE,
7460                             10*i, 10*j - (int)adj->value, 1+i%10, 1+j%10);
7461
7462   return TRUE;
7463 }
7464
7465 static void
7466 scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
7467                        GtkAdjustment *adj)
7468 {
7469   adj->page_increment = 0.9 * widget->allocation.height;
7470   adj->page_size = widget->allocation.height;
7471
7472   gtk_signal_emit_by_name (GTK_OBJECT (adj), "changed");
7473 }
7474
7475 static void
7476 scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
7477 {
7478   gint source_min = (int)adj->value - scroll_test_pos;
7479   gint source_max = source_min + widget->allocation.height;
7480   gint dest_min = 0;
7481   gint dest_max = widget->allocation.height;
7482   GdkRectangle rect;
7483   GdkEvent *event;
7484
7485   scroll_test_pos = adj->value;
7486
7487   if (!GTK_WIDGET_DRAWABLE (widget))
7488     return;
7489
7490   if (source_min < 0)
7491     {
7492       rect.x = 0;
7493       rect.y = 0;
7494       rect.width = widget->allocation.width;
7495       rect.height = -source_min;
7496       if (rect.height > widget->allocation.height)
7497         rect.height = widget->allocation.height;
7498
7499       source_min = 0;
7500       dest_min = rect.height;
7501     }
7502   else
7503     {
7504       rect.x = 0;
7505       rect.y = 2*widget->allocation.height - source_max;
7506       if (rect.y < 0)
7507         rect.y = 0;
7508       rect.width = widget->allocation.width;
7509       rect.height = widget->allocation.height - rect.y;
7510
7511       source_max = widget->allocation.height;
7512       dest_max = rect.y;
7513     }
7514
7515   if (source_min != source_max)
7516     {
7517       if (scroll_test_gc == NULL)
7518         {
7519           scroll_test_gc = gdk_gc_new (widget->window);
7520           gdk_gc_set_exposures (scroll_test_gc, TRUE);
7521         }
7522
7523       gdk_draw_pixmap (widget->window,
7524                        scroll_test_gc,
7525                        widget->window,
7526                        0, source_min,
7527                        0, dest_min,
7528                        widget->allocation.width,
7529                        source_max - source_min);
7530
7531       /* Make sure graphics expose events are processed before scrolling
7532        * again */
7533
7534       while ((event = gdk_event_get_graphics_expose (widget->window)) != NULL)
7535         {
7536           gtk_widget_event (widget, event);
7537           if (event->expose.count == 0)
7538             {
7539               gdk_event_free (event);
7540               break;
7541             }
7542           gdk_event_free (event);
7543         }
7544     }
7545
7546   if (rect.height != 0)
7547     gtk_widget_draw (widget, &rect);
7548 }
7549
7550
7551 void
7552 create_scroll_test (void)
7553 {
7554   static GtkWidget *window = NULL;
7555   GtkWidget *hbox;
7556   GtkWidget *drawing_area;
7557   GtkWidget *scrollbar;
7558   GtkWidget *button;
7559   GtkAdjustment *adj;
7560   GdkGeometry geometry;
7561   GdkWindowHints geometry_mask;
7562
7563   if (!window)
7564     {
7565       window = gtk_dialog_new ();
7566
7567       gtk_signal_connect (GTK_OBJECT (window), "destroy",
7568                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7569                           &window);
7570
7571       gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
7572       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
7573
7574       hbox = gtk_hbox_new (FALSE, 0);
7575       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox,
7576                           TRUE, TRUE, 0);
7577       gtk_widget_show (hbox);
7578
7579       drawing_area = gtk_drawing_area_new ();
7580       gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 200, 200);
7581       gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
7582       gtk_widget_show (drawing_area);
7583
7584       gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK);
7585
7586       adj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0));
7587       scroll_test_pos = 0.0;
7588
7589       scrollbar = gtk_vscrollbar_new (adj);
7590       gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
7591       gtk_widget_show (scrollbar);
7592
7593       gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
7594                           GTK_SIGNAL_FUNC (scroll_test_expose), adj);
7595       gtk_signal_connect (GTK_OBJECT (drawing_area), "configure_event",
7596                           GTK_SIGNAL_FUNC (scroll_test_configure), adj);
7597
7598
7599       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7600                           GTK_SIGNAL_FUNC (scroll_test_adjustment_changed),
7601                           drawing_area);
7602
7603       /* .. And create some buttons */
7604
7605       button = gtk_button_new_with_label ("Quit");
7606       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7607                           button, TRUE, TRUE, 0);
7608
7609       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7610                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
7611                                  GTK_OBJECT (window));
7612       gtk_widget_show (button);
7613
7614       /* Set up gridded geometry */
7615
7616       geometry_mask = GDK_HINT_MIN_SIZE |
7617                        GDK_HINT_BASE_SIZE |
7618                        GDK_HINT_RESIZE_INC;
7619
7620       geometry.min_width = 20;
7621       geometry.min_height = 20;
7622       geometry.base_width = 0;
7623       geometry.base_height = 0;
7624       geometry.width_inc = 10;
7625       geometry.height_inc = 10;
7626
7627       gtk_window_set_geometry_hints (GTK_WINDOW (window),
7628                                drawing_area, &geometry, geometry_mask);
7629     }
7630
7631   if (!GTK_WIDGET_VISIBLE (window))
7632     gtk_widget_show (window);
7633   else
7634     gtk_widget_destroy (window);
7635 }
7636
7637 /*
7638  * Timeout Test
7639  */
7640
7641 static int timer = 0;
7642
7643 gint
7644 timeout_test (GtkWidget *label)
7645 {
7646   static int count = 0;
7647   static char buffer[32];
7648
7649   sprintf (buffer, "count: %d", ++count);
7650   gtk_label_set_text (GTK_LABEL (label), buffer);
7651
7652   return TRUE;
7653 }
7654
7655 void
7656 start_timeout_test (GtkWidget *widget,
7657                     GtkWidget *label)
7658 {
7659   if (!timer)
7660     {
7661       timer = gtk_timeout_add (100, (GtkFunction) timeout_test, label);
7662     }
7663 }
7664
7665 void
7666 stop_timeout_test (GtkWidget *widget,
7667                    gpointer   data)
7668 {
7669   if (timer)
7670     {
7671       gtk_timeout_remove (timer);
7672       timer = 0;
7673     }
7674 }
7675
7676 void
7677 destroy_timeout_test (GtkWidget  *widget,
7678                       GtkWidget **window)
7679 {
7680   stop_timeout_test (NULL, NULL);
7681
7682   *window = NULL;
7683 }
7684
7685 void
7686 create_timeout_test (void)
7687 {
7688   static GtkWidget *window = NULL;
7689   GtkWidget *button;
7690   GtkWidget *label;
7691
7692   if (!window)
7693     {
7694       window = gtk_dialog_new ();
7695
7696       gtk_signal_connect (GTK_OBJECT (window), "destroy",
7697                           GTK_SIGNAL_FUNC(destroy_timeout_test),
7698                           &window);
7699
7700       gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
7701       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
7702
7703       label = gtk_label_new ("count: 0");
7704       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
7705       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
7706                           label, TRUE, TRUE, 0);
7707       gtk_widget_show (label);
7708
7709       button = gtk_button_new_with_label ("close");
7710       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7711                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
7712                                  GTK_OBJECT (window));
7713       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7714       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7715                           button, TRUE, TRUE, 0);
7716       gtk_widget_grab_default (button);
7717       gtk_widget_show (button);
7718
7719       button = gtk_button_new_with_label ("start");
7720       gtk_signal_connect (GTK_OBJECT (button), "clicked",
7721                           GTK_SIGNAL_FUNC(start_timeout_test),
7722                           label);
7723       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7724       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7725                           button, TRUE, TRUE, 0);
7726       gtk_widget_show (button);
7727
7728       button = gtk_button_new_with_label ("stop");
7729       gtk_signal_connect (GTK_OBJECT (button), "clicked",
7730                           GTK_SIGNAL_FUNC(stop_timeout_test),
7731                           NULL);
7732       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7733       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7734                           button, TRUE, TRUE, 0);
7735       gtk_widget_show (button);
7736     }
7737
7738   if (!GTK_WIDGET_VISIBLE (window))
7739     gtk_widget_show (window);
7740   else
7741     gtk_widget_destroy (window);
7742 }
7743
7744 /*
7745  * Idle Test
7746  */
7747
7748 static int idle = 0;
7749
7750 static gint
7751 idle_test (GtkWidget *label)
7752 {
7753   static int count = 0;
7754   static char buffer[32];
7755
7756   sprintf (buffer, "count: %d", ++count);
7757   gtk_label_set_text (GTK_LABEL (label), buffer);
7758
7759   return TRUE;
7760 }
7761
7762 static void
7763 start_idle_test (GtkWidget *widget,
7764                  GtkWidget *label)
7765 {
7766   if (!idle)
7767     {
7768       idle = gtk_idle_add ((GtkFunction) idle_test, label);
7769     }
7770 }
7771
7772 static void
7773 stop_idle_test (GtkWidget *widget,
7774                 gpointer   data)
7775 {
7776   if (idle)
7777     {
7778       gtk_idle_remove (idle);
7779       idle = 0;
7780     }
7781 }
7782
7783 static void
7784 destroy_idle_test (GtkWidget  *widget,
7785                    GtkWidget **window)
7786 {
7787   stop_idle_test (NULL, NULL);
7788
7789   *window = NULL;
7790 }
7791
7792 static void
7793 toggle_idle_container (GtkObject *button,
7794                        GtkContainer *container)
7795 {
7796   gtk_container_set_resize_mode (container, GPOINTER_TO_INT (gtk_object_get_user_data (button)));
7797 }
7798
7799 static void
7800 create_idle_test (void)
7801 {
7802   static GtkWidget *window = NULL;
7803   GtkWidget *button;
7804   GtkWidget *label;
7805   GtkWidget *container;
7806
7807   if (!window)
7808     {
7809       GtkWidget *frame;
7810       GtkWidget *box;
7811
7812       window = gtk_dialog_new ();
7813
7814       gtk_signal_connect (GTK_OBJECT (window), "destroy",
7815                           GTK_SIGNAL_FUNC(destroy_idle_test),
7816                           &window);
7817
7818       gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
7819       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
7820
7821       label = gtk_label_new ("count: 0");
7822       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
7823       gtk_widget_show (label);
7824
7825       container =
7826         gtk_widget_new (GTK_TYPE_HBOX,
7827                         "GtkWidget::visible", TRUE,
7828                         /* "GtkContainer::child", gtk_widget_new (GTK_TYPE_HBOX,
7829                          * "GtkWidget::visible", TRUE,
7830                          */
7831                          "GtkContainer::child", label,
7832                         /* NULL), */
7833                         NULL);
7834       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
7835                           container, TRUE, TRUE, 0);
7836
7837       frame =
7838         gtk_widget_new (GTK_TYPE_FRAME,
7839                         "GtkContainer::border_width", 5,
7840                         "GtkFrame::label", "Label Container",
7841                         "GtkWidget::visible", TRUE,
7842                         "GtkWidget::parent", GTK_DIALOG (window)->vbox,
7843                         NULL);
7844       box =
7845         gtk_widget_new (GTK_TYPE_VBOX,
7846                         "GtkWidget::visible", TRUE,
7847                         "GtkWidget::parent", frame,
7848                         NULL);
7849       button =
7850         gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
7851                         "GtkButton::label", "Resize-Parent",
7852                         "GtkObject::user_data", (void*)GTK_RESIZE_PARENT,
7853                         "GtkObject::signal::clicked", toggle_idle_container, container,
7854                         "GtkWidget::visible", TRUE,
7855                         "GtkWidget::parent", box,
7856                         NULL);
7857       button =
7858         gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
7859                         "GtkButton::label", "Resize-Queue",
7860                         "GtkObject::user_data", (void*)GTK_RESIZE_QUEUE,
7861                         "GtkObject::signal::clicked", toggle_idle_container, container,
7862                         "GtkRadioButton::group", button,
7863                         "GtkWidget::visible", TRUE,
7864                         "GtkWidget::parent", box,
7865                         NULL);
7866       button =
7867         gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
7868                         "GtkButton::label", "Resize-Immediate",
7869                         "GtkObject::user_data", (void*)GTK_RESIZE_IMMEDIATE,
7870                         "GtkObject::signal::clicked", toggle_idle_container, container,
7871                         "GtkRadioButton::group", button,
7872                         "GtkWidget::visible", TRUE,
7873                         "GtkWidget::parent", box,
7874                         NULL);
7875
7876
7877       button = gtk_button_new_with_label ("close");
7878       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7879                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
7880                                  GTK_OBJECT (window));
7881       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7882       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7883                           button, TRUE, TRUE, 0);
7884       gtk_widget_grab_default (button);
7885       gtk_widget_show (button);
7886
7887       button = gtk_button_new_with_label ("start");
7888       gtk_signal_connect (GTK_OBJECT (button), "clicked",
7889                           GTK_SIGNAL_FUNC(start_idle_test),
7890                           label);
7891       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7892       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7893                           button, TRUE, TRUE, 0);
7894       gtk_widget_show (button);
7895
7896       button = gtk_button_new_with_label ("stop");
7897       gtk_signal_connect (GTK_OBJECT (button), "clicked",
7898                           GTK_SIGNAL_FUNC(stop_idle_test),
7899                           NULL);
7900       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7901       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7902                           button, TRUE, TRUE, 0);
7903       gtk_widget_show (button);
7904     }
7905
7906   if (!GTK_WIDGET_VISIBLE (window))
7907     gtk_widget_show (window);
7908   else
7909     gtk_widget_destroy (window);
7910 }
7911
7912 /*
7913  * rc file test
7914  */
7915
7916 void
7917 reload_rc_file (void)
7918 {
7919   GList *toplevels;
7920
7921   if (gtk_rc_reparse_all ())
7922     {
7923       toplevels = gdk_window_get_toplevels();
7924       while (toplevels)
7925         {
7926           GtkWidget *widget;
7927           gdk_window_get_user_data (toplevels->data, (gpointer *)&widget);
7928
7929           if (widget)
7930             gtk_widget_reset_rc_styles (widget);
7931
7932           toplevels = toplevels->next;
7933         }
7934       g_list_free (toplevels);
7935     }
7936 }
7937
7938 void
7939 reload_all_rc_files (void)
7940 {
7941   static GdkAtom atom_rcfiles = GDK_NONE;
7942
7943   GdkEventClient sev;
7944   int i;
7945
7946   if (!atom_rcfiles)
7947     atom_rcfiles = gdk_atom_intern("_GTK_READ_RCFILES", FALSE);
7948
7949   for(i = 0; i < 5; i++)
7950     sev.data.l[i] = 0;
7951   sev.data_format = 32;
7952   sev.message_type = atom_rcfiles;
7953   gdk_event_send_clientmessage_toall ((GdkEvent *) &sev);
7954 }
7955
7956 void
7957 create_rc_file (void)
7958 {
7959   static GtkWidget *window = NULL;
7960   GtkWidget *button;
7961
7962   if (!window)
7963     {
7964       window = gtk_dialog_new ();
7965
7966       gtk_signal_connect (GTK_OBJECT (window), "destroy",
7967                           GTK_SIGNAL_FUNC(destroy_idle_test),
7968                           &window);
7969
7970       gtk_window_set_title (GTK_WINDOW (window), "Reload Rc file");
7971       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
7972
7973       button = gtk_button_new_with_label ("Reload");
7974       gtk_signal_connect (GTK_OBJECT (button), "clicked",
7975                           GTK_SIGNAL_FUNC(reload_rc_file), NULL);
7976       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7977       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7978                           button, TRUE, TRUE, 0);
7979       gtk_widget_grab_default (button);
7980       gtk_widget_show (button);
7981
7982       button = gtk_button_new_with_label ("Reload All");
7983       gtk_signal_connect (GTK_OBJECT (button), "clicked",
7984                           GTK_SIGNAL_FUNC(reload_all_rc_files), NULL);
7985       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7986       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7987                           button, TRUE, TRUE, 0);
7988       gtk_widget_show (button);
7989
7990       button = gtk_button_new_with_label ("Close");
7991       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7992                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
7993                                  GTK_OBJECT (window));
7994       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7995       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7996                           button, TRUE, TRUE, 0);
7997       gtk_widget_show (button);
7998
7999     }
8000
8001   if (!GTK_WIDGET_VISIBLE (window))
8002     gtk_widget_show (window);
8003   else
8004     gtk_widget_destroy (window);
8005 }
8006
8007 /*
8008  * Test of recursive mainloop
8009  */
8010
8011 void
8012 mainloop_destroyed (GtkWidget *w, GtkWidget **window)
8013 {
8014   *window = NULL;
8015   gtk_main_quit ();
8016 }
8017
8018 void
8019 create_mainloop (void)
8020 {
8021   static GtkWidget *window = NULL;
8022   GtkWidget *label;
8023   GtkWidget *button;
8024
8025   if (!window)
8026     {
8027       window = gtk_dialog_new ();
8028
8029       gtk_window_set_title (GTK_WINDOW (window), "Test Main Loop");
8030
8031       gtk_signal_connect (GTK_OBJECT (window), "destroy",
8032                           GTK_SIGNAL_FUNC(mainloop_destroyed),
8033                           &window);
8034
8035       label = gtk_label_new ("In recursive main loop...");
8036       gtk_misc_set_padding (GTK_MISC(label), 20, 20);
8037
8038       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), label,
8039                           TRUE, TRUE, 0);
8040       gtk_widget_show (label);
8041
8042       button = gtk_button_new_with_label ("Leave");
8043       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button,
8044                           FALSE, TRUE, 0);
8045
8046       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
8047                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
8048                                  GTK_OBJECT (window));
8049
8050       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8051       gtk_widget_grab_default (button);
8052
8053       gtk_widget_show (button);
8054     }
8055
8056   if (!GTK_WIDGET_VISIBLE (window))
8057     {
8058       gtk_widget_show (window);
8059
8060       g_print ("create_mainloop: start\n");
8061       gtk_main ();
8062       g_print ("create_mainloop: done\n");
8063     }
8064   else
8065     gtk_widget_destroy (window);
8066 }
8067
8068 gint
8069 layout_expose_handler (GtkWidget *widget, GdkEventExpose *event)
8070 {
8071   GtkLayout *layout;
8072
8073   gint i,j;
8074   gint imin, imax, jmin, jmax;
8075
8076   layout = GTK_LAYOUT (widget);
8077
8078   imin = (layout->xoffset + event->area.x) / 10;
8079   imax = (layout->xoffset + event->area.x + event->area.width + 9) / 10;
8080
8081   jmin = (layout->yoffset + event->area.y) / 10;
8082   jmax = (layout->yoffset + event->area.y + event->area.height + 9) / 10;
8083
8084   gdk_window_clear_area (widget->window,
8085                          event->area.x, event->area.y,
8086                          event->area.width, event->area.height);
8087
8088   for (i=imin; i<imax; i++)
8089     for (j=jmin; j<jmax; j++)
8090       if ((i+j) % 2)
8091         gdk_draw_rectangle (layout->bin_window,
8092                             widget->style->black_gc,
8093                             TRUE,
8094                             10*i - layout->xoffset, 10*j - layout->yoffset,
8095                             1+i%10, 1+j%10);
8096
8097   return TRUE;
8098 }
8099
8100 void create_layout (void)
8101 {
8102   static GtkWidget *window = NULL;
8103   GtkWidget *layout;
8104   GtkWidget *scrolledwindow;
8105   GtkWidget *button;
8106
8107   if (!window)
8108     {
8109       gchar buf[16];
8110
8111       gint i, j;
8112
8113       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8114       gtk_signal_connect (GTK_OBJECT (window), "destroy",
8115                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
8116                           &window);
8117
8118       gtk_window_set_title (GTK_WINDOW (window), "Layout");
8119       gtk_widget_set_usize (window, 200, 200);
8120
8121       scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
8122
8123       gtk_container_add (GTK_CONTAINER (window), scrolledwindow);
8124
8125       layout = gtk_layout_new (NULL, NULL);
8126       gtk_container_add (GTK_CONTAINER (scrolledwindow), layout);
8127
8128       /* We set step sizes here since GtkLayout does not set
8129        * them itself.
8130        */
8131       GTK_LAYOUT (layout)->hadjustment->step_increment = 10.0;
8132       GTK_LAYOUT (layout)->vadjustment->step_increment = 10.0;
8133
8134       gtk_widget_set_events (layout, GDK_EXPOSURE_MASK);
8135       gtk_signal_connect (GTK_OBJECT (layout), "expose_event",
8136                           GTK_SIGNAL_FUNC (layout_expose_handler), NULL);
8137
8138       gtk_layout_set_size (GTK_LAYOUT (layout), 1600, 128000);
8139
8140       for (i=0 ; i < 16 ; i++)
8141         for (j=0 ; j < 16 ; j++)
8142           {
8143             sprintf(buf, "Button %d, %d", i, j);
8144             if ((i + j) % 2)
8145               button = gtk_button_new_with_label (buf);
8146             else
8147               button = gtk_label_new (buf);
8148
8149             gtk_layout_put (GTK_LAYOUT (layout), button,
8150                             j*100, i*100);
8151           }
8152
8153       for (i=16; i < 1280; i++)
8154         {
8155           sprintf(buf, "Button %d, %d", i, 0);
8156           if (i % 2)
8157             button = gtk_button_new_with_label (buf);
8158           else
8159             button = gtk_label_new (buf);
8160
8161           gtk_layout_put (GTK_LAYOUT (layout), button,
8162                           0, i*100);
8163         }
8164     }
8165
8166   if (!GTK_WIDGET_VISIBLE (window))
8167     gtk_widget_show_all (window);
8168   else
8169     gtk_widget_destroy (window);
8170 }
8171
8172 /*
8173  * Main Window and Exit
8174  */
8175
8176 void
8177 do_exit (GtkWidget *widget, GtkWidget *window)
8178 {
8179   gtk_widget_destroy (window);
8180   gtk_main_quit ();
8181 }
8182
8183 void
8184 create_main_window (void)
8185 {
8186   struct {
8187     char *label;
8188     void (*func) ();
8189   } buttons[] =
8190     {
8191       { "button box", create_button_box },
8192       { "buttons", create_buttons },
8193       { "check buttons", create_check_buttons },
8194       { "clist", create_clist},
8195       { "color selection", create_color_selection },
8196       { "ctree", create_ctree },
8197       { "cursors", create_cursors },
8198       { "dialog", create_dialog },
8199       /*      { "dnd", create_dnd }, */
8200       { "entry", create_entry },
8201       { "event watcher", create_event_watcher },
8202       { "file selection", create_file_selection },
8203       { "font selection", create_font_selection },
8204       { "gamma curve", create_gamma_curve },
8205       { "handle box", create_handle_box },
8206       { "item factory", create_item_factory },
8207       { "labels", create_labels },
8208       { "layout", create_layout },
8209       { "list", create_list },
8210       { "menus", create_menus },
8211       { "modal window", create_modal_window },
8212       { "notebook", create_notebook },
8213       { "panes", create_panes },
8214       { "pixmap", create_pixmap },
8215       { "preview color", create_color_preview },
8216       { "preview gray", create_gray_preview },
8217       { "progress bar", create_progress_bar },
8218       { "radio buttons", create_radio_buttons },
8219       { "range controls", create_range_controls },
8220       { "rc file", create_rc_file },
8221       { "reparent", create_reparent },
8222       { "rulers", create_rulers },
8223       { "saved position", create_saved_position },
8224       { "scrolled windows", create_scrolled_windows },
8225       { "shapes", create_shapes },
8226       { "spinbutton", create_spins },
8227       { "statusbar", create_statusbar },
8228       { "test idle", create_idle_test },
8229       { "test mainloop", create_mainloop },
8230       { "test scrolling", create_scroll_test },
8231       { "test selection", create_selection_test },
8232       { "test timeout", create_timeout_test },
8233       { "text", create_text },
8234       { "toggle buttons", create_toggle_buttons },
8235       { "toolbar", create_toolbar },
8236       { "tooltips", create_tooltips },
8237       { "tree", create_tree_mode_window},
8238       { "WM hints", create_wmhints },
8239     };
8240   int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
8241   GtkWidget *window;
8242   GtkWidget *box1;
8243   GtkWidget *box2;
8244   GtkWidget *scrolled_window;
8245   GtkWidget *button;
8246   GtkWidget *label;
8247   gchar buffer[64];
8248   GtkWidget *separator;
8249   int i;
8250
8251   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8252   gtk_window_set_policy (GTK_WINDOW (window), FALSE, FALSE, FALSE);
8253   gtk_widget_set_name (window, "main window");
8254   gtk_widget_set_usize (window, 200, 400);
8255   gtk_widget_set_uposition (window, 20, 20);
8256
8257   gtk_signal_connect (GTK_OBJECT (window), "destroy",
8258                       GTK_SIGNAL_FUNC(gtk_main_quit),
8259                       NULL);
8260   gtk_signal_connect (GTK_OBJECT (window), "delete-event",
8261                       GTK_SIGNAL_FUNC (gtk_false),
8262                       NULL);
8263
8264   box1 = gtk_vbox_new (FALSE, 0);
8265   gtk_container_add (GTK_CONTAINER (window), box1);
8266
8267   if (gtk_micro_version > 0)
8268     sprintf (buffer,
8269              "Gtk+ v%d.%d.%d",
8270              gtk_major_version,
8271              gtk_minor_version,
8272              gtk_micro_version);
8273   else
8274     sprintf (buffer,
8275              "Gtk+ v%d.%d",
8276              gtk_major_version,
8277              gtk_minor_version);
8278
8279   label = gtk_label_new (buffer);
8280   gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
8281
8282   scrolled_window = gtk_scrolled_window_new (NULL, NULL);
8283   gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
8284   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
8285                                   GTK_POLICY_AUTOMATIC,
8286                                   GTK_POLICY_AUTOMATIC);
8287   gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
8288
8289   box2 = gtk_vbox_new (FALSE, 0);
8290   gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
8291   gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), box2);
8292   gtk_container_set_focus_vadjustment (GTK_CONTAINER (box2),
8293                                        gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
8294   gtk_widget_show (box2);
8295
8296   for (i = 0; i < nbuttons; i++)
8297     {
8298       button = gtk_button_new_with_label (buttons[i].label);
8299       if (buttons[i].func)
8300         gtk_signal_connect (GTK_OBJECT (button),
8301                             "clicked",
8302                             GTK_SIGNAL_FUNC(buttons[i].func),
8303                             NULL);
8304       else
8305         gtk_widget_set_sensitive (button, FALSE);
8306       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
8307     }
8308
8309   separator = gtk_hseparator_new ();
8310   gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
8311
8312   box2 = gtk_vbox_new (FALSE, 10);
8313   gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
8314   gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
8315
8316   button = gtk_button_new_with_label ("close");
8317   gtk_signal_connect (GTK_OBJECT (button), "clicked",
8318                       GTK_SIGNAL_FUNC (do_exit),
8319                       window);
8320   gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
8321   GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8322   gtk_widget_grab_default (button);
8323
8324   gtk_widget_show_all (window);
8325 }
8326
8327 int
8328 main (int argc, char *argv[])
8329 {
8330   GtkBindingSet *binding_set;
8331
8332   srand (time (NULL));
8333
8334   gtk_set_locale ();
8335
8336   gtk_rc_add_default_file ("testgtkrc");
8337
8338   gtk_init (&argc, &argv);
8339
8340   gdk_rgb_init ();
8341
8342   /* bindings test
8343    */
8344   binding_set = gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_WIDGET));
8345   gtk_binding_entry_add_signal (binding_set,
8346                                 '9', GDK_CONTROL_MASK | GDK_RELEASE_MASK,
8347                                 "debug_msg",
8348                                 1,
8349                                 GTK_TYPE_STRING, "GtkWidgetClass <ctrl><release>9 test");
8350
8351   create_main_window ();
8352
8353   gtk_main ();
8354
8355   return 0;
8356 }