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

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