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