Pileus Git - ~andy/gtk/blob - tests/testcombo.c

   1 /* testcombo.c
   2  * Copyright (C) 2003  Kristian Rietveld
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19 #include "config.h"
  20 #include <gtk/gtk.h>
  21
  22 #include <string.h>
  23 #include <stdio.h>
  24
  25 /**
  26  * oh yes, this test app surely has a lot of ugly code
  27  */
  28
  29 /* grid combo demo */
  30 static GdkPixbuf *
  31 create_color_pixbuf (const char *color)
  32 {
  33         GdkPixbuf *pixbuf;
  34         GdkColor col;
  35
  36         int x;
  37         int num;
  38         int rowstride;
  39         guchar *pixels, *p;
  40
  41         if (!gdk_color_parse (color, &col))
  42                 return NULL;
  43
  44         pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
  45                                  FALSE, 8,
  46                                  16, 16);
  47
  48         rowstride = gdk_pixbuf_get_rowstride (pixbuf);
  49         p = pixels = gdk_pixbuf_get_pixels (pixbuf);
  50
  51         num = gdk_pixbuf_get_width (pixbuf) *
  52                 gdk_pixbuf_get_height (pixbuf);
  53
  54         for (x = 0; x < num; x++) {
  55                 p[0] = col.red / 65535 * 255;
  56                 p[1] = col.green / 65535 * 255;
  57                 p[2] = col.blue / 65535 * 255;
  58                 p += 3;
  59         }
  60
  61         return pixbuf;
  62 }
  63
  64 static GtkWidget *
  65 create_combo_box_grid_demo (void)
  66 {
  67         GtkWidget *combo;
  68         GtkTreeIter iter;
  69         GdkPixbuf *pixbuf;
  70         GtkCellRenderer *cell = gtk_cell_renderer_pixbuf_new ();
  71         GtkListStore *store;
  72
  73         store = gtk_list_store_new (1, GDK_TYPE_PIXBUF);
  74
  75         combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (store));
  76         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo),
  77                                     cell, TRUE);
  78         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo),
  79                                         cell, "pixbuf", 0, NULL);
  80         gtk_combo_box_set_wrap_width (GTK_COMBO_BOX (combo),
  81                                       3);
  82
  83         /* first row */
  84         pixbuf = create_color_pixbuf ("red");
  85         gtk_list_store_append (store, &iter);
  86         gtk_list_store_set (store, &iter,
  87                             0, pixbuf,
  88                             -1);
  89         g_object_unref (pixbuf);
  90
  91         pixbuf = create_color_pixbuf ("green");
  92         gtk_list_store_append (store, &iter);
  93         gtk_list_store_set (store, &iter,
  94                             0, pixbuf,
  95                             -1);
  96         g_object_unref (pixbuf);
  97
  98         pixbuf = create_color_pixbuf ("blue");
  99         gtk_list_store_append (store, &iter);
 100         gtk_list_store_set (store, &iter,
 101                             0, pixbuf,
 102                             -1);
 103         g_object_unref (pixbuf);
 104
 105         /* second row */
 106         pixbuf = create_color_pixbuf ("yellow");
 107         gtk_list_store_append (store, &iter);
 108         gtk_list_store_set (store, &iter,
 109                             0, pixbuf,
 110                             -1);
 111         g_object_unref (pixbuf);
 112
 113         pixbuf = create_color_pixbuf ("black");
 114         gtk_list_store_append (store, &iter);
 115         gtk_list_store_set (store, &iter,
 116                             0, pixbuf,
 117                             -1);
 118         g_object_unref (pixbuf);
 119
 120         pixbuf = create_color_pixbuf ("white");
 121         gtk_list_store_append (store, &iter);
 122         gtk_list_store_set (store, &iter,
 123                             0, pixbuf,
 124                             -1);
 125         g_object_unref (pixbuf);
 126
 127         /* third row */
 128         pixbuf = create_color_pixbuf ("gray");
 129         gtk_list_store_append (store, &iter);
 130         gtk_list_store_set (store, &iter,
 131                             0, pixbuf,
 132                             -1);
 133         g_object_unref (pixbuf);
 134
 135         pixbuf = create_color_pixbuf ("snow");
 136         gtk_list_store_append (store, &iter);
 137         gtk_list_store_set (store, &iter,
 138                             0, pixbuf,
 139                             -1);
 140         g_object_unref (pixbuf);
 141
 142         pixbuf = create_color_pixbuf ("magenta");
 143         gtk_list_store_append (store, &iter);
 144         gtk_list_store_set (store, &iter,
 145                             0, pixbuf,
 146                             -1);
 147         g_object_unref (pixbuf);
 148
 149         g_object_unref (store);
 150
 151         gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0);
 152
 153         return combo;
 154 }
 155
 156 /* blaat */
 157 static GtkTreeModel *
 158 create_tree_blaat (void)
 159 {
 160         GdkPixbuf *pixbuf;
 161         GtkWidget *cellview;
 162         GtkTreeIter iter, iter2;
 163         GtkTreeStore *store;
 164
 165         cellview = gtk_cell_view_new ();
 166
 167         store = gtk_tree_store_new (3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_BOOLEAN);
 168
 169         pixbuf = gtk_widget_render_icon (cellview, GTK_STOCK_DIALOG_WARNING,
 170                                          GTK_ICON_SIZE_BUTTON, NULL);
 171         gtk_tree_store_append (store, &iter, NULL);
 172         gtk_tree_store_set (store, &iter,
 173                             0, pixbuf,
 174                             1, "gtk-stock-dialog-warning",
 175                             2, FALSE,
 176                             -1);
 177
 178         pixbuf = gtk_widget_render_icon (cellview, GTK_STOCK_STOP,
 179                                          GTK_ICON_SIZE_BUTTON, NULL);
 180         gtk_tree_store_append (store, &iter2, &iter);
 181         gtk_tree_store_set (store, &iter2,
 182                             0, pixbuf,
 183                             1, "gtk-stock-stop",
 184                             2, FALSE,
 185                             -1);
 186
 187         pixbuf = gtk_widget_render_icon (cellview, GTK_STOCK_NEW,
 188                                          GTK_ICON_SIZE_BUTTON, NULL);
 189         gtk_tree_store_append (store, &iter2, &iter);
 190         gtk_tree_store_set (store, &iter2,
 191                             0, pixbuf,
 192                             1, "gtk-stock-new",
 193                             2, FALSE,
 194                             -1);
 195
 196         pixbuf = gtk_widget_render_icon (cellview, GTK_STOCK_CLEAR,
 197                                          GTK_ICON_SIZE_BUTTON, NULL);
 198         gtk_tree_store_append (store, &iter, NULL);
 199         gtk_tree_store_set (store, &iter,
 200                             0, pixbuf,
 201                             1, "gtk-stock-clear",
 202                             2, FALSE,
 203                             -1);
 204
 205 #if 0
 206         gtk_tree_store_append (store, &iter, NULL);
 207         gtk_tree_store_set (store, &iter,
 208                             0, NULL,
 209                             1, "separator",
 210                             2, TRUE,
 211                             -1);
 212 #endif
 213
 214         pixbuf = gtk_widget_render_icon (cellview, GTK_STOCK_OPEN,
 215                                          GTK_ICON_SIZE_BUTTON, NULL);
 216         gtk_tree_store_append (store, &iter, NULL);
 217         gtk_tree_store_set (store, &iter,
 218                             0, pixbuf,
 219                             1, "gtk-stock-open",
 220                             2, FALSE,
 221                             -1);
 222
 223         gtk_widget_destroy (cellview);
 224
 225         return GTK_TREE_MODEL (store);
 226 }
 227
 228 static GtkTreeModel *
 229 create_empty_list_blaat (void)
 230 {
 231         GdkPixbuf *pixbuf;
 232         GtkWidget *cellview;
 233         GtkTreeIter iter;
 234         GtkListStore *store;
 235
 236         cellview = gtk_cell_view_new ();
 237
 238         store = gtk_list_store_new (2, GDK_TYPE_PIXBUF, G_TYPE_STRING);
 239
 240         pixbuf = gtk_widget_render_icon (cellview, GTK_STOCK_DIALOG_WARNING,
 241                                          GTK_ICON_SIZE_BUTTON, NULL);
 242         gtk_list_store_append (store, &iter);
 243         gtk_list_store_set (store, &iter,
 244                             0, pixbuf,
 245                             1, "gtk-stock-dialog-warning",
 246                             -1);
 247
 248         gtk_widget_destroy (cellview);
 249
 250         return GTK_TREE_MODEL (store);
 251 }
 252
 253 static void
 254 populate_list_blaat (gpointer data)
 255 {
 256   GtkComboBox *combo_box = GTK_COMBO_BOX (data);
 257   GtkListStore *store;
 258   GdkPixbuf *pixbuf;
 259   GtkWidget *cellview;
 260   GtkTreeIter iter;
 261
 262   store = GTK_LIST_STORE (gtk_combo_box_get_model (combo_box));
 263
 264   gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter);
 265
 266   if (gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter))
 267     return;
 268
 269   cellview = gtk_cell_view_new ();
 270
 271   pixbuf = gtk_widget_render_icon (cellview, GTK_STOCK_STOP,
 272                                    GTK_ICON_SIZE_BUTTON, NULL);
 273   gtk_list_store_append (store, &iter);
 274   gtk_list_store_set (store, &iter,
 275                       0, pixbuf,
 276                       1, "gtk-stock-stop",
 277                       -1);
 278
 279   pixbuf = gtk_widget_render_icon (cellview, GTK_STOCK_NEW,
 280                                    GTK_ICON_SIZE_BUTTON, NULL);
 281   gtk_list_store_append (store, &iter);
 282   gtk_list_store_set (store, &iter,
 283                       0, pixbuf,
 284                       1, "gtk-stock-new",
 285                       -1);
 286
 287   pixbuf = gtk_widget_render_icon (cellview, GTK_STOCK_CLEAR,
 288                                    GTK_ICON_SIZE_BUTTON, NULL);
 289   gtk_list_store_append (store, &iter);
 290   gtk_list_store_set (store, &iter,
 291                       0, pixbuf,
 292                       1, "gtk-stock-clear",
 293                       -1);
 294
 295   gtk_list_store_append (store, &iter);
 296   gtk_list_store_set (store, &iter,
 297                       0, NULL,
 298                       1, "separator",
 299                       -1);
 300
 301   pixbuf = gtk_widget_render_icon (cellview, GTK_STOCK_OPEN,
 302                                    GTK_ICON_SIZE_BUTTON, NULL);
 303   gtk_list_store_append (store, &iter);
 304   gtk_list_store_set (store, &iter,
 305                       0, pixbuf,
 306                       1, "gtk-stock-open",
 307                       -1);
 308
 309   gtk_widget_destroy (cellview);
 310 }
 311
 312 static GtkTreeModel *
 313 create_list_blaat (void)
 314 {
 315         GdkPixbuf *pixbuf;
 316         GtkWidget *cellview;
 317         GtkTreeIter iter;
 318         GtkListStore *store;
 319
 320         cellview = gtk_cell_view_new ();
 321
 322         store = gtk_list_store_new (2, GDK_TYPE_PIXBUF, G_TYPE_STRING);
 323
 324         pixbuf = gtk_widget_render_icon (cellview, GTK_STOCK_DIALOG_WARNING,
 325                                          GTK_ICON_SIZE_BUTTON, NULL);
 326         gtk_list_store_append (store, &iter);
 327         gtk_list_store_set (store, &iter,
 328                             0, pixbuf,
 329                             1, "gtk-stock-dialog-warning",
 330                             -1);
 331
 332         pixbuf = gtk_widget_render_icon (cellview, GTK_STOCK_STOP,
 333                                          GTK_ICON_SIZE_BUTTON, NULL);
 334         gtk_list_store_append (store, &iter);
 335         gtk_list_store_set (store, &iter,
 336                             0, pixbuf,
 337                             1, "gtk-stock-stop",
 338                             -1);
 339
 340         pixbuf = gtk_widget_render_icon (cellview, GTK_STOCK_NEW,
 341                                          GTK_ICON_SIZE_BUTTON, NULL);
 342         gtk_list_store_append (store, &iter);
 343         gtk_list_store_set (store, &iter,
 344                             0, pixbuf,
 345                             1, "gtk-stock-new",
 346                             -1);
 347
 348         pixbuf = gtk_widget_render_icon (cellview, GTK_STOCK_CLEAR,
 349                                          GTK_ICON_SIZE_BUTTON, NULL);
 350         gtk_list_store_append (store, &iter);
 351         gtk_list_store_set (store, &iter,
 352                             0, pixbuf,
 353                             1, "gtk-stock-clear",
 354                             -1);
 355
 356         gtk_list_store_append (store, &iter);
 357         gtk_list_store_set (store, &iter,
 358                             0, NULL,
 359                             1, "separator",
 360                             -1);
 361
 362         pixbuf = gtk_widget_render_icon (cellview, GTK_STOCK_OPEN,
 363                                          GTK_ICON_SIZE_BUTTON, NULL);
 364         gtk_list_store_append (store, &iter);
 365         gtk_list_store_set (store, &iter,
 366                             0, pixbuf,
 367                             1, "gtk-stock-open",
 368                             -1);
 369
 370         gtk_widget_destroy (cellview);
 371
 372         return GTK_TREE_MODEL (store);
 373 }
 374
 375
 376 static GtkTreeModel *
 377 create_list_long (void)
 378 {
 379         GtkTreeIter iter;
 380         GtkListStore *store;
 381
 382         store = gtk_list_store_new (1, G_TYPE_STRING);
 383
 384         gtk_list_store_append (store, &iter);
 385         gtk_list_store_set (store, &iter,
 386                             0, "here is some long long text that grows out of the combo's allocation",
 387                             -1);
 388
 389
 390         gtk_list_store_append (store, &iter);
 391         gtk_list_store_set (store, &iter,
 392                             0, "with at least a few of these rows",
 393                             -1);
 394
 395         gtk_list_store_append (store, &iter);
 396         gtk_list_store_set (store, &iter,
 397                             0, "so that we can get some ellipsized text here",
 398                             -1);
 399
 400         gtk_list_store_append (store, &iter);
 401         gtk_list_store_set (store, &iter,
 402                             0, "and see the combo box menu being allocated without any constraints",
 403                             -1);
 404
 405         return GTK_TREE_MODEL (store);
 406 }
 407
 408 /* blaat */
 409 static GtkTreeModel *
 410 create_phylogenetic_tree (void)
 411 {
 412         GtkTreeIter iter, iter2, iter3;
 413         GtkTreeStore *store;
 414
 415         store = gtk_tree_store_new (1,G_TYPE_STRING);
 416
 417         gtk_tree_store_append (store, &iter, NULL);
 418         gtk_tree_store_set (store, &iter,
 419                             0, "Eubacteria",
 420                             -1);
 421
 422         gtk_tree_store_append (store, &iter2, &iter);
 423         gtk_tree_store_set (store, &iter2,
 424                             0, "Aquifecales",
 425                             -1);
 426
 427         gtk_tree_store_append (store, &iter2, &iter);
 428         gtk_tree_store_set (store, &iter2,
 429                             0, "Thermotogales",
 430                             -1);
 431
 432         gtk_tree_store_append (store, &iter2, &iter);
 433         gtk_tree_store_set (store, &iter2,
 434                             0, "Thermodesulfobacterium",
 435                             -1);
 436
 437         gtk_tree_store_append (store, &iter2, &iter);
 438         gtk_tree_store_set (store, &iter2,
 439                             0, "Thermus-Deinococcus group",
 440                             -1);
 441
 442         gtk_tree_store_append (store, &iter2, &iter);
 443         gtk_tree_store_set (store, &iter2,
 444                             0, "Chloroflecales",
 445                             -1);
 446
 447         gtk_tree_store_append (store, &iter2, &iter);
 448         gtk_tree_store_set (store, &iter2,
 449                             0, "Cyanobacteria",
 450                             -1);
 451
 452         gtk_tree_store_append (store, &iter2, &iter);
 453         gtk_tree_store_set (store, &iter2,
 454                             0, "Firmicutes",
 455                             -1);
 456
 457         gtk_tree_store_append (store, &iter2, &iter);
 458         gtk_tree_store_set (store, &iter2,
 459                             0, "Leptospirillium Group",
 460                             -1);
 461
 462         gtk_tree_store_append (store, &iter2, &iter);
 463         gtk_tree_store_set (store, &iter2,
 464                             0, "Synergistes",
 465                             -1);
 466         gtk_tree_store_append (store, &iter2, &iter);
 467         gtk_tree_store_set (store, &iter2,
 468                             0, "Chlorobium-Flavobacteria group",
 469                             -1);
 470         gtk_tree_store_append (store, &iter2, &iter);
 471         gtk_tree_store_set (store, &iter2,
 472                             0, "Chlamydia-Verrucomicrobia group",
 473                             -1);
 474
 475         gtk_tree_store_append (store, &iter3, &iter2);
 476         gtk_tree_store_set (store, &iter3,
 477                             0, "Verrucomicrobia",
 478                             -1);
 479         gtk_tree_store_append (store, &iter3, &iter2);
 480         gtk_tree_store_set (store, &iter3,
 481                             0, "Chlamydia",
 482                             -1);
 483
 484         gtk_tree_store_append (store, &iter2, &iter);
 485         gtk_tree_store_set (store, &iter2,
 486                             0, "Flexistipes",
 487                             -1);
 488
 489
 490         gtk_tree_store_append (store, &iter2, &iter);
 491         gtk_tree_store_set (store, &iter2,
 492                             0, "Fibrobacter group",
 493                             -1);
 494
 495
 496         gtk_tree_store_append (store, &iter2, &iter);
 497         gtk_tree_store_set (store, &iter2,
 498                             0, "spirocheteus",
 499                             -1);
 500
 501
 502         gtk_tree_store_append (store, &iter2, &iter);
 503         gtk_tree_store_set (store, &iter2,
 504                             0, "Proteobacteria",
 505                             -1);
 506
 507
 508         gtk_tree_store_append (store, &iter3, &iter2);
 509         gtk_tree_store_set (store, &iter3,
 510                             0, "alpha",
 511                             -1);
 512
 513
 514         gtk_tree_store_append (store, &iter3, &iter2);
 515         gtk_tree_store_set (store, &iter3,
 516                             0, "beta",
 517                             -1);
 518
 519
 520         gtk_tree_store_append (store, &iter3, &iter2);
 521         gtk_tree_store_set (store, &iter3,
 522                             0, "delta ",
 523                             -1);
 524
 525
 526         gtk_tree_store_append (store, &iter3, &iter2);
 527         gtk_tree_store_set (store, &iter3,
 528                             0, "epsilon",
 529                             -1);
 530
 531
 532         gtk_tree_store_append (store, &iter3, &iter2);
 533         gtk_tree_store_set (store, &iter3,
 534                             0, "gamma ",
 535                             -1);
 536
 537
 538         gtk_tree_store_append (store, &iter, NULL);
 539         gtk_tree_store_set (store, &iter,
 540                             0, "Eukaryotes",
 541                             -1);
 542
 543
 544         gtk_tree_store_append (store, &iter2, &iter);
 545         gtk_tree_store_set (store, &iter2,
 546                             0, "Metazoa",
 547                             -1);
 548
 549
 550         gtk_tree_store_append (store, &iter2, &iter);
 551         gtk_tree_store_set (store, &iter2,
 552                             0, "Bilateria",
 553                             -1);
 554
 555
 556         gtk_tree_store_append (store, &iter2, &iter);
 557         gtk_tree_store_set (store, &iter2,
 558                             0, "Myxozoa",
 559                             -1);
 560
 561
 562         gtk_tree_store_append (store, &iter2, &iter);
 563         gtk_tree_store_set (store, &iter2,
 564                             0, "Cnidaria",
 565                             -1);
 566
 567
 568         gtk_tree_store_append (store, &iter2, &iter);
 569         gtk_tree_store_set (store, &iter2,
 570                             0, "Ctenophora",
 571                             -1);
 572
 573
 574         gtk_tree_store_append (store, &iter2, &iter);
 575         gtk_tree_store_set (store, &iter2,
 576                             0, "Placozoa",
 577                             -1);
 578
 579
 580         gtk_tree_store_append (store, &iter2, &iter);
 581         gtk_tree_store_set (store, &iter2,
 582                             0, "Porifera",
 583                             -1);
 584
 585
 586         gtk_tree_store_append (store, &iter2, &iter);
 587         gtk_tree_store_set (store, &iter2,
 588                             0, "choanoflagellates",
 589                             -1);
 590
 591
 592         gtk_tree_store_append (store, &iter2, &iter);
 593         gtk_tree_store_set (store, &iter2,
 594                             0, "Fungi",
 595                             -1);
 596
 597
 598         gtk_tree_store_append (store, &iter2, &iter);
 599         gtk_tree_store_set (store, &iter2,
 600                             0, "Microsporidia",
 601                             -1);
 602
 603
 604         gtk_tree_store_append (store, &iter2, &iter);
 605         gtk_tree_store_set (store, &iter2,
 606                             0, "Aleveolates",
 607                             -1);
 608
 609
 610         gtk_tree_store_append (store, &iter2, &iter);
 611         gtk_tree_store_set (store, &iter2,
 612                             0, "Stramenopiles",
 613                             -1);
 614
 615
 616         gtk_tree_store_append (store, &iter2, &iter);
 617         gtk_tree_store_set (store, &iter2,
 618                             0, "Rhodophyta",
 619                             -1);
 620
 621
 622         gtk_tree_store_append (store, &iter2, &iter);
 623         gtk_tree_store_set (store, &iter2,
 624                             0, "Viridaeplantae",
 625                             -1);
 626
 627
 628         gtk_tree_store_append (store, &iter2, &iter);
 629         gtk_tree_store_set (store, &iter2,
 630                             0, "crytomonads et al",
 631                             -1);
 632
 633
 634         gtk_tree_store_append (store, &iter, NULL);
 635         gtk_tree_store_set (store, &iter,
 636                             0, "Archaea ",
 637                             -1);
 638
 639
 640         gtk_tree_store_append (store, &iter2, &iter);
 641         gtk_tree_store_set (store, &iter2,
 642                             0, "Korarchaeota",
 643                             -1);
 644
 645
 646         gtk_tree_store_append (store, &iter2, &iter);
 647         gtk_tree_store_set (store, &iter2,
 648                             0, "Crenarchaeota",
 649                             -1);
 650
 651
 652         gtk_tree_store_append (store, &iter2, &iter);
 653         gtk_tree_store_set (store, &iter2,
 654                             0, "Buryarchaeota",
 655                             -1);
 656
 657         return GTK_TREE_MODEL (store);
 658 }
 659
 660
 661 /* blaat */
 662 static GtkTreeModel *
 663 create_capital_tree (void)
 664 {
 665         GtkTreeIter iter, iter2;
 666         GtkTreeStore *store;
 667
 668         store = gtk_tree_store_new (1, G_TYPE_STRING);
 669
 670         gtk_tree_store_append (store, &iter, NULL);
 671         gtk_tree_store_set (store, &iter, 0, "A - B", -1);
 672
 673         gtk_tree_store_append (store, &iter2, &iter);
 674         gtk_tree_store_set (store, &iter2, 0, "Albany", -1);
 675
 676         gtk_tree_store_append (store, &iter2, &iter);
 677         gtk_tree_store_set (store, &iter2, 0, "Annapolis", -1);
 678
 679         gtk_tree_store_append (store, &iter2, &iter);
 680         gtk_tree_store_set (store, &iter2, 0, "Atlanta", -1);
 681
 682         gtk_tree_store_append (store, &iter2, &iter);
 683         gtk_tree_store_set (store, &iter2, 0, "Augusta", -1);
 684
 685         gtk_tree_store_append (store, &iter2, &iter);
 686         gtk_tree_store_set (store, &iter2, 0, "Austin", -1);
 687
 688         gtk_tree_store_append (store, &iter2, &iter);
 689         gtk_tree_store_set (store, &iter2, 0, "Baton Rouge", -1);
 690
 691         gtk_tree_store_append (store, &iter2, &iter);
 692         gtk_tree_store_set (store, &iter2, 0, "Bismarck", -1);
 693
 694         gtk_tree_store_append (store, &iter2, &iter);
 695         gtk_tree_store_set (store, &iter2, 0, "Boise", -1);
 696
 697         gtk_tree_store_append (store, &iter2, &iter);
 698         gtk_tree_store_set (store, &iter2, 0, "Boston", -1);
 699
 700         gtk_tree_store_append (store, &iter, NULL);
 701         gtk_tree_store_set (store, &iter, 0, "C - D", -1);
 702
 703         gtk_tree_store_append (store, &iter2, &iter);
 704         gtk_tree_store_set (store, &iter2, 0, "Carson City", -1);
 705
 706         gtk_tree_store_append (store, &iter2, &iter);
 707         gtk_tree_store_set (store, &iter2, 0, "Charleston", -1);
 708
 709         gtk_tree_store_append (store, &iter2, &iter);
 710         gtk_tree_store_set (store, &iter2, 0, "Cheyenne", -1);
 711
 712         gtk_tree_store_append (store, &iter2, &iter);
 713         gtk_tree_store_set (store, &iter2, 0, "Columbia", -1);
 714
 715         gtk_tree_store_append (store, &iter2, &iter);
 716         gtk_tree_store_set (store, &iter2, 0, "Columbus", -1);
 717
 718         gtk_tree_store_append (store, &iter2, &iter);
 719         gtk_tree_store_set (store, &iter2, 0, "Concord", -1);
 720
 721         gtk_tree_store_append (store, &iter2, &iter);
 722         gtk_tree_store_set (store, &iter2, 0, "Denver", -1);
 723
 724         gtk_tree_store_append (store, &iter2, &iter);
 725         gtk_tree_store_set (store, &iter2, 0, "Des Moines", -1);
 726
 727         gtk_tree_store_append (store, &iter2, &iter);
 728         gtk_tree_store_set (store, &iter2, 0, "Dover", -1);
 729
 730
 731         gtk_tree_store_append (store, &iter, NULL);
 732         gtk_tree_store_set (store, &iter, 0, "E - J", -1);
 733
 734         gtk_tree_store_append (store, &iter2, &iter);
 735         gtk_tree_store_set (store, &iter2, 0, "Frankfort", -1);
 736
 737         gtk_tree_store_append (store, &iter2, &iter);
 738         gtk_tree_store_set (store, &iter2, 0, "Harrisburg", -1);
 739
 740         gtk_tree_store_append (store, &iter2, &iter);
 741         gtk_tree_store_set (store, &iter2, 0, "Hartford", -1);
 742
 743         gtk_tree_store_append (store, &iter2, &iter);
 744         gtk_tree_store_set (store, &iter2, 0, "Helena", -1);
 745
 746         gtk_tree_store_append (store, &iter2, &iter);
 747         gtk_tree_store_set (store, &iter2, 0, "Honolulu", -1);
 748
 749         gtk_tree_store_append (store, &iter2, &iter);
 750         gtk_tree_store_set (store, &iter2, 0, "Indianapolis", -1);
 751
 752         gtk_tree_store_append (store, &iter2, &iter);
 753         gtk_tree_store_set (store, &iter2, 0, "Jackson", -1);
 754
 755         gtk_tree_store_append (store, &iter2, &iter);
 756         gtk_tree_store_set (store, &iter2, 0, "Jefferson City", -1);
 757
 758         gtk_tree_store_append (store, &iter2, &iter);
 759         gtk_tree_store_set (store, &iter2, 0, "Juneau", -1);
 760
 761
 762         gtk_tree_store_append (store, &iter, NULL);
 763         gtk_tree_store_set (store, &iter, 0, "K - O", -1);
 764
 765         gtk_tree_store_append (store, &iter2, &iter);
 766         gtk_tree_store_set (store, &iter2, 0, "Lansing", -1);
 767
 768         gtk_tree_store_append (store, &iter2, &iter);
 769         gtk_tree_store_set (store, &iter2, 0, "Lincoln", -1);
 770
 771         gtk_tree_store_append (store, &iter2, &iter);
 772         gtk_tree_store_set (store, &iter2, 0, "Little Rock", -1);
 773
 774         gtk_tree_store_append (store, &iter2, &iter);
 775         gtk_tree_store_set (store, &iter2, 0, "Madison", -1);
 776
 777         gtk_tree_store_append (store, &iter2, &iter);
 778         gtk_tree_store_set (store, &iter2, 0, "Montgomery", -1);
 779
 780         gtk_tree_store_append (store, &iter2, &iter);
 781         gtk_tree_store_set (store, &iter2, 0, "Montpelier", -1);
 782
 783         gtk_tree_store_append (store, &iter2, &iter);
 784         gtk_tree_store_set (store, &iter2, 0, "Nashville", -1);
 785
 786         gtk_tree_store_append (store, &iter2, &iter);
 787         gtk_tree_store_set (store, &iter2, 0, "Oklahoma City", -1);
 788
 789         gtk_tree_store_append (store, &iter2, &iter);
 790         gtk_tree_store_set (store, &iter2, 0, "Olympia", -1);
 791
 792
 793         gtk_tree_store_append (store, &iter, NULL);
 794         gtk_tree_store_set (store, &iter, 0, "P - S", -1);
 795
 796         gtk_tree_store_append (store, &iter2, &iter);
 797         gtk_tree_store_set (store, &iter2, 0, "Phoenix", -1);
 798
 799         gtk_tree_store_append (store, &iter2, &iter);
 800         gtk_tree_store_set (store, &iter2, 0, "Pierre", -1);
 801
 802         gtk_tree_store_append (store, &iter2, &iter);
 803         gtk_tree_store_set (store, &iter2, 0, "Providence", -1);
 804
 805         gtk_tree_store_append (store, &iter2, &iter);
 806         gtk_tree_store_set (store, &iter2, 0, "Raleigh", -1);
 807
 808         gtk_tree_store_append (store, &iter2, &iter);
 809         gtk_tree_store_set (store, &iter2, 0, "Richmond", -1);
 810
 811         gtk_tree_store_append (store, &iter2, &iter);
 812         gtk_tree_store_set (store, &iter2, 0, "Sacramento", -1);
 813
 814         gtk_tree_store_append (store, &iter2, &iter);
 815         gtk_tree_store_set (store, &iter2, 0, "Salem", -1);
 816
 817         gtk_tree_store_append (store, &iter2, &iter);
 818         gtk_tree_store_set (store, &iter2, 0, "Salt Lake City", -1);
 819
 820         gtk_tree_store_append (store, &iter2, &iter);
 821         gtk_tree_store_set (store, &iter2, 0, "Santa Fe", -1);
 822
 823         gtk_tree_store_append (store, &iter2, &iter);
 824         gtk_tree_store_set (store, &iter2, 0, "Springfield", -1);
 825
 826         gtk_tree_store_append (store, &iter2, &iter);
 827         gtk_tree_store_set (store, &iter2, 0, "St. Paul", -1);
 828
 829
 830         gtk_tree_store_append (store, &iter, NULL);
 831         gtk_tree_store_set (store, &iter, 0, "T - Z", -1);
 832
 833         gtk_tree_store_append (store, &iter2, &iter);
 834         gtk_tree_store_set (store, &iter2, 0, "Tallahassee", -1);
 835
 836         gtk_tree_store_append (store, &iter2, &iter);
 837         gtk_tree_store_set (store, &iter2, 0, "Topeka", -1);
 838
 839         gtk_tree_store_append (store, &iter2, &iter);
 840         gtk_tree_store_set (store, &iter2, 0, "Trenton", -1);
 841
 842         return GTK_TREE_MODEL (store);
 843 }
 844
 845 static void
 846 capital_sensitive (GtkCellLayout   *cell_layout,
 847                    GtkCellRenderer *cell,
 848                    GtkTreeModel    *tree_model,
 849                    GtkTreeIter     *iter,
 850                    gpointer         data)
 851 {
 852   gboolean sensitive;
 853
 854   sensitive = !gtk_tree_model_iter_has_child (tree_model, iter);
 855
 856   g_object_set (cell, "sensitive", sensitive, NULL);
 857 }
 858
 859 static gboolean
 860 capital_animation (gpointer data)
 861 {
 862   static gint insert_count = 0;
 863   GtkTreeModel *model = GTK_TREE_MODEL (data);
 864   GtkTreePath *path;
 865   GtkTreeIter iter, parent;
 866
 867   switch (insert_count % 8)
 868     {
 869     case 0:
 870       gtk_tree_store_insert (GTK_TREE_STORE (model), &iter, NULL, 0);
 871       gtk_tree_store_set (GTK_TREE_STORE (model),
 872                           &iter,
 873                           0, "Europe", -1);
 874       break;
 875
 876     case 1:
 877       path = gtk_tree_path_new_from_indices (0, -1);
 878       gtk_tree_model_get_iter (model, &parent, path);
 879       gtk_tree_path_free (path);
 880       gtk_tree_store_insert (GTK_TREE_STORE (model), &iter, &parent, 0);
 881       gtk_tree_store_set (GTK_TREE_STORE (model),
 882                           &iter,
 883                           0, "Berlin", -1);
 884       break;
 885
 886     case 2:
 887       path = gtk_tree_path_new_from_indices (0, -1);
 888       gtk_tree_model_get_iter (model, &parent, path);
 889       gtk_tree_path_free (path);
 890       gtk_tree_store_insert (GTK_TREE_STORE (model), &iter, &parent, 1);
 891       gtk_tree_store_set (GTK_TREE_STORE (model),
 892                           &iter,
 893                           0, "London", -1);
 894       break;
 895
 896     case 3:
 897       path = gtk_tree_path_new_from_indices (0, -1);
 898       gtk_tree_model_get_iter (model, &parent, path);
 899       gtk_tree_path_free (path);
 900       gtk_tree_store_insert (GTK_TREE_STORE (model), &iter, &parent, 2);
 901       gtk_tree_store_set (GTK_TREE_STORE (model),
 902                           &iter,
 903                           0, "Paris", -1);
 904       break;
 905
 906     case 4:
 907       path = gtk_tree_path_new_from_indices (0, 2, -1);
 908       gtk_tree_model_get_iter (model, &iter, path);
 909       gtk_tree_path_free (path);
 910       gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
 911       break;
 912
 913     case 5:
 914       path = gtk_tree_path_new_from_indices (0, 1, -1);
 915       gtk_tree_model_get_iter (model, &iter, path);
 916       gtk_tree_path_free (path);
 917       gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
 918       break;
 919
 920     case 6:
 921       path = gtk_tree_path_new_from_indices (0, 0, -1);
 922       gtk_tree_model_get_iter (model, &iter, path);
 923       gtk_tree_path_free (path);
 924       gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
 925       break;
 926
 927     case 7:
 928       path = gtk_tree_path_new_from_indices (0, -1);
 929       gtk_tree_model_get_iter (model, &iter, path);
 930       gtk_tree_path_free (path);
 931       gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
 932       break;
 933
 934     default: ;
 935
 936     }
 937   insert_count++;
 938
 939   return TRUE;
 940 }
 941
 942 static void
 943 setup_combo_entry (GtkWidget *entry_box)
 944 {
 945         gtk_combo_box_append_text (GTK_COMBO_BOX (entry_box),
 946                                    "dum de dum");
 947         gtk_combo_box_append_text (GTK_COMBO_BOX (entry_box),
 948                                    "la la la");
 949         gtk_combo_box_append_text (GTK_COMBO_BOX (entry_box),
 950                                    "la la la dum de dum la la la la la la boom de da la la");
 951         gtk_combo_box_append_text (GTK_COMBO_BOX (entry_box),
 952                                    "bloop");
 953         gtk_combo_box_append_text (GTK_COMBO_BOX (entry_box),
 954                                    "bleep");
 955         gtk_combo_box_append_text (GTK_COMBO_BOX (entry_box),
 956                                    "klaas");
 957         gtk_combo_box_append_text (GTK_COMBO_BOX (entry_box),
 958                                    "klaas0");
 959         gtk_combo_box_append_text (GTK_COMBO_BOX (entry_box),
 960                                    "klaas1");
 961         gtk_combo_box_append_text (GTK_COMBO_BOX (entry_box),
 962                                    "klaas2");
 963         gtk_combo_box_append_text (GTK_COMBO_BOX (entry_box),
 964                                    "klaas3");
 965         gtk_combo_box_append_text (GTK_COMBO_BOX (entry_box),
 966                                    "klaas4");
 967         gtk_combo_box_append_text (GTK_COMBO_BOX (entry_box),
 968                                    "klaas5");
 969         gtk_combo_box_append_text (GTK_COMBO_BOX (entry_box),
 970                                    "klaas6");
 971         gtk_combo_box_append_text (GTK_COMBO_BOX (entry_box),
 972                                    "klaas7");
 973         gtk_combo_box_append_text (GTK_COMBO_BOX (entry_box),
 974                                    "klaas8");
 975         gtk_combo_box_append_text (GTK_COMBO_BOX (entry_box),
 976                                    "klaas9");
 977         gtk_combo_box_append_text (GTK_COMBO_BOX (entry_box),
 978                                    "klaasa");
 979         gtk_combo_box_append_text (GTK_COMBO_BOX (entry_box),
 980                                    "klaasb");
 981         gtk_combo_box_append_text (GTK_COMBO_BOX (entry_box),
 982                                    "klaasc");
 983         gtk_combo_box_append_text (GTK_COMBO_BOX (entry_box),
 984                                    "klaasd");
 985         gtk_combo_box_append_text (GTK_COMBO_BOX (entry_box),
 986                                    "klaase");
 987         gtk_combo_box_append_text (GTK_COMBO_BOX (entry_box),
 988                                    "klaasf");
 989         gtk_combo_box_append_text (GTK_COMBO_BOX (entry_box),
 990                                    "klaas10");
 991         gtk_combo_box_append_text (GTK_COMBO_BOX (entry_box),
 992                                    "klaas11");
 993         gtk_combo_box_append_text (GTK_COMBO_BOX (entry_box),
 994                                    "klaas12");
 995 }
 996
 997 static void
 998 set_sensitive (GtkCellLayout   *cell_layout,
 999                GtkCellRenderer *cell,
1000                GtkTreeModel    *tree_model,
1001                GtkTreeIter     *iter,
1002                gpointer         data)
1003 {
1004   GtkTreePath *path;
1005   gint *indices;
1006   gboolean sensitive;
1007
1008   path = gtk_tree_model_get_path (tree_model, iter);
1009   indices = gtk_tree_path_get_indices (path);
1010   sensitive = indices[0] != 1;
1011   gtk_tree_path_free (path);
1012
1013   g_object_set (cell, "sensitive", sensitive, NULL);
1014 }
1015
1016 static gboolean
1017 is_separator (GtkTreeModel *model,
1018               GtkTreeIter  *iter,
1019               gpointer      data)
1020 {
1021   GtkTreePath *path;
1022   gboolean result;
1023
1024   path = gtk_tree_model_get_path (model, iter);
1025   result = gtk_tree_path_get_indices (path)[0] == 4;
1026   gtk_tree_path_free (path);
1027
1028   return result;
1029
1030 }
1031
1032 static void
1033 displayed_row_changed (GtkComboBox *combo,
1034                        GtkCellView *cell)
1035 {
1036   gint row;
1037   GtkTreePath *path;
1038
1039   row = gtk_combo_box_get_active (combo);
1040   path = gtk_tree_path_new_from_indices (row, -1);
1041   gtk_cell_view_set_displayed_row (cell, path);
1042   gtk_tree_path_free (path);
1043 }
1044
1045 int
1046 main (int argc, char **argv)
1047 {
1048         GtkWidget *window, *cellview, *mainbox;
1049         GtkWidget *combobox, *comboboxtext, *comboboxgrid;
1050         GtkWidget *tmp, *boom;
1051         GtkCellRenderer *renderer;
1052         GdkPixbuf *pixbuf;
1053         GtkTreeModel *model;
1054         GtkTreePath *path;
1055         GtkTreeIter iter;
1056         GdkColor color;
1057         GtkListStore *store;
1058
1059         gtk_init (&argc, &argv);
1060
1061         if (g_getenv ("RTL"))
1062           gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL);
1063
1064         window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1065         gtk_container_set_border_width (GTK_CONTAINER (window), 5);
1066         g_signal_connect (window, "destroy", gtk_main_quit, NULL);
1067
1068         mainbox = gtk_vbox_new (FALSE, 2);
1069         gtk_container_add (GTK_CONTAINER (window), mainbox);
1070
1071         /* GtkCellView */
1072         tmp = gtk_frame_new ("GtkCellView");
1073         gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
1074
1075         boom = gtk_vbox_new (FALSE, 0);
1076         gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
1077         gtk_container_add (GTK_CONTAINER (tmp), boom);
1078
1079         cellview = gtk_cell_view_new ();
1080         renderer = gtk_cell_renderer_pixbuf_new ();
1081         pixbuf = gtk_widget_render_icon (cellview, GTK_STOCK_DIALOG_WARNING,
1082                                          GTK_ICON_SIZE_BUTTON, NULL);
1083
1084         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (cellview),
1085                                     renderer,
1086                                     FALSE);
1087         g_object_set (renderer, "pixbuf", pixbuf, NULL);
1088
1089         renderer = gtk_cell_renderer_text_new ();
1090         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (cellview),
1091                                     renderer,
1092                                     TRUE);
1093         g_object_set (renderer, "text", "la la la", NULL);
1094         gtk_container_add (GTK_CONTAINER (boom), cellview);
1095
1096         /* GtkComboBox list */
1097         tmp = gtk_frame_new ("GtkComboBox (list)");
1098         gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
1099
1100         boom = gtk_vbox_new (FALSE, 0);
1101         gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
1102         gtk_container_add (GTK_CONTAINER (tmp), boom);
1103
1104         model = create_list_blaat ();
1105         combobox = gtk_combo_box_new_with_model (model);
1106         gtk_combo_box_set_add_tearoffs (GTK_COMBO_BOX (combobox), TRUE);
1107         g_object_unref (model);
1108         gtk_container_add (GTK_CONTAINER (boom), combobox);
1109
1110         renderer = gtk_cell_renderer_pixbuf_new ();
1111         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
1112                                     renderer,
1113                                     FALSE);
1114         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
1115                                         "pixbuf", 0,
1116                                         NULL);
1117         gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
1118                                             renderer,
1119                                             set_sensitive,
1120                                             NULL, NULL);
1121
1122         renderer = gtk_cell_renderer_text_new ();
1123         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
1124                                     renderer,
1125                                     TRUE);
1126         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
1127                                         "text", 1,
1128                                         NULL);
1129         gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
1130                                             renderer,
1131                                             set_sensitive,
1132                                             NULL, NULL);
1133         gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combobox),
1134                                               is_separator, NULL, NULL);
1135
1136         gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 0);
1137
1138         /* GtkComboBox dynamic list */
1139         tmp = gtk_frame_new ("GtkComboBox (dynamic list)");
1140         gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
1141
1142         boom = gtk_vbox_new (FALSE, 0);
1143         gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
1144         gtk_container_add (GTK_CONTAINER (tmp), boom);
1145
1146         model = create_empty_list_blaat ();
1147         combobox = gtk_combo_box_new_with_model (model);
1148         g_signal_connect (combobox, "notify::popup-shown",
1149                           G_CALLBACK (populate_list_blaat), combobox);
1150
1151         gtk_combo_box_set_add_tearoffs (GTK_COMBO_BOX (combobox), TRUE);
1152         g_object_unref (model);
1153         gtk_container_add (GTK_CONTAINER (boom), combobox);
1154
1155         renderer = gtk_cell_renderer_pixbuf_new ();
1156         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
1157                                     renderer,
1158                                     FALSE);
1159         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
1160                                         "pixbuf", 0,
1161                                         NULL);
1162         gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
1163                                             renderer,
1164                                             set_sensitive,
1165                                             NULL, NULL);
1166
1167         renderer = gtk_cell_renderer_text_new ();
1168         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
1169                                     renderer,
1170                                     TRUE);
1171         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
1172                                         "text", 1,
1173                                         NULL);
1174         gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
1175                                             renderer,
1176                                             set_sensitive,
1177                                             NULL, NULL);
1178         gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combobox),
1179                                               is_separator, NULL, NULL);
1180
1181         gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 0);
1182         gtk_combo_box_set_title (GTK_COMBO_BOX (combobox), "Dynamic list");
1183
1184         /* GtkComboBox custom entry */
1185         tmp = gtk_frame_new ("GtkComboBox (custom)");
1186         gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
1187
1188         boom = gtk_vbox_new (FALSE, 0);
1189         gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
1190         gtk_container_add (GTK_CONTAINER (tmp), boom);
1191
1192         model = create_list_blaat ();
1193         combobox = gtk_combo_box_new_with_model (model);
1194         gtk_combo_box_set_add_tearoffs (GTK_COMBO_BOX (combobox), TRUE);
1195         g_object_unref (model);
1196         gtk_container_add (GTK_CONTAINER (boom), combobox);
1197
1198         renderer = gtk_cell_renderer_pixbuf_new ();
1199         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
1200                                     renderer,
1201                                     FALSE);
1202         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
1203                                         "pixbuf", 0,
1204                                         NULL);
1205         gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
1206                                             renderer,
1207                                             set_sensitive,
1208                                             NULL, NULL);
1209
1210         renderer = gtk_cell_renderer_text_new ();
1211         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
1212                                     renderer,
1213                                     TRUE);
1214         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
1215                                         "text", 1,
1216                                         NULL);
1217         gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
1218                                             renderer,
1219                                             set_sensitive,
1220                                             NULL, NULL);
1221         gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combobox),
1222                                               is_separator, NULL, NULL);
1223
1224         gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 0);
1225
1226         tmp = gtk_cell_view_new ();
1227         gtk_widget_show (tmp);
1228         gtk_cell_view_set_model (GTK_CELL_VIEW (tmp), model);
1229
1230         renderer = gtk_cell_renderer_text_new ();
1231         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (tmp), renderer, TRUE);
1232         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (tmp), renderer,
1233                                         "text", 1,
1234                                         NULL);
1235         color.red = 0xffff;
1236         color.blue = 0xffff;
1237         color.green = 0;
1238         gtk_cell_view_set_background_color (GTK_CELL_VIEW (tmp), &color);
1239         displayed_row_changed (GTK_COMBO_BOX (combobox), GTK_CELL_VIEW (tmp));
1240         g_signal_connect (combobox, "changed", G_CALLBACK (displayed_row_changed), tmp);
1241
1242         gtk_container_add (GTK_CONTAINER (combobox), tmp);
1243
1244         /* GtkComboBox tree */
1245         tmp = gtk_frame_new ("GtkComboBox (tree)");
1246         gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
1247
1248         boom = gtk_vbox_new (FALSE, 0);
1249         gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
1250         gtk_container_add (GTK_CONTAINER (tmp), boom);
1251
1252         model = create_tree_blaat ();
1253         combobox = gtk_combo_box_new_with_model (model);
1254         gtk_combo_box_set_add_tearoffs (GTK_COMBO_BOX (combobox), TRUE);
1255         g_object_unref (model);
1256         gtk_container_add (GTK_CONTAINER (boom), combobox);
1257
1258         renderer = gtk_cell_renderer_pixbuf_new ();
1259         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
1260                                     renderer,
1261                                     FALSE);
1262         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
1263                                         "pixbuf", 0,
1264                                         NULL);
1265         gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
1266                                             renderer,
1267                                             set_sensitive,
1268                                             NULL, NULL);
1269
1270         renderer = gtk_cell_renderer_text_new ();
1271         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
1272                                     renderer,
1273                                     TRUE);
1274         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
1275                                         "text", 1,
1276                                         NULL);
1277         gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
1278                                             renderer,
1279                                             set_sensitive,
1280                                             NULL, NULL);
1281         gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combobox),
1282                                               is_separator, NULL, NULL);
1283
1284         gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 0);
1285 #if 0
1286         g_timeout_add (1000, (GSourceFunc) animation_timer, model);
1287 #endif
1288
1289         /* GtkComboBox (grid mode) */
1290         tmp = gtk_frame_new ("GtkComboBox (grid mode)");
1291         gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
1292
1293         boom = gtk_vbox_new (FALSE, 0);
1294         gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
1295         gtk_container_add (GTK_CONTAINER (tmp), boom);
1296
1297         comboboxgrid = create_combo_box_grid_demo ();
1298         gtk_box_pack_start (GTK_BOX (boom), comboboxgrid, FALSE, FALSE, 0);
1299
1300
1301         /* GtkComboBoxEntry */
1302         tmp = gtk_frame_new ("GtkComboBox with entry");
1303         gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
1304
1305         boom = gtk_vbox_new (FALSE, 0);
1306         gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
1307         gtk_container_add (GTK_CONTAINER (tmp), boom);
1308
1309         store = gtk_list_store_new (1, G_TYPE_STRING);
1310         comboboxtext = g_object_new (GTK_TYPE_COMBO_BOX,
1311                                      "has-entry", TRUE,
1312                                      "model", store,
1313                                      "entry-text-column", 0,
1314                                      NULL);
1315         g_object_unref (store);
1316
1317         setup_combo_entry (comboboxtext);
1318         gtk_container_add (GTK_CONTAINER (boom), comboboxtext);
1319
1320
1321         /* Phylogenetic tree */
1322         tmp = gtk_frame_new ("What are you ?");
1323         gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
1324
1325         boom = gtk_vbox_new (FALSE, 0);
1326         gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
1327         gtk_container_add (GTK_CONTAINER (tmp), boom);
1328
1329         model = create_phylogenetic_tree ();
1330         combobox = gtk_combo_box_new_with_model (model);
1331         gtk_combo_box_set_add_tearoffs (GTK_COMBO_BOX (combobox), TRUE);
1332         g_object_unref (model);
1333         gtk_container_add (GTK_CONTAINER (boom), combobox);
1334
1335         renderer = gtk_cell_renderer_text_new ();
1336         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
1337                                     renderer,
1338                                     TRUE);
1339         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
1340                                         "text", 0,
1341                                         NULL);
1342
1343         gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 0);
1344
1345
1346         /* Capitals */
1347         tmp = gtk_frame_new ("Where are you ?");
1348         gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
1349
1350         boom = gtk_vbox_new (FALSE, 0);
1351         gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
1352         gtk_container_add (GTK_CONTAINER (tmp), boom);
1353
1354         model = create_capital_tree ();
1355         combobox = gtk_combo_box_new_with_model (model);
1356         gtk_combo_box_set_add_tearoffs (GTK_COMBO_BOX (combobox), TRUE);
1357         g_object_unref (model);
1358         gtk_container_add (GTK_CONTAINER (boom), combobox);
1359         renderer = gtk_cell_renderer_text_new ();
1360         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
1361                                     renderer,
1362                                     TRUE);
1363         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
1364                                         "text", 0,
1365                                         NULL);
1366         gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
1367                                             renderer,
1368                                             capital_sensitive,
1369                                             NULL, NULL);
1370         path = gtk_tree_path_new_from_indices (0, 8, -1);
1371         gtk_tree_model_get_iter (model, &iter, path);
1372         gtk_tree_path_free (path);
1373         gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combobox), &iter);
1374
1375 #if 1
1376         gdk_threads_add_timeout (1000, (GSourceFunc) capital_animation, model);
1377 #endif
1378
1379         /* Ellipsizing growing combos */
1380         tmp = gtk_frame_new ("Unconstrained Menu");
1381         gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
1382
1383         boom = gtk_vbox_new (FALSE, 0);
1384         gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
1385         gtk_container_add (GTK_CONTAINER (tmp), boom);
1386
1387         model = create_list_long ();
1388         combobox = gtk_combo_box_new_with_model (model);
1389         g_object_unref (model);
1390         gtk_container_add (GTK_CONTAINER (boom), combobox);
1391         renderer = gtk_cell_renderer_text_new ();
1392         g_object_set (G_OBJECT (renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
1393
1394         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, TRUE);
1395         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
1396                                         "text", 0, NULL);
1397         gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 0);
1398         gtk_combo_box_set_popup_fixed_width (GTK_COMBO_BOX (combobox), FALSE);
1399
1400         gtk_widget_show_all (window);
1401
1402         gtk_main ();
1403
1404         return 0;
1405 }
1406
1407 /* vim:expandtab
1408  */