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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_container_add(GTK_CONTAINER(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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_freeze_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_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_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_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_border_width (GTK_CONTAINER(box1),3);
2454   gtk_container_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_border_width (GTK_CONTAINER (window), 0);
2509
2510
2511       scrolled_window = gtk_scrolled_window_new (NULL, NULL);
2512       gtk_container_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_container_add (GTK_CONTAINER (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_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_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_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_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_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_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_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_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_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_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_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_container_add (GTK_CONTAINER (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_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", "a", "inserted", "row.",
3729     "This", "is", "a", "inserted", "row.",
3730     "This", "is", "a", "inserted", "row.",
3731     "This", "is", "a", "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_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_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       /*clist = gtk_clist_new (TESTGTK_CLIST_COLUMNS);*/
3912
3913       gtk_signal_connect (GTK_OBJECT (clist), "click_column",
3914                           (GtkSignalFunc) clist_click_column, NULL);
3915
3916       /* control buttons */
3917       button = gtk_button_new_with_label ("Add 1,000 Rows With Pixmaps");
3918       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3919
3920       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3921                           (GtkSignalFunc) add1000_clist, (gpointer) clist);
3922
3923       button = gtk_button_new_with_label ("Add 10,000 Rows");
3924       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3925
3926       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3927                           (GtkSignalFunc) add10000_clist, (gpointer) clist);
3928
3929       button = gtk_button_new_with_label ("Clear List");
3930       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3931
3932       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3933                           (GtkSignalFunc) clear_clist, (gpointer) clist);
3934
3935       button = gtk_button_new_with_label ("Remove Row");
3936       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3937
3938       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3939                           (GtkSignalFunc) remove_row_clist, (gpointer) clist);
3940
3941       /* second layer of buttons */
3942       box2 = gtk_hbox_new (FALSE, 10);
3943       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3944       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
3945
3946       button = gtk_button_new_with_label ("Insert Row");
3947       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3948
3949       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3950                           (GtkSignalFunc) insert_row_clist, (gpointer) clist);
3951
3952       button = gtk_button_new_with_label ("Show Title Buttons");
3953       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3954
3955       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3956                           (GtkSignalFunc) show_titles_clist, (gpointer) clist);
3957
3958       button = gtk_button_new_with_label ("Hide Title Buttons");
3959       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3960
3961       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3962                           (GtkSignalFunc) hide_titles_clist, (gpointer) clist);
3963
3964       button = gtk_button_new_with_label ("Warning Test");
3965       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3966
3967       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3968                           (GtkSignalFunc) clist_warning_test,(gpointer) clist);
3969
3970       box2 = gtk_hbox_new (FALSE, 10);
3971       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3972       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
3973
3974       undo_button = gtk_button_new_with_label ("Undo last selection");
3975       gtk_box_pack_start (GTK_BOX (box2), undo_button, TRUE, TRUE, 0);
3976       gtk_signal_connect (GTK_OBJECT (undo_button), "clicked",
3977                           (GtkSignalFunc) undo_selection, (gpointer) clist);
3978
3979       label = gtk_label_new ("Selection Mode :");
3980       gtk_box_pack_start (GTK_BOX (box2), label, FALSE, TRUE, 0);
3981
3982       clist_omenu = build_option_menu (items, 4, 3, clist);
3983       gtk_box_pack_start (GTK_BOX (box2), clist_omenu, FALSE, TRUE, 0);
3984
3985       /* vbox for the list itself */
3986       box2 = gtk_vbox_new (FALSE, 10);
3987       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3988       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3989
3990       /*
3991        * the rest of the clist configuration
3992        */
3993
3994       /*
3995       gtk_signal_connect (GTK_OBJECT (clist),
3996                           "select_row",
3997                           (GtkSignalFunc) select_clist,
3998                           undo_button);
3999
4000       gtk_signal_connect (GTK_OBJECT (clist),
4001                           "unselect_row",
4002                           (GtkSignalFunc) unselect_clist,
4003                           undo_button);
4004       */
4005
4006       gtk_clist_set_row_height (GTK_CLIST (clist), 18);
4007       gtk_widget_set_usize (clist, -1, 300);
4008
4009       gtk_clist_set_column_width (GTK_CLIST (clist), 0, 100);
4010
4011       for (i = 1; i < TESTGTK_CLIST_COLUMNS; i++)
4012         gtk_clist_set_column_width (GTK_CLIST (clist), i, 80);
4013
4014       gtk_clist_set_column_auto_resize (GTK_CLIST (clist), 0, TRUE);
4015       gtk_clist_set_column_resizeable (GTK_CLIST (clist), 1, FALSE);
4016       gtk_clist_set_column_max_width (GTK_CLIST (clist), 2, 100);
4017       gtk_clist_set_column_min_width (GTK_CLIST (clist), 3, 50);
4018
4019       gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_EXTENDED);
4020
4021       gtk_clist_set_column_justification (GTK_CLIST (clist), 1,
4022                                           GTK_JUSTIFY_RIGHT);
4023       gtk_clist_set_column_justification (GTK_CLIST (clist), 2,
4024                                           GTK_JUSTIFY_CENTER);
4025
4026       for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
4027         {
4028           texts[i] = text[i];
4029           sprintf (text[i], "Column %d", i);
4030         }
4031
4032       sprintf (text[1], "Right");
4033       sprintf (text[2], "Center");
4034
4035       col1.red   = 56000;
4036       col1.green = 0;
4037       col1.blue  = 0;
4038       col2.red   = 0;
4039       col2.green = 56000;
4040       col2.blue  = 32000;
4041
4042       style = gtk_style_new ();
4043       style->fg[GTK_STATE_PRELIGHT] = col1;
4044       style->bg[GTK_STATE_PRELIGHT] = col2;
4045
4046       gdk_font_unref (style->font);
4047       style->font =
4048         gdk_font_load ("-adobe-helvetica-bold-r-*-*-*-140-*-*-*-*-*-*");
4049
4050       for (i = 0; i < 10; i++)
4051         {
4052           sprintf (text[0], "CListRow %d", clist_rows++);
4053           gtk_clist_append (GTK_CLIST (clist), texts);
4054
4055           switch (i % 4)
4056             {
4057             case 2:
4058               gtk_clist_set_row_style (GTK_CLIST (clist), i, style);
4059               break;
4060             default:
4061               gtk_clist_set_cell_style (GTK_CLIST (clist), i, i % 4, style);
4062               break;
4063             }
4064         }
4065
4066       gtk_container_border_width (GTK_CONTAINER (scrolled_win), 5);
4067       gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
4068
4069       separator = gtk_hseparator_new ();
4070       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4071
4072       box2 = gtk_vbox_new (FALSE, 10);
4073       gtk_container_border_width (GTK_CONTAINER (box2), 10);
4074       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4075
4076       button = gtk_button_new_with_label ("close");
4077       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4078                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
4079                                  GTK_OBJECT (window));
4080
4081       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4082       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4083       gtk_widget_grab_default (button);
4084     }
4085
4086   if (!GTK_WIDGET_VISIBLE (window))
4087     gtk_widget_show_all (window);
4088   else
4089     {
4090       clist_rows = 0;
4091       gtk_widget_destroy (window);
4092     }
4093 }
4094
4095 /*
4096  * GtkCTree
4097  */
4098
4099 GdkPixmap *pixmap1;
4100 GdkPixmap *pixmap2;
4101 GdkPixmap *pixmap3;
4102 GdkBitmap *mask1;
4103 GdkBitmap *mask2;
4104 GdkBitmap *mask3;
4105
4106 static gint books = 0;
4107 static gint pages = 0;
4108
4109 static GtkWidget *book_label;
4110 static GtkWidget *page_label;
4111 static GtkWidget *sel_label;
4112 static GtkWidget *vis_label;
4113 static GtkWidget *omenu1;
4114 static GtkWidget *omenu2;
4115 static GtkWidget *omenu3;
4116 static GtkWidget *omenu4;
4117 static GtkWidget *spin1;
4118 static GtkWidget *spin2;
4119 static GtkWidget *spin3;
4120 static gint line_style;
4121
4122 void after_press (GtkCTree *ctree, gpointer data)
4123 {
4124   char buf[80];
4125
4126   sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection));
4127   gtk_label_set (GTK_LABEL (sel_label), buf);
4128
4129   sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list));
4130   gtk_label_set (GTK_LABEL (vis_label), buf);
4131
4132   sprintf (buf, "%d", books);
4133   gtk_label_set (GTK_LABEL (book_label), buf);
4134
4135   sprintf (buf, "%d", pages);
4136   gtk_label_set (GTK_LABEL (page_label), buf);
4137 }
4138
4139 void after_move (GtkCTree *ctree, GtkCTreeNode *child, GtkCTreeNode *parent,
4140                  GtkCTreeNode *sibling, gpointer data)
4141 {
4142   char *source;
4143   char *target1;
4144   char *target2;
4145
4146   gtk_ctree_get_node_info (ctree, child, &source,
4147                            NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4148   if (parent)
4149     gtk_ctree_get_node_info (ctree, parent, &target1,
4150                              NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4151   if (sibling)
4152     gtk_ctree_get_node_info (ctree, sibling, &target2,
4153                              NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4154
4155   g_print ("Moving \"%s\" to \"%s\" with sibling \"%s\".\n", source,
4156            (parent) ? target1 : "nil", (sibling) ? target2 : "nil");
4157 }
4158
4159 gint button_press (GtkCTree *ctree, GdkEventButton *event, gpointer data)
4160 {
4161   gint row;
4162   gint column;
4163   GtkCTreeNode *work;
4164   gint res;
4165
4166   res = gtk_clist_get_selection_info (GTK_CLIST (ctree), event->x, event->y,
4167                                       &row, &column);
4168   if (!res && event->button != 3)
4169     return FALSE;
4170
4171   work = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list, row));
4172
4173   switch (event->button)
4174     {
4175     case 1:
4176       if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_MULTIPLE &&
4177           event->state & GDK_SHIFT_MASK)
4178         gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),"button_press_event");
4179       break;
4180     case  2:
4181       if (GTK_CTREE_ROW (work)->children &&
4182           gtk_ctree_is_hot_spot (ctree, event->x, event->y))
4183         {
4184           if (GTK_CTREE_ROW (work)->expanded)
4185             gtk_ctree_collapse_recursive (ctree, work);
4186           else
4187             gtk_ctree_expand_recursive (ctree, work);
4188           after_press (ctree, NULL);
4189           gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),
4190                                         "button_press_event");
4191         }
4192       break;
4193     default:
4194       break;
4195     }
4196   return FALSE;
4197 }
4198
4199 gint button_release (GtkCTree *ctree, GdkEventButton *event, gpointer data)
4200 {
4201   gint row;
4202   gint column;
4203   GtkCTreeNode *work;
4204   gint res;
4205
4206   res = gtk_clist_get_selection_info (GTK_CLIST (ctree), event->x, event->y,
4207                                       &row, &column);
4208   if (!res || event->button != 1)
4209     return FALSE;
4210
4211   work = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list, row));
4212
4213   if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_MULTIPLE &&
4214       event->state & GDK_SHIFT_MASK)
4215     {
4216       if (GTK_CTREE_ROW (work)->row.state == GTK_STATE_SELECTED)
4217             gtk_ctree_unselect_recursive (ctree, work);
4218       else
4219         gtk_ctree_select_recursive (ctree, work);
4220       after_press (ctree, NULL);
4221       gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),
4222                                     "button_release_event");
4223     }
4224   return FALSE;
4225 }
4226
4227 void count_items (GtkCTree *ctree, GtkCTreeNode *list)
4228 {
4229   if (GTK_CTREE_ROW (list)->is_leaf)
4230     pages--;
4231   else
4232     books--;
4233 }
4234
4235 void expand_all (GtkWidget *widget, GtkCTree *ctree)
4236 {
4237   gtk_ctree_expand_recursive (ctree, NULL);
4238   after_press (ctree, NULL);
4239 }
4240
4241 void collapse_all (GtkWidget *widget, GtkCTree *ctree)
4242 {
4243   gtk_ctree_collapse_recursive (ctree, NULL);
4244   after_press (ctree, NULL);
4245 }
4246
4247 void select_all (GtkWidget *widget, GtkCTree *ctree)
4248 {
4249   gtk_ctree_select_recursive (ctree, NULL);
4250   after_press (ctree, NULL);
4251 }
4252
4253 void change_style (GtkWidget *widget, GtkCTree *ctree)
4254 {
4255   static GtkStyle *style1 = NULL;
4256   static GtkStyle *style2 = NULL;
4257
4258   GtkCTreeNode *node;
4259   GdkColor col1;
4260   GdkColor col2;
4261
4262   if (GTK_CLIST (ctree)->focus_row >= 0)
4263     node = GTK_CTREE_NODE
4264       (g_list_nth (GTK_CLIST (ctree)->row_list,GTK_CLIST (ctree)->focus_row));
4265   else
4266     node = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list);
4267
4268   if (!node)
4269     return;
4270
4271   if (!style1)
4272     {
4273       col1.red   = 0;
4274       col1.green = 56000;
4275       col1.blue  = 0;
4276       col2.red   = 32000;
4277       col2.green = 0;
4278       col2.blue  = 56000;
4279
4280       style1 = gtk_style_new ();
4281       style1->bg[GTK_STATE_PRELIGHT] = col1;
4282       style1->fg[GTK_STATE_SELECTED] = col2;
4283
4284       style2 = gtk_style_new ();
4285       style2->bg[GTK_STATE_SELECTED] = col2;
4286       style2->fg[GTK_STATE_PRELIGHT] = col1;
4287       style2->bg[GTK_STATE_PRELIGHT] = col2;
4288       gdk_font_unref (style2->font);
4289       style2->font =
4290         gdk_font_load ("-*-courier-medium-*-*-*-*-300-*-*-*-*-*-*");
4291     }
4292
4293   gtk_ctree_node_set_cell_style (ctree, node, 1, style1);
4294   gtk_ctree_node_set_cell_style (ctree, node, 0, style2);
4295
4296   if (GTK_CTREE_ROW (node)->children)
4297     gtk_ctree_node_set_row_style (ctree, GTK_CTREE_ROW (node)->children,
4298                                   style2);
4299
4300 }
4301
4302 void unselect_all (GtkWidget *widget, GtkCTree *ctree)
4303 {
4304   gtk_ctree_unselect_recursive (ctree, NULL);
4305   after_press (ctree, NULL);
4306 }
4307
4308 void remove_selection (GtkWidget *widget, GtkCTree *ctree)
4309 {
4310   GtkCTreeNode *work;
4311   GtkCTreeNode *new_sel;
4312   GList *selection;
4313
4314   selection = GTK_CLIST (ctree)->selection;
4315   new_sel = NULL;
4316
4317   gtk_clist_freeze (GTK_CLIST (ctree));
4318
4319   while (selection)
4320     {
4321       work = selection->data;
4322       if (GTK_CTREE_ROW (work)->is_leaf)
4323         pages--;
4324       else
4325         gtk_ctree_post_recursive (ctree, work,
4326                                   (GtkCTreeFunc) count_items, NULL);
4327
4328       if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_BROWSE)
4329         {
4330           if (GTK_CTREE_ROW (work)->children)
4331             {
4332               new_sel = GTK_CTREE_ROW (work)->sibling;
4333               if (!new_sel)
4334                 new_sel = GTK_CTREE_NODE_NEXT (work);
4335             }
4336           else
4337             {
4338               if (GTK_CTREE_NODE_NEXT (work))
4339                 new_sel = GTK_CTREE_NODE_NEXT (work);
4340               else
4341                 new_sel = GTK_CTREE_NODE_PREV (work);
4342             }
4343         }
4344
4345       gtk_ctree_remove_node (ctree, work);
4346       selection = GTK_CLIST (ctree)->selection;
4347     }
4348
4349   if (new_sel)
4350     gtk_ctree_select (ctree, new_sel);
4351
4352   gtk_clist_thaw (GTK_CLIST (ctree));
4353   after_press (ctree, NULL);
4354 }
4355
4356 struct _ExportStruct {
4357   gchar *tree;
4358   gchar *info;
4359   gboolean is_leaf;
4360 };
4361
4362 typedef struct _ExportStruct ExportStruct;
4363
4364 gboolean
4365 gnode2ctree (GtkCTree   *ctree,
4366              guint       depth,
4367              GNode        *gnode,
4368              GtkCTreeNode *cnode,
4369              gpointer    data)
4370 {
4371   ExportStruct *es;
4372   GdkPixmap *pixmap_closed;
4373   GdkBitmap *mask_closed;
4374   GdkPixmap *pixmap_opened;
4375   GdkBitmap *mask_opened;
4376
4377   if (!cnode || !gnode || (!(es = gnode->data)))
4378     return FALSE;
4379
4380   if (es->is_leaf)
4381     {
4382       pixmap_closed = pixmap3;
4383       mask_closed = mask3;
4384       pixmap_opened = NULL;
4385       mask_opened = NULL;
4386     }
4387   else
4388     {
4389       pixmap_closed = pixmap1;
4390       mask_closed = mask1;
4391       pixmap_opened = pixmap2;
4392       mask_opened = mask2;
4393     }
4394
4395   gtk_ctree_set_node_info (ctree, cnode, es->tree, 2, pixmap_closed,
4396                            mask_closed, pixmap_opened, mask_opened,
4397                            es->is_leaf, (depth < 3));
4398   gtk_ctree_node_set_text (ctree, cnode, 1, es->info);
4399   g_free (es);
4400   gnode->data = NULL;
4401
4402   return TRUE;
4403 }
4404
4405 gboolean
4406 ctree2gnode (GtkCTree   *ctree,
4407              guint       depth,
4408              GNode        *gnode,
4409              GtkCTreeNode *cnode,
4410              gpointer    data)
4411 {
4412   ExportStruct *es;
4413
4414   if (!cnode || !gnode)
4415     return FALSE;
4416
4417   es = g_new (ExportStruct, 1);
4418   gnode->data = es;
4419   es->is_leaf = GTK_CTREE_ROW (cnode)->is_leaf;
4420   es->tree = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[0])->text;
4421   es->info = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[1])->text;
4422   return TRUE;
4423 }
4424
4425 void export_ctree (GtkWidget *widget, GtkCTree *ctree)
4426 {
4427   char *title[] = { "Tree" , "Info" };
4428   static GtkWidget *export_window = NULL;
4429   static GtkCTree *export_ctree;
4430   GtkWidget *vbox;
4431   GtkWidget *scrolled_win;
4432   GtkWidget *button;
4433   GtkWidget *sep;
4434   GNode *gnode;
4435   GtkCTreeNode *node;
4436
4437   if (!export_window)
4438     {
4439       export_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4440
4441       gtk_signal_connect (GTK_OBJECT (export_window), "destroy",
4442                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
4443                           &export_window);
4444
4445       gtk_window_set_title (GTK_WINDOW (export_window), "exported ctree");
4446       gtk_container_border_width (GTK_CONTAINER (export_window), 5);
4447
4448       vbox = gtk_vbox_new (FALSE, 0);
4449       gtk_container_add (GTK_CONTAINER (export_window), vbox);
4450
4451       button = gtk_button_new_with_label ("Close");
4452       gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, TRUE, 0);
4453
4454       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4455                                  (GtkSignalFunc) gtk_widget_destroy,
4456                                  GTK_OBJECT(export_window));
4457
4458       sep = gtk_hseparator_new ();
4459       gtk_box_pack_end (GTK_BOX (vbox), sep, FALSE, TRUE, 10);
4460
4461       export_ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title));
4462       gtk_ctree_set_line_style (export_ctree, GTK_CTREE_LINES_DOTTED);
4463
4464       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
4465       gtk_container_add (GTK_CONTAINER (scrolled_win),
4466                          GTK_WIDGET (export_ctree));
4467       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
4468                                       GTK_POLICY_AUTOMATIC,
4469                                       GTK_POLICY_AUTOMATIC);
4470       gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
4471       gtk_clist_set_selection_mode (GTK_CLIST (export_ctree),
4472                                     GTK_SELECTION_EXTENDED);
4473       gtk_clist_set_column_width (GTK_CLIST (export_ctree), 0, 200);
4474       gtk_clist_set_column_width (GTK_CLIST (export_ctree), 1, 200);
4475       gtk_widget_set_usize (GTK_WIDGET (export_ctree), 300, 200);
4476     }
4477
4478   if (!GTK_WIDGET_VISIBLE (export_window))
4479     gtk_widget_show_all (export_window);
4480
4481   gtk_clist_clear (GTK_CLIST (export_ctree));
4482
4483   node = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list,
4484                                      GTK_CLIST (ctree)->focus_row));
4485   if (!node)
4486     return;
4487
4488   gnode = gtk_ctree_export_to_gnode (ctree, NULL, NULL, node,
4489                                      ctree2gnode, NULL);
4490   if (gnode)
4491     {
4492       gtk_ctree_insert_gnode (export_ctree, NULL, NULL, gnode,
4493                               gnode2ctree, NULL);
4494       g_node_destroy (gnode);
4495     }
4496 }
4497
4498 void change_indent (GtkWidget *widget, GtkCTree *ctree)
4499 {
4500   gtk_ctree_set_indent (ctree, GTK_ADJUSTMENT (widget)->value);
4501 }
4502
4503 void change_spacing (GtkWidget *widget, GtkCTree *ctree)
4504 {
4505   gtk_ctree_set_spacing (ctree, GTK_ADJUSTMENT (widget)->value);
4506 }
4507
4508 void change_row_height (GtkWidget *widget, GtkCList *clist)
4509 {
4510   gtk_clist_set_row_height (clist, GTK_ADJUSTMENT (widget)->value);
4511 }
4512
4513 void toggle_reorderable (GtkWidget *widget, GtkCTree *ctree)
4514 {
4515   gtk_ctree_set_reorderable (ctree, GTK_TOGGLE_BUTTON (widget)->active);
4516 }
4517
4518 void set_background (GtkCTree *ctree, GtkCTreeNode *node, gpointer data)
4519 {
4520   GtkStyle *style = NULL;
4521
4522   if (!node)
4523     return;
4524
4525   if (ctree->line_style != GTK_CTREE_LINES_TABBED)
4526     {
4527       if (!GTK_CTREE_ROW (node)->is_leaf)
4528         style = GTK_CTREE_ROW (node)->row.data;
4529       else if (GTK_CTREE_ROW (node)->parent)
4530         style = GTK_CTREE_ROW (GTK_CTREE_ROW (node)->parent)->row.data;
4531     }
4532
4533   gtk_ctree_node_set_row_style (ctree, node, style);
4534 }
4535
4536 void ctree_toggle_line_style (GtkWidget *widget, GtkCTree *ctree)
4537 {
4538   gint i;
4539
4540   if (!GTK_WIDGET_MAPPED (widget))
4541     return;
4542
4543   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4544                     (((GtkOptionMenu *)omenu1)->menu_item), i);
4545
4546   if ((ctree->line_style == GTK_CTREE_LINES_TABBED &&
4547        ((GtkCTreeLineStyle) (3 - i)) != GTK_CTREE_LINES_TABBED) ||
4548       (ctree->line_style != GTK_CTREE_LINES_TABBED &&
4549        ((GtkCTreeLineStyle) (3 - i)) == GTK_CTREE_LINES_TABBED))
4550     gtk_ctree_pre_recursive (ctree, NULL, set_background, NULL);
4551   gtk_ctree_set_line_style (ctree, 3 - i);
4552   line_style = 3 - i;
4553 }
4554
4555 void ctree_toggle_expander_style (GtkWidget *widget, GtkCTree *ctree)
4556 {
4557   gint i;
4558
4559   if (!GTK_WIDGET_MAPPED (widget))
4560     return;
4561
4562   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4563                     (((GtkOptionMenu *)omenu2)->menu_item), i);
4564
4565   gtk_ctree_set_expander_style (ctree, (GtkCTreeExpanderStyle) (3 - i));
4566 }
4567
4568 void ctree_toggle_justify (GtkWidget *widget, GtkCTree *ctree)
4569 {
4570   gint i;
4571
4572   if (!GTK_WIDGET_MAPPED (widget))
4573     return;
4574
4575   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4576                     (((GtkOptionMenu *)omenu3)->menu_item), i);
4577
4578   gtk_clist_set_column_justification (GTK_CLIST (ctree), ctree->tree_column,
4579                                       (GtkJustification) (1 - i));
4580 }
4581
4582 void ctree_toggle_sel_mode (GtkWidget *widget, GtkCTree *ctree)
4583 {
4584   gint i;
4585
4586   if (!GTK_WIDGET_MAPPED (widget))
4587     return;
4588
4589   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4590                     (((GtkOptionMenu *)omenu4)->menu_item), i);
4591
4592   gtk_clist_set_selection_mode (GTK_CLIST (ctree), (GtkSelectionMode) (3 - i));
4593   after_press (ctree, NULL);
4594 }
4595
4596 void build_recursive (GtkCTree *ctree, gint cur_depth, gint depth,
4597                       gint num_books, gint num_pages, GtkCTreeNode *parent)
4598 {
4599   gchar *text[2];
4600   gchar buf1[60];
4601   gchar buf2[60];
4602   GtkCTreeNode *sibling;
4603   gint i;
4604
4605   text[0] = buf1;
4606   text[1] = buf2;
4607   sibling = NULL;
4608
4609   for (i = num_pages + num_books; i > num_books; i--)
4610     {
4611       pages++;
4612       sprintf (buf1, "Page %02d", (gint) rand() % 100);
4613       sprintf (buf2, "Item %d-%d", cur_depth, i);
4614       sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
4615                                        pixmap3, mask3, NULL, NULL,
4616                                        TRUE, FALSE);
4617
4618       if (parent && ctree->line_style == GTK_CTREE_LINES_TABBED)
4619         gtk_ctree_node_set_row_style (ctree, sibling,
4620                                       GTK_CTREE_ROW (parent)->row.style);
4621     }
4622
4623   if (cur_depth == depth)
4624     return;
4625
4626   for (i = num_books; i > 0; i--)
4627     {
4628       GtkStyle *style;
4629
4630       books++;
4631       sprintf (buf1, "Book %02d", (gint) rand() % 100);
4632       sprintf (buf2, "Item %d-%d", cur_depth, i);
4633       sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
4634                                        pixmap1, mask1, pixmap2, mask2,
4635                                        FALSE, FALSE);
4636
4637       style = gtk_style_new();
4638       switch (cur_depth % 3)
4639         {
4640         case 0:
4641           style->bg[GTK_STATE_PRELIGHT].red   = 10000 * (cur_depth % 6);
4642           style->bg[GTK_STATE_PRELIGHT].green = 0;
4643           style->bg[GTK_STATE_PRELIGHT].blue  = 65535 - ((i * 10000) % 65535);
4644           break;
4645         case 1:
4646           style->bg[GTK_STATE_PRELIGHT].red   = 10000 * (cur_depth % 6);
4647           style->bg[GTK_STATE_PRELIGHT].green = 65535 - ((i * 10000) % 65535);
4648           style->bg[GTK_STATE_PRELIGHT].blue  = 0;
4649           break;
4650         default:
4651           style->bg[GTK_STATE_PRELIGHT].red   = 65535 - ((i * 10000) % 65535);
4652           style->bg[GTK_STATE_PRELIGHT].green = 0;
4653           style->bg[GTK_STATE_PRELIGHT].blue  = 10000 * (cur_depth % 6);
4654           break;
4655         }
4656       gtk_ctree_node_set_row_data_full (ctree, sibling, style,
4657                                         (GtkDestroyNotify) gtk_style_unref);
4658
4659       if (ctree->line_style == GTK_CTREE_LINES_TABBED)
4660         gtk_ctree_node_set_row_style (ctree, sibling, style);
4661
4662       build_recursive (ctree, cur_depth + 1, depth, num_books, num_pages,
4663                        sibling);
4664     }
4665 }
4666
4667 void rebuild_tree (GtkWidget *widget, GtkCTree *ctree)
4668 {
4669   gchar *text [2];
4670   gchar label1[] = "Root";
4671   gchar label2[] = "";
4672   GtkCTreeNode *parent;
4673   GtkStyle *style;
4674   guint b, d, p, n;
4675
4676   text[0] = label1;
4677   text[1] = label2;
4678
4679   d = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin1));
4680   b = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin2));
4681   p = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin3));
4682
4683   n = ((pow (b, d) - 1) / (b - 1)) * (p + 1);
4684
4685   if (n > 100000)
4686     {
4687       g_print ("%d total items? Try less\n",n);
4688       return;
4689     }
4690
4691   gtk_clist_freeze (GTK_CLIST (ctree));
4692   gtk_clist_clear (GTK_CLIST (ctree));
4693
4694   books = 1;
4695   pages = 0;
4696
4697   parent = gtk_ctree_insert_node (ctree, NULL, NULL, text, 5, pixmap1,
4698                                   mask1, pixmap2, mask2, FALSE, TRUE);
4699
4700   style = gtk_style_new ();
4701   style->bg[GTK_STATE_PRELIGHT].red   = 0;
4702   style->bg[GTK_STATE_PRELIGHT].green = 45000;
4703   style->bg[GTK_STATE_PRELIGHT].blue  = 55000;
4704   gtk_ctree_node_set_row_data_full (ctree, parent, style,
4705                                     (GtkDestroyNotify) gtk_style_unref);
4706
4707   if (ctree->line_style == GTK_CTREE_LINES_TABBED)
4708     gtk_ctree_node_set_row_style (ctree, parent, style);
4709
4710   build_recursive (ctree, 1, d, b, p, parent);
4711   gtk_clist_thaw (GTK_CLIST (ctree));
4712   after_press (ctree, NULL);
4713 }
4714
4715 static void
4716 ctree_click_column (GtkCTree *ctree, gint column, gpointer data)
4717 {
4718   GtkCList *clist;
4719
4720   clist = GTK_CLIST (ctree);
4721
4722   if (column == clist->sort_column)
4723     {
4724       if (clist->sort_type == GTK_SORT_ASCENDING)
4725         clist->sort_type = GTK_SORT_DESCENDING;
4726       else
4727         clist->sort_type = GTK_SORT_ASCENDING;
4728     }
4729   else
4730     gtk_clist_set_sort_column (clist, column);
4731
4732   gtk_ctree_sort_recursive (ctree, NULL);
4733 }
4734
4735 void create_ctree (void)
4736 {
4737   static GtkWidget *window = NULL;
4738   GtkTooltips *tooltips;
4739   GtkCTree *ctree;
4740   GtkWidget *scrolled_win;
4741   GtkWidget *vbox;
4742   GtkWidget *bbox;
4743   GtkWidget *mbox;
4744   GtkWidget *hbox;
4745   GtkWidget *hbox2;
4746   GtkWidget *frame;
4747   GtkWidget *label;
4748   GtkWidget *button;
4749   GtkWidget *check;
4750   GtkAdjustment *adj;
4751   GtkWidget *spinner;
4752   GdkColor transparent;
4753
4754   char *title[] = { "Tree" , "Info" };
4755   char buf[80];
4756
4757   static OptionMenuItem items1[] =
4758   {
4759     { "No lines", ctree_toggle_line_style },
4760     { "Solid",    ctree_toggle_line_style },
4761     { "Dotted",   ctree_toggle_line_style },
4762     { "Tabbed",   ctree_toggle_line_style }
4763   };
4764
4765   static OptionMenuItem items2[] =
4766   {
4767     { "None",     ctree_toggle_expander_style },
4768     { "Square",   ctree_toggle_expander_style },
4769     { "Triangle", ctree_toggle_expander_style },
4770     { "Circular", ctree_toggle_expander_style }
4771   };
4772
4773   static OptionMenuItem items3[] =
4774   {
4775     { "Left",  ctree_toggle_justify },
4776     { "Right", ctree_toggle_justify }
4777   };
4778
4779   static OptionMenuItem items4[] =
4780   {
4781     { "Single",   ctree_toggle_sel_mode },
4782     { "Browse",   ctree_toggle_sel_mode },
4783     { "Multiple", ctree_toggle_sel_mode },
4784     { "Extended", ctree_toggle_sel_mode }
4785   };
4786
4787   if (!window)
4788     {
4789       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4790
4791       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4792                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
4793                           &window);
4794
4795       gtk_window_set_title (GTK_WINDOW (window), "GtkCTree");
4796       gtk_container_border_width (GTK_CONTAINER (window), 0);
4797
4798       tooltips = gtk_tooltips_new ();
4799       gtk_object_ref (GTK_OBJECT (tooltips));
4800       gtk_object_sink (GTK_OBJECT (tooltips));
4801
4802       gtk_object_set_data_full (GTK_OBJECT (window), "tooltips", tooltips,
4803                                 (GtkDestroyNotify) gtk_object_unref);
4804
4805       vbox = gtk_vbox_new (FALSE, 0);
4806       gtk_container_add (GTK_CONTAINER (window), vbox);
4807
4808       hbox = gtk_hbox_new (FALSE, 5);
4809       gtk_container_border_width (GTK_CONTAINER (hbox), 5);
4810       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4811
4812       label = gtk_label_new ("Depth :");
4813       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4814
4815       adj = (GtkAdjustment *) gtk_adjustment_new (4, 1, 10, 1, 5, 0);
4816       spin1 = gtk_spin_button_new (adj, 0, 0);
4817       gtk_box_pack_start (GTK_BOX (hbox), spin1, FALSE, TRUE, 5);
4818
4819       label = gtk_label_new ("Books :");
4820       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4821
4822       adj = (GtkAdjustment *) gtk_adjustment_new (3, 1, 20, 1, 5, 0);
4823       spin2 = gtk_spin_button_new (adj, 0, 0);
4824       gtk_box_pack_start (GTK_BOX (hbox), spin2, FALSE, TRUE, 5);
4825
4826       label = gtk_label_new ("Pages :");
4827       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4828
4829       adj = (GtkAdjustment *) gtk_adjustment_new (5, 1, 20, 1, 5, 0);
4830       spin3 = gtk_spin_button_new (adj, 0, 0);
4831       gtk_box_pack_start (GTK_BOX (hbox), spin3, FALSE, TRUE, 5);
4832
4833       button = gtk_button_new_with_label ("Close");
4834       gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4835
4836       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4837                                  (GtkSignalFunc) gtk_widget_destroy,
4838                                  GTK_OBJECT(window));
4839
4840       button = gtk_button_new_with_label ("Rebuild tree");
4841       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4842
4843       ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title));
4844       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4845                           GTK_SIGNAL_FUNC (rebuild_tree), ctree);
4846
4847       gtk_ctree_set_line_style (ctree, GTK_CTREE_LINES_DOTTED);
4848       line_style = GTK_CTREE_LINES_DOTTED;
4849
4850       gtk_ctree_set_reorderable (ctree, TRUE);
4851       gtk_signal_connect (GTK_OBJECT (ctree), "click_column",
4852                           (GtkSignalFunc) ctree_click_column,
4853                           NULL);
4854       gtk_signal_connect (GTK_OBJECT (ctree), "button_press_event",
4855                           GTK_SIGNAL_FUNC (button_press), NULL);
4856       gtk_signal_connect_after (GTK_OBJECT (ctree), "button_press_event",
4857                                 GTK_SIGNAL_FUNC (after_press), NULL);
4858       gtk_signal_connect (GTK_OBJECT (ctree), "button_release_event",
4859                           GTK_SIGNAL_FUNC (button_release), NULL);
4860       gtk_signal_connect_after (GTK_OBJECT (ctree), "button_release_event",
4861                                 GTK_SIGNAL_FUNC (after_press), NULL);
4862       gtk_signal_connect_after (GTK_OBJECT (ctree), "tree_move",
4863                                 GTK_SIGNAL_FUNC (after_move), NULL);
4864       gtk_signal_connect_after (GTK_OBJECT (ctree), "end_selection",
4865                                 GTK_SIGNAL_FUNC (after_press), NULL);
4866       gtk_signal_connect_after (GTK_OBJECT (ctree), "toggle_focus_row",
4867                                 GTK_SIGNAL_FUNC (after_press), NULL);
4868       gtk_signal_connect_after (GTK_OBJECT (ctree), "select_all",
4869                                 GTK_SIGNAL_FUNC (after_press), NULL);
4870       gtk_signal_connect_after (GTK_OBJECT (ctree), "unselect_all",
4871                                 GTK_SIGNAL_FUNC (after_press), NULL);
4872       gtk_signal_connect_after (GTK_OBJECT (ctree), "scroll_vertical",
4873                                 GTK_SIGNAL_FUNC (after_press), NULL);
4874
4875       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
4876       gtk_container_add (GTK_CONTAINER (scrolled_win), GTK_WIDGET (ctree));
4877       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
4878                                       GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
4879       gtk_container_border_width (GTK_CONTAINER (scrolled_win), 5);
4880       gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
4881       gtk_clist_set_selection_mode (GTK_CLIST (ctree), GTK_SELECTION_EXTENDED);
4882       gtk_clist_set_column_min_width (GTK_CLIST (ctree), 0, 50);
4883       gtk_clist_set_column_auto_resize (GTK_CLIST (ctree), 0, TRUE);
4884       gtk_clist_set_column_width (GTK_CLIST (ctree), 1, 200);
4885
4886       bbox = gtk_hbox_new (FALSE, 5);
4887       gtk_container_border_width (GTK_CONTAINER (bbox), 5);
4888       gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, TRUE, 0);
4889
4890       mbox = gtk_vbox_new (TRUE, 5);
4891       gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
4892
4893       label = gtk_label_new ("Row height :");
4894       gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
4895
4896       label = gtk_label_new ("Indent :");
4897       gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
4898
4899       label = gtk_label_new ("Spacing :");
4900       gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
4901
4902       mbox = gtk_vbox_new (TRUE, 5);
4903       gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
4904
4905       adj = (GtkAdjustment *) gtk_adjustment_new (20, 12, 100, 1, 10, 0);
4906       spinner = gtk_spin_button_new (adj, 0, 0);
4907       gtk_tooltips_set_tip (tooltips, spinner,
4908                             "Row height of list items", NULL);
4909       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
4910                           GTK_SIGNAL_FUNC (change_row_height), ctree);
4911       gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
4912       gtk_clist_set_row_height ( GTK_CLIST (ctree), adj->value);
4913
4914       adj = (GtkAdjustment *) gtk_adjustment_new (20, 0, 60, 1, 10, 0);
4915       spinner = gtk_spin_button_new (adj, 0, 0);
4916       gtk_tooltips_set_tip (tooltips, spinner, "Tree indentation.", NULL);
4917       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
4918                           GTK_SIGNAL_FUNC (change_indent), ctree);
4919       gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
4920
4921       adj = (GtkAdjustment *) gtk_adjustment_new (5, 0, 60, 1, 10, 0);
4922       spinner = gtk_spin_button_new (adj, 0, 0);
4923       gtk_tooltips_set_tip (tooltips, spinner, "Tree spacing.", NULL);
4924       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
4925                           GTK_SIGNAL_FUNC (change_spacing), ctree);
4926       gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
4927
4928       mbox = gtk_vbox_new (TRUE, 5);
4929       gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
4930
4931       hbox = gtk_hbox_new (FALSE, 5);
4932       gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
4933
4934       button = gtk_button_new_with_label ("Expand all");
4935       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4936                           GTK_SIGNAL_FUNC (expand_all), ctree);
4937       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4938
4939       button = gtk_button_new_with_label ("Collapse all");
4940       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4941                           GTK_SIGNAL_FUNC (collapse_all), ctree);
4942       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4943
4944       button = gtk_button_new_with_label ("Change Style");
4945       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4946                           GTK_SIGNAL_FUNC (change_style), ctree);
4947       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4948
4949       button = gtk_button_new_with_label ("Export tree");
4950       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4951                           GTK_SIGNAL_FUNC (export_ctree), ctree);
4952       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4953
4954       hbox = gtk_hbox_new (FALSE, 5);
4955       gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
4956
4957       button = gtk_button_new_with_label ("Select all");
4958       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4959                           GTK_SIGNAL_FUNC (select_all), ctree);
4960       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4961
4962       button = gtk_button_new_with_label ("Unselect all");
4963       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4964                           GTK_SIGNAL_FUNC (unselect_all), ctree);
4965       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4966
4967       button = gtk_button_new_with_label ("Remove selection");
4968       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4969                           GTK_SIGNAL_FUNC (remove_selection), ctree);
4970       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4971
4972       check = gtk_check_button_new_with_label ("Reorderable");
4973       gtk_tooltips_set_tip (tooltips, check,
4974                             "Tree items can be reordered by dragging.", NULL);
4975       gtk_signal_connect (GTK_OBJECT (check), "clicked",
4976                           GTK_SIGNAL_FUNC (toggle_reorderable), ctree);
4977       gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
4978       gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (check), TRUE);
4979
4980       hbox = gtk_hbox_new (TRUE, 5);
4981       gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
4982
4983       omenu1 = build_option_menu (items1, 4, 2, ctree);
4984       gtk_tooltips_set_tip (tooltips, omenu1, "The tree's line style.", NULL);
4985       gtk_box_pack_start (GTK_BOX (hbox), omenu1, FALSE, TRUE, 0);
4986
4987       omenu2 = build_option_menu (items2, 4, 1, ctree);
4988       gtk_tooltips_set_tip (tooltips, omenu2, "The tree's expander style.",
4989                             NULL);
4990       gtk_box_pack_start (GTK_BOX (hbox), omenu2, FALSE, TRUE, 0);
4991
4992       omenu3 = build_option_menu (items3, 2, 0, ctree);
4993       gtk_tooltips_set_tip (tooltips, omenu3, "The tree's justification.",
4994                             NULL);
4995       gtk_box_pack_start (GTK_BOX (hbox), omenu3, FALSE, TRUE, 0);
4996
4997       omenu4 = build_option_menu (items4, 4, 3, ctree);
4998       gtk_tooltips_set_tip (tooltips, omenu4, "The list's selection mode.",
4999                             NULL);
5000       gtk_box_pack_start (GTK_BOX (hbox), omenu4, FALSE, TRUE, 0);
5001
5002       gtk_widget_realize (window);
5003
5004       pixmap1 = gdk_pixmap_create_from_xpm_d (window->window, &mask1,
5005                                               &transparent, book_closed_xpm);
5006       pixmap2 = gdk_pixmap_create_from_xpm_d (window->window, &mask2,
5007                                               &transparent, book_open_xpm);
5008       pixmap3 = gdk_pixmap_create_from_xpm_d (window->window, &mask3,
5009                                               &transparent, mini_page_xpm);
5010
5011       gtk_widget_set_usize (GTK_WIDGET (ctree), 0, 300);
5012
5013       frame = gtk_frame_new (NULL);
5014       gtk_container_border_width (GTK_CONTAINER (frame), 0);
5015       gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
5016       gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
5017
5018       hbox = gtk_hbox_new (TRUE, 2);
5019       gtk_container_border_width (GTK_CONTAINER (hbox), 2);
5020       gtk_container_add (GTK_CONTAINER (frame), hbox);
5021
5022       frame = gtk_frame_new (NULL);
5023       gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
5024       gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
5025
5026       hbox2 = gtk_hbox_new (FALSE, 0);
5027       gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
5028       gtk_container_add (GTK_CONTAINER (frame), hbox2);
5029
5030       label = gtk_label_new ("Books :");
5031       gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
5032
5033       sprintf (buf, "%d", books);
5034       book_label = gtk_label_new (buf);
5035       gtk_box_pack_end (GTK_BOX (hbox2), book_label, FALSE, TRUE, 5);
5036
5037       frame = gtk_frame_new (NULL);
5038       gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
5039       gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
5040
5041       hbox2 = gtk_hbox_new (FALSE, 0);
5042       gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
5043       gtk_container_add (GTK_CONTAINER (frame), hbox2);
5044
5045       label = gtk_label_new ("Pages :");
5046       gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
5047
5048       sprintf (buf, "%d", pages);
5049       page_label = gtk_label_new (buf);
5050       gtk_box_pack_end (GTK_BOX (hbox2), page_label, FALSE, TRUE, 5);
5051
5052       frame = gtk_frame_new (NULL);
5053       gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
5054       gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
5055
5056       hbox2 = gtk_hbox_new (FALSE, 0);
5057       gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
5058       gtk_container_add (GTK_CONTAINER (frame), hbox2);
5059
5060       label = gtk_label_new ("Selected :");
5061       gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
5062
5063       sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection));
5064       sel_label = gtk_label_new (buf);
5065       gtk_box_pack_end (GTK_BOX (hbox2), sel_label, FALSE, TRUE, 5);
5066
5067       frame = gtk_frame_new (NULL);
5068       gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
5069       gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
5070
5071       hbox2 = gtk_hbox_new (FALSE, 0);
5072       gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
5073       gtk_container_add (GTK_CONTAINER (frame), hbox2);
5074
5075       label = gtk_label_new ("Visible :");
5076       gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
5077
5078       sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list));
5079       vis_label = gtk_label_new (buf);
5080       gtk_box_pack_end (GTK_BOX (hbox2), vis_label, FALSE, TRUE, 5);
5081
5082       rebuild_tree (NULL, ctree);
5083     }
5084
5085   if (!GTK_WIDGET_VISIBLE (window))
5086     gtk_widget_show_all (window);
5087   else
5088     gtk_widget_destroy (window);
5089 }
5090
5091 /*
5092  * GtkColorSelection
5093  */
5094
5095 void
5096 color_selection_ok (GtkWidget               *w,
5097                     GtkColorSelectionDialog *cs)
5098 {
5099   GtkColorSelection *colorsel;
5100   gdouble color[4];
5101
5102   colorsel=GTK_COLOR_SELECTION(cs->colorsel);
5103
5104   gtk_color_selection_get_color(colorsel,color);
5105   gtk_color_selection_set_color(colorsel,color);
5106 }
5107
5108 void
5109 color_selection_changed (GtkWidget *w,
5110                          GtkColorSelectionDialog *cs)
5111 {
5112   GtkColorSelection *colorsel;
5113   gdouble color[4];
5114
5115   colorsel=GTK_COLOR_SELECTION(cs->colorsel);
5116   gtk_color_selection_get_color(colorsel,color);
5117 }
5118
5119 void
5120 create_color_selection (void)
5121 {
5122   static GtkWidget *window = NULL;
5123
5124   if (!window)
5125     {
5126       window = gtk_color_selection_dialog_new ("color selection dialog");
5127
5128       gtk_color_selection_set_opacity (
5129         GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
5130         TRUE);
5131
5132       gtk_color_selection_set_update_policy(
5133         GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
5134         GTK_UPDATE_CONTINUOUS);
5135
5136       gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
5137
5138       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5139                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5140                           &window);
5141
5142       gtk_signal_connect (
5143         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
5144         "color_changed",
5145         GTK_SIGNAL_FUNC(color_selection_changed),
5146         window);
5147
5148       gtk_signal_connect (
5149         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->ok_button),
5150         "clicked",
5151         GTK_SIGNAL_FUNC(color_selection_ok),
5152         window);
5153
5154       gtk_signal_connect_object (
5155         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->cancel_button),
5156         "clicked",
5157         GTK_SIGNAL_FUNC(gtk_widget_destroy),
5158         GTK_OBJECT (window));
5159     }
5160
5161   if (!GTK_WIDGET_VISIBLE (window))
5162     gtk_widget_show (window);
5163   else
5164     gtk_widget_destroy (window);
5165 }
5166
5167 /*
5168  * GtkFileSelection
5169  */
5170
5171 void
5172 file_selection_hide_fileops (GtkWidget *widget,
5173                              GtkFileSelection *fs)
5174 {
5175   gtk_file_selection_hide_fileop_buttons (fs);
5176 }
5177
5178 void
5179 file_selection_ok (GtkWidget        *w,
5180                    GtkFileSelection *fs)
5181 {
5182   g_print ("%s\n", gtk_file_selection_get_filename (fs));
5183   gtk_widget_destroy (GTK_WIDGET (fs));
5184 }
5185
5186 void
5187 create_file_selection (void)
5188 {
5189   static GtkWidget *window = NULL;
5190   GtkWidget *button;
5191
5192   if (!window)
5193     {
5194       window = gtk_file_selection_new ("file selection dialog");
5195
5196       gtk_file_selection_hide_fileop_buttons (GTK_FILE_SELECTION (window));
5197
5198       gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
5199
5200       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5201                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5202                           &window);
5203
5204       gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (window)->ok_button),
5205                           "clicked", GTK_SIGNAL_FUNC(file_selection_ok),
5206                           window);
5207       gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (window)->cancel_button),
5208                                  "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
5209                                  GTK_OBJECT (window));
5210
5211       button = gtk_button_new_with_label ("Hide Fileops");
5212       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5213                           (GtkSignalFunc) file_selection_hide_fileops,
5214                           (gpointer) window);
5215       gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
5216                           button, FALSE, FALSE, 0);
5217       gtk_widget_show (button);
5218
5219       button = gtk_button_new_with_label ("Show Fileops");
5220       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5221                                  (GtkSignalFunc) gtk_file_selection_show_fileop_buttons,
5222                                  (gpointer) window);
5223       gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
5224                           button, FALSE, FALSE, 0);
5225       gtk_widget_show (button);
5226     }
5227
5228   if (!GTK_WIDGET_VISIBLE (window))
5229     gtk_widget_show (window);
5230   else
5231     gtk_widget_destroy (window);
5232 }
5233
5234 /*
5235  * GtkFontSelection
5236  */
5237
5238 void
5239 font_selection_ok (GtkWidget              *w,
5240                    GtkFontSelectionDialog *fs)
5241 {
5242   g_print ("%s\n", gtk_font_selection_dialog_get_font_name (fs));
5243   gtk_widget_destroy (GTK_WIDGET (fs));
5244 }
5245
5246 void
5247 create_font_selection (void)
5248 {
5249   static GtkWidget *window = NULL;
5250
5251   if (!window)
5252     {
5253       window = gtk_font_selection_dialog_new ("Font Selection Dialog");
5254
5255       gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
5256
5257       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5258                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5259                           &window);
5260
5261       gtk_signal_connect (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->ok_button),
5262                           "clicked", GTK_SIGNAL_FUNC(font_selection_ok),
5263                           GTK_FONT_SELECTION_DIALOG (window));
5264       gtk_signal_connect_object (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->cancel_button),
5265                                  "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
5266                                  GTK_OBJECT (window));
5267     }
5268
5269   if (!GTK_WIDGET_VISIBLE (window))
5270     gtk_widget_show (window);
5271   else
5272     gtk_widget_destroy (window);
5273 }
5274
5275 /*
5276  * GtkDialog
5277  */
5278
5279 static GtkWidget *dialog_window = NULL;
5280
5281 void
5282 label_toggle (GtkWidget  *widget,
5283               GtkWidget **label)
5284 {
5285   if (!(*label))
5286     {
5287       *label = gtk_label_new ("Dialog Test");
5288       gtk_signal_connect (GTK_OBJECT (*label),
5289                           "destroy",
5290                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
5291                           label);
5292       gtk_misc_set_padding (GTK_MISC (*label), 10, 10);
5293       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
5294                           *label, TRUE, TRUE, 0);
5295       gtk_widget_show (*label);
5296     }
5297   else
5298     gtk_widget_destroy (*label);
5299 }
5300
5301 void
5302 create_dialog (void)
5303 {
5304   static GtkWidget *label;
5305   GtkWidget *button;
5306
5307   if (!dialog_window)
5308     {
5309       dialog_window = gtk_dialog_new ();
5310
5311       gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
5312                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5313                           &dialog_window);
5314
5315       gtk_window_set_title (GTK_WINDOW (dialog_window), "GtkDialog");
5316       gtk_container_border_width (GTK_CONTAINER (dialog_window), 0);
5317       gtk_widget_set_usize (dialog_window, 200, 110);
5318
5319       button = gtk_button_new_with_label ("OK");
5320       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5321       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
5322                           button, TRUE, TRUE, 0);
5323       gtk_widget_grab_default (button);
5324       gtk_widget_show (button);
5325
5326       button = gtk_button_new_with_label ("Toggle");
5327       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5328                           GTK_SIGNAL_FUNC (label_toggle),
5329                           &label);
5330       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5331       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
5332                           button, TRUE, TRUE, 0);
5333       gtk_widget_show (button);
5334
5335       label = NULL;
5336     }
5337
5338   if (!GTK_WIDGET_VISIBLE (dialog_window))
5339     gtk_widget_show (dialog_window);
5340   else
5341     gtk_widget_destroy (dialog_window);
5342 }
5343
5344 /*
5345  * GtkRange
5346  */
5347
5348 void
5349 create_range_controls (void)
5350 {
5351   static GtkWidget *window = NULL;
5352   GtkWidget *box1;
5353   GtkWidget *box2;
5354   GtkWidget *button;
5355   GtkWidget *scrollbar;
5356   GtkWidget *scale;
5357   GtkWidget *separator;
5358   GtkObject *adjustment;
5359
5360   if (!window)
5361     {
5362       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5363
5364       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5365                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5366                           &window);
5367
5368       gtk_window_set_title (GTK_WINDOW (window), "range controls");
5369       gtk_container_border_width (GTK_CONTAINER (window), 0);
5370
5371
5372       box1 = gtk_vbox_new (FALSE, 0);
5373       gtk_container_add (GTK_CONTAINER (window), box1);
5374       gtk_widget_show (box1);
5375
5376
5377       box2 = gtk_vbox_new (FALSE, 10);
5378       gtk_container_border_width (GTK_CONTAINER (box2), 10);
5379       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
5380       gtk_widget_show (box2);
5381
5382
5383       adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
5384
5385       scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
5386       gtk_widget_set_usize (GTK_WIDGET (scale), 150, 30);
5387       gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
5388       gtk_scale_set_digits (GTK_SCALE (scale), 1);
5389       gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5390       gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
5391       gtk_widget_show (scale);
5392
5393       scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adjustment));
5394       gtk_range_set_update_policy (GTK_RANGE (scrollbar),
5395                                    GTK_UPDATE_CONTINUOUS);
5396       gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0);
5397       gtk_widget_show (scrollbar);
5398
5399
5400       separator = gtk_hseparator_new ();
5401       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5402       gtk_widget_show (separator);
5403
5404
5405       box2 = gtk_vbox_new (FALSE, 10);
5406       gtk_container_border_width (GTK_CONTAINER (box2), 10);
5407       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5408       gtk_widget_show (box2);
5409
5410
5411       button = gtk_button_new_with_label ("close");
5412       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5413                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
5414                                  GTK_OBJECT (window));
5415       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5416       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5417       gtk_widget_grab_default (button);
5418       gtk_widget_show (button);
5419     }
5420
5421   if (!GTK_WIDGET_VISIBLE (window))
5422     gtk_widget_show (window);
5423   else
5424     gtk_widget_destroy (window);
5425 }
5426
5427 /*
5428  * GtkRulers
5429  */
5430
5431 void
5432 create_rulers (void)
5433 {
5434   static GtkWidget *window = NULL;
5435   GtkWidget *table;
5436   GtkWidget *ruler;
5437
5438   if (!window)
5439     {
5440       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5441       gtk_window_set_policy (GTK_WINDOW (window), TRUE, TRUE, FALSE);
5442
5443       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5444                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5445                           &window);
5446
5447       gtk_window_set_title (GTK_WINDOW (window), "rulers");
5448       gtk_widget_set_usize (window, 300, 300);
5449       gtk_widget_set_events (window,
5450                              GDK_POINTER_MOTION_MASK
5451                              | GDK_POINTER_MOTION_HINT_MASK);
5452       gtk_container_border_width (GTK_CONTAINER (window), 0);
5453
5454       table = gtk_table_new (2, 2, FALSE);
5455       gtk_container_add (GTK_CONTAINER (window), table);
5456       gtk_widget_show (table);
5457
5458       ruler = gtk_hruler_new ();
5459       gtk_ruler_set_metric (GTK_RULER (ruler), GTK_CENTIMETERS);
5460       gtk_ruler_set_range (GTK_RULER (ruler), 100, 0, 0, 20);
5461
5462       gtk_signal_connect_object (
5463         GTK_OBJECT (window),
5464         "motion_notify_event",
5465         GTK_SIGNAL_FUNC(
5466           GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
5467         GTK_OBJECT (ruler));
5468
5469       gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
5470                         GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
5471       gtk_widget_show (ruler);
5472
5473
5474       ruler = gtk_vruler_new ();
5475       gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
5476
5477       gtk_signal_connect_object (
5478         GTK_OBJECT (window),
5479         "motion_notify_event",
5480         GTK_SIGNAL_FUNC (GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
5481         GTK_OBJECT (ruler));
5482
5483       gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
5484                         GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
5485       gtk_widget_show (ruler);
5486     }
5487
5488   if (!GTK_WIDGET_VISIBLE (window))
5489     gtk_widget_show (window);
5490   else
5491     gtk_widget_destroy (window);
5492 }
5493
5494 static void
5495 text_toggle_editable (GtkWidget *checkbutton,
5496                        GtkWidget *text)
5497 {
5498    gtk_text_set_editable(GTK_TEXT(text),
5499                           GTK_TOGGLE_BUTTON(checkbutton)->active);
5500 }
5501
5502 static void
5503 text_toggle_word_wrap (GtkWidget *checkbutton,
5504                        GtkWidget *text)
5505 {
5506    gtk_text_set_word_wrap(GTK_TEXT(text),
5507                           GTK_TOGGLE_BUTTON(checkbutton)->active);
5508 }
5509
5510 struct {
5511   GdkColor color;
5512   gchar *name;
5513 } text_colors[] = {
5514  { { 0, 0x0000, 0x0000, 0x0000 }, "black" },
5515  { { 0, 0xFFFF, 0xFFFF, 0xFFFF }, "white" },
5516  { { 0, 0xFFFF, 0x0000, 0x0000 }, "red" },
5517  { { 0, 0x0000, 0xFFFF, 0x0000 }, "green" },
5518  { { 0, 0x0000, 0x0000, 0xFFFF }, "blue" },
5519  { { 0, 0x0000, 0xFFFF, 0xFFFF }, "cyan" },
5520  { { 0, 0xFFFF, 0x0000, 0xFFFF }, "magenta" },
5521  { { 0, 0xFFFF, 0xFFFF, 0x0000 }, "yellow" }
5522 };
5523
5524 int ntext_colors = sizeof(text_colors) / sizeof(text_colors[0]);
5525
5526 /*
5527  * GtkText
5528  */
5529 void
5530 text_insert_random (GtkWidget *w, GtkText *text)
5531 {
5532   int i;
5533   char c;
5534    for (i=0; i<10; i++)
5535     {
5536       c = 'A' + rand() % ('Z' - 'A');
5537       gtk_text_set_point (text, rand() % gtk_text_get_length (text));
5538       gtk_text_insert (text, NULL, NULL, NULL, &c, 1);
5539     }
5540 }
5541
5542 void
5543 create_text (void)
5544 {
5545   int i, j;
5546
5547   static GtkWidget *window = NULL;
5548   GtkWidget *box1;
5549   GtkWidget *box2;
5550   GtkWidget *hbox;
5551   GtkWidget *button;
5552   GtkWidget *check;
5553   GtkWidget *separator;
5554   GtkWidget *table;
5555   GtkWidget *hscrollbar;
5556   GtkWidget *vscrollbar;
5557   GtkWidget *text;
5558   GdkFont *font;
5559
5560   FILE *infile;
5561
5562   if (!window)
5563     {
5564       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5565       gtk_widget_set_name (window, "text window");
5566       gtk_widget_set_usize (window, 500, 500);
5567       gtk_window_set_policy (GTK_WINDOW(window), TRUE, TRUE, FALSE);
5568
5569       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5570                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5571                           &window);
5572
5573       gtk_window_set_title (GTK_WINDOW (window), "test");
5574       gtk_container_border_width (GTK_CONTAINER (window), 0);
5575
5576
5577       box1 = gtk_vbox_new (FALSE, 0);
5578       gtk_container_add (GTK_CONTAINER (window), box1);
5579       gtk_widget_show (box1);
5580
5581
5582       box2 = gtk_vbox_new (FALSE, 10);
5583       gtk_container_border_width (GTK_CONTAINER (box2), 10);
5584       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
5585       gtk_widget_show (box2);
5586
5587
5588       table = gtk_table_new (2, 2, FALSE);
5589       gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2);
5590       gtk_table_set_col_spacing (GTK_TABLE (table), 0, 2);
5591       gtk_box_pack_start (GTK_BOX (box2), table, TRUE, TRUE, 0);
5592       gtk_widget_show (table);
5593
5594       text = gtk_text_new (NULL, NULL);
5595       gtk_text_set_editable (GTK_TEXT (text), TRUE);
5596       gtk_table_attach (GTK_TABLE (table), text, 0, 1, 0, 1,
5597                         GTK_EXPAND | GTK_SHRINK | GTK_FILL,
5598                         GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
5599       gtk_widget_grab_focus (text);
5600       gtk_widget_show (text);
5601
5602       hscrollbar = gtk_hscrollbar_new (GTK_TEXT (text)->hadj);
5603       gtk_table_attach (GTK_TABLE (table), hscrollbar, 0, 1, 1, 2,
5604                         GTK_EXPAND | GTK_FILL | GTK_SHRINK, GTK_FILL, 0, 0);
5605       gtk_widget_show (hscrollbar);
5606
5607       vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
5608       gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 0, 1,
5609                         GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
5610       gtk_widget_show (vscrollbar);
5611
5612       gtk_text_freeze (GTK_TEXT (text));
5613
5614       font = gdk_font_load ("-adobe-courier-medium-r-normal--*-120-*-*-*-*-*-*");
5615
5616       for (i=0; i<ntext_colors; i++)
5617         {
5618           gtk_text_insert (GTK_TEXT (text), font, NULL, NULL,
5619                            text_colors[i].name, -1);
5620           gtk_text_insert (GTK_TEXT (text), font, NULL, NULL, "\t", -1);
5621
5622           for (j=0; j<ntext_colors; j++)
5623             {
5624               gtk_text_insert (GTK_TEXT (text), font,
5625                                &text_colors[j].color, &text_colors[i].color,
5626                                "XYZ", -1);
5627             }
5628           gtk_text_insert (GTK_TEXT (text), NULL, NULL, NULL, "\n", -1);
5629         }
5630
5631       /* The Text widget will reference count the font, so we
5632        * unreference it here
5633        */
5634       gdk_font_unref (font);
5635
5636       infile = fopen("testgtk.c", "r");
5637
5638       if (infile)
5639         {
5640           char buffer[1024];
5641           int nchars;
5642
5643           while (1)
5644             {
5645               nchars = fread(buffer, 1, 1024, infile);
5646               gtk_text_insert (GTK_TEXT (text), NULL, NULL,
5647                                NULL, buffer, nchars);
5648
5649               if (nchars < 1024)
5650                 break;
5651             }
5652
5653           fclose (infile);
5654         }
5655
5656       gtk_text_thaw (GTK_TEXT (text));
5657
5658       hbox = gtk_hbutton_box_new ();
5659       gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, FALSE, 0);
5660       gtk_widget_show (hbox);
5661
5662       check = gtk_check_button_new_with_label("Editable");
5663       gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, FALSE, 0);
5664       gtk_signal_connect (GTK_OBJECT(check), "toggled",
5665                           GTK_SIGNAL_FUNC(text_toggle_editable), text);
5666       gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), TRUE);
5667       gtk_widget_show (check);
5668
5669       check = gtk_check_button_new_with_label("Wrap Words");
5670       gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
5671       gtk_signal_connect (GTK_OBJECT(check), "toggled",
5672                           GTK_SIGNAL_FUNC(text_toggle_word_wrap), text);
5673       gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), FALSE);
5674       gtk_widget_show (check);
5675
5676       separator = gtk_hseparator_new ();
5677       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5678       gtk_widget_show (separator);
5679
5680
5681       box2 = gtk_vbox_new (FALSE, 10);
5682       gtk_container_border_width (GTK_CONTAINER (box2), 10);
5683       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5684       gtk_widget_show (box2);
5685
5686
5687       button = gtk_button_new_with_label ("insert random");
5688       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5689                           GTK_SIGNAL_FUNC(text_insert_random),
5690                           GTK_TEXT (text));
5691       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5692       gtk_widget_show (button);
5693
5694       button = gtk_button_new_with_label ("close");
5695       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5696                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
5697                                  GTK_OBJECT (window));
5698       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5699       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5700       gtk_widget_grab_default (button);
5701       gtk_widget_show (button);
5702     }
5703
5704   if (!GTK_WIDGET_VISIBLE (window))
5705     gtk_widget_show (window);
5706   else
5707     gtk_widget_destroy (window);
5708 }
5709
5710 /*
5711  * GtkNotebook
5712  */
5713
5714 GdkPixmap *book_open;
5715 GdkPixmap *book_closed;
5716 GdkBitmap *book_open_mask;
5717 GdkBitmap *book_closed_mask;
5718
5719 static void
5720 page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num)
5721 {
5722   GtkNotebookPage *oldpage;
5723   GtkWidget *pixwid;
5724
5725   oldpage = GTK_NOTEBOOK (widget)->cur_page;
5726
5727   if (page == oldpage)
5728     return;
5729
5730   pixwid = ((GtkBoxChild*)(GTK_BOX (page->tab_label)->children->data))->widget;
5731   gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
5732   pixwid = ((GtkBoxChild*) (GTK_BOX (page->menu_label)->children->data))->widget;
5733   gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
5734
5735   if (oldpage)
5736     {
5737       pixwid = ((GtkBoxChild*) (GTK_BOX
5738                                 (oldpage->tab_label)->children->data))->widget;
5739       gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
5740       pixwid = ((GtkBoxChild*) (GTK_BOX (oldpage->menu_label)->children->data))->widget;
5741       gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
5742     }
5743 }
5744
5745 static void
5746 create_pages (GtkNotebook *notebook, gint start, gint end)
5747 {
5748   GtkWidget *child = NULL;
5749   GtkWidget *label;
5750   GtkWidget *entry;
5751   GtkWidget *box;
5752   GtkWidget *hbox;
5753   GtkWidget *label_box;
5754   GtkWidget *menu_box;
5755   GtkWidget *button;
5756   GtkWidget *pixwid;
5757   gint i;
5758   char buffer[32];
5759
5760   for (i = start; i <= end; i++)
5761     {
5762       sprintf (buffer, "Page %d", i);
5763
5764       switch (i % 4)
5765         {
5766         case 3:
5767           child = gtk_button_new_with_label (buffer);
5768           gtk_container_border_width (GTK_CONTAINER(child), 10);
5769           break;
5770         case 2:
5771           child = gtk_label_new (buffer);
5772           break;
5773         case 1:
5774           child = gtk_frame_new (buffer);
5775           gtk_container_border_width (GTK_CONTAINER (child), 10);
5776
5777           box = gtk_vbox_new (TRUE,0);
5778           gtk_container_border_width (GTK_CONTAINER (box), 10);
5779           gtk_container_add (GTK_CONTAINER (child), box);
5780
5781           label = gtk_label_new (buffer);
5782           gtk_box_pack_start (GTK_BOX(box), label, TRUE, TRUE, 5);
5783
5784           entry = gtk_entry_new ();
5785           gtk_box_pack_start (GTK_BOX(box), entry, TRUE, TRUE, 5);
5786
5787           hbox = gtk_hbox_new (TRUE,0);
5788           gtk_box_pack_start (GTK_BOX(box), hbox, TRUE, TRUE, 5);
5789
5790           button = gtk_button_new_with_label ("Ok");
5791           gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
5792
5793           button = gtk_button_new_with_label ("Cancel");
5794           gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
5795           break;
5796         case 0:
5797           child = gtk_frame_new (buffer);
5798           gtk_container_border_width (GTK_CONTAINER (child), 10);
5799
5800           label = gtk_label_new (buffer);
5801           gtk_container_add (GTK_CONTAINER (child), label);
5802           break;
5803         }
5804
5805       gtk_widget_show_all (child);
5806
5807       label_box = gtk_hbox_new (FALSE, 0);
5808       pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
5809       gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
5810       gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
5811       label = gtk_label_new (buffer);
5812       gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
5813       gtk_widget_show_all (label_box);
5814
5815       menu_box = gtk_hbox_new (FALSE, 0);
5816       pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
5817       gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
5818       gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
5819       label = gtk_label_new (buffer);
5820       gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0);
5821       gtk_widget_show_all (menu_box);
5822
5823       gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
5824     }
5825 }
5826
5827 static void
5828 rotate_notebook (GtkButton   *button,
5829                  GtkNotebook *notebook)
5830 {
5831   gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos + 1) % 4);
5832 }
5833
5834 static void
5835 standard_notebook (GtkButton   *button,
5836                    GtkNotebook *notebook)
5837 {
5838   gint i;
5839
5840   gtk_notebook_set_show_tabs (notebook, TRUE);
5841   gtk_notebook_set_scrollable (notebook, FALSE);
5842   if (g_list_length (notebook->children) == 15)
5843     for (i = 0; i < 10; i++)
5844       gtk_notebook_remove_page (notebook, 5);
5845 }
5846
5847 static void
5848 notabs_notebook (GtkButton   *button,
5849                  GtkNotebook *notebook)
5850 {
5851   gint i;
5852
5853   gtk_notebook_set_show_tabs (notebook, FALSE);
5854   if (g_list_length (notebook->children) == 15)
5855     for (i = 0; i < 10; i++)
5856       gtk_notebook_remove_page (notebook, 5);
5857 }
5858
5859 static void
5860 scrollable_notebook (GtkButton   *button,
5861                      GtkNotebook *notebook)
5862 {
5863   gtk_notebook_set_show_tabs (notebook, TRUE);
5864   gtk_notebook_set_scrollable (notebook, TRUE);
5865   if (g_list_length (notebook->children) == 5)
5866     create_pages (notebook, 6, 15);
5867 }
5868
5869 static void
5870 notebook_popup (GtkToggleButton *button,
5871                 GtkNotebook     *notebook)
5872 {
5873   if (button->active)
5874     gtk_notebook_popup_enable (notebook);
5875   else
5876     gtk_notebook_popup_disable (notebook);
5877 }
5878
5879 static void
5880 create_notebook (void)
5881 {
5882   static GtkWidget *window = NULL;
5883   GtkWidget *box1;
5884   GtkWidget *box2;
5885   GtkWidget *button;
5886   GtkWidget *separator;
5887   GtkWidget *notebook;
5888   GtkWidget *omenu;
5889   GdkColor *transparent = NULL;
5890
5891   static OptionMenuItem items[] =
5892   {
5893     { "Standard",   standard_notebook },
5894     { "No tabs",    notabs_notebook },
5895     { "Scrollable", scrollable_notebook }
5896   };
5897
5898   if (!window)
5899     {
5900       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5901
5902       gtk_signal_connect (GTK_OBJECT (window), "destroy",
5903                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5904                           &window);
5905
5906       gtk_window_set_title (GTK_WINDOW (window), "notebook");
5907       gtk_container_border_width (GTK_CONTAINER (window), 0);
5908
5909       box1 = gtk_vbox_new (FALSE, 0);
5910       gtk_container_add (GTK_CONTAINER (window), box1);
5911
5912       notebook = gtk_notebook_new ();
5913       gtk_signal_connect (GTK_OBJECT (notebook), "switch_page",
5914                           GTK_SIGNAL_FUNC (page_switch), NULL);
5915       gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
5916       gtk_box_pack_start (GTK_BOX (box1), notebook, TRUE, TRUE, 0);
5917       gtk_container_border_width (GTK_CONTAINER (notebook), 10);
5918
5919       gtk_widget_realize (notebook);
5920       book_open = gdk_pixmap_create_from_xpm_d (notebook->window,
5921                                                 &book_open_mask,
5922                                                 transparent,
5923                                                 book_open_xpm);
5924       book_closed = gdk_pixmap_create_from_xpm_d (notebook->window,
5925                                                   &book_closed_mask,
5926                                                   transparent,
5927                                                   book_closed_xpm);
5928
5929       create_pages (GTK_NOTEBOOK (notebook), 1, 5);
5930
5931       separator = gtk_hseparator_new ();
5932       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10);
5933
5934       box2 = gtk_hbox_new (TRUE, 5);
5935       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5936
5937       omenu = build_option_menu (items, 3, 0, notebook);
5938       gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, FALSE, 0);
5939
5940       button = gtk_check_button_new_with_label ("enable popup menu");
5941       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
5942       gtk_signal_connect (GTK_OBJECT(button), "clicked",
5943                           GTK_SIGNAL_FUNC (notebook_popup),
5944                           GTK_OBJECT (notebook));
5945
5946       box2 = gtk_hbox_new (TRUE, 10);
5947       gtk_container_border_width (GTK_CONTAINER (box2), 10);
5948       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5949
5950       button = gtk_button_new_with_label ("close");
5951       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5952                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
5953                                  GTK_OBJECT (window));
5954       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5955       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5956       gtk_widget_grab_default (button);
5957
5958       button = gtk_button_new_with_label ("next");
5959       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5960                                  GTK_SIGNAL_FUNC (gtk_notebook_next_page),
5961                                  GTK_OBJECT (notebook));
5962       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5963       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5964
5965       button = gtk_button_new_with_label ("prev");
5966       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5967                                  GTK_SIGNAL_FUNC (gtk_notebook_prev_page),
5968                                  GTK_OBJECT (notebook));
5969       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5970       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5971
5972       button = gtk_button_new_with_label ("rotate");
5973       gtk_signal_connect (GTK_OBJECT (button), "clicked",
5974                           GTK_SIGNAL_FUNC (rotate_notebook),
5975                           notebook);
5976       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5977       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5978     }
5979
5980   if (!GTK_WIDGET_VISIBLE (window))
5981     gtk_widget_show_all (window);
5982   else
5983     gtk_widget_destroy (window);
5984 }
5985
5986 /*
5987  * GtkPanes
5988  */
5989
5990 void
5991 create_panes (void)
5992 {
5993   static GtkWidget *window = NULL;
5994   GtkWidget *frame;
5995   GtkWidget *hpaned;
5996   GtkWidget *vpaned;
5997   GtkWidget *button;
5998
5999   if (!window)
6000     {
6001       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6002
6003       gtk_signal_connect (GTK_OBJECT (window), "destroy",
6004                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6005                           &window);
6006
6007       gtk_window_set_title (GTK_WINDOW (window), "Panes");
6008       gtk_container_border_width (GTK_CONTAINER (window), 0);
6009
6010       vpaned = gtk_vpaned_new ();
6011       gtk_container_add (GTK_CONTAINER (window), vpaned);
6012       gtk_container_border_width (GTK_CONTAINER(vpaned), 5);
6013       gtk_widget_show (vpaned);
6014
6015       hpaned = gtk_hpaned_new ();
6016       gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
6017
6018       frame = gtk_frame_new (NULL);
6019       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6020       gtk_widget_set_usize (frame, 60, 60);
6021       gtk_paned_add1 (GTK_PANED (hpaned), frame);
6022       gtk_widget_show (frame);
6023
6024       button = gtk_button_new_with_label ("Hi there");
6025       gtk_container_add (GTK_CONTAINER(frame), button);
6026       gtk_widget_show (button);
6027
6028       frame = gtk_frame_new (NULL);
6029       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6030       gtk_widget_set_usize (frame, 80, 60);
6031       gtk_paned_add2 (GTK_PANED (hpaned), frame);
6032       gtk_widget_show (frame);
6033
6034       gtk_widget_show (hpaned);
6035
6036       frame = gtk_frame_new (NULL);
6037       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6038       gtk_widget_set_usize (frame, 60, 80);
6039       gtk_paned_add2 (GTK_PANED (vpaned), frame);
6040       gtk_widget_show (frame);
6041     }
6042
6043   if (!GTK_WIDGET_VISIBLE (window))
6044     gtk_widget_show (window);
6045   else
6046     gtk_widget_destroy (window);
6047 }
6048
6049 /*
6050  * Drag -N- Drop
6051  */
6052
6053 #if 0
6054 gint
6055 dnd_drop_destroy_popup (GtkWidget *widget, GtkWindow **window)
6056 {
6057   if(GTK_IS_BUTTON(widget)) /* I.e. they clicked the close button */
6058     gtk_widget_destroy(GTK_WIDGET(*window));
6059   else {
6060     gtk_grab_remove(GTK_WIDGET(*window));
6061     *window = NULL;
6062   }
6063
6064   return FALSE;
6065 }
6066
6067 void
6068 dnd_drop (GtkWidget *button, GdkEvent *event)
6069 {
6070   static GtkWidget *window = NULL;
6071   GtkWidget *vbox, *lbl, *btn;
6072   gchar *msg;
6073
6074   /* DND doesn't obey gtk_grab's, so check if we're already displaying
6075    * drop modal dialog first
6076    */
6077   if (window)
6078     return;
6079
6080   window = gtk_window_new(GTK_WINDOW_DIALOG);
6081   gtk_container_border_width (GTK_CONTAINER(window), 10);
6082
6083   gtk_signal_connect (GTK_OBJECT (window), "destroy",
6084                       GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
6085                       &window);
6086   gtk_signal_connect (GTK_OBJECT (window), "delete-event",
6087                       GTK_SIGNAL_FUNC(gtk_false),
6088                       &window);
6089
6090   vbox = gtk_vbox_new(FALSE, 5);
6091
6092   /* Display message that we got from drop source */
6093   msg = g_malloc(strlen(event->dropdataavailable.data)
6094                  + strlen(event->dropdataavailable.data_type) + 100);
6095   sprintf(msg, "Drop data of type %s was:\n\n%s",
6096           event->dropdataavailable.data_type,
6097           (char *)event->dropdataavailable.data);
6098   lbl = gtk_label_new(msg);
6099   gtk_label_set_justify(GTK_LABEL(lbl), GTK_JUSTIFY_FILL);
6100   g_free(msg);
6101   gtk_widget_show(lbl);
6102   gtk_box_pack_start_defaults(GTK_BOX(vbox), lbl);
6103
6104   /* Provide an obvious way out of this heinousness */
6105   btn = gtk_button_new_with_label("Continue with life in\nspite of this oppression");
6106   gtk_signal_connect_object (GTK_OBJECT (btn), "clicked",
6107                              GTK_SIGNAL_FUNC(gtk_widget_destroy),
6108                              GTK_OBJECT (window));
6109   gtk_widget_show(btn);
6110   gtk_box_pack_start_defaults(GTK_BOX(vbox), btn);
6111
6112   gtk_container_add(GTK_CONTAINER(window), vbox);
6113
6114   gtk_widget_show(vbox);
6115   gtk_grab_add(window);
6116   gtk_widget_show(window);
6117 }
6118
6119 void
6120 dnd_drag_request (GtkWidget *button, GdkEvent *event)
6121 {
6122 #define DND_STRING "Bill Gates demands royalties for\nyour use of his innovation."
6123   gtk_widget_dnd_data_set (button, event, DND_STRING, strlen(DND_STRING) + 1);
6124 }
6125
6126 void
6127 create_dnd (void)
6128 {
6129   static GtkWidget *window = NULL;
6130   GtkWidget *box1;
6131   GtkWidget *box2;
6132   GtkWidget *box3;
6133   GtkWidget *frame;
6134   GtkWidget *button;
6135   GtkWidget *separator;
6136
6137   /* For clarity... */
6138   char *possible_drag_types[] = {"text/plain"};
6139   char *accepted_drop_types[] = {"text/plain"};
6140
6141   static GtkWidget *drag_icon = NULL;
6142   static GtkWidget *drop_icon = NULL;
6143
6144   if (!window)
6145     {
6146       GdkPoint hotspot = {5,5};
6147
6148       if (!drag_icon)
6149         {
6150           drag_icon = shape_create_icon ("Modeller.xpm",
6151                                          440, 140, 0,0, GTK_WINDOW_POPUP);
6152
6153           gtk_signal_connect (GTK_OBJECT (drag_icon), "destroy",
6154                               GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6155                               &drag_icon);
6156
6157           gtk_widget_hide (drag_icon);
6158         }
6159
6160       if (!drop_icon)
6161         {
6162           drop_icon = shape_create_icon ("3DRings.xpm",
6163                                          440, 140, 0,0, GTK_WINDOW_POPUP);
6164
6165           gtk_signal_connect (GTK_OBJECT (drop_icon), "destroy",
6166                               GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6167                               &drop_icon);
6168
6169           gtk_widget_hide (drop_icon);
6170         }
6171
6172       gdk_dnd_set_drag_shape(drag_icon->window,
6173                              &hotspot,
6174                              drop_icon->window,
6175                              &hotspot);
6176
6177       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6178
6179       gtk_signal_connect (GTK_OBJECT (window), "destroy",
6180                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6181                           &window);
6182
6183       gtk_window_set_title (GTK_WINDOW (window), "Drag -N- Drop");
6184       gtk_container_border_width (GTK_CONTAINER (window), 0);
6185
6186       box1 = gtk_vbox_new (FALSE, 0);
6187       gtk_container_add (GTK_CONTAINER (window), box1);
6188       gtk_widget_show (box1);
6189
6190       box2 = gtk_hbox_new (FALSE, 5);
6191       gtk_container_border_width (GTK_CONTAINER (box2), 10);
6192       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
6193       gtk_widget_show (box2);
6194
6195       frame = gtk_frame_new ("Drag");
6196       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
6197       gtk_widget_show (frame);
6198
6199       box3 = gtk_vbox_new (FALSE, 5);
6200       gtk_container_border_width (GTK_CONTAINER (box3), 5);
6201       gtk_container_add (GTK_CONTAINER (frame), box3);
6202       gtk_widget_show (box3);
6203
6204       /*
6205        * FROM Button
6206        */
6207       button = gtk_button_new_with_label ("Drag me!");
6208       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
6209       gtk_widget_show (button);
6210
6211       /*
6212        * currently, the widget has to be realized to
6213        * set dnd on it, this needs to change
6214        */
6215       gtk_widget_realize (button);
6216       gtk_signal_connect (GTK_OBJECT (button),
6217                           "drag_request_event",
6218                           GTK_SIGNAL_FUNC(dnd_drag_request),
6219                           button);
6220
6221       gtk_widget_dnd_drag_set (button, TRUE, possible_drag_types, 1);
6222
6223
6224       frame = gtk_frame_new ("Drop");
6225       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
6226       gtk_widget_show (frame);
6227
6228       box3 = gtk_vbox_new (FALSE, 5);
6229       gtk_container_border_width (GTK_CONTAINER (box3), 5);
6230       gtk_container_add (GTK_CONTAINER (frame), box3);
6231       gtk_widget_show (box3);
6232
6233
6234       /*
6235        * TO Button
6236        */
6237       button = gtk_button_new_with_label ("To");
6238       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
6239       gtk_widget_show (button);
6240
6241       gtk_widget_realize (button);
6242       gtk_signal_connect (GTK_OBJECT (button),
6243                           "drop_data_available_event",
6244                           GTK_SIGNAL_FUNC(dnd_drop),
6245                           button);
6246
6247       gtk_widget_dnd_drop_set (button, TRUE, accepted_drop_types, 1, FALSE);
6248
6249
6250       separator = gtk_hseparator_new ();
6251       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
6252       gtk_widget_show (separator);
6253
6254
6255       box2 = gtk_vbox_new (FALSE, 10);
6256       gtk_container_border_width (GTK_CONTAINER (box2), 10);
6257       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6258       gtk_widget_show (box2);
6259
6260
6261       button = gtk_button_new_with_label ("close");
6262
6263       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6264                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
6265                                  GTK_OBJECT (window));
6266
6267       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6268       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6269       gtk_widget_grab_default (button);
6270       gtk_widget_show (button);
6271     }
6272
6273   if (!GTK_WIDGET_VISIBLE (window))
6274     gtk_widget_show (window);
6275   else
6276     gtk_widget_destroy (window);
6277 }
6278 #endif
6279
6280 /*
6281  * Shaped Windows
6282  */
6283
6284 static GdkWindow *root_win = NULL;
6285
6286 typedef struct _cursoroffset {gint x,y;} CursorOffset;
6287
6288 static void
6289 shape_pressed (GtkWidget *widget, GdkEventButton *event)
6290 {
6291   CursorOffset *p;
6292
6293   /* ignore double and triple click */
6294   if (event->type != GDK_BUTTON_PRESS)
6295     return;
6296
6297   p = gtk_object_get_user_data (GTK_OBJECT(widget));
6298   p->x = (int) event->x;
6299   p->y = (int) event->y;
6300
6301   gtk_grab_add (widget);
6302   gdk_pointer_grab (widget->window, TRUE,
6303                     GDK_BUTTON_RELEASE_MASK |
6304                     GDK_BUTTON_MOTION_MASK |
6305                     GDK_POINTER_MOTION_HINT_MASK,
6306                     NULL, NULL, 0);
6307 }
6308
6309 static void
6310 shape_released (GtkWidget *widget)
6311 {
6312   gtk_grab_remove (widget);
6313   gdk_pointer_ungrab (0);
6314 }
6315
6316 static void
6317 shape_motion (GtkWidget      *widget,
6318               GdkEventMotion *event)
6319 {
6320   gint xp, yp;
6321   CursorOffset * p;
6322   GdkModifierType mask;
6323
6324   p = gtk_object_get_user_data (GTK_OBJECT (widget));
6325
6326   /*
6327    * Can't use event->x / event->y here
6328    * because I need absolute coordinates.
6329    */
6330   gdk_window_get_pointer (root_win, &xp, &yp, &mask);
6331   gtk_widget_set_uposition (widget, xp  - p->x, yp  - p->y);
6332 }
6333
6334 GtkWidget *
6335 shape_create_icon (char     *xpm_file,
6336                    gint      x,
6337                    gint      y,
6338                    gint      px,
6339                    gint      py,
6340                    gint      window_type)
6341 {
6342   GtkWidget *window;
6343   GtkWidget *pixmap;
6344   GtkWidget *fixed;
6345   CursorOffset* icon_pos;
6346   GdkGC* gc;
6347   GdkBitmap *gdk_pixmap_mask;
6348   GdkPixmap *gdk_pixmap;
6349   GtkStyle *style;
6350
6351   style = gtk_widget_get_default_style ();
6352   gc = style->black_gc;
6353
6354   /*
6355    * GDK_WINDOW_TOPLEVEL works also, giving you a title border
6356    */
6357   window = gtk_window_new (window_type);
6358
6359   fixed = gtk_fixed_new ();
6360   gtk_widget_set_usize (fixed, 100,100);
6361   gtk_container_add (GTK_CONTAINER (window), fixed);
6362   gtk_widget_show (fixed);
6363
6364   gtk_widget_set_events (window,
6365                          gtk_widget_get_events (window) |
6366                          GDK_BUTTON_MOTION_MASK |
6367                          GDK_POINTER_MOTION_HINT_MASK |
6368                          GDK_BUTTON_PRESS_MASK);
6369
6370   gtk_widget_realize (window);
6371   gdk_pixmap = gdk_pixmap_create_from_xpm (window->window, &gdk_pixmap_mask,
6372                                            &style->bg[GTK_STATE_NORMAL],
6373                                            xpm_file);
6374
6375   pixmap = gtk_pixmap_new (gdk_pixmap, gdk_pixmap_mask);
6376   gtk_fixed_put (GTK_FIXED (fixed), pixmap, px,py);
6377   gtk_widget_show (pixmap);
6378
6379   gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px,py);
6380
6381
6382   gtk_signal_connect (GTK_OBJECT (window), "button_press_event",
6383                       GTK_SIGNAL_FUNC (shape_pressed),NULL);
6384   gtk_signal_connect (GTK_OBJECT (window), "button_release_event",
6385                       GTK_SIGNAL_FUNC (shape_released),NULL);
6386   gtk_signal_connect (GTK_OBJECT (window), "motion_notify_event",
6387                       GTK_SIGNAL_FUNC (shape_motion),NULL);
6388
6389   icon_pos = g_new (CursorOffset, 1);
6390   gtk_object_set_user_data(GTK_OBJECT(window), icon_pos);
6391
6392   gtk_widget_set_uposition (window, x, y);
6393   gtk_widget_show (window);
6394
6395   return window;
6396 }
6397
6398 void
6399 create_shapes (void)
6400 {
6401   /* Variables used by the Drag/Drop and Shape Window demos */
6402   static GtkWidget *modeller = NULL;
6403   static GtkWidget *sheets = NULL;
6404   static GtkWidget *rings = NULL;
6405
6406   root_win = gdk_window_foreign_new (GDK_ROOT_WINDOW ());
6407
6408   if (!modeller)
6409     {
6410       modeller = shape_create_icon ("Modeller.xpm",
6411                                     440, 140, 0,0, GTK_WINDOW_POPUP);
6412
6413       gtk_signal_connect (GTK_OBJECT (modeller), "destroy",
6414                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6415                           &modeller);
6416     }
6417   else
6418     gtk_widget_destroy (modeller);
6419
6420   if (!sheets)
6421     {
6422       sheets = shape_create_icon ("FilesQueue.xpm",
6423                                   580, 170, 0,0, GTK_WINDOW_POPUP);
6424
6425       gtk_signal_connect (GTK_OBJECT (sheets), "destroy",
6426                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6427                           &sheets);
6428
6429     }
6430   else
6431     gtk_widget_destroy (sheets);
6432
6433   if (!rings)
6434     {
6435       rings = shape_create_icon ("3DRings.xpm",
6436                                  460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
6437
6438       gtk_signal_connect (GTK_OBJECT (rings), "destroy",
6439                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6440                           &rings);
6441     }
6442   else
6443     gtk_widget_destroy (rings);
6444 }
6445
6446 /*
6447  * WM Hints demo
6448  */
6449
6450 void
6451 create_wmhints (void)
6452 {
6453   static GtkWidget *window = NULL;
6454   GtkWidget *label;
6455   GtkWidget *separator;
6456   GtkWidget *button;
6457   GtkWidget *box1;
6458   GtkWidget *box2;
6459
6460   GdkBitmap *circles;
6461
6462   if (!window)
6463     {
6464       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6465
6466       gtk_signal_connect (GTK_OBJECT (window), "destroy",
6467                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6468                           &window);
6469
6470       gtk_window_set_title (GTK_WINDOW (window), "WM Hints");
6471       gtk_container_border_width (GTK_CONTAINER (window), 0);
6472
6473       gtk_widget_realize (window);
6474
6475       circles = gdk_bitmap_create_from_data (window->window,
6476                                              circles_bits,
6477                                              circles_width,
6478                                              circles_height);
6479       gdk_window_set_icon (window->window, NULL,
6480                            circles, circles);
6481
6482       gdk_window_set_icon_name (window->window, "WMHints Test Icon");
6483
6484       gdk_window_set_decorations (window->window, GDK_DECOR_ALL | GDK_DECOR_MENU);
6485       gdk_window_set_functions (window->window, GDK_FUNC_ALL | GDK_FUNC_RESIZE);
6486
6487       box1 = gtk_vbox_new (FALSE, 0);
6488       gtk_container_add (GTK_CONTAINER (window), box1);
6489       gtk_widget_show (box1);
6490
6491       label = gtk_label_new ("Try iconizing me!");
6492       gtk_widget_set_usize (label, 150, 50);
6493       gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
6494       gtk_widget_show (label);
6495
6496
6497       separator = gtk_hseparator_new ();
6498       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
6499       gtk_widget_show (separator);
6500
6501
6502       box2 = gtk_vbox_new (FALSE, 10);
6503       gtk_container_border_width (GTK_CONTAINER (box2), 10);
6504       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6505       gtk_widget_show (box2);
6506
6507
6508       button = gtk_button_new_with_label ("close");
6509
6510       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6511                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
6512                                  GTK_OBJECT (window));
6513
6514       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6515       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6516       gtk_widget_grab_default (button);
6517       gtk_widget_show (button);
6518     }
6519
6520   if (!GTK_WIDGET_VISIBLE (window))
6521     gtk_widget_show (window);
6522   else
6523     gtk_widget_destroy (window);
6524 }
6525
6526 /*
6527  * GtkProgressBar
6528  */
6529
6530 typedef struct _ProgressData {
6531   GtkWidget *window;
6532   GtkWidget *pbar;
6533   GtkWidget *block_spin;
6534   GtkWidget *x_align_spin;
6535   GtkWidget *y_align_spin;
6536   GtkWidget *step_spin;
6537   GtkWidget *act_blocks_spin;
6538   GtkWidget *label;
6539   GtkWidget *omenu1;
6540   GtkWidget *omenu2;
6541   GtkWidget *entry;
6542   int timer;
6543 } ProgressData;
6544
6545 gint
6546 progress_timeout (gpointer data)
6547 {
6548   gfloat new_val;
6549   GtkAdjustment *adj;
6550
6551   adj = GTK_PROGRESS (data)->adjustment;
6552
6553   new_val = adj->value + 1;
6554   if (new_val > adj->upper)
6555     new_val = adj->lower;
6556
6557   gtk_progress_set_value (GTK_PROGRESS (data), new_val);
6558
6559   return TRUE;
6560 }
6561
6562 static void
6563 destroy_progress (GtkWidget     *widget,
6564                   ProgressData **pdata)
6565 {
6566   gtk_timeout_remove ((*pdata)->timer);
6567   (*pdata)->timer = 0;
6568   (*pdata)->window = NULL;
6569   g_free (*pdata);
6570   *pdata = NULL;
6571 }
6572
6573 static void
6574 progressbar_toggle_orientation (GtkWidget *widget, ProgressData *pdata)
6575 {
6576   gint i;
6577
6578   if (!GTK_WIDGET_MAPPED (widget))
6579     return;
6580
6581   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
6582                     (((GtkOptionMenu *)(pdata->omenu1))->menu_item), i);
6583
6584   gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (pdata->pbar),
6585                             (GtkProgressBarOrientation) (3-i));
6586 }
6587
6588 static void
6589 toggle_show_text (GtkWidget *widget, ProgressData *pdata)
6590 {
6591   gtk_progress_set_show_text (GTK_PROGRESS (pdata->pbar),
6592                               GTK_TOGGLE_BUTTON (widget)->active);
6593   gtk_widget_set_sensitive (pdata->entry, GTK_TOGGLE_BUTTON (widget)->active);
6594   gtk_widget_set_sensitive (pdata->x_align_spin,
6595                             GTK_TOGGLE_BUTTON (widget)->active);
6596   gtk_widget_set_sensitive (pdata->y_align_spin,
6597                             GTK_TOGGLE_BUTTON (widget)->active);
6598 }
6599
6600 static void
6601 progressbar_toggle_bar_style (GtkWidget *widget, ProgressData *pdata)
6602 {
6603   gint i;
6604
6605   if (!GTK_WIDGET_MAPPED (widget))
6606     return;
6607
6608   RADIOMENUTOGGLED ((GtkRadioMenuItem *)
6609                     (((GtkOptionMenu *)(pdata->omenu2))->menu_item), i);
6610
6611   i = 1 - i;
6612
6613   if (i == 1)
6614     gtk_widget_set_sensitive (pdata->block_spin, TRUE);
6615   else
6616     gtk_widget_set_sensitive (pdata->block_spin, FALSE);
6617
6618   gtk_progress_bar_set_bar_style (GTK_PROGRESS_BAR (pdata->pbar),
6619                                   (GtkProgressBarStyle) i);
6620 }
6621
6622 static void
6623 progress_value_changed (GtkAdjustment *adj, ProgressData *pdata)
6624 {
6625   char buf[20];
6626
6627   if (GTK_PROGRESS (pdata->pbar)->activity_mode)
6628     sprintf (buf, "???");
6629   else
6630     sprintf (buf, "%.0f%%", 100 *
6631              gtk_progress_get_current_percentage (GTK_PROGRESS (pdata->pbar)));
6632   gtk_label_set (GTK_LABEL (pdata->label), buf);
6633 }
6634
6635 static void
6636 adjust_blocks (GtkAdjustment *adj, ProgressData *pdata)
6637 {
6638   gtk_progress_set_percentage (GTK_PROGRESS (pdata->pbar), 0);
6639   gtk_progress_bar_set_discrete_blocks (GTK_PROGRESS_BAR (pdata->pbar),
6640      gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pdata->block_spin)));
6641 }
6642
6643 static void
6644 adjust_step (GtkAdjustment *adj, ProgressData *pdata)
6645 {
6646   gtk_progress_bar_set_activity_step (GTK_PROGRESS_BAR (pdata->pbar),
6647      gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pdata->step_spin)));
6648 }
6649
6650 static void
6651 adjust_act_blocks (GtkAdjustment *adj, ProgressData *pdata)
6652 {
6653   gtk_progress_bar_set_activity_blocks (GTK_PROGRESS_BAR (pdata->pbar),
6654                gtk_spin_button_get_value_as_int
6655                       (GTK_SPIN_BUTTON (pdata->act_blocks_spin)));
6656 }
6657
6658 static void
6659 adjust_align (GtkAdjustment *adj, ProgressData *pdata)
6660 {
6661   gtk_progress_set_text_alignment (GTK_PROGRESS (pdata->pbar),
6662          gtk_spin_button_get_value_as_float
6663                                    (GTK_SPIN_BUTTON (pdata->x_align_spin)),
6664          gtk_spin_button_get_value_as_float
6665                                    (GTK_SPIN_BUTTON (pdata->y_align_spin)));
6666 }
6667
6668 static void
6669 toggle_activity_mode (GtkWidget *widget, ProgressData *pdata)
6670 {
6671   gtk_progress_set_activity_mode (GTK_PROGRESS (pdata->pbar),
6672                                   GTK_TOGGLE_BUTTON (widget)->active);
6673   gtk_widget_set_sensitive (pdata->step_spin,
6674                             GTK_TOGGLE_BUTTON (widget)->active);
6675   gtk_widget_set_sensitive (pdata->act_blocks_spin,
6676                             GTK_TOGGLE_BUTTON (widget)->active);
6677 }
6678
6679 static void
6680 entry_changed (GtkWidget *widget, ProgressData *pdata)
6681 {
6682   gtk_progress_set_format_string (GTK_PROGRESS (pdata->pbar),
6683                           gtk_entry_get_text (GTK_ENTRY (pdata->entry)));
6684 }
6685
6686 void
6687 create_progress_bar (void)
6688 {
6689   GtkWidget *button;
6690   GtkWidget *vbox;
6691   GtkWidget *vbox2;
6692   GtkWidget *hbox;
6693   GtkWidget *check;
6694   GtkWidget *frame;
6695   GtkWidget *tab;
6696   GtkWidget *label;
6697   GtkWidget *align;
6698   GtkAdjustment *adj;
6699   static ProgressData *pdata = NULL;
6700
6701   static OptionMenuItem items1[] =
6702   {
6703     { "Left-Right", progressbar_toggle_orientation },
6704     { "Right-Left", progressbar_toggle_orientation },
6705     { "Bottom-Top", progressbar_toggle_orientation },
6706     { "Top-Bottom", progressbar_toggle_orientation }
6707   };
6708
6709   static OptionMenuItem items2[] =
6710   {
6711     { "Continuous", progressbar_toggle_bar_style },
6712     { "Discrete",   progressbar_toggle_bar_style }
6713   };
6714
6715   if (!pdata)
6716     pdata = g_new0 (ProgressData, 1);
6717
6718   if (!pdata->window)
6719     {
6720       pdata->window = gtk_dialog_new ();
6721
6722       gtk_window_set_policy (GTK_WINDOW (pdata->window), FALSE, FALSE, TRUE);
6723
6724       gtk_signal_connect (GTK_OBJECT (pdata->window), "destroy",
6725                           GTK_SIGNAL_FUNC (destroy_progress),
6726                           &pdata);
6727
6728       pdata->timer = 0;
6729
6730       gtk_window_set_title (GTK_WINDOW (pdata->window), "GtkProgressBar");
6731       gtk_container_border_width (GTK_CONTAINER (pdata->window), 0);
6732
6733       vbox = gtk_vbox_new (FALSE, 5);
6734       gtk_container_border_width (GTK_CONTAINER (vbox), 10);
6735       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pdata->window)->vbox),
6736                           vbox, FALSE, TRUE, 0);
6737
6738       frame = gtk_frame_new ("Progress");
6739       gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
6740
6741       vbox2 = gtk_vbox_new (FALSE, 5);
6742       gtk_container_add (GTK_CONTAINER (frame), vbox2);
6743
6744       align = gtk_alignment_new (0.5, 0.5, 0, 0);
6745       gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
6746
6747       adj = (GtkAdjustment *) gtk_adjustment_new (0, 1, 300, 0, 0, 0);
6748       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6749                           GTK_SIGNAL_FUNC (progress_value_changed), pdata);
6750
6751       pdata->pbar = gtk_progress_bar_new_with_adjustment (adj);
6752       gtk_progress_set_format_string (GTK_PROGRESS (pdata->pbar),
6753                                       "%v from [%l,%u] (=%p%%)");
6754       gtk_container_add (GTK_CONTAINER (align), pdata->pbar);
6755       pdata->timer = gtk_timeout_add (100, progress_timeout, pdata->pbar);
6756
6757       align = gtk_alignment_new (0.5, 0.5, 0, 0);
6758       gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
6759
6760       hbox = gtk_hbox_new (FALSE, 5);
6761       gtk_container_add (GTK_CONTAINER (align), hbox);
6762       label = gtk_label_new ("Label updated by user :");
6763       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
6764       pdata->label = gtk_label_new ("");
6765       gtk_box_pack_start (GTK_BOX (hbox), pdata->label, FALSE, TRUE, 0);
6766
6767       frame = gtk_frame_new ("Options");
6768       gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
6769
6770       vbox2 = gtk_vbox_new (FALSE, 5);
6771       gtk_container_add (GTK_CONTAINER (frame), vbox2);
6772
6773       tab = gtk_table_new (7, 2, FALSE);
6774       gtk_box_pack_start (GTK_BOX (vbox2), tab, FALSE, TRUE, 0);
6775
6776       label = gtk_label_new ("Orientation :");
6777       gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 0, 1,
6778                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6779                         5, 5);
6780       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
6781
6782       pdata->omenu1 = build_option_menu (items1, 4, 0, pdata);
6783       hbox = gtk_hbox_new (FALSE, 0);
6784       gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 0, 1,
6785                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6786                         5, 5);
6787       gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu1, TRUE, TRUE, 0);
6788
6789       check = gtk_check_button_new_with_label ("Show text");
6790       gtk_signal_connect (GTK_OBJECT (check), "clicked",
6791                           GTK_SIGNAL_FUNC (toggle_show_text),
6792                           pdata);
6793       gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 1, 2,
6794                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6795                         5, 5);
6796
6797       hbox = gtk_hbox_new (FALSE, 0);
6798       gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 1, 2,
6799                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6800                         5, 5);
6801
6802       label = gtk_label_new ("Format : ");
6803       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
6804
6805       pdata->entry = gtk_entry_new ();
6806       gtk_signal_connect (GTK_OBJECT (pdata->entry), "changed",
6807                           GTK_SIGNAL_FUNC (entry_changed),
6808                           pdata);
6809       gtk_box_pack_start (GTK_BOX (hbox), pdata->entry, TRUE, TRUE, 0);
6810       gtk_entry_set_text (GTK_ENTRY (pdata->entry), "%v from [%l,%u] (=%p%%)");
6811       gtk_widget_set_usize (pdata->entry, 100, -1);
6812       gtk_widget_set_sensitive (pdata->entry, FALSE);
6813
6814       label = gtk_label_new ("Text align :");
6815       gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 2, 3,
6816                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6817                         5, 5);
6818       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
6819
6820       hbox = gtk_hbox_new (FALSE, 0);
6821       gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 2, 3,
6822                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6823                         5, 5);
6824
6825       label = gtk_label_new ("x :");
6826       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 5);
6827
6828       adj = (GtkAdjustment *) gtk_adjustment_new (0.5, 0, 1, 0.1, 0.1, 0);
6829       pdata->x_align_spin = gtk_spin_button_new (adj, 0, 1);
6830       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6831                           GTK_SIGNAL_FUNC (adjust_align), pdata);
6832       gtk_box_pack_start (GTK_BOX (hbox), pdata->x_align_spin, FALSE, TRUE, 0);
6833       gtk_widget_set_sensitive (pdata->x_align_spin, FALSE);
6834
6835       label = gtk_label_new ("y :");
6836       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 5);
6837
6838       adj = (GtkAdjustment *) gtk_adjustment_new (0.5, 0, 1, 0.1, 0.1, 0);
6839       pdata->y_align_spin = gtk_spin_button_new (adj, 0, 1);
6840       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6841                           GTK_SIGNAL_FUNC (adjust_align), pdata);
6842       gtk_box_pack_start (GTK_BOX (hbox), pdata->y_align_spin, FALSE, TRUE, 0);
6843       gtk_widget_set_sensitive (pdata->y_align_spin, FALSE);
6844
6845       label = gtk_label_new ("Bar Style :");
6846       gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 3, 4,
6847                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6848                         5, 5);
6849       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
6850
6851       pdata->omenu2 = build_option_menu (items2, 2, 0, pdata);
6852       hbox = gtk_hbox_new (FALSE, 0);
6853       gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 3, 4,
6854                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6855                         5, 5);
6856       gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu2, TRUE, TRUE, 0);
6857
6858       label = gtk_label_new ("Block count :");
6859       gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 4, 5,
6860                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6861                         5, 5);
6862       gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
6863
6864       hbox = gtk_hbox_new (FALSE, 0);
6865       gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 4, 5,
6866                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6867                         5, 5);
6868       adj = (GtkAdjustment *) gtk_adjustment_new (10, 2, 20, 1, 5, 0);
6869       pdata->block_spin = gtk_spin_button_new (adj, 0, 0);
6870       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6871                           GTK_SIGNAL_FUNC (adjust_blocks), pdata);
6872       gtk_box_pack_start (GTK_BOX (hbox), pdata->block_spin, FALSE, TRUE, 0);
6873       gtk_widget_set_sensitive (pdata->block_spin, FALSE);
6874
6875       check = gtk_check_button_new_with_label ("Activity mode");
6876       gtk_signal_connect (GTK_OBJECT (check), "clicked",
6877                           GTK_SIGNAL_FUNC (toggle_activity_mode),
6878                           pdata);
6879       gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 5, 6,
6880                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6881                         5, 5);
6882
6883       hbox = gtk_hbox_new (FALSE, 0);
6884       gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 5, 6,
6885                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6886                         5, 5);
6887       label = gtk_label_new ("Step size : ");
6888       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
6889       adj = (GtkAdjustment *) gtk_adjustment_new (3, 1, 20, 1, 5, 0);
6890       pdata->step_spin = gtk_spin_button_new (adj, 0, 0);
6891       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6892                           GTK_SIGNAL_FUNC (adjust_step), pdata);
6893       gtk_box_pack_start (GTK_BOX (hbox), pdata->step_spin, FALSE, TRUE, 0);
6894       gtk_widget_set_sensitive (pdata->step_spin, FALSE);
6895
6896       hbox = gtk_hbox_new (FALSE, 0);
6897       gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 6, 7,
6898                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6899                         5, 5);
6900       label = gtk_label_new ("Blocks :     ");
6901       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
6902       adj = (GtkAdjustment *) gtk_adjustment_new (5, 2, 10, 1, 5, 0);
6903       pdata->act_blocks_spin = gtk_spin_button_new (adj, 0, 0);
6904       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6905                           GTK_SIGNAL_FUNC (adjust_act_blocks), pdata);
6906       gtk_box_pack_start (GTK_BOX (hbox), pdata->act_blocks_spin, FALSE, TRUE,
6907                           0);
6908       gtk_widget_set_sensitive (pdata->act_blocks_spin, FALSE);
6909
6910       button = gtk_button_new_with_label ("close");
6911       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6912                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
6913                                  GTK_OBJECT (pdata->window));
6914       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6915       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pdata->window)->action_area),
6916                           button, TRUE, TRUE, 0);
6917       gtk_widget_grab_default (button);
6918     }
6919
6920   if (!GTK_WIDGET_VISIBLE (pdata->window))
6921     gtk_widget_show_all (pdata->window);
6922   else
6923     gtk_widget_destroy (pdata->window);
6924 }
6925
6926 /*
6927  * Color Preview
6928  */
6929
6930 static int color_idle = 0;
6931
6932 gint
6933 color_idle_func (GtkWidget *preview)
6934 {
6935   static int count = 1;
6936   guchar buf[768];
6937   int i, j, k;
6938
6939   for (i = 0; i < 256; i++)
6940     {
6941       for (j = 0, k = 0; j < 256; j++)
6942         {
6943           buf[k+0] = i + count;
6944           buf[k+1] = 0;
6945           buf[k+2] = j + count;
6946           k += 3;
6947         }
6948
6949       gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
6950     }
6951
6952   count += 1;
6953
6954   gtk_widget_draw (preview, NULL);
6955
6956   return TRUE;
6957 }
6958
6959 static void
6960 color_preview_destroy (GtkWidget  *widget,
6961                        GtkWidget **window)
6962 {
6963   gtk_idle_remove (color_idle);
6964   color_idle = 0;
6965
6966   *window = NULL;
6967 }
6968
6969 void
6970 create_color_preview (void)
6971 {
6972   static GtkWidget *window = NULL;
6973   GtkWidget *preview;
6974   guchar buf[768];
6975   int i, j, k;
6976
6977   if (!window)
6978     {
6979       gtk_widget_push_visual (gdk_rgb_get_visual ());
6980       gtk_widget_push_colormap (gdk_rgb_get_cmap ());
6981       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6982       gtk_widget_pop_colormap ();
6983       gtk_widget_pop_visual ();
6984
6985       gtk_signal_connect (GTK_OBJECT (window), "destroy",
6986                           GTK_SIGNAL_FUNC(color_preview_destroy),
6987                           &window);
6988
6989       gtk_window_set_title (GTK_WINDOW (window), "test");
6990       gtk_container_border_width (GTK_CONTAINER (window), 10);
6991
6992       preview = gtk_preview_new (GTK_PREVIEW_COLOR);
6993       gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
6994       gtk_container_add (GTK_CONTAINER (window), preview);
6995
6996       for (i = 0; i < 256; i++)
6997         {
6998           for (j = 0, k = 0; j < 256; j++)
6999             {
7000               buf[k+0] = i;
7001               buf[k+1] = 0;
7002               buf[k+2] = j;
7003               k += 3;
7004             }
7005
7006           gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
7007         }
7008
7009       color_idle = gtk_idle_add ((GtkFunction) color_idle_func, preview);
7010     }
7011
7012   if (!GTK_WIDGET_VISIBLE (window))
7013     gtk_widget_show_all (window);
7014   else
7015     gtk_widget_destroy (window);
7016 }
7017
7018 /*
7019  * Gray Preview
7020  */
7021
7022 static int gray_idle = 0;
7023
7024 gint
7025 gray_idle_func (GtkWidget *preview)
7026 {
7027   static int count = 1;
7028   guchar buf[256];
7029   int i, j;
7030
7031   for (i = 0; i < 256; i++)
7032     {
7033       for (j = 0; j < 256; j++)
7034         buf[j] = i + j + count;
7035
7036       gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
7037     }
7038
7039   count += 1;
7040
7041   gtk_widget_draw (preview, NULL);
7042
7043   return TRUE;
7044 }
7045
7046 static void
7047 gray_preview_destroy (GtkWidget  *widget,
7048                       GtkWidget **window)
7049 {
7050   gtk_idle_remove (gray_idle);
7051   gray_idle = 0;
7052
7053   *window = NULL;
7054 }
7055
7056 void
7057 create_gray_preview (void)
7058 {
7059   static GtkWidget *window = NULL;
7060   GtkWidget *preview;
7061   guchar buf[256];
7062   int i, j;
7063
7064   if (!window)
7065     {
7066       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7067
7068       gtk_signal_connect (GTK_OBJECT (window), "destroy",
7069                           GTK_SIGNAL_FUNC(gray_preview_destroy),
7070                           &window);
7071
7072       gtk_window_set_title (GTK_WINDOW (window), "test");
7073       gtk_container_border_width (GTK_CONTAINER (window), 10);
7074
7075       preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
7076       gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
7077       gtk_container_add (GTK_CONTAINER (window), preview);
7078
7079       for (i = 0; i < 256; i++)
7080         {
7081           for (j = 0; j < 256; j++)
7082             buf[j] = i + j;
7083
7084           gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
7085         }
7086
7087       gray_idle = gtk_idle_add ((GtkFunction) gray_idle_func, preview);
7088     }
7089
7090   if (!GTK_WIDGET_VISIBLE (window))
7091     gtk_widget_show_all (window);
7092   else
7093     gtk_widget_destroy (window);
7094 }
7095
7096
7097 /*
7098  * Selection Test
7099  */
7100
7101 void
7102 selection_test_received (GtkWidget *list, GtkSelectionData *data)
7103 {
7104   GdkAtom *atoms;
7105   GtkWidget *list_item;
7106   GList *item_list;
7107   int i, l;
7108
7109   if (data->length < 0)
7110     {
7111       g_print ("Selection retrieval failed\n");
7112       return;
7113     }
7114   if (data->type != GDK_SELECTION_TYPE_ATOM)
7115     {
7116       g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
7117       return;
7118     }
7119
7120   /* Clear out any current list items */
7121
7122   gtk_list_clear_items (GTK_LIST(list), 0, -1);
7123
7124   /* Add new items to list */
7125
7126   atoms = (GdkAtom *)data->data;
7127
7128   item_list = NULL;
7129   l = data->length / sizeof (GdkAtom);
7130   for (i = 0; i < l; i++)
7131     {
7132       char *name;
7133       name = gdk_atom_name (atoms[i]);
7134       if (name != NULL)
7135         {
7136           list_item = gtk_list_item_new_with_label (name);
7137           g_free (name);
7138         }
7139       else
7140         list_item = gtk_list_item_new_with_label ("(bad atom)");
7141
7142       gtk_widget_show (list_item);
7143       item_list = g_list_append (item_list, list_item);
7144     }
7145
7146   gtk_list_append_items (GTK_LIST (list), item_list);
7147
7148   return;
7149 }
7150
7151 void
7152 selection_test_get_targets (GtkWidget *widget, GtkWidget *list)
7153 {
7154   static GdkAtom targets_atom = GDK_NONE;
7155
7156   if (targets_atom == GDK_NONE)
7157     targets_atom = gdk_atom_intern ("TARGETS", FALSE);
7158
7159   gtk_selection_convert (list, GDK_SELECTION_PRIMARY, targets_atom,
7160                          GDK_CURRENT_TIME);
7161 }
7162
7163 void
7164 create_selection_test (void)
7165 {
7166   static GtkWidget *window = NULL;
7167   GtkWidget *button;
7168   GtkWidget *vbox;
7169   GtkWidget *scrolled_win;
7170   GtkWidget *list;
7171   GtkWidget *label;
7172
7173   if (!window)
7174     {
7175       window = gtk_dialog_new ();
7176
7177       gtk_signal_connect (GTK_OBJECT (window), "destroy",
7178                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7179                           &window);
7180
7181       gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
7182       gtk_container_border_width (GTK_CONTAINER (window), 0);
7183
7184       /* Create the list */
7185
7186       vbox = gtk_vbox_new (FALSE, 5);
7187       gtk_container_border_width (GTK_CONTAINER (vbox), 10);
7188       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox,
7189                           TRUE, TRUE, 0);
7190
7191       label = gtk_label_new ("Gets available targets for current selection");
7192       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
7193
7194       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
7195       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
7196                                       GTK_POLICY_AUTOMATIC,
7197                                       GTK_POLICY_AUTOMATIC);
7198       gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
7199       gtk_widget_set_usize (scrolled_win, 100, 200);
7200
7201       list = gtk_list_new ();
7202       gtk_container_add (GTK_CONTAINER (scrolled_win), list);
7203
7204       gtk_signal_connect (GTK_OBJECT(list), "selection_received",
7205                           GTK_SIGNAL_FUNC (selection_test_received), NULL);
7206
7207       /* .. And create some buttons */
7208       button = gtk_button_new_with_label ("Get Targets");
7209       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7210                           button, TRUE, TRUE, 0);
7211
7212       gtk_signal_connect (GTK_OBJECT (button), "clicked",
7213                           GTK_SIGNAL_FUNC (selection_test_get_targets), list);
7214
7215       button = gtk_button_new_with_label ("Quit");
7216       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7217                           button, TRUE, TRUE, 0);
7218
7219       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7220                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
7221                                  GTK_OBJECT (window));
7222     }
7223
7224   if (!GTK_WIDGET_VISIBLE (window))
7225     gtk_widget_show_all (window);
7226   else
7227     gtk_widget_destroy (window);
7228 }
7229
7230 /*
7231  * Gamma Curve
7232  */
7233
7234 void
7235 create_gamma_curve (void)
7236 {
7237   static GtkWidget *window = NULL, *curve;
7238   static int count = 0;
7239   gfloat vec[256];
7240   gint max;
7241   gint i;
7242
7243   if (!window)
7244     {
7245       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7246       gtk_window_set_title (GTK_WINDOW (window), "test");
7247       gtk_container_border_width (GTK_CONTAINER (window), 10);
7248
7249       gtk_signal_connect (GTK_OBJECT (window), "destroy",
7250                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7251                           &window);
7252
7253       curve = gtk_gamma_curve_new ();
7254       gtk_container_add (GTK_CONTAINER (window), curve);
7255       gtk_widget_show (curve);
7256     }
7257
7258   max = 127 + (count % 2)*128;
7259   gtk_curve_set_range (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
7260                        0, max, 0, max);
7261   for (i = 0; i < max; ++i)
7262     vec[i] = (127 / sqrt (max)) * sqrt (i);
7263   gtk_curve_set_vector (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
7264                         max, vec);
7265
7266   if (!GTK_WIDGET_VISIBLE (window))
7267     gtk_widget_show (window);
7268   else if (count % 4 == 3)
7269     {
7270       gtk_widget_destroy (window);
7271       window = NULL;
7272     }
7273
7274   ++count;
7275 }
7276
7277 /*
7278  * Test scrolling
7279  */
7280
7281 static int scroll_test_pos = 0.0;
7282 static GdkGC *scroll_test_gc = NULL;
7283
7284 static gint
7285 scroll_test_expose (GtkWidget *widget, GdkEventExpose *event,
7286                     GtkAdjustment *adj)
7287 {
7288   gint i,j;
7289   gint imin, imax, jmin, jmax;
7290
7291   imin = (event->area.x) / 10;
7292   imax = (event->area.x + event->area.width + 9) / 10;
7293
7294   jmin = ((int)adj->value + event->area.y) / 10;
7295   jmax = ((int)adj->value + event->area.y + event->area.height + 9) / 10;
7296
7297   gdk_window_clear_area (widget->window,
7298                          event->area.x, event->area.y,
7299                          event->area.width, event->area.height);
7300
7301   for (i=imin; i<imax; i++)
7302     for (j=jmin; j<jmax; j++)
7303       if ((i+j) % 2)
7304         gdk_draw_rectangle (widget->window,
7305                             widget->style->black_gc,
7306                             TRUE,
7307                             10*i, 10*j - (int)adj->value, 1+i%10, 1+j%10);
7308
7309   return TRUE;
7310 }
7311
7312 static void
7313 scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
7314                        GtkAdjustment *adj)
7315 {
7316   adj->page_increment = 0.9 * widget->allocation.height;
7317   adj->page_size = widget->allocation.height;
7318
7319   gtk_signal_emit_by_name (GTK_OBJECT (adj), "changed");
7320 }
7321
7322 static void
7323 scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
7324 {
7325   gint source_min = (int)adj->value - scroll_test_pos;
7326   gint source_max = source_min + widget->allocation.height;
7327   gint dest_min = 0;
7328   gint dest_max = widget->allocation.height;
7329   GdkRectangle rect;
7330   GdkEvent *event;
7331
7332   scroll_test_pos = adj->value;
7333
7334   if (!GTK_WIDGET_DRAWABLE (widget))
7335     return;
7336
7337   if (source_min < 0)
7338     {
7339       rect.x = 0;
7340       rect.y = 0;
7341       rect.width = widget->allocation.width;
7342       rect.height = -source_min;
7343       if (rect.height > widget->allocation.height)
7344         rect.height = widget->allocation.height;
7345
7346       source_min = 0;
7347       dest_min = rect.height;
7348     }
7349   else
7350     {
7351       rect.x = 0;
7352       rect.y = 2*widget->allocation.height - source_max;
7353       if (rect.y < 0)
7354         rect.y = 0;
7355       rect.width = widget->allocation.width;
7356       rect.height = widget->allocation.height - rect.y;
7357
7358       source_max = widget->allocation.height;
7359       dest_max = rect.y;
7360     }
7361
7362   if (source_min != source_max)
7363     {
7364       if (scroll_test_gc == NULL)
7365         {
7366           scroll_test_gc = gdk_gc_new (widget->window);
7367           gdk_gc_set_exposures (scroll_test_gc, TRUE);
7368         }
7369
7370       gdk_draw_pixmap (widget->window,
7371                        scroll_test_gc,
7372                        widget->window,
7373                        0, source_min,
7374                        0, dest_min,
7375                        widget->allocation.width,
7376                        source_max - source_min);
7377
7378       /* Make sure graphics expose events are processed before scrolling
7379        * again */
7380
7381       while ((event = gdk_event_get_graphics_expose (widget->window)) != NULL)
7382         {
7383           gtk_widget_event (widget, event);
7384           if (event->expose.count == 0)
7385             {
7386               gdk_event_free (event);
7387               break;
7388             }
7389           gdk_event_free (event);
7390         }
7391     }
7392
7393   if (rect.height != 0)
7394     gtk_widget_draw (widget, &rect);
7395 }
7396
7397
7398 void
7399 create_scroll_test (void)
7400 {
7401   static GtkWidget *window = NULL;
7402   GtkWidget *hbox;
7403   GtkWidget *drawing_area;
7404   GtkWidget *scrollbar;
7405   GtkWidget *button;
7406   GtkAdjustment *adj;
7407
7408   if (!window)
7409     {
7410       window = gtk_dialog_new ();
7411
7412       gtk_signal_connect (GTK_OBJECT (window), "destroy",
7413                           GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7414                           &window);
7415
7416       gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
7417       gtk_container_border_width (GTK_CONTAINER (window), 0);
7418
7419       hbox = gtk_hbox_new (FALSE, 0);
7420       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox,
7421                           TRUE, TRUE, 0);
7422       gtk_widget_show (hbox);
7423
7424       drawing_area = gtk_drawing_area_new ();
7425       gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 200, 200);
7426       gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
7427       gtk_widget_show (drawing_area);
7428
7429       gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK);
7430
7431       adj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0));
7432       scroll_test_pos = 0.0;
7433
7434       scrollbar = gtk_vscrollbar_new (adj);
7435       gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
7436       gtk_widget_show (scrollbar);
7437
7438       gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
7439                           GTK_SIGNAL_FUNC (scroll_test_expose), adj);
7440       gtk_signal_connect (GTK_OBJECT (drawing_area), "configure_event",
7441                           GTK_SIGNAL_FUNC (scroll_test_configure), adj);
7442
7443
7444       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7445                           GTK_SIGNAL_FUNC (scroll_test_adjustment_changed),
7446                           drawing_area);
7447
7448       /* .. And create some buttons */
7449
7450       button = gtk_button_new_with_label ("Quit");
7451       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7452                           button, TRUE, TRUE, 0);
7453
7454       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7455                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
7456                                  GTK_OBJECT (window));
7457       gtk_widget_show (button);
7458     }
7459
7460   if (!GTK_WIDGET_VISIBLE (window))
7461     gtk_widget_show (window);
7462   else
7463     gtk_widget_destroy (window);
7464 }
7465
7466 /*
7467  * Timeout Test
7468  */
7469
7470 static int timer = 0;
7471
7472 gint
7473 timeout_test (GtkWidget *label)
7474 {
7475   static int count = 0;
7476   static char buffer[32];
7477
7478   sprintf (buffer, "count: %d", ++count);
7479   gtk_label_set (GTK_LABEL (label), buffer);
7480
7481   return TRUE;
7482 }
7483
7484 void
7485 start_timeout_test (GtkWidget *widget,
7486                     GtkWidget *label)
7487 {
7488   if (!timer)
7489     {
7490       timer = gtk_timeout_add (100, (GtkFunction) timeout_test, label);
7491     }
7492 }
7493
7494 void
7495 stop_timeout_test (GtkWidget *widget,
7496                    gpointer   data)
7497 {
7498   if (timer)
7499     {
7500       gtk_timeout_remove (timer);
7501       timer = 0;
7502     }
7503 }
7504
7505 void
7506 destroy_timeout_test (GtkWidget  *widget,
7507                       GtkWidget **window)
7508 {
7509   stop_timeout_test (NULL, NULL);
7510
7511   *window = NULL;
7512 }
7513
7514 void
7515 create_timeout_test (void)
7516 {
7517   static GtkWidget *window = NULL;
7518   GtkWidget *button;
7519   GtkWidget *label;
7520
7521   if (!window)
7522     {
7523       window = gtk_dialog_new ();
7524
7525       gtk_signal_connect (GTK_OBJECT (window), "destroy",
7526                           GTK_SIGNAL_FUNC(destroy_timeout_test),
7527                           &window);
7528
7529       gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
7530       gtk_container_border_width (GTK_CONTAINER (window), 0);
7531
7532       label = gtk_label_new ("count: 0");
7533       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
7534       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
7535                           label, TRUE, TRUE, 0);
7536       gtk_widget_show (label);
7537
7538       button = gtk_button_new_with_label ("close");
7539       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7540                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
7541                                  GTK_OBJECT (window));
7542       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7543       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7544                           button, TRUE, TRUE, 0);
7545       gtk_widget_grab_default (button);
7546       gtk_widget_show (button);
7547
7548       button = gtk_button_new_with_label ("start");
7549       gtk_signal_connect (GTK_OBJECT (button), "clicked",
7550                           GTK_SIGNAL_FUNC(start_timeout_test),
7551                           label);
7552       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7553       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7554                           button, TRUE, TRUE, 0);
7555       gtk_widget_show (button);
7556
7557       button = gtk_button_new_with_label ("stop");
7558       gtk_signal_connect (GTK_OBJECT (button), "clicked",
7559                           GTK_SIGNAL_FUNC(stop_timeout_test),
7560                           NULL);
7561       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7562       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7563                           button, TRUE, TRUE, 0);
7564       gtk_widget_show (button);
7565     }
7566
7567   if (!GTK_WIDGET_VISIBLE (window))
7568     gtk_widget_show (window);
7569   else
7570     gtk_widget_destroy (window);
7571 }
7572
7573 /*
7574  * Idle Test
7575  */
7576
7577 static int idle = 0;
7578
7579 static gint
7580 idle_test (GtkWidget *label)
7581 {
7582   static int count = 0;
7583   static char buffer[32];
7584
7585   sprintf (buffer, "count: %d", ++count);
7586   gtk_label_set (GTK_LABEL (label), buffer);
7587
7588   return TRUE;
7589 }
7590
7591 static void
7592 start_idle_test (GtkWidget *widget,
7593                  GtkWidget *label)
7594 {
7595   if (!idle)
7596     {
7597       idle = gtk_idle_add ((GtkFunction) idle_test, label);
7598     }
7599 }
7600
7601 static void
7602 stop_idle_test (GtkWidget *widget,
7603                 gpointer   data)
7604 {
7605   if (idle)
7606     {
7607       gtk_idle_remove (idle);
7608       idle = 0;
7609     }
7610 }
7611
7612 static void
7613 destroy_idle_test (GtkWidget  *widget,
7614                    GtkWidget **window)
7615 {
7616   stop_idle_test (NULL, NULL);
7617
7618   *window = NULL;
7619 }
7620
7621 static void
7622 toggle_idle_container (GtkObject *button,
7623                        GtkContainer *container)
7624 {
7625   gtk_container_set_resize_mode (container, (guint) gtk_object_get_user_data (button));
7626 }
7627
7628 static void
7629 create_idle_test (void)
7630 {
7631   static GtkWidget *window = NULL;
7632   GtkWidget *button;
7633   GtkWidget *label;
7634   GtkWidget *container;
7635
7636   if (!window)
7637     {
7638       GtkWidget *frame;
7639       GtkWidget *box;
7640
7641       window = gtk_dialog_new ();
7642
7643       gtk_signal_connect (GTK_OBJECT (window), "destroy",
7644                           GTK_SIGNAL_FUNC(destroy_idle_test),
7645                           &window);
7646
7647       gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
7648       gtk_container_border_width (GTK_CONTAINER (window), 0);
7649
7650       label = gtk_label_new ("count: 0");
7651       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
7652       gtk_widget_show (label);
7653
7654       container =
7655         gtk_widget_new (GTK_TYPE_HBOX,
7656                         "GtkWidget::visible", TRUE,
7657                         /* "GtkContainer::child", gtk_widget_new (GTK_TYPE_HBOX,
7658                          * "GtkWidget::visible", TRUE,
7659                          */
7660                          "GtkContainer::child", label,
7661                         /* NULL), */
7662                         NULL);
7663       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
7664                           container, TRUE, TRUE, 0);
7665
7666       frame =
7667         gtk_widget_new (GTK_TYPE_FRAME,
7668                         "GtkContainer::border_width", 5,
7669                         "GtkFrame::label", "Label Container",
7670                         "GtkWidget::visible", TRUE,
7671                         "GtkWidget::parent", GTK_DIALOG (window)->vbox,
7672                         NULL);
7673       box =
7674         gtk_widget_new (GTK_TYPE_VBOX,
7675                         "GtkWidget::visible", TRUE,
7676                         "GtkWidget::parent", frame,
7677                         NULL);
7678       button =
7679         gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
7680                         "GtkButton::label", "Resize-Parent",
7681                         "GtkObject::user_data", (void*)GTK_RESIZE_PARENT,
7682                         "GtkObject::signal::clicked", toggle_idle_container, container,
7683                         "GtkWidget::visible", TRUE,
7684                         "GtkWidget::parent", box,
7685                         NULL);
7686       button =
7687         gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
7688                         "GtkButton::label", "Resize-Queue",
7689                         "GtkObject::user_data", (void*)GTK_RESIZE_QUEUE,
7690                         "GtkObject::signal::clicked", toggle_idle_container, container,
7691                         "GtkRadioButton::group", button,
7692                         "GtkWidget::visible", TRUE,
7693                         "GtkWidget::parent", box,
7694                         NULL);
7695       button =
7696         gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
7697                         "GtkButton::label", "Resize-Immediate",
7698                         "GtkObject::user_data", (void*)GTK_RESIZE_IMMEDIATE,
7699                         "GtkObject::signal::clicked", toggle_idle_container, container,
7700                         "GtkRadioButton::group", button,
7701                         "GtkWidget::visible", TRUE,
7702                         "GtkWidget::parent", box,
7703                         NULL);
7704
7705
7706       button = gtk_button_new_with_label ("close");
7707       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7708                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
7709                                  GTK_OBJECT (window));
7710       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7711       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7712                           button, TRUE, TRUE, 0);
7713       gtk_widget_grab_default (button);
7714       gtk_widget_show (button);
7715
7716       button = gtk_button_new_with_label ("start");
7717       gtk_signal_connect (GTK_OBJECT (button), "clicked",
7718                           GTK_SIGNAL_FUNC(start_idle_test),
7719                           label);
7720       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7721       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7722                           button, TRUE, TRUE, 0);
7723       gtk_widget_show (button);
7724
7725       button = gtk_button_new_with_label ("stop");
7726       gtk_signal_connect (GTK_OBJECT (button), "clicked",
7727                           GTK_SIGNAL_FUNC(stop_idle_test),
7728                           NULL);
7729       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7730       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7731                           button, TRUE, TRUE, 0);
7732       gtk_widget_show (button);
7733     }
7734
7735   if (!GTK_WIDGET_VISIBLE (window))
7736     gtk_widget_show (window);
7737   else
7738     gtk_widget_destroy (window);
7739 }
7740
7741 /*
7742  * rc file test
7743  */
7744
7745 void
7746 reload_rc_file (void)
7747 {
7748   GList *toplevels;
7749
7750   if (gtk_rc_reparse_all ())
7751     {
7752       toplevels = gdk_window_get_toplevels();
7753       while (toplevels)
7754         {
7755           GtkWidget *widget;
7756           gdk_window_get_user_data (toplevels->data, (gpointer *)&widget);
7757
7758           if (widget)
7759             gtk_widget_reset_rc_styles (widget);
7760
7761           toplevels = toplevels->next;
7762         }
7763       g_list_free (toplevels);
7764     }
7765 }
7766
7767 void
7768 reload_all_rc_files (void)
7769 {
7770   static GdkAtom atom_rcfiles = GDK_NONE;
7771
7772   GdkEventClient sev;
7773   int i;
7774
7775   if (!atom_rcfiles)
7776     atom_rcfiles = gdk_atom_intern("_GTK_READ_RCFILES", FALSE);
7777
7778   for(i = 0; i < 5; i++)
7779     sev.data.l[i] = 0;
7780   sev.data_format = 32;
7781   sev.message_type = atom_rcfiles;
7782   gdk_event_send_clientmessage_toall ((GdkEvent *) &sev);
7783 }
7784
7785 void
7786 create_rc_file (void)
7787 {
7788   static GtkWidget *window = NULL;
7789   GtkWidget *button;
7790
7791   if (!window)
7792     {
7793       window = gtk_dialog_new ();
7794
7795       gtk_signal_connect (GTK_OBJECT (window), "destroy",
7796                           GTK_SIGNAL_FUNC(destroy_idle_test),
7797                           &window);
7798
7799       gtk_window_set_title (GTK_WINDOW (window), "Reload Rc file");
7800       gtk_container_border_width (GTK_CONTAINER (window), 0);
7801
7802       button = gtk_button_new_with_label ("Reload");
7803       gtk_signal_connect (GTK_OBJECT (button), "clicked",
7804                           GTK_SIGNAL_FUNC(reload_rc_file), NULL);
7805       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7806       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7807                           button, TRUE, TRUE, 0);
7808       gtk_widget_grab_default (button);
7809       gtk_widget_show (button);
7810
7811       button = gtk_button_new_with_label ("Reload All");
7812       gtk_signal_connect (GTK_OBJECT (button), "clicked",
7813                           GTK_SIGNAL_FUNC(reload_all_rc_files), NULL);
7814       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7815       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7816                           button, TRUE, TRUE, 0);
7817       gtk_widget_show (button);
7818
7819       button = gtk_button_new_with_label ("Close");
7820       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7821                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
7822                                  GTK_OBJECT (window));
7823       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7824       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7825                           button, TRUE, TRUE, 0);
7826       gtk_widget_show (button);
7827
7828     }
7829
7830   if (!GTK_WIDGET_VISIBLE (window))
7831     gtk_widget_show (window);
7832   else
7833     gtk_widget_destroy (window);
7834 }
7835
7836 /*
7837  * Test of recursive mainloop
7838  */
7839
7840 void
7841 mainloop_destroyed (GtkWidget *w, GtkWidget **window)
7842 {
7843   *window = NULL;
7844   gtk_main_quit ();
7845 }
7846
7847 void
7848 create_mainloop (void)
7849 {
7850   static GtkWidget *window = NULL;
7851   GtkWidget *label;
7852   GtkWidget *button;
7853
7854   if (!window)
7855     {
7856       window = gtk_dialog_new ();
7857
7858       gtk_window_set_title (GTK_WINDOW (window), "Test Main Loop");
7859
7860       gtk_signal_connect (GTK_OBJECT (window), "destroy",
7861                           GTK_SIGNAL_FUNC(mainloop_destroyed),
7862                           &window);
7863
7864       label = gtk_label_new ("In recursive main loop...");
7865       gtk_misc_set_padding (GTK_MISC(label), 20, 20);
7866
7867       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), label,
7868                           TRUE, TRUE, 0);
7869       gtk_widget_show (label);
7870
7871       button = gtk_button_new_with_label ("Leave");
7872       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button,
7873                           FALSE, TRUE, 0);
7874
7875       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7876                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
7877                                  GTK_OBJECT (window));
7878
7879       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7880       gtk_widget_grab_default (button);
7881
7882       gtk_widget_show (button);
7883     }
7884
7885   if (!GTK_WIDGET_VISIBLE (window))
7886     {
7887       gtk_widget_show (window);
7888
7889       g_print ("create_mainloop: start\n");
7890       gtk_main ();
7891       g_print ("create_mainloop: done\n");
7892     }
7893   else
7894     gtk_widget_destroy (window);
7895 }
7896
7897 /*
7898  * Main Window and Exit
7899  */
7900
7901 void
7902 do_exit (GtkWidget *widget, GtkWidget *window)
7903 {
7904   gtk_widget_destroy (window);
7905   gtk_main_quit ();
7906 }
7907
7908 void
7909 create_main_window (void)
7910 {
7911   struct {
7912     char *label;
7913     void (*func) ();
7914   } buttons[] =
7915     {
7916       { "button box", create_button_box },
7917       { "buttons", create_buttons },
7918       { "check buttons", create_check_buttons },
7919       { "clist", create_clist},
7920       { "color selection", create_color_selection },
7921       { "ctree", create_ctree },
7922       { "cursors", create_cursors },
7923       { "dialog", create_dialog },
7924       /*      { "dnd", create_dnd }, */
7925       { "entry", create_entry },
7926       { "file selection", create_file_selection },
7927       { "font selection", create_font_selection },
7928       { "gamma curve", create_gamma_curve },
7929       { "handle box", create_handle_box },
7930       { "item factory", create_item_factory },
7931       { "list", create_list },
7932       { "menus", create_menus },
7933       { "modal window", create_modal_window },
7934       { "notebook", create_notebook },
7935       { "panes", create_panes },
7936       { "pixmap", create_pixmap },
7937       { "preview color", create_color_preview },
7938       { "preview gray", create_gray_preview },
7939       { "progress bar", create_progress_bar },
7940       { "radio buttons", create_radio_buttons },
7941       { "range controls", create_range_controls },
7942       { "rc file", create_rc_file },
7943       { "reparent", create_reparent },
7944       { "rulers", create_rulers },
7945       { "saved position", create_saved_position },
7946       { "scrolled windows", create_scrolled_windows },
7947       { "shapes", create_shapes },
7948       { "spinbutton", create_spins },
7949       { "statusbar", create_statusbar },
7950       { "test idle", create_idle_test },
7951       { "test mainloop", create_mainloop },
7952       { "test scrolling", create_scroll_test },
7953       { "test selection", create_selection_test },
7954       { "test timeout", create_timeout_test },
7955       { "text", create_text },
7956       { "toggle buttons", create_toggle_buttons },
7957       { "toolbar", create_toolbar },
7958       { "tooltips", create_tooltips },
7959       { "tree", create_tree_mode_window},
7960       { "WM hints", create_wmhints },
7961     };
7962   int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
7963   GtkWidget *window;
7964   GtkWidget *box1;
7965   GtkWidget *box2;
7966   GtkWidget *scrolled_window;
7967   GtkWidget *button;
7968   GtkWidget *label;
7969   gchar buffer[64];
7970   GtkWidget *separator;
7971   int i;
7972
7973   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7974   gtk_window_set_policy (GTK_WINDOW (window), FALSE, FALSE, FALSE);
7975   gtk_widget_set_name (window, "main window");
7976   gtk_widget_set_usize (window, 200, 400);
7977   gtk_widget_set_uposition (window, 20, 20);
7978
7979   gtk_signal_connect (GTK_OBJECT (window), "destroy",
7980                       GTK_SIGNAL_FUNC(gtk_main_quit),
7981                       NULL);
7982   gtk_signal_connect (GTK_OBJECT (window), "delete-event",
7983                       GTK_SIGNAL_FUNC (gtk_false),
7984                       NULL);
7985
7986   box1 = gtk_vbox_new (FALSE, 0);
7987   gtk_container_add (GTK_CONTAINER (window), box1);
7988
7989   if (gtk_micro_version > 0)
7990     sprintf (buffer,
7991              "Gtk+ v%d.%d.%d",
7992              gtk_major_version,
7993              gtk_minor_version,
7994              gtk_micro_version);
7995   else
7996     sprintf (buffer,
7997              "Gtk+ v%d.%d",
7998              gtk_major_version,
7999              gtk_minor_version);
8000
8001   label = gtk_label_new (buffer);
8002   gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
8003
8004   scrolled_window = gtk_scrolled_window_new (NULL, NULL);
8005   gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
8006   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
8007                                   GTK_POLICY_AUTOMATIC,
8008                                   GTK_POLICY_AUTOMATIC);
8009   gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
8010
8011   box2 = gtk_vbox_new (FALSE, 0);
8012   gtk_container_border_width (GTK_CONTAINER (box2), 10);
8013   gtk_container_add (GTK_CONTAINER (scrolled_window), box2);
8014   gtk_container_set_focus_vadjustment (GTK_CONTAINER (box2),
8015                                        gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
8016   gtk_widget_show (box2);
8017
8018   for (i = 0; i < nbuttons; i++)
8019     {
8020       button = gtk_button_new_with_label (buttons[i].label);
8021       if (buttons[i].func)
8022         gtk_signal_connect (GTK_OBJECT (button),
8023                             "clicked",
8024                             GTK_SIGNAL_FUNC(buttons[i].func),
8025                             NULL);
8026       else
8027         gtk_widget_set_sensitive (button, FALSE);
8028       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
8029     }
8030
8031   separator = gtk_hseparator_new ();
8032   gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
8033
8034   box2 = gtk_vbox_new (FALSE, 10);
8035   gtk_container_border_width (GTK_CONTAINER (box2), 10);
8036   gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
8037
8038   button = gtk_button_new_with_label ("close");
8039   gtk_signal_connect (GTK_OBJECT (button), "clicked",
8040                       GTK_SIGNAL_FUNC (do_exit),
8041                       window);
8042   gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
8043   GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8044   gtk_widget_grab_default (button);
8045
8046   gtk_widget_show_all (window);
8047 }
8048
8049 int
8050 main (int argc, char *argv[])
8051 {
8052   GtkBindingSet *binding_set;
8053
8054   srand (time (NULL));
8055
8056   gtk_set_locale ();
8057
8058   gtk_init (&argc, &argv);
8059
8060   gdk_rgb_init ();
8061
8062   /* bindings test
8063    */
8064   binding_set = gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_WIDGET));
8065   gtk_binding_entry_add_signal (binding_set,
8066                                 '9', GDK_CONTROL_MASK | GDK_RELEASE_MASK,
8067                                 "debug_msg",
8068                                 1,
8069                                 GTK_TYPE_STRING, "GtkWidgetClass <ctrl><release>9 test");
8070
8071   gtk_rc_parse ("testgtkrc");
8072
8073   create_main_window ();
8074
8075   gtk_main ();
8076
8077   return 0;
8078 }