Pileus Git - ~andy/gtk/blob - gtk/gtkcombobox.c

   1 /* gtkcombobox.c
   2  * Copyright (C) 2002, 2003  Kristian Rietveld <kris@gtk.org>
   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
  20 #include "config.h"
  21 #include "gtkcombobox.h"
  22
  23 #include "gtkarrow.h"
  24 #include "gtkbindings.h"
  25 #include "gtkcelllayout.h"
  26 #include "gtkcellrenderertext.h"
  27 #include "gtkcellview.h"
  28 #include "gtkeventbox.h"
  29 #include "gtkframe.h"
  30 #include "gtkhbox.h"
  31 #include "gtkliststore.h"
  32 #include "gtkmain.h"
  33 #include "gtkmenu.h"
  34 #include "gtkscrolledwindow.h"
  35 #include "gtkseparatormenuitem.h"
  36 #include "gtktearoffmenuitem.h"
  37 #include "gtktogglebutton.h"
  38 #include "gtktreeselection.h"
  39 #include "gtkvseparator.h"
  40 #include "gtkwindow.h"
  41 #include "gtkprivate.h"
  42
  43 #include <gdk/gdkkeysyms.h>
  44
  45 #include <gobject/gvaluecollector.h>
  46
  47 #include <string.h>
  48 #include <stdarg.h>
  49
  50 #include "gtkmarshalers.h"
  51 #include "gtkintl.h"
  52
  53 #include "gtktreeprivate.h"
  54
  55
  56 /**
  57  * SECTION:gtkcombobox
  58  * @Short_description: A widget used to choose from a list of items
  59  * @Title: GtkComboBox
  60  * @See_also: #GtkComboBoxText, #GtkTreeModel, #GtkCellRenderer
  61  *
  62  * A GtkComboBox is a widget that allows the user to choose from a list of
  63  * valid choices. The GtkComboBox displays the selected choice. When
  64  * activated, the GtkComboBox displays a popup which allows the user to
  65  * make a new choice. The style in which the selected value is displayed,
  66  * and the style of the popup is determined by the current theme. It may
  67  * be similar to a Windows-style combo box.
  68  *
  69  * The GtkComboBox uses the model-view pattern; the list of valid choices
  70  * is specified in the form of a tree model, and the display of the choices
  71  * can be adapted to the data in the model by using cell renderers, as you
  72  * would in a tree view. This is possible since GtkComboBox implements the
  73  * #GtkCellLayout interface. The tree model holding the valid choices is
  74  * not restricted to a flat list, it can be a real tree, and the popup will
  75  * reflect the tree structure.
  76  *
  77  * For a simple list of textual choices, the model-view API of GtkComboBox
  78  * can be a bit overwhelming. In this case, #GtkComboBoxText offers a
  79  * simple alternative.
  80  */
  81
  82
  83 /* WELCOME, to THE house of evil code */
  84
  85 typedef struct _ComboCellInfo ComboCellInfo;
  86 struct _ComboCellInfo
  87 {
  88   GtkCellRenderer *cell;
  89   GSList *attributes;
  90
  91   GtkCellLayoutDataFunc func;
  92   gpointer func_data;
  93   GDestroyNotify destroy;
  94
  95   guint expand : 1;
  96   guint pack : 1;
  97 };
  98
  99
 100 struct _GtkComboBoxPrivate
 101 {
 102   GtkTreeModel *model;
 103
 104   gint col_column;
 105   gint row_column;
 106
 107   gint wrap_width;
 108   GtkShadowType shadow_type;
 109
 110   gint active; /* Only temporary */
 111   GtkTreeRowReference *active_row;
 112
 113   GtkWidget *tree_view;
 114   GtkTreeViewColumn *column;
 115
 116   GtkWidget *cell_view;
 117   GtkWidget *cell_view_frame;
 118
 119   GtkWidget *button;
 120   GtkWidget *box;
 121   GtkWidget *arrow;
 122   GtkWidget *separator;
 123
 124   GtkWidget *popup_widget;
 125   GtkWidget *popup_window;
 126   GtkWidget *scrolled_window;
 127
 128   gulong inserted_id;
 129   gulong deleted_id;
 130   gulong reordered_id;
 131   gulong changed_id;
 132   guint popup_idle_id;
 133   guint activate_button;
 134   guint32 activate_time;
 135   guint scroll_timer;
 136   guint resize_idle_id;
 137
 138   gint  minimum_width;
 139   gint  natural_width;
 140
 141   /* For "has-entry" specific behavior we track
 142    * an automated cell renderer and text column */
 143   gint  text_column;
 144   GtkCellRenderer *text_renderer;
 145
 146   GSList *cells;
 147
 148   guint popup_in_progress : 1;
 149   guint popup_shown : 1;
 150   guint add_tearoffs : 1;
 151   guint has_frame : 1;
 152   guint is_cell_renderer : 1;
 153   guint editing_canceled : 1;
 154   guint auto_scroll : 1;
 155   guint focus_on_click : 1;
 156   guint button_sensitivity : 2;
 157   guint has_entry : 1;
 158   guint popup_fixed_width : 1;
 159
 160   GtkTreeViewRowSeparatorFunc row_separator_func;
 161   gpointer                    row_separator_data;
 162   GDestroyNotify              row_separator_destroy;
 163
 164   GdkDevice *grab_pointer;
 165   GdkDevice *grab_keyboard;
 166
 167   gchar *tearoff_title;
 168 };
 169
 170 /* While debugging this evil code, I have learned that
 171  * there are actually 4 modes to this widget, which can
 172  * be characterized as follows
 173  *
 174  * 1) menu mode, no child added
 175  *
 176  * tree_view -> NULL
 177  * cell_view -> GtkCellView, regular child
 178  * cell_view_frame -> NULL
 179  * button -> GtkToggleButton set_parent to combo
 180  * arrow -> GtkArrow set_parent to button
 181  * separator -> GtkVSepator set_parent to button
 182  * popup_widget -> GtkMenu
 183  * popup_window -> NULL
 184  * scrolled_window -> NULL
 185  *
 186  * 2) menu mode, child added
 187  *
 188  * tree_view -> NULL
 189  * cell_view -> NULL
 190  * cell_view_frame -> NULL
 191  * button -> GtkToggleButton set_parent to combo
 192  * arrow -> GtkArrow, child of button
 193  * separator -> NULL
 194  * popup_widget -> GtkMenu
 195  * popup_window -> NULL
 196  * scrolled_window -> NULL
 197  *
 198  * 3) list mode, no child added
 199  *
 200  * tree_view -> GtkTreeView, child of scrolled_window
 201  * cell_view -> GtkCellView, regular child
 202  * cell_view_frame -> GtkFrame, set parent to combo
 203  * button -> GtkToggleButton, set_parent to combo
 204  * arrow -> GtkArrow, child of button
 205  * separator -> NULL
 206  * popup_widget -> tree_view
 207  * popup_window -> GtkWindow
 208  * scrolled_window -> GtkScrolledWindow, child of popup_window
 209  *
 210  * 4) list mode, child added
 211  *
 212  * tree_view -> GtkTreeView, child of scrolled_window
 213  * cell_view -> NULL
 214  * cell_view_frame -> NULL
 215  * button -> GtkToggleButton, set_parent to combo
 216  * arrow -> GtkArrow, child of button
 217  * separator -> NULL
 218  * popup_widget -> tree_view
 219  * popup_window -> GtkWindow
 220  * scrolled_window -> GtkScrolledWindow, child of popup_window
 221  *
 222  */
 223
 224 enum {
 225   CHANGED,
 226   MOVE_ACTIVE,
 227   POPUP,
 228   POPDOWN,
 229   LAST_SIGNAL
 230 };
 231
 232 enum {
 233   PROP_0,
 234   PROP_MODEL,
 235   PROP_WRAP_WIDTH,
 236   PROP_ROW_SPAN_COLUMN,
 237   PROP_COLUMN_SPAN_COLUMN,
 238   PROP_ACTIVE,
 239   PROP_ADD_TEAROFFS,
 240   PROP_TEAROFF_TITLE,
 241   PROP_HAS_FRAME,
 242   PROP_FOCUS_ON_CLICK,
 243   PROP_POPUP_SHOWN,
 244   PROP_BUTTON_SENSITIVITY,
 245   PROP_EDITING_CANCELED,
 246   PROP_HAS_ENTRY,
 247   PROP_ENTRY_TEXT_COLUMN,
 248   PROP_POPUP_FIXED_WIDTH
 249 };
 250
 251 static guint combo_box_signals[LAST_SIGNAL] = {0,};
 252
 253 #define BONUS_PADDING 4
 254 #define SCROLL_TIME  100
 255
 256 /* common */
 257
 258 static void     gtk_combo_box_cell_layout_init     (GtkCellLayoutIface *iface);
 259 static void     gtk_combo_box_cell_editable_init   (GtkCellEditableIface *iface);
 260 static GObject *gtk_combo_box_constructor          (GType                  type,
 261                                                     guint                  n_construct_properties,
 262                                                     GObjectConstructParam *construct_properties);
 263 static void     gtk_combo_box_dispose              (GObject          *object);
 264 static void     gtk_combo_box_finalize             (GObject          *object);
 265 static void     gtk_combo_box_destroy              (GtkWidget        *widget);
 266
 267 static void     gtk_combo_box_set_property         (GObject         *object,
 268                                                     guint            prop_id,
 269                                                     const GValue    *value,
 270                                                     GParamSpec      *spec);
 271 static void     gtk_combo_box_get_property         (GObject         *object,
 272                                                     guint            prop_id,
 273                                                     GValue          *value,
 274                                                     GParamSpec      *spec);
 275
 276 static void     gtk_combo_box_state_changed        (GtkWidget        *widget,
 277                                                     GtkStateType      previous);
 278 static void     gtk_combo_box_grab_focus           (GtkWidget       *widget);
 279 static void     gtk_combo_box_style_set            (GtkWidget       *widget,
 280                                                     GtkStyle        *previous);
 281 static void     gtk_combo_box_button_toggled       (GtkWidget       *widget,
 282                                                     gpointer         data);
 283 static void     gtk_combo_box_button_state_changed (GtkWidget       *widget,
 284                                                     GtkStateType     previous,
 285                                                     gpointer         data);
 286 static void     gtk_combo_box_add                  (GtkContainer    *container,
 287                                                     GtkWidget       *widget);
 288 static void     gtk_combo_box_remove               (GtkContainer    *container,
 289                                                     GtkWidget       *widget);
 290
 291 static ComboCellInfo *gtk_combo_box_get_cell_info  (GtkComboBox      *combo_box,
 292                                                     GtkCellRenderer  *cell);
 293
 294 static void     gtk_combo_box_menu_show            (GtkWidget        *menu,
 295                                                     gpointer          user_data);
 296 static void     gtk_combo_box_menu_hide            (GtkWidget        *menu,
 297                                                     gpointer          user_data);
 298
 299 static void     gtk_combo_box_set_popup_widget     (GtkComboBox      *combo_box,
 300                                                     GtkWidget        *popup);
 301 static void     gtk_combo_box_menu_position_below  (GtkMenu          *menu,
 302                                                     gint             *x,
 303                                                     gint             *y,
 304                                                     gint             *push_in,
 305                                                     gpointer          user_data);
 306 static void     gtk_combo_box_menu_position_over   (GtkMenu          *menu,
 307                                                     gint             *x,
 308                                                     gint             *y,
 309                                                     gint             *push_in,
 310                                                     gpointer          user_data);
 311 static void     gtk_combo_box_menu_position        (GtkMenu          *menu,
 312                                                     gint             *x,
 313                                                     gint             *y,
 314                                                     gint             *push_in,
 315                                                     gpointer          user_data);
 316
 317 static void     gtk_combo_box_update_requested_width(GtkComboBox      *combo_box,
 318                                                      GtkTreePath      *path);
 319 static void     gtk_combo_box_remeasure            (GtkComboBox      *combo_box);
 320
 321 static void     gtk_combo_box_unset_model          (GtkComboBox      *combo_box);
 322
 323 static void     gtk_combo_box_size_allocate        (GtkWidget        *widget,
 324                                                     GtkAllocation    *allocation);
 325 static void     gtk_combo_box_forall               (GtkContainer     *container,
 326                                                     gboolean          include_internals,
 327                                                     GtkCallback       callback,
 328                                                     gpointer          callback_data);
 329 static gboolean gtk_combo_box_draw                 (GtkWidget        *widget,
 330                                                     cairo_t          *cr);
 331 static gboolean gtk_combo_box_scroll_event         (GtkWidget        *widget,
 332                                                     GdkEventScroll   *event);
 333 static void     gtk_combo_box_set_active_internal  (GtkComboBox      *combo_box,
 334                                                     GtkTreePath      *path);
 335
 336 static void     gtk_combo_box_check_appearance     (GtkComboBox      *combo_box);
 337 static void     gtk_combo_box_real_move_active     (GtkComboBox      *combo_box,
 338                                                     GtkScrollType     scroll);
 339 static void     gtk_combo_box_real_popup           (GtkComboBox      *combo_box);
 340 static gboolean gtk_combo_box_real_popdown         (GtkComboBox      *combo_box);
 341
 342 /* listening to the model */
 343 static void     gtk_combo_box_model_row_inserted   (GtkTreeModel     *model,
 344                                                     GtkTreePath      *path,
 345                                                     GtkTreeIter      *iter,
 346                                                     gpointer          user_data);
 347 static void     gtk_combo_box_model_row_deleted    (GtkTreeModel     *model,
 348                                                     GtkTreePath      *path,
 349                                                     gpointer          user_data);
 350 static void     gtk_combo_box_model_rows_reordered (GtkTreeModel     *model,
 351                                                     GtkTreePath      *path,
 352                                                     GtkTreeIter      *iter,
 353                                                     gint             *new_order,
 354                                                     gpointer          user_data);
 355 static void     gtk_combo_box_model_row_changed    (GtkTreeModel     *model,
 356                                                     GtkTreePath      *path,
 357                                                     GtkTreeIter      *iter,
 358                                                     gpointer          data);
 359 static void     gtk_combo_box_model_row_expanded   (GtkTreeModel     *model,
 360                                                     GtkTreePath      *path,
 361                                                     GtkTreeIter      *iter,
 362                                                     gpointer          data);
 363
 364 /* list */
 365 static void     gtk_combo_box_list_position        (GtkComboBox      *combo_box,
 366                                                     gint             *x,
 367                                                     gint             *y,
 368                                                     gint             *width,
 369                                                     gint             *height);
 370 static void     gtk_combo_box_list_setup           (GtkComboBox      *combo_box);
 371 static void     gtk_combo_box_list_destroy         (GtkComboBox      *combo_box);
 372
 373 static gboolean gtk_combo_box_list_button_released (GtkWidget        *widget,
 374                                                     GdkEventButton   *event,
 375                                                     gpointer          data);
 376 static gboolean gtk_combo_box_list_key_press       (GtkWidget        *widget,
 377                                                     GdkEventKey      *event,
 378                                                     gpointer          data);
 379 static gboolean gtk_combo_box_list_enter_notify    (GtkWidget        *widget,
 380                                                     GdkEventCrossing *event,
 381                                                     gpointer          data);
 382 static void     gtk_combo_box_list_auto_scroll     (GtkComboBox   *combo,
 383                                                     gint           x,
 384                                                     gint           y);
 385 static gboolean gtk_combo_box_list_scroll_timeout  (GtkComboBox   *combo);
 386 static gboolean gtk_combo_box_list_button_pressed  (GtkWidget        *widget,
 387                                                     GdkEventButton   *event,
 388                                                     gpointer          data);
 389
 390 static gboolean gtk_combo_box_list_select_func     (GtkTreeSelection *selection,
 391                                                     GtkTreeModel     *model,
 392                                                     GtkTreePath      *path,
 393                                                     gboolean          path_currently_selected,
 394                                                     gpointer          data);
 395
 396 static void     gtk_combo_box_list_row_changed     (GtkTreeModel     *model,
 397                                                     GtkTreePath      *path,
 398                                                     GtkTreeIter      *iter,
 399                                                     gpointer          data);
 400 static void     gtk_combo_box_list_popup_resize    (GtkComboBox      *combo_box);
 401
 402 /* menu */
 403 static void     gtk_combo_box_menu_setup           (GtkComboBox      *combo_box,
 404                                                     gboolean          add_children);
 405 static void     gtk_combo_box_menu_fill            (GtkComboBox      *combo_box);
 406 static void     gtk_combo_box_menu_fill_level      (GtkComboBox      *combo_box,
 407                                                     GtkWidget        *menu,
 408                                                     GtkTreeIter      *iter);
 409 static void     gtk_combo_box_update_title         (GtkComboBox      *combo_box);
 410 static void     gtk_combo_box_menu_destroy         (GtkComboBox      *combo_box);
 411
 412 static void     gtk_combo_box_relayout_item        (GtkComboBox      *combo_box,
 413                                                     GtkWidget        *item,
 414                                                     GtkTreeIter      *iter,
 415                                                     GtkWidget        *last);
 416 static void     gtk_combo_box_relayout             (GtkComboBox      *combo_box);
 417
 418 static gboolean gtk_combo_box_menu_button_press    (GtkWidget        *widget,
 419                                                     GdkEventButton   *event,
 420                                                     gpointer          user_data);
 421 static void     gtk_combo_box_menu_item_activate   (GtkWidget        *item,
 422                                                     gpointer          user_data);
 423
 424 static void     gtk_combo_box_update_sensitivity   (GtkComboBox      *combo_box);
 425 static void     gtk_combo_box_menu_row_inserted    (GtkTreeModel     *model,
 426                                                     GtkTreePath      *path,
 427                                                     GtkTreeIter      *iter,
 428                                                     gpointer          user_data);
 429 static void     gtk_combo_box_menu_row_deleted     (GtkTreeModel     *model,
 430                                                     GtkTreePath      *path,
 431                                                     gpointer          user_data);
 432 static void     gtk_combo_box_menu_rows_reordered  (GtkTreeModel     *model,
 433                                                     GtkTreePath      *path,
 434                                                     GtkTreeIter      *iter,
 435                                                     gint             *new_order,
 436                                                     gpointer          user_data);
 437 static void     gtk_combo_box_menu_row_changed     (GtkTreeModel     *model,
 438                                                     GtkTreePath      *path,
 439                                                     GtkTreeIter      *iter,
 440                                                     gpointer          data);
 441 static gboolean gtk_combo_box_menu_key_press       (GtkWidget        *widget,
 442                                                     GdkEventKey      *event,
 443                                                     gpointer          data);
 444 static void     gtk_combo_box_menu_popup           (GtkComboBox      *combo_box,
 445                                                     guint             button,
 446                                                     guint32           activate_time);
 447 static GtkWidget *gtk_cell_view_menu_item_new      (GtkComboBox      *combo_box,
 448                                                     GtkTreeModel     *model,
 449                                                     GtkTreeIter      *iter);
 450
 451 /* cell layout */
 452 static void     gtk_combo_box_cell_layout_pack_start         (GtkCellLayout         *layout,
 453                                                               GtkCellRenderer       *cell,
 454                                                               gboolean               expand);
 455 static void     gtk_combo_box_cell_layout_pack_end           (GtkCellLayout         *layout,
 456                                                               GtkCellRenderer       *cell,
 457                                                               gboolean               expand);
 458 static GList   *gtk_combo_box_cell_layout_get_cells          (GtkCellLayout         *layout);
 459 static void     gtk_combo_box_cell_layout_clear              (GtkCellLayout         *layout);
 460 static void     gtk_combo_box_cell_layout_add_attribute      (GtkCellLayout         *layout,
 461                                                               GtkCellRenderer       *cell,
 462                                                               const gchar           *attribute,
 463                                                               gint                   column);
 464 static void     gtk_combo_box_cell_layout_set_cell_data_func (GtkCellLayout         *layout,
 465                                                               GtkCellRenderer       *cell,
 466                                                               GtkCellLayoutDataFunc  func,
 467                                                               gpointer               func_data,
 468                                                               GDestroyNotify         destroy);
 469 static void     gtk_combo_box_cell_layout_clear_attributes   (GtkCellLayout         *layout,
 470                                                               GtkCellRenderer       *cell);
 471 static void     gtk_combo_box_cell_layout_reorder            (GtkCellLayout         *layout,
 472                                                               GtkCellRenderer       *cell,
 473                                                               gint                   position);
 474 static gboolean gtk_combo_box_mnemonic_activate              (GtkWidget    *widget,
 475                                                               gboolean      group_cycling);
 476
 477 static void     gtk_combo_box_sync_cells                     (GtkComboBox   *combo_box,
 478                                                               GtkCellLayout *cell_layout);
 479 static void     combo_cell_data_func                         (GtkCellLayout   *cell_layout,
 480                                                               GtkCellRenderer *cell,
 481                                                               GtkTreeModel    *tree_model,
 482                                                               GtkTreeIter     *iter,
 483                                                               gpointer         data);
 484 static void     gtk_combo_box_child_show                     (GtkWidget       *widget,
 485                                                               GtkComboBox     *combo_box);
 486 static void     gtk_combo_box_child_hide                     (GtkWidget       *widget,
 487                                                               GtkComboBox     *combo_box);
 488
 489 /* GtkComboBox:has-entry callbacks */
 490 static void     gtk_combo_box_entry_contents_changed         (GtkEntry        *entry,
 491                                                               gpointer         user_data);
 492 static void     gtk_combo_box_entry_active_changed           (GtkComboBox     *combo_box,
 493                                                               gpointer         user_data);
 494
 495
 496 /* GtkBuildable method implementation */
 497 static GtkBuildableIface *parent_buildable_iface;
 498
 499 static void     gtk_combo_box_buildable_init                 (GtkBuildableIface *iface);
 500 static gboolean gtk_combo_box_buildable_custom_tag_start     (GtkBuildable  *buildable,
 501                                                               GtkBuilder    *builder,
 502                                                               GObject       *child,
 503                                                               const gchar   *tagname,
 504                                                               GMarkupParser *parser,
 505                                                               gpointer      *data);
 506 static void     gtk_combo_box_buildable_custom_tag_end       (GtkBuildable  *buildable,
 507                                                               GtkBuilder    *builder,
 508                                                               GObject       *child,
 509                                                               const gchar   *tagname,
 510                                                               gpointer      *data);
 511 static GObject *gtk_combo_box_buildable_get_internal_child   (GtkBuildable *buildable,
 512                                                               GtkBuilder   *builder,
 513                                                               const gchar  *childname);
 514
 515
 516 /* GtkCellEditable method implementations */
 517 static void     gtk_combo_box_start_editing                  (GtkCellEditable *cell_editable,
 518                                                               GdkEvent        *event);
 519
 520 static void     gtk_combo_box_get_preferred_width            (GtkWidget           *widget,
 521                                                               gint                *minimum_size,
 522                                                               gint                *natural_size);
 523 static void     gtk_combo_box_get_preferred_height           (GtkWidget           *widget,
 524                                                               gint                *minimum_size,
 525                                                               gint                *natural_size);
 526 static void     gtk_combo_box_get_preferred_width_for_height (GtkWidget             *widget,
 527                                                               gint                   avail_size,
 528                                                               gint                  *minimum_size,
 529                                                               gint                  *natural_size);
 530 static void     gtk_combo_box_get_preferred_height_for_width (GtkWidget             *widget,
 531                                                               gint                   avail_size,
 532                                                               gint                  *minimum_size,
 533                                                               gint                  *natural_size);
 534
 535
 536 G_DEFINE_TYPE_WITH_CODE (GtkComboBox, gtk_combo_box, GTK_TYPE_BIN,
 537                          G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_LAYOUT,
 538                                                 gtk_combo_box_cell_layout_init)
 539                          G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_EDITABLE,
 540                                                 gtk_combo_box_cell_editable_init)
 541                          G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
 542                                                 gtk_combo_box_buildable_init))
 543
 544
 545 /* common */
 546 static void
 547 gtk_combo_box_class_init (GtkComboBoxClass *klass)
 548 {
 549   GObjectClass *object_class;
 550   GtkContainerClass *container_class;
 551   GtkWidgetClass *widget_class;
 552   GtkBindingSet *binding_set;
 553
 554   container_class = (GtkContainerClass *)klass;
 555   container_class->forall = gtk_combo_box_forall;
 556   container_class->add = gtk_combo_box_add;
 557   container_class->remove = gtk_combo_box_remove;
 558
 559   widget_class = (GtkWidgetClass *)klass;
 560   widget_class->size_allocate = gtk_combo_box_size_allocate;
 561   widget_class->draw = gtk_combo_box_draw;
 562   widget_class->scroll_event = gtk_combo_box_scroll_event;
 563   widget_class->mnemonic_activate = gtk_combo_box_mnemonic_activate;
 564   widget_class->grab_focus = gtk_combo_box_grab_focus;
 565   widget_class->style_set = gtk_combo_box_style_set;
 566   widget_class->state_changed = gtk_combo_box_state_changed;
 567   widget_class->get_preferred_width = gtk_combo_box_get_preferred_width;
 568   widget_class->get_preferred_height = gtk_combo_box_get_preferred_height;
 569   widget_class->get_preferred_height_for_width = gtk_combo_box_get_preferred_height_for_width;
 570   widget_class->get_preferred_width_for_height = gtk_combo_box_get_preferred_width_for_height;
 571   widget_class->destroy = gtk_combo_box_destroy;
 572
 573   object_class = (GObjectClass *)klass;
 574   object_class->constructor = gtk_combo_box_constructor;
 575   object_class->dispose = gtk_combo_box_dispose;
 576   object_class->finalize = gtk_combo_box_finalize;
 577   object_class->set_property = gtk_combo_box_set_property;
 578   object_class->get_property = gtk_combo_box_get_property;
 579
 580   /* signals */
 581   /**
 582    * GtkComboBox::changed:
 583    * @widget: the object which received the signal
 584    *
 585    * The changed signal is emitted when the active
 586    * item is changed. The can be due to the user selecting
 587    * a different item from the list, or due to a
 588    * call to gtk_combo_box_set_active_iter().
 589    * It will also be emitted while typing into the entry of a combo box
 590    * with an entry.
 591    *
 592    * Since: 2.4
 593    */
 594   combo_box_signals[CHANGED] =
 595     g_signal_new (I_("changed"),
 596                   G_OBJECT_CLASS_TYPE (klass),
 597                   G_SIGNAL_RUN_LAST,
 598                   G_STRUCT_OFFSET (GtkComboBoxClass, changed),
 599                   NULL, NULL,
 600                   g_cclosure_marshal_VOID__VOID,
 601                   G_TYPE_NONE, 0);
 602   /**
 603    * GtkComboBox::move-active:
 604    * @widget: the object that received the signal
 605    * @scroll_type: a #GtkScrollType
 606    *
 607    * The ::move-active signal is a
 608    * <link linkend="keybinding-signals">keybinding signal</link>
 609    * which gets emitted to move the active selection.
 610    *
 611    * Since: 2.12
 612    */
 613   combo_box_signals[MOVE_ACTIVE] =
 614     g_signal_new_class_handler (I_("move-active"),
 615                                 G_OBJECT_CLASS_TYPE (klass),
 616                                 G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 617                                 G_CALLBACK (gtk_combo_box_real_move_active),
 618                                 NULL, NULL,
 619                                 g_cclosure_marshal_VOID__ENUM,
 620                                 G_TYPE_NONE, 1,
 621                                 GTK_TYPE_SCROLL_TYPE);
 622
 623   /**
 624    * GtkComboBox::popup:
 625    * @widget: the object that received the signal
 626    *
 627    * The ::popup signal is a
 628    * <link linkend="keybinding-signals">keybinding signal</link>
 629    * which gets emitted to popup the combo box list.
 630    *
 631    * The default binding for this signal is Alt+Down.
 632    *
 633    * Since: 2.12
 634    */
 635   combo_box_signals[POPUP] =
 636     g_signal_new_class_handler (I_("popup"),
 637                                 G_OBJECT_CLASS_TYPE (klass),
 638                                 G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 639                                 G_CALLBACK (gtk_combo_box_real_popup),
 640                                 NULL, NULL,
 641                                 g_cclosure_marshal_VOID__VOID,
 642                                 G_TYPE_NONE, 0);
 643   /**
 644    * GtkComboBox::popdown:
 645    * @button: the object which received the signal
 646    *
 647    * The ::popdown signal is a
 648    * <link linkend="keybinding-signals">keybinding signal</link>
 649    * which gets emitted to popdown the combo box list.
 650    *
 651    * The default bindings for this signal are Alt+Up and Escape.
 652    *
 653    * Since: 2.12
 654    */
 655   combo_box_signals[POPDOWN] =
 656     g_signal_new_class_handler (I_("popdown"),
 657                                 G_OBJECT_CLASS_TYPE (klass),
 658                                 G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 659                                 G_CALLBACK (gtk_combo_box_real_popdown),
 660                                 NULL, NULL,
 661                                 _gtk_marshal_BOOLEAN__VOID,
 662                                 G_TYPE_BOOLEAN, 0);
 663
 664   /* key bindings */
 665   binding_set = gtk_binding_set_by_class (widget_class);
 666
 667   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Down, GDK_MOD1_MASK,
 668                                 "popup", 0);
 669   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Down, GDK_MOD1_MASK,
 670                                 "popup", 0);
 671
 672   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Up, GDK_MOD1_MASK,
 673                                 "popdown", 0);
 674   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Up, GDK_MOD1_MASK,
 675                                 "popdown", 0);
 676   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Escape, 0,
 677                                 "popdown", 0);
 678
 679   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Up, 0,
 680                                 "move-active", 1,
 681                                 GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_UP);
 682   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Up, 0,
 683                                 "move-active", 1,
 684                                 GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_UP);
 685   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Page_Up, 0,
 686                                 "move-active", 1,
 687                                 GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_PAGE_UP);
 688   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Page_Up, 0,
 689                                 "move-active", 1,
 690                                 GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_PAGE_UP);
 691   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Home, 0,
 692                                 "move-active", 1,
 693                                 GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_START);
 694   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Home, 0,
 695                                 "move-active", 1,
 696                                 GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_START);
 697
 698   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Down, 0,
 699                                 "move-active", 1,
 700                                 GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_DOWN);
 701   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Down, 0,
 702                                 "move-active", 1,
 703                                 GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_DOWN);
 704   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Page_Down, 0,
 705                                 "move-active", 1,
 706                                 GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_PAGE_DOWN);
 707   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Page_Down, 0,
 708                                 "move-active", 1,
 709                                 GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_PAGE_DOWN);
 710   gtk_binding_entry_add_signal (binding_set, GDK_KEY_End, 0,
 711                                 "move-active", 1,
 712                                 GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_END);
 713   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_End, 0,
 714                                 "move-active", 1,
 715                                 GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_END);
 716
 717   /* properties */
 718   g_object_class_override_property (object_class,
 719                                     PROP_EDITING_CANCELED,
 720                                     "editing-canceled");
 721
 722   /**
 723    * GtkComboBox:model:
 724    *
 725    * The model from which the combo box takes the values shown
 726    * in the list.
 727    *
 728    * Since: 2.4
 729    */
 730   g_object_class_install_property (object_class,
 731                                    PROP_MODEL,
 732                                    g_param_spec_object ("model",
 733                                                         P_("ComboBox model"),
 734                                                         P_("The model for the combo box"),
 735                                                         GTK_TYPE_TREE_MODEL,
 736                                                         GTK_PARAM_READWRITE));
 737
 738   /**
 739    * GtkComboBox:wrap-width:
 740    *
 741    * If wrap-width is set to a positive value, the list will be
 742    * displayed in multiple columns, the number of columns is
 743    * determined by wrap-width.
 744    *
 745    * Since: 2.4
 746    */
 747   g_object_class_install_property (object_class,
 748                                    PROP_WRAP_WIDTH,
 749                                    g_param_spec_int ("wrap-width",
 750                                                      P_("Wrap width"),
 751                                                      P_("Wrap width for laying out the items in a grid"),
 752                                                      0,
 753                                                      G_MAXINT,
 754                                                      0,
 755                                                      GTK_PARAM_READWRITE));
 756
 757
 758   /**
 759    * GtkComboBox:row-span-column:
 760    *
 761    * If this is set to a non-negative value, it must be the index of a column
 762    * of type %G_TYPE_INT in the model.
 763    *
 764    * The values of that column are used to determine how many rows a value in
 765    * the list will span. Therefore, the values in the model column pointed to
 766    * by this property must be greater than zero and not larger than wrap-width.
 767    *
 768    * Since: 2.4
 769    */
 770   g_object_class_install_property (object_class,
 771                                    PROP_ROW_SPAN_COLUMN,
 772                                    g_param_spec_int ("row-span-column",
 773                                                      P_("Row span column"),
 774                                                      P_("TreeModel column containing the row span values"),
 775                                                      -1,
 776                                                      G_MAXINT,
 777                                                      -1,
 778                                                      GTK_PARAM_READWRITE));
 779
 780
 781   /**
 782    * GtkComboBox:column-span-column:
 783    *
 784    * If this is set to a non-negative value, it must be the index of a column
 785    * of type %G_TYPE_INT in the model.
 786    *
 787    * The values of that column are used to determine how many columns a value
 788    * in the list will span.
 789    *
 790    * Since: 2.4
 791    */
 792   g_object_class_install_property (object_class,
 793                                    PROP_COLUMN_SPAN_COLUMN,
 794                                    g_param_spec_int ("column-span-column",
 795                                                      P_("Column span column"),
 796                                                      P_("TreeModel column containing the column span values"),
 797                                                      -1,
 798                                                      G_MAXINT,
 799                                                      -1,
 800                                                      GTK_PARAM_READWRITE));
 801
 802
 803   /**
 804    * GtkComboBox:active:
 805    *
 806    * The item which is currently active. If the model is a non-flat treemodel,
 807    * and the active item is not an immediate child of the root of the tree,
 808    * this property has the value
 809    * <literal>gtk_tree_path_get_indices (path)[0]</literal>,
 810    * where <literal>path</literal> is the #GtkTreePath of the active item.
 811    *
 812    * Since: 2.4
 813    */
 814   g_object_class_install_property (object_class,
 815                                    PROP_ACTIVE,
 816                                    g_param_spec_int ("active",
 817                                                      P_("Active item"),
 818                                                      P_("The item which is currently active"),
 819                                                      -1,
 820                                                      G_MAXINT,
 821                                                      -1,
 822                                                      GTK_PARAM_READWRITE));
 823
 824   /**
 825    * GtkComboBox:add-tearoffs:
 826    *
 827    * The add-tearoffs property controls whether generated menus
 828    * have tearoff menu items.
 829    *
 830    * Note that this only affects menu style combo boxes.
 831    *
 832    * Since: 2.6
 833    */
 834   g_object_class_install_property (object_class,
 835                                    PROP_ADD_TEAROFFS,
 836                                    g_param_spec_boolean ("add-tearoffs",
 837                                                          P_("Add tearoffs to menus"),
 838                                                          P_("Whether dropdowns should have a tearoff menu item"),
 839                                                          FALSE,
 840                                                          GTK_PARAM_READWRITE));
 841
 842   /**
 843    * GtkComboBox:has-frame:
 844    *
 845    * The has-frame property controls whether a frame
 846    * is drawn around the entry.
 847    *
 848    * Since: 2.6
 849    */
 850   g_object_class_install_property (object_class,
 851                                    PROP_HAS_FRAME,
 852                                    g_param_spec_boolean ("has-frame",
 853                                                          P_("Has Frame"),
 854                                                          P_("Whether the combo box draws a frame around the child"),
 855                                                          TRUE,
 856                                                          GTK_PARAM_READWRITE));
 857
 858   g_object_class_install_property (object_class,
 859                                    PROP_FOCUS_ON_CLICK,
 860                                    g_param_spec_boolean ("focus-on-click",
 861                                                          P_("Focus on click"),
 862                                                          P_("Whether the combo box grabs focus when it is clicked with the mouse"),
 863                                                          TRUE,
 864                                                          GTK_PARAM_READWRITE));
 865
 866   /**
 867    * GtkComboBox:tearoff-title:
 868    *
 869    * A title that may be displayed by the window manager
 870    * when the popup is torn-off.
 871    *
 872    * Since: 2.10
 873    */
 874   g_object_class_install_property (object_class,
 875                                    PROP_TEAROFF_TITLE,
 876                                    g_param_spec_string ("tearoff-title",
 877                                                         P_("Tearoff Title"),
 878                                                         P_("A title that may be displayed by the window manager when the popup is torn-off"),
 879                                                         NULL,
 880                                                         GTK_PARAM_READWRITE));
 881
 882
 883   /**
 884    * GtkComboBox:popup-shown:
 885    *
 886    * Whether the combo boxes dropdown is popped up.
 887    * Note that this property is mainly useful, because
 888    * it allows you to connect to notify::popup-shown.
 889    *
 890    * Since: 2.10
 891    */
 892   g_object_class_install_property (object_class,
 893                                    PROP_POPUP_SHOWN,
 894                                    g_param_spec_boolean ("popup-shown",
 895                                                          P_("Popup shown"),
 896                                                          P_("Whether the combo's dropdown is shown"),
 897                                                          FALSE,
 898                                                          GTK_PARAM_READABLE));
 899
 900
 901    /**
 902     * GtkComboBox:button-sensitivity:
 903     *
 904     * Whether the dropdown button is sensitive when
 905     * the model is empty.
 906     *
 907     * Since: 2.14
 908     */
 909    g_object_class_install_property (object_class,
 910                                     PROP_BUTTON_SENSITIVITY,
 911                                     g_param_spec_enum ("button-sensitivity",
 912                                                        P_("Button Sensitivity"),
 913                                                        P_("Whether the dropdown button is sensitive when the model is empty"),
 914                                                        GTK_TYPE_SENSITIVITY_TYPE,
 915                                                        GTK_SENSITIVITY_AUTO,
 916                                                        GTK_PARAM_READWRITE));
 917
 918    /**
 919     * GtkComboBox:has-entry:
 920     *
 921     * Whether the combo box has an entry.
 922     *
 923     * Since: 2.24
 924     */
 925    g_object_class_install_property (object_class,
 926                                     PROP_HAS_ENTRY,
 927                                     g_param_spec_boolean ("has-entry",
 928                                                           P_("Has Entry"),
 929                                                           P_("Whether combo box has an entry"),
 930                                                           FALSE,
 931                                                           GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 932
 933    /**
 934     * GtkComboBox:entry-text-column:
 935     *
 936     * The column in the combo box's model to associate with strings from the entry
 937     * if the combo was created with #GtkComboBox:has-entry = %TRUE.
 938     *
 939     * Since: 2.24
 940     */
 941    g_object_class_install_property (object_class,
 942                                     PROP_ENTRY_TEXT_COLUMN,
 943                                     g_param_spec_int ("entry-text-column",
 944                                                       P_("Entry Text Column"),
 945                                                       P_("The column in the combo box's model to associate "
 946                                                          "with strings from the entry if the combo was "
 947                                                          "created with #GtkComboBox:has-entry = %TRUE"),
 948                                                       -1, G_MAXINT, -1,
 949                                                       GTK_PARAM_READWRITE));
 950
 951    /**
 952     * GtkComboBox:popup-fixed-width:
 953     *
 954     * Whether the popup's width should be a fixed width matching the
 955     * allocated width of the combo box.
 956     *
 957     * Since: 3.0
 958     */
 959    g_object_class_install_property (object_class,
 960                                     PROP_POPUP_FIXED_WIDTH,
 961                                     g_param_spec_boolean ("popup-fixed-width",
 962                                                           P_("Popup Fixed Width"),
 963                                                           P_("Whether the popup's width should be a "
 964                                                              "fixed width matching the allocated width "
 965                                                              "of the combo box"),
 966                                                           TRUE,
 967                                                           GTK_PARAM_READWRITE));
 968
 969   gtk_widget_class_install_style_property (widget_class,
 970                                            g_param_spec_boolean ("appears-as-list",
 971                                                                  P_("Appears as list"),
 972                                                                  P_("Whether dropdowns should look like lists rather than menus"),
 973                                                                  FALSE,
 974                                                                  GTK_PARAM_READABLE));
 975
 976   /**
 977    * GtkComboBox:arrow-size:
 978    *
 979    * Sets the minimum size of the arrow in the combo box.  Note
 980    * that the arrow size is coupled to the font size, so in case
 981    * a larger font is used, the arrow will be larger than set
 982    * by arrow size.
 983    *
 984    * Since: 2.12
 985    */
 986   gtk_widget_class_install_style_property (widget_class,
 987                                            g_param_spec_int ("arrow-size",
 988                                                              P_("Arrow Size"),
 989                                                              P_("The minimum size of the arrow in the combo box"),
 990                                                              0,
 991                                                              G_MAXINT,
 992                                                              15,
 993                                                              GTK_PARAM_READABLE));
 994
 995   /**
 996    * GtkComboBox:shadow-type:
 997    *
 998    * Which kind of shadow to draw around the combo box.
 999    *
1000    * Since: 2.12
1001    */
1002   gtk_widget_class_install_style_property (widget_class,
1003                                            g_param_spec_enum ("shadow-type",
1004                                                               P_("Shadow type"),
1005                                                               P_("Which kind of shadow to draw around the combo box"),
1006                                                               GTK_TYPE_SHADOW_TYPE,
1007                                                               GTK_SHADOW_NONE,
1008                                                               GTK_PARAM_READABLE));
1009
1010   g_type_class_add_private (object_class, sizeof (GtkComboBoxPrivate));
1011 }
1012
1013 static void
1014 gtk_combo_box_buildable_init (GtkBuildableIface *iface)
1015 {
1016   parent_buildable_iface = g_type_interface_peek_parent (iface);
1017   iface->add_child = _gtk_cell_layout_buildable_add_child;
1018   iface->custom_tag_start = gtk_combo_box_buildable_custom_tag_start;
1019   iface->custom_tag_end = gtk_combo_box_buildable_custom_tag_end;
1020   iface->get_internal_child = gtk_combo_box_buildable_get_internal_child;
1021 }
1022
1023 static void
1024 gtk_combo_box_cell_layout_init (GtkCellLayoutIface *iface)
1025 {
1026   iface->pack_start = gtk_combo_box_cell_layout_pack_start;
1027   iface->pack_end = gtk_combo_box_cell_layout_pack_end;
1028   iface->get_cells = gtk_combo_box_cell_layout_get_cells;
1029   iface->clear = gtk_combo_box_cell_layout_clear;
1030   iface->add_attribute = gtk_combo_box_cell_layout_add_attribute;
1031   iface->set_cell_data_func = gtk_combo_box_cell_layout_set_cell_data_func;
1032   iface->clear_attributes = gtk_combo_box_cell_layout_clear_attributes;
1033   iface->reorder = gtk_combo_box_cell_layout_reorder;
1034 }
1035
1036 static void
1037 gtk_combo_box_cell_editable_init (GtkCellEditableIface *iface)
1038 {
1039   iface->start_editing = gtk_combo_box_start_editing;
1040 }
1041
1042 static void
1043 gtk_combo_box_init (GtkComboBox *combo_box)
1044 {
1045   GtkComboBoxPrivate *priv;
1046
1047   combo_box->priv = G_TYPE_INSTANCE_GET_PRIVATE (combo_box,
1048                                                  GTK_TYPE_COMBO_BOX,
1049                                                  GtkComboBoxPrivate);
1050   priv = combo_box->priv;
1051
1052   priv->cell_view = gtk_cell_view_new ();
1053   gtk_widget_set_parent (priv->cell_view, GTK_WIDGET (combo_box));
1054   _gtk_bin_set_child (GTK_BIN (combo_box), priv->cell_view);
1055   gtk_widget_show (priv->cell_view);
1056
1057   priv->minimum_width = 0;
1058   priv->natural_width = 0;
1059
1060   priv->wrap_width = 0;
1061
1062   priv->active = -1;
1063   priv->active_row = NULL;
1064   priv->col_column = -1;
1065   priv->row_column = -1;
1066
1067   priv->popup_shown = FALSE;
1068   priv->add_tearoffs = FALSE;
1069   priv->has_frame = TRUE;
1070   priv->is_cell_renderer = FALSE;
1071   priv->editing_canceled = FALSE;
1072   priv->auto_scroll = FALSE;
1073   priv->focus_on_click = TRUE;
1074   priv->button_sensitivity = GTK_SENSITIVITY_AUTO;
1075   priv->has_entry = FALSE;
1076   priv->popup_fixed_width = TRUE;
1077
1078   priv->text_column = -1;
1079   priv->text_renderer = NULL;
1080
1081   gtk_combo_box_check_appearance (combo_box);
1082 }
1083
1084 static void
1085 gtk_combo_box_set_property (GObject      *object,
1086                             guint         prop_id,
1087                             const GValue *value,
1088                             GParamSpec   *pspec)
1089 {
1090   GtkComboBox *combo_box = GTK_COMBO_BOX (object);
1091
1092   switch (prop_id)
1093     {
1094     case PROP_MODEL:
1095       gtk_combo_box_set_model (combo_box, g_value_get_object (value));
1096       break;
1097
1098     case PROP_WRAP_WIDTH:
1099       gtk_combo_box_set_wrap_width (combo_box, g_value_get_int (value));
1100       break;
1101
1102     case PROP_ROW_SPAN_COLUMN:
1103       gtk_combo_box_set_row_span_column (combo_box, g_value_get_int (value));
1104       break;
1105
1106     case PROP_COLUMN_SPAN_COLUMN:
1107       gtk_combo_box_set_column_span_column (combo_box, g_value_get_int (value));
1108       break;
1109
1110     case PROP_ACTIVE:
1111       gtk_combo_box_set_active (combo_box, g_value_get_int (value));
1112       break;
1113
1114     case PROP_ADD_TEAROFFS:
1115       gtk_combo_box_set_add_tearoffs (combo_box, g_value_get_boolean (value));
1116       break;
1117
1118     case PROP_HAS_FRAME:
1119       combo_box->priv->has_frame = g_value_get_boolean (value);
1120
1121       if (combo_box->priv->has_entry)
1122         {
1123           GtkWidget *child;
1124
1125           child = gtk_bin_get_child (GTK_BIN (combo_box));
1126
1127           gtk_entry_set_has_frame (GTK_ENTRY (child),
1128                                    combo_box->priv->has_frame);
1129         }
1130
1131       break;
1132
1133     case PROP_FOCUS_ON_CLICK:
1134       gtk_combo_box_set_focus_on_click (combo_box,
1135                                         g_value_get_boolean (value));
1136       break;
1137
1138     case PROP_TEAROFF_TITLE:
1139       gtk_combo_box_set_title (combo_box, g_value_get_string (value));
1140       break;
1141
1142     case PROP_POPUP_SHOWN:
1143       if (g_value_get_boolean (value))
1144         gtk_combo_box_popup (combo_box);
1145       else
1146         gtk_combo_box_popdown (combo_box);
1147       break;
1148
1149     case PROP_BUTTON_SENSITIVITY:
1150       gtk_combo_box_set_button_sensitivity (combo_box,
1151                                             g_value_get_enum (value));
1152       break;
1153
1154     case PROP_POPUP_FIXED_WIDTH:
1155       gtk_combo_box_set_popup_fixed_width (combo_box,
1156                                            g_value_get_boolean (value));
1157       break;
1158
1159     case PROP_EDITING_CANCELED:
1160       combo_box->priv->editing_canceled = g_value_get_boolean (value);
1161       break;
1162
1163     case PROP_HAS_ENTRY:
1164       combo_box->priv->has_entry = g_value_get_boolean (value);
1165       break;
1166
1167     case PROP_ENTRY_TEXT_COLUMN:
1168       gtk_combo_box_set_entry_text_column (combo_box, g_value_get_int (value));
1169       break;
1170
1171     default:
1172       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1173       break;
1174     }
1175 }
1176
1177 static void
1178 gtk_combo_box_get_property (GObject    *object,
1179                             guint       prop_id,
1180                             GValue     *value,
1181                             GParamSpec *pspec)
1182 {
1183   GtkComboBox *combo_box = GTK_COMBO_BOX (object);
1184   GtkComboBoxPrivate *priv = combo_box->priv;
1185
1186   switch (prop_id)
1187     {
1188       case PROP_MODEL:
1189         g_value_set_object (value, combo_box->priv->model);
1190         break;
1191
1192       case PROP_WRAP_WIDTH:
1193         g_value_set_int (value, combo_box->priv->wrap_width);
1194         break;
1195
1196       case PROP_ROW_SPAN_COLUMN:
1197         g_value_set_int (value, combo_box->priv->row_column);
1198         break;
1199
1200       case PROP_COLUMN_SPAN_COLUMN:
1201         g_value_set_int (value, combo_box->priv->col_column);
1202         break;
1203
1204       case PROP_ACTIVE:
1205         g_value_set_int (value, gtk_combo_box_get_active (combo_box));
1206         break;
1207
1208       case PROP_ADD_TEAROFFS:
1209         g_value_set_boolean (value, gtk_combo_box_get_add_tearoffs (combo_box));
1210         break;
1211
1212       case PROP_HAS_FRAME:
1213         g_value_set_boolean (value, combo_box->priv->has_frame);
1214         break;
1215
1216       case PROP_FOCUS_ON_CLICK:
1217         g_value_set_boolean (value, combo_box->priv->focus_on_click);
1218         break;
1219
1220       case PROP_TEAROFF_TITLE:
1221         g_value_set_string (value, gtk_combo_box_get_title (combo_box));
1222         break;
1223
1224       case PROP_POPUP_SHOWN:
1225         g_value_set_boolean (value, combo_box->priv->popup_shown);
1226         break;
1227
1228       case PROP_BUTTON_SENSITIVITY:
1229         g_value_set_enum (value, combo_box->priv->button_sensitivity);
1230         break;
1231
1232       case PROP_POPUP_FIXED_WIDTH:
1233         g_value_set_boolean (value, combo_box->priv->popup_fixed_width);
1234         break;
1235
1236       case PROP_EDITING_CANCELED:
1237         g_value_set_boolean (value, priv->editing_canceled);
1238         break;
1239
1240       case PROP_HAS_ENTRY:
1241         g_value_set_boolean (value, priv->has_entry);
1242         break;
1243
1244       case PROP_ENTRY_TEXT_COLUMN:
1245         g_value_set_int (value, priv->text_column);
1246         break;
1247
1248       default:
1249         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1250         break;
1251     }
1252 }
1253
1254 static void
1255 gtk_combo_box_state_changed (GtkWidget    *widget,
1256                              GtkStateType  previous)
1257 {
1258   GtkComboBox *combo_box = GTK_COMBO_BOX (widget);
1259   GtkComboBoxPrivate *priv = combo_box->priv;
1260
1261   if (gtk_widget_get_realized (widget))
1262     {
1263       if (priv->tree_view && priv->cell_view)
1264         gtk_cell_view_set_background_color (GTK_CELL_VIEW (priv->cell_view),
1265                                             &gtk_widget_get_style (widget)->base[gtk_widget_get_state (widget)]);
1266     }
1267
1268   gtk_widget_queue_draw (widget);
1269 }
1270
1271 static void
1272 gtk_combo_box_button_state_changed (GtkWidget    *widget,
1273                                     GtkStateType  previous,
1274                                     gpointer      data)
1275 {
1276   GtkComboBox *combo_box = GTK_COMBO_BOX (data);
1277   GtkComboBoxPrivate *priv = combo_box->priv;
1278
1279   if (gtk_widget_get_realized (widget))
1280     {
1281       if (!priv->tree_view && priv->cell_view)
1282         {
1283           if ((gtk_widget_get_state (widget) == GTK_STATE_INSENSITIVE) !=
1284               (gtk_widget_get_state (priv->cell_view) == GTK_STATE_INSENSITIVE))
1285             gtk_widget_set_sensitive (priv->cell_view, gtk_widget_get_sensitive (widget));
1286
1287           gtk_widget_set_state (priv->cell_view,
1288                                 gtk_widget_get_state (widget));
1289         }
1290     }
1291
1292   gtk_widget_queue_draw (widget);
1293 }
1294
1295 static void
1296 gtk_combo_box_check_appearance (GtkComboBox *combo_box)
1297 {
1298   GtkComboBoxPrivate *priv = combo_box->priv;
1299   gboolean appears_as_list;
1300
1301   /* if wrap_width > 0, then we are in grid-mode and forced to use
1302    * unix style
1303    */
1304   if (priv->wrap_width)
1305     appears_as_list = FALSE;
1306   else
1307     gtk_widget_style_get (GTK_WIDGET (combo_box),
1308                           "appears-as-list", &appears_as_list,
1309                           NULL);
1310
1311   if (appears_as_list)
1312     {
1313       /* Destroy all the menu mode widgets, if they exist. */
1314       if (GTK_IS_MENU (priv->popup_widget))
1315         gtk_combo_box_menu_destroy (combo_box);
1316
1317       /* Create the list mode widgets, if they don't already exist. */
1318       if (!GTK_IS_TREE_VIEW (priv->tree_view))
1319         gtk_combo_box_list_setup (combo_box);
1320     }
1321   else
1322     {
1323       /* Destroy all the list mode widgets, if they exist. */
1324       if (GTK_IS_TREE_VIEW (priv->tree_view))
1325         gtk_combo_box_list_destroy (combo_box);
1326
1327       /* Create the menu mode widgets, if they don't already exist. */
1328       if (!GTK_IS_MENU (priv->popup_widget))
1329         gtk_combo_box_menu_setup (combo_box, TRUE);
1330     }
1331
1332   gtk_widget_style_get (GTK_WIDGET (combo_box),
1333                         "shadow-type", &priv->shadow_type,
1334                         NULL);
1335 }
1336
1337 static void
1338 gtk_combo_box_style_set (GtkWidget *widget,
1339                          GtkStyle  *previous)
1340 {
1341   GtkComboBox *combo_box = GTK_COMBO_BOX (widget);
1342   GtkComboBoxPrivate *priv = combo_box->priv;
1343   GtkWidget *child;
1344
1345   gtk_combo_box_check_appearance (combo_box);
1346
1347   if (priv->tree_view && priv->cell_view)
1348     gtk_cell_view_set_background_color (GTK_CELL_VIEW (priv->cell_view),
1349                                         &gtk_widget_get_style (widget)->base[gtk_widget_get_state (widget)]);
1350
1351   child = gtk_bin_get_child (GTK_BIN (combo_box));
1352   if (GTK_IS_ENTRY (child))
1353     g_object_set (child, "shadow-type",
1354                   GTK_SHADOW_NONE == priv->shadow_type ?
1355                   GTK_SHADOW_IN : GTK_SHADOW_NONE, NULL);
1356 }
1357
1358 static void
1359 gtk_combo_box_button_toggled (GtkWidget *widget,
1360                               gpointer   data)
1361 {
1362   GtkComboBox *combo_box = GTK_COMBO_BOX (data);
1363
1364   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
1365     {
1366       if (!combo_box->priv->popup_in_progress)
1367         gtk_combo_box_popup (combo_box);
1368     }
1369   else
1370     gtk_combo_box_popdown (combo_box);
1371 }
1372
1373 static void
1374 gtk_combo_box_add (GtkContainer *container,
1375                    GtkWidget    *widget)
1376 {
1377   GtkComboBox *combo_box = GTK_COMBO_BOX (container);
1378   GtkComboBoxPrivate *priv = combo_box->priv;
1379
1380   if (priv->has_entry && !GTK_IS_ENTRY (widget))
1381     {
1382       g_warning ("Attempting to add a widget with type %s to a GtkComboBox that needs an entry "
1383                  "(need an instance of GtkEntry or of a subclass)",
1384                  G_OBJECT_TYPE_NAME (widget));
1385       return;
1386     }
1387
1388   if (priv->cell_view &&
1389       gtk_widget_get_parent (priv->cell_view))
1390     {
1391       gtk_widget_unparent (priv->cell_view);
1392       _gtk_bin_set_child (GTK_BIN (container), NULL);
1393       gtk_widget_queue_resize (GTK_WIDGET (container));
1394     }
1395
1396   gtk_widget_set_parent (widget, GTK_WIDGET (container));
1397   _gtk_bin_set_child (GTK_BIN (container), widget);
1398
1399   if (priv->cell_view &&
1400       widget != priv->cell_view)
1401     {
1402       /* since the cell_view was unparented, it's gone now */
1403       priv->cell_view = NULL;
1404
1405       if (!priv->tree_view && priv->separator)
1406         {
1407           gtk_container_remove (GTK_CONTAINER (gtk_widget_get_parent (priv->separator)),
1408                                 priv->separator);
1409           priv->separator = NULL;
1410
1411           gtk_widget_queue_resize (GTK_WIDGET (container));
1412         }
1413       else if (priv->cell_view_frame)
1414         {
1415           gtk_widget_unparent (priv->cell_view_frame);
1416           priv->cell_view_frame = NULL;
1417           priv->box = NULL;
1418         }
1419     }
1420
1421   if (priv->has_entry)
1422     {
1423       /* this flag is a hack to tell the entry to fill its allocation.
1424        */
1425       GTK_ENTRY (widget)->is_cell_renderer = TRUE;
1426
1427       g_signal_connect (widget, "changed",
1428                         G_CALLBACK (gtk_combo_box_entry_contents_changed),
1429                         combo_box);
1430
1431       gtk_entry_set_has_frame (GTK_ENTRY (widget), priv->has_frame);
1432     }
1433 }
1434
1435 static void
1436 gtk_combo_box_remove (GtkContainer *container,
1437                       GtkWidget    *widget)
1438 {
1439   GtkComboBox *combo_box = GTK_COMBO_BOX (container);
1440   GtkComboBoxPrivate *priv = combo_box->priv;
1441   GtkTreePath *path;
1442   gboolean appears_as_list;
1443
1444   if (priv->has_entry)
1445     {
1446       GtkWidget *child_widget;
1447
1448       child_widget = gtk_bin_get_child (GTK_BIN (container));
1449       if (widget && widget == child_widget)
1450         {
1451           g_signal_handlers_disconnect_by_func (widget,
1452                                                 gtk_combo_box_entry_contents_changed,
1453                                                 container);
1454           GTK_ENTRY (widget)->is_cell_renderer = FALSE;
1455         }
1456     }
1457
1458   if (widget == priv->cell_view)
1459     priv->cell_view = NULL;
1460
1461   gtk_widget_unparent (widget);
1462   _gtk_bin_set_child (GTK_BIN (container), NULL);
1463
1464   if (gtk_widget_in_destruction (GTK_WIDGET (combo_box)))
1465     return;
1466
1467   gtk_widget_queue_resize (GTK_WIDGET (container));
1468
1469   if (!priv->tree_view)
1470     appears_as_list = FALSE;
1471   else
1472     appears_as_list = TRUE;
1473
1474   if (appears_as_list)
1475     gtk_combo_box_list_destroy (combo_box);
1476   else if (GTK_IS_MENU (priv->popup_widget))
1477     {
1478       gtk_combo_box_menu_destroy (combo_box);
1479       gtk_menu_detach (GTK_MENU (priv->popup_widget));
1480       priv->popup_widget = NULL;
1481     }
1482
1483   if (!priv->cell_view)
1484     {
1485       priv->cell_view = gtk_cell_view_new ();
1486       gtk_widget_set_parent (priv->cell_view, GTK_WIDGET (container));
1487       _gtk_bin_set_child (GTK_BIN (container), priv->cell_view);
1488
1489       gtk_widget_show (priv->cell_view);
1490       gtk_cell_view_set_model (GTK_CELL_VIEW (priv->cell_view),
1491                                priv->model);
1492       gtk_combo_box_sync_cells (combo_box, GTK_CELL_LAYOUT (priv->cell_view));
1493     }
1494
1495
1496   if (appears_as_list)
1497     gtk_combo_box_list_setup (combo_box);
1498   else
1499     gtk_combo_box_menu_setup (combo_box, TRUE);
1500
1501   if (gtk_tree_row_reference_valid (priv->active_row))
1502     {
1503       path = gtk_tree_row_reference_get_path (priv->active_row);
1504       gtk_combo_box_set_active_internal (combo_box, path);
1505       gtk_tree_path_free (path);
1506     }
1507   else
1508     gtk_combo_box_set_active_internal (combo_box, NULL);
1509 }
1510
1511 static ComboCellInfo *
1512 gtk_combo_box_get_cell_info (GtkComboBox     *combo_box,
1513                              GtkCellRenderer *cell)
1514 {
1515   GSList *i;
1516
1517   for (i = combo_box->priv->cells; i; i = i->next)
1518     {
1519       ComboCellInfo *info = (ComboCellInfo *)i->data;
1520
1521       if (info && info->cell == cell)
1522         return info;
1523     }
1524
1525   return NULL;
1526 }
1527
1528 static void
1529 gtk_combo_box_menu_show (GtkWidget *menu,
1530                          gpointer   user_data)
1531 {
1532   GtkComboBox *combo_box = GTK_COMBO_BOX (user_data);
1533   GtkComboBoxPrivate *priv = combo_box->priv;
1534
1535   gtk_combo_box_child_show (menu, user_data);
1536
1537   priv->popup_in_progress = TRUE;
1538   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->button),
1539                                 TRUE);
1540   priv->popup_in_progress = FALSE;
1541 }
1542
1543 static void
1544 gtk_combo_box_menu_hide (GtkWidget *menu,
1545                          gpointer   user_data)
1546 {
1547   GtkComboBox *combo_box = GTK_COMBO_BOX (user_data);
1548
1549   gtk_combo_box_child_hide (menu,user_data);
1550
1551   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (combo_box->priv->button),
1552                                 FALSE);
1553 }
1554
1555 static void
1556 gtk_combo_box_detacher (GtkWidget *widget,
1557                         GtkMenu   *menu)
1558 {
1559   GtkComboBox *combo_box = GTK_COMBO_BOX (widget);
1560   GtkComboBoxPrivate *priv = combo_box->priv;
1561
1562   g_return_if_fail (priv->popup_widget == (GtkWidget *) menu);
1563
1564   g_signal_handlers_disconnect_by_func (menu->toplevel,
1565                                         gtk_combo_box_menu_show,
1566                                         combo_box);
1567   g_signal_handlers_disconnect_by_func (menu->toplevel,
1568                                         gtk_combo_box_menu_hide,
1569                                         combo_box);
1570
1571   priv->popup_widget = NULL;
1572 }
1573
1574 static void
1575 gtk_combo_box_set_popup_widget (GtkComboBox *combo_box,
1576                                 GtkWidget   *popup)
1577 {
1578   GtkComboBoxPrivate *priv = combo_box->priv;
1579
1580   if (GTK_IS_MENU (priv->popup_widget))
1581     {
1582       gtk_menu_detach (GTK_MENU (priv->popup_widget));
1583       priv->popup_widget = NULL;
1584     }
1585   else if (priv->popup_widget)
1586     {
1587       gtk_container_remove (GTK_CONTAINER (priv->scrolled_window),
1588                             priv->popup_widget);
1589       g_object_unref (priv->popup_widget);
1590       priv->popup_widget = NULL;
1591     }
1592
1593   if (GTK_IS_MENU (popup))
1594     {
1595       if (priv->popup_window)
1596         {
1597           gtk_widget_destroy (priv->popup_window);
1598           priv->popup_window = NULL;
1599         }
1600
1601       priv->popup_widget = popup;
1602
1603       /*
1604        * Note that we connect to show/hide on the toplevel, not the
1605        * menu itself, since the menu is not shown/hidden when it is
1606        * popped up while torn-off.
1607        */
1608       g_signal_connect (GTK_MENU (popup)->toplevel, "show",
1609                         G_CALLBACK (gtk_combo_box_menu_show), combo_box);
1610       g_signal_connect (GTK_MENU (popup)->toplevel, "hide",
1611                         G_CALLBACK (gtk_combo_box_menu_hide), combo_box);
1612
1613       gtk_menu_attach_to_widget (GTK_MENU (popup),
1614                                  GTK_WIDGET (combo_box),
1615                                  gtk_combo_box_detacher);
1616     }
1617   else
1618     {
1619       if (!priv->popup_window)
1620         {
1621           GtkWidget *toplevel;
1622
1623           priv->popup_window = gtk_window_new (GTK_WINDOW_POPUP);
1624           gtk_widget_set_name (priv->popup_window, "gtk-combobox-popup-window");
1625
1626           gtk_window_set_type_hint (GTK_WINDOW (priv->popup_window),
1627                                     GDK_WINDOW_TYPE_HINT_COMBO);
1628
1629           g_signal_connect (GTK_WINDOW (priv->popup_window),"show",
1630                             G_CALLBACK (gtk_combo_box_child_show),
1631                             combo_box);
1632           g_signal_connect (GTK_WINDOW (priv->popup_window),"hide",
1633                             G_CALLBACK (gtk_combo_box_child_hide),
1634                             combo_box);
1635
1636           toplevel = gtk_widget_get_toplevel (GTK_WIDGET (combo_box));
1637           if (GTK_IS_WINDOW (toplevel))
1638             {
1639               gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
1640                                            GTK_WINDOW (priv->popup_window));
1641               gtk_window_set_transient_for (GTK_WINDOW (priv->popup_window),
1642                                             GTK_WINDOW (toplevel));
1643             }
1644
1645           gtk_window_set_resizable (GTK_WINDOW (priv->popup_window), FALSE);
1646           gtk_window_set_screen (GTK_WINDOW (priv->popup_window),
1647                                  gtk_widget_get_screen (GTK_WIDGET (combo_box)));
1648
1649           priv->scrolled_window = gtk_scrolled_window_new (NULL, NULL);
1650
1651           gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->scrolled_window),
1652                                           GTK_POLICY_NEVER,
1653                                           GTK_POLICY_NEVER);
1654           gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (priv->scrolled_window),
1655                                                GTK_SHADOW_IN);
1656
1657           gtk_widget_show (priv->scrolled_window);
1658
1659           gtk_container_add (GTK_CONTAINER (priv->popup_window),
1660                              priv->scrolled_window);
1661         }
1662
1663       gtk_container_add (GTK_CONTAINER (priv->scrolled_window),
1664                          popup);
1665
1666       gtk_widget_show (popup);
1667       g_object_ref (popup);
1668       priv->popup_widget = popup;
1669     }
1670 }
1671
1672 static void
1673 gtk_combo_box_menu_position_below (GtkMenu  *menu,
1674                                    gint     *x,
1675                                    gint     *y,
1676                                    gint     *push_in,
1677                                    gpointer  user_data)
1678 {
1679   GtkComboBox *combo_box = GTK_COMBO_BOX (user_data);
1680   GtkAllocation child_allocation;
1681   gint sx, sy;
1682   GtkWidget *child;
1683   GtkRequisition req;
1684   GdkScreen *screen;
1685   gint monitor_num;
1686   GdkRectangle monitor;
1687
1688   /* FIXME: is using the size request here broken? */
1689   child = gtk_bin_get_child (GTK_BIN (combo_box));
1690
1691   sx = sy = 0;
1692
1693   gtk_widget_get_allocation (child, &child_allocation);
1694
1695   if (!gtk_widget_get_has_window (child))
1696     {
1697       sx += child_allocation.x;
1698       sy += child_allocation.y;
1699     }
1700
1701   gdk_window_get_root_coords (gtk_widget_get_window (child),
1702                               sx, sy, &sx, &sy);
1703
1704   if (GTK_SHADOW_NONE != combo_box->priv->shadow_type)
1705     sx -= gtk_widget_get_style (GTK_WIDGET (combo_box))->xthickness;
1706
1707   if (combo_box->priv->popup_fixed_width)
1708     gtk_widget_get_preferred_size (GTK_WIDGET (menu), &req, NULL);
1709   else
1710     gtk_widget_get_preferred_size (GTK_WIDGET (menu), NULL, &req);
1711
1712   if (gtk_widget_get_direction (GTK_WIDGET (combo_box)) == GTK_TEXT_DIR_LTR)
1713     *x = sx;
1714   else
1715     *x = sx + child_allocation.width - req.width;
1716   *y = sy;
1717
1718   screen = gtk_widget_get_screen (GTK_WIDGET (combo_box));
1719   monitor_num = gdk_screen_get_monitor_at_window (screen,
1720                                                   gtk_widget_get_window (GTK_WIDGET (combo_box)));
1721   gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
1722
1723   if (*x < monitor.x)
1724     *x = monitor.x;
1725   else if (*x + req.width > monitor.x + monitor.width)
1726     *x = monitor.x + monitor.width - req.width;
1727
1728   if (monitor.y + monitor.height - *y - child_allocation.height >= req.height)
1729     *y += child_allocation.height;
1730   else if (*y - monitor.y >= req.height)
1731     *y -= req.height;
1732   else if (monitor.y + monitor.height - *y - child_allocation.height > *y - monitor.y)
1733     *y += child_allocation.height;
1734   else
1735     *y -= req.height;
1736
1737    *push_in = FALSE;
1738 }
1739
1740 static void
1741 gtk_combo_box_menu_position_over (GtkMenu  *menu,
1742                                   gint     *x,
1743                                   gint     *y,
1744                                   gboolean *push_in,
1745                                   gpointer  user_data)
1746 {
1747   GtkComboBox    *combo_box;
1748   GtkWidget      *active;
1749   GtkWidget      *child;
1750   GtkWidget      *widget;
1751   GtkAllocation   allocation;
1752   GtkAllocation   child_allocation;
1753   GList          *children;
1754   gint            screen_width;
1755   gint            menu_xpos;
1756   gint            menu_ypos;
1757   gint            menu_width;
1758
1759   combo_box = GTK_COMBO_BOX (user_data);
1760   widget = GTK_WIDGET (combo_box);
1761
1762   active = gtk_menu_get_active (GTK_MENU (combo_box->priv->popup_widget));
1763
1764   gtk_widget_get_allocation (widget, &allocation);
1765
1766   menu_xpos = allocation.x;
1767   menu_ypos = allocation.y + allocation.height / 2 - 2;
1768
1769   if (combo_box->priv->popup_fixed_width)
1770     gtk_widget_get_preferred_width (GTK_WIDGET (menu), &menu_width, NULL);
1771   else
1772     gtk_widget_get_preferred_width (GTK_WIDGET (menu), NULL, &menu_width);
1773
1774   if (active != NULL)
1775     {
1776       gtk_widget_get_allocation (active, &child_allocation);
1777       menu_ypos -= child_allocation.height / 2;
1778     }
1779
1780   children = GTK_MENU_SHELL (combo_box->priv->popup_widget)->children;
1781   while (children)
1782     {
1783       child = children->data;
1784
1785       if (active == child)
1786         break;
1787
1788       if (gtk_widget_get_visible (child))
1789         {
1790           gtk_widget_get_allocation (child, &child_allocation);
1791
1792           menu_ypos -= child_allocation.height;
1793         }
1794
1795       children = children->next;
1796     }
1797
1798   if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
1799     menu_xpos = menu_xpos + allocation.width - menu_width;
1800
1801   gdk_window_get_root_coords (gtk_widget_get_window (widget),
1802                               menu_xpos, menu_ypos,
1803                               &menu_xpos, &menu_ypos);
1804
1805   /* Clamp the position on screen */
1806   screen_width = gdk_screen_get_width (gtk_widget_get_screen (widget));
1807
1808   if (menu_xpos < 0)
1809     menu_xpos = 0;
1810   else if ((menu_xpos + menu_width) > screen_width)
1811     menu_xpos -= ((menu_xpos + menu_width) - screen_width);
1812
1813   *x = menu_xpos;
1814   *y = menu_ypos;
1815
1816   *push_in = TRUE;
1817 }
1818
1819 static void
1820 gtk_combo_box_menu_position (GtkMenu  *menu,
1821                              gint     *x,
1822                              gint     *y,
1823                              gint     *push_in,
1824                              gpointer  user_data)
1825 {
1826   GtkComboBox *combo_box = GTK_COMBO_BOX (user_data);
1827   GtkComboBoxPrivate *priv = combo_box->priv;
1828   GtkWidget *menu_item;
1829
1830   if (priv->wrap_width > 0 || priv->cell_view == NULL)
1831     gtk_combo_box_menu_position_below (menu, x, y, push_in, user_data);
1832   else
1833     {
1834       /* FIXME handle nested menus better */
1835       menu_item = gtk_menu_get_active (GTK_MENU (priv->popup_widget));
1836       if (menu_item)
1837         gtk_menu_shell_select_item (GTK_MENU_SHELL (priv->popup_widget),
1838                                     menu_item);
1839
1840       gtk_combo_box_menu_position_over (menu, x, y, push_in, user_data);
1841     }
1842
1843   if (!gtk_widget_get_visible (GTK_MENU (priv->popup_widget)->toplevel))
1844     gtk_window_set_type_hint (GTK_WINDOW (GTK_MENU (priv->popup_widget)->toplevel),
1845                               GDK_WINDOW_TYPE_HINT_COMBO);
1846 }
1847
1848 static void
1849 gtk_combo_box_list_position (GtkComboBox *combo_box,
1850                              gint        *x,
1851                              gint        *y,
1852                              gint        *width,
1853                              gint        *height)
1854 {
1855   GtkComboBoxPrivate *priv = combo_box->priv;
1856   GtkAllocation allocation;
1857   GdkScreen *screen;
1858   gint monitor_num;
1859   GdkRectangle monitor;
1860   GtkRequisition popup_req;
1861   GtkPolicyType hpolicy, vpolicy;
1862   GdkWindow *window;
1863
1864   /* under windows, the drop down list is as wide as the combo box itself.
1865      see bug #340204 */
1866   GtkWidget *widget = GTK_WIDGET (combo_box);
1867
1868   *x = *y = 0;
1869
1870   gtk_widget_get_allocation (widget, &allocation);
1871
1872   if (!gtk_widget_get_has_window (widget))
1873     {
1874       *x += allocation.x;
1875       *y += allocation.y;
1876     }
1877
1878   window = gtk_widget_get_window (widget);
1879
1880   gdk_window_get_root_coords (gtk_widget_get_window (widget),
1881                               *x, *y, x, y);
1882
1883   *width = allocation.width;
1884
1885   hpolicy = vpolicy = GTK_POLICY_NEVER;
1886   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->scrolled_window),
1887                                   hpolicy, vpolicy);
1888
1889   /* XXX This set_size_request call is part of the hack outlined below and can
1890    * go away once height-for-width is implemented on treeviews. */
1891   gtk_widget_set_size_request (priv->tree_view, -1, -1);
1892
1893   if (combo_box->priv->popup_fixed_width)
1894     {
1895       gtk_widget_get_preferred_size (priv->scrolled_window, &popup_req, NULL);
1896
1897       if (popup_req.width > *width)
1898         {
1899           hpolicy = GTK_POLICY_ALWAYS;
1900           gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->scrolled_window),
1901                                           hpolicy, vpolicy);
1902         }
1903     }
1904   else
1905     {
1906       gtk_combo_box_remeasure (combo_box);
1907
1908       if (priv->natural_width > *width)
1909         {
1910           hpolicy = GTK_POLICY_NEVER;
1911           gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->scrolled_window),
1912                                           hpolicy, vpolicy);
1913
1914
1915           /* XXX Currently we set the size-request on the internal treeview to be
1916            * the natural width of the cells, this hack can go away once our
1917            * treeview does height-for-width properly (i.e. just adjust *width
1918            * here to be the natural width request of the scrolled-window).
1919            *
1920            * I can't tell why the magic number 5 is needed here (i.e. without it
1921            * treeviews are left ellipsizing) , however it this all should be
1922            * removed with height-for-width treeviews.
1923            */
1924           gtk_widget_set_size_request (priv->tree_view, priv->natural_width + 5, -1);
1925           gtk_widget_get_preferred_size (priv->scrolled_window, NULL, &popup_req);
1926
1927           *width = popup_req.width;
1928         }
1929     }
1930
1931   *height = popup_req.height;
1932
1933   screen = gtk_widget_get_screen (GTK_WIDGET (combo_box));
1934   monitor_num = gdk_screen_get_monitor_at_window (screen, window);
1935   gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
1936
1937   if (gtk_widget_get_direction (GTK_WIDGET (combo_box)) == GTK_TEXT_DIR_RTL)
1938     *x = *x + allocation.width - *width;
1939
1940   if (*x < monitor.x)
1941     *x = monitor.x;
1942   else if (*x + *width > monitor.x + monitor.width)
1943     *x = monitor.x + monitor.width - *width;
1944
1945   if (*y + allocation.height + *height <= monitor.y + monitor.height)
1946     *y += allocation.height;
1947   else if (*y - *height >= monitor.y)
1948     *y -= *height;
1949   else if (monitor.y + monitor.height - (*y + allocation.height) > *y - monitor.y)
1950     {
1951       *y += allocation.height;
1952       *height = monitor.y + monitor.height - *y;
1953     }
1954   else
1955     {
1956       *height = *y - monitor.y;
1957       *y = monitor.y;
1958     }
1959
1960   if (popup_req.height > *height)
1961     {
1962       vpolicy = GTK_POLICY_ALWAYS;
1963
1964       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->scrolled_window),
1965                                       hpolicy, vpolicy);
1966     }
1967 }
1968
1969 static gboolean
1970 cell_view_is_sensitive (GtkCellView *cell_view)
1971 {
1972   GList *cells, *list;
1973   gboolean sensitive;
1974
1975   cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (cell_view));
1976
1977   sensitive = FALSE;
1978   for (list = cells; list; list = list->next)
1979     {
1980       g_object_get (list->data, "sensitive", &sensitive, NULL);
1981
1982       if (sensitive)
1983         break;
1984     }
1985   g_list_free (cells);
1986
1987   return sensitive;
1988 }
1989
1990 static gboolean
1991 tree_column_row_is_sensitive (GtkComboBox *combo_box,
1992                               GtkTreeIter *iter)
1993 {
1994   GtkComboBoxPrivate *priv = combo_box->priv;
1995   GList *cells, *list;
1996   gboolean sensitive;
1997
1998   if (!priv->column)
1999     return TRUE;
2000
2001   if (priv->row_separator_func)
2002     {
2003       if (priv->row_separator_func (priv->model, iter,
2004                                     priv->row_separator_data))
2005         return FALSE;
2006     }
2007
2008   gtk_tree_view_column_cell_set_cell_data (priv->column,
2009                                            priv->model,
2010                                            iter, FALSE, FALSE);
2011
2012   cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (priv->column));
2013
2014   sensitive = FALSE;
2015   for (list = cells; list; list = list->next)
2016     {
2017       g_object_get (list->data, "sensitive", &sensitive, NULL);
2018
2019       if (sensitive)
2020         break;
2021     }
2022   g_list_free (cells);
2023
2024   return sensitive;
2025 }
2026
2027 static void
2028 update_menu_sensitivity (GtkComboBox *combo_box,
2029                          GtkWidget   *menu)
2030 {
2031   GtkComboBoxPrivate *priv = combo_box->priv;
2032   GList *children, *child;
2033   GtkWidget *item, *submenu, *separator;
2034   GtkWidget *cell_view;
2035   gboolean sensitive;
2036
2037   if (!priv->model)
2038     return;
2039
2040   children = gtk_container_get_children (GTK_CONTAINER (menu));
2041
2042   for (child = children; child; child = child->next)
2043     {
2044       item = GTK_WIDGET (child->data);
2045       cell_view = gtk_bin_get_child (GTK_BIN (item));
2046
2047       if (!GTK_IS_CELL_VIEW (cell_view))
2048         continue;
2049
2050       submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (item));
2051       if (submenu != NULL)
2052         {
2053           gtk_widget_set_sensitive (item, TRUE);
2054           update_menu_sensitivity (combo_box, submenu);
2055         }
2056       else
2057         {
2058           sensitive = cell_view_is_sensitive (GTK_CELL_VIEW (cell_view));
2059
2060           if (menu != priv->popup_widget && child == children)
2061             {
2062               separator = GTK_WIDGET (child->next->data);
2063               g_object_set (item, "visible", sensitive, NULL);
2064               g_object_set (separator, "visible", sensitive, NULL);
2065             }
2066           else
2067             gtk_widget_set_sensitive (item, sensitive);
2068         }
2069     }
2070
2071   g_list_free (children);
2072 }
2073
2074 static void
2075 gtk_combo_box_menu_popup (GtkComboBox *combo_box,
2076                           guint        button,
2077                           guint32      activate_time)
2078 {
2079   GtkComboBoxPrivate *priv = combo_box->priv;
2080   GtkTreePath *path;
2081   gint active_item;
2082   gint width, min_width, nat_width;
2083
2084   update_menu_sensitivity (combo_box, priv->popup_widget);
2085
2086   active_item = -1;
2087   if (gtk_tree_row_reference_valid (priv->active_row))
2088     {
2089       path = gtk_tree_row_reference_get_path (priv->active_row);
2090       active_item = gtk_tree_path_get_indices (path)[0];
2091       gtk_tree_path_free (path);
2092
2093       if (priv->add_tearoffs)
2094         active_item++;
2095     }
2096
2097   /* FIXME handle nested menus better */
2098   gtk_menu_set_active (GTK_MENU (priv->popup_widget), active_item);
2099
2100   if (priv->wrap_width == 0)
2101     {
2102       GtkAllocation allocation;
2103
2104       gtk_widget_get_allocation (GTK_WIDGET (combo_box), &allocation);
2105       width = allocation.width;
2106       gtk_widget_set_size_request (priv->popup_widget, -1, -1);
2107       gtk_widget_get_preferred_width (priv->popup_widget, &min_width, &nat_width);
2108
2109       if (combo_box->priv->popup_fixed_width)
2110         width = MAX (width, min_width);
2111       else
2112         width = MAX (width, nat_width);
2113
2114       gtk_widget_set_size_request (priv->popup_widget, width, -1);
2115     }
2116
2117   gtk_menu_popup (GTK_MENU (priv->popup_widget),
2118                   NULL, NULL,
2119                   gtk_combo_box_menu_position, combo_box,
2120                   button, activate_time);
2121 }
2122
2123 static gboolean
2124 popup_grab_on_window (GdkWindow *window,
2125                       GdkDevice *keyboard,
2126                       GdkDevice *pointer,
2127                       guint32    activate_time)
2128 {
2129   if (keyboard &&
2130       gdk_device_grab (keyboard, window,
2131                        GDK_OWNERSHIP_WINDOW, TRUE,
2132                        GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK,
2133                        NULL, activate_time) != GDK_GRAB_SUCCESS)
2134     return FALSE;
2135
2136   if (pointer &&
2137       gdk_device_grab (pointer, window,
2138                        GDK_OWNERSHIP_WINDOW, TRUE,
2139                        GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
2140                        GDK_POINTER_MOTION_MASK,
2141                        NULL, activate_time) != GDK_GRAB_SUCCESS)
2142     {
2143       if (keyboard)
2144         gdk_device_ungrab (keyboard, activate_time);
2145
2146       return FALSE;
2147     }
2148
2149   return TRUE;
2150 }
2151
2152 /**
2153  * gtk_combo_box_popup:
2154  * @combo_box: a #GtkComboBox
2155  *
2156  * Pops up the menu or dropdown list of @combo_box.
2157  *
2158  * This function is mostly intended for use by accessibility technologies;
2159  * applications should have little use for it.
2160  *
2161  * Since: 2.4
2162  */
2163 void
2164 gtk_combo_box_popup (GtkComboBox *combo_box)
2165 {
2166   g_return_if_fail (GTK_IS_COMBO_BOX (combo_box));
2167
2168   g_signal_emit (combo_box, combo_box_signals[POPUP], 0);
2169 }
2170
2171 /**
2172  * gtk_combo_box_popup_for_device:
2173  * @combo_box: a #GtkComboBox
2174  * @device: a #GdkDevice
2175  *
2176  * Pops up the menu or dropdown list of @combo_box, the popup window
2177  * will be grabbed so only @device and its associated pointer/keyboard
2178  * are the only #GdkDevice<!-- -->s able to send events to it.
2179  *
2180  * Since: 3.0
2181  **/
2182 void
2183 gtk_combo_box_popup_for_device (GtkComboBox *combo_box,
2184                                 GdkDevice   *device)
2185 {
2186   GtkComboBoxPrivate *priv = combo_box->priv;
2187   gint x, y, width, height;
2188   GtkTreePath *path = NULL, *ppath;
2189   GtkWidget *toplevel;
2190   GdkDevice *keyboard, *pointer;
2191   guint32 time;
2192
2193   g_return_if_fail (GTK_IS_COMBO_BOX (combo_box));
2194   g_return_if_fail (GDK_IS_DEVICE (device));
2195
2196   if (!gtk_widget_get_realized (GTK_WIDGET (combo_box)))
2197     return;
2198
2199   if (gtk_widget_get_mapped (priv->popup_widget))
2200     return;
2201
2202   if (priv->grab_pointer && priv->grab_keyboard)
2203     return;
2204
2205   time = gtk_get_current_event_time ();
2206
2207   if (device->source == GDK_SOURCE_KEYBOARD)
2208     {
2209       keyboard = device;
2210       pointer = gdk_device_get_associated_device (device);
2211     }
2212   else
2213     {
2214       pointer = device;
2215       keyboard = gdk_device_get_associated_device (device);
2216     }
2217
2218   if (GTK_IS_MENU (priv->popup_widget))
2219     {
2220       gtk_combo_box_menu_popup (combo_box,
2221                                 priv->activate_button,
2222                                 priv->activate_time);
2223       return;
2224     }
2225
2226   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (combo_box));
2227   if (GTK_IS_WINDOW (toplevel))
2228     gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
2229                                  GTK_WINDOW (priv->popup_window));
2230
2231   gtk_widget_show_all (priv->scrolled_window);
2232   gtk_combo_box_list_position (combo_box, &x, &y, &width, &height);
2233
2234   gtk_widget_set_size_request (priv->popup_window, width, height);
2235   gtk_window_move (GTK_WINDOW (priv->popup_window), x, y);
2236
2237   if (gtk_tree_row_reference_valid (priv->active_row))
2238     {
2239       path = gtk_tree_row_reference_get_path (priv->active_row);
2240       ppath = gtk_tree_path_copy (path);
2241       if (gtk_tree_path_up (ppath))
2242         gtk_tree_view_expand_to_path (GTK_TREE_VIEW (priv->tree_view),
2243                                       ppath);
2244       gtk_tree_path_free (ppath);
2245     }
2246   gtk_tree_view_set_hover_expand (GTK_TREE_VIEW (priv->tree_view),
2247                                   TRUE);
2248
2249   /* popup */
2250   gtk_widget_show (priv->popup_window);
2251
2252   if (path)
2253     {
2254       gtk_tree_view_set_cursor (GTK_TREE_VIEW (priv->tree_view),
2255                                 path, NULL, FALSE);
2256       gtk_tree_path_free (path);
2257     }
2258
2259   gtk_widget_grab_focus (priv->popup_window);
2260   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->button),
2261                                 TRUE);
2262
2263   if (!gtk_widget_has_focus (priv->tree_view))
2264     gtk_widget_grab_focus (priv->tree_view);
2265
2266   if (!popup_grab_on_window (gtk_widget_get_window (priv->popup_window),
2267                              keyboard, pointer, time))
2268     {
2269       gtk_widget_hide (priv->popup_window);
2270       return;
2271     }
2272
2273   gtk_device_grab_add (priv->popup_window, pointer, TRUE);
2274   priv->grab_pointer = pointer;
2275   priv->grab_keyboard = keyboard;
2276 }
2277
2278 static void
2279 gtk_combo_box_real_popup (GtkComboBox *combo_box)
2280 {
2281   GdkDevice *device;
2282
2283   device = gtk_get_current_event_device ();
2284
2285   if (!device)
2286     {
2287       GdkDeviceManager *device_manager;
2288       GdkDisplay *display;
2289       GList *devices;
2290
2291       display = gtk_widget_get_display (GTK_WIDGET (combo_box));
2292       device_manager = gdk_display_get_device_manager (display);
2293
2294       /* No device was set, pick the first master device */
2295       devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
2296       device = devices->data;
2297       g_list_free (devices);
2298     }
2299
2300   gtk_combo_box_popup_for_device (combo_box, device);
2301 }
2302
2303 static gboolean
2304 gtk_combo_box_real_popdown (GtkComboBox *combo_box)
2305 {
2306   if (combo_box->priv->popup_shown)
2307     {
2308       gtk_combo_box_popdown (combo_box);
2309       return TRUE;
2310     }
2311
2312   return FALSE;
2313 }
2314
2315 /**
2316  * gtk_combo_box_popdown:
2317  * @combo_box: a #GtkComboBox
2318  *
2319  * Hides the menu or dropdown list of @combo_box.
2320  *
2321  * This function is mostly intended for use by accessibility technologies;
2322  * applications should have little use for it.
2323  *
2324  * Since: 2.4
2325  */
2326 void
2327 gtk_combo_box_popdown (GtkComboBox *combo_box)
2328 {
2329   GtkComboBoxPrivate *priv = combo_box->priv;
2330
2331   g_return_if_fail (GTK_IS_COMBO_BOX (combo_box));
2332
2333   if (GTK_IS_MENU (priv->popup_widget))
2334     {
2335       gtk_menu_popdown (GTK_MENU (priv->popup_widget));
2336       return;
2337     }
2338
2339   if (!gtk_widget_get_realized (GTK_WIDGET (combo_box)))
2340     return;
2341
2342   gtk_device_grab_remove (priv->popup_window, priv->grab_pointer);
2343   gtk_widget_hide (priv->popup_window);
2344   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->button),
2345                                 FALSE);
2346
2347   priv->grab_pointer = NULL;
2348   priv->grab_keyboard = NULL;
2349 }
2350
2351 static void
2352 gtk_combo_box_update_requested_width (GtkComboBox *combo_box,
2353                                       GtkTreePath *path)
2354 {
2355   GtkComboBoxPrivate *priv = combo_box->priv;
2356   gint                padding, min_width, nat_width;
2357
2358   if (priv->cell_view)
2359     gtk_widget_style_get (priv->cell_view,
2360                           "focus-line-width", &padding,
2361                           NULL);
2362   else
2363     padding = 0;
2364
2365   /* add some pixels for good measure */
2366   padding += BONUS_PADDING;
2367
2368   if (priv->cell_view)
2369     gtk_cell_view_get_desired_width_of_row (GTK_CELL_VIEW (priv->cell_view),
2370                                             path, &min_width, &nat_width);
2371   else
2372     min_width = nat_width = 0;
2373
2374   min_width += padding;
2375   nat_width += padding;
2376
2377   if (min_width > priv->minimum_width || nat_width > priv->natural_width)
2378     {
2379       priv->minimum_width = MAX (priv->minimum_width, min_width);
2380       priv->natural_width = MAX (priv->natural_width, nat_width);
2381
2382       if (priv->cell_view)
2383         {
2384           gtk_widget_set_size_request (priv->cell_view, min_width, -1);
2385           gtk_widget_queue_resize (priv->cell_view);
2386         }
2387     }
2388 }
2389
2390 #define GTK_COMBO_BOX_SIZE_ALLOCATE_BUTTON                                      \
2391   gtk_widget_get_preferred_size (combo_box->priv->button,                       \
2392                                  &req, NULL);                                   \
2393                                                                                 \
2394   if (is_rtl)                                                                   \
2395     child.x = allocation->x + shadow_width;                                     \
2396   else                                                                          \
2397     child.x = allocation->x + allocation->width - req.width - shadow_width;     \
2398                                                                                 \
2399   child.y = allocation->y + shadow_height;                                      \
2400   child.width = req.width;                                                      \
2401   child.height = allocation->height - 2 * shadow_height;                        \
2402   child.width = MAX (1, child.width);                                           \
2403   child.height = MAX (1, child.height);                                         \
2404                                                                                 \
2405   gtk_widget_size_allocate (combo_box->priv->button, &child);
2406
2407 static void
2408 gtk_combo_box_size_allocate (GtkWidget     *widget,
2409                              GtkAllocation *allocation)
2410 {
2411   GtkComboBox *combo_box = GTK_COMBO_BOX (widget);
2412   GtkComboBoxPrivate *priv = combo_box->priv;
2413   GtkWidget *child_widget;
2414   gint shadow_width, shadow_height;
2415   gint focus_width, focus_pad;
2416   GtkAllocation child;
2417   GtkRequisition req;
2418   GtkStyle *style;
2419   gboolean is_rtl = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL;
2420
2421   gtk_widget_set_allocation (widget, allocation);
2422   child_widget = gtk_bin_get_child (GTK_BIN (widget));
2423
2424   style = gtk_widget_get_style (widget);
2425   gtk_widget_style_get (widget,
2426                         "focus-line-width", &focus_width,
2427                         "focus-padding", &focus_pad,
2428                         NULL);
2429
2430   if (GTK_SHADOW_NONE != priv->shadow_type)
2431     {
2432       shadow_width = style->xthickness;
2433       shadow_height = style->ythickness;
2434     }
2435   else
2436     {
2437       shadow_width = 0;
2438       shadow_height = 0;
2439     }
2440
2441   if (!priv->tree_view)
2442     {
2443       if (priv->cell_view)
2444         {
2445           gint xthickness, ythickness;
2446           gint width;
2447           guint border_width;
2448
2449           /* menu mode */
2450           allocation->x += shadow_width;
2451           allocation->y += shadow_height;
2452           allocation->width -= 2 * shadow_width;
2453           allocation->height -= 2 * shadow_height;
2454
2455           gtk_widget_size_allocate (priv->button, allocation);
2456
2457           /* set some things ready */
2458           border_width = gtk_container_get_border_width (GTK_CONTAINER (priv->button));
2459           style = gtk_widget_get_style (priv->button);
2460           xthickness = style->xthickness;
2461           ythickness = style->ythickness;
2462
2463           child.x = allocation->x;
2464           child.y = allocation->y;
2465           width = allocation->width;
2466           child.height = allocation->height;
2467
2468           if (!priv->is_cell_renderer)
2469             {
2470               child.x += border_width + xthickness + focus_width + focus_pad;
2471               child.y += border_width + ythickness + focus_width + focus_pad;
2472               width -= 2 * (child.x - allocation->x);
2473               child.height -= 2 * (child.y - allocation->y);
2474             }
2475
2476
2477           /* handle the children */
2478           gtk_widget_get_preferred_size (priv->arrow, &req, NULL);
2479           child.width = req.width;
2480           if (!is_rtl)
2481             child.x += width - req.width;
2482           child.width = MAX (1, child.width);
2483           child.height = MAX (1, child.height);
2484           gtk_widget_size_allocate (priv->arrow, &child);
2485           if (is_rtl)
2486             child.x += req.width;
2487           gtk_widget_get_preferred_size (priv->separator, &req, NULL);
2488           child.width = req.width;
2489           if (!is_rtl)
2490             child.x -= req.width;
2491           child.width = MAX (1, child.width);
2492           child.height = MAX (1, child.height);
2493           gtk_widget_size_allocate (priv->separator, &child);
2494
2495           if (is_rtl)
2496             {
2497               child.x += req.width;
2498               child.width = allocation->x + allocation->width
2499                 - (border_width + xthickness + focus_width + focus_pad)
2500                 - child.x;
2501             }
2502           else
2503             {
2504               child.width = child.x;
2505               child.x = allocation->x
2506                 + border_width + xthickness + focus_width + focus_pad;
2507               child.width -= child.x;
2508             }
2509
2510           if (gtk_widget_get_visible (priv->popup_widget))
2511             {
2512               gint width, menu_width;
2513
2514               if (priv->wrap_width == 0)
2515                 {
2516                   GtkAllocation combo_box_allocation;
2517
2518                   gtk_widget_get_allocation (GTK_WIDGET (combo_box), &combo_box_allocation);
2519                   width = combo_box_allocation.width;
2520                   gtk_widget_set_size_request (priv->popup_widget, -1, -1);
2521
2522                   if (combo_box->priv->popup_fixed_width)
2523                     gtk_widget_get_preferred_width (priv->popup_widget, &menu_width, NULL);
2524                   else
2525                     gtk_widget_get_preferred_width (priv->popup_widget, NULL, &menu_width);
2526
2527                   gtk_widget_set_size_request (priv->popup_widget,
2528                                                MAX (width, menu_width), -1);
2529                }
2530
2531               /* reposition the menu after giving it a new width */
2532               gtk_menu_reposition (GTK_MENU (priv->popup_widget));
2533             }
2534
2535           child.width = MAX (1, child.width);
2536           child.height = MAX (1, child.height);
2537           gtk_widget_size_allocate (child_widget, &child);
2538         }
2539       else
2540         {
2541           GTK_COMBO_BOX_SIZE_ALLOCATE_BUTTON
2542
2543           if (is_rtl)
2544             child.x = allocation->x + req.width + shadow_width;
2545           else
2546             child.x = allocation->x + shadow_width;
2547           child.y = allocation->y + shadow_height;
2548           child.width = allocation->width - req.width - 2 * shadow_width;
2549           child.width = MAX (1, child.width);
2550           child.height = MAX (1, child.height);
2551           gtk_widget_size_allocate (child_widget, &child);
2552         }
2553     }
2554   else
2555     {
2556       /* list mode */
2557
2558       /* Combobox thickness + border-width */
2559       guint border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
2560       int delta_x = shadow_width + border_width;
2561       int delta_y = shadow_height + border_width;
2562
2563       /* button */
2564       GTK_COMBO_BOX_SIZE_ALLOCATE_BUTTON
2565
2566       /* frame */
2567       if (is_rtl)
2568         child.x = allocation->x + req.width;
2569       else
2570         child.x = allocation->x;
2571
2572       child.y = allocation->y;
2573       child.width = allocation->width - req.width;
2574       child.height = allocation->height;
2575
2576       if (priv->cell_view_frame)
2577         {
2578           child.x += delta_x;
2579           child.y += delta_y;
2580           child.width = MAX (1, child.width - delta_x * 2);
2581           child.height = MAX (1, child.height - delta_y * 2);
2582           gtk_widget_size_allocate (priv->cell_view_frame, &child);
2583
2584           /* the sample */
2585           if (priv->has_frame)
2586             {
2587               border_width = gtk_container_get_border_width (GTK_CONTAINER (priv->cell_view_frame));
2588               style = gtk_widget_get_style (priv->cell_view_frame);
2589               delta_x = border_width + style->xthickness;
2590               delta_y = border_width + style->ythickness;
2591
2592               child.x += delta_x;
2593               child.y += delta_y;
2594               child.width -= delta_x * 2;
2595               child.height -= delta_y * 2;
2596             }
2597         }
2598       else
2599         {
2600           child.x += delta_x;
2601           child.y += delta_y;
2602           child.width -= delta_x * 2;
2603           child.height -= delta_y * 2;
2604         }
2605
2606       if (gtk_widget_get_visible (priv->popup_window))
2607         {
2608           gint x, y, width, height;
2609           gtk_combo_box_list_position (combo_box, &x, &y, &width, &height);
2610           gtk_window_move (GTK_WINDOW (priv->popup_window), x, y);
2611           gtk_widget_set_size_request (priv->popup_window, width, height);
2612         }
2613
2614
2615       child.width = MAX (1, child.width);
2616       child.height = MAX (1, child.height);
2617
2618       gtk_widget_size_allocate (child_widget, &child);
2619     }
2620 }
2621
2622 #undef GTK_COMBO_BOX_ALLOCATE_BUTTON
2623
2624 static void
2625 gtk_combo_box_unset_model (GtkComboBox *combo_box)
2626 {
2627   GtkComboBoxPrivate *priv = combo_box->priv;
2628
2629   if (priv->model)
2630     {
2631       g_signal_handler_disconnect (priv->model,
2632                                    priv->inserted_id);
2633       g_signal_handler_disconnect (priv->model,
2634                                    priv->deleted_id);
2635       g_signal_handler_disconnect (priv->model,
2636                                    priv->reordered_id);
2637       g_signal_handler_disconnect (priv->model,
2638                                    priv->changed_id);
2639     }
2640
2641   /* menu mode */
2642   if (!priv->tree_view)
2643     {
2644       if (priv->popup_widget)
2645         gtk_container_foreach (GTK_CONTAINER (priv->popup_widget),
2646                                (GtkCallback)gtk_widget_destroy, NULL);
2647     }
2648
2649   if (priv->model)
2650     {
2651       g_object_unref (priv->model);
2652       priv->model = NULL;
2653     }
2654
2655   if (priv->active_row)
2656     {
2657       gtk_tree_row_reference_free (priv->active_row);
2658       priv->active_row = NULL;
2659     }
2660
2661   if (priv->cell_view)
2662     gtk_cell_view_set_model (GTK_CELL_VIEW (priv->cell_view), NULL);
2663 }
2664
2665 static void
2666 gtk_combo_box_forall (GtkContainer *container,
2667                       gboolean      include_internals,
2668                       GtkCallback   callback,
2669                       gpointer      callback_data)
2670 {
2671   GtkComboBox *combo_box = GTK_COMBO_BOX (container);
2672   GtkComboBoxPrivate *priv = combo_box->priv;
2673   GtkWidget *child;
2674
2675   if (include_internals)
2676     {
2677       if (priv->button)
2678         (* callback) (priv->button, callback_data);
2679       if (priv->cell_view_frame)
2680         (* callback) (priv->cell_view_frame, callback_data);
2681     }
2682
2683   child = gtk_bin_get_child (GTK_BIN (container));
2684   if (child)
2685     (* callback) (child, callback_data);
2686 }
2687
2688 static void
2689 gtk_combo_box_child_show (GtkWidget *widget,
2690                           GtkComboBox *combo_box)
2691 {
2692   GtkComboBoxPrivate *priv = combo_box->priv;
2693
2694   priv->popup_shown = TRUE;
2695   g_object_notify (G_OBJECT (combo_box), "popup-shown");
2696 }
2697
2698 static void
2699 gtk_combo_box_child_hide (GtkWidget *widget,
2700                           GtkComboBox *combo_box)
2701 {
2702   GtkComboBoxPrivate *priv = combo_box->priv;
2703
2704   priv->popup_shown = FALSE;
2705   g_object_notify (G_OBJECT (combo_box), "popup-shown");
2706 }
2707
2708 static gboolean
2709 gtk_combo_box_draw (GtkWidget *widget,
2710                     cairo_t   *cr)
2711 {
2712   GtkComboBox *combo_box = GTK_COMBO_BOX (widget);
2713   GtkComboBoxPrivate *priv = combo_box->priv;
2714
2715   if (priv->shadow_type != GTK_SHADOW_NONE)
2716     {
2717       gtk_paint_shadow (gtk_widget_get_style (widget),
2718                         cr,
2719                         GTK_STATE_NORMAL, priv->shadow_type,
2720                         widget, "combobox",
2721                         0, 0,
2722                         gtk_widget_get_allocated_width (widget),
2723                         gtk_widget_get_allocated_height (widget));
2724     }
2725
2726   gtk_container_propagate_draw (GTK_CONTAINER (widget),
2727                                 priv->button, cr);
2728
2729   if (priv->tree_view && priv->cell_view_frame)
2730     {
2731       gtk_container_propagate_draw (GTK_CONTAINER (widget),
2732                                     priv->cell_view_frame, cr);
2733     }
2734
2735   gtk_container_propagate_draw (GTK_CONTAINER (widget),
2736                                 gtk_bin_get_child (GTK_BIN (widget)),
2737                                 cr);
2738
2739   return FALSE;
2740 }
2741
2742 typedef struct {
2743   GtkComboBox *combo;
2744   GtkTreePath *path;
2745   GtkTreeIter iter;
2746   gboolean found;
2747   gboolean set;
2748   gboolean visible;
2749 } SearchData;
2750
2751 static gboolean
2752 path_visible (GtkTreeView *view,
2753               GtkTreePath *path)
2754 {
2755   GtkRBTree *tree;
2756   GtkRBNode *node;
2757
2758   /* Note that we rely on the fact that collapsed rows don't have nodes
2759    */
2760   return _gtk_tree_view_find_node (view, path, &tree, &node);
2761 }
2762
2763 static gboolean
2764 tree_next_func (GtkTreeModel *model,
2765                 GtkTreePath  *path,
2766                 GtkTreeIter  *iter,
2767                 gpointer      data)
2768 {
2769   SearchData *search_data = (SearchData *)data;
2770
2771   if (search_data->found)
2772     {
2773       if (!tree_column_row_is_sensitive (search_data->combo, iter))
2774         return FALSE;
2775
2776       if (search_data->visible &&
2777           !path_visible (GTK_TREE_VIEW (search_data->combo->priv->tree_view), path))
2778         return FALSE;
2779
2780       search_data->set = TRUE;
2781       search_data->iter = *iter;
2782
2783       return TRUE;
2784     }
2785
2786   if (gtk_tree_path_compare (path, search_data->path) == 0)
2787     search_data->found = TRUE;
2788
2789   return FALSE;
2790 }
2791
2792 static gboolean
2793 tree_next (GtkComboBox  *combo,
2794            GtkTreeModel *model,
2795            GtkTreeIter  *iter,
2796            GtkTreeIter  *next,
2797            gboolean      visible)
2798 {
2799   SearchData search_data;
2800
2801   search_data.combo = combo;
2802   search_data.path = gtk_tree_model_get_path (model, iter);
2803   search_data.visible = visible;
2804   search_data.found = FALSE;
2805   search_data.set = FALSE;
2806
2807   gtk_tree_model_foreach (model, tree_next_func, &search_data);
2808
2809   *next = search_data.iter;
2810
2811   gtk_tree_path_free (search_data.path);
2812
2813   return search_data.set;
2814 }
2815
2816 static gboolean
2817 tree_prev_func (GtkTreeModel *model,
2818                 GtkTreePath  *path,
2819                 GtkTreeIter  *iter,
2820                 gpointer      data)
2821 {
2822   SearchData *search_data = (SearchData *)data;
2823
2824   if (gtk_tree_path_compare (path, search_data->path) == 0)
2825     {
2826       search_data->found = TRUE;
2827       return TRUE;
2828     }
2829
2830   if (!tree_column_row_is_sensitive (search_data->combo, iter))
2831     return FALSE;
2832
2833   if (search_data->visible &&
2834       !path_visible (GTK_TREE_VIEW (search_data->combo->priv->tree_view), path))
2835     return FALSE;
2836
2837   search_data->set = TRUE;
2838   search_data->iter = *iter;
2839
2840   return FALSE;
2841 }
2842
2843 static gboolean
2844 tree_prev (GtkComboBox  *combo,
2845            GtkTreeModel *model,
2846            GtkTreeIter  *iter,
2847            GtkTreeIter  *prev,
2848            gboolean      visible)
2849 {
2850   SearchData search_data;
2851
2852   search_data.combo = combo;
2853   search_data.path = gtk_tree_model_get_path (model, iter);
2854   search_data.visible = visible;
2855   search_data.found = FALSE;
2856   search_data.set = FALSE;
2857
2858   gtk_tree_model_foreach (model, tree_prev_func, &search_data);
2859
2860   *prev = search_data.iter;
2861
2862   gtk_tree_path_free (search_data.path);
2863
2864   return search_data.set;
2865 }
2866
2867 static gboolean
2868 tree_last_func (GtkTreeModel *model,
2869                 GtkTreePath  *path,
2870                 GtkTreeIter  *iter,
2871                 gpointer      data)
2872 {
2873   SearchData *search_data = (SearchData *)data;
2874
2875   if (!tree_column_row_is_sensitive (search_data->combo, iter))
2876     return FALSE;
2877
2878   /* Note that we rely on the fact that collapsed rows don't have nodes
2879    */
2880   if (search_data->visible &&
2881       !path_visible (GTK_TREE_VIEW (search_data->combo->priv->tree_view), path))
2882     return FALSE;
2883
2884   search_data->set = TRUE;
2885   search_data->iter = *iter;
2886
2887   return FALSE;
2888 }
2889
2890 static gboolean
2891 tree_last (GtkComboBox  *combo,
2892            GtkTreeModel *model,
2893            GtkTreeIter  *last,
2894            gboolean      visible)
2895 {
2896   SearchData search_data;
2897
2898   search_data.combo = combo;
2899   search_data.visible = visible;
2900   search_data.set = FALSE;
2901
2902   gtk_tree_model_foreach (model, tree_last_func, &search_data);
2903
2904   *last = search_data.iter;
2905
2906   return search_data.set;
2907 }
2908
2909
2910 static gboolean
2911 tree_first_func (GtkTreeModel *model,
2912                  GtkTreePath  *path,
2913                  GtkTreeIter  *iter,
2914                  gpointer      data)
2915 {
2916   SearchData *search_data = (SearchData *)data;
2917
2918   if (!tree_column_row_is_sensitive (search_data->combo, iter))
2919     return FALSE;
2920
2921   if (search_data->visible &&
2922       !path_visible (GTK_TREE_VIEW (search_data->combo->priv->tree_view), path))
2923     return FALSE;
2924
2925   search_data->set = TRUE;
2926   search_data->iter = *iter;
2927
2928   return TRUE;
2929 }
2930
2931 static gboolean
2932 tree_first (GtkComboBox  *combo,
2933             GtkTreeModel *model,
2934             GtkTreeIter  *first,
2935             gboolean      visible)
2936 {
2937   SearchData search_data;
2938
2939   search_data.combo = combo;
2940   search_data.visible = visible;
2941   search_data.set = FALSE;
2942
2943   gtk_tree_model_foreach (model, tree_first_func, &search_data);
2944
2945   *first = search_data.iter;
2946
2947   return search_data.set;
2948 }
2949
2950 static gboolean
2951 gtk_combo_box_scroll_event (GtkWidget          *widget,
2952                             GdkEventScroll     *event)
2953 {
2954   GtkComboBox *combo_box = GTK_COMBO_BOX (widget);
2955   gboolean found;
2956   GtkTreeIter iter;
2957   GtkTreeIter new_iter;
2958
2959   if (!gtk_combo_box_get_active_iter (combo_box, &iter))
2960     return TRUE;
2961
2962   if (event->direction == GDK_SCROLL_UP)
2963     found = tree_prev (combo_box, combo_box->priv->model,
2964                        &iter, &new_iter, FALSE);
2965   else
2966     found = tree_next (combo_box, combo_box->priv->model,
2967                        &iter, &new_iter, FALSE);
2968
2969   if (found)
2970     gtk_combo_box_set_active_iter (combo_box, &new_iter);
2971
2972   return TRUE;
2973 }
2974
2975 /*
2976  * menu style
2977  */
2978
2979 static void
2980 gtk_combo_box_sync_cells (GtkComboBox   *combo_box,
2981                           GtkCellLayout *cell_layout)
2982 {
2983   GtkComboBoxPrivate *priv = combo_box->priv;
2984   GSList *k;
2985
2986   for (k = priv->cells; k; k = k->next)
2987     {
2988       GSList *j;
2989       ComboCellInfo *info = (ComboCellInfo *)k->data;
2990
2991       if (info->pack == GTK_PACK_START)
2992         gtk_cell_layout_pack_start (cell_layout,
2993                                     info->cell, info->expand);
2994       else if (info->pack == GTK_PACK_END)
2995         gtk_cell_layout_pack_end (cell_layout,
2996                                   info->cell, info->expand);
2997
2998       gtk_cell_layout_set_cell_data_func (cell_layout,
2999                                           info->cell,
3000                                           combo_cell_data_func, info, NULL);
3001
3002       for (j = info->attributes; j; j = j->next->next)
3003         {
3004           gtk_cell_layout_add_attribute (cell_layout,
3005                                          info->cell,
3006                                          j->data,
3007                                          GPOINTER_TO_INT (j->next->data));
3008         }
3009     }
3010 }
3011
3012 static void
3013 gtk_combo_box_menu_setup (GtkComboBox *combo_box,
3014                           gboolean     add_children)
3015 {
3016   GtkComboBoxPrivate *priv = combo_box->priv;
3017   GtkWidget *child;
3018   GtkWidget *menu;
3019
3020   child = gtk_bin_get_child (GTK_BIN (combo_box));
3021
3022   if (priv->cell_view)
3023     {
3024       priv->button = gtk_toggle_button_new ();
3025       gtk_button_set_focus_on_click (GTK_BUTTON (priv->button),
3026                                      priv->focus_on_click);
3027
3028       g_signal_connect (priv->button, "toggled",
3029                         G_CALLBACK (gtk_combo_box_button_toggled), combo_box);
3030       gtk_widget_set_parent (priv->button,
3031                              gtk_widget_get_parent (child));
3032
3033       priv->box = gtk_hbox_new (FALSE, 0);
3034       gtk_container_add (GTK_CONTAINER (priv->button), priv->box);
3035
3036       priv->separator = gtk_vseparator_new ();
3037       gtk_container_add (GTK_CONTAINER (priv->box), priv->separator);
3038
3039       priv->arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_NONE);
3040       gtk_container_add (GTK_CONTAINER (priv->box), priv->arrow);
3041
3042       gtk_widget_show_all (priv->button);
3043     }
3044   else
3045     {
3046       priv->button = gtk_toggle_button_new ();
3047       gtk_button_set_focus_on_click (GTK_BUTTON (priv->button),
3048                                      priv->focus_on_click);
3049
3050       g_signal_connect (priv->button, "toggled",
3051                         G_CALLBACK (gtk_combo_box_button_toggled), combo_box);
3052       gtk_widget_set_parent (priv->button,
3053                              gtk_widget_get_parent (child));
3054
3055       priv->arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_NONE);
3056       gtk_container_add (GTK_CONTAINER (priv->button), priv->arrow);
3057       gtk_widget_show_all (priv->button);
3058     }
3059
3060   g_signal_connect (priv->button, "button-press-event",
3061                     G_CALLBACK (gtk_combo_box_menu_button_press),
3062                     combo_box);
3063   g_signal_connect (priv->button, "state-changed",
3064                     G_CALLBACK (gtk_combo_box_button_state_changed),
3065                     combo_box);
3066
3067   /* create our funky menu */
3068   menu = gtk_menu_new ();
3069   gtk_widget_set_name (menu, "gtk-combobox-popup-menu");
3070   gtk_menu_set_reserve_toggle_size (GTK_MENU (menu), FALSE);
3071
3072   g_signal_connect (menu, "key-press-event",
3073                     G_CALLBACK (gtk_combo_box_menu_key_press), combo_box);
3074   gtk_combo_box_set_popup_widget (combo_box, menu);
3075
3076   /* add items */
3077   if (add_children)
3078     gtk_combo_box_menu_fill (combo_box);
3079
3080   /* the column is needed in tree_column_row_is_sensitive() */
3081   priv->column = gtk_tree_view_column_new ();
3082   g_object_ref_sink (priv->column);
3083   gtk_combo_box_sync_cells (combo_box, GTK_CELL_LAYOUT (priv->column));
3084
3085   gtk_combo_box_update_title (combo_box);
3086   gtk_combo_box_update_sensitivity (combo_box);
3087 }
3088
3089 static void
3090 gtk_combo_box_menu_fill (GtkComboBox *combo_box)
3091 {
3092   GtkComboBoxPrivate *priv = combo_box->priv;
3093   GtkWidget *menu;
3094
3095   if (!priv->model)
3096     return;
3097
3098   menu = priv->popup_widget;
3099
3100   if (priv->add_tearoffs)
3101     {
3102       GtkWidget *tearoff = gtk_tearoff_menu_item_new ();
3103
3104       gtk_widget_show (tearoff);
3105
3106       if (priv->wrap_width)
3107         gtk_menu_attach (GTK_MENU (menu), tearoff, 0, priv->wrap_width, 0, 1);
3108       else
3109         gtk_menu_shell_append (GTK_MENU_SHELL (menu), tearoff);
3110     }
3111
3112   gtk_combo_box_menu_fill_level (combo_box, menu, NULL);
3113 }
3114
3115 static GtkWidget *
3116 gtk_cell_view_menu_item_new (GtkComboBox  *combo_box,
3117                              GtkTreeModel *model,
3118                              GtkTreeIter  *iter)
3119 {
3120   GtkWidget *cell_view;
3121   GtkWidget *item;
3122   GtkTreePath *path;
3123   GtkRequisition req;
3124
3125   cell_view = gtk_cell_view_new ();
3126   item = gtk_menu_item_new ();
3127   gtk_container_add (GTK_CONTAINER (item), cell_view);
3128
3129   gtk_cell_view_set_model (GTK_CELL_VIEW (cell_view), model);
3130   path = gtk_tree_model_get_path (model, iter);
3131   gtk_cell_view_set_displayed_row (GTK_CELL_VIEW (cell_view), path);
3132   gtk_tree_path_free (path);
3133
3134   gtk_combo_box_sync_cells (combo_box, GTK_CELL_LAYOUT (cell_view));
3135   gtk_widget_get_preferred_size (cell_view, &req, NULL);
3136   gtk_widget_show (cell_view);
3137
3138   return item;
3139 }
3140
3141 static void
3142 gtk_combo_box_menu_fill_level (GtkComboBox *combo_box,
3143                                GtkWidget   *menu,
3144                                GtkTreeIter *parent)
3145 {
3146   GtkComboBoxPrivate *priv = combo_box->priv;
3147   GtkTreeModel *model = priv->model;
3148   GtkWidget *item, *submenu, *subitem, *separator;
3149   GtkTreeIter iter;
3150   gboolean is_separator;
3151   gint i, n_children;
3152   GtkWidget *last;
3153   GtkTreePath *path;
3154
3155   n_children = gtk_tree_model_iter_n_children (model, parent);
3156
3157   last = NULL;
3158   for (i = 0; i < n_children; i++)
3159     {
3160       gtk_tree_model_iter_nth_child (model, &iter, parent, i);
3161
3162       if (priv->row_separator_func)
3163         is_separator = priv->row_separator_func (priv->model, &iter,
3164                                                  priv->row_separator_data);
3165       else
3166         is_separator = FALSE;
3167
3168       if (is_separator)
3169         {
3170           item = gtk_separator_menu_item_new ();
3171           path = gtk_tree_model_get_path (model, &iter);
3172           g_object_set_data_full (G_OBJECT (item),
3173                                   I_("gtk-combo-box-item-path"),
3174                                   gtk_tree_row_reference_new (model, path),
3175                                   (GDestroyNotify)gtk_tree_row_reference_free);
3176           gtk_tree_path_free (path);
3177         }
3178       else
3179         {
3180           item = gtk_cell_view_menu_item_new (combo_box, model, &iter);
3181           if (gtk_tree_model_iter_has_child (model, &iter))
3182             {
3183               submenu = gtk_menu_new ();
3184               gtk_menu_set_reserve_toggle_size (GTK_MENU (submenu), FALSE);
3185               gtk_widget_show (submenu);
3186               gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu);
3187
3188               /* Ugly - since menus can only activate leafs, we have to
3189                * duplicate the item inside the submenu.
3190                */
3191               subitem = gtk_cell_view_menu_item_new (combo_box, model, &iter);
3192               separator = gtk_separator_menu_item_new ();
3193               gtk_widget_show (subitem);
3194               gtk_widget_show (separator);
3195               g_signal_connect (subitem, "activate",
3196                                 G_CALLBACK (gtk_combo_box_menu_item_activate),
3197                                 combo_box);
3198               gtk_menu_shell_append (GTK_MENU_SHELL (submenu), subitem);
3199               gtk_menu_shell_append (GTK_MENU_SHELL (submenu), separator);
3200
3201               gtk_combo_box_menu_fill_level (combo_box, submenu, &iter);
3202             }
3203           g_signal_connect (item, "activate",
3204                             G_CALLBACK (gtk_combo_box_menu_item_activate),
3205                             combo_box);
3206         }
3207
3208       gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
3209       if (priv->wrap_width && menu == priv->popup_widget)
3210         gtk_combo_box_relayout_item (combo_box, item, &iter, last);
3211       gtk_widget_show (item);
3212
3213       last = item;
3214     }
3215 }
3216
3217 static void
3218 gtk_combo_box_menu_destroy (GtkComboBox *combo_box)
3219 {
3220   GtkComboBoxPrivate *priv = combo_box->priv;
3221
3222   g_signal_handlers_disconnect_matched (priv->button,
3223                                         G_SIGNAL_MATCH_DATA,
3224                                         0, 0, NULL,
3225                                         gtk_combo_box_menu_button_press, NULL);
3226   g_signal_handlers_disconnect_matched (priv->button,
3227                                         G_SIGNAL_MATCH_DATA,
3228                                         0, 0, NULL,
3229                                         gtk_combo_box_button_state_changed, combo_box);
3230
3231   /* unparent will remove our latest ref */
3232   gtk_widget_unparent (priv->button);
3233
3234   priv->box = NULL;
3235   priv->button = NULL;
3236   priv->arrow = NULL;
3237   priv->separator = NULL;
3238
3239   g_object_unref (priv->column);
3240   priv->column = NULL;
3241
3242   /* changing the popup window will unref the menu and the children */
3243 }
3244
3245 /*
3246  * grid
3247  */
3248
3249 static gboolean
3250 menu_occupied (GtkMenu   *menu,
3251                guint      left_attach,
3252                guint      right_attach,
3253                guint      top_attach,
3254                guint      bottom_attach)
3255 {
3256   GList *i;
3257
3258   for (i = GTK_MENU_SHELL (menu)->children; i; i = i->next)
3259     {
3260       guint l, r, b, t;
3261
3262       gtk_container_child_get (GTK_CONTAINER (menu),
3263                                i->data,
3264                                "left-attach", &l,
3265                                "right-attach", &r,
3266                                "bottom-attach", &b,
3267                                "top-attach", &t,
3268                                NULL);
3269
3270       /* look if this item intersects with the given coordinates */
3271       if (right_attach > l && left_attach < r && bottom_attach > t && top_attach < b)
3272         return TRUE;
3273     }
3274
3275   return FALSE;
3276 }
3277
3278 static void
3279 gtk_combo_box_relayout_item (GtkComboBox *combo_box,
3280                              GtkWidget   *item,
3281                              GtkTreeIter *iter,
3282                              GtkWidget   *last)
3283 {
3284   GtkComboBoxPrivate *priv = combo_box->priv;
3285   gint current_col = 0, current_row = 0;
3286   gint rows = 1, cols = 1;
3287   GtkWidget *menu = priv->popup_widget;
3288
3289   if (!GTK_IS_MENU_SHELL (menu))
3290     return;
3291
3292   if (priv->col_column == -1 &&
3293       priv->row_column == -1 &&
3294       last)
3295     {
3296       gtk_container_child_get (GTK_CONTAINER (menu),
3297                                last,
3298                                "right-attach", &current_col,
3299                                "top-attach", &current_row,
3300                                NULL);
3301       if (current_col + cols > priv->wrap_width)
3302         {
3303           current_col = 0;
3304           current_row++;
3305         }
3306     }
3307   else
3308     {
3309       if (priv->col_column != -1)
3310         gtk_tree_model_get (priv->model, iter,
3311                             priv->col_column, &cols,
3312                             -1);
3313       if (priv->row_column != -1)
3314         gtk_tree_model_get (priv->model, iter,
3315                             priv->row_column, &rows,
3316                             -1);
3317
3318       while (1)
3319         {
3320           if (current_col + cols > priv->wrap_width)
3321             {
3322               current_col = 0;
3323               current_row++;
3324             }
3325
3326           if (!menu_occupied (GTK_MENU (menu),
3327                               current_col, current_col + cols,
3328                               current_row, current_row + rows))
3329             break;
3330
3331           current_col++;
3332         }
3333     }
3334
3335   /* set attach props */
3336   gtk_menu_attach (GTK_MENU (menu), item,
3337                    current_col, current_col + cols,
3338                    current_row, current_row + rows);
3339 }
3340
3341 static void
3342 gtk_combo_box_relayout (GtkComboBox *combo_box)
3343 {
3344   GList *list, *j;
3345   GtkWidget *menu;
3346
3347   menu = combo_box->priv->popup_widget;
3348
3349   /* do nothing unless we are in menu style and realized */
3350   if (combo_box->priv->tree_view || !GTK_IS_MENU_SHELL (menu))
3351     return;
3352
3353   list = gtk_container_get_children (GTK_CONTAINER (menu));
3354
3355   for (j = g_list_last (list); j; j = j->prev)
3356     gtk_container_remove (GTK_CONTAINER (menu), j->data);
3357
3358   gtk_combo_box_menu_fill (combo_box);
3359
3360   g_list_free (list);
3361 }
3362
3363 /* callbacks */
3364 static gboolean
3365 gtk_combo_box_menu_button_press (GtkWidget      *widget,
3366                                  GdkEventButton *event,
3367                                  gpointer        user_data)
3368 {
3369   GtkComboBox *combo_box = GTK_COMBO_BOX (user_data);
3370   GtkComboBoxPrivate *priv = combo_box->priv;
3371
3372   if (GTK_IS_MENU (priv->popup_widget) &&
3373       event->type == GDK_BUTTON_PRESS && event->button == 1)
3374     {
3375       if (priv->focus_on_click &&
3376           !gtk_widget_has_focus (priv->button))
3377         gtk_widget_grab_focus (priv->button);
3378
3379       gtk_combo_box_menu_popup (combo_box, event->button, event->time);
3380
3381       return TRUE;
3382     }
3383
3384   return FALSE;
3385 }
3386
3387 static void
3388 gtk_combo_box_menu_item_activate (GtkWidget *item,
3389                                   gpointer   user_data)
3390 {
3391   GtkComboBox *combo_box = GTK_COMBO_BOX (user_data);
3392   GtkWidget *cell_view;
3393   GtkTreePath *path;
3394   GtkTreeIter iter;
3395
3396   cell_view = gtk_bin_get_child (GTK_BIN (item));
3397
3398   g_return_if_fail (GTK_IS_CELL_VIEW (cell_view));
3399
3400   path = gtk_cell_view_get_displayed_row (GTK_CELL_VIEW (cell_view));
3401
3402   if (gtk_tree_model_get_iter (combo_box->priv->model, &iter, path))
3403   {
3404     if (gtk_menu_item_get_submenu (GTK_MENU_ITEM (item)) == NULL)
3405       gtk_combo_box_set_active_iter (combo_box, &iter);
3406   }
3407
3408   gtk_tree_path_free (path);
3409
3410   g_object_set (combo_box,
3411                 "editing-canceled", FALSE,
3412                 NULL);
3413 }
3414
3415 static void
3416 gtk_combo_box_update_sensitivity (GtkComboBox *combo_box)
3417 {
3418   GtkTreeIter iter;
3419   gboolean sensitive = TRUE; /* fool code checkers */
3420
3421   if (!combo_box->priv->button)
3422     return;
3423
3424   switch (combo_box->priv->button_sensitivity)
3425     {
3426       case GTK_SENSITIVITY_ON:
3427         sensitive = TRUE;
3428         break;
3429       case GTK_SENSITIVITY_OFF:
3430         sensitive = FALSE;
3431         break;
3432       case GTK_SENSITIVITY_AUTO:
3433         sensitive = combo_box->priv->model &&
3434                     gtk_tree_model_get_iter_first (combo_box->priv->model, &iter);
3435         break;
3436       default:
3437         g_assert_not_reached ();
3438         break;
3439     }
3440
3441   gtk_widget_set_sensitive (combo_box->priv->button, sensitive);
3442
3443   /* In list-mode, we also need to update sensitivity of the event box */
3444   if (GTK_IS_TREE_VIEW (combo_box->priv->tree_view)
3445       && combo_box->priv->cell_view)
3446     gtk_widget_set_sensitive (combo_box->priv->box, sensitive);
3447 }
3448
3449 static void
3450 gtk_combo_box_model_row_inserted (GtkTreeModel     *model,
3451                                   GtkTreePath      *path,
3452                                   GtkTreeIter      *iter,
3453                                   gpointer          user_data)
3454 {
3455   GtkComboBox *combo_box = GTK_COMBO_BOX (user_data);
3456
3457   if (combo_box->priv->tree_view)
3458     gtk_combo_box_list_popup_resize (combo_box);
3459   else
3460     gtk_combo_box_menu_row_inserted (model, path, iter, user_data);
3461
3462   gtk_combo_box_update_sensitivity (combo_box);
3463 }
3464
3465 static void
3466 gtk_combo_box_model_row_deleted (GtkTreeModel     *model,
3467                                  GtkTreePath      *path,
3468                                  gpointer          user_data)
3469 {
3470   GtkComboBox *combo_box = GTK_COMBO_BOX (user_data);
3471   GtkComboBoxPrivate *priv = combo_box->priv;
3472
3473   if (!gtk_tree_row_reference_valid (priv->active_row))
3474     {
3475       if (priv->cell_view)
3476         gtk_cell_view_set_displayed_row (GTK_CELL_VIEW (priv->cell_view), NULL);
3477       g_signal_emit (combo_box, combo_box_signals[CHANGED], 0);
3478     }
3479
3480   if (priv->tree_view)
3481     gtk_combo_box_list_popup_resize (combo_box);
3482   else
3483     gtk_combo_box_menu_row_deleted (model, path, user_data);
3484
3485   gtk_combo_box_update_sensitivity (combo_box);
3486 }
3487
3488 static void
3489 gtk_combo_box_model_rows_reordered (GtkTreeModel    *model,
3490                                     GtkTreePath     *path,
3491                                     GtkTreeIter     *iter,
3492                                     gint            *new_order,
3493                                     gpointer         user_data)
3494 {
3495   GtkComboBox *combo_box = GTK_COMBO_BOX (user_data);
3496
3497   gtk_tree_row_reference_reordered (G_OBJECT (user_data), path, iter, new_order);
3498
3499   if (!combo_box->priv->tree_view)
3500     gtk_combo_box_menu_rows_reordered (model, path, iter, new_order, user_data);
3501 }
3502
3503 static void
3504 gtk_combo_box_model_row_changed (GtkTreeModel     *model,
3505                                  GtkTreePath      *path,
3506                                  GtkTreeIter      *iter,
3507                                  gpointer          user_data)
3508 {
3509   GtkComboBox *combo_box = GTK_COMBO_BOX (user_data);
3510   GtkComboBoxPrivate *priv = combo_box->priv;
3511   GtkTreePath *active_path;
3512
3513   /* FIXME this belongs to GtkCellView */
3514   if (gtk_tree_row_reference_valid (priv->active_row))
3515     {
3516       active_path = gtk_tree_row_reference_get_path (priv->active_row);
3517       if (gtk_tree_path_compare (path, active_path) == 0 &&
3518           priv->cell_view)
3519         gtk_widget_queue_resize (GTK_WIDGET (priv->cell_view));
3520       gtk_tree_path_free (active_path);
3521     }
3522
3523   if (priv->tree_view)
3524     gtk_combo_box_list_row_changed (model, path, iter, user_data);
3525   else
3526     gtk_combo_box_menu_row_changed (model, path, iter, user_data);
3527 }
3528
3529 static gboolean
3530 list_popup_resize_idle (gpointer user_data)
3531 {
3532   GtkComboBox *combo_box = GTK_COMBO_BOX (user_data);
3533   GtkComboBoxPrivate *priv = combo_box->priv;
3534   gint x, y, width, height;
3535
3536   if (priv->tree_view && gtk_widget_get_mapped (priv->popup_window))
3537     {
3538       gtk_combo_box_list_position (combo_box, &x, &y, &width, &height);
3539
3540       gtk_widget_set_size_request (priv->popup_window, width, height);
3541       gtk_window_move (GTK_WINDOW (priv->popup_window), x, y);
3542     }
3543
3544   priv->resize_idle_id = 0;
3545
3546   return FALSE;
3547 }
3548
3549 static void
3550 gtk_combo_box_list_popup_resize (GtkComboBox *combo_box)
3551 {
3552   GtkComboBoxPrivate *priv = combo_box->priv;
3553
3554   if (!priv->resize_idle_id)
3555     priv->resize_idle_id =
3556       gdk_threads_add_idle (list_popup_resize_idle, combo_box);
3557 }
3558
3559 static void
3560 gtk_combo_box_model_row_expanded (GtkTreeModel     *model,
3561                                   GtkTreePath      *path,
3562                                   GtkTreeIter      *iter,
3563                                   gpointer          user_data)
3564 {
3565   GtkComboBox *combo_box = GTK_COMBO_BOX (user_data);
3566
3567   gtk_combo_box_list_popup_resize (combo_box);
3568 }
3569
3570
3571 static GtkWidget *
3572 find_menu_by_path (GtkWidget   *menu,
3573                    GtkTreePath *path,
3574                    gboolean     skip_first)
3575 {
3576   GList *i, *list;
3577   GtkWidget *child;
3578   GtkWidget *item;
3579   GtkWidget *submenu;
3580   GtkTreeRowReference *mref;
3581   GtkTreePath *mpath;
3582   gboolean skip;
3583
3584   list = gtk_container_get_children (GTK_CONTAINER (menu));
3585   skip = skip_first;
3586   item = NULL;
3587   for (i = list; i; i = i->next)
3588     {
3589       child = gtk_bin_get_child (i->data);
3590       if (GTK_IS_SEPARATOR_MENU_ITEM (i->data))
3591         {
3592           mref = g_object_get_data (G_OBJECT (i->data), "gtk-combo-box-item-path");
3593           if (!mref)
3594             continue;
3595           else if (!gtk_tree_row_reference_valid (mref))
3596             mpath = NULL;
3597           else
3598             mpath = gtk_tree_row_reference_get_path (mref);
3599         }
3600       else if (GTK_IS_CELL_VIEW (child))
3601         {
3602           if (skip)
3603             {
3604               skip = FALSE;
3605               continue;
3606             }
3607
3608           mpath = gtk_cell_view_get_displayed_row (GTK_CELL_VIEW (child));
3609         }
3610       else
3611         continue;
3612
3613       /* this case is necessary, since the row reference of
3614        * the cell view may already be updated after a deletion
3615        */
3616       if (!mpath)
3617         {
3618           item = i->data;
3619           break;
3620         }
3621       if (gtk_tree_path_compare (mpath, path) == 0)
3622         {
3623           gtk_tree_path_free (mpath);
3624           item = i->data;
3625           break;
3626         }
3627       if (gtk_tree_path_is_ancestor (mpath, path))
3628         {
3629           submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (i->data));
3630           if (submenu != NULL)
3631             {
3632               gtk_tree_path_free (mpath);
3633               item = find_menu_by_path (submenu, path, TRUE);
3634               break;
3635             }
3636         }
3637       gtk_tree_path_free (mpath);
3638     }
3639
3640   g_list_free (list);
3641
3642   return item;
3643 }
3644
3645 #if 0
3646 static void
3647 dump_menu_tree (GtkWidget   *menu,
3648                 gint         level)
3649 {
3650   GList *i, *list;
3651   GtkWidget *submenu;
3652   GtkTreePath *path;
3653
3654   list = gtk_container_get_children (GTK_CONTAINER (menu));
3655   for (i = list; i; i = i->next)
3656     {
3657       if (GTK_IS_CELL_VIEW (GTK_BIN (i->data)->child))
3658         {
3659           path = gtk_cell_view_get_displayed_row (GTK_CELL_VIEW (GTK_BIN (i->data)->child));
3660           g_print ("%*s%s\n", 2 * level, " ", gtk_tree_path_to_string (path));
3661           gtk_tree_path_free (path);
3662
3663           submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (i->data));
3664           if (submenu != NULL)
3665             dump_menu_tree (submenu, level + 1);
3666         }
3667     }
3668
3669   g_list_free (list);
3670 }
3671 #endif
3672
3673 static void
3674 gtk_combo_box_menu_row_inserted (GtkTreeModel *model,
3675                                  GtkTreePath  *path,
3676                                  GtkTreeIter  *iter,
3677                                  gpointer      user_data)
3678 {
3679   GtkComboBox *combo_box = GTK_COMBO_BOX (user_data);
3680   GtkComboBoxPrivate *priv = combo_box->priv;
3681   GtkWidget *parent;
3682   GtkWidget *item, *menu, *separator;
3683   GtkTreePath *ppath;
3684   GtkTreeIter piter;
3685   gint depth, pos;
3686   gboolean is_separator;
3687
3688   if (!priv->popup_widget)
3689     return;
3690
3691   depth = gtk_tree_path_get_depth (path);
3692   pos = gtk_tree_path_get_indices (path)[depth - 1];
3693   if (depth > 1)
3694     {
3695       ppath = gtk_tree_path_copy (path);
3696       gtk_tree_path_up (ppath);
3697       parent = find_menu_by_path (priv->popup_widget, ppath, FALSE);
3698       gtk_tree_path_free (ppath);
3699
3700       menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (parent));
3701       if (!menu)
3702         {
3703           menu = gtk_menu_new ();
3704           gtk_menu_set_reserve_toggle_size (GTK_MENU (menu), FALSE);
3705           gtk_widget_show (menu);
3706           gtk_menu_item_set_submenu (GTK_MENU_ITEM (parent), menu);
3707
3708           /* Ugly - since menus can only activate leaves, we have to
3709            * duplicate the item inside the submenu.
3710            */
3711           gtk_tree_model_iter_parent (model, &piter, iter);
3712           item = gtk_cell_view_menu_item_new (combo_box, model, &piter);
3713           separator = gtk_separator_menu_item_new ();
3714           g_signal_connect (item, "activate",
3715                             G_CALLBACK (gtk_combo_box_menu_item_activate),
3716                             combo_box);
3717           gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
3718           gtk_menu_shell_append (GTK_MENU_SHELL (menu), separator);
3719           if (cell_view_is_sensitive (GTK_CELL_VIEW (gtk_bin_get_child (GTK_BIN (item)))))
3720             {
3721               gtk_widget_show (item);
3722               gtk_widget_show (separator);
3723             }
3724         }
3725       pos += 2;
3726     }
3727   else
3728     {
3729       menu = priv->popup_widget;
3730       if (priv->add_tearoffs)
3731         pos += 1;
3732     }
3733
3734   if (priv->row_separator_func)
3735     is_separator = priv->row_separator_func (model, iter,
3736                                              priv->row_separator_data);
3737   else
3738     is_separator = FALSE;
3739
3740   if (is_separator)
3741     {
3742       item = gtk_separator_menu_item_new ();
3743       g_object_set_data_full (G_OBJECT (item),
3744                               I_("gtk-combo-box-item-path"),
3745                               gtk_tree_row_reference_new (model, path),
3746                               (GDestroyNotify)gtk_tree_row_reference_free);
3747     }
3748   else
3749     {
3750       item = gtk_cell_view_menu_item_new (combo_box, model, iter);
3751
3752       g_signal_connect (item, "activate",
3753                         G_CALLBACK (gtk_combo_box_menu_item_activate),
3754                         combo_box);
3755     }
3756
3757   gtk_widget_show (item);
3758   gtk_menu_shell_insert (GTK_MENU_SHELL (menu), item, pos);
3759 }
3760
3761 static void
3762 gtk_combo_box_menu_row_deleted (GtkTreeModel *model,
3763                                 GtkTreePath  *path,
3764                                 gpointer      user_data)
3765 {
3766   GtkComboBox *combo_box = GTK_COMBO_BOX (user_data);
3767   GtkComboBoxPrivate *priv = combo_box->priv;
3768   GtkWidget *menu;
3769   GtkWidget *item;
3770
3771   if (!priv->popup_widget)
3772     return;
3773
3774   item = find_menu_by_path (priv->popup_widget, path, FALSE);
3775   menu = gtk_widget_get_parent (item);
3776   gtk_container_remove (GTK_CONTAINER (menu), item);
3777
3778   if (gtk_tree_path_get_depth (path) > 1)
3779     {
3780       GtkTreePath *parent_path;
3781       GtkTreeIter iter;
3782       GtkWidget *parent;
3783
3784       parent_path = gtk_tree_path_copy (path);
3785       gtk_tree_path_up (parent_path);
3786       gtk_tree_model_get_iter (model, &iter, parent_path);
3787
3788       if (!gtk_tree_model_iter_has_child (model, &iter))
3789         {
3790           parent = find_menu_by_path (priv->popup_widget,
3791                                       parent_path, FALSE);
3792           gtk_menu_item_set_submenu (GTK_MENU_ITEM (parent), NULL);
3793         }
3794     }
3795 }
3796
3797 static void
3798 gtk_combo_box_menu_rows_reordered  (GtkTreeModel     *model,
3799                                     GtkTreePath      *path,
3800                                     GtkTreeIter      *iter,
3801                                     gint             *new_order,
3802                                     gpointer          user_data)
3803 {
3804   GtkComboBox *combo_box = GTK_COMBO_BOX (user_data);
3805
3806   gtk_combo_box_relayout (combo_box);
3807 }
3808
3809 static void
3810 gtk_combo_box_menu_row_changed (GtkTreeModel *model,
3811                                 GtkTreePath  *path,
3812                                 GtkTreeIter  *iter,
3813                                 gpointer      user_data)
3814 {
3815   GtkComboBox *combo_box = GTK_COMBO_BOX (user_data);
3816   GtkComboBoxPrivate *priv = combo_box->priv;
3817   GtkWidget *item;
3818   gboolean is_separator;
3819
3820   if (!priv->popup_widget)
3821     return;
3822
3823   item = find_menu_by_path (priv->popup_widget, path, FALSE);
3824
3825   if (priv->row_separator_func)
3826     is_separator = priv->row_separator_func (model, iter,
3827                                              priv->row_separator_data);
3828   else
3829     is_separator = FALSE;
3830
3831   if (is_separator != GTK_IS_SEPARATOR_MENU_ITEM (item))
3832     {
3833       gtk_combo_box_menu_row_deleted (model, path, combo_box);
3834       gtk_combo_box_menu_row_inserted (model, path, iter, combo_box);
3835     }
3836
3837   if (priv->wrap_width &&
3838       gtk_widget_get_parent (item) == priv->popup_widget)
3839     {
3840       GtkWidget *pitem = NULL;
3841       GtkTreePath *prev;
3842
3843       prev = gtk_tree_path_copy (path);
3844
3845       if (gtk_tree_path_prev (prev))
3846         pitem = find_menu_by_path (priv->popup_widget, prev, FALSE);
3847
3848       gtk_tree_path_free (prev);
3849
3850       /* unattach item so gtk_combo_box_relayout_item() won't spuriously
3851          move it */
3852       gtk_container_child_set (GTK_CONTAINER (priv->popup_widget),
3853                                item,
3854                                "left-attach", -1,
3855                                "right-attach", -1,
3856                                "top-attach", -1,
3857                                "bottom-attach", -1,
3858                                NULL);
3859
3860       gtk_combo_box_relayout_item (combo_box, item, iter, pitem);
3861     }
3862
3863   gtk_combo_box_update_requested_width (combo_box, path);
3864 }
3865
3866 /*
3867  * list style
3868  */
3869
3870 static void
3871 gtk_combo_box_list_setup (GtkComboBox *combo_box)
3872 {
3873   GtkComboBoxPrivate *priv = combo_box->priv;
3874   GtkTreeSelection *sel;
3875   GtkStyle *style;
3876   GtkWidget *child;
3877   GtkWidget *widget = GTK_WIDGET (combo_box);
3878
3879   priv->button = gtk_toggle_button_new ();
3880   child = gtk_bin_get_child (GTK_BIN (combo_box));
3881   gtk_widget_set_parent (priv->button,
3882                          gtk_widget_get_parent (child));
3883   g_signal_connect (priv->button, "button-press-event",
3884                     G_CALLBACK (gtk_combo_box_list_button_pressed), combo_box);
3885   g_signal_connect (priv->button, "toggled",
3886                     G_CALLBACK (gtk_combo_box_button_toggled), combo_box);
3887
3888   priv->arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_NONE);
3889   gtk_container_add (GTK_CONTAINER (priv->button), priv->arrow);
3890   priv->separator = NULL;
3891   gtk_widget_show_all (priv->button);
3892
3893   if (priv->cell_view)
3894     {
3895       style = gtk_widget_get_style (widget);
3896       gtk_cell_view_set_background_color (GTK_CELL_VIEW (priv->cell_view),
3897                                           &style->base[gtk_widget_get_state (widget)]);
3898
3899       priv->box = gtk_event_box_new ();
3900       gtk_event_box_set_visible_window (GTK_EVENT_BOX (priv->box),
3901                                         FALSE);
3902
3903       if (priv->has_frame)
3904         {
3905           priv->cell_view_frame = gtk_frame_new (NULL);
3906           gtk_frame_set_shadow_type (GTK_FRAME (priv->cell_view_frame),
3907                                      GTK_SHADOW_IN);
3908         }
3909       else
3910         {
3911           combo_box->priv->cell_view_frame = gtk_event_box_new ();
3912           gtk_event_box_set_visible_window (GTK_EVENT_BOX (combo_box->priv->cell_view_frame),
3913                                             FALSE);
3914         }
3915
3916       gtk_widget_set_parent (priv->cell_view_frame,
3917                              gtk_widget_get_parent (child));
3918       gtk_container_add (GTK_CONTAINER (priv->cell_view_frame), priv->box);
3919       gtk_widget_show_all (priv->cell_view_frame);
3920
3921       g_signal_connect (priv->box, "button-press-event",
3922                         G_CALLBACK (gtk_combo_box_list_button_pressed),
3923                         combo_box);
3924     }
3925
3926   priv->tree_view = gtk_tree_view_new ();
3927   sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->tree_view));
3928   gtk_tree_selection_set_mode (sel, GTK_SELECTION_BROWSE);
3929   gtk_tree_selection_set_select_function (sel,
3930                                           gtk_combo_box_list_select_func,
3931                                           NULL, NULL);
3932   gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->tree_view),
3933                                      FALSE);
3934   gtk_tree_view_set_hover_selection (GTK_TREE_VIEW (priv->tree_view),
3935                                      TRUE);
3936   if (priv->row_separator_func)
3937     gtk_tree_view_set_row_separator_func (GTK_TREE_VIEW (priv->tree_view),
3938                                           priv->row_separator_func,
3939                                           priv->row_separator_data,
3940                                           NULL);
3941   if (priv->model)
3942     gtk_tree_view_set_model (GTK_TREE_VIEW (priv->tree_view), priv->model);
3943
3944   priv->column = gtk_tree_view_column_new ();
3945   gtk_tree_view_append_column (GTK_TREE_VIEW (priv->tree_view), priv->column);
3946
3947   /* sync up */
3948   gtk_combo_box_sync_cells (combo_box,
3949                             GTK_CELL_LAYOUT (priv->column));
3950
3951   if (gtk_tree_row_reference_valid (priv->active_row))
3952     {
3953       GtkTreePath *path;
3954
3955       path = gtk_tree_row_reference_get_path (priv->active_row);
3956       gtk_tree_view_set_cursor (GTK_TREE_VIEW (priv->tree_view),
3957                                 path, NULL, FALSE);
3958       gtk_tree_path_free (path);
3959     }
3960
3961   /* set sample/popup widgets */
3962   gtk_combo_box_set_popup_widget (combo_box, priv->tree_view);
3963
3964   g_signal_connect (priv->tree_view, "key-press-event",
3965                     G_CALLBACK (gtk_combo_box_list_key_press),
3966                     combo_box);
3967   g_signal_connect (priv->tree_view, "enter-notify-event",
3968                     G_CALLBACK (gtk_combo_box_list_enter_notify),
3969                     combo_box);
3970   g_signal_connect (priv->tree_view, "row-expanded",
3971                     G_CALLBACK (gtk_combo_box_model_row_expanded),
3972                     combo_box);
3973   g_signal_connect (priv->tree_view, "row-collapsed",
3974                     G_CALLBACK (gtk_combo_box_model_row_expanded),
3975                     combo_box);
3976   g_signal_connect (priv->popup_window, "button-press-event",
3977                     G_CALLBACK (gtk_combo_box_list_button_pressed),
3978                     combo_box);
3979   g_signal_connect (priv->popup_window, "button-release-event",
3980                     G_CALLBACK (gtk_combo_box_list_button_released),
3981                     combo_box);
3982
3983   gtk_widget_show (priv->tree_view);
3984
3985   gtk_combo_box_update_sensitivity (combo_box);
3986 }
3987
3988 static void
3989 gtk_combo_box_list_destroy (GtkComboBox *combo_box)
3990 {
3991   GtkComboBoxPrivate *priv = combo_box->priv;
3992
3993   /* disconnect signals */
3994   g_signal_handlers_disconnect_matched (priv->tree_view,
3995                                         G_SIGNAL_MATCH_DATA,
3996                                         0, 0, NULL, NULL, combo_box);
3997   g_signal_handlers_disconnect_matched (priv->button,
3998                                         G_SIGNAL_MATCH_DATA,
3999                                         0, 0, NULL,
4000                                         gtk_combo_box_list_button_pressed,
4001                                         NULL);
4002   g_signal_handlers_disconnect_matched (priv->popup_window,
4003                                         G_SIGNAL_MATCH_DATA,
4004                                         0, 0, NULL,
4005                                         gtk_combo_box_list_button_pressed,
4006                                         NULL);
4007   g_signal_handlers_disconnect_matched (priv->popup_window,
4008                                         G_SIGNAL_MATCH_DATA,
4009                                         0, 0, NULL,
4010                                         gtk_combo_box_list_button_released,
4011                                         NULL);
4012
4013   g_signal_handlers_disconnect_matched (priv->popup_window,
4014                                         G_SIGNAL_MATCH_DATA,
4015                                         0, 0, NULL,
4016                                         gtk_combo_box_child_show,
4017                                         NULL);
4018
4019   g_signal_handlers_disconnect_matched (priv->popup_window,
4020                                         G_SIGNAL_MATCH_DATA,
4021                                         0, 0, NULL,
4022                                         gtk_combo_box_child_hide,
4023                                         NULL);
4024
4025   if (priv->box)
4026     g_signal_handlers_disconnect_matched (priv->box,
4027                                           G_SIGNAL_MATCH_DATA,
4028                                           0, 0, NULL,
4029                                           gtk_combo_box_list_button_pressed,
4030                                           NULL);
4031
4032   /* destroy things (unparent will kill the latest ref from us)
4033    * last unref on button will destroy the arrow
4034    */
4035   gtk_widget_unparent (priv->button);
4036   priv->button = NULL;
4037   priv->arrow = NULL;
4038
4039   if (priv->cell_view)
4040     {
4041       g_object_set (priv->cell_view,
4042                     "background-set", FALSE,
4043                     NULL);
4044     }
4045
4046   if (priv->cell_view_frame)
4047     {
4048       gtk_widget_unparent (priv->cell_view_frame);
4049       priv->cell_view_frame = NULL;
4050       priv->box = NULL;
4051     }
4052
4053   if (priv->scroll_timer)
4054     {
4055       g_source_remove (priv->scroll_timer);
4056       priv->scroll_timer = 0;
4057     }
4058
4059   if (priv->resize_idle_id)
4060     {
4061       g_source_remove (priv->resize_idle_id);
4062       priv->resize_idle_id = 0;
4063     }
4064
4065   gtk_widget_destroy (priv->tree_view);
4066
4067   priv->tree_view = NULL;
4068   if (priv->popup_widget)
4069     {
4070       g_object_unref (priv->popup_widget);
4071       priv->popup_widget = NULL;
4072     }
4073 }
4074
4075 /* callbacks */
4076
4077 static gboolean
4078 gtk_combo_box_list_button_pressed (GtkWidget      *widget,
4079                                    GdkEventButton *event,
4080                                    gpointer        data)
4081 {
4082   GtkComboBox *combo_box = GTK_COMBO_BOX (data);
4083   GtkComboBoxPrivate *priv = combo_box->priv;
4084
4085   GtkWidget *ewidget = gtk_get_event_widget ((GdkEvent *)event);
4086
4087   if (ewidget == priv->popup_window)
4088     return TRUE;
4089
4090   if ((ewidget != priv->button && ewidget != priv->box) ||
4091       gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->button)))
4092     return FALSE;
4093
4094   if (priv->focus_on_click &&
4095       !gtk_widget_has_focus (priv->button))
4096     gtk_widget_grab_focus (priv->button);
4097
4098   gtk_combo_box_popup_for_device (combo_box, event->device);
4099
4100   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->button), TRUE);
4101
4102   priv->auto_scroll = FALSE;
4103   if (priv->scroll_timer == 0)
4104     priv->scroll_timer = gdk_threads_add_timeout (SCROLL_TIME,
4105                                                   (GSourceFunc) gtk_combo_box_list_scroll_timeout,
4106                                                    combo_box);
4107
4108   priv->popup_in_progress = TRUE;
4109
4110   return TRUE;
4111 }
4112
4113 static gboolean
4114 gtk_combo_box_list_button_released (GtkWidget      *widget,
4115                                     GdkEventButton *event,
4116                                     gpointer        data)
4117 {
4118   gboolean ret;
4119   GtkTreePath *path = NULL;
4120   GtkTreeIter iter;
4121
4122   GtkComboBox *combo_box = GTK_COMBO_BOX (data);
4123   GtkComboBoxPrivate *priv = combo_box->priv;
4124
4125   gboolean popup_in_progress = FALSE;
4126
4127   GtkWidget *ewidget = gtk_get_event_widget ((GdkEvent *)event);
4128
4129   if (priv->popup_in_progress)
4130     {
4131       popup_in_progress = TRUE;
4132       priv->popup_in_progress = FALSE;
4133     }
4134
4135   gtk_tree_view_set_hover_expand (GTK_TREE_VIEW (priv->tree_view),
4136                                   FALSE);
4137   if (priv->scroll_timer)
4138     {
4139       g_source_remove (priv->scroll_timer);
4140       priv->scroll_timer = 0;
4141     }
4142
4143   if (ewidget != priv->tree_view)
4144     {
4145       if ((ewidget == priv->button ||
4146            ewidget == priv->box) &&
4147           !popup_in_progress &&
4148           gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->button)))
4149         {
4150           gtk_combo_box_popdown (combo_box);
4151           return TRUE;
4152         }
4153
4154       /* released outside treeview */
4155       if (ewidget != priv->button && ewidget != priv->box)
4156         {
4157           gtk_combo_box_popdown (combo_box);
4158
4159           return TRUE;
4160         }
4161
4162       return FALSE;
4163     }
4164
4165   /* select something cool */
4166   ret = gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (priv->tree_view),
4167                                        event->x, event->y,
4168                                        &path,
4169                                        NULL, NULL, NULL);
4170
4171   if (!ret)
4172     return TRUE; /* clicked outside window? */
4173
4174   gtk_tree_model_get_iter (priv->model, &iter, path);
4175   gtk_tree_path_free (path);
4176
4177   gtk_combo_box_popdown (combo_box);
4178
4179   if (tree_column_row_is_sensitive (combo_box, &iter))
4180     gtk_combo_box_set_active_iter (combo_box, &iter);
4181
4182   return TRUE;
4183 }
4184
4185 static gboolean
4186 gtk_combo_box_menu_key_press (GtkWidget   *widget,
4187                               GdkEventKey *event,
4188                               gpointer     data)
4189 {
4190   GtkComboBox *combo_box = GTK_COMBO_BOX (data);
4191
4192   if (!gtk_bindings_activate_event (G_OBJECT (widget), event))
4193     {
4194       /* The menu hasn't managed the
4195        * event, forward it to the combobox
4196        */
4197       gtk_bindings_activate_event (G_OBJECT (combo_box), event);
4198     }
4199
4200   return TRUE;
4201 }
4202
4203 static gboolean
4204 gtk_combo_box_list_key_press (GtkWidget   *widget,
4205                               GdkEventKey *event,
4206                               gpointer     data)
4207 {
4208   GtkComboBox *combo_box = GTK_COMBO_BOX (data);
4209   GtkTreeIter iter;
4210
4211   if (event->keyval == GDK_KEY_Return || event->keyval == GDK_KEY_ISO_Enter || event->keyval == GDK_KEY_KP_Enter ||
4212       event->keyval == GDK_KEY_space || event->keyval == GDK_KEY_KP_Space)
4213   {
4214     GtkTreeModel *model = NULL;
4215
4216     gtk_combo_box_popdown (combo_box);
4217
4218     if (combo_box->priv->model)
4219       {
4220         GtkTreeSelection *sel;
4221
4222         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (combo_box->priv->tree_view));
4223
4224         if (gtk_tree_selection_get_selected (sel, &model, &iter))
4225           gtk_combo_box_set_active_iter (combo_box, &iter);
4226       }
4227
4228     return TRUE;
4229   }
4230
4231   if (!gtk_bindings_activate_event (G_OBJECT (widget), event))
4232     {
4233       /* The list hasn't managed the
4234        * event, forward it to the combobox
4235        */
4236       gtk_bindings_activate_event (G_OBJECT (combo_box), event);
4237     }
4238
4239   return TRUE;
4240 }
4241
4242 static void
4243 gtk_combo_box_list_auto_scroll (GtkComboBox *combo_box,
4244                                 gint         x,
4245                                 gint         y)
4246 {
4247   GtkAdjustment *adj;
4248   GtkAllocation allocation;
4249   GtkWidget *tree_view = combo_box->priv->tree_view;
4250   gdouble value;
4251
4252   gtk_widget_get_allocation (tree_view, &allocation);
4253
4254   adj = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (combo_box->priv->scrolled_window));
4255   if (adj && adj->upper - adj->lower > adj->page_size)
4256     {
4257       if (x <= allocation.x &&
4258           adj->lower < adj->value)
4259         {
4260           value = adj->value - (allocation.x - x + 1);
4261           gtk_adjustment_set_value (adj, value);
4262         }
4263       else if (x >= allocation.x + allocation.width &&
4264                adj->upper - adj->page_size > adj->value)
4265         {
4266           value = adj->value + (x - allocation.x - allocation.width + 1);
4267           gtk_adjustment_set_value (adj, MAX (value, 0.0));
4268         }
4269     }
4270
4271   adj = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (combo_box->priv->scrolled_window));
4272   if (adj && adj->upper - adj->lower > adj->page_size)
4273     {
4274       if (y <= allocation.y &&
4275           adj->lower < adj->value)
4276         {
4277           value = adj->value - (allocation.y - y + 1);
4278           gtk_adjustment_set_value (adj, value);
4279         }
4280       else if (y >= allocation.height &&
4281                adj->upper - adj->page_size > adj->value)
4282         {
4283           value = adj->value + (y - allocation.height + 1);
4284           gtk_adjustment_set_value (adj, MAX (value, 0.0));
4285         }
4286     }
4287 }
4288
4289 static gboolean
4290 gtk_combo_box_list_scroll_timeout (GtkComboBox *combo_box)
4291 {
4292   GtkComboBoxPrivate *priv = combo_box->priv;
4293   gint x, y;
4294
4295   if (priv->auto_scroll)
4296     {
4297       gdk_window_get_device_position (gtk_widget_get_window (priv->tree_view),
4298                                       priv->grab_pointer,
4299                                       &x, &y, NULL);
4300       gtk_combo_box_list_auto_scroll (combo_box, x, y);
4301     }
4302
4303   return TRUE;
4304 }
4305
4306 static gboolean
4307 gtk_combo_box_list_enter_notify (GtkWidget        *widget,
4308                                  GdkEventCrossing *event,
4309                                  gpointer          data)
4310 {
4311   GtkComboBox *combo_box = GTK_COMBO_BOX (data);
4312
4313   combo_box->priv->auto_scroll = TRUE;
4314
4315   return TRUE;
4316 }
4317
4318 static gboolean
4319 gtk_combo_box_list_select_func (GtkTreeSelection *selection,
4320                                 GtkTreeModel     *model,
4321                                 GtkTreePath      *path,
4322                                 gboolean          path_currently_selected,
4323                                 gpointer          data)
4324 {
4325   GList *list;
4326   gboolean sensitive = FALSE;
4327
4328   for (list = selection->tree_view->priv->columns; list && !sensitive; list = list->next)
4329     {
4330       GList *cells, *cell;
4331       gboolean cell_sensitive, cell_visible;
4332       GtkTreeIter iter;
4333       GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (list->data);
4334
4335       if (!column->visible)
4336         continue;
4337
4338       gtk_tree_model_get_iter (model, &iter, path);
4339       gtk_tree_view_column_cell_set_cell_data (column, model, &iter,
4340                                                FALSE, FALSE);
4341
4342       cell = cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (column));
4343       while (cell)
4344         {
4345           g_object_get (cell->data,
4346                         "sensitive", &cell_sensitive,
4347                         "visible", &cell_visible,
4348                         NULL);
4349
4350           if (cell_visible && cell_sensitive)
4351             break;
4352
4353           cell = cell->next;
4354         }
4355       g_list_free (cells);
4356
4357       sensitive = cell_sensitive;
4358     }
4359
4360   return sensitive;
4361 }
4362
4363 static void
4364 gtk_combo_box_list_row_changed (GtkTreeModel *model,
4365                                 GtkTreePath  *path,
4366                                 GtkTreeIter  *iter,
4367                                 gpointer      data)
4368 {
4369   GtkComboBox *combo_box = GTK_COMBO_BOX (data);
4370
4371   gtk_combo_box_update_requested_width (combo_box, path);
4372 }
4373
4374 /*
4375  * GtkCellLayout implementation
4376  */
4377
4378 static void
4379 pack_start_recurse (GtkWidget       *menu,
4380                     GtkCellRenderer *cell,
4381                     gboolean         expand)
4382 {
4383   GList *i, *list;
4384   GtkWidget *child;
4385   GtkWidget *submenu;
4386
4387   list = gtk_container_get_children (GTK_CONTAINER (menu));
4388   for (i = list; i; i = i->next)
4389     {
4390       child = gtk_bin_get_child (GTK_BIN (i->data));
4391       if (GTK_IS_CELL_LAYOUT (child))
4392         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (child),
4393                                     cell, expand);
4394
4395       submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (i->data));
4396       if (submenu != NULL)
4397         pack_start_recurse (submenu, cell, expand);
4398     }
4399
4400   g_list_free (list);
4401 }
4402
4403 static void
4404 gtk_combo_box_cell_layout_pack_start (GtkCellLayout   *layout,
4405                                       GtkCellRenderer *cell,
4406                                       gboolean         expand)
4407 {
4408   GtkComboBox *combo_box = GTK_COMBO_BOX (layout);
4409   ComboCellInfo *info;
4410   GtkComboBoxPrivate *priv;
4411
4412   priv = combo_box->priv;
4413
4414   g_object_ref_sink (cell);
4415
4416   info = g_slice_new0 (ComboCellInfo);
4417   info->cell = cell;
4418   info->expand = expand;
4419   info->pack = GTK_PACK_START;
4420
4421   priv->cells = g_slist_append (priv->cells, info);
4422
4423   if (priv->cell_view)
4424     {
4425       gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (priv->cell_view),
4426                                   cell, expand);
4427
4428     }
4429
4430   if (priv->column)
4431     gtk_tree_view_column_pack_start (priv->column, cell, expand);
4432
4433   if (GTK_IS_MENU (priv->popup_widget))
4434     pack_start_recurse (priv->popup_widget, cell, expand);
4435 }
4436
4437 static void
4438 pack_end_recurse (GtkWidget       *menu,
4439                   GtkCellRenderer *cell,
4440                   gboolean         expand)
4441 {
4442   GList *i, *list;
4443   GtkWidget *child;
4444   GtkWidget *submenu;
4445
4446   list = gtk_container_get_children (GTK_CONTAINER (menu));
4447   for (i = list; i; i = i->next)
4448     {
4449       child = gtk_bin_get_child (GTK_BIN (i->data));
4450       if (GTK_IS_CELL_LAYOUT (child))
4451         gtk_cell_layout_pack_end (GTK_CELL_LAYOUT (child),
4452                                   cell, expand);
4453
4454       submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (i->data));
4455       if (submenu != NULL)
4456         pack_end_recurse (submenu, cell, expand);
4457     }
4458
4459   g_list_free (list);
4460 }
4461
4462 static void
4463 gtk_combo_box_cell_layout_pack_end (GtkCellLayout   *layout,
4464                                     GtkCellRenderer *cell,
4465                                     gboolean         expand)
4466 {
4467   GtkComboBox *combo_box = GTK_COMBO_BOX (layout);
4468   ComboCellInfo *info;
4469   GtkComboBoxPrivate *priv;
4470
4471   priv = combo_box->priv;
4472
4473   g_object_ref_sink (cell);
4474
4475   info = g_slice_new0 (ComboCellInfo);
4476   info->cell = cell;
4477   info->expand = expand;
4478   info->pack = GTK_PACK_END;
4479
4480   priv->cells = g_slist_append (priv->cells, info);
4481
4482   if (priv->cell_view)
4483     gtk_cell_layout_pack_end (GTK_CELL_LAYOUT (priv->cell_view),
4484                               cell, expand);
4485
4486   if (priv->column)
4487     gtk_tree_view_column_pack_end (priv->column, cell, expand);
4488
4489   if (GTK_IS_MENU (priv->popup_widget))
4490     pack_end_recurse (priv->popup_widget, cell, expand);
4491 }
4492
4493 static GList *
4494 gtk_combo_box_cell_layout_get_cells (GtkCellLayout *layout)
4495 {
4496   GtkComboBox *combo_box = GTK_COMBO_BOX (layout);
4497   GSList *list;
4498   GList *retval = NULL;
4499
4500   for (list = combo_box->priv->cells; list; list = list->next)
4501     {
4502       ComboCellInfo *info = (ComboCellInfo *)list->data;
4503
4504       retval = g_list_prepend (retval, info->cell);
4505     }
4506
4507   return g_list_reverse (retval);
4508 }
4509
4510 static void
4511 clear_recurse (GtkWidget *menu)
4512 {
4513   GList *i, *list;
4514   GtkWidget *child;
4515   GtkWidget *submenu;
4516
4517   list = gtk_container_get_children (GTK_CONTAINER (menu));
4518   for (i = list; i; i = i->next)
4519     {
4520       child = gtk_bin_get_child (GTK_BIN (i->data));
4521       if (GTK_IS_CELL_LAYOUT (child))
4522         gtk_cell_layout_clear (GTK_CELL_LAYOUT (child));
4523
4524       submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (i->data));
4525       if (submenu != NULL)
4526         clear_recurse (submenu);
4527     }
4528
4529   g_list_free (list);
4530 }
4531
4532 static void
4533 gtk_combo_box_cell_layout_clear (GtkCellLayout *layout)
4534 {
4535   GtkComboBox *combo_box = GTK_COMBO_BOX (layout);
4536   GtkComboBoxPrivate *priv = combo_box->priv;
4537   GSList *i;
4538
4539   if (priv->cell_view)
4540     gtk_cell_layout_clear (GTK_CELL_LAYOUT (priv->cell_view));
4541
4542   if (priv->column)
4543     gtk_tree_view_column_clear (priv->column);
4544
4545   for (i = priv->cells; i; i = i->next)
4546     {
4547       ComboCellInfo *info = (ComboCellInfo *)i->data;
4548
4549       gtk_combo_box_cell_layout_clear_attributes (layout, info->cell);
4550       g_object_unref (info->cell);
4551       g_slice_free (ComboCellInfo, info);
4552       i->data = NULL;
4553     }
4554   g_slist_free (priv->cells);
4555   priv->cells = NULL;
4556
4557   if (GTK_IS_MENU (priv->popup_widget))
4558     clear_recurse (priv->popup_widget);
4559 }
4560
4561 static void
4562 add_attribute_recurse (GtkWidget       *menu,
4563                        GtkCellRenderer *cell,
4564                        const gchar     *attribute,
4565                        gint             column)
4566 {
4567   GList *i, *list;
4568   GtkWidget *child;
4569   GtkWidget *submenu;
4570
4571   list = gtk_container_get_children (GTK_CONTAINER (menu));
4572   for (i = list; i; i = i->next)
4573     {
4574       child = gtk_bin_get_child (GTK_BIN (i->data));
4575       if (GTK_IS_CELL_LAYOUT (child))
4576         gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (child),
4577                                        cell, attribute, column);
4578
4579       submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (i->data));
4580       if (submenu != NULL)
4581         add_attribute_recurse (submenu, cell, attribute, column);
4582     }
4583
4584   g_list_free (list);
4585 }
4586
4587 static void
4588 gtk_combo_box_cell_layout_add_attribute (GtkCellLayout   *layout,
4589                                          GtkCellRenderer *cell,
4590                                          const gchar     *attribute,
4591                                          gint             column)
4592 {
4593   GtkComboBox *combo_box = GTK_COMBO_BOX (layout);
4594   ComboCellInfo *info;
4595
4596   info = gtk_combo_box_get_cell_info (combo_box, cell);
4597   g_return_if_fail (info != NULL);
4598
4599   info->attributes = g_slist_prepend (info->attributes,
4600                                       GINT_TO_POINTER (column));
4601   info->attributes = g_slist_prepend (info->attributes,
4602                                       g_strdup (attribute));
4603
4604   if (combo_box->priv->cell_view)
4605     gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo_box->priv->cell_view),
4606                                    cell, attribute, column);
4607
4608   if (combo_box->priv->column)
4609     gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo_box->priv->column),
4610                                    cell, attribute, column);
4611
4612   if (GTK_IS_MENU (combo_box->priv->popup_widget))
4613     add_attribute_recurse (combo_box->priv->popup_widget, cell, attribute, column);
4614   gtk_widget_queue_resize (GTK_WIDGET (combo_box));
4615 }
4616
4617 static void
4618 combo_cell_data_func (GtkCellLayout   *cell_layout,
4619                       GtkCellRenderer *cell,
4620                       GtkTreeModel    *tree_model,
4621                       GtkTreeIter     *iter,
4622                       gpointer         data)
4623 {
4624   ComboCellInfo *info = (ComboCellInfo *)data;
4625   GtkWidget *parent = NULL;
4626
4627   if (!info->func)
4628     return;
4629
4630   info->func (cell_layout, cell, tree_model, iter, info->func_data);
4631
4632   if (GTK_IS_WIDGET (cell_layout))
4633     parent = gtk_widget_get_parent (GTK_WIDGET (cell_layout));
4634
4635   if (GTK_IS_MENU_ITEM (parent) &&
4636       gtk_menu_item_get_submenu (GTK_MENU_ITEM (parent)))
4637     g_object_set (cell, "sensitive", TRUE, NULL);
4638 }
4639
4640
4641 static void
4642 set_cell_data_func_recurse (GtkWidget       *menu,
4643                             GtkCellRenderer *cell,
4644                             ComboCellInfo   *info)
4645 {
4646   GList *i, *list;
4647   GtkWidget *submenu;
4648   GtkWidget *cell_view;
4649
4650  list = gtk_container_get_children (GTK_CONTAINER (menu));
4651   for (i = list; i; i = i->next)
4652     {
4653       cell_view = gtk_bin_get_child (GTK_BIN (i->data));
4654       if (GTK_IS_CELL_LAYOUT (cell_view))
4655         {
4656           /* Override sensitivity for inner nodes; we don't
4657            * want menuitems with submenus to appear insensitive
4658            */
4659           gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (cell_view),
4660                                               cell,
4661                                               combo_cell_data_func,
4662                                               info, NULL);
4663           submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (i->data));
4664           if (submenu != NULL)
4665             set_cell_data_func_recurse (submenu, cell, info);
4666         }
4667     }
4668
4669   g_list_free (list);
4670 }
4671
4672 static void
4673 gtk_combo_box_cell_layout_set_cell_data_func (GtkCellLayout         *layout,
4674                                               GtkCellRenderer       *cell,
4675                                               GtkCellLayoutDataFunc  func,
4676                                               gpointer               func_data,
4677                                               GDestroyNotify         destroy)
4678 {
4679   GtkComboBox *combo_box = GTK_COMBO_BOX (layout);
4680   GtkComboBoxPrivate *priv = combo_box->priv;
4681   ComboCellInfo *info;
4682
4683   info = gtk_combo_box_get_cell_info (combo_box, cell);
4684   g_return_if_fail (info != NULL);
4685
4686   if (info->destroy)
4687     {
4688       GDestroyNotify d = info->destroy;
4689
4690       info->destroy = NULL;
4691       d (info->func_data);
4692     }
4693
4694   info->func = func;
4695   info->func_data = func_data;
4696   info->destroy = destroy;
4697
4698   if (priv->cell_view)
4699     gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (priv->cell_view), cell, func, func_data, NULL);
4700
4701   if (priv->column)
4702     gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (priv->column), cell, func, func_data, NULL);
4703
4704   if (GTK_IS_MENU (priv->popup_widget))
4705     set_cell_data_func_recurse (priv->popup_widget, cell, info);
4706
4707   gtk_widget_queue_resize (GTK_WIDGET (combo_box));
4708 }
4709
4710 static void
4711 clear_attributes_recurse (GtkWidget       *menu,
4712                           GtkCellRenderer *cell)
4713 {
4714   GList *i, *list;
4715   GtkWidget *submenu;
4716   GtkWidget *child;
4717
4718   list = gtk_container_get_children (GTK_CONTAINER (menu));
4719   for (i = list; i; i = i->next)
4720     {
4721       child = gtk_bin_get_child (GTK_BIN (i->data));
4722       if (GTK_IS_CELL_LAYOUT (child))
4723         gtk_cell_layout_clear_attributes (GTK_CELL_LAYOUT (child), cell);
4724
4725       submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (i->data));
4726       if (submenu != NULL)
4727         clear_attributes_recurse (submenu, cell);
4728     }
4729
4730   g_list_free (list);
4731 }
4732
4733 static void
4734 gtk_combo_box_cell_layout_clear_attributes (GtkCellLayout   *layout,
4735                                             GtkCellRenderer *cell)
4736 {
4737   GtkComboBox *combo_box = GTK_COMBO_BOX (layout);
4738   GtkComboBoxPrivate *priv;
4739   ComboCellInfo *info;
4740   GSList *list;
4741
4742   priv = combo_box->priv;
4743
4744   info = gtk_combo_box_get_cell_info (combo_box, cell);
4745   g_return_if_fail (info != NULL);
4746
4747   list = info->attributes;
4748   while (list && list->next)
4749     {
4750       g_free (list->data);
4751       list = list->next->next;
4752     }
4753   g_slist_free (info->attributes);
4754   info->attributes = NULL;
4755
4756   if (priv->cell_view)
4757     gtk_cell_layout_clear_attributes (GTK_CELL_LAYOUT (priv->cell_view), cell);
4758
4759   if (priv->column)
4760     gtk_cell_layout_clear_attributes (GTK_CELL_LAYOUT (priv->column), cell);
4761
4762   if (GTK_IS_MENU (priv->popup_widget))
4763     clear_attributes_recurse (priv->popup_widget, cell);
4764
4765   gtk_widget_queue_resize (GTK_WIDGET (combo_box));
4766 }
4767
4768 static void
4769 reorder_recurse (GtkWidget             *menu,
4770                  GtkCellRenderer       *cell,
4771                  gint                   position)
4772 {
4773   GList *i, *list;
4774   GtkWidget *child;
4775   GtkWidget *submenu;
4776
4777   list = gtk_container_get_children (GTK_CONTAINER (menu));
4778   for (i = list; i; i = i->next)
4779     {
4780       child = gtk_bin_get_child (GTK_BIN (i->data));
4781       if (GTK_IS_CELL_LAYOUT (child))
4782         gtk_cell_layout_reorder (GTK_CELL_LAYOUT (child),
4783                                  cell, position);
4784
4785       submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (i->data));
4786       if (submenu != NULL)
4787         reorder_recurse (submenu, cell, position);
4788     }
4789
4790   g_list_free (list);
4791 }
4792
4793 static void
4794 gtk_combo_box_cell_layout_reorder (GtkCellLayout   *layout,
4795                                    GtkCellRenderer *cell,
4796                                    gint             position)
4797 {
4798   GtkComboBox *combo_box = GTK_COMBO_BOX (layout);
4799   GtkComboBoxPrivate *priv;
4800   ComboCellInfo *info;
4801   GSList *link;
4802
4803   priv = combo_box->priv;
4804
4805   info = gtk_combo_box_get_cell_info (combo_box, cell);
4806
4807   g_return_if_fail (info != NULL);
4808   g_return_if_fail (position >= 0);
4809
4810   link = g_slist_find (priv->cells, info);
4811
4812   g_return_if_fail (link != NULL);
4813
4814   priv->cells = g_slist_delete_link (priv->cells, link);
4815   priv->cells = g_slist_insert (priv->cells, info, position);
4816
4817   if (priv->cell_view)
4818     gtk_cell_layout_reorder (GTK_CELL_LAYOUT (priv->cell_view),
4819                              cell, position);
4820
4821   if (priv->column)
4822     gtk_cell_layout_reorder (GTK_CELL_LAYOUT (priv->column),
4823                              cell, position);
4824
4825   if (GTK_IS_MENU (priv->popup_widget))
4826     reorder_recurse (priv->popup_widget, cell, position);
4827
4828   gtk_widget_queue_draw (GTK_WIDGET (combo_box));
4829 }
4830
4831 /*
4832  * public API
4833  */
4834
4835 /**
4836  * gtk_combo_box_new:
4837  *
4838  * Creates a new empty #GtkComboBox.
4839  *
4840  * Return value: A new #GtkComboBox.
4841  *
4842  * Since: 2.4
4843  */
4844 GtkWidget *
4845 gtk_combo_box_new (void)
4846 {
4847   return g_object_new (GTK_TYPE_COMBO_BOX, NULL);
4848 }
4849
4850 /**
4851  * gtk_combo_box_new_with_entry:
4852  *
4853  * Creates a new empty #GtkComboBox with an entry.
4854  *
4855  * Return value: A new #GtkComboBox.
4856  */
4857 GtkWidget *
4858 gtk_combo_box_new_with_entry (void)
4859 {
4860   return g_object_new (GTK_TYPE_COMBO_BOX, "has-entry", TRUE, NULL);
4861 }
4862
4863 /**
4864  * gtk_combo_box_new_with_model:
4865  * @model: A #GtkTreeModel.
4866  *
4867  * Creates a new #GtkComboBox with the model initialized to @model.
4868  *
4869  * Return value: A new #GtkComboBox.
4870  *
4871  * Since: 2.4
4872  */
4873 GtkWidget *
4874 gtk_combo_box_new_with_model (GtkTreeModel *model)
4875 {
4876   GtkComboBox *combo_box;
4877
4878   g_return_val_if_fail (GTK_IS_TREE_MODEL (model), NULL);
4879
4880   combo_box = g_object_new (GTK_TYPE_COMBO_BOX, "model", model, NULL);
4881
4882   return GTK_WIDGET (combo_box);
4883 }
4884
4885 /**
4886  * gtk_combo_box_get_wrap_width:
4887  * @combo_box: A #GtkComboBox
4888  *
4889  * Returns the wrap width which is used to determine the number of columns
4890  * for the popup menu. If the wrap width is larger than 1, the combo box
4891  * is in table mode.
4892  *
4893  * Returns: the wrap width.
4894  *
4895  * Since: 2.6
4896  */
4897 gint
4898 gtk_combo_box_get_wrap_width (GtkComboBox *combo_box)
4899 {
4900   g_return_val_if_fail (GTK_IS_COMBO_BOX (combo_box), -1);
4901
4902   return combo_box->priv->wrap_width;
4903 }
4904
4905 /**
4906  * gtk_combo_box_set_wrap_width:
4907  * @combo_box: A #GtkComboBox
4908  * @width: Preferred number of columns
4909  *
4910  * Sets the wrap width of @combo_box to be @width. The wrap width is basically
4911  * the preferred number of columns when you want the popup to be layed out
4912  * in a table.
4913  *
4914  * Since: 2.4
4915  */
4916 void
4917 gtk_combo_box_set_wrap_width (GtkComboBox *combo_box,
4918                               gint         width)
4919 {
4920   GtkComboBoxPrivate *priv;
4921
4922   g_return_if_fail (GTK_IS_COMBO_BOX (combo_box));
4923   g_return_if_fail (width >= 0);
4924
4925   priv = combo_box->priv;
4926
4927   if (width != priv->wrap_width)
4928     {
4929       priv->wrap_width = width;
4930
4931       gtk_combo_box_check_appearance (combo_box);
4932       gtk_combo_box_relayout (combo_box);
4933
4934       g_object_notify (G_OBJECT (combo_box), "wrap-width");
4935     }
4936 }
4937
4938 /**
4939  * gtk_combo_box_get_row_span_column:
4940  * @combo_box: A #GtkComboBox
4941  *
4942  * Returns the column with row span information for @combo_box.
4943  *
4944  * Returns: the row span column.
4945  *
4946  * Since: 2.6
4947  */
4948 gint
4949 gtk_combo_box_get_row_span_column (GtkComboBox *combo_box)
4950 {
4951   g_return_val_if_fail (GTK_IS_COMBO_BOX (combo_box), -1);
4952
4953   return combo_box->priv->row_column;
4954 }
4955
4956 /**
4957  * gtk_combo_box_set_row_span_column:
4958  * @combo_box: A #GtkComboBox.
4959  * @row_span: A column in the model passed during construction.
4960  *
4961  * Sets the column with row span information for @combo_box to be @row_span.
4962  * The row span column contains integers which indicate how many rows
4963  * an item should span.
4964  *
4965  * Since: 2.4
4966  */
4967 void
4968 gtk_combo_box_set_row_span_column (GtkComboBox *combo_box,
4969                                    gint         row_span)
4970 {
4971   GtkComboBoxPrivate *priv;
4972   gint col;
4973
4974   g_return_if_fail (GTK_IS_COMBO_BOX (combo_box));
4975
4976   priv = combo_box->priv;
4977
4978   col = gtk_tree_model_get_n_columns (priv->model);
4979   g_return_if_fail (row_span >= -1 && row_span < col);
4980
4981   if (row_span != priv->row_column)
4982     {
4983       priv->row_column = row_span;
4984
4985       gtk_combo_box_relayout (combo_box);
4986
4987       g_object_notify (G_OBJECT (combo_box), "row-span-column");
4988     }
4989 }
4990
4991 /**
4992  * gtk_combo_box_get_column_span_column:
4993  * @combo_box: A #GtkComboBox
4994  *
4995  * Returns the column with column span information for @combo_box.
4996  *
4997  * Returns: the column span column.
4998  *
4999  * Since: 2.6
5000  */
5001 gint
5002 gtk_combo_box_get_column_span_column (GtkComboBox *combo_box)
5003 {
5004   g_return_val_if_fail (GTK_IS_COMBO_BOX (combo_box), -1);
5005
5006   return combo_box->priv->col_column;
5007 }
5008
5009 /**
5010  * gtk_combo_box_set_column_span_column:
5011  * @combo_box: A #GtkComboBox
5012  * @column_span: A column in the model passed during construction
5013  *
5014  * Sets the column with column span information for @combo_box to be
5015  * @column_span. The column span column contains integers which indicate
5016  * how many columns an item should span.
5017  *
5018  * Since: 2.4
5019  */
5020 void
5021 gtk_combo_box_set_column_span_column (GtkComboBox *combo_box,
5022                                       gint         column_span)
5023 {
5024   GtkComboBoxPrivate *priv;
5025   gint col;
5026
5027   g_return_if_fail (GTK_IS_COMBO_BOX (combo_box));
5028
5029   priv = combo_box->priv;
5030
5031   col = gtk_tree_model_get_n_columns (priv->model);
5032   g_return_if_fail (column_span >= -1 && column_span < col);
5033
5034   if (column_span != priv->col_column)
5035     {
5036       priv->col_column = column_span;
5037
5038       gtk_combo_box_relayout (combo_box);
5039
5040       g_object_notify (G_OBJECT (combo_box), "column-span-column");
5041     }
5042 }
5043
5044 /**
5045  * gtk_combo_box_get_active:
5046  * @combo_box: A #GtkComboBox
5047  *
5048  * Returns the index of the currently active item, or -1 if there's no
5049  * active item. If the model is a non-flat treemodel, and the active item
5050  * is not an immediate child of the root of the tree, this function returns
5051  * <literal>gtk_tree_path_get_indices (path)[0]</literal>, where
5052  * <literal>path</literal> is the #GtkTreePath of the active item.
5053  *
5054  * Return value: An integer which is the index of the currently active item,
5055  *     or -1 if there's no active item.
5056  *
5057  * Since: 2.4
5058  */
5059 gint
5060 gtk_combo_box_get_active (GtkComboBox *combo_box)
5061 {
5062   GtkComboBoxPrivate *priv;
5063   gint result;
5064
5065   g_return_val_if_fail (GTK_IS_COMBO_BOX (combo_box), 0);
5066
5067   priv = combo_box->priv;
5068
5069   if (gtk_tree_row_reference_valid (priv->active_row))
5070     {
5071       GtkTreePath *path;
5072
5073       path = gtk_tree_row_reference_get_path (priv->active_row);
5074       result = gtk_tree_path_get_indices (path)[0];
5075       gtk_tree_path_free (path);
5076     }
5077   else
5078     result = -1;
5079
5080   return result;
5081 }
5082
5083 /**
5084  * gtk_combo_box_set_active:
5085  * @combo_box: A #GtkComboBox
5086  * @index_: An index in the model passed during construction, or -1 to have
5087  * no active item
5088  *
5089  * Sets the active item of @combo_box to be the item at @index.
5090  *
5091  * Since: 2.4
5092  */
5093 void
5094 gtk_combo_box_set_active (GtkComboBox *combo_box,
5095                           gint         index_)
5096 {
5097   GtkTreePath *path = NULL;
5098   g_return_if_fail (GTK_IS_COMBO_BOX (combo_box));
5099   g_return_if_fail (index_ >= -1);
5100
5101   if (combo_box->priv->model == NULL)
5102     {
5103       /* Save index, in case the model is set after the index */
5104       combo_box->priv->active = index_;
5105       if (index_ != -1)
5106         return;
5107     }
5108
5109   if (index_ != -1)
5110     path = gtk_tree_path_new_from_indices (index_, -1);
5111
5112   gtk_combo_box_set_active_internal (combo_box, path);
5113
5114   if (path)
5115     gtk_tree_path_free (path);
5116 }
5117
5118 static void
5119 gtk_combo_box_set_active_internal (GtkComboBox *combo_box,
5120                                    GtkTreePath *path)
5121 {
5122   GtkComboBoxPrivate *priv = combo_box->priv;
5123   GtkTreePath *active_path;
5124   gint path_cmp;
5125
5126   /* Remember whether the initially active row is valid. */
5127   gboolean is_valid_row_reference = gtk_tree_row_reference_valid (priv->active_row);
5128
5129   if (path && is_valid_row_reference)
5130     {
5131       active_path = gtk_tree_row_reference_get_path (priv->active_row);
5132       path_cmp = gtk_tree_path_compare (path, active_path);
5133       gtk_tree_path_free (active_path);
5134       if (path_cmp == 0)
5135         return;
5136     }
5137
5138   if (priv->active_row)
5139     {
5140       gtk_tree_row_reference_free (priv->active_row);
5141       priv->active_row = NULL;
5142     }
5143
5144   if (!path)
5145     {
5146       if (priv->tree_view)
5147         gtk_tree_selection_unselect_all (gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->tree_view)));
5148       else
5149         {
5150           GtkMenu *menu = GTK_MENU (priv->popup_widget);
5151
5152           if (GTK_IS_MENU (menu))
5153             gtk_menu_set_active (menu, -1);
5154         }
5155
5156       if (priv->cell_view)
5157         gtk_cell_view_set_displayed_row (GTK_CELL_VIEW (priv->cell_view), NULL);
5158
5159       /*
5160        *  Do not emit a "changed" signal when an already invalid selection was
5161        *  now set to invalid.
5162        */
5163       if (!is_valid_row_reference)
5164         return;
5165     }
5166   else
5167     {
5168       priv->active_row =
5169         gtk_tree_row_reference_new (priv->model, path);
5170
5171       if (priv->tree_view)
5172         {
5173           gtk_tree_view_set_cursor (GTK_TREE_VIEW (priv->tree_view),
5174                                     path, NULL, FALSE);
5175         }
5176       else if (GTK_IS_MENU (priv->popup_widget))
5177         {
5178           /* FIXME handle nested menus better */
5179           gtk_menu_set_active (GTK_MENU (priv->popup_widget),
5180                                gtk_tree_path_get_indices (path)[0]);
5181         }
5182
5183       if (priv->cell_view)
5184         gtk_cell_view_set_displayed_row (GTK_CELL_VIEW (priv->cell_view),
5185                                          path);
5186     }
5187
5188   g_signal_emit (combo_box, combo_box_signals[CHANGED], 0);
5189   g_object_notify (G_OBJECT (combo_box), "active");
5190 }
5191
5192
5193 /**
5194  * gtk_combo_box_get_active_iter:
5195  * @combo_box: A #GtkComboBox
5196  * @iter: (out): The uninitialized #GtkTreeIter
5197  *
5198  * Sets @iter to point to the current active item, if it exists.
5199  *
5200  * Return value: %TRUE, if @iter was set
5201  *
5202  * Since: 2.4
5203  */
5204 gboolean
5205 gtk_combo_box_get_active_iter (GtkComboBox     *combo_box,
5206                                GtkTreeIter     *iter)
5207 {
5208   GtkTreePath *path;
5209   gboolean result;
5210
5211   g_return_val_if_fail (GTK_IS_COMBO_BOX (combo_box), FALSE);
5212
5213   if (!gtk_tree_row_reference_valid (combo_box->priv->active_row))
5214     return FALSE;
5215
5216   path = gtk_tree_row_reference_get_path (combo_box->priv->active_row);
5217   result = gtk_tree_model_get_iter (combo_box->priv->model, iter, path);
5218   gtk_tree_path_free (path);
5219
5220   return result;
5221 }
5222
5223 /**
5224  * gtk_combo_box_set_active_iter:
5225  * @combo_box: A #GtkComboBox
5226  * @iter: (allow-none): The #GtkTreeIter, or %NULL
5227  *
5228  * Sets the current active item to be the one referenced by @iter, or
5229  * unsets the active item if @iter is %NULL.
5230  *
5231  * Since: 2.4
5232  */
5233 void
5234 gtk_combo_box_set_active_iter (GtkComboBox     *combo_box,
5235                                GtkTreeIter     *iter)
5236 {
5237   GtkTreePath *path = NULL;
5238
5239   g_return_if_fail (GTK_IS_COMBO_BOX (combo_box));
5240
5241   if (iter)
5242     path = gtk_tree_model_get_path (gtk_combo_box_get_model (combo_box), iter);
5243
5244   gtk_combo_box_set_active_internal (combo_box, path);
5245   gtk_tree_path_free (path);
5246 }
5247
5248 /**
5249  * gtk_combo_box_set_model:
5250  * @combo_box: A #GtkComboBox
5251  * @model: (allow-none): A #GtkTreeModel
5252  *
5253  * Sets the model used by @combo_box to be @model. Will unset a previously set
5254  * model (if applicable). If model is %NULL, then it will unset the model.
5255  *
5256  * Note that this function does not clear the cell renderers, you have to
5257  * call gtk_cell_layout_clear() yourself if you need to set up different
5258  * cell renderers for the new model.
5259  *
5260  * Since: 2.4
5261  */
5262 void
5263 gtk_combo_box_set_model (GtkComboBox  *combo_box,
5264                          GtkTreeModel *model)
5265 {
5266   g_return_if_fail (GTK_IS_COMBO_BOX (combo_box));
5267   g_return_if_fail (model == NULL || GTK_IS_TREE_MODEL (model));
5268
5269   if (model == combo_box->priv->model)
5270     return;
5271
5272   gtk_combo_box_unset_model (combo_box);
5273
5274   if (model == NULL)
5275     goto out;
5276
5277   combo_box->priv->model = model;
5278   g_object_ref (combo_box->priv->model);
5279
5280   combo_box->priv->inserted_id =
5281     g_signal_connect (combo_box->priv->model, "row-inserted",
5282                       G_CALLBACK (gtk_combo_box_model_row_inserted),
5283                       combo_box);
5284   combo_box->priv->deleted_id =
5285     g_signal_connect (combo_box->priv->model, "row-deleted",
5286                       G_CALLBACK (gtk_combo_box_model_row_deleted),
5287                       combo_box);
5288   combo_box->priv->reordered_id =
5289     g_signal_connect (combo_box->priv->model, "rows-reordered",
5290                       G_CALLBACK (gtk_combo_box_model_rows_reordered),
5291                       combo_box);
5292   combo_box->priv->changed_id =
5293     g_signal_connect (combo_box->priv->model, "row-changed",
5294                       G_CALLBACK (gtk_combo_box_model_row_changed),
5295                       combo_box);
5296
5297   if (combo_box->priv->tree_view)
5298     {
5299       /* list mode */
5300       gtk_tree_view_set_model (GTK_TREE_VIEW (combo_box->priv->tree_view),
5301                                combo_box->priv->model);
5302       gtk_combo_box_list_popup_resize (combo_box);
5303     }
5304   else
5305     {
5306       /* menu mode */
5307       if (combo_box->priv->popup_widget)
5308         gtk_combo_box_menu_fill (combo_box);
5309
5310     }
5311
5312   if (combo_box->priv->cell_view)
5313     gtk_cell_view_set_model (GTK_CELL_VIEW (combo_box->priv->cell_view),
5314                              combo_box->priv->model);
5315
5316   if (combo_box->priv->active != -1)
5317     {
5318       /* If an index was set in advance, apply it now */
5319       gtk_combo_box_set_active (combo_box, combo_box->priv->active);
5320       combo_box->priv->active = -1;
5321     }
5322
5323 out:
5324   gtk_combo_box_update_sensitivity (combo_box);
5325
5326   g_object_notify (G_OBJECT (combo_box), "model");
5327 }
5328
5329 /**
5330  * gtk_combo_box_get_model:
5331  * @combo_box: A #GtkComboBox
5332  *
5333  * Returns the #GtkTreeModel which is acting as data source for @combo_box.
5334  *
5335  * Return value: (transfer none): A #GtkTreeModel which was passed
5336  *     during construction.
5337  *
5338  * Since: 2.4
5339  */
5340 GtkTreeModel *
5341 gtk_combo_box_get_model (GtkComboBox *combo_box)
5342 {
5343   g_return_val_if_fail (GTK_IS_COMBO_BOX (combo_box), NULL);
5344
5345   return combo_box->priv->model;
5346 }
5347
5348 static void
5349 gtk_combo_box_real_move_active (GtkComboBox   *combo_box,
5350                                 GtkScrollType  scroll)
5351 {
5352   GtkTreeIter iter;
5353   GtkTreeIter new_iter;
5354   gboolean    active_iter;
5355   gboolean    found;
5356
5357   if (!combo_box->priv->model)
5358     {
5359       gtk_widget_error_bell (GTK_WIDGET (combo_box));
5360       return;
5361     }
5362
5363   active_iter = gtk_combo_box_get_active_iter (combo_box, &iter);
5364
5365   switch (scroll)
5366     {
5367     case GTK_SCROLL_STEP_BACKWARD:
5368     case GTK_SCROLL_STEP_UP:
5369     case GTK_SCROLL_STEP_LEFT:
5370       if (active_iter)
5371         {
5372           found = tree_prev (combo_box, combo_box->priv->model,
5373                              &iter, &new_iter, FALSE);
5374           break;
5375         }
5376       /* else fall through */
5377
5378     case GTK_SCROLL_PAGE_FORWARD:
5379     case GTK_SCROLL_PAGE_DOWN:
5380     case GTK_SCROLL_PAGE_RIGHT:
5381     case GTK_SCROLL_END:
5382       found = tree_last (combo_box, combo_box->priv->model, &new_iter, FALSE);
5383       break;
5384
5385     case GTK_SCROLL_STEP_FORWARD:
5386     case GTK_SCROLL_STEP_DOWN:
5387     case GTK_SCROLL_STEP_RIGHT:
5388       if (active_iter)
5389         {
5390           found = tree_next (combo_box, combo_box->priv->model,
5391                              &iter, &new_iter, FALSE);
5392           break;
5393         }
5394       /* else fall through */
5395
5396     case GTK_SCROLL_PAGE_BACKWARD:
5397     case GTK_SCROLL_PAGE_UP:
5398     case GTK_SCROLL_PAGE_LEFT:
5399     case GTK_SCROLL_START:
5400       found = tree_first (combo_box, combo_box->priv->model, &new_iter, FALSE);
5401       break;
5402
5403     default:
5404       return;
5405     }
5406
5407   if (found && active_iter)
5408     {
5409       GtkTreePath *old_path;
5410       GtkTreePath *new_path;
5411
5412       old_path = gtk_tree_model_get_path (combo_box->priv->model, &iter);
5413       new_path = gtk_tree_model_get_path (combo_box->priv->model, &new_iter);
5414
5415       if (gtk_tree_path_compare (old_path, new_path) == 0)
5416         found = FALSE;
5417
5418       gtk_tree_path_free (old_path);
5419       gtk_tree_path_free (new_path);
5420     }
5421
5422   if (found)
5423     {
5424       gtk_combo_box_set_active_iter (combo_box, &new_iter);
5425     }
5426   else
5427     {
5428       gtk_widget_error_bell (GTK_WIDGET (combo_box));
5429     }
5430 }
5431
5432 static gboolean
5433 gtk_combo_box_mnemonic_activate (GtkWidget *widget,
5434                                  gboolean   group_cycling)
5435 {
5436   GtkComboBox *combo_box = GTK_COMBO_BOX (widget);
5437
5438   if (combo_box->priv->has_entry)
5439     {
5440       GtkWidget* child;
5441
5442       child = gtk_bin_get_child (GTK_BIN (combo_box));
5443       if (child)
5444         gtk_widget_grab_focus (child);
5445     }
5446   else
5447     gtk_widget_grab_focus (combo_box->priv->button);
5448
5449   return TRUE;
5450 }
5451
5452 static void
5453 gtk_combo_box_grab_focus (GtkWidget *widget)
5454 {
5455   GtkComboBox *combo_box = GTK_COMBO_BOX (widget);
5456
5457   if (combo_box->priv->has_entry)
5458     {
5459       GtkWidget *child;
5460
5461       child = gtk_bin_get_child (GTK_BIN (combo_box));
5462       if (child)
5463         gtk_widget_grab_focus (child);
5464     }
5465   else
5466     gtk_widget_grab_focus (combo_box->priv->button);
5467 }
5468
5469 static void
5470 gtk_combo_box_destroy (GtkWidget *widget)
5471 {
5472   GtkComboBox *combo_box = GTK_COMBO_BOX (widget);
5473
5474   if (combo_box->priv->popup_idle_id > 0)
5475     {
5476       g_source_remove (combo_box->priv->popup_idle_id);
5477       combo_box->priv->popup_idle_id = 0;
5478     }
5479
5480   gtk_combo_box_popdown (combo_box);
5481
5482   if (combo_box->priv->row_separator_destroy)
5483     combo_box->priv->row_separator_destroy (combo_box->priv->row_separator_data);
5484
5485   combo_box->priv->row_separator_func = NULL;
5486   combo_box->priv->row_separator_data = NULL;
5487   combo_box->priv->row_separator_destroy = NULL;
5488
5489   GTK_WIDGET_CLASS (gtk_combo_box_parent_class)->destroy (widget);
5490   combo_box->priv->cell_view = NULL;
5491 }
5492
5493 static void
5494 gtk_combo_box_entry_contents_changed (GtkEntry *entry,
5495                                       gpointer  user_data)
5496 {
5497   GtkComboBox *combo_box = GTK_COMBO_BOX (user_data);
5498
5499   /*
5500    *  Fixes regression reported in bug #574059. The old functionality relied on
5501    *  bug #572478.  As a bugfix, we now emit the "changed" signal ourselves
5502    *  when the selection was already set to -1.
5503    */
5504   if (gtk_combo_box_get_active(combo_box) == -1)
5505     g_signal_emit_by_name (combo_box, "changed");
5506   else
5507     gtk_combo_box_set_active (combo_box, -1);
5508 }
5509
5510 static void
5511 gtk_combo_box_entry_active_changed (GtkComboBox *combo_box,
5512                                     gpointer     user_data)
5513 {
5514   GtkComboBoxPrivate *priv = combo_box->priv;
5515   GtkTreeModel *model;
5516   GtkTreeIter iter;
5517
5518   if (gtk_combo_box_get_active_iter (combo_box, &iter))
5519     {
5520       GtkEntry *entry = GTK_ENTRY (gtk_bin_get_child (GTK_BIN (combo_box)));
5521
5522       if (entry)
5523         {
5524           GValue value = {0,};
5525
5526           g_signal_handlers_block_by_func (entry,
5527                                            gtk_combo_box_entry_contents_changed,
5528                                            combo_box);
5529
5530           model = gtk_combo_box_get_model (combo_box);
5531
5532           gtk_tree_model_get_value (model, &iter,
5533                                     priv->text_column, &value);
5534           g_object_set_property (G_OBJECT (entry), "text", &value);
5535           g_value_unset (&value);
5536
5537           g_signal_handlers_unblock_by_func (entry,
5538                                              gtk_combo_box_entry_contents_changed,
5539                                              combo_box);
5540         }
5541     }
5542 }
5543
5544 static GObject *
5545 gtk_combo_box_constructor (GType                  type,
5546                            guint                  n_construct_properties,
5547                            GObjectConstructParam *construct_properties)
5548 {
5549   GObject            *object;
5550   GtkComboBox        *combo_box;
5551   GtkComboBoxPrivate *priv;
5552
5553   object = G_OBJECT_CLASS (gtk_combo_box_parent_class)->constructor
5554     (type, n_construct_properties, construct_properties);
5555
5556   combo_box = GTK_COMBO_BOX (object);
5557   priv      = combo_box->priv;
5558
5559   if (priv->has_entry)
5560     {
5561       GtkWidget *entry;
5562
5563       entry = gtk_entry_new ();
5564       gtk_widget_show (entry);
5565       gtk_container_add (GTK_CONTAINER (combo_box), entry);
5566
5567       priv->text_renderer = gtk_cell_renderer_text_new ();
5568       gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box),
5569                                   priv->text_renderer, TRUE);
5570
5571       gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), -1);
5572
5573       g_signal_connect (combo_box, "changed",
5574                         G_CALLBACK (gtk_combo_box_entry_active_changed), NULL);
5575     }
5576
5577   return object;
5578 }
5579
5580
5581 static void
5582 gtk_combo_box_dispose(GObject* object)
5583 {
5584   GtkComboBox *combo_box = GTK_COMBO_BOX (object);
5585
5586   if (GTK_IS_MENU (combo_box->priv->popup_widget))
5587     {
5588       gtk_combo_box_menu_destroy (combo_box);
5589       gtk_menu_detach (GTK_MENU (combo_box->priv->popup_widget));
5590       combo_box->priv->popup_widget = NULL;
5591     }
5592
5593   G_OBJECT_CLASS (gtk_combo_box_parent_class)->dispose (object);
5594 }
5595
5596 static void
5597 gtk_combo_box_finalize (GObject *object)
5598 {
5599   GtkComboBox *combo_box = GTK_COMBO_BOX (object);
5600   GSList *i;
5601
5602   if (GTK_IS_TREE_VIEW (combo_box->priv->tree_view))
5603     gtk_combo_box_list_destroy (combo_box);
5604
5605   if (combo_box->priv->popup_window)
5606     gtk_widget_destroy (combo_box->priv->popup_window);
5607
5608   gtk_combo_box_unset_model (combo_box);
5609
5610   for (i = combo_box->priv->cells; i; i = i->next)
5611     {
5612       ComboCellInfo *info = (ComboCellInfo *)i->data;
5613       GSList *list = info->attributes;
5614
5615       if (info->destroy)
5616         info->destroy (info->func_data);
5617
5618       while (list && list->next)
5619         {
5620           g_free (list->data);
5621           list = list->next->next;
5622         }
5623       g_slist_free (info->attributes);
5624
5625       g_object_unref (info->cell);
5626       g_slice_free (ComboCellInfo, info);
5627     }
5628    g_slist_free (combo_box->priv->cells);
5629
5630    g_free (combo_box->priv->tearoff_title);
5631
5632    G_OBJECT_CLASS (gtk_combo_box_parent_class)->finalize (object);
5633 }
5634
5635
5636 static gboolean
5637 gtk_cell_editable_key_press (GtkWidget   *widget,
5638                              GdkEventKey *event,
5639                              gpointer     data)
5640 {
5641   GtkComboBox *combo_box = GTK_COMBO_BOX (data);
5642
5643   if (event->keyval == GDK_KEY_Escape)
5644     {
5645       g_object_set (combo_box,
5646                     "editing-canceled", TRUE,
5647                     NULL);
5648       gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (combo_box));
5649       gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (combo_box));
5650
5651       return TRUE;
5652     }
5653   else if (event->keyval == GDK_KEY_Return ||
5654            event->keyval == GDK_KEY_ISO_Enter ||
5655            event->keyval == GDK_KEY_KP_Enter)
5656     {
5657       gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (combo_box));
5658       gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (combo_box));
5659
5660       return TRUE;
5661     }
5662
5663   return FALSE;
5664 }
5665
5666 static gboolean
5667 popdown_idle (gpointer data)
5668 {
5669   GtkComboBox *combo_box;
5670
5671   combo_box = GTK_COMBO_BOX (data);
5672
5673   gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (combo_box));
5674   gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (combo_box));
5675
5676   g_object_unref (combo_box);
5677
5678   return FALSE;
5679 }
5680
5681 static void
5682 popdown_handler (GtkWidget *widget,
5683                  gpointer   data)
5684 {
5685   gdk_threads_add_idle (popdown_idle, g_object_ref (data));
5686 }
5687
5688 static gboolean
5689 popup_idle (gpointer data)
5690 {
5691   GtkComboBox *combo_box;
5692
5693   combo_box = GTK_COMBO_BOX (data);
5694
5695   if (GTK_IS_MENU (combo_box->priv->popup_widget) &&
5696       combo_box->priv->cell_view)
5697     g_signal_connect_object (combo_box->priv->popup_widget,
5698                              "unmap", G_CALLBACK (popdown_handler),
5699                              combo_box, 0);
5700
5701   /* we unset this if a menu item is activated */
5702   g_object_set (combo_box,
5703                 "editing-canceled", TRUE,
5704                 NULL);
5705   gtk_combo_box_popup (combo_box);
5706
5707   combo_box->priv->popup_idle_id = 0;
5708   combo_box->priv->activate_button = 0;
5709   combo_box->priv->activate_time = 0;
5710
5711   return FALSE;
5712 }
5713
5714 static void
5715 gtk_combo_box_start_editing (GtkCellEditable *cell_editable,
5716                              GdkEvent        *event)
5717 {
5718   GtkComboBox *combo_box = GTK_COMBO_BOX (cell_editable);
5719   GtkWidget *child;
5720
5721   combo_box->priv->is_cell_renderer = TRUE;
5722
5723   if (combo_box->priv->cell_view)
5724     {
5725       g_signal_connect_object (combo_box->priv->button, "key-press-event",
5726                                G_CALLBACK (gtk_cell_editable_key_press),
5727                                cell_editable, 0);
5728
5729       gtk_widget_grab_focus (combo_box->priv->button);
5730     }
5731   else
5732     {
5733       child = gtk_bin_get_child (GTK_BIN (combo_box));
5734
5735       g_signal_connect_object (child, "key-press-event",
5736                                G_CALLBACK (gtk_cell_editable_key_press),
5737                                cell_editable, 0);
5738
5739       gtk_widget_grab_focus (child);
5740       gtk_widget_set_can_focus (combo_box->priv->button, FALSE);
5741     }
5742
5743   /* we do the immediate popup only for the optionmenu-like
5744    * appearance
5745    */
5746   if (combo_box->priv->is_cell_renderer &&
5747       combo_box->priv->cell_view && !combo_box->priv->tree_view)
5748     {
5749       if (event && event->type == GDK_BUTTON_PRESS)
5750         {
5751           GdkEventButton *event_button = (GdkEventButton *)event;
5752
5753           combo_box->priv->activate_button = event_button->button;
5754           combo_box->priv->activate_time = event_button->time;
5755         }
5756
5757       combo_box->priv->popup_idle_id =
5758           gdk_threads_add_idle (popup_idle, combo_box);
5759     }
5760 }
5761
5762
5763 /**
5764  * gtk_combo_box_get_add_tearoffs:
5765  * @combo_box: a #GtkComboBox
5766  *
5767  * Gets the current value of the :add-tearoffs property.
5768  *
5769  * Return value: the current value of the :add-tearoffs property.
5770  */
5771 gboolean
5772 gtk_combo_box_get_add_tearoffs (GtkComboBox *combo_box)
5773 {
5774   g_return_val_if_fail (GTK_IS_COMBO_BOX (combo_box), FALSE);
5775
5776   return combo_box->priv->add_tearoffs;
5777 }
5778
5779 /**
5780  * gtk_combo_box_set_add_tearoffs:
5781  * @combo_box: a #GtkComboBox
5782  * @add_tearoffs: %TRUE to add tearoff menu items
5783  *
5784  * Sets whether the popup menu should have a tearoff
5785  * menu item.
5786  *
5787  * Since: 2.6
5788  */
5789 void
5790 gtk_combo_box_set_add_tearoffs (GtkComboBox *combo_box,
5791                                 gboolean     add_tearoffs)
5792 {
5793   g_return_if_fail (GTK_IS_COMBO_BOX (combo_box));
5794
5795   add_tearoffs = add_tearoffs != FALSE;
5796
5797   if (combo_box->priv->add_tearoffs != add_tearoffs)
5798     {
5799       combo_box->priv->add_tearoffs = add_tearoffs;
5800       gtk_combo_box_check_appearance (combo_box);
5801       gtk_combo_box_relayout (combo_box);
5802       g_object_notify (G_OBJECT (combo_box), "add-tearoffs");
5803     }
5804 }
5805
5806 /**
5807  * gtk_combo_box_get_title:
5808  * @combo_box: a #GtkComboBox
5809  *
5810  * Gets the current title of the menu in tearoff mode. See
5811  * gtk_combo_box_set_add_tearoffs().
5812  *
5813  * Returns: the menu's title in tearoff mode. This is an internal copy of the
5814  * string which must not be freed.
5815  *
5816  * Since: 2.10
5817  */
5818 G_CONST_RETURN gchar*
5819 gtk_combo_box_get_title (GtkComboBox *combo_box)
5820 {
5821   g_return_val_if_fail (GTK_IS_COMBO_BOX (combo_box), NULL);
5822
5823   return combo_box->priv->tearoff_title;
5824 }
5825
5826 static void
5827 gtk_combo_box_update_title (GtkComboBox *combo_box)
5828 {
5829   gtk_combo_box_check_appearance (combo_box);
5830
5831   if (combo_box->priv->popup_widget &&
5832       GTK_IS_MENU (combo_box->priv->popup_widget))
5833     gtk_menu_set_title (GTK_MENU (combo_box->priv->popup_widget),
5834                         combo_box->priv->tearoff_title);
5835 }
5836
5837 /**
5838  * gtk_combo_box_set_title:
5839  * @combo_box: a #GtkComboBox
5840  * @title: a title for the menu in tearoff mode
5841  *
5842  * Sets the menu's title in tearoff mode.
5843  *
5844  * Since: 2.10
5845  */
5846 void
5847 gtk_combo_box_set_title (GtkComboBox *combo_box,
5848                          const gchar *title)
5849 {
5850   GtkComboBoxPrivate *priv;
5851
5852   g_return_if_fail (GTK_IS_COMBO_BOX (combo_box));
5853
5854   priv = combo_box->priv;
5855
5856   if (strcmp (title ? title : "",
5857               priv->tearoff_title ? priv->tearoff_title : "") != 0)
5858     {
5859       g_free (priv->tearoff_title);
5860       priv->tearoff_title = g_strdup (title);
5861
5862       gtk_combo_box_update_title (combo_box);
5863
5864       g_object_notify (G_OBJECT (combo_box), "tearoff-title");
5865     }
5866 }
5867
5868
5869 /**
5870  * gtk_combo_box_set_popup_fixed_width:
5871  * @combo_box: a #GtkComboBox
5872  * @fixed: whether to use a fixed popup width
5873  *
5874  * Specifies whether the popup's width should be a fixed width matching
5875  * the allocated width of the combo box.
5876  *
5877  * Since: 3.0
5878  **/
5879 void
5880 gtk_combo_box_set_popup_fixed_width (GtkComboBox *combo_box,
5881                                      gboolean     fixed)
5882 {
5883   g_return_if_fail (GTK_IS_COMBO_BOX (combo_box));
5884
5885   if (combo_box->priv->popup_fixed_width != fixed)
5886     {
5887       combo_box->priv->popup_fixed_width = fixed;
5888
5889       g_object_notify (G_OBJECT (combo_box), "popup-fixed-width");
5890     }
5891 }
5892
5893 /**
5894  * gtk_combo_box_get_popup_fixed_width:
5895  * @combo_box: a #GtkComboBox
5896  *
5897  * Gets whether the popup uses a fixed width matching
5898  * the allocated width of the combo box.
5899  *
5900  * Since: 3.0
5901  **/
5902 gboolean
5903 gtk_combo_box_get_popup_fixed_width (GtkComboBox *combo_box)
5904 {
5905   g_return_val_if_fail (GTK_IS_COMBO_BOX (combo_box), FALSE);
5906
5907   return combo_box->priv->popup_fixed_width;
5908 }
5909
5910
5911 /**
5912  * gtk_combo_box_get_popup_accessible:
5913  * @combo_box: a #GtkComboBox
5914  *
5915  * Gets the accessible object corresponding to the combo box's popup.
5916  *
5917  * This function is mostly intended for use by accessibility technologies;
5918  * applications should have little use for it.
5919  *
5920  * Returns: (transfer none): the accessible object corresponding
5921  *     to the combo box's popup.
5922  *
5923  * Since: 2.6
5924  */
5925 AtkObject*
5926 gtk_combo_box_get_popup_accessible (GtkComboBox *combo_box)
5927 {
5928   AtkObject *atk_obj;
5929
5930   g_return_val_if_fail (GTK_IS_COMBO_BOX (combo_box), NULL);
5931
5932   if (combo_box->priv->popup_widget)
5933     {
5934       atk_obj = gtk_widget_get_accessible (combo_box->priv->popup_widget);
5935       return atk_obj;
5936     }
5937
5938   return NULL;
5939 }
5940
5941 /**
5942  * gtk_combo_box_get_row_separator_func:
5943  * @combo_box: a #GtkComboBox
5944  *
5945  * Returns the current row separator function.
5946  *
5947  * Return value: the current row separator function.
5948  *
5949  * Since: 2.6
5950  */
5951 GtkTreeViewRowSeparatorFunc
5952 gtk_combo_box_get_row_separator_func (GtkComboBox *combo_box)
5953 {
5954   g_return_val_if_fail (GTK_IS_COMBO_BOX (combo_box), NULL);
5955
5956   return combo_box->priv->row_separator_func;
5957 }
5958
5959 /**
5960  * gtk_combo_box_set_row_separator_func:
5961  * @combo_box: a #GtkComboBox
5962  * @func: a #GtkTreeViewRowSeparatorFunc
5963  * @data: (allow-none): user data to pass to @func, or %NULL
5964  * @destroy: (allow-none): destroy notifier for @data, or %NULL
5965  *
5966  * Sets the row separator function, which is used to determine
5967  * whether a row should be drawn as a separator. If the row separator
5968  * function is %NULL, no separators are drawn. This is the default value.
5969  *
5970  * Since: 2.6
5971  */
5972 void
5973 gtk_combo_box_set_row_separator_func (GtkComboBox                 *combo_box,
5974                                       GtkTreeViewRowSeparatorFunc  func,
5975                                       gpointer                     data,
5976                                       GDestroyNotify               destroy)
5977 {
5978   g_return_if_fail (GTK_IS_COMBO_BOX (combo_box));
5979
5980   if (combo_box->priv->row_separator_destroy)
5981     combo_box->priv->row_separator_destroy (combo_box->priv->row_separator_data);
5982
5983   combo_box->priv->row_separator_func = func;
5984   combo_box->priv->row_separator_data = data;
5985   combo_box->priv->row_separator_destroy = destroy;
5986
5987   if (combo_box->priv->tree_view)
5988     gtk_tree_view_set_row_separator_func (GTK_TREE_VIEW (combo_box->priv->tree_view),
5989                                           func, data, NULL);
5990
5991   gtk_combo_box_relayout (combo_box);
5992
5993   gtk_widget_queue_draw (GTK_WIDGET (combo_box));
5994 }
5995
5996 /**
5997  * gtk_combo_box_set_button_sensitivity:
5998  * @combo_box: a #GtkComboBox
5999  * @sensitivity: specify the sensitivity of the dropdown button
6000  *
6001  * Sets whether the dropdown button of the combo box should be
6002  * always sensitive (%GTK_SENSITIVITY_ON), never sensitive (%GTK_SENSITIVITY_OFF)
6003  * or only if there is at least one item to display (%GTK_SENSITIVITY_AUTO).
6004  *
6005  * Since: 2.14
6006  **/
6007 void
6008 gtk_combo_box_set_button_sensitivity (GtkComboBox        *combo_box,
6009                                       GtkSensitivityType  sensitivity)
6010 {
6011   g_return_if_fail (GTK_IS_COMBO_BOX (combo_box));
6012
6013   if (combo_box->priv->button_sensitivity != sensitivity)
6014     {
6015       combo_box->priv->button_sensitivity = sensitivity;
6016       gtk_combo_box_update_sensitivity (combo_box);
6017
6018       g_object_notify (G_OBJECT (combo_box), "button-sensitivity");
6019     }
6020 }
6021
6022 /**
6023  * gtk_combo_box_get_button_sensitivity:
6024  * @combo_box: a #GtkComboBox
6025  *
6026  * Returns whether the combo box sets the dropdown button
6027  * sensitive or not when there are no items in the model.
6028  *
6029  * Return Value: %GTK_SENSITIVITY_ON if the dropdown button
6030  *    is sensitive when the model is empty, %GTK_SENSITIVITY_OFF
6031  *    if the button is always insensitive or
6032  *    %GTK_SENSITIVITY_AUTO if it is only sensitive as long as
6033  *    the model has one item to be selected.
6034  *
6035  * Since: 2.14
6036  **/
6037 GtkSensitivityType
6038 gtk_combo_box_get_button_sensitivity (GtkComboBox *combo_box)
6039 {
6040   g_return_val_if_fail (GTK_IS_COMBO_BOX (combo_box), FALSE);
6041
6042   return combo_box->priv->button_sensitivity;
6043 }
6044
6045
6046 /**
6047  * gtk_combo_box_get_has_entry:
6048  * @combo_box: a #GtkComboBox
6049  *
6050  * Returns whether the combo box has an entry.
6051  *
6052  * Return Value: whether there is an entry in @combo_box.
6053  *
6054  * Since: 2.24
6055  **/
6056 gboolean
6057 gtk_combo_box_get_has_entry (GtkComboBox *combo_box)
6058 {
6059   g_return_val_if_fail (GTK_IS_COMBO_BOX (combo_box), FALSE);
6060
6061   return combo_box->priv->has_entry;
6062 }
6063
6064 /**
6065  * gtk_combo_box_set_entry_text_column:
6066  * @combo_box: A #GtkComboBox
6067  * @text_column: A column in @model to get the strings from for
6068  *     the internal entry
6069  *
6070  * Sets the model column which @combo_box should use to get strings from
6071  * to be @text_column. The column @text_column in the model of @combo_box
6072  * must be of type %G_TYPE_STRING.
6073  *
6074  * This is only relevant if @combo_box has been created with
6075  * #GtkComboBox:has-entry as %TRUE.
6076  *
6077  * Since: 2.24
6078  */
6079 void
6080 gtk_combo_box_set_entry_text_column (GtkComboBox *combo_box,
6081                                      gint         text_column)
6082 {
6083   GtkComboBoxPrivate *priv = combo_box->priv;
6084   GtkTreeModel *model;
6085
6086   g_return_if_fail (GTK_IS_COMBO_BOX (combo_box));
6087
6088   model = gtk_combo_box_get_model (combo_box);
6089
6090   g_return_if_fail (text_column >= 0);
6091   g_return_if_fail (model == NULL || text_column < gtk_tree_model_get_n_columns (model));
6092
6093   priv->text_column = text_column;
6094
6095   if (priv->text_renderer != NULL)
6096     gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box),
6097                                     priv->text_renderer,
6098                                     "text", text_column,
6099                                     NULL);
6100 }
6101
6102 /**
6103  * gtk_combo_box_get_entry_text_column:
6104  * @combo_box: A #GtkComboBox.
6105  *
6106  * Returns the column which @combo_box is using to get the strings
6107  * from to display in the internal entry.
6108  *
6109  * Return value: A column in the data source model of @combo_box.
6110  *
6111  * Since: 2.24
6112  */
6113 gint
6114 gtk_combo_box_get_entry_text_column (GtkComboBox *combo_box)
6115 {
6116   g_return_val_if_fail (GTK_IS_COMBO_BOX (combo_box), 0);
6117
6118   return combo_box->priv->text_column;
6119 }
6120
6121 /**
6122  * gtk_combo_box_set_focus_on_click:
6123  * @combo: a #GtkComboBox
6124  * @focus_on_click: whether the combo box grabs focus when clicked
6125  *    with the mouse
6126  *
6127  * Sets whether the combo box will grab focus when it is clicked with
6128  * the mouse. Making mouse clicks not grab focus is useful in places
6129  * like toolbars where you don't want the keyboard focus removed from
6130  * the main area of the application.
6131  *
6132  * Since: 2.6
6133  */
6134 void
6135 gtk_combo_box_set_focus_on_click (GtkComboBox *combo_box,
6136                                   gboolean     focus_on_click)
6137 {
6138   g_return_if_fail (GTK_IS_COMBO_BOX (combo_box));
6139
6140   focus_on_click = focus_on_click != FALSE;
6141
6142   if (combo_box->priv->focus_on_click != focus_on_click)
6143     {
6144       combo_box->priv->focus_on_click = focus_on_click;
6145
6146       if (combo_box->priv->button)
6147         gtk_button_set_focus_on_click (GTK_BUTTON (combo_box->priv->button),
6148                                        focus_on_click);
6149
6150       g_object_notify (G_OBJECT (combo_box), "focus-on-click");
6151     }
6152 }
6153
6154 /**
6155  * gtk_combo_box_get_focus_on_click:
6156  * @combo: a #GtkComboBox
6157  *
6158  * Returns whether the combo box grabs focus when it is clicked
6159  * with the mouse. See gtk_combo_box_set_focus_on_click().
6160  *
6161  * Return value: %TRUE if the combo box grabs focus when it is
6162  *     clicked with the mouse.
6163  *
6164  * Since: 2.6
6165  */
6166 gboolean
6167 gtk_combo_box_get_focus_on_click (GtkComboBox *combo_box)
6168 {
6169   g_return_val_if_fail (GTK_IS_COMBO_BOX (combo_box), FALSE);
6170
6171   return combo_box->priv->focus_on_click;
6172 }
6173
6174
6175 static gboolean
6176 gtk_combo_box_buildable_custom_tag_start (GtkBuildable  *buildable,
6177                                           GtkBuilder    *builder,
6178                                           GObject       *child,
6179                                           const gchar   *tagname,
6180                                           GMarkupParser *parser,
6181                                           gpointer      *data)
6182 {
6183   if (parent_buildable_iface->custom_tag_start (buildable, builder, child,
6184                                                 tagname, parser, data))
6185     return TRUE;
6186
6187   return _gtk_cell_layout_buildable_custom_tag_start (buildable, builder, child,
6188                                                       tagname, parser, data);
6189 }
6190
6191 static void
6192 gtk_combo_box_buildable_custom_tag_end (GtkBuildable *buildable,
6193                                         GtkBuilder   *builder,
6194                                         GObject      *child,
6195                                         const gchar  *tagname,
6196                                         gpointer     *data)
6197 {
6198   if (strcmp (tagname, "attributes") == 0)
6199     _gtk_cell_layout_buildable_custom_tag_end (buildable, builder, child, tagname,
6200                                                data);
6201   else
6202     parent_buildable_iface->custom_tag_end (buildable, builder, child, tagname,
6203                                             data);
6204 }
6205
6206 static GObject *
6207 gtk_combo_box_buildable_get_internal_child (GtkBuildable *buildable,
6208                                             GtkBuilder   *builder,
6209                                             const gchar  *childname)
6210 {
6211   GtkComboBox *combo_box = GTK_COMBO_BOX (buildable);
6212
6213   if (combo_box->priv->has_entry && strcmp (childname, "entry") == 0)
6214     return G_OBJECT (gtk_bin_get_child (GTK_BIN (buildable)));
6215
6216   return parent_buildable_iface->get_internal_child (buildable, builder, childname);
6217 }
6218
6219 static void
6220 gtk_combo_box_remeasure (GtkComboBox *combo_box)
6221 {
6222   GtkComboBoxPrivate *priv = combo_box->priv;
6223   GtkTreeIter iter;
6224   GtkTreePath *path;
6225
6226   if (!priv->model ||
6227       !gtk_tree_model_get_iter_first (priv->model, &iter))
6228     return;
6229
6230   priv->minimum_width = priv->natural_width = 0;
6231
6232   path = gtk_tree_path_new_from_indices (0, -1);
6233
6234   do
6235     {
6236       gint row_min = 0, row_nat = 0;
6237
6238       if (priv->cell_view)
6239         gtk_cell_view_get_desired_width_of_row (GTK_CELL_VIEW (priv->cell_view),
6240                                                 path, &row_min, &row_nat);
6241
6242       priv->minimum_width = MAX (priv->minimum_width, row_min);
6243       priv->natural_width = MAX (priv->natural_width, row_nat);
6244
6245       gtk_tree_path_next (path);
6246     }
6247   while (gtk_tree_model_iter_next (priv->model, &iter));
6248
6249   gtk_tree_path_free (path);
6250 }
6251
6252
6253 static void
6254 gtk_combo_box_measure_height_for_width (GtkComboBox *combo_box,
6255                                         gint         avail_width,
6256                                         gint        *min_height,
6257                                         gint        *nat_height)
6258 {
6259   GtkWidget             *child;
6260   GtkComboBoxPrivate    *priv = combo_box->priv;
6261   GtkTreeIter            iter;
6262   GtkTreePath           *path;
6263   gint                   child_min, child_nat;
6264
6265   child = gtk_bin_get_child (GTK_BIN (combo_box));
6266
6267   gtk_widget_get_preferred_height_for_width (child, avail_width,
6268                                              &child_min, &child_nat);
6269
6270   if (!priv->model ||
6271       !gtk_tree_model_get_iter_first (priv->model, &iter))
6272     goto out;
6273
6274   path = gtk_tree_path_new_from_indices (0, -1);
6275
6276   do
6277     {
6278       gint row_min = 0, row_nat = 0;
6279
6280       if (priv->cell_view)
6281         gtk_cell_view_get_desired_height_for_width_of_row (GTK_CELL_VIEW (priv->cell_view),
6282                                                            path, avail_width,
6283                                                            &row_min, &row_nat);
6284
6285       child_min = MAX (child_min, row_min);
6286       child_nat = MAX (child_nat, row_nat);
6287
6288       gtk_tree_path_next (path);
6289     }
6290   while (gtk_tree_model_iter_next (priv->model, &iter));
6291
6292   gtk_tree_path_free (path);
6293
6294  out:
6295
6296   if (min_height)
6297     *min_height = child_min;
6298   if (nat_height)
6299     *nat_height = child_nat;
6300 }
6301
6302
6303 static void
6304 gtk_combo_box_get_preferred_width (GtkWidget *widget,
6305                                    gint      *minimum_size,
6306                                    gint      *natural_size)
6307 {
6308   GtkComboBox           *combo_box = GTK_COMBO_BOX (widget);
6309   GtkComboBoxPrivate    *priv = combo_box->priv;
6310   GtkStyle              *style;
6311   gint                   focus_width, focus_pad;
6312   gint                   font_size, arrow_size;
6313   PangoContext          *context;
6314   PangoFontMetrics      *metrics;
6315   PangoFontDescription  *font_desc;
6316   GtkWidget             *child;
6317   gint                   minimum_width, natural_width;
6318   gint                   child_min, child_nat;
6319
6320   child = gtk_bin_get_child (GTK_BIN (widget));
6321
6322   /* common */
6323   gtk_widget_get_preferred_width (child, &child_min, &child_nat);
6324   gtk_combo_box_remeasure (combo_box);
6325
6326   child_min  = MAX (child_min,  priv->minimum_width);
6327   child_nat  = MAX (child_nat,  priv->natural_width);
6328
6329   gtk_widget_style_get (GTK_WIDGET (widget),
6330                         "focus-line-width", &focus_width,
6331                         "focus-padding", &focus_pad,
6332                         "arrow-size", &arrow_size,
6333                         NULL);
6334
6335   font_desc = gtk_widget_get_style (child)->font_desc;
6336   context = gtk_widget_get_pango_context (GTK_WIDGET (widget));
6337   metrics = pango_context_get_metrics (context, font_desc,
6338                                        pango_context_get_language (context));
6339   font_size = PANGO_PIXELS (pango_font_metrics_get_ascent (metrics) +
6340                             pango_font_metrics_get_descent (metrics));
6341   pango_font_metrics_unref (metrics);
6342
6343   arrow_size = MAX (arrow_size, font_size);
6344
6345   gtk_widget_set_size_request (priv->arrow, arrow_size, arrow_size);
6346
6347   if (!priv->tree_view)
6348     {
6349       /* menu mode */
6350
6351       if (priv->cell_view)
6352         {
6353           gint sep_width, arrow_width;
6354           gint border_width, xthickness, xpad;
6355
6356           border_width = gtk_container_get_border_width (GTK_CONTAINER (combo_box));
6357           xthickness   = gtk_widget_get_style (priv->button)->xthickness;
6358
6359           gtk_widget_get_preferred_width (priv->separator, &sep_width, NULL);
6360           gtk_widget_get_preferred_width (priv->arrow, &arrow_width, NULL);
6361
6362           xpad = 2*(border_width + xthickness + focus_width + focus_pad);
6363
6364           minimum_width  = child_min + sep_width + arrow_width + xpad;
6365           natural_width  = child_nat + sep_width + arrow_width + xpad;
6366         }
6367       else
6368         {
6369           gint but_width, but_nat_width;
6370
6371           gtk_widget_get_preferred_width (priv->button,
6372                                           &but_width, &but_nat_width);
6373
6374           minimum_width  = child_min + but_width;
6375           natural_width  = child_nat + but_nat_width;
6376         }
6377     }
6378   else
6379     {
6380       /* list mode */
6381       gint button_width, button_nat_width;
6382
6383       /* sample + frame */
6384       minimum_width = child_min;
6385       natural_width = child_nat;
6386
6387       minimum_width += 2 * focus_width;
6388       natural_width += 2 * focus_width;
6389
6390       if (priv->cell_view_frame)
6391         {
6392           if (priv->has_frame)
6393             {
6394               gint border_width = gtk_container_get_border_width (GTK_CONTAINER (priv->cell_view_frame));
6395               gint xpad         = 2 * (border_width + gtk_widget_get_style (GTK_WIDGET (priv->cell_view_frame))->xthickness);
6396
6397               minimum_width  += xpad;
6398               natural_width  += xpad;
6399             }
6400         }
6401
6402       /* the button */
6403       gtk_widget_get_preferred_width (priv->button,
6404                                       &button_width, &button_nat_width);
6405
6406       minimum_width += button_width;
6407       natural_width += button_nat_width;
6408     }
6409
6410   if (GTK_SHADOW_NONE != priv->shadow_type)
6411     {
6412       style = gtk_widget_get_style (GTK_WIDGET (widget));
6413
6414       minimum_width  += 2 * style->xthickness;
6415       natural_width  += 2 * style->xthickness;
6416     }
6417
6418   if (minimum_size)
6419     *minimum_size = minimum_width;
6420
6421   if (natural_size)
6422     *natural_size = natural_width;
6423 }
6424
6425 static void
6426 gtk_combo_box_get_preferred_height (GtkWidget *widget,
6427                                     gint      *minimum_size,
6428                                     gint      *natural_size)
6429 {
6430   gint min_width;
6431
6432   /* Combo box is height-for-width only
6433    * (so we always just reserve enough height for the minimum width) */
6434   GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, &min_width, NULL);
6435   GTK_WIDGET_GET_CLASS (widget)->get_preferred_height_for_width (widget, min_width, minimum_size, natural_size);
6436 }
6437
6438 static void
6439 gtk_combo_box_get_preferred_width_for_height (GtkWidget *widget,
6440                                               gint       avail_size,
6441                                               gint      *minimum_size,
6442                                               gint      *natural_size)
6443 {
6444   /* Combo box is height-for-width only
6445    * (so we assume we always reserved enough height for the minimum width) */
6446   GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, minimum_size, natural_size);
6447 }
6448
6449
6450 static void
6451 gtk_combo_box_get_preferred_height_for_width (GtkWidget *widget,
6452                                               gint       avail_size,
6453                                               gint      *minimum_size,
6454                                               gint      *natural_size)
6455 {
6456   GtkComboBox           *combo_box = GTK_COMBO_BOX (widget);
6457   GtkComboBoxPrivate    *priv = combo_box->priv;
6458   GtkStyle              *style;
6459   gint                   focus_width, focus_pad;
6460   gint                   min_height, nat_height;
6461   gint                   size;
6462
6463   gtk_widget_style_get (GTK_WIDGET (widget),
6464                         "focus-line-width", &focus_width,
6465                         "focus-padding", &focus_pad,
6466                         NULL);
6467
6468   size = avail_size;
6469
6470   if (GTK_SHADOW_NONE != priv->shadow_type)
6471     size -= gtk_widget_get_style (GTK_WIDGET (widget))->xthickness;
6472
6473   if (!priv->tree_view)
6474     {
6475       /* menu mode */
6476       if (priv->cell_view)
6477         {
6478           GtkStyle *button_style;
6479           /* calculate x/y padding and separator/arrow size */
6480           gint sep_width, arrow_width, sep_height, arrow_height;
6481           gint border_width, xthickness, ythickness, xpad, ypad;
6482
6483           border_width = gtk_container_get_border_width (GTK_CONTAINER (combo_box));
6484           button_style = gtk_widget_get_style (priv->button);
6485
6486           xthickness = button_style->xthickness;
6487           ythickness = button_style->ythickness;
6488
6489           gtk_widget_get_preferred_width (priv->separator, &sep_width, NULL);
6490           gtk_widget_get_preferred_width (priv->arrow, &arrow_width, NULL);
6491           gtk_widget_get_preferred_height_for_width (priv->separator,
6492                                                      sep_width, &sep_height, NULL);
6493           gtk_widget_get_preferred_height_for_width (priv->arrow,
6494                                                      arrow_width, &arrow_height, NULL);
6495
6496           xpad = 2*(border_width + xthickness + focus_width + focus_pad);
6497           ypad = 2*(border_width + ythickness + focus_width + focus_pad);
6498
6499           size -= sep_width + arrow_width + xpad;
6500
6501           gtk_combo_box_measure_height_for_width (combo_box, size, &min_height, &nat_height);
6502
6503           arrow_height = MAX (arrow_height, sep_height);
6504           min_height = MAX (min_height, arrow_height);
6505           nat_height = MAX (nat_height, arrow_height);
6506
6507           min_height += ypad;
6508           nat_height += ypad;
6509         }
6510       else
6511         {
6512           /* there is a custom child widget inside (no priv->cell_view) */
6513           gint but_width, but_height;
6514
6515           gtk_widget_get_preferred_width (priv->button, &but_width, NULL);
6516           gtk_widget_get_preferred_height_for_width (priv->button,
6517                                                      but_width, &but_height, NULL);
6518
6519           size -= but_width;
6520
6521           gtk_combo_box_measure_height_for_width (combo_box, size, &min_height, &nat_height);
6522
6523           min_height = MAX (min_height, but_height);
6524           nat_height = MAX (nat_height, but_height);
6525         }
6526     }
6527   else
6528     {
6529       /* list mode */
6530       gint but_width, but_height;
6531       gint xpad = 0, ypad = 0;
6532
6533       gtk_widget_get_preferred_width (priv->button, &but_width, NULL);
6534       gtk_widget_get_preferred_height_for_width (priv->button,
6535                                                  but_width, &but_height, NULL);
6536
6537       if (priv->cell_view_frame && priv->has_frame)
6538         {
6539           GtkStyle *cell_style;
6540           gint border_width;
6541
6542           border_width = gtk_container_get_border_width (GTK_CONTAINER (priv->cell_view_frame));
6543           cell_style = gtk_widget_get_style (GTK_WIDGET (priv->cell_view_frame));
6544
6545           xpad = 2 * (border_width + cell_style->xthickness);
6546           ypad = 2 * (border_width + cell_style->ythickness);
6547         }
6548
6549       size -= but_width;
6550       size -= 2 * focus_width;
6551       size -= xpad;
6552
6553       gtk_combo_box_measure_height_for_width (combo_box, size, &min_height, &nat_height);
6554
6555       min_height = MAX (min_height, but_height);
6556       nat_height = MAX (nat_height, but_height);
6557
6558       min_height += ypad;
6559       nat_height += ypad;
6560     }
6561
6562   if (GTK_SHADOW_NONE != priv->shadow_type)
6563     {
6564       style = gtk_widget_get_style (GTK_WIDGET (widget));
6565
6566       min_height += 2 * style->ythickness;
6567       nat_height += 2 * style->ythickness;
6568     }
6569
6570   if (minimum_size)
6571     *minimum_size = min_height;
6572
6573   if (natural_size)
6574     *natural_size = nat_height;
6575 }