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