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