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