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