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 Free
  16  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include "gtk.h"
  21 #include "../gdk/gdk.h"
  22 #include "../gdk/gdkx.h"
  23
  24 void
  25 destroy_window (GtkWidget  *widget,
  26                 GtkWidget **window)
  27 {
  28   *window = NULL;
  29 }
  30
  31 static void
  32 destroy_tooltips (GtkWidget *widget, GtkWindow **window)
  33 {
  34   GtkTooltips *tt = gtk_object_get_data (GTK_OBJECT (*window), "tooltips");
  35   gtk_object_unref (GTK_OBJECT (tt));
  36
  37   *window = NULL;
  38 }
  39
  40 static void
  41 button_window (GtkWidget *widget,
  42                GtkWidget *button)
  43 {
  44   if (!GTK_WIDGET_VISIBLE (button))
  45     gtk_widget_show (button);
  46   else
  47     gtk_widget_hide (button);
  48 }
  49
  50 static void
  51 create_buttons ()
  52 {
  53   static GtkWidget *window = NULL;
  54   GtkWidget *box1;
  55   GtkWidget *box2;
  56   GtkWidget *table;
  57   GtkWidget *button[10];
  58   GtkWidget *separator;
  59
  60   if (!window)
  61     {
  62       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  63
  64       gtk_signal_connect (GTK_OBJECT (window), "destroy",
  65                           GTK_SIGNAL_FUNC (destroy_window),
  66                           &window);
  67       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
  68                           GTK_SIGNAL_FUNC (gtk_true),
  69                           &window);
  70
  71       gtk_window_set_title (GTK_WINDOW (window), "buttons");
  72       gtk_container_border_width (GTK_CONTAINER (window), 0);
  73
  74       box1 = gtk_vbox_new (FALSE, 0);
  75       gtk_container_add (GTK_CONTAINER (window), box1);
  76       gtk_widget_show (box1);
  77
  78
  79       table = gtk_table_new (3, 3, FALSE);
  80       gtk_table_set_row_spacings (GTK_TABLE (table), 5);
  81       gtk_table_set_col_spacings (GTK_TABLE (table), 5);
  82       gtk_container_border_width (GTK_CONTAINER (table), 10);
  83       gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
  84       gtk_widget_show (table);
  85
  86
  87       button[0] = gtk_button_new_with_label ("button1");
  88       button[1] = gtk_button_new_with_label ("button2");
  89       button[2] = gtk_button_new_with_label ("button3");
  90       button[3] = gtk_button_new_with_label ("button4");
  91       button[4] = gtk_button_new_with_label ("button5");
  92       button[5] = gtk_button_new_with_label ("button6");
  93       button[6] = gtk_button_new_with_label ("button7");
  94       button[7] = gtk_button_new_with_label ("button8");
  95       button[8] = gtk_button_new_with_label ("button9");
  96
  97       gtk_signal_connect (GTK_OBJECT (button[0]), "clicked",
  98                           GTK_SIGNAL_FUNC(button_window),
  99                           button[1]);
 100
 101       gtk_table_attach (GTK_TABLE (table), button[0], 0, 1, 0, 1,
 102                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 103       gtk_widget_show (button[0]);
 104
 105       gtk_signal_connect (GTK_OBJECT (button[1]), "clicked",
 106                           GTK_SIGNAL_FUNC(button_window),
 107                           button[2]);
 108
 109       gtk_table_attach (GTK_TABLE (table), button[1], 1, 2, 1, 2,
 110                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 111       gtk_widget_show (button[1]);
 112
 113       gtk_signal_connect (GTK_OBJECT (button[2]), "clicked",
 114                           GTK_SIGNAL_FUNC(button_window),
 115                           button[3]);
 116       gtk_table_attach (GTK_TABLE (table), button[2], 2, 3, 2, 3,
 117                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 118       gtk_widget_show (button[2]);
 119
 120       gtk_signal_connect (GTK_OBJECT (button[3]), "clicked",
 121                           GTK_SIGNAL_FUNC(button_window),
 122                           button[4]);
 123       gtk_table_attach (GTK_TABLE (table), button[3], 0, 1, 2, 3,
 124                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 125       gtk_widget_show (button[3]);
 126
 127       gtk_signal_connect (GTK_OBJECT (button[4]), "clicked",
 128                           GTK_SIGNAL_FUNC(button_window),
 129                           button[5]);
 130       gtk_table_attach (GTK_TABLE (table), button[4], 2, 3, 0, 1,
 131                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 132       gtk_widget_show (button[4]);
 133
 134       gtk_signal_connect (GTK_OBJECT (button[5]), "clicked",
 135                           GTK_SIGNAL_FUNC(button_window),
 136                           button[6]);
 137       gtk_table_attach (GTK_TABLE (table), button[5], 1, 2, 2, 3,
 138                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 139       gtk_widget_show (button[5]);
 140
 141       gtk_signal_connect (GTK_OBJECT (button[6]), "clicked",
 142                           GTK_SIGNAL_FUNC(button_window),
 143                           button[7]);
 144       gtk_table_attach (GTK_TABLE (table), button[6], 1, 2, 0, 1,
 145                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 146       gtk_widget_show (button[6]);
 147
 148       gtk_signal_connect (GTK_OBJECT (button[7]), "clicked",
 149                           GTK_SIGNAL_FUNC(button_window),
 150                           button[8]);
 151       gtk_table_attach (GTK_TABLE (table), button[7], 2, 3, 1, 2,
 152                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 153       gtk_widget_show (button[7]);
 154
 155       gtk_signal_connect (GTK_OBJECT (button[8]), "clicked",
 156                           GTK_SIGNAL_FUNC(button_window),
 157                           button[0]);
 158       gtk_table_attach (GTK_TABLE (table), button[8], 0, 1, 1, 2,
 159                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 160       gtk_widget_show (button[8]);
 161
 162
 163       separator = gtk_hseparator_new ();
 164       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 165       gtk_widget_show (separator);
 166
 167
 168       box2 = gtk_vbox_new (FALSE, 10);
 169       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 170       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 171       gtk_widget_show (box2);
 172
 173
 174       button[9] = gtk_button_new_with_label ("close");
 175       gtk_signal_connect_object (GTK_OBJECT (button[9]), "clicked",
 176                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
 177                                  GTK_OBJECT (window));
 178       gtk_box_pack_start (GTK_BOX (box2), button[9], TRUE, TRUE, 0);
 179       GTK_WIDGET_SET_FLAGS (button[9], GTK_CAN_DEFAULT);
 180       gtk_widget_grab_default (button[9]);
 181       gtk_widget_show (button[9]);
 182     }
 183
 184   if (!GTK_WIDGET_VISIBLE (window))
 185     gtk_widget_show (window);
 186   else
 187     gtk_widget_destroy (window);
 188 }
 189
 190 static void
 191 create_toggle_buttons ()
 192 {
 193   static GtkWidget *window = NULL;
 194   GtkWidget *box1;
 195   GtkWidget *box2;
 196   GtkWidget *button;
 197   GtkWidget *separator;
 198
 199   if (!window)
 200     {
 201       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 202
 203       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 204                           GTK_SIGNAL_FUNC(destroy_window),
 205                           &window);
 206       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
 207                           GTK_SIGNAL_FUNC(destroy_window),
 208                           &window);
 209
 210       gtk_window_set_title (GTK_WINDOW (window), "toggle buttons");
 211       gtk_container_border_width (GTK_CONTAINER (window), 0);
 212
 213
 214       box1 = gtk_vbox_new (FALSE, 0);
 215       gtk_container_add (GTK_CONTAINER (window), box1);
 216       gtk_widget_show (box1);
 217
 218
 219       box2 = gtk_vbox_new (FALSE, 10);
 220       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 221       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
 222       gtk_widget_show (box2);
 223
 224
 225       button = gtk_toggle_button_new_with_label ("button1");
 226       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 227       gtk_widget_show (button);
 228
 229       button = gtk_toggle_button_new_with_label ("button2");
 230       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 231       gtk_widget_show (button);
 232
 233       button = gtk_toggle_button_new_with_label ("button3");
 234       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 235       gtk_widget_show (button);
 236
 237
 238       separator = gtk_hseparator_new ();
 239       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 240       gtk_widget_show (separator);
 241
 242
 243       box2 = gtk_vbox_new (FALSE, 10);
 244       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 245       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 246       gtk_widget_show (box2);
 247
 248
 249       button = gtk_button_new_with_label ("close");
 250       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
 251                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
 252                                  GTK_OBJECT (window));
 253       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 254       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 255       gtk_widget_grab_default (button);
 256       gtk_widget_show (button);
 257     }
 258
 259   if (!GTK_WIDGET_VISIBLE (window))
 260     gtk_widget_show (window);
 261   else
 262     gtk_widget_destroy (window);
 263 }
 264
 265 static void
 266 create_check_buttons ()
 267 {
 268   static GtkWidget *window = NULL;
 269   GtkWidget *box1;
 270   GtkWidget *box2;
 271   GtkWidget *button;
 272   GtkWidget *separator;
 273
 274   if (!window)
 275     {
 276       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 277
 278       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 279                           GTK_SIGNAL_FUNC(destroy_window),
 280                           &window);
 281       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
 282                           GTK_SIGNAL_FUNC(destroy_window),
 283                           &window);
 284
 285       gtk_window_set_title (GTK_WINDOW (window), "check buttons");
 286       gtk_container_border_width (GTK_CONTAINER (window), 0);
 287
 288
 289       box1 = gtk_vbox_new (FALSE, 0);
 290       gtk_container_add (GTK_CONTAINER (window), box1);
 291       gtk_widget_show (box1);
 292
 293
 294       box2 = gtk_vbox_new (FALSE, 10);
 295       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 296       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
 297       gtk_widget_show (box2);
 298
 299
 300       button = gtk_check_button_new_with_label ("button1");
 301       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 302       gtk_widget_show (button);
 303
 304       button = gtk_check_button_new_with_label ("button2");
 305       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 306       gtk_widget_show (button);
 307
 308       button = gtk_check_button_new_with_label ("button3");
 309       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 310       gtk_widget_show (button);
 311
 312
 313       separator = gtk_hseparator_new ();
 314       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 315       gtk_widget_show (separator);
 316
 317
 318       box2 = gtk_vbox_new (FALSE, 10);
 319       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 320       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 321       gtk_widget_show (box2);
 322
 323
 324       button = gtk_button_new_with_label ("close");
 325       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
 326                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
 327                                  GTK_OBJECT (window));
 328       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 329       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 330       gtk_widget_grab_default (button);
 331       gtk_widget_show (button);
 332     }
 333
 334   if (!GTK_WIDGET_VISIBLE (window))
 335     gtk_widget_show (window);
 336   else
 337     gtk_widget_destroy (window);
 338 }
 339
 340 static void
 341 create_radio_buttons ()
 342 {
 343   static GtkWidget *window = NULL;
 344   GtkWidget *box1;
 345   GtkWidget *box2;
 346   GtkWidget *button;
 347   GtkWidget *separator;
 348
 349   if (!window)
 350     {
 351       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 352
 353       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 354                           GTK_SIGNAL_FUNC(destroy_window),
 355                           &window);
 356       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
 357                           GTK_SIGNAL_FUNC(destroy_window),
 358                           &window);
 359
 360       gtk_window_set_title (GTK_WINDOW (window), "radio buttons");
 361       gtk_container_border_width (GTK_CONTAINER (window), 0);
 362
 363
 364       box1 = gtk_vbox_new (FALSE, 0);
 365       gtk_container_add (GTK_CONTAINER (window), box1);
 366       gtk_widget_show (box1);
 367
 368
 369       box2 = gtk_vbox_new (FALSE, 10);
 370       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 371       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
 372       gtk_widget_show (box2);
 373
 374
 375       button = gtk_radio_button_new_with_label (NULL, "button1");
 376       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 377       gtk_widget_show (button);
 378
 379       button = gtk_radio_button_new_with_label (
 380                  gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
 381                  "button2");
 382       gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
 383       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 384       gtk_widget_show (button);
 385
 386       button = gtk_radio_button_new_with_label (
 387                  gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
 388                  "button3");
 389       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 390       gtk_widget_show (button);
 391
 392
 393       separator = gtk_hseparator_new ();
 394       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 395       gtk_widget_show (separator);
 396
 397
 398       box2 = gtk_vbox_new (FALSE, 10);
 399       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 400       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 401       gtk_widget_show (box2);
 402
 403
 404       button = gtk_button_new_with_label ("close");
 405       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
 406                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
 407                                  GTK_OBJECT (window));
 408       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 409       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 410       gtk_widget_grab_default (button);
 411       gtk_widget_show (button);
 412     }
 413
 414   if (!GTK_WIDGET_VISIBLE (window))
 415     gtk_widget_show (window);
 416   else
 417     gtk_widget_destroy (window);
 418 }
 419
 420 static void
 421 bbox_widget_destroy (GtkWidget* widget, GtkWidget* todestroy)
 422 {
 423 }
 424
 425 static void
 426 create_bbox_window (gint  horizontal,
 427                     char* title,
 428                     gint  pos,
 429                     gint  spacing,
 430                     gint  child_w,
 431                     gint  child_h,
 432                     gint  layout)
 433 {
 434   GtkWidget* window;
 435   GtkWidget* box1;
 436   GtkWidget* bbox;
 437   GtkWidget* button;
 438
 439   /* create a new window */
 440   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 441   gtk_window_set_title (GTK_WINDOW (window), title);
 442
 443   gtk_signal_connect (GTK_OBJECT (window), "destroy",
 444                       GTK_SIGNAL_FUNC(bbox_widget_destroy), window);
 445   gtk_signal_connect (GTK_OBJECT (window), "delete_event",
 446                       GTK_SIGNAL_FUNC(bbox_widget_destroy), window);
 447
 448   if (horizontal)
 449   {
 450     gtk_widget_set_usize (window, 550, 60);
 451     gtk_widget_set_uposition (window, 150, pos);
 452     box1 = gtk_vbox_new (FALSE, 0);
 453   }
 454   else
 455   {
 456     gtk_widget_set_usize (window, 150, 400);
 457     gtk_widget_set_uposition (window, pos, 200);
 458     box1 = gtk_vbox_new (FALSE, 0);
 459   }
 460
 461   gtk_container_add (GTK_CONTAINER (window), box1);
 462   gtk_widget_show (box1);
 463
 464   if (horizontal)
 465     bbox = gtk_hbutton_box_new();
 466   else
 467     bbox = gtk_vbutton_box_new();
 468   gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), layout);
 469   gtk_button_box_set_spacing (GTK_BUTTON_BOX (bbox), spacing);
 470   gtk_button_box_set_child_size (GTK_BUTTON_BOX (bbox), child_w, child_h);
 471   gtk_widget_show (bbox);
 472
 473   gtk_container_border_width (GTK_CONTAINER(box1), 25);
 474   gtk_box_pack_start (GTK_BOX (box1), bbox, TRUE, TRUE, 0);
 475
 476   button = gtk_button_new_with_label ("OK");
 477   gtk_container_add (GTK_CONTAINER(bbox), button);
 478
 479   gtk_signal_connect (GTK_OBJECT (button), "clicked",
 480                       GTK_SIGNAL_FUNC(bbox_widget_destroy), window);
 481
 482   gtk_widget_show (button);
 483
 484   button = gtk_button_new_with_label ("Cancel");
 485   gtk_container_add (GTK_CONTAINER(bbox), button);
 486   gtk_widget_show (button);
 487
 488   button = gtk_button_new_with_label ("Help");
 489   gtk_container_add (GTK_CONTAINER(bbox), button);
 490   gtk_widget_show (button);
 491
 492   gtk_widget_show (window);
 493 }
 494
 495 static void
 496 test_hbbox ()
 497 {
 498   create_bbox_window (TRUE, "Spread", 50, 40, 85, 28, GTK_BUTTONBOX_SPREAD);
 499   create_bbox_window (TRUE, "Edge", 200, 40, 85, 25, GTK_BUTTONBOX_EDGE);
 500   create_bbox_window (TRUE, "Start", 350, 40, 85, 25, GTK_BUTTONBOX_START);
 501   create_bbox_window (TRUE, "End", 500, 15, 30, 25, GTK_BUTTONBOX_END);
 502 }
 503
 504 static void
 505 test_vbbox ()
 506 {
 507   create_bbox_window (FALSE, "Spread", 50, 40, 85, 25, GTK_BUTTONBOX_SPREAD);
 508   create_bbox_window (FALSE, "Edge", 250, 40, 85, 28, GTK_BUTTONBOX_EDGE);
 509   create_bbox_window (FALSE, "Start", 450, 40, 85, 25, GTK_BUTTONBOX_START);
 510   create_bbox_window (FALSE, "End", 650, 15, 30, 25, GTK_BUTTONBOX_END);
 511 }
 512
 513 static void
 514 create_button_box ()
 515 {
 516   static GtkWidget* window = NULL;
 517   GtkWidget* bbox;
 518   GtkWidget* button;
 519
 520   if (!window)
 521   {
 522     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 523     gtk_window_set_title (GTK_WINDOW (window),
 524                           "Button Box Test");
 525
 526     gtk_signal_connect (GTK_OBJECT (window), "destroy",
 527                         GTK_SIGNAL_FUNC(destroy_window), &window);
 528     gtk_signal_connect (GTK_OBJECT (window), "delete_event",
 529                         GTK_SIGNAL_FUNC(destroy_window), &window);
 530
 531     gtk_container_border_width (GTK_CONTAINER (window), 20);
 532
 533     /*
 534      *these 15 lines are a nice and easy example for GtkHButtonBox
 535      */
 536     bbox = gtk_hbutton_box_new ();
 537     gtk_container_add (GTK_CONTAINER (window), bbox);
 538     gtk_widget_show (bbox);
 539
 540     button = gtk_button_new_with_label ("Horizontal");
 541     gtk_signal_connect (GTK_OBJECT (button), "clicked",
 542                         GTK_SIGNAL_FUNC(test_hbbox), 0);
 543     gtk_container_add (GTK_CONTAINER (bbox), button);
 544     gtk_widget_show (button);
 545
 546     button = gtk_button_new_with_label ("Vertical");
 547     gtk_signal_connect (GTK_OBJECT (button), "clicked",
 548                         GTK_SIGNAL_FUNC(test_vbbox), 0);
 549     gtk_container_add (GTK_CONTAINER (bbox), button);
 550     gtk_widget_show (button);
 551   }
 552
 553   if (!GTK_WIDGET_VISIBLE (window))
 554     gtk_widget_show (window);
 555   else
 556     gtk_widget_destroy (window);
 557 }
 558
 559 static GtkWidget*
 560 new_pixmap (char      *filename,
 561             GdkWindow *window,
 562             GdkColor  *background)
 563 {
 564   GtkWidget *wpixmap;
 565   GdkPixmap *pixmap;
 566   GdkBitmap *mask;
 567
 568   pixmap = gdk_pixmap_create_from_xpm (window, &mask,
 569                                        background,
 570                                        "test.xpm");
 571   wpixmap = gtk_pixmap_new (pixmap, mask);
 572
 573   return wpixmap;
 574 }
 575
 576 static void
 577 set_toolbar_horizontal (GtkWidget *widget,
 578                         gpointer   data)
 579 {
 580   gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_HORIZONTAL);
 581 }
 582
 583 static void
 584 set_toolbar_vertical (GtkWidget *widget,
 585                       gpointer   data)
 586 {
 587   gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_VERTICAL);
 588 }
 589
 590 static void
 591 set_toolbar_icons (GtkWidget *widget,
 592                    gpointer   data)
 593 {
 594   gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_ICONS);
 595 }
 596
 597 static void
 598 set_toolbar_text (GtkWidget *widget,
 599                   gpointer   data)
 600 {
 601   gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_TEXT);
 602 }
 603
 604 static void
 605 set_toolbar_both (GtkWidget *widget,
 606                   gpointer   data)
 607 {
 608   gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH);
 609 }
 610
 611 static void
 612 set_toolbar_small_space (GtkWidget *widget,
 613                          gpointer   data)
 614 {
 615   gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 5);
 616 }
 617
 618 static void
 619 set_toolbar_big_space (GtkWidget *widget,
 620                        gpointer   data)
 621 {
 622   gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 10);
 623 }
 624
 625 static void
 626 set_toolbar_enable (GtkWidget *widget,
 627                     gpointer   data)
 628 {
 629   gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), TRUE);
 630 }
 631
 632 static void
 633 set_toolbar_disable (GtkWidget *widget,
 634                      gpointer   data)
 635 {
 636   gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), FALSE);
 637 }
 638
 639 static void
 640 create_toolbar (void)
 641 {
 642   static GtkWidget *window = NULL;
 643   GtkWidget *toolbar;
 644   GtkWidget *entry;
 645
 646   if (!window)
 647     {
 648       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 649       gtk_window_set_title (GTK_WINDOW (window), "Toolbar test");
 650       gtk_window_set_policy (GTK_WINDOW (window), FALSE, TRUE, TRUE);
 651
 652       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 653                           GTK_SIGNAL_FUNC (destroy_window),
 654                           &window);
 655       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
 656                           GTK_SIGNAL_FUNC (destroy_window),
 657                           &window);
 658
 659       gtk_container_border_width (GTK_CONTAINER (window), 0);
 660       gtk_widget_realize (window);
 661
 662       toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
 663
 664       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 665                                "Horizontal", "Horizontal toolbar layout",
 666                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 667                                (GtkSignalFunc) set_toolbar_horizontal, toolbar);
 668       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 669                                "Vertical", "Vertical toolbar layout",
 670                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 671                                (GtkSignalFunc) set_toolbar_vertical, toolbar);
 672
 673       gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
 674
 675       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 676                                "Icons", "Only show toolbar icons",
 677                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 678                                (GtkSignalFunc) set_toolbar_icons, toolbar);
 679       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 680                                "Text", "Only show toolbar text",
 681                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 682                                (GtkSignalFunc) set_toolbar_text, toolbar);
 683       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 684                                "Both", "Show toolbar icons and text",
 685                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 686                                (GtkSignalFunc) set_toolbar_both, toolbar);
 687
 688       gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 689
 690       entry = gtk_entry_new ();
 691       gtk_widget_show(entry);
 692       gtk_toolbar_append_widget (GTK_TOOLBAR (toolbar), entry, NULL);
 693
 694       gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 695
 696       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 697                                "Small", "Use small spaces",
 698                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 699                                (GtkSignalFunc) set_toolbar_small_space, toolbar);
 700       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 701                                "Big", "Use big spaces",
 702                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 703                                (GtkSignalFunc) set_toolbar_big_space, toolbar);
 704
 705       gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 706
 707       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 708                                "Enable", "Enable tooltips",
 709                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 710                                (GtkSignalFunc) set_toolbar_enable, toolbar);
 711       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 712                                "Disable", "Disable tooltips",
 713                                new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 714                                (GtkSignalFunc) set_toolbar_disable, toolbar);
 715
 716       gtk_container_add (GTK_CONTAINER (window), toolbar);
 717       gtk_widget_show (toolbar);
 718     }
 719
 720   if (!GTK_WIDGET_VISIBLE (window))
 721     gtk_widget_show (window);
 722   else
 723     gtk_widget_destroy (window);
 724 }
 725
 726 static GtkWidget*
 727 make_toolbar (GtkWidget *window)
 728 {
 729   GtkWidget *toolbar;
 730
 731   if (!GTK_WIDGET_REALIZED (window))
 732     gtk_widget_realize (window);
 733
 734   toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
 735
 736   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 737                            "Horizontal", "Horizontal toolbar layout",
 738                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 739                            (GtkSignalFunc) set_toolbar_horizontal, toolbar);
 740   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 741                            "Vertical", "Vertical toolbar layout",
 742                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 743                            (GtkSignalFunc) set_toolbar_vertical, toolbar);
 744
 745   gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
 746
 747   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 748                            "Icons", "Only show toolbar icons",
 749                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 750                            (GtkSignalFunc) set_toolbar_icons, toolbar);
 751   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 752                            "Text", "Only show toolbar text",
 753                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 754                            (GtkSignalFunc) set_toolbar_text, toolbar);
 755   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 756                            "Both", "Show toolbar icons and text",
 757                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 758                            (GtkSignalFunc) set_toolbar_both, toolbar);
 759
 760   gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 761
 762   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 763                            "Small", "Use small spaces",
 764                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 765                            (GtkSignalFunc) set_toolbar_small_space, toolbar);
 766   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 767                            "Big", "Use big spaces",
 768                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 769                            (GtkSignalFunc) set_toolbar_big_space, toolbar);
 770
 771   gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 772
 773   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 774                            "Enable", "Enable tooltips",
 775                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 776                            (GtkSignalFunc) set_toolbar_enable, toolbar);
 777   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 778                            "Disable", "Disable tooltips",
 779                            new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
 780                            (GtkSignalFunc) set_toolbar_disable, toolbar);
 781
 782   return toolbar;
 783 }
 784
 785 static void
 786 create_handle_box ()
 787 {
 788   static GtkWidget* window = NULL;
 789   GtkWidget *hbox;
 790   GtkWidget *toolbar;
 791
 792   if (!window)
 793   {
 794     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 795     gtk_window_set_title (GTK_WINDOW (window),
 796                           "Handle Box Test");
 797
 798     gtk_signal_connect (GTK_OBJECT (window), "destroy",
 799                         GTK_SIGNAL_FUNC(destroy_window), &window);
 800     gtk_signal_connect (GTK_OBJECT (window), "delete_event",
 801                         GTK_SIGNAL_FUNC(destroy_window), &window);
 802
 803     gtk_container_border_width (GTK_CONTAINER (window), 20);
 804
 805     hbox = gtk_handle_box_new ();
 806     gtk_container_add (GTK_CONTAINER (window), hbox);
 807     gtk_widget_show (hbox);
 808
 809     toolbar = make_toolbar (window);
 810     gtk_container_add (GTK_CONTAINER (hbox), toolbar);
 811     gtk_widget_show (toolbar);
 812   }
 813
 814   if (!GTK_WIDGET_VISIBLE (window))
 815     gtk_widget_show (window);
 816   else
 817     gtk_widget_destroy (window);
 818 }
 819
 820
 821 static void
 822 reparent_label (GtkWidget *widget,
 823                 GtkWidget *new_parent)
 824 {
 825   GtkWidget *label;
 826
 827   label = gtk_object_get_user_data (GTK_OBJECT (widget));
 828
 829   gtk_widget_reparent (label, new_parent);
 830 }
 831
 832 static void
 833 set_parent_signal (GtkWidget *child,
 834                    GtkWidget *old_parent,
 835                    gpointer   func_data)
 836 {
 837   g_print ("set_parent for \"%s\": new parent: \"%s\", old parent: \"%s\", data: %d\n",
 838            gtk_type_name (GTK_OBJECT_TYPE (child)),
 839            child->parent ? gtk_type_name (GTK_OBJECT_TYPE (child->parent)) : "NULL",
 840            old_parent ? gtk_type_name (GTK_OBJECT_TYPE (old_parent)) : "NULL",
 841            (gint) func_data);
 842 }
 843
 844 static void
 845 create_reparent ()
 846 {
 847   static GtkWidget *window = NULL;
 848   GtkWidget *box1;
 849   GtkWidget *box2;
 850   GtkWidget *box3;
 851   GtkWidget *frame;
 852   GtkWidget *button;
 853   GtkWidget *label;
 854   GtkWidget *separator;
 855
 856   if (!window)
 857     {
 858       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 859
 860       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 861                           GTK_SIGNAL_FUNC(destroy_window),
 862                           &window);
 863       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
 864                           GTK_SIGNAL_FUNC(destroy_window),
 865                           &window);
 866
 867       gtk_window_set_title (GTK_WINDOW (window), "buttons");
 868       gtk_container_border_width (GTK_CONTAINER (window), 0);
 869
 870
 871       box1 = gtk_vbox_new (FALSE, 0);
 872       gtk_container_add (GTK_CONTAINER (window), box1);
 873       gtk_widget_show (box1);
 874
 875
 876       box2 = gtk_hbox_new (FALSE, 5);
 877       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 878       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
 879       gtk_widget_show (box2);
 880
 881
 882       label = gtk_label_new ("Hello World");
 883
 884       frame = gtk_frame_new ("Frame 1");
 885       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
 886       gtk_widget_show (frame);
 887
 888       box3 = gtk_vbox_new (FALSE, 5);
 889       gtk_container_border_width (GTK_CONTAINER (box3), 5);
 890       gtk_container_add (GTK_CONTAINER (frame), box3);
 891       gtk_widget_show (box3);
 892
 893       button = gtk_button_new_with_label ("switch");
 894       gtk_signal_connect (GTK_OBJECT (button), "clicked",
 895                           GTK_SIGNAL_FUNC(reparent_label),
 896                           box3);
 897       gtk_object_set_user_data (GTK_OBJECT (button), label);
 898       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
 899       gtk_widget_show (button);
 900
 901       gtk_box_pack_start (GTK_BOX (box3), label, FALSE, TRUE, 0);
 902       gtk_signal_connect (GTK_OBJECT (label),
 903                           "set_parent",
 904                           GTK_SIGNAL_FUNC (set_parent_signal),
 905                           (GtkObject*) 42);
 906       gtk_widget_show (label);
 907
 908
 909       frame = gtk_frame_new ("Frame 2");
 910       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
 911       gtk_widget_show (frame);
 912
 913       box3 = gtk_vbox_new (FALSE, 5);
 914       gtk_container_border_width (GTK_CONTAINER (box3), 5);
 915       gtk_container_add (GTK_CONTAINER (frame), box3);
 916       gtk_widget_show (box3);
 917
 918       button = gtk_button_new_with_label ("switch");
 919       gtk_signal_connect (GTK_OBJECT (button), "clicked",
 920                           GTK_SIGNAL_FUNC(reparent_label),
 921                           box3);
 922       gtk_object_set_user_data (GTK_OBJECT (button), label);
 923       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
 924       gtk_widget_show (button);
 925
 926
 927       separator = gtk_hseparator_new ();
 928       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 929       gtk_widget_show (separator);
 930
 931
 932       box2 = gtk_vbox_new (FALSE, 10);
 933       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 934       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 935       gtk_widget_show (box2);
 936
 937
 938       button = gtk_button_new_with_label ("close");
 939       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
 940                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
 941                                  GTK_OBJECT (window));
 942       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 943       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 944       gtk_widget_grab_default (button);
 945       gtk_widget_show (button);
 946     }
 947
 948   if (!GTK_WIDGET_VISIBLE (window))
 949     gtk_widget_show (window);
 950   else
 951     gtk_widget_destroy (window);
 952 }
 953
 954 static void
 955 create_pixmap ()
 956 {
 957   static GtkWidget *window = NULL;
 958   GtkWidget *box1;
 959   GtkWidget *box2;
 960   GtkWidget *box3;
 961   GtkWidget *button;
 962   GtkWidget *label;
 963   GtkWidget *separator;
 964   GtkWidget *pixmapwid;
 965   GdkPixmap *pixmap;
 966   GdkBitmap *mask;
 967   GtkStyle *style;
 968
 969   if (!window)
 970     {
 971       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 972
 973       gtk_signal_connect (GTK_OBJECT (window), "destroy",
 974                           GTK_SIGNAL_FUNC(destroy_window),
 975                           &window);
 976       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
 977                           GTK_SIGNAL_FUNC(destroy_window),
 978                           &window);
 979
 980       gtk_window_set_title (GTK_WINDOW (window), "pixmap");
 981       gtk_container_border_width (GTK_CONTAINER (window), 0);
 982       gtk_widget_realize(window);
 983
 984       box1 = gtk_vbox_new (FALSE, 0);
 985       gtk_container_add (GTK_CONTAINER (window), box1);
 986       gtk_widget_show (box1);
 987
 988       box2 = gtk_vbox_new (FALSE, 10);
 989       gtk_container_border_width (GTK_CONTAINER (box2), 10);
 990       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
 991       gtk_widget_show (box2);
 992
 993       button = gtk_button_new ();
 994       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
 995       gtk_widget_show (button);
 996
 997       style=gtk_widget_get_style(button);
 998
 999       pixmap = gdk_pixmap_create_from_xpm (window->window, &mask,
1000                                            &style->bg[GTK_STATE_NORMAL],
1001                                            "test.xpm");
1002       pixmapwid = gtk_pixmap_new (pixmap, mask);
1003
1004       label = gtk_label_new ("Pixmap\ntest");
1005       box3 = gtk_hbox_new (FALSE, 0);
1006       gtk_container_border_width (GTK_CONTAINER (box3), 2);
1007       gtk_container_add (GTK_CONTAINER (box3), pixmapwid);
1008       gtk_container_add (GTK_CONTAINER (box3), label);
1009       gtk_container_add (GTK_CONTAINER (button), box3);
1010       gtk_widget_show (pixmapwid);
1011       gtk_widget_show (label);
1012       gtk_widget_show (box3);
1013
1014       separator = gtk_hseparator_new ();
1015       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1016       gtk_widget_show (separator);
1017
1018
1019       box2 = gtk_vbox_new (FALSE, 10);
1020       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1021       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1022       gtk_widget_show (box2);
1023
1024
1025       button = gtk_button_new_with_label ("close");
1026       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1027                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1028                                  GTK_OBJECT (window));
1029       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1030       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1031       gtk_widget_grab_default (button);
1032       gtk_widget_show (button);
1033     }
1034
1035   if (!GTK_WIDGET_VISIBLE (window))
1036     gtk_widget_show (window);
1037   else
1038     gtk_widget_destroy (window);
1039 }
1040
1041 static void
1042 create_tooltips ()
1043 {
1044   static GtkWidget *window = NULL;
1045   GtkWidget *box1;
1046   GtkWidget *box2;
1047   GtkWidget *button;
1048   GtkWidget *separator;
1049   GtkTooltips *tooltips;
1050
1051   if (!window)
1052     {
1053       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1054
1055       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1056                           GTK_SIGNAL_FUNC (destroy_tooltips),
1057                           &window);
1058       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
1059                           GTK_SIGNAL_FUNC (gtk_true),
1060                           &window);
1061
1062       gtk_window_set_title (GTK_WINDOW (window), "tooltips");
1063       gtk_container_border_width (GTK_CONTAINER (window), 0);
1064
1065       tooltips=gtk_tooltips_new();
1066       gtk_object_set_data (GTK_OBJECT (window), "tooltips", tooltips);
1067
1068       box1 = gtk_vbox_new (FALSE, 0);
1069       gtk_container_add (GTK_CONTAINER (window), box1);
1070       gtk_widget_show (box1);
1071
1072
1073       box2 = gtk_vbox_new (FALSE, 10);
1074       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1075       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1076       gtk_widget_show (box2);
1077
1078
1079       button = gtk_toggle_button_new_with_label ("button1");
1080       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1081       gtk_widget_show (button);
1082
1083       gtk_tooltips_set_tips(tooltips,button,"This is button 1");
1084
1085       button = gtk_toggle_button_new_with_label ("button2");
1086       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1087       gtk_widget_show (button);
1088
1089       gtk_tooltips_set_tips(tooltips,button,"This is button 2");
1090
1091       button = gtk_toggle_button_new_with_label ("button3");
1092       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1093       gtk_widget_show (button);
1094
1095       gtk_tooltips_set_tips (tooltips, button, "This is button 3. 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.");
1096
1097       separator = gtk_hseparator_new ();
1098       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1099       gtk_widget_show (separator);
1100
1101
1102       box2 = gtk_vbox_new (FALSE, 10);
1103       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1104       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1105       gtk_widget_show (box2);
1106
1107
1108       button = gtk_button_new_with_label ("close");
1109       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1110                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1111                                  GTK_OBJECT (window));
1112       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1113       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1114       gtk_widget_grab_default (button);
1115       gtk_widget_show (button);
1116
1117       gtk_tooltips_set_tips (tooltips, button, "Push this button to close window");
1118     }
1119
1120   if (!GTK_WIDGET_VISIBLE (window))
1121     gtk_widget_show (window);
1122   else
1123     gtk_widget_destroy (window);
1124 }
1125
1126 static GtkWidget*
1127 create_menu (int depth)
1128 {
1129   GtkWidget *menu;
1130   GtkWidget *menuitem;
1131   GSList *group;
1132   char buf[32];
1133   int i, j;
1134
1135   if (depth < 1)
1136     return NULL;
1137
1138   menu = gtk_menu_new ();
1139   group = NULL;
1140
1141   for (i = 0, j = 1; i < 5; i++, j++)
1142     {
1143       sprintf (buf, "item %2d - %d", depth, j);
1144       menuitem = gtk_radio_menu_item_new_with_label (group, buf);
1145       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
1146       if (depth % 2)
1147         gtk_check_menu_item_set_show_toggle (GTK_CHECK_MENU_ITEM (menuitem), TRUE);
1148       gtk_menu_append (GTK_MENU (menu), menuitem);
1149       gtk_widget_show (menuitem);
1150
1151       gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (depth - 1));
1152     }
1153
1154   return menu;
1155 }
1156
1157 static void
1158 create_menus ()
1159 {
1160   static GtkWidget *window = NULL;
1161   GtkWidget *box1;
1162   GtkWidget *box2;
1163   GtkWidget *button;
1164   GtkWidget *menu;
1165   GtkWidget *menubar;
1166   GtkWidget *menuitem;
1167   GtkWidget *optionmenu;
1168   GtkWidget *separator;
1169
1170   if (!window)
1171     {
1172       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1173
1174       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1175                           GTK_SIGNAL_FUNC(destroy_window),
1176                           &window);
1177       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
1178                           GTK_SIGNAL_FUNC(destroy_window),
1179                           &window);
1180
1181       gtk_window_set_title (GTK_WINDOW (window), "menus");
1182       gtk_container_border_width (GTK_CONTAINER (window), 0);
1183
1184
1185       box1 = gtk_vbox_new (FALSE, 0);
1186       gtk_container_add (GTK_CONTAINER (window), box1);
1187       gtk_widget_show (box1);
1188
1189
1190       menubar = gtk_menu_bar_new ();
1191       gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
1192       gtk_widget_show (menubar);
1193
1194       menu = create_menu (2);
1195
1196       menuitem = gtk_menu_item_new_with_label ("test\nline2");
1197       gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
1198       gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
1199       gtk_widget_show (menuitem);
1200
1201       menuitem = gtk_menu_item_new_with_label ("foo");
1202       gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (3));
1203       gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
1204       gtk_widget_show (menuitem);
1205
1206       menuitem = gtk_menu_item_new_with_label ("bar");
1207       gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4));
1208       gtk_menu_item_right_justify (GTK_MENU_ITEM (menuitem));
1209       gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
1210       gtk_widget_show (menuitem);
1211
1212
1213       box2 = gtk_vbox_new (FALSE, 10);
1214       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1215       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1216       gtk_widget_show (box2);
1217
1218
1219       optionmenu = gtk_option_menu_new ();
1220       gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), create_menu (1));
1221       gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu), 4);
1222       gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0);
1223       gtk_widget_show (optionmenu);
1224
1225
1226       separator = gtk_hseparator_new ();
1227       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1228       gtk_widget_show (separator);
1229
1230
1231       box2 = gtk_vbox_new (FALSE, 10);
1232       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1233       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1234       gtk_widget_show (box2);
1235
1236
1237       button = gtk_button_new_with_label ("close");
1238       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1239                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1240                                  GTK_OBJECT (window));
1241       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1242       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1243       gtk_widget_grab_default (button);
1244       gtk_widget_show (button);
1245     }
1246
1247   if (!GTK_WIDGET_VISIBLE (window))
1248     gtk_widget_show (window);
1249   else
1250     gtk_widget_destroy (window);
1251 }
1252
1253 /*
1254  * GtkScrolledWindow
1255  */
1256 static void
1257 create_scrolled_windows ()
1258 {
1259   static GtkWidget *window;
1260   GtkWidget *scrolled_window;
1261   GtkWidget *table;
1262   GtkWidget *button;
1263   char buffer[32];
1264   int i, j;
1265
1266   if (!window)
1267     {
1268       window = gtk_dialog_new ();
1269
1270       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1271                           GTK_SIGNAL_FUNC(destroy_window),
1272                           &window);
1273       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
1274                           GTK_SIGNAL_FUNC(destroy_window),
1275                           &window);
1276
1277       gtk_window_set_title (GTK_WINDOW (window), "dialog");
1278       gtk_container_border_width (GTK_CONTAINER (window), 0);
1279
1280
1281       scrolled_window = gtk_scrolled_window_new (NULL, NULL);
1282       gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
1283       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
1284                                       GTK_POLICY_AUTOMATIC,
1285                                       GTK_POLICY_AUTOMATIC);
1286       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
1287                           scrolled_window, TRUE, TRUE, 0);
1288       gtk_widget_show (scrolled_window);
1289
1290       table = gtk_table_new (20, 20, FALSE);
1291       gtk_table_set_row_spacings (GTK_TABLE (table), 10);
1292       gtk_table_set_col_spacings (GTK_TABLE (table), 10);
1293       gtk_container_add (GTK_CONTAINER (scrolled_window), table);
1294       gtk_widget_show (table);
1295
1296       for (i = 0; i < 20; i++)
1297         for (j = 0; j < 20; j++)
1298           {
1299             sprintf (buffer, "button (%d,%d)\n", i, j);
1300             button = gtk_toggle_button_new_with_label (buffer);
1301             gtk_table_attach_defaults (GTK_TABLE (table), button,
1302                                        i, i+1, j, j+1);
1303             gtk_widget_show (button);
1304           }
1305
1306
1307       button = gtk_button_new_with_label ("close");
1308       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1309                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1310                                  GTK_OBJECT (window));
1311       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1312       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
1313                           button, TRUE, TRUE, 0);
1314       gtk_widget_grab_default (button);
1315       gtk_widget_show (button);
1316     }
1317
1318   if (!GTK_WIDGET_VISIBLE (window))
1319     gtk_widget_show (window);
1320   else
1321     gtk_widget_destroy (window);
1322 }
1323
1324 /*
1325  * GtkEntry
1326  */
1327
1328 static void
1329 entry_toggle_editable (GtkWidget *checkbutton,
1330                        GtkWidget *entry)
1331 {
1332    gtk_entry_set_editable(GTK_ENTRY(entry),
1333                           GTK_TOGGLE_BUTTON(checkbutton)->active);
1334 }
1335
1336 static void
1337 create_entry ()
1338 {
1339   static GtkWidget *window = NULL;
1340   GtkWidget *box1;
1341   GtkWidget *box2;
1342   GtkWidget *editable_check;
1343   GtkWidget *entry, *cb;
1344   GtkWidget *button;
1345   GtkWidget *separator;
1346   GList *cbitems = NULL;
1347
1348   if (!window)
1349     {
1350       cbitems = g_list_append(cbitems, "item1");
1351       cbitems = g_list_append(cbitems, "item2");
1352       cbitems = g_list_append(cbitems, "and item3");
1353       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1354
1355       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1356                           GTK_SIGNAL_FUNC(destroy_window),
1357                           &window);
1358       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
1359                           GTK_SIGNAL_FUNC(destroy_window),
1360                           &window);
1361
1362       gtk_window_set_title (GTK_WINDOW (window), "entry");
1363       gtk_container_border_width (GTK_CONTAINER (window), 0);
1364
1365
1366       box1 = gtk_vbox_new (FALSE, 0);
1367       gtk_container_add (GTK_CONTAINER (window), box1);
1368       gtk_widget_show (box1);
1369
1370
1371       box2 = gtk_vbox_new (FALSE, 10);
1372       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1373       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1374       gtk_widget_show (box2);
1375
1376       entry = gtk_entry_new ();
1377       gtk_entry_set_text (GTK_ENTRY (entry), "hello world");
1378       gtk_entry_select_region (GTK_ENTRY (entry),
1379                                0, GTK_ENTRY(entry)->text_length);
1380       gtk_box_pack_start (GTK_BOX (box2), entry, TRUE, TRUE, 0);
1381       gtk_widget_show (entry);
1382
1383       cb = gtk_combo_new ();
1384       gtk_combo_set_popdown_strings (GTK_COMBO (cb), cbitems);
1385       gtk_entry_set_text (GTK_ENTRY (GTK_COMBO(cb)->entry), "hello world");
1386       gtk_entry_select_region (GTK_ENTRY (GTK_COMBO(cb)->entry),
1387                                0, GTK_ENTRY(entry)->text_length);
1388       gtk_box_pack_start (GTK_BOX (box2), cb, TRUE, TRUE, 0);
1389       gtk_widget_show (cb);
1390
1391       editable_check = gtk_check_button_new_with_label("Editable");
1392       gtk_box_pack_start (GTK_BOX (box2), editable_check, TRUE, TRUE, 0);
1393       gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
1394                           GTK_SIGNAL_FUNC(entry_toggle_editable), entry);
1395       gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE);
1396       gtk_widget_show (editable_check);
1397
1398       separator = gtk_hseparator_new ();
1399       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1400       gtk_widget_show (separator);
1401
1402
1403       box2 = gtk_vbox_new (FALSE, 10);
1404       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1405       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1406       gtk_widget_show (box2);
1407
1408
1409       button = gtk_button_new_with_label ("close");
1410       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1411                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1412                                  GTK_OBJECT (window));
1413       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1414       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1415       gtk_widget_grab_default (button);
1416       gtk_widget_show (button);
1417     }
1418
1419   if (!GTK_WIDGET_VISIBLE (window))
1420     gtk_widget_show (window);
1421   /*  else
1422     gtk_widget_destroy (window); */
1423 }
1424
1425 /*
1426  * GtkList
1427  */
1428 static void
1429 list_add (GtkWidget *widget,
1430           GtkWidget *list)
1431 {
1432   static int i = 1;
1433   gchar buffer[64];
1434   GtkWidget *list_item;
1435
1436   sprintf (buffer, "added item %d", i++);
1437   list_item = gtk_list_item_new_with_label (buffer);
1438   gtk_widget_show (list_item);
1439   gtk_container_add (GTK_CONTAINER (list), list_item);
1440 }
1441
1442 static void
1443 list_remove (GtkWidget *widget,
1444              GtkWidget *list)
1445 {
1446   GList *tmp_list;
1447   GList *clear_list;
1448
1449   tmp_list = GTK_LIST (list)->selection;
1450   clear_list = NULL;
1451
1452   while (tmp_list)
1453     {
1454       clear_list = g_list_prepend (clear_list, tmp_list->data);
1455       tmp_list = tmp_list->next;
1456     }
1457
1458   clear_list = g_list_reverse (clear_list);
1459
1460   gtk_list_remove_items (GTK_LIST (list), clear_list);
1461
1462   g_list_free (clear_list);
1463 }
1464
1465 static void
1466 create_list ()
1467 {
1468   static GtkWidget *window = NULL;
1469   static char *list_items[] =
1470   {
1471     "hello",
1472     "world",
1473     "blah",
1474     "foo",
1475     "bar",
1476     "argh",
1477     "spencer",
1478     "is a",
1479     "wussy",
1480     "programmer",
1481   };
1482   static int nlist_items = sizeof (list_items) / sizeof (list_items[0]);
1483
1484   GtkWidget *box1;
1485   GtkWidget *box2;
1486   GtkWidget *scrolled_win;
1487   GtkWidget *list;
1488   GtkWidget *list_item;
1489   GtkWidget *button;
1490   GtkWidget *separator;
1491   int i;
1492
1493   if (!window)
1494     {
1495       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1496
1497       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1498                           GTK_SIGNAL_FUNC(destroy_window),
1499                           &window);
1500       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
1501                           GTK_SIGNAL_FUNC(destroy_window),
1502                           &window);
1503
1504       gtk_window_set_title (GTK_WINDOW (window), "list");
1505       gtk_container_border_width (GTK_CONTAINER (window), 0);
1506
1507
1508       box1 = gtk_vbox_new (FALSE, 0);
1509       gtk_container_add (GTK_CONTAINER (window), box1);
1510       gtk_widget_show (box1);
1511
1512
1513       box2 = gtk_vbox_new (FALSE, 10);
1514       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1515       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1516       gtk_widget_show (box2);
1517
1518
1519       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
1520       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
1521                                       GTK_POLICY_AUTOMATIC,
1522                                       GTK_POLICY_AUTOMATIC);
1523       gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
1524       gtk_widget_show (scrolled_win);
1525
1526       list = gtk_list_new ();
1527       gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_MULTIPLE);
1528       gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_BROWSE);
1529       gtk_container_add (GTK_CONTAINER (scrolled_win), list);
1530       gtk_widget_show (list);
1531
1532       for (i = 0; i < nlist_items; i++)
1533         {
1534           list_item = gtk_list_item_new_with_label (list_items[i]);
1535           gtk_container_add (GTK_CONTAINER (list), list_item);
1536           gtk_widget_show (list_item);
1537         }
1538
1539       button = gtk_button_new_with_label ("add");
1540       GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
1541       gtk_signal_connect (GTK_OBJECT (button), "clicked",
1542                           GTK_SIGNAL_FUNC(list_add),
1543                           list);
1544       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
1545       gtk_widget_show (button);
1546
1547       button = gtk_button_new_with_label ("remove");
1548       GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
1549       gtk_signal_connect (GTK_OBJECT (button), "clicked",
1550                           GTK_SIGNAL_FUNC(list_remove),
1551                           list);
1552       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
1553       gtk_widget_show (button);
1554
1555
1556       separator = gtk_hseparator_new ();
1557       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1558       gtk_widget_show (separator);
1559
1560
1561       box2 = gtk_vbox_new (FALSE, 10);
1562       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1563       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1564       gtk_widget_show (box2);
1565
1566
1567       button = gtk_button_new_with_label ("close");
1568       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1569                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1570                                  GTK_OBJECT (window));
1571       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1572       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1573       gtk_widget_grab_default (button);
1574       gtk_widget_show (button);
1575     }
1576
1577   if (!GTK_WIDGET_VISIBLE (window))
1578     gtk_widget_show (window);
1579   else
1580     gtk_widget_destroy (window);
1581 }
1582
1583 /*
1584  * GtkCList
1585  */
1586 #define TESTGTK_CLIST_COLUMNS 7
1587 static gint clist_rows = 0;
1588 static gint clist_selected_row = 0;
1589
1590 static void
1591 add1000_clist (GtkWidget *widget, gpointer data)
1592 {
1593   gint i, row;
1594   char text[TESTGTK_CLIST_COLUMNS][50];
1595   char *texts[TESTGTK_CLIST_COLUMNS];
1596   GdkBitmap *mask;
1597   GdkPixmap *pixmap;
1598
1599   pixmap = gdk_pixmap_create_from_xpm (GTK_CLIST (data)->clist_window,
1600                                        &mask,
1601                                        &GTK_WIDGET (data)->style->white,
1602                                        "test.xpm");
1603
1604   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
1605     {
1606       texts[i] = text[i];
1607       sprintf (text[i], "Column %d", i);
1608     }
1609
1610   texts[3] = NULL;
1611   sprintf (text[1], "Right");
1612   sprintf (text[2], "Center");
1613
1614   gtk_clist_freeze (GTK_CLIST (data));
1615   for (i = 0; i < 1000; i++)
1616     {
1617       sprintf (text[0], "Row %d", clist_rows++);
1618       row = gtk_clist_append (GTK_CLIST (data), texts);
1619       gtk_clist_set_pixtext (GTK_CLIST (data), row, 3, "Testing", 5, pixmap, mask);
1620     }
1621   gtk_clist_thaw (GTK_CLIST (data));
1622
1623   gdk_pixmap_unref (pixmap);
1624   gdk_bitmap_unref (mask);
1625 }
1626
1627 static void
1628 add10000_clist (GtkWidget *widget, gpointer data)
1629 {
1630   gint i;
1631   char text[TESTGTK_CLIST_COLUMNS][50];
1632   char *texts[TESTGTK_CLIST_COLUMNS];
1633
1634   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
1635     {
1636       texts[i] = text[i];
1637       sprintf (text[i], "Column %d", i);
1638     }
1639
1640   sprintf (text[1], "Right");
1641   sprintf (text[2], "Center");
1642
1643   gtk_clist_freeze (GTK_CLIST (data));
1644   for (i = 0; i < 10000; i++)
1645     {
1646       sprintf (text[0], "Row %d", clist_rows++);
1647       gtk_clist_append (GTK_CLIST (data), texts);
1648     }
1649   gtk_clist_thaw (GTK_CLIST (data));
1650
1651 }
1652
1653 void
1654 clear_clist (GtkWidget *widget, gpointer data)
1655 {
1656   gtk_clist_clear (GTK_CLIST (data));
1657   clist_rows = 0;
1658 }
1659
1660 void
1661 remove_row_clist (GtkWidget *widget, gpointer data)
1662 {
1663   gtk_clist_remove (GTK_CLIST (data), clist_selected_row);
1664   clist_rows--;
1665 }
1666
1667 void
1668 show_titles_clist (GtkWidget *widget, gpointer data)
1669 {
1670   gtk_clist_column_titles_show (GTK_CLIST (data));
1671 }
1672
1673 void
1674 hide_titles_clist (GtkWidget *widget, gpointer data)
1675 {
1676   gtk_clist_column_titles_hide (GTK_CLIST (data));
1677 }
1678
1679 void
1680 select_clist (GtkWidget *widget,
1681               gint row,
1682               gint column,
1683               GdkEventButton * bevent)
1684 {
1685   gint i;
1686   guint8 spacing;
1687   gchar *text;
1688   GdkPixmap *pixmap;
1689   GdkBitmap *mask;
1690
1691   g_print ("GtkCList Selection: row %d column %d button %d\n",
1692            row, column, bevent ? bevent->button : 0);
1693
1694   for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
1695     {
1696       switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i))
1697         {
1698         case GTK_CELL_TEXT:
1699           g_print ("CELL %d GTK_CELL_TEXT\n", i);
1700           gtk_clist_get_text (GTK_CLIST (widget), row, i, &text);
1701           g_print ("TEXT: %s\n", text);
1702           break;
1703
1704         case GTK_CELL_PIXMAP:
1705           g_print ("CELL %d GTK_CELL_PIXMAP\n", i);
1706           gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask);
1707           g_print ("PIXMAP: %d\n", (int) pixmap);
1708           g_print ("MASK: %d\n", (int) mask);
1709           break;
1710
1711         case GTK_CELL_PIXTEXT:
1712           g_print ("CELL %d GTK_CELL_PIXTEXT\n", i);
1713           gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask);
1714           g_print ("TEXT: %s\n", text);
1715           g_print ("SPACING: %d\n", spacing);
1716           g_print ("PIXMAP: %d\n", (int) pixmap);
1717           g_print ("MASK: %d\n", (int) mask);
1718           break;
1719
1720         default:
1721           break;
1722         }
1723     }
1724
1725   g_print ("\n\n");
1726
1727   clist_selected_row = row;
1728 }
1729
1730 void
1731 list_selection_clist (GtkWidget *widget, gpointer data)
1732 {
1733 }
1734
1735 void
1736 create_clist ()
1737 {
1738   gint i;
1739   static GtkWidget *window = NULL;
1740
1741   static char *titles[] =
1742   {
1743     "Title 0",
1744     "Title 1",
1745     "Title 2",
1746     "Title 3",
1747     "Title 4",
1748     "Title 5",
1749     "Title 6"
1750   };
1751
1752   char text[TESTGTK_CLIST_COLUMNS][50];
1753   char *texts[TESTGTK_CLIST_COLUMNS];
1754
1755   GtkWidget *box1;
1756   GtkWidget *box2;
1757   GtkWidget *clist;
1758   GtkWidget *button;
1759   GtkWidget *separator;
1760
1761
1762   if (!window)
1763     {
1764       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1765
1766       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1767                           GTK_SIGNAL_FUNC(destroy_window),
1768                           &window);
1769       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
1770                           GTK_SIGNAL_FUNC(destroy_window),
1771                           &window);
1772
1773       gtk_window_set_title (GTK_WINDOW (window), "clist");
1774       gtk_container_border_width (GTK_CONTAINER (window), 0);
1775
1776
1777       box1 = gtk_vbox_new (FALSE, 0);
1778       gtk_container_add (GTK_CONTAINER (window), box1);
1779       gtk_widget_show (box1);
1780
1781
1782       box2 = gtk_hbox_new (FALSE, 10);
1783       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1784       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
1785       gtk_widget_show (box2);
1786
1787       /* create GtkCList here so we have a pointer to throw at the
1788        * button callbacks -- more is done with it later */
1789       clist = gtk_clist_new_with_titles (TESTGTK_CLIST_COLUMNS, titles);
1790       /*clist = gtk_clist_new (TESTGTK_CLIST_COLUMNS);*/
1791
1792       /* control buttons */
1793       button = gtk_button_new_with_label ("Add 1,000 Rows With Pixmaps");
1794       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1795
1796       gtk_signal_connect (GTK_OBJECT (button),
1797                           "clicked",
1798                           (GtkSignalFunc) add1000_clist,
1799                           (gpointer) clist);
1800
1801       gtk_widget_show (button);
1802
1803
1804       button = gtk_button_new_with_label ("Add 10,000 Rows");
1805       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1806
1807       gtk_signal_connect (GTK_OBJECT (button),
1808                           "clicked",
1809                           (GtkSignalFunc) add10000_clist,
1810                           (gpointer) clist);
1811
1812       gtk_widget_show (button);
1813
1814       button = gtk_button_new_with_label ("Clear List");
1815       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1816
1817       gtk_signal_connect (GTK_OBJECT (button),
1818                           "clicked",
1819                           (GtkSignalFunc) clear_clist,
1820                           (gpointer) clist);
1821
1822       gtk_widget_show (button);
1823
1824       button = gtk_button_new_with_label ("Remove Row");
1825       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1826
1827       gtk_signal_connect (GTK_OBJECT (button),
1828                           "clicked",
1829                           (GtkSignalFunc) remove_row_clist,
1830                           (gpointer) clist);
1831
1832       gtk_widget_show (button);
1833
1834       /* second layer of buttons */
1835       box2 = gtk_hbox_new (FALSE, 10);
1836       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1837       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
1838       gtk_widget_show (box2);
1839
1840       button = gtk_button_new_with_label ("Show Title Buttons");
1841       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1842
1843       gtk_signal_connect (GTK_OBJECT (button),
1844                           "clicked",
1845                           (GtkSignalFunc) show_titles_clist,
1846                           (gpointer) clist);
1847
1848       gtk_widget_show (button);
1849
1850       button = gtk_button_new_with_label ("Hide Title Buttons");
1851       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1852
1853       gtk_signal_connect (GTK_OBJECT (button),
1854                           "clicked",
1855                           (GtkSignalFunc) hide_titles_clist,
1856                           (gpointer) clist);
1857
1858       gtk_widget_show (button);
1859
1860       /* vbox for the list itself */
1861       box2 = gtk_vbox_new (FALSE, 10);
1862       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1863       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1864       gtk_widget_show (box2);
1865
1866       /*
1867        * the rest of the clist configuration
1868        */
1869       gtk_clist_set_row_height (GTK_CLIST (clist), 20);
1870
1871       gtk_signal_connect (GTK_OBJECT (clist),
1872                           "select_row",
1873                           (GtkSignalFunc) select_clist,
1874                           NULL);
1875
1876       gtk_clist_set_column_width (GTK_CLIST (clist), 0, 100);
1877
1878       for (i = 1; i < TESTGTK_CLIST_COLUMNS; i++)
1879         gtk_clist_set_column_width (GTK_CLIST (clist), i, 80);
1880
1881       gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_BROWSE);
1882
1883       gtk_clist_set_policy (GTK_CLIST (clist), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1884
1885       gtk_clist_set_column_justification (GTK_CLIST (clist), 1, GTK_JUSTIFY_RIGHT);
1886       gtk_clist_set_column_justification (GTK_CLIST (clist), 2, GTK_JUSTIFY_CENTER);
1887
1888       for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
1889         {
1890           texts[i] = text[i];
1891           sprintf (text[i], "Column %d", i);
1892         }
1893
1894       sprintf (text[1], "Right");
1895       sprintf (text[2], "Center");
1896
1897       for (i = 0; i < 100; i++)
1898         {
1899           sprintf (text[0], "Row %d", clist_rows++);
1900           gtk_clist_append (GTK_CLIST (clist), texts);
1901         }
1902
1903       gtk_container_border_width (GTK_CONTAINER (clist), 5);
1904       gtk_box_pack_start (GTK_BOX (box2), clist, TRUE, TRUE, 0);
1905       gtk_widget_show (clist);
1906
1907
1908       separator = gtk_hseparator_new ();
1909       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1910       gtk_widget_show (separator);
1911
1912       box2 = gtk_vbox_new (FALSE, 10);
1913       gtk_container_border_width (GTK_CONTAINER (box2), 10);
1914       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1915       gtk_widget_show (box2);
1916
1917       button = gtk_button_new_with_label ("close");
1918       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1919                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
1920                                  GTK_OBJECT (window));
1921
1922       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1923       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1924       gtk_widget_grab_default (button);
1925
1926       gtk_widget_show (button);
1927     }
1928
1929   if (!GTK_WIDGET_VISIBLE (window))
1930     gtk_widget_show (window);
1931   else
1932     gtk_widget_destroy (window);
1933
1934 }
1935
1936 /*
1937  * GtkColorSelect
1938  */
1939 void
1940 color_selection_ok (GtkWidget               *w,
1941                     GtkColorSelectionDialog *cs)
1942 {
1943   GtkColorSelection *colorsel;
1944   gdouble color[4];
1945
1946   colorsel=GTK_COLOR_SELECTION(cs->colorsel);
1947
1948   gtk_color_selection_get_color(colorsel,color);
1949   gtk_color_selection_set_color(colorsel,color);
1950 }
1951
1952 void
1953 color_selection_changed (GtkWidget *w,
1954                          GtkColorSelectionDialog *cs)
1955 {
1956   GtkColorSelection *colorsel;
1957   gdouble color[4];
1958
1959   colorsel=GTK_COLOR_SELECTION(cs->colorsel);
1960   gtk_color_selection_get_color(colorsel,color);
1961 }
1962
1963 void
1964 create_color_selection ()
1965 {
1966   static GtkWidget *window = NULL;
1967
1968   if (!window)
1969     {
1970       gtk_preview_set_install_cmap (TRUE);
1971       gtk_widget_push_visual (gtk_preview_get_visual ());
1972       gtk_widget_push_colormap (gtk_preview_get_cmap ());
1973
1974       window = gtk_color_selection_dialog_new ("color selection dialog");
1975
1976       gtk_color_selection_set_opacity (
1977         GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
1978         TRUE);
1979
1980       gtk_color_selection_set_update_policy(
1981         GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
1982         GTK_UPDATE_CONTINUOUS);
1983
1984       gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
1985
1986       gtk_signal_connect (GTK_OBJECT (window), "destroy",
1987                           GTK_SIGNAL_FUNC(destroy_window),
1988                           &window);
1989       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
1990                           GTK_SIGNAL_FUNC(destroy_window),
1991                           &window);
1992
1993       gtk_signal_connect (
1994         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
1995         "color_changed",
1996         GTK_SIGNAL_FUNC(color_selection_changed),
1997         window);
1998
1999       gtk_signal_connect (
2000         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->ok_button),
2001         "clicked",
2002         GTK_SIGNAL_FUNC(color_selection_ok),
2003         window);
2004
2005       gtk_signal_connect_object (
2006         GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->cancel_button),
2007         "clicked",
2008         GTK_SIGNAL_FUNC(gtk_widget_destroy),
2009         GTK_OBJECT (window));
2010
2011       gtk_widget_pop_colormap ();
2012       gtk_widget_pop_visual ();
2013     }
2014
2015   if (!GTK_WIDGET_VISIBLE (window))
2016     gtk_widget_show (window);
2017   else
2018     gtk_widget_destroy (window);
2019 }
2020
2021
2022 void
2023 file_selection_ok (GtkWidget        *w,
2024                    GtkFileSelection *fs)
2025 {
2026   g_print ("%s\n", gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs)));
2027   gtk_widget_destroy (GTK_WIDGET (fs));
2028 }
2029
2030 void
2031 create_file_selection ()
2032 {
2033   static GtkWidget *window = NULL;
2034
2035   if (!window)
2036     {
2037       window = gtk_file_selection_new ("file selection dialog");
2038       gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
2039
2040       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2041                           GTK_SIGNAL_FUNC(destroy_window),
2042                           &window);
2043       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2044                           GTK_SIGNAL_FUNC(destroy_window),
2045                           &window);
2046
2047       gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (window)->ok_button),
2048                           "clicked", GTK_SIGNAL_FUNC(file_selection_ok),
2049                           window);
2050       gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (window)->cancel_button),
2051                                  "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
2052                                  GTK_OBJECT (window));
2053     }
2054
2055   if (!GTK_WIDGET_VISIBLE (window))
2056     gtk_widget_show (window);
2057   else
2058     gtk_widget_destroy (window);
2059 }
2060
2061
2062 /*
2063  * GtkDialog
2064  */
2065 static GtkWidget *dialog_window = NULL;
2066
2067 void
2068 label_toggle (GtkWidget  *widget,
2069               GtkWidget **label)
2070 {
2071   if (!(*label))
2072     {
2073       *label = gtk_label_new ("Dialog Test");
2074       gtk_signal_connect (GTK_OBJECT (*label),
2075                           "destroy",
2076                           GTK_SIGNAL_FUNC (gtk_widget_destroyed),
2077                           label);
2078       gtk_misc_set_padding (GTK_MISC (*label), 10, 10);
2079       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
2080                           *label, TRUE, TRUE, 0);
2081       gtk_widget_show (*label);
2082     }
2083   else
2084     gtk_widget_destroy (*label);
2085 }
2086
2087 void
2088 create_dialog ()
2089 {
2090   static GtkWidget *label;
2091   GtkWidget *button;
2092
2093   if (!dialog_window)
2094     {
2095       dialog_window = gtk_dialog_new ();
2096
2097       gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
2098                           GTK_SIGNAL_FUNC(destroy_window),
2099                           &dialog_window);
2100       gtk_signal_connect (GTK_OBJECT (dialog_window), "delete_event",
2101                           GTK_SIGNAL_FUNC(destroy_window),
2102                           &dialog_window);
2103
2104       gtk_window_set_title (GTK_WINDOW (dialog_window), "dialog");
2105       gtk_container_border_width (GTK_CONTAINER (dialog_window), 0);
2106
2107       button = gtk_button_new_with_label ("OK");
2108       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2109       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
2110                           button, TRUE, TRUE, 0);
2111       gtk_widget_grab_default (button);
2112       gtk_widget_show (button);
2113
2114       button = gtk_button_new_with_label ("Toggle");
2115       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2116                           GTK_SIGNAL_FUNC (label_toggle),
2117                           &label);
2118       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2119       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
2120                           button, TRUE, TRUE, 0);
2121       gtk_widget_show (button);
2122
2123       label = NULL;
2124     }
2125
2126   if (!GTK_WIDGET_VISIBLE (dialog_window))
2127     gtk_widget_show (dialog_window);
2128   else
2129     gtk_widget_destroy (dialog_window);
2130 }
2131
2132
2133 /*
2134  * GtkRange
2135  */
2136 void
2137 create_range_controls ()
2138 {
2139   static GtkWidget *window = NULL;
2140   GtkWidget *box1;
2141   GtkWidget *box2;
2142   GtkWidget *button;
2143   GtkWidget *scrollbar;
2144   GtkWidget *scale;
2145   GtkWidget *separator;
2146   GtkObject *adjustment;
2147
2148   if (!window)
2149     {
2150       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2151
2152       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2153                           GTK_SIGNAL_FUNC(destroy_window),
2154                           &window);
2155       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2156                           GTK_SIGNAL_FUNC(destroy_window),
2157                           &window);
2158
2159       gtk_window_set_title (GTK_WINDOW (window), "range controls");
2160       gtk_container_border_width (GTK_CONTAINER (window), 0);
2161
2162
2163       box1 = gtk_vbox_new (FALSE, 0);
2164       gtk_container_add (GTK_CONTAINER (window), box1);
2165       gtk_widget_show (box1);
2166
2167
2168       box2 = gtk_vbox_new (FALSE, 10);
2169       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2170       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2171       gtk_widget_show (box2);
2172
2173
2174       adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
2175
2176       scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
2177       gtk_widget_set_usize (GTK_WIDGET (scale), 150, 30);
2178       gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
2179       gtk_scale_set_digits (GTK_SCALE (scale), 1);
2180       gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
2181       gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
2182       gtk_widget_show (scale);
2183
2184       scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adjustment));
2185       gtk_range_set_update_policy (GTK_RANGE (scrollbar),
2186                                    GTK_UPDATE_CONTINUOUS);
2187       gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0);
2188       gtk_widget_show (scrollbar);
2189
2190
2191       separator = gtk_hseparator_new ();
2192       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2193       gtk_widget_show (separator);
2194
2195
2196       box2 = gtk_vbox_new (FALSE, 10);
2197       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2198       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2199       gtk_widget_show (box2);
2200
2201
2202       button = gtk_button_new_with_label ("close");
2203       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2204                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2205                                  GTK_OBJECT (window));
2206       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2207       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2208       gtk_widget_grab_default (button);
2209       gtk_widget_show (button);
2210     }
2211
2212   if (!GTK_WIDGET_VISIBLE (window))
2213     gtk_widget_show (window);
2214   else
2215     gtk_widget_destroy (window);
2216 }
2217
2218
2219 /*
2220  * GtkRulers
2221  */
2222 void
2223 create_rulers ()
2224 {
2225   static GtkWidget *window = NULL;
2226   GtkWidget *table;
2227   GtkWidget *ruler;
2228
2229   if (!window)
2230     {
2231       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2232
2233       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2234                           GTK_SIGNAL_FUNC(destroy_window),
2235                           &window);
2236       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2237                           GTK_SIGNAL_FUNC(destroy_window),
2238                           &window);
2239
2240       gtk_window_set_title (GTK_WINDOW (window), "rulers");
2241       gtk_widget_set_usize (window, 300, 300);
2242       gtk_widget_set_events (window,
2243                              GDK_POINTER_MOTION_MASK
2244                              | GDK_POINTER_MOTION_HINT_MASK);
2245       gtk_container_border_width (GTK_CONTAINER (window), 0);
2246
2247       table = gtk_table_new (2, 2, FALSE);
2248       gtk_container_add (GTK_CONTAINER (window), table);
2249       gtk_widget_show (table);
2250
2251       ruler = gtk_hruler_new ();
2252       gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
2253
2254       gtk_signal_connect_object (
2255         GTK_OBJECT (window),
2256         "motion_notify_event",
2257         GTK_SIGNAL_FUNC(
2258           GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
2259         GTK_OBJECT (ruler));
2260
2261       gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
2262                         GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
2263       gtk_widget_show (ruler);
2264
2265
2266       ruler = gtk_vruler_new ();
2267       gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
2268
2269       gtk_signal_connect_object (
2270         GTK_OBJECT (window),
2271         "motion_notify_event",
2272         GTK_SIGNAL_FUNC (GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
2273         GTK_OBJECT (ruler));
2274
2275       gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
2276                         GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
2277       gtk_widget_show (ruler);
2278     }
2279
2280   if (!GTK_WIDGET_VISIBLE (window))
2281     gtk_widget_show (window);
2282   else
2283     gtk_widget_destroy (window);
2284 }
2285
2286
2287 /*
2288  * GtkText
2289  */
2290 void
2291 create_text ()
2292 {
2293   static GtkWidget *window = NULL;
2294   GtkWidget *box1;
2295   GtkWidget *box2;
2296   GtkWidget *button;
2297   GtkWidget *separator;
2298   GtkWidget *table;
2299   GtkWidget *hscrollbar;
2300   GtkWidget *vscrollbar;
2301   GtkWidget *text;
2302
2303   if (!window)
2304     {
2305       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2306       gtk_widget_set_name (window, "text window");
2307
2308       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2309                           GTK_SIGNAL_FUNC(destroy_window),
2310                           &window);
2311       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2312                           GTK_SIGNAL_FUNC(destroy_window),
2313                           &window);
2314
2315       gtk_window_set_title (GTK_WINDOW (window), "test");
2316       gtk_container_border_width (GTK_CONTAINER (window), 0);
2317
2318
2319       box1 = gtk_vbox_new (FALSE, 0);
2320       gtk_container_add (GTK_CONTAINER (window), box1);
2321       gtk_widget_show (box1);
2322
2323
2324       box2 = gtk_vbox_new (FALSE, 10);
2325       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2326       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2327       gtk_widget_show (box2);
2328
2329
2330       table = gtk_table_new (2, 2, FALSE);
2331       gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2);
2332       gtk_table_set_col_spacing (GTK_TABLE (table), 0, 2);
2333       gtk_box_pack_start (GTK_BOX (box2), table, TRUE, TRUE, 0);
2334       gtk_widget_show (table);
2335
2336       text = gtk_text_new (NULL, NULL);
2337       gtk_text_set_editable (GTK_TEXT (text), TRUE);
2338       gtk_table_attach_defaults (GTK_TABLE (table), text, 0, 1, 0, 1);
2339       gtk_widget_show (text);
2340
2341       hscrollbar = gtk_hscrollbar_new (GTK_TEXT (text)->hadj);
2342       gtk_table_attach (GTK_TABLE (table), hscrollbar, 0, 1, 1, 2,
2343                         GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
2344       gtk_widget_show (hscrollbar);
2345
2346       vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
2347       gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 0, 1,
2348                         GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
2349       gtk_widget_show (vscrollbar);
2350
2351       gtk_text_freeze (GTK_TEXT (text));
2352
2353       gtk_widget_realize (text);
2354
2355       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2356                        "spencer blah blah blah\n", -1);
2357       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2358                        "kimball\n", -1);
2359       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2360                        "is\n", -1);
2361       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2362                        "a\n", -1);
2363       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2364                        "wuss.\n", -1);
2365       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2366                        "but\n", -1);
2367       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2368                        "josephine\n", -1);
2369       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2370                        "(his\n", -1);
2371       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2372                        "girlfriend\n", -1);
2373       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2374                        "is\n", -1);
2375       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2376                        "not).\n", -1);
2377       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2378                        "why?\n", -1);
2379       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2380                        "because\n", -1);
2381       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2382                        "spencer\n", -1);
2383       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2384                        "puked\n", -1);
2385       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2386                        "last\n", -1);
2387       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2388                        "night\n", -1);
2389       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2390                        "but\n", -1);
2391       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2392                        "josephine\n", -1);
2393       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2394                        "did\n", -1);
2395       gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
2396                        "not", -1);
2397
2398       gtk_text_thaw (GTK_TEXT (text));
2399
2400       separator = gtk_hseparator_new ();
2401       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2402       gtk_widget_show (separator);
2403
2404
2405       box2 = gtk_vbox_new (FALSE, 10);
2406       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2407       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2408       gtk_widget_show (box2);
2409
2410
2411       button = gtk_button_new_with_label ("close");
2412       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2413                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
2414                                  GTK_OBJECT (window));
2415       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2416       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2417       gtk_widget_grab_default (button);
2418       gtk_widget_show (button);
2419     }
2420
2421   if (!GTK_WIDGET_VISIBLE (window))
2422     gtk_widget_show (window);
2423   else
2424     gtk_widget_destroy (window);
2425 }
2426
2427
2428 /*
2429  * GtkNotebook
2430  */
2431
2432 GdkPixmap *book_open;
2433 GdkPixmap *book_closed;
2434 GdkBitmap *book_open_mask;
2435 GdkBitmap *book_closed_mask;
2436
2437 static char * book_open_xpm[] = {
2438 "16 16 11 1",
2439 "       c None",
2440 ".      c #28A22CB228A2",
2441 "X      c #FFFFFFFFFFFF",
2442 "o      c #F7DEF7DEF7DE",
2443 "O      c #000000000000",
2444 "+      c #FFFF6DB60000",
2445 "@      c #CF3CCF3CCF3C",
2446 "#      c #FFFFDB6C0000",
2447 "$      c #30C234D330C2",
2448 "%      c #C71BC30BC71B",
2449 "&      c #D75C6DB60000",
2450 "                ",
2451 "  ..            ",
2452 "  .X.           ",
2453 "  .oO     ...   ",
2454 " .+Xo.  ..oX..  ",
2455 " .+oXo..XXoX.@..",
2456 " .+ooX.@ooXo.@#.",
2457 " .+XXo.@XooX.@+.",
2458 " .+XoX.@XoXo.@#.",
2459 " .+oXo.@oXXX.@+.",
2460 " .++Xo$@oOO..%#.",
2461 " ..+&X.@.O@@@@+.",
2462 "   .++........#.",
2463 "   .+..+++++++&$",
2464 "   .+++.......$.",
2465 "    ...         "};
2466
2467 static char * book_closed_xpm[] = {
2468 "16 16 12 1",
2469 "       c None",
2470 ".      c #000000000000",
2471 "X      c #FFFF6DB60000",
2472 "o      c #082008200820",
2473 "O      c #AEBA00005144",
2474 "+      c #FFFFDB6C0000",
2475 "@      c #AEBA00000000",
2476 "#      c #D75CDB6C0000",
2477 "$      c #28A22CB228A2",
2478 "%      c #FFFFFFFFFFFF",
2479 "&      c #F7DEF7DEF7DE",
2480 "*      c #30C234D330C2",
2481 "                ",
2482 "       ..       ",
2483 "     ..XX.      ",
2484 "   ..XXXXX.     ",
2485 " o.XXXXXXXX.    ",
2486 ".O+XXXXXXXXX.   ",
2487 "o.@#XXXXXXXXX.  ",
2488 ".X.O+XXXXXXXXXo ",
2489 ".XX.@+XXXXXXXX.$",
2490 "oXXX.O+XXXXX..%$",
2491 " .XXX.@+XX..&&&$",
2492 "  .XXX.O..&%&%.*",
2493 "   .XX$.&&%&..  ",
2494 "    .X$&%&.o    ",
2495 "     .$%..      ",
2496 "      .o        "};
2497
2498 static void
2499 page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num)
2500 {
2501   GtkNotebookPage *oldpage;
2502   GtkWidget *pixwid;
2503
2504   oldpage = GTK_NOTEBOOK (widget)->cur_page;
2505
2506   if (page == oldpage)
2507     return;
2508
2509   pixwid = ((GtkBoxChild*)(GTK_BOX (page->tab_label)->children->data))->widget;
2510   gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
2511   pixwid = ((GtkBoxChild*) (GTK_BOX (page->menu_label)->children->data))->widget;
2512   gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
2513
2514   if (oldpage)
2515     {
2516       pixwid = ((GtkBoxChild*) (GTK_BOX
2517                                 (oldpage->tab_label)->children->data))->widget;
2518       gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
2519       pixwid = ((GtkBoxChild*) (GTK_BOX (oldpage->menu_label)->children->data))->widget;
2520       gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
2521     }
2522 }
2523
2524 static void
2525 create_pages (GtkNotebook *notebook, gint start, gint end)
2526 {
2527   GtkWidget *child = NULL;
2528   GtkWidget *label;
2529   GtkWidget *entry;
2530   GtkWidget *box;
2531   GtkWidget *hbox;
2532   GtkWidget *label_box;
2533   GtkWidget *menu_box;
2534   GtkWidget *button;
2535   GtkWidget *pixwid;
2536   gint i;
2537   char buffer[32];
2538
2539   for (i = start; i <= end; i++)
2540     {
2541       sprintf (buffer, "Page %d", i);
2542
2543       switch (i%4)
2544         {
2545         case 3:
2546           child = gtk_button_new_with_label (buffer);
2547           gtk_container_border_width (GTK_CONTAINER(child), 10);
2548           break;
2549         case 2:
2550           child = gtk_label_new (buffer);
2551           break;
2552         case 1:
2553           child = gtk_frame_new (buffer);
2554           gtk_container_border_width (GTK_CONTAINER (child), 10);
2555
2556           box = gtk_vbox_new (TRUE,0);
2557           gtk_container_border_width (GTK_CONTAINER (box), 10);
2558           gtk_container_add (GTK_CONTAINER (child), box);
2559
2560           label = gtk_label_new (buffer);
2561           gtk_box_pack_start (GTK_BOX(box), label, TRUE, TRUE, 5);
2562
2563           entry = gtk_entry_new ();
2564           gtk_box_pack_start (GTK_BOX(box), entry, TRUE, TRUE, 5);
2565
2566           hbox = gtk_hbox_new (TRUE,0);
2567           gtk_box_pack_start (GTK_BOX(box), hbox, TRUE, TRUE, 5);
2568
2569           button = gtk_button_new_with_label ("Ok");
2570           gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
2571
2572           button = gtk_button_new_with_label ("Cancel");
2573           gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
2574           break;
2575         case 0:
2576           child = gtk_frame_new (buffer);
2577           gtk_container_border_width (GTK_CONTAINER (child), 10);
2578
2579           label = gtk_label_new (buffer);
2580           gtk_container_add (GTK_CONTAINER (child), label);
2581           break;
2582         }
2583
2584       gtk_widget_show_all (child);
2585
2586       label_box = gtk_hbox_new (FALSE, 0);
2587       pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
2588       gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
2589       gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
2590       label = gtk_label_new (buffer);
2591       gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
2592       gtk_widget_show_all (label_box);
2593
2594       menu_box = gtk_hbox_new (FALSE, 0);
2595       pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
2596       gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
2597       gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
2598       label = gtk_label_new (buffer);
2599       gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0);
2600       gtk_widget_show_all (menu_box);
2601
2602       gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
2603     }
2604 }
2605
2606 static void
2607 rotate_notebook (GtkButton   *button,
2608                  GtkNotebook *notebook)
2609 {
2610   gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos + 1) % 4);
2611 }
2612
2613 static void
2614 standard_notebook (GtkButton   *button,
2615                    GtkNotebook *notebook)
2616 {
2617   gint i;
2618
2619   gtk_notebook_set_show_tabs (notebook, TRUE);
2620   gtk_notebook_set_scrollable (notebook, FALSE);
2621   if (g_list_length (notebook->children) == 15)
2622     for (i = 0; i < 10; i++)
2623       gtk_notebook_remove_page (notebook, 5);
2624 }
2625
2626 static void
2627 notabs_notebook (GtkButton   *button,
2628                  GtkNotebook *notebook)
2629 {
2630   gint i;
2631
2632   gtk_notebook_set_show_tabs (notebook, FALSE);
2633   if (g_list_length (notebook->children) == 15)
2634     for (i = 0; i < 10; i++)
2635       gtk_notebook_remove_page (notebook, 5);
2636 }
2637
2638 static void
2639 scrollable_notebook (GtkButton   *button,
2640                      GtkNotebook *notebook)
2641 {
2642   gtk_notebook_set_show_tabs (notebook, TRUE);
2643   gtk_notebook_set_scrollable (notebook, TRUE);
2644   if (g_list_length (notebook->children) == 5)
2645     create_pages (notebook, 6, 15);
2646 }
2647
2648 static void
2649 notebook_popup (GtkToggleButton *button,
2650                 GtkNotebook     *notebook)
2651 {
2652   if (button->active)
2653     gtk_notebook_popup_enable (notebook);
2654   else
2655     gtk_notebook_popup_disable (notebook);
2656 }
2657
2658 static void
2659 create_notebook ()
2660 {
2661   static GtkWidget *window = NULL;
2662   GtkWidget *box1;
2663   GtkWidget *box2;
2664   GtkWidget *button;
2665   GtkWidget *separator;
2666   GtkWidget *notebook;
2667   GtkWidget *omenu;
2668   GtkWidget *menu;
2669   GtkWidget *submenu;
2670   GtkWidget *menuitem;
2671   GSList *group;
2672   GdkColor transparent;
2673
2674   if (!window)
2675     {
2676       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2677
2678       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2679                           GTK_SIGNAL_FUNC(destroy_window),
2680                           &window);
2681       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2682                           GTK_SIGNAL_FUNC(destroy_window),
2683                           &window);
2684
2685       gtk_window_set_title (GTK_WINDOW (window), "notebook");
2686       gtk_container_border_width (GTK_CONTAINER (window), 0);
2687
2688       box1 = gtk_vbox_new (FALSE, 0);
2689       gtk_container_add (GTK_CONTAINER (window), box1);
2690
2691       notebook = gtk_notebook_new ();
2692       gtk_signal_connect (GTK_OBJECT (notebook), "switch_page",
2693                           GTK_SIGNAL_FUNC (page_switch), NULL);
2694       gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
2695       gtk_box_pack_start (GTK_BOX (box1), notebook, TRUE, TRUE, 0);
2696       gtk_container_border_width (GTK_CONTAINER (notebook), 10);
2697
2698       book_open = gdk_pixmap_create_from_xpm_d (notebook->window,
2699                                                 &book_open_mask,
2700                                                 &transparent,
2701                                                 book_open_xpm);
2702       book_closed = gdk_pixmap_create_from_xpm_d (notebook->window,
2703                                                   &book_closed_mask,
2704                                                   &transparent,
2705                                                   book_closed_xpm);
2706
2707       create_pages (GTK_NOTEBOOK (notebook), 1, 5);
2708
2709       separator = gtk_hseparator_new ();
2710       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10);
2711
2712       box2 = gtk_hbox_new (TRUE, 5);
2713       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2714
2715       omenu = gtk_option_menu_new ();
2716       menu = gtk_menu_new ();
2717       submenu = NULL;
2718       group = NULL;
2719
2720       menuitem = gtk_radio_menu_item_new_with_label (group, "Standard");
2721       gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
2722                                  GTK_SIGNAL_FUNC (standard_notebook),
2723                                  GTK_OBJECT (notebook));
2724       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
2725       gtk_menu_append (GTK_MENU (menu), menuitem);
2726       gtk_widget_show (menuitem);
2727       menuitem = gtk_radio_menu_item_new_with_label (group, "w/o Tabs");
2728       gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
2729                                  GTK_SIGNAL_FUNC (notabs_notebook),
2730                                  GTK_OBJECT (notebook));
2731       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
2732       gtk_menu_append (GTK_MENU (menu), menuitem);
2733       gtk_widget_show (menuitem);
2734       menuitem = gtk_radio_menu_item_new_with_label (group, "Scrollable");
2735       gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
2736                                  GTK_SIGNAL_FUNC (scrollable_notebook),
2737                                  GTK_OBJECT (notebook));
2738       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
2739       gtk_menu_append (GTK_MENU (menu), menuitem);
2740       gtk_widget_show (menuitem);
2741
2742       gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
2743       gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, FALSE, 0);
2744       button = gtk_check_button_new_with_label ("enable popup menu");
2745       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
2746       gtk_signal_connect (GTK_OBJECT(button), "clicked",
2747                           GTK_SIGNAL_FUNC (notebook_popup),
2748                           GTK_OBJECT (notebook));
2749
2750       box2 = gtk_hbox_new (FALSE, 10);
2751       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2752       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2753
2754       button = gtk_button_new_with_label ("close");
2755       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2756                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
2757                                  GTK_OBJECT (window));
2758       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2759       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2760       gtk_widget_grab_default (button);
2761
2762       button = gtk_button_new_with_label ("next");
2763       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2764                                  GTK_SIGNAL_FUNC (gtk_notebook_next_page),
2765                                  GTK_OBJECT (notebook));
2766       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2767
2768       button = gtk_button_new_with_label ("prev");
2769       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2770                                  GTK_SIGNAL_FUNC (gtk_notebook_prev_page),
2771                                  GTK_OBJECT (notebook));
2772       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2773
2774       button = gtk_button_new_with_label ("rotate");
2775       gtk_signal_connect (GTK_OBJECT (button), "clicked",
2776                           GTK_SIGNAL_FUNC (rotate_notebook),
2777                           notebook);
2778       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2779     }
2780
2781   if (!GTK_WIDGET_VISIBLE (window))
2782     gtk_widget_show_all (window);
2783   else
2784     gtk_widget_destroy (window);
2785 }
2786
2787
2788 /*
2789  * GtkPanes
2790  */
2791 void
2792 create_panes ()
2793 {
2794   static GtkWidget *window = NULL;
2795   GtkWidget *frame;
2796   GtkWidget *hpaned;
2797   GtkWidget *vpaned;
2798
2799   if (!window)
2800     {
2801       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2802
2803       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2804                           GTK_SIGNAL_FUNC(destroy_window),
2805                           &window);
2806       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2807                           GTK_SIGNAL_FUNC(destroy_window),
2808                           &window);
2809
2810       gtk_window_set_title (GTK_WINDOW (window), "Panes");
2811       gtk_container_border_width (GTK_CONTAINER (window), 0);
2812
2813       vpaned = gtk_vpaned_new ();
2814       gtk_container_add (GTK_CONTAINER (window), vpaned);
2815       gtk_container_border_width (GTK_CONTAINER(vpaned), 5);
2816       gtk_widget_show (vpaned);
2817
2818       hpaned = gtk_hpaned_new ();
2819       gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
2820
2821       frame = gtk_frame_new (NULL);
2822       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
2823       gtk_widget_set_usize (frame, 60, 60);
2824       gtk_paned_add1 (GTK_PANED (hpaned), frame);
2825       gtk_widget_show (frame);
2826
2827       frame = gtk_frame_new (NULL);
2828       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
2829       gtk_widget_set_usize (frame, 80, 60);
2830       gtk_paned_add2 (GTK_PANED (hpaned), frame);
2831       gtk_widget_show (frame);
2832
2833       gtk_widget_show (hpaned);
2834
2835       frame = gtk_frame_new (NULL);
2836       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
2837       gtk_widget_set_usize (frame, 60, 80);
2838       gtk_paned_add2 (GTK_PANED (vpaned), frame);
2839       gtk_widget_show (frame);
2840     }
2841
2842   if (!GTK_WIDGET_VISIBLE (window))
2843     gtk_widget_show (window);
2844   else
2845     gtk_widget_destroy (window);
2846 }
2847
2848
2849 /*
2850  * Drag -N- Drop
2851  */
2852
2853 gboolean
2854 dnd_drop_destroy_popup (GtkWidget *widget, GtkWindow **window)
2855 {
2856   if(GTK_IS_BUTTON(widget)) /* I.e. they clicked the close button */
2857     gtk_widget_destroy(GTK_WIDGET(*window));
2858   else {
2859     gtk_grab_remove(GTK_WIDGET(*window));
2860     *window = NULL;
2861   }
2862   return TRUE;
2863 }
2864
2865 void
2866 dnd_drop (GtkWidget *button, GdkEvent *event)
2867 {
2868   static GtkWidget *window = NULL;
2869   GtkWidget *vbox, *lbl, *btn;
2870   gchar *msg;
2871
2872   window = gtk_window_new(GTK_WINDOW_DIALOG);
2873   gtk_container_border_width (GTK_CONTAINER(window), 10);
2874
2875   gtk_signal_connect (GTK_OBJECT (window), "destroy",
2876                       GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
2877                       &window);
2878   gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2879                       GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
2880                       &window);
2881
2882   vbox = gtk_vbox_new(FALSE, 5);
2883
2884   /* Display message that we got from drop source */
2885   msg = g_malloc(strlen(event->dropdataavailable.data)
2886                  + strlen(event->dropdataavailable.data_type) + 100);
2887   sprintf(msg, "Drop data of type %s was:\n\n%s",
2888           event->dropdataavailable.data_type,
2889           (char *)event->dropdataavailable.data);
2890   lbl = gtk_label_new(msg);
2891   gtk_label_set_justify(GTK_LABEL(lbl), GTK_JUSTIFY_FILL);
2892   g_free(msg);
2893   gtk_widget_show(lbl);
2894   gtk_box_pack_start_defaults(GTK_BOX(vbox), lbl);
2895
2896   /* Provide an obvious way out of this heinousness */
2897   btn = gtk_button_new_with_label("Continue with life in\nspite of this oppression");
2898   gtk_signal_connect (GTK_OBJECT (btn), "clicked",
2899                       GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
2900                       &window);
2901   gtk_widget_show(btn);
2902   gtk_box_pack_start_defaults(GTK_BOX(vbox), btn);
2903
2904   gtk_container_add(GTK_CONTAINER(window), vbox);
2905
2906   gtk_widget_show(vbox);
2907   gtk_grab_add(window);
2908   gtk_widget_show(window);
2909 }
2910
2911 void
2912 dnd_drag_request (GtkWidget *button, GdkEvent *event)
2913 {
2914 #define DND_STRING "Bill Gates demands royalties for\nyour use of his innovation."
2915   gtk_widget_dnd_data_set (button, event, DND_STRING, strlen(DND_STRING) + 1);
2916 }
2917
2918 void
2919 create_dnd ()
2920 {
2921   static GtkWidget *window = NULL;
2922   GtkWidget *box1;
2923   GtkWidget *box2;
2924   GtkWidget *box3;
2925   GtkWidget *frame;
2926   GtkWidget *button;
2927   GtkWidget *separator;
2928
2929   /* For clarity... */
2930   char *possible_drag_types[] = {"text/plain"};
2931   char *accepted_drop_types[] = {"text/plain"};
2932
2933   if (!window)
2934     {
2935       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2936
2937       gtk_signal_connect (GTK_OBJECT (window), "destroy",
2938                           GTK_SIGNAL_FUNC(destroy_window),
2939                           &window);
2940       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
2941                           GTK_SIGNAL_FUNC(destroy_window),
2942                           &window);
2943
2944       gtk_window_set_title (GTK_WINDOW (window), "Drag -N- Drop");
2945       gtk_container_border_width (GTK_CONTAINER (window), 0);
2946
2947       box1 = gtk_vbox_new (FALSE, 0);
2948       gtk_container_add (GTK_CONTAINER (window), box1);
2949       gtk_widget_show (box1);
2950
2951       box2 = gtk_hbox_new (FALSE, 5);
2952       gtk_container_border_width (GTK_CONTAINER (box2), 10);
2953       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2954       gtk_widget_show (box2);
2955
2956       frame = gtk_frame_new ("Drag");
2957       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
2958       gtk_widget_show (frame);
2959
2960       box3 = gtk_vbox_new (FALSE, 5);
2961       gtk_container_border_width (GTK_CONTAINER (box3), 5);
2962       gtk_container_add (GTK_CONTAINER (frame), box3);
2963       gtk_widget_show (box3);
2964
2965       /*
2966        * FROM Button
2967        */
2968       button = gtk_button_new_with_label ("Drag me!");
2969       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
2970       gtk_widget_show (button);
2971
2972       /*
2973        * currently, the widget has to be realized to
2974        * set dnd on it, this needs to change
2975        */
2976       gtk_widget_realize (button);
2977       gtk_signal_connect (GTK_OBJECT (button),
2978                           "drag_request_event",
2979                           GTK_SIGNAL_FUNC(dnd_drag_request),
2980                           button);
2981
2982       gtk_widget_dnd_drag_set (button, TRUE, possible_drag_types, 1);
2983
2984
2985       frame = gtk_frame_new ("Drop");
2986       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
2987       gtk_widget_show (frame);
2988
2989       box3 = gtk_vbox_new (FALSE, 5);
2990       gtk_container_border_width (GTK_CONTAINER (box3), 5);
2991       gtk_container_add (GTK_CONTAINER (frame), box3);
2992       gtk_widget_show (box3);
2993
2994
2995       /*
2996        * TO Button
2997        */
2998       button = gtk_button_new_with_label ("To");
2999       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
3000       gtk_widget_show (button);
3001
3002       gtk_widget_realize (button);
3003       gtk_signal_connect (GTK_OBJECT (button),
3004                           "drop_data_available_event",
3005                           GTK_SIGNAL_FUNC(dnd_drop),
3006                           button);
3007
3008       gtk_widget_dnd_drop_set (button, TRUE, accepted_drop_types, 1, FALSE);
3009
3010
3011       separator = gtk_hseparator_new ();
3012       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3013       gtk_widget_show (separator);
3014
3015
3016       box2 = gtk_vbox_new (FALSE, 10);
3017       gtk_container_border_width (GTK_CONTAINER (box2), 10);
3018       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3019       gtk_widget_show (box2);
3020
3021
3022       button = gtk_button_new_with_label ("close");
3023
3024       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3025                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
3026                                  GTK_OBJECT (window));
3027
3028       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3029       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3030       gtk_widget_grab_default (button);
3031       gtk_widget_show (button);
3032     }
3033
3034   if (!GTK_WIDGET_VISIBLE (window))
3035     gtk_widget_show (window);
3036   else
3037     gtk_widget_destroy (window);
3038 }
3039
3040 /*
3041  * Shaped Windows
3042  */
3043 static GdkWindow *root_win = NULL;
3044 static GtkWidget *modeller = NULL;
3045 static GtkWidget *sheets = NULL;
3046 static GtkWidget *rings = NULL;
3047
3048 typedef struct _cursoroffset {gint x,y;} CursorOffset;
3049
3050 static void
3051 shape_pressed (GtkWidget *widget, GdkEventButton *event)
3052 {
3053   CursorOffset *p;
3054
3055   /* ignore double and triple click */
3056   if (event->type != GDK_BUTTON_PRESS)
3057     return;
3058
3059   p = gtk_object_get_user_data (GTK_OBJECT(widget));
3060   p->x = (int) event->x;
3061   p->y = (int) event->y;
3062
3063   gtk_grab_add (widget);
3064   gdk_pointer_grab (widget->window, TRUE,
3065                     GDK_BUTTON_RELEASE_MASK |
3066                     GDK_BUTTON_MOTION_MASK,
3067                     NULL, NULL, 0);
3068 }
3069
3070
3071 static void
3072 shape_released (GtkWidget *widget)
3073 {
3074   gtk_grab_remove (widget);
3075   gdk_pointer_ungrab (0);
3076 }
3077
3078 static void
3079 shape_motion (GtkWidget      *widget,
3080               GdkEventMotion *event)
3081 {
3082   gint xp, yp;
3083   CursorOffset * p;
3084   GdkModifierType mask;
3085
3086   p = gtk_object_get_user_data (GTK_OBJECT (widget));
3087
3088   gdk_window_get_pointer (root_win, &xp, &yp, &mask);
3089   gtk_widget_set_uposition (widget, xp  - p->x, yp  - p->y);
3090 }
3091
3092 GtkWidget *
3093 shape_create_icon (char     *xpm_file,
3094                    gint      x,
3095                    gint      y,
3096                    gint      px,
3097                    gint      py,
3098                    gint      window_type)
3099 {
3100   GtkWidget *window;
3101   GtkWidget *pixmap;
3102   GtkWidget *fixed;
3103   CursorOffset* icon_pos;
3104   GdkGC* gc;
3105   GdkBitmap *gdk_pixmap_mask;
3106   GdkPixmap *gdk_pixmap;
3107   GtkStyle *style;
3108
3109   style = gtk_widget_get_default_style ();
3110   gc = style->black_gc;
3111
3112   /*
3113    * GDK_WINDOW_TOPLEVEL works also, giving you a title border
3114    */
3115   window = gtk_window_new (window_type);
3116
3117   fixed = gtk_fixed_new ();
3118   gtk_widget_set_usize (fixed, 100,100);
3119   gtk_container_add (GTK_CONTAINER (window), fixed);
3120   gtk_widget_show (fixed);
3121
3122   gtk_widget_set_events (window,
3123                          gtk_widget_get_events (window) |
3124                          GDK_BUTTON_MOTION_MASK |
3125                          GDK_BUTTON_PRESS_MASK);
3126
3127   gtk_widget_realize (window);
3128   gdk_pixmap = gdk_pixmap_create_from_xpm (window->window, &gdk_pixmap_mask,
3129                                            &style->bg[GTK_STATE_NORMAL],
3130                                            xpm_file);
3131
3132   pixmap = gtk_pixmap_new (gdk_pixmap, gdk_pixmap_mask);
3133   gtk_fixed_put (GTK_FIXED (fixed), pixmap, px,py);
3134   gtk_widget_show (pixmap);
3135
3136   gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px,py);
3137
3138
3139   gtk_signal_connect (GTK_OBJECT (window), "button_press_event",
3140                       GTK_SIGNAL_FUNC (shape_pressed),NULL);
3141   gtk_signal_connect (GTK_OBJECT (window), "button_release_event",
3142                       GTK_SIGNAL_FUNC (shape_released),NULL);
3143   gtk_signal_connect (GTK_OBJECT (window), "motion_notify_event",
3144                       GTK_SIGNAL_FUNC (shape_motion),NULL);
3145
3146   icon_pos = g_new (CursorOffset, 1);
3147   gtk_object_set_user_data(GTK_OBJECT(window), icon_pos);
3148
3149   gtk_widget_set_uposition (window, x, y);
3150   gtk_widget_show (window);
3151
3152   return window;
3153 }
3154
3155 void
3156 create_shapes ()
3157 {
3158   root_win = gdk_window_foreign_new (GDK_ROOT_WINDOW ());
3159
3160   if (!modeller)
3161     {
3162       modeller = shape_create_icon ("Modeller.xpm",
3163                                     440, 140, 0,0, GTK_WINDOW_POPUP);
3164
3165       gtk_signal_connect (GTK_OBJECT (modeller), "destroy",
3166                           GTK_SIGNAL_FUNC(destroy_window),
3167                           &modeller);
3168       gtk_signal_connect (GTK_OBJECT (modeller), "delete_event",
3169                           GTK_SIGNAL_FUNC(destroy_window),
3170                           &modeller);
3171     }
3172   else
3173     gtk_widget_destroy (modeller);
3174
3175   if (!sheets)
3176     {
3177       sheets = shape_create_icon ("FilesQueue.xpm",
3178                                   580, 170, 0,0, GTK_WINDOW_POPUP);
3179
3180       gtk_signal_connect (GTK_OBJECT (sheets), "destroy",
3181                           GTK_SIGNAL_FUNC(destroy_window),
3182                           &sheets);
3183       gtk_signal_connect (GTK_OBJECT (sheets), "delete_event",
3184                           GTK_SIGNAL_FUNC(destroy_window),
3185                           &sheets);
3186
3187     }
3188   else
3189     gtk_widget_destroy (sheets);
3190
3191   if (!rings)
3192     {
3193       rings = shape_create_icon ("3DRings.xpm",
3194                                  460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
3195
3196       gtk_signal_connect (GTK_OBJECT (rings), "destroy",
3197                           GTK_SIGNAL_FUNC(destroy_window),
3198                           &rings);
3199       gtk_signal_connect (GTK_OBJECT (rings), "delete_event",
3200                           GTK_SIGNAL_FUNC(destroy_window),
3201                           &rings);
3202     }
3203   else
3204     gtk_widget_destroy (rings);
3205 }
3206
3207
3208 /*
3209  * Progress Bar
3210  */
3211 static int progress_timer = 0;
3212
3213 gint
3214 progress_timeout (gpointer data)
3215 {
3216   gfloat new_val;
3217
3218   new_val = GTK_PROGRESS_BAR (data)->percentage;
3219   if (new_val >= 1.0)
3220     new_val = 0.0;
3221   new_val += 0.02;
3222
3223   gtk_progress_bar_update (GTK_PROGRESS_BAR (data), new_val);
3224
3225   return TRUE;
3226 }
3227
3228 void
3229 destroy_progress (GtkWidget  *widget,
3230                   GtkWidget **window)
3231 {
3232   destroy_window (widget, window);
3233   gtk_timeout_remove (progress_timer);
3234   progress_timer = 0;
3235 }
3236
3237 void
3238 create_progress_bar ()
3239 {
3240   static GtkWidget *window = NULL;
3241   GtkWidget *button;
3242   GtkWidget *vbox;
3243   GtkWidget *pbar;
3244   GtkWidget *label;
3245
3246   if (!window)
3247     {
3248       window = gtk_dialog_new ();
3249
3250       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3251                           GTK_SIGNAL_FUNC(destroy_progress),
3252                           &window);
3253       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3254                           GTK_SIGNAL_FUNC(destroy_progress),
3255                           &window);
3256
3257       gtk_window_set_title (GTK_WINDOW (window), "dialog");
3258       gtk_container_border_width (GTK_CONTAINER (window), 0);
3259
3260
3261       vbox = gtk_vbox_new (FALSE, 5);
3262       gtk_container_border_width (GTK_CONTAINER (vbox), 10);
3263       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
3264                           vbox, TRUE, TRUE, 0);
3265       gtk_widget_show (vbox);
3266
3267       label = gtk_label_new ("progress...");
3268       gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3269       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
3270       gtk_widget_show (label);
3271
3272       pbar = gtk_progress_bar_new ();
3273       gtk_widget_set_usize (pbar, 200, 20);
3274       gtk_box_pack_start (GTK_BOX (vbox), pbar, TRUE, TRUE, 0);
3275       gtk_widget_show (pbar);
3276
3277       progress_timer = gtk_timeout_add (100, progress_timeout, pbar);
3278
3279       button = gtk_button_new_with_label ("close");
3280       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3281                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
3282                                  GTK_OBJECT (window));
3283       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3284       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3285                           button, TRUE, TRUE, 0);
3286       gtk_widget_grab_default (button);
3287       gtk_widget_show (button);
3288     }
3289
3290   if (!GTK_WIDGET_VISIBLE (window))
3291     gtk_widget_show (window);
3292   else
3293     gtk_widget_destroy (window);
3294 }
3295
3296
3297 /*
3298  * Color Preview
3299  */
3300 static int color_idle = 0;
3301
3302 gint
3303 color_idle_func (GtkWidget *preview)
3304 {
3305   static int count = 1;
3306   guchar buf[768];
3307   int i, j, k;
3308
3309   for (i = 0; i < 256; i++)
3310     {
3311       for (j = 0, k = 0; j < 256; j++)
3312         {
3313           buf[k+0] = i + count;
3314           buf[k+1] = 0;
3315           buf[k+2] = j + count;
3316           k += 3;
3317         }
3318
3319       gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
3320     }
3321
3322   count += 1;
3323
3324   gtk_widget_draw (preview, NULL);
3325
3326   return TRUE;
3327 }
3328
3329 void
3330 color_preview_destroy (GtkWidget  *widget,
3331                        GtkWidget **window)
3332 {
3333   gtk_idle_remove (color_idle);
3334   color_idle = 0;
3335
3336   destroy_window (widget, window);
3337 }
3338
3339 void
3340 create_color_preview ()
3341 {
3342   static GtkWidget *window = NULL;
3343   GtkWidget *preview;
3344   guchar buf[768];
3345   int i, j, k;
3346
3347   if (!window)
3348     {
3349       gtk_widget_push_visual (gtk_preview_get_visual ());
3350       gtk_widget_push_colormap (gtk_preview_get_cmap ());
3351
3352       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3353
3354       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3355                           GTK_SIGNAL_FUNC(color_preview_destroy),
3356                           &window);
3357       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3358                           GTK_SIGNAL_FUNC(color_preview_destroy),
3359                           &window);
3360
3361       gtk_window_set_title (GTK_WINDOW (window), "test");
3362       gtk_container_border_width (GTK_CONTAINER (window), 10);
3363
3364       preview = gtk_preview_new (GTK_PREVIEW_COLOR);
3365       gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
3366       gtk_container_add (GTK_CONTAINER (window), preview);
3367       gtk_widget_show (preview);
3368
3369       for (i = 0; i < 256; i++)
3370         {
3371           for (j = 0, k = 0; j < 256; j++)
3372             {
3373               buf[k+0] = i;
3374               buf[k+1] = 0;
3375               buf[k+2] = j;
3376               k += 3;
3377             }
3378
3379           gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
3380         }
3381
3382       color_idle = gtk_idle_add ((GtkFunction) color_idle_func, preview);
3383
3384       gtk_widget_pop_colormap ();
3385       gtk_widget_pop_visual ();
3386     }
3387
3388   if (!GTK_WIDGET_VISIBLE (window))
3389     gtk_widget_show (window);
3390   else
3391     gtk_widget_destroy (window);
3392 }
3393
3394
3395 /*
3396  * Gray Preview
3397  */
3398 static int gray_idle = 0;
3399
3400 gint
3401 gray_idle_func (GtkWidget *preview)
3402 {
3403   static int count = 1;
3404   guchar buf[256];
3405   int i, j;
3406
3407   for (i = 0; i < 256; i++)
3408     {
3409       for (j = 0; j < 256; j++)
3410         buf[j] = i + j + count;
3411
3412       gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
3413     }
3414
3415   count += 1;
3416
3417   gtk_widget_draw (preview, NULL);
3418
3419   return TRUE;
3420 }
3421
3422 void
3423 gray_preview_destroy (GtkWidget  *widget,
3424                       GtkWidget **window)
3425 {
3426   gtk_idle_remove (gray_idle);
3427   gray_idle = 0;
3428
3429   destroy_window (widget, window);
3430 }
3431
3432 void
3433 create_gray_preview ()
3434 {
3435   static GtkWidget *window = NULL;
3436   GtkWidget *preview;
3437   guchar buf[256];
3438   int i, j;
3439
3440   if (!window)
3441     {
3442       gtk_widget_push_visual (gtk_preview_get_visual ());
3443       gtk_widget_push_colormap (gtk_preview_get_cmap ());
3444
3445       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3446
3447       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3448                           GTK_SIGNAL_FUNC(gray_preview_destroy),
3449                           &window);
3450       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3451                           GTK_SIGNAL_FUNC(gray_preview_destroy),
3452                           &window);
3453
3454       gtk_window_set_title (GTK_WINDOW (window), "test");
3455       gtk_container_border_width (GTK_CONTAINER (window), 10);
3456
3457       preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
3458       gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
3459       gtk_container_add (GTK_CONTAINER (window), preview);
3460       gtk_widget_show (preview);
3461
3462       for (i = 0; i < 256; i++)
3463         {
3464           for (j = 0; j < 256; j++)
3465             buf[j] = i + j;
3466
3467           gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
3468         }
3469
3470       gray_idle = gtk_idle_add ((GtkFunction) gray_idle_func, preview);
3471
3472       gtk_widget_pop_colormap ();
3473       gtk_widget_pop_visual ();
3474     }
3475
3476   if (!GTK_WIDGET_VISIBLE (window))
3477     gtk_widget_show (window);
3478   else
3479     gtk_widget_destroy (window);
3480 }
3481
3482
3483 /*
3484  * Selection Test
3485  */
3486 void
3487 selection_test_received (GtkWidget *list, GtkSelectionData *data)
3488 {
3489   GdkAtom *atoms;
3490   GtkWidget *list_item;
3491   GList *item_list;
3492   int i, l;
3493
3494   if (data->length < 0)
3495     {
3496       g_print ("Selection retrieval failed\n");
3497       return;
3498     }
3499   if (data->type != GDK_SELECTION_TYPE_ATOM)
3500     {
3501       g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
3502       return;
3503     }
3504
3505   /* Clear out any current list items */
3506
3507   gtk_list_clear_items (GTK_LIST(list), 0, -1);
3508
3509   /* Add new items to list */
3510
3511   atoms = (GdkAtom *)data->data;
3512
3513   item_list = NULL;
3514   l = data->length / sizeof (GdkAtom);
3515   for (i = 0; i < l; i++)
3516     {
3517       char *name;
3518       name = gdk_atom_name (atoms[i]);
3519       if (name != NULL)
3520         {
3521           list_item = gtk_list_item_new_with_label (name);
3522           g_free (name);
3523         }
3524       else
3525         list_item = gtk_list_item_new_with_label ("(bad atom)");
3526
3527       gtk_widget_show (list_item);
3528       item_list = g_list_append (item_list, list_item);
3529     }
3530
3531   gtk_list_append_items (GTK_LIST (list), item_list);
3532
3533   return;
3534 }
3535
3536 void
3537 selection_test_get_targets (GtkWidget *widget, GtkWidget *list)
3538 {
3539   static GdkAtom targets_atom = GDK_NONE;
3540
3541   if (targets_atom == GDK_NONE)
3542     targets_atom = gdk_atom_intern ("TARGETS", FALSE);
3543
3544   gtk_selection_convert (list, GDK_SELECTION_PRIMARY, targets_atom,
3545                          GDK_CURRENT_TIME);
3546 }
3547
3548 void
3549 create_selection_test ()
3550 {
3551   static GtkWidget *window = NULL;
3552   GtkWidget *button;
3553   GtkWidget *vbox;
3554   GtkWidget *scrolled_win;
3555   GtkWidget *list;
3556   GtkWidget *label;
3557
3558   if (!window)
3559     {
3560       window = gtk_dialog_new ();
3561
3562       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3563                           GTK_SIGNAL_FUNC(destroy_window),
3564                           &window);
3565       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3566                           GTK_SIGNAL_FUNC(destroy_window),
3567                           &window);
3568
3569       gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
3570       gtk_container_border_width (GTK_CONTAINER (window), 0);
3571
3572       /* Create the list */
3573
3574       vbox = gtk_vbox_new (FALSE, 5);
3575       gtk_container_border_width (GTK_CONTAINER (vbox), 10);
3576       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox,
3577                           TRUE, TRUE, 0);
3578       gtk_widget_show (vbox);
3579
3580       label = gtk_label_new ("Gets available targets for current selection");
3581       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
3582       gtk_widget_show (label);
3583
3584       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
3585       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
3586                                       GTK_POLICY_AUTOMATIC,
3587                                       GTK_POLICY_AUTOMATIC);
3588       gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
3589       gtk_widget_set_usize (scrolled_win, 100, 200);
3590       gtk_widget_show (scrolled_win);
3591
3592       list = gtk_list_new ();
3593       gtk_container_add (GTK_CONTAINER (scrolled_win), list);
3594
3595       gtk_signal_connect (GTK_OBJECT(list), "selection_received",
3596                           GTK_SIGNAL_FUNC (selection_test_received), NULL);
3597       gtk_widget_show (list);
3598
3599       /* .. And create some buttons */
3600       button = gtk_button_new_with_label ("Get Targets");
3601       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3602                           button, TRUE, TRUE, 0);
3603
3604       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3605                           GTK_SIGNAL_FUNC (selection_test_get_targets), list);
3606       gtk_widget_show (button);
3607
3608       button = gtk_button_new_with_label ("Quit");
3609       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3610                           button, TRUE, TRUE, 0);
3611
3612       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3613                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
3614                                  GTK_OBJECT (window));
3615       gtk_widget_show (button);
3616     }
3617
3618   if (!GTK_WIDGET_VISIBLE (window))
3619     gtk_widget_show (window);
3620   else
3621     gtk_widget_destroy (window);
3622 }
3623
3624
3625 /*
3626  * Gamma Curve
3627  */
3628 void
3629 create_gamma_curve ()
3630 {
3631   static GtkWidget *window = NULL, *curve;
3632   static int count = 0;
3633   gfloat vec[256];
3634   gint max;
3635   gint i;
3636
3637   if (!window)
3638     {
3639       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3640       gtk_window_set_title (GTK_WINDOW (window), "test");
3641       gtk_container_border_width (GTK_CONTAINER (window), 10);
3642
3643       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3644                           GTK_SIGNAL_FUNC(destroy_window),
3645                           &window);
3646       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3647                           GTK_SIGNAL_FUNC(destroy_window),
3648                           &window);
3649
3650       curve = gtk_gamma_curve_new ();
3651       gtk_container_add (GTK_CONTAINER (window), curve);
3652       gtk_widget_show (curve);
3653     }
3654
3655   max = 127 + (count % 2)*128;
3656   gtk_curve_set_range (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
3657                        0, max, 0, max);
3658   for (i = 0; i < max; ++i)
3659     vec[i] = (127 / sqrt (max)) * sqrt (i);
3660   gtk_curve_set_vector (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
3661                         max, vec);
3662
3663   if (!GTK_WIDGET_VISIBLE (window))
3664     gtk_widget_show (window);
3665   else if (count % 4 == 3)
3666     {
3667       gtk_widget_destroy (window);
3668       window = NULL;
3669     }
3670
3671   ++count;
3672 }
3673
3674 static int scroll_test_pos = 0.0;
3675 static GdkGC *scroll_test_gc = NULL;
3676
3677 static gint
3678 scroll_test_expose (GtkWidget *widget, GdkEventExpose *event,
3679                     GtkAdjustment *adj)
3680 {
3681   gint i,j;
3682   gint imin, imax, jmin, jmax;
3683
3684   imin = (event->area.x) / 10;
3685   imax = (event->area.x + event->area.width + 9) / 10;
3686
3687   jmin = ((int)adj->value + event->area.y) / 10;
3688   jmax = ((int)adj->value + event->area.y + event->area.height + 9) / 10;
3689
3690   gdk_window_clear_area (widget->window,
3691                          event->area.x, event->area.y,
3692                          event->area.width, event->area.height);
3693
3694   for (i=imin; i<imax; i++)
3695     for (j=jmin; j<jmax; j++)
3696       if ((i+j) % 2)
3697         gdk_draw_rectangle (widget->window,
3698                             widget->style->black_gc,
3699                             TRUE,
3700                             10*i, 10*j - (int)adj->value, 1+i%10, 1+j%10);
3701
3702   return TRUE;
3703 }
3704
3705 static void
3706 scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
3707                        GtkAdjustment *adj)
3708 {
3709   adj->page_increment = 0.9 * widget->allocation.height;
3710   adj->page_size = widget->allocation.height;
3711
3712   gtk_signal_emit_by_name (GTK_OBJECT (adj), "changed");
3713 }
3714
3715 static void
3716 scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
3717 {
3718   gint source_min = (int)adj->value - scroll_test_pos;
3719   gint source_max = source_min + widget->allocation.height;
3720   gint dest_min = 0;
3721   gint dest_max = widget->allocation.height;
3722   GdkRectangle rect;
3723   GdkEvent *event;
3724
3725   scroll_test_pos = adj->value;
3726
3727   if (!GTK_WIDGET_DRAWABLE (widget))
3728     return;
3729
3730   if (source_min < 0)
3731     {
3732       rect.x = 0;
3733       rect.y = 0;
3734       rect.width = widget->allocation.width;
3735       rect.height = -source_min;
3736       if (rect.height > widget->allocation.height)
3737         rect.height = widget->allocation.height;
3738
3739       source_min = 0;
3740       dest_min = rect.height;
3741     }
3742   else
3743     {
3744       rect.x = 0;
3745       rect.y = 2*widget->allocation.height - source_max;
3746       if (rect.y < 0)
3747         rect.y = 0;
3748       rect.width = widget->allocation.width;
3749       rect.height = widget->allocation.height - rect.y;
3750
3751       source_max = widget->allocation.height;
3752       dest_max = rect.y;
3753     }
3754
3755   if (source_min != source_max)
3756     {
3757       if (scroll_test_gc == NULL)
3758         {
3759           scroll_test_gc = gdk_gc_new (widget->window);
3760           gdk_gc_set_exposures (scroll_test_gc, TRUE);
3761         }
3762
3763       gdk_draw_pixmap (widget->window,
3764                        scroll_test_gc,
3765                        widget->window,
3766                        0, source_min,
3767                        0, dest_min,
3768                        widget->allocation.width,
3769                        source_max - source_min);
3770
3771       /* Make sure graphics expose events are processed before scrolling
3772        * again */
3773
3774       while ((event = gdk_event_get_graphics_expose (widget->window)) != NULL)
3775         {
3776           gtk_widget_event (widget, event);
3777           if (event->expose.count == 0)
3778             {
3779               gdk_event_free (event);
3780               break;
3781             }
3782           gdk_event_free (event);
3783         }
3784     }
3785
3786
3787   if (rect.height != 0)
3788     gtk_widget_draw (widget, &rect);
3789 }
3790
3791
3792 void
3793 create_scroll_test ()
3794 {
3795   static GtkWidget *window = NULL;
3796   GtkWidget *hbox;
3797   GtkWidget *drawing_area;
3798   GtkWidget *scrollbar;
3799   GtkWidget *button;
3800   GtkAdjustment *adj;
3801
3802   if (!window)
3803     {
3804       window = gtk_dialog_new ();
3805
3806       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3807                           GTK_SIGNAL_FUNC(destroy_window),
3808                           &window);
3809       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3810                           GTK_SIGNAL_FUNC(destroy_window),
3811                           &window);
3812
3813       gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
3814       gtk_container_border_width (GTK_CONTAINER (window), 0);
3815
3816       hbox = gtk_hbox_new (FALSE, 0);
3817       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox,
3818                           TRUE, TRUE, 0);
3819       gtk_widget_show (hbox);
3820
3821       drawing_area = gtk_drawing_area_new ();
3822       gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 200, 200);
3823       gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
3824       gtk_widget_show (drawing_area);
3825
3826       gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK);
3827
3828       adj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0));
3829       scroll_test_pos = 0.0;
3830
3831       scrollbar = gtk_vscrollbar_new (adj);
3832       gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
3833       gtk_widget_show (scrollbar);
3834
3835       gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
3836                           GTK_SIGNAL_FUNC (scroll_test_expose), adj);
3837       gtk_signal_connect (GTK_OBJECT (drawing_area), "configure_event",
3838                           GTK_SIGNAL_FUNC (scroll_test_configure), adj);
3839
3840
3841       gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
3842                           GTK_SIGNAL_FUNC (scroll_test_adjustment_changed),
3843                           drawing_area);
3844
3845       /* .. And create some buttons */
3846
3847       button = gtk_button_new_with_label ("Quit");
3848       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3849                           button, TRUE, TRUE, 0);
3850
3851       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3852                                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
3853                                  GTK_OBJECT (window));
3854       gtk_widget_show (button);
3855     }
3856
3857   if (!GTK_WIDGET_VISIBLE (window))
3858     gtk_widget_show (window);
3859   else
3860     gtk_widget_destroy (window);
3861 }
3862
3863 /*
3864  * Timeout Test
3865  */
3866 static int timer = 0;
3867
3868 void
3869 timeout_test (GtkWidget *label)
3870 {
3871   static int count = 0;
3872   static char buffer[32];
3873
3874   sprintf (buffer, "count: %d", ++count);
3875   gtk_label_set (GTK_LABEL (label), buffer);
3876 }
3877
3878 void
3879 start_timeout_test (GtkWidget *widget,
3880                     GtkWidget *label)
3881 {
3882   if (!timer)
3883     {
3884       timer = gtk_timeout_add (100, (GtkFunction) timeout_test, label);
3885     }
3886 }
3887
3888 void
3889 stop_timeout_test (GtkWidget *widget,
3890                    gpointer   data)
3891 {
3892   if (timer)
3893     {
3894       gtk_timeout_remove (timer);
3895       timer = 0;
3896     }
3897 }
3898
3899 void
3900 destroy_timeout_test (GtkWidget  *widget,
3901                       GtkWidget **window)
3902 {
3903   destroy_window (widget, window);
3904   stop_timeout_test (NULL, NULL);
3905 }
3906
3907 void
3908 create_timeout_test ()
3909 {
3910   static GtkWidget *window = NULL;
3911   GtkWidget *button;
3912   GtkWidget *label;
3913
3914   if (!window)
3915     {
3916       window = gtk_dialog_new ();
3917
3918       gtk_signal_connect (GTK_OBJECT (window), "destroy",
3919                           GTK_SIGNAL_FUNC(destroy_timeout_test),
3920                           &window);
3921       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
3922                           GTK_SIGNAL_FUNC(destroy_timeout_test),
3923                           &window);
3924
3925       gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
3926       gtk_container_border_width (GTK_CONTAINER (window), 0);
3927
3928       label = gtk_label_new ("count: 0");
3929       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
3930       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
3931                           label, TRUE, TRUE, 0);
3932       gtk_widget_show (label);
3933
3934       button = gtk_button_new_with_label ("close");
3935       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3936                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
3937                                  GTK_OBJECT (window));
3938       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3939       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3940                           button, TRUE, TRUE, 0);
3941       gtk_widget_grab_default (button);
3942       gtk_widget_show (button);
3943
3944       button = gtk_button_new_with_label ("start");
3945       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3946                           GTK_SIGNAL_FUNC(start_timeout_test),
3947                           label);
3948       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3949       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3950                           button, TRUE, TRUE, 0);
3951       gtk_widget_show (button);
3952
3953       button = gtk_button_new_with_label ("stop");
3954       gtk_signal_connect (GTK_OBJECT (button), "clicked",
3955                           GTK_SIGNAL_FUNC(stop_timeout_test),
3956                           NULL);
3957       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3958       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3959                           button, TRUE, TRUE, 0);
3960       gtk_widget_show (button);
3961     }
3962
3963   if (!GTK_WIDGET_VISIBLE (window))
3964     gtk_widget_show (window);
3965   else
3966     gtk_widget_destroy (window);
3967 }
3968
3969
3970 /*
3971  * Idle Test
3972  */
3973 static int idle = 0;
3974
3975 gint
3976 idle_test (GtkWidget *label)
3977 {
3978   static int count = 0;
3979   static char buffer[32];
3980
3981   sprintf (buffer, "count: %d", ++count);
3982   gtk_label_set (GTK_LABEL (label), buffer);
3983
3984   return TRUE;
3985 }
3986
3987 void
3988 start_idle_test (GtkWidget *widget,
3989                  GtkWidget *label)
3990 {
3991   if (!idle)
3992     {
3993       idle = gtk_idle_add ((GtkFunction) idle_test, label);
3994     }
3995 }
3996
3997 void
3998 stop_idle_test (GtkWidget *widget,
3999                 gpointer   data)
4000 {
4001   if (idle)
4002     {
4003       gtk_idle_remove (idle);
4004       idle = 0;
4005     }
4006 }
4007
4008 void
4009 destroy_idle_test (GtkWidget  *widget,
4010                    GtkWidget **window)
4011 {
4012   destroy_window (widget, window);
4013   stop_idle_test (NULL, NULL);
4014 }
4015
4016 void
4017 create_idle_test ()
4018 {
4019   static GtkWidget *window = NULL;
4020   GtkWidget *button;
4021   GtkWidget *label;
4022
4023   if (!window)
4024     {
4025       window = gtk_dialog_new ();
4026
4027       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4028                           GTK_SIGNAL_FUNC(destroy_idle_test),
4029                           &window);
4030       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
4031                           GTK_SIGNAL_FUNC(destroy_idle_test),
4032                           &window);
4033
4034       gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
4035       gtk_container_border_width (GTK_CONTAINER (window), 0);
4036
4037       label = gtk_label_new ("count: 0");
4038       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
4039       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
4040                           label, TRUE, TRUE, 0);
4041       gtk_widget_show (label);
4042
4043       button = gtk_button_new_with_label ("close");
4044       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4045                                  GTK_SIGNAL_FUNC(gtk_widget_destroy),
4046                                  GTK_OBJECT (window));
4047       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4048       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
4049                           button, TRUE, TRUE, 0);
4050       gtk_widget_grab_default (button);
4051       gtk_widget_show (button);
4052
4053       button = gtk_button_new_with_label ("start");
4054       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4055                           GTK_SIGNAL_FUNC(start_idle_test),
4056                           label);
4057       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4058       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
4059                           button, TRUE, TRUE, 0);
4060       gtk_widget_show (button);
4061
4062       button = gtk_button_new_with_label ("stop");
4063       gtk_signal_connect (GTK_OBJECT (button), "clicked",
4064                           GTK_SIGNAL_FUNC(stop_idle_test),
4065                           NULL);
4066       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4067       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
4068                           button, TRUE, TRUE, 0);
4069       gtk_widget_show (button);
4070     }
4071
4072   if (!GTK_WIDGET_VISIBLE (window))
4073     gtk_widget_show (window);
4074   else
4075     gtk_widget_destroy (window);
4076 }
4077
4078 void
4079 test_destroy (GtkWidget  *widget,
4080               GtkWidget **window)
4081 {
4082   destroy_window (widget, window);
4083   gtk_main_quit ();
4084 }
4085
4086 /*
4087  * Basic Test
4088  */
4089 void
4090 create_test ()
4091 {
4092   static GtkWidget *window = NULL;
4093
4094   if (!window)
4095     {
4096       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4097
4098       gtk_signal_connect (GTK_OBJECT (window), "destroy",
4099                           GTK_SIGNAL_FUNC(test_destroy),
4100                           &window);
4101       gtk_signal_connect (GTK_OBJECT (window), "delete_event",
4102                           GTK_SIGNAL_FUNC(test_destroy),
4103                           &window);
4104
4105
4106       gtk_window_set_title (GTK_WINDOW (window), "test");
4107       gtk_container_border_width (GTK_CONTAINER (window), 0);
4108     }
4109
4110   if (!GTK_WIDGET_VISIBLE (window))
4111     {
4112       gtk_widget_show (window);
4113
4114       g_print ("create_test: start\n");
4115       gtk_main ();
4116       g_print ("create_test: done\n");
4117     }
4118   else
4119     gtk_widget_destroy (window);
4120 }
4121
4122
4123 /*
4124  * Main Window and Exit
4125  */
4126 void
4127 do_exit (GtkWidget *widget, GtkWidget *window)
4128 {
4129   gtk_widget_destroy (window);
4130   gtk_main_quit ();
4131 }
4132
4133 void
4134 create_main_window ()
4135 {
4136   struct {
4137     char *label;
4138     void (*func) ();
4139   } buttons[] =
4140     {
4141       { "buttons", create_buttons },
4142       { "toggle buttons", create_toggle_buttons },
4143       { "check buttons", create_check_buttons },
4144       { "radio buttons", create_radio_buttons },
4145       { "button box", create_button_box },
4146       { "toolbar", create_toolbar },
4147       { "handle box", create_handle_box },
4148       { "reparent", create_reparent },
4149       { "pixmap", create_pixmap },
4150       { "tooltips", create_tooltips },
4151       { "menus", create_menus },
4152       { "scrolled windows", create_scrolled_windows },
4153       { "drawing areas", NULL },
4154       { "entry", create_entry },
4155       { "list", create_list },
4156       { "clist", create_clist},
4157       { "color selection", create_color_selection },
4158       { "file selection", create_file_selection },
4159       { "dialog", create_dialog },
4160       { "miscellaneous", NULL },
4161       { "range controls", create_range_controls },
4162       { "rulers", create_rulers },
4163       { "text", create_text },
4164       { "notebook", create_notebook },
4165       { "panes", create_panes },
4166       { "shapes", create_shapes },
4167       { "dnd", create_dnd },
4168       { "progress bar", create_progress_bar },
4169       { "preview color", create_color_preview },
4170       { "preview gray", create_gray_preview },
4171       { "gamma curve", create_gamma_curve },
4172       { "test scrolling", create_scroll_test },
4173       { "test selection", create_selection_test },
4174       { "test timeout", create_timeout_test },
4175       { "test idle", create_idle_test },
4176       { "test", create_test },
4177     };
4178   int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
4179   GtkWidget *window;
4180   GtkWidget *box1;
4181   GtkWidget *box2;
4182   GtkWidget *scrolled_window;
4183   GtkWidget *button;
4184   GtkWidget *separator;
4185   int i;
4186
4187   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4188   gtk_widget_set_name (window, "main window");
4189   gtk_widget_set_usize (window, 200, 400);
4190   gtk_widget_set_uposition (window, 20, 20);
4191
4192   gtk_signal_connect (GTK_OBJECT (window), "destroy",
4193                       GTK_SIGNAL_FUNC(gtk_main_quit),
4194                       NULL);
4195   gtk_signal_connect (GTK_OBJECT (window), "delete_event",
4196                       GTK_SIGNAL_FUNC(gtk_main_quit),
4197                       NULL);
4198
4199   box1 = gtk_vbox_new (FALSE, 0);
4200   gtk_container_add (GTK_CONTAINER (window), box1);
4201   gtk_widget_show (box1);
4202
4203   scrolled_window = gtk_scrolled_window_new (NULL, NULL);
4204   gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
4205   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
4206                                   GTK_POLICY_AUTOMATIC,
4207                                   GTK_POLICY_AUTOMATIC);
4208   gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
4209   gtk_widget_show (scrolled_window);
4210
4211   box2 = gtk_vbox_new (FALSE, 0);
4212   gtk_container_border_width (GTK_CONTAINER (box2), 10);
4213   gtk_container_add (GTK_CONTAINER (scrolled_window), box2);
4214   gtk_widget_show (box2);
4215
4216   for (i = 0; i < nbuttons; i++)
4217     {
4218       button = gtk_button_new_with_label (buttons[i].label);
4219       if (buttons[i].func)
4220         gtk_signal_connect (GTK_OBJECT (button),
4221                             "clicked",
4222                             GTK_SIGNAL_FUNC(buttons[i].func),
4223                             NULL);
4224       else
4225         gtk_widget_set_sensitive (button, FALSE);
4226       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4227       gtk_widget_show (button);
4228     }
4229
4230   separator = gtk_hseparator_new ();
4231   gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4232   gtk_widget_show (separator);
4233
4234   box2 = gtk_vbox_new (FALSE, 10);
4235   gtk_container_border_width (GTK_CONTAINER (box2), 10);
4236   gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4237   gtk_widget_show (box2);
4238
4239   button = gtk_button_new_with_label ("close");
4240   gtk_signal_connect (GTK_OBJECT (button), "clicked",
4241                       GTK_SIGNAL_FUNC (do_exit),
4242                       window);
4243   gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4244   GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4245   gtk_widget_grab_default (button);
4246   gtk_widget_show (button);
4247
4248   gtk_widget_show (window);
4249 }
4250
4251 int
4252 main (int argc, char *argv[])
4253 {
4254   gtk_set_locale ();
4255
4256   gtk_init (&argc, &argv);
4257   gtk_rc_parse ("testgtkrc");
4258
4259   create_main_window ();
4260
4261   gtk_main ();
4262
4263   return 0;
4264 }