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 (GtkComboBoxText *combo)
 944 {
 945   gtk_combo_box_text_append_text (combo,
 946                                    "dum de dum");
 947   gtk_combo_box_text_append_text (combo,
 948                                    "la la la");
 949   gtk_combo_box_text_append_text (combo,
 950                                    "la la la dum de dum la la la la la la boom de da la la");
 951   gtk_combo_box_text_append_text (combo,
 952                                    "bloop");
 953   gtk_combo_box_text_append_text (combo,
 954                                    "bleep");
 955   gtk_combo_box_text_append_text (combo,
 956                                    "klaas");
 957   gtk_combo_box_text_append_text (combo,
 958                                    "klaas0");
 959   gtk_combo_box_text_append_text (combo,
 960                                    "klaas1");
 961   gtk_combo_box_text_append_text (combo,
 962                                    "klaas2");
 963   gtk_combo_box_text_append_text (combo,
 964                                    "klaas3");
 965   gtk_combo_box_text_append_text (combo,
 966                                    "klaas4");
 967   gtk_combo_box_text_append_text (combo,
 968                                    "klaas5");
 969   gtk_combo_box_text_append_text (combo,
 970                                    "klaas6");
 971   gtk_combo_box_text_append_text (combo,
 972                                    "klaas7");
 973   gtk_combo_box_text_append_text (combo,
 974                                    "klaas8");
 975   gtk_combo_box_text_append_text (combo,
 976                                    "klaas9");
 977   gtk_combo_box_text_append_text (combo,
 978                                    "klaasa");
 979   gtk_combo_box_text_append_text (combo,
 980                                    "klaasb");
 981   gtk_combo_box_text_append_text (combo,
 982                                    "klaasc");
 983   gtk_combo_box_text_append_text (combo,
 984                                    "klaasd");
 985   gtk_combo_box_text_append_text (combo,
 986                                    "klaase");
 987   gtk_combo_box_text_append_text (combo,
 988                                    "klaasf");
 989   gtk_combo_box_text_append_text (combo,
 990                                    "klaas10");
 991   gtk_combo_box_text_append_text (combo,
 992                                    "klaas11");
 993   gtk_combo_box_text_append_text (combo,
 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
1058         gtk_init (&argc, &argv);
1059
1060         if (g_getenv ("RTL"))
1061           gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL);
1062
1063         window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1064         gtk_container_set_border_width (GTK_CONTAINER (window), 5);
1065         g_signal_connect (window, "destroy", gtk_main_quit, NULL);
1066
1067         mainbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE, 2);
1068         gtk_container_add (GTK_CONTAINER (window), mainbox);
1069
1070         /* GtkCellView */
1071         tmp = gtk_frame_new ("GtkCellView");
1072         gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
1073
1074         boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE, 0);
1075         gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
1076         gtk_container_add (GTK_CONTAINER (tmp), boom);
1077
1078         cellview = gtk_cell_view_new ();
1079         renderer = gtk_cell_renderer_pixbuf_new ();
1080         pixbuf = gtk_widget_render_icon (cellview, GTK_STOCK_DIALOG_WARNING,
1081                                          GTK_ICON_SIZE_BUTTON, NULL);
1082
1083         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (cellview),
1084                                     renderer,
1085                                     FALSE);
1086         g_object_set (renderer, "pixbuf", pixbuf, NULL);
1087
1088         renderer = gtk_cell_renderer_text_new ();
1089         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (cellview),
1090                                     renderer,
1091                                     TRUE);
1092         g_object_set (renderer, "text", "la la la", NULL);
1093         gtk_container_add (GTK_CONTAINER (boom), cellview);
1094
1095         /* GtkComboBox list */
1096         tmp = gtk_frame_new ("GtkComboBox (list)");
1097         gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
1098
1099         boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE, 0);
1100         gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
1101         gtk_container_add (GTK_CONTAINER (tmp), boom);
1102
1103         model = create_list_blaat ();
1104         combobox = gtk_combo_box_new_with_model (model);
1105         gtk_combo_box_set_add_tearoffs (GTK_COMBO_BOX (combobox), TRUE);
1106         g_object_unref (model);
1107         gtk_container_add (GTK_CONTAINER (boom), combobox);
1108
1109         renderer = gtk_cell_renderer_pixbuf_new ();
1110         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
1111                                     renderer,
1112                                     FALSE);
1113         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
1114                                         "pixbuf", 0,
1115                                         NULL);
1116         gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
1117                                             renderer,
1118                                             set_sensitive,
1119                                             NULL, NULL);
1120
1121         renderer = gtk_cell_renderer_text_new ();
1122         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
1123                                     renderer,
1124                                     TRUE);
1125         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
1126                                         "text", 1,
1127                                         NULL);
1128         gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
1129                                             renderer,
1130                                             set_sensitive,
1131                                             NULL, NULL);
1132         gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combobox),
1133                                               is_separator, NULL, NULL);
1134
1135         gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 0);
1136
1137         /* GtkComboBox dynamic list */
1138         tmp = gtk_frame_new ("GtkComboBox (dynamic list)");
1139         gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
1140
1141         boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE, 0);
1142         gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
1143         gtk_container_add (GTK_CONTAINER (tmp), boom);
1144
1145         model = create_empty_list_blaat ();
1146         combobox = gtk_combo_box_new_with_model (model);
1147         g_signal_connect (combobox, "notify::popup-shown",
1148                           G_CALLBACK (populate_list_blaat), combobox);
1149
1150         gtk_combo_box_set_add_tearoffs (GTK_COMBO_BOX (combobox), TRUE);
1151         g_object_unref (model);
1152         gtk_container_add (GTK_CONTAINER (boom), combobox);
1153
1154         renderer = gtk_cell_renderer_pixbuf_new ();
1155         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
1156                                     renderer,
1157                                     FALSE);
1158         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
1159                                         "pixbuf", 0,
1160                                         NULL);
1161         gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
1162                                             renderer,
1163                                             set_sensitive,
1164                                             NULL, NULL);
1165
1166         renderer = gtk_cell_renderer_text_new ();
1167         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
1168                                     renderer,
1169                                     TRUE);
1170         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
1171                                         "text", 1,
1172                                         NULL);
1173         gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
1174                                             renderer,
1175                                             set_sensitive,
1176                                             NULL, NULL);
1177         gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combobox),
1178                                               is_separator, NULL, NULL);
1179
1180         gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 0);
1181         gtk_combo_box_set_title (GTK_COMBO_BOX (combobox), "Dynamic list");
1182
1183         /* GtkComboBox custom entry */
1184         tmp = gtk_frame_new ("GtkComboBox (custom)");
1185         gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
1186
1187         boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE, 0);
1188         gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
1189         gtk_container_add (GTK_CONTAINER (tmp), boom);
1190
1191         model = create_list_blaat ();
1192         combobox = gtk_combo_box_new_with_model (model);
1193         gtk_combo_box_set_add_tearoffs (GTK_COMBO_BOX (combobox), TRUE);
1194         g_object_unref (model);
1195         gtk_container_add (GTK_CONTAINER (boom), combobox);
1196
1197         renderer = gtk_cell_renderer_pixbuf_new ();
1198         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
1199                                     renderer,
1200                                     FALSE);
1201         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
1202                                         "pixbuf", 0,
1203                                         NULL);
1204         gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
1205                                             renderer,
1206                                             set_sensitive,
1207                                             NULL, NULL);
1208
1209         renderer = gtk_cell_renderer_text_new ();
1210         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
1211                                     renderer,
1212                                     TRUE);
1213         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
1214                                         "text", 1,
1215                                         NULL);
1216         gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
1217                                             renderer,
1218                                             set_sensitive,
1219                                             NULL, NULL);
1220         gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combobox),
1221                                               is_separator, NULL, NULL);
1222
1223         gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 0);
1224
1225         tmp = gtk_cell_view_new ();
1226         gtk_widget_show (tmp);
1227         gtk_cell_view_set_model (GTK_CELL_VIEW (tmp), model);
1228
1229         renderer = gtk_cell_renderer_text_new ();
1230         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (tmp), renderer, TRUE);
1231         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (tmp), renderer,
1232                                         "text", 1,
1233                                         NULL);
1234         color.red = 0xffff;
1235         color.blue = 0xffff;
1236         color.green = 0;
1237         gtk_cell_view_set_background_color (GTK_CELL_VIEW (tmp), &color);
1238         displayed_row_changed (GTK_COMBO_BOX (combobox), GTK_CELL_VIEW (tmp));
1239         g_signal_connect (combobox, "changed", G_CALLBACK (displayed_row_changed), tmp);
1240
1241         gtk_container_add (GTK_CONTAINER (combobox), tmp);
1242
1243         /* GtkComboBox tree */
1244         tmp = gtk_frame_new ("GtkComboBox (tree)");
1245         gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
1246
1247         boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE, 0);
1248         gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
1249         gtk_container_add (GTK_CONTAINER (tmp), boom);
1250
1251         model = create_tree_blaat ();
1252         combobox = gtk_combo_box_new_with_model (model);
1253         gtk_combo_box_set_add_tearoffs (GTK_COMBO_BOX (combobox), TRUE);
1254         g_object_unref (model);
1255         gtk_container_add (GTK_CONTAINER (boom), combobox);
1256
1257         renderer = gtk_cell_renderer_pixbuf_new ();
1258         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
1259                                     renderer,
1260                                     FALSE);
1261         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
1262                                         "pixbuf", 0,
1263                                         NULL);
1264         gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
1265                                             renderer,
1266                                             set_sensitive,
1267                                             NULL, NULL);
1268
1269         renderer = gtk_cell_renderer_text_new ();
1270         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
1271                                     renderer,
1272                                     TRUE);
1273         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
1274                                         "text", 1,
1275                                         NULL);
1276         gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
1277                                             renderer,
1278                                             set_sensitive,
1279                                             NULL, NULL);
1280         gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combobox),
1281                                               is_separator, NULL, NULL);
1282
1283         gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 0);
1284 #if 0
1285         g_timeout_add (1000, (GSourceFunc) animation_timer, model);
1286 #endif
1287
1288         /* GtkComboBox (grid mode) */
1289         tmp = gtk_frame_new ("GtkComboBox (grid mode)");
1290         gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
1291
1292         boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE, 0);
1293         gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
1294         gtk_container_add (GTK_CONTAINER (tmp), boom);
1295
1296         comboboxgrid = create_combo_box_grid_demo ();
1297         gtk_box_pack_start (GTK_BOX (boom), comboboxgrid, FALSE, FALSE, 0);
1298
1299
1300         /* GtkComboBoxEntry */
1301         tmp = gtk_frame_new ("GtkComboBox with entry");
1302         gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
1303
1304         boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE, 0);
1305         gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
1306         gtk_container_add (GTK_CONTAINER (tmp), boom);
1307
1308         comboboxtext = gtk_combo_box_text_new_with_entry ();
1309         setup_combo_entry (GTK_COMBO_BOX_TEXT (comboboxtext));
1310         gtk_container_add (GTK_CONTAINER (boom), comboboxtext);
1311
1312
1313         /* Phylogenetic tree */
1314         tmp = gtk_frame_new ("What are you ?");
1315         gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
1316
1317         boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE, 0);
1318         gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
1319         gtk_container_add (GTK_CONTAINER (tmp), boom);
1320
1321         model = create_phylogenetic_tree ();
1322         combobox = gtk_combo_box_new_with_model (model);
1323         gtk_combo_box_set_add_tearoffs (GTK_COMBO_BOX (combobox), TRUE);
1324         g_object_unref (model);
1325         gtk_container_add (GTK_CONTAINER (boom), combobox);
1326
1327         renderer = gtk_cell_renderer_text_new ();
1328         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
1329                                     renderer,
1330                                     TRUE);
1331         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
1332                                         "text", 0,
1333                                         NULL);
1334
1335         gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 0);
1336
1337
1338         /* Capitals */
1339         tmp = gtk_frame_new ("Where are you ?");
1340         gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
1341
1342         boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE, 0);
1343         gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
1344         gtk_container_add (GTK_CONTAINER (tmp), boom);
1345
1346         model = create_capital_tree ();
1347         combobox = gtk_combo_box_new_with_model (model);
1348         gtk_combo_box_set_add_tearoffs (GTK_COMBO_BOX (combobox), TRUE);
1349         g_object_unref (model);
1350         gtk_container_add (GTK_CONTAINER (boom), combobox);
1351         renderer = gtk_cell_renderer_text_new ();
1352         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
1353                                     renderer,
1354                                     TRUE);
1355         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
1356                                         "text", 0,
1357                                         NULL);
1358         gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
1359                                             renderer,
1360                                             capital_sensitive,
1361                                             NULL, NULL);
1362         path = gtk_tree_path_new_from_indices (0, 8, -1);
1363         gtk_tree_model_get_iter (model, &iter, path);
1364         gtk_tree_path_free (path);
1365         gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combobox), &iter);
1366
1367 #if 1
1368         gdk_threads_add_timeout (1000, (GSourceFunc) capital_animation, model);
1369 #endif
1370
1371         /* Ellipsizing growing combos */
1372         tmp = gtk_frame_new ("Unconstrained Menu");
1373         gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
1374
1375         boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE, 0);
1376         gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
1377         gtk_container_add (GTK_CONTAINER (tmp), boom);
1378
1379         model = create_list_long ();
1380         combobox = gtk_combo_box_new_with_model (model);
1381         g_object_unref (model);
1382         gtk_container_add (GTK_CONTAINER (boom), combobox);
1383         renderer = gtk_cell_renderer_text_new ();
1384         g_object_set (G_OBJECT (renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
1385
1386         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, TRUE);
1387         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
1388                                         "text", 0, NULL);
1389         gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 0);
1390         gtk_combo_box_set_popup_fixed_width (GTK_COMBO_BOX (combobox), FALSE);
1391
1392         gtk_widget_show_all (window);
1393
1394         gtk_main ();
1395
1396         return 0;
1397 }
1398
1399 /* vim:expandtab
1400  */