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

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