#include "gtkintl.h"
#include "gtktreeprivate.h"
-#include "gtkalias.h"
+
+
+/**
+ * SECTION:gtkcombobox
+ * @Short_description: A widget used to choose from a list of items
+ * @Title: GtkComboBox
+ * @See_also: #GtkComboBoxText, #GtkTreeModel, #GtkCellRenderer
+ *
+ * A GtkComboBox is a widget that allows the user to choose from a list of
+ * valid choices. The GtkComboBox displays the selected choice. When
+ * activated, the GtkComboBox displays a popup which allows the user to
+ * make a new choice. The style in which the selected value is displayed,
+ * and the style of the popup is determined by the current theme. It may
+ * be similar to a Windows-style combo box.
+ *
+ * The GtkComboBox uses the model-view pattern; the list of valid choices
+ * is specified in the form of a tree model, and the display of the choices
+ * can be adapted to the data in the model by using cell renderers, as you
+ * would in a tree view. This is possible since GtkComboBox implements the
+ * #GtkCellLayout interface. The tree model holding the valid choices is
+ * not restricted to a flat list, it can be a real tree, and the popup will
+ * reflect the tree structure.
+ *
+ * For a simple list of textual choices, the model-view API of GtkComboBox
+ * can be a bit overwhelming. In this case, #GtkComboBoxText offers a
+ * simple alternative.
+ */
+
/* WELCOME, to THE house of evil code */
guint pack : 1;
};
-#define GTK_COMBO_BOX_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_COMBO_BOX, GtkComboBoxPrivate))
struct _GtkComboBoxPrivate
{
GtkWidget *popup_window;
GtkWidget *scrolled_window;
- guint inserted_id;
- guint deleted_id;
- guint reordered_id;
- guint changed_id;
+ gulong inserted_id;
+ gulong deleted_id;
+ gulong reordered_id;
+ gulong changed_id;
guint popup_idle_id;
guint activate_button;
guint32 activate_time;
guint scroll_timer;
guint resize_idle_id;
- gint width;
- gint height;
+ gint minimum_width;
+ gint natural_width;
+
+ /* For "has-entry" specific behavior we track
+ * an automated cell renderer and text column */
+ gint text_column;
+ GtkCellRenderer *text_renderer;
+
GSList *cells;
guint popup_in_progress : 1;
guint auto_scroll : 1;
guint focus_on_click : 1;
guint button_sensitivity : 2;
+ guint has_entry : 1;
+ guint popup_fixed_width : 1;
GtkTreeViewRowSeparatorFunc row_separator_func;
gpointer row_separator_data;
GDestroyNotify row_separator_destroy;
+ GdkDevice *grab_pointer;
+ GdkDevice *grab_keyboard;
+
gchar *tearoff_title;
};
PROP_FOCUS_ON_CLICK,
PROP_POPUP_SHOWN,
PROP_BUTTON_SENSITIVITY,
- PROP_EDITING_CANCELED
+ PROP_EDITING_CANCELED,
+ PROP_HAS_ENTRY,
+ PROP_ENTRY_TEXT_COLUMN,
+ PROP_POPUP_FIXED_WIDTH
};
static guint combo_box_signals[LAST_SIGNAL] = {0,};
static void gtk_combo_box_cell_layout_init (GtkCellLayoutIface *iface);
static void gtk_combo_box_cell_editable_init (GtkCellEditableIface *iface);
+static GObject *gtk_combo_box_constructor (GType type,
+ guint n_construct_properties,
+ GObjectConstructParam *construct_properties);
static void gtk_combo_box_dispose (GObject *object);
static void gtk_combo_box_finalize (GObject *object);
-static void gtk_combo_box_destroy (GtkObject *object);
+static void gtk_combo_box_destroy (GtkWidget *widget);
static void gtk_combo_box_set_property (GObject *object,
guint prop_id,
gint *push_in,
gpointer user_data);
-static gint gtk_combo_box_calc_requested_width (GtkComboBox *combo_box,
- GtkTreePath *path);
+static void gtk_combo_box_update_requested_width(GtkComboBox *combo_box,
+ GtkTreePath *path);
static void gtk_combo_box_remeasure (GtkComboBox *combo_box);
static void gtk_combo_box_unset_model (GtkComboBox *combo_box);
-static void gtk_combo_box_size_request (GtkWidget *widget,
- GtkRequisition *requisition);
static void gtk_combo_box_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
static void gtk_combo_box_forall (GtkContainer *container,
gboolean include_internals,
GtkCallback callback,
gpointer callback_data);
-static gboolean gtk_combo_box_expose_event (GtkWidget *widget,
- GdkEventExpose *event);
+static gboolean gtk_combo_box_draw (GtkWidget *widget,
+ cairo_t *cr);
static gboolean gtk_combo_box_scroll_event (GtkWidget *widget,
GdkEventScroll *event);
static void gtk_combo_box_set_active_internal (GtkComboBox *combo_box,
GtkTreePath *path);
static void gtk_combo_box_check_appearance (GtkComboBox *combo_box);
-static gchar * gtk_combo_box_real_get_active_text (GtkComboBox *combo_box);
static void gtk_combo_box_real_move_active (GtkComboBox *combo_box,
GtkScrollType scroll);
static void gtk_combo_box_real_popup (GtkComboBox *combo_box);
static void gtk_combo_box_child_hide (GtkWidget *widget,
GtkComboBox *combo_box);
+/* GtkComboBox:has-entry callbacks */
+static void gtk_combo_box_entry_contents_changed (GtkEntry *entry,
+ gpointer user_data);
+static void gtk_combo_box_entry_active_changed (GtkComboBox *combo_box,
+ gpointer user_data);
+
+
/* GtkBuildable method implementation */
static GtkBuildableIface *parent_buildable_iface;
GObject *child,
const gchar *tagname,
gpointer *data);
+static GObject *gtk_combo_box_buildable_get_internal_child (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ const gchar *childname);
+
/* GtkCellEditable method implementations */
-static void gtk_combo_box_start_editing (GtkCellEditable *cell_editable,
- GdkEvent *event);
+static void gtk_combo_box_start_editing (GtkCellEditable *cell_editable,
+ GdkEvent *event);
+
+static void gtk_combo_box_get_preferred_width (GtkWidget *widget,
+ gint *minimum_size,
+ gint *natural_size);
+static void gtk_combo_box_get_preferred_height (GtkWidget *widget,
+ gint *minimum_size,
+ gint *natural_size);
+static void gtk_combo_box_get_preferred_width_for_height (GtkWidget *widget,
+ gint avail_size,
+ gint *minimum_size,
+ gint *natural_size);
+static void gtk_combo_box_get_preferred_height_for_width (GtkWidget *widget,
+ gint avail_size,
+ gint *minimum_size,
+ gint *natural_size);
G_DEFINE_TYPE_WITH_CODE (GtkComboBox, gtk_combo_box, GTK_TYPE_BIN,
gtk_combo_box_class_init (GtkComboBoxClass *klass)
{
GObjectClass *object_class;
- GtkObjectClass *gtk_object_class;
GtkContainerClass *container_class;
GtkWidgetClass *widget_class;
GtkBindingSet *binding_set;
- klass->get_active_text = gtk_combo_box_real_get_active_text;
-
container_class = (GtkContainerClass *)klass;
container_class->forall = gtk_combo_box_forall;
container_class->add = gtk_combo_box_add;
widget_class = (GtkWidgetClass *)klass;
widget_class->size_allocate = gtk_combo_box_size_allocate;
- widget_class->size_request = gtk_combo_box_size_request;
- widget_class->expose_event = gtk_combo_box_expose_event;
+ widget_class->draw = gtk_combo_box_draw;
widget_class->scroll_event = gtk_combo_box_scroll_event;
widget_class->mnemonic_activate = gtk_combo_box_mnemonic_activate;
widget_class->grab_focus = gtk_combo_box_grab_focus;
widget_class->style_set = gtk_combo_box_style_set;
widget_class->state_changed = gtk_combo_box_state_changed;
-
- gtk_object_class = (GtkObjectClass *)klass;
- gtk_object_class->destroy = gtk_combo_box_destroy;
+ widget_class->get_preferred_width = gtk_combo_box_get_preferred_width;
+ widget_class->get_preferred_height = gtk_combo_box_get_preferred_height;
+ widget_class->get_preferred_height_for_width = gtk_combo_box_get_preferred_height_for_width;
+ widget_class->get_preferred_width_for_height = gtk_combo_box_get_preferred_width_for_height;
+ widget_class->destroy = gtk_combo_box_destroy;
object_class = (GObjectClass *)klass;
+ object_class->constructor = gtk_combo_box_constructor;
object_class->dispose = gtk_combo_box_dispose;
object_class->finalize = gtk_combo_box_finalize;
object_class->set_property = gtk_combo_box_set_property;
*
* The changed signal is emitted when the active
* item is changed. The can be due to the user selecting
- * a different item from the list, or due to a
+ * a different item from the list, or due to a
* call to gtk_combo_box_set_active_iter().
- * It will also be emitted while typing into a GtkComboBoxEntry,
- * as well as when selecting an item from the GtkComboBoxEntry's list.
+ * It will also be emitted while typing into the entry of a combo box
+ * with an entry.
*
* Since: 2.4
*/
/* key bindings */
binding_set = gtk_binding_set_by_class (widget_class);
- gtk_binding_entry_add_signal (binding_set, GDK_Down, GDK_MOD1_MASK,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Down, GDK_MOD1_MASK,
"popup", 0);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Down, GDK_MOD1_MASK,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Down, GDK_MOD1_MASK,
"popup", 0);
- gtk_binding_entry_add_signal (binding_set, GDK_Up, GDK_MOD1_MASK,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Up, GDK_MOD1_MASK,
"popdown", 0);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Up, GDK_MOD1_MASK,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Up, GDK_MOD1_MASK,
"popdown", 0);
- gtk_binding_entry_add_signal (binding_set, GDK_Escape, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Escape, 0,
"popdown", 0);
- gtk_binding_entry_add_signal (binding_set, GDK_Up, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Up, 0,
"move-active", 1,
GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_UP);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Up, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Up, 0,
"move-active", 1,
GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_UP);
- gtk_binding_entry_add_signal (binding_set, GDK_Page_Up, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Page_Up, 0,
"move-active", 1,
GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_PAGE_UP);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Page_Up, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Page_Up, 0,
"move-active", 1,
GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_PAGE_UP);
- gtk_binding_entry_add_signal (binding_set, GDK_Home, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Home, 0,
"move-active", 1,
GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_START);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Home, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Home, 0,
"move-active", 1,
GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_START);
- gtk_binding_entry_add_signal (binding_set, GDK_Down, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Down, 0,
"move-active", 1,
GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_DOWN);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Down, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Down, 0,
"move-active", 1,
GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_DOWN);
- gtk_binding_entry_add_signal (binding_set, GDK_Page_Down, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Page_Down, 0,
"move-active", 1,
GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_PAGE_DOWN);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Page_Down, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Page_Down, 0,
"move-active", 1,
GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_PAGE_DOWN);
- gtk_binding_entry_add_signal (binding_set, GDK_End, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_End, 0,
"move-active", 1,
GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_END);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_End, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_End, 0,
"move-active", 1,
GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_END);
GTK_SENSITIVITY_AUTO,
GTK_PARAM_READWRITE));
+ /**
+ * GtkComboBox:has-entry:
+ *
+ * Whether the combo box has an entry.
+ *
+ * Since: 2.24
+ */
+ g_object_class_install_property (object_class,
+ PROP_HAS_ENTRY,
+ g_param_spec_boolean ("has-entry",
+ P_("Has Entry"),
+ P_("Whether combo box has an entry"),
+ FALSE,
+ GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+
+ /**
+ * GtkComboBox:entry-text-column:
+ *
+ * The column in the combo box's model to associate with strings from the entry
+ * if the combo was created with #GtkComboBox:has-entry = %TRUE.
+ *
+ * Since: 2.24
+ */
+ g_object_class_install_property (object_class,
+ PROP_ENTRY_TEXT_COLUMN,
+ g_param_spec_int ("entry-text-column",
+ P_("Entry Text Column"),
+ P_("The column in the combo box's model to associate "
+ "with strings from the entry if the combo was "
+ "created with #GtkComboBox:has-entry = %TRUE"),
+ -1, G_MAXINT, -1,
+ GTK_PARAM_READWRITE));
+
+ /**
+ * GtkComboBox:popup-fixed-width:
+ *
+ * Whether the popup's width should be a fixed width matching the
+ * allocated width of the combo box.
+ *
+ * Since: 3.0
+ */
+ g_object_class_install_property (object_class,
+ PROP_POPUP_FIXED_WIDTH,
+ g_param_spec_boolean ("popup-fixed-width",
+ P_("Popup Fixed Width"),
+ P_("Whether the popup's width should be a "
+ "fixed width matching the allocated width "
+ "of the combo box"),
+ TRUE,
+ GTK_PARAM_READWRITE));
+
gtk_widget_class_install_style_property (widget_class,
g_param_spec_boolean ("appears-as-list",
P_("Appears as list"),
iface->add_child = _gtk_cell_layout_buildable_add_child;
iface->custom_tag_start = gtk_combo_box_buildable_custom_tag_start;
iface->custom_tag_end = gtk_combo_box_buildable_custom_tag_end;
+ iface->get_internal_child = gtk_combo_box_buildable_get_internal_child;
}
static void
static void
gtk_combo_box_init (GtkComboBox *combo_box)
{
- GtkComboBoxPrivate *priv = GTK_COMBO_BOX_GET_PRIVATE (combo_box);
+ GtkComboBoxPrivate *priv;
+
+ combo_box->priv = G_TYPE_INSTANCE_GET_PRIVATE (combo_box,
+ GTK_TYPE_COMBO_BOX,
+ GtkComboBoxPrivate);
+ priv = combo_box->priv;
priv->cell_view = gtk_cell_view_new ();
gtk_widget_set_parent (priv->cell_view, GTK_WIDGET (combo_box));
- GTK_BIN (combo_box)->child = priv->cell_view;
+ _gtk_bin_set_child (GTK_BIN (combo_box), priv->cell_view);
gtk_widget_show (priv->cell_view);
- priv->width = 0;
- priv->height = 0;
+ priv->minimum_width = 0;
+ priv->natural_width = 0;
+
priv->wrap_width = 0;
priv->active = -1;
priv->auto_scroll = FALSE;
priv->focus_on_click = TRUE;
priv->button_sensitivity = GTK_SENSITIVITY_AUTO;
+ priv->has_entry = FALSE;
+ priv->popup_fixed_width = TRUE;
- combo_box->priv = priv;
+ priv->text_column = -1;
+ priv->text_renderer = NULL;
gtk_combo_box_check_appearance (combo_box);
}
case PROP_HAS_FRAME:
combo_box->priv->has_frame = g_value_get_boolean (value);
+
+ if (combo_box->priv->has_entry)
+ {
+ GtkWidget *child;
+
+ child = gtk_bin_get_child (GTK_BIN (combo_box));
+
+ gtk_entry_set_has_frame (GTK_ENTRY (child),
+ combo_box->priv->has_frame);
+ }
+
break;
case PROP_FOCUS_ON_CLICK:
g_value_get_enum (value));
break;
+ case PROP_POPUP_FIXED_WIDTH:
+ gtk_combo_box_set_popup_fixed_width (combo_box,
+ g_value_get_boolean (value));
+ break;
+
case PROP_EDITING_CANCELED:
combo_box->priv->editing_canceled = g_value_get_boolean (value);
break;
+ case PROP_HAS_ENTRY:
+ combo_box->priv->has_entry = g_value_get_boolean (value);
+ break;
+
+ case PROP_ENTRY_TEXT_COLUMN:
+ gtk_combo_box_set_entry_text_column (combo_box, g_value_get_int (value));
+ break;
+
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
GParamSpec *pspec)
{
GtkComboBox *combo_box = GTK_COMBO_BOX (object);
- GtkComboBoxPrivate *priv = GTK_COMBO_BOX_GET_PRIVATE (combo_box);
+ GtkComboBoxPrivate *priv = combo_box->priv;
switch (prop_id)
{
g_value_set_enum (value, combo_box->priv->button_sensitivity);
break;
+ case PROP_POPUP_FIXED_WIDTH:
+ g_value_set_boolean (value, combo_box->priv->popup_fixed_width);
+ break;
+
case PROP_EDITING_CANCELED:
g_value_set_boolean (value, priv->editing_canceled);
break;
+ case PROP_HAS_ENTRY:
+ g_value_set_boolean (value, priv->has_entry);
+ break;
+
+ case PROP_ENTRY_TEXT_COLUMN:
+ g_value_set_int (value, priv->text_column);
+ break;
+
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
{
if (priv->tree_view && priv->cell_view)
gtk_cell_view_set_background_color (GTK_CELL_VIEW (priv->cell_view),
- &widget->style->base[gtk_widget_get_state (widget)]);
+ >k_widget_get_style (widget)->base[gtk_widget_get_state (widget)]);
}
gtk_widget_queue_draw (widget);
{
GtkComboBox *combo_box = GTK_COMBO_BOX (widget);
GtkComboBoxPrivate *priv = combo_box->priv;
+ GtkWidget *child;
gtk_combo_box_check_appearance (combo_box);
if (priv->tree_view && priv->cell_view)
gtk_cell_view_set_background_color (GTK_CELL_VIEW (priv->cell_view),
- &widget->style->base[gtk_widget_get_state (widget)]);
+ >k_widget_get_style (widget)->base[gtk_widget_get_state (widget)]);
- if (GTK_IS_ENTRY (GTK_BIN (combo_box)->child))
- g_object_set (GTK_BIN (combo_box)->child, "shadow-type",
+ child = gtk_bin_get_child (GTK_BIN (combo_box));
+ if (GTK_IS_ENTRY (child))
+ g_object_set (child, "shadow-type",
GTK_SHADOW_NONE == priv->shadow_type ?
GTK_SHADOW_IN : GTK_SHADOW_NONE, NULL);
}
GtkComboBox *combo_box = GTK_COMBO_BOX (container);
GtkComboBoxPrivate *priv = combo_box->priv;
- if (priv->cell_view && priv->cell_view->parent)
+ if (priv->has_entry && !GTK_IS_ENTRY (widget))
+ {
+ g_warning ("Attempting to add a widget with type %s to a GtkComboBox that needs an entry "
+ "(need an instance of GtkEntry or of a subclass)",
+ G_OBJECT_TYPE_NAME (widget));
+ return;
+ }
+
+ if (priv->cell_view &&
+ gtk_widget_get_parent (priv->cell_view))
{
gtk_widget_unparent (priv->cell_view);
- GTK_BIN (container)->child = NULL;
+ _gtk_bin_set_child (GTK_BIN (container), NULL);
gtk_widget_queue_resize (GTK_WIDGET (container));
}
gtk_widget_set_parent (widget, GTK_WIDGET (container));
- GTK_BIN (container)->child = widget;
+ _gtk_bin_set_child (GTK_BIN (container), widget);
if (priv->cell_view &&
widget != priv->cell_view)
if (!priv->tree_view && priv->separator)
{
- gtk_container_remove (GTK_CONTAINER (priv->separator->parent),
- priv->separator);
+ gtk_container_remove (GTK_CONTAINER (gtk_widget_get_parent (priv->separator)),
+ priv->separator);
priv->separator = NULL;
gtk_widget_queue_resize (GTK_WIDGET (container));
priv->box = NULL;
}
}
+
+ if (priv->has_entry)
+ {
+ /* this flag is a hack to tell the entry to fill its allocation.
+ */
+ GTK_ENTRY (widget)->is_cell_renderer = TRUE;
+
+ g_signal_connect (widget, "changed",
+ G_CALLBACK (gtk_combo_box_entry_contents_changed),
+ combo_box);
+
+ gtk_entry_set_has_frame (GTK_ENTRY (widget), priv->has_frame);
+ }
}
static void
GtkTreePath *path;
gboolean appears_as_list;
+ if (priv->has_entry)
+ {
+ GtkWidget *child_widget;
+
+ child_widget = gtk_bin_get_child (GTK_BIN (container));
+ if (widget && widget == child_widget)
+ {
+ g_signal_handlers_disconnect_by_func (widget,
+ gtk_combo_box_entry_contents_changed,
+ container);
+ GTK_ENTRY (widget)->is_cell_renderer = FALSE;
+ }
+ }
+
if (widget == priv->cell_view)
priv->cell_view = NULL;
gtk_widget_unparent (widget);
- GTK_BIN (container)->child = NULL;
+ _gtk_bin_set_child (GTK_BIN (container), NULL);
- if (GTK_OBJECT_FLAGS (combo_box) & GTK_IN_DESTRUCTION)
+ if (gtk_widget_in_destruction (GTK_WIDGET (combo_box)))
return;
gtk_widget_queue_resize (GTK_WIDGET (container));
{
priv->cell_view = gtk_cell_view_new ();
gtk_widget_set_parent (priv->cell_view, GTK_WIDGET (container));
- GTK_BIN (container)->child = priv->cell_view;
+ _gtk_bin_set_child (GTK_BIN (container), priv->cell_view);
gtk_widget_show (priv->cell_view);
gtk_cell_view_set_model (GTK_CELL_VIEW (priv->cell_view),
gpointer user_data)
{
GtkComboBox *combo_box = GTK_COMBO_BOX (user_data);
+ GtkAllocation child_allocation;
gint sx, sy;
GtkWidget *child;
GtkRequisition req;
GdkRectangle monitor;
/* FIXME: is using the size request here broken? */
- child = GTK_BIN (combo_box)->child;
+ child = gtk_bin_get_child (GTK_BIN (combo_box));
sx = sy = 0;
+ gtk_widget_get_allocation (child, &child_allocation);
+
if (!gtk_widget_get_has_window (child))
{
- sx += child->allocation.x;
- sy += child->allocation.y;
+ sx += child_allocation.x;
+ sy += child_allocation.y;
}
- gdk_window_get_root_coords (child->window, sx, sy, &sx, &sy);
+ gdk_window_get_root_coords (gtk_widget_get_window (child),
+ sx, sy, &sx, &sy);
if (GTK_SHADOW_NONE != combo_box->priv->shadow_type)
- sx -= GTK_WIDGET (combo_box)->style->xthickness;
+ sx -= gtk_widget_get_style (GTK_WIDGET (combo_box))->xthickness;
- gtk_widget_size_request (GTK_WIDGET (menu), &req);
+ if (combo_box->priv->popup_fixed_width)
+ gtk_widget_get_preferred_size (GTK_WIDGET (menu), &req, NULL);
+ else
+ gtk_widget_get_preferred_size (GTK_WIDGET (menu), NULL, &req);
if (gtk_widget_get_direction (GTK_WIDGET (combo_box)) == GTK_TEXT_DIR_LTR)
*x = sx;
else
- *x = sx + child->allocation.width - req.width;
+ *x = sx + child_allocation.width - req.width;
*y = sy;
screen = gtk_widget_get_screen (GTK_WIDGET (combo_box));
monitor_num = gdk_screen_get_monitor_at_window (screen,
- GTK_WIDGET (combo_box)->window);
+ gtk_widget_get_window (GTK_WIDGET (combo_box)));
gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
if (*x < monitor.x)
else if (*x + req.width > monitor.x + monitor.width)
*x = monitor.x + monitor.width - req.width;
- if (monitor.y + monitor.height - *y - child->allocation.height >= req.height)
- *y += child->allocation.height;
+ if (monitor.y + monitor.height - *y - child_allocation.height >= req.height)
+ *y += child_allocation.height;
else if (*y - monitor.y >= req.height)
*y -= req.height;
- else if (monitor.y + monitor.height - *y - child->allocation.height > *y - monitor.y)
- *y += child->allocation.height;
+ else if (monitor.y + monitor.height - *y - child_allocation.height > *y - monitor.y)
+ *y += child_allocation.height;
else
*y -= req.height;
gboolean *push_in,
gpointer user_data)
{
- GtkComboBox *combo_box;
- GtkWidget *active;
- GtkWidget *child;
- GtkWidget *widget;
- GtkRequisition requisition;
- GList *children;
- gint screen_width;
- gint menu_xpos;
- gint menu_ypos;
- gint menu_width;
+ GtkComboBox *combo_box;
+ GtkWidget *active;
+ GtkWidget *child;
+ GtkWidget *widget;
+ GtkAllocation allocation;
+ GtkAllocation child_allocation;
+ GList *children;
+ gint screen_width;
+ gint menu_xpos;
+ gint menu_ypos;
+ gint menu_width;
combo_box = GTK_COMBO_BOX (user_data);
widget = GTK_WIDGET (combo_box);
- gtk_widget_get_child_requisition (GTK_WIDGET (menu), &requisition);
- menu_width = requisition.width;
-
active = gtk_menu_get_active (GTK_MENU (combo_box->priv->popup_widget));
- menu_xpos = widget->allocation.x;
- menu_ypos = widget->allocation.y + widget->allocation.height / 2 - 2;
+ gtk_widget_get_allocation (widget, &allocation);
+
+ menu_xpos = allocation.x;
+ menu_ypos = allocation.y + allocation.height / 2 - 2;
+
+ if (combo_box->priv->popup_fixed_width)
+ gtk_widget_get_preferred_width (GTK_WIDGET (menu), &menu_width, NULL);
+ else
+ gtk_widget_get_preferred_width (GTK_WIDGET (menu), NULL, &menu_width);
if (active != NULL)
{
- gtk_widget_get_child_requisition (active, &requisition);
- menu_ypos -= requisition.height / 2;
+ gtk_widget_get_allocation (active, &child_allocation);
+ menu_ypos -= child_allocation.height / 2;
}
children = GTK_MENU_SHELL (combo_box->priv->popup_widget)->children;
if (gtk_widget_get_visible (child))
{
- gtk_widget_get_child_requisition (child, &requisition);
- menu_ypos -= requisition.height;
+ gtk_widget_get_allocation (child, &child_allocation);
+
+ menu_ypos -= child_allocation.height;
}
children = children->next;
}
if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
- menu_xpos = menu_xpos + widget->allocation.width - menu_width;
+ menu_xpos = menu_xpos + allocation.width - menu_width;
- gdk_window_get_root_coords (widget->window, menu_xpos, menu_ypos,
+ gdk_window_get_root_coords (gtk_widget_get_window (widget),
+ menu_xpos, menu_ypos,
&menu_xpos, &menu_ypos);
/* Clamp the position on screen */
GtkComboBoxPrivate *priv = combo_box->priv;
GtkWidget *menu_item;
-
if (priv->wrap_width > 0 || priv->cell_view == NULL)
gtk_combo_box_menu_position_below (menu, x, y, push_in, user_data);
else
gint *height)
{
GtkComboBoxPrivate *priv = combo_box->priv;
+ GtkAllocation allocation;
GdkScreen *screen;
gint monitor_num;
GdkRectangle monitor;
GtkRequisition popup_req;
GtkPolicyType hpolicy, vpolicy;
-
+ GdkWindow *window;
+
/* under windows, the drop down list is as wide as the combo box itself.
see bug #340204 */
- GtkWidget *sample = GTK_WIDGET (combo_box);
+ GtkWidget *widget = GTK_WIDGET (combo_box);
*x = *y = 0;
- if (!gtk_widget_get_has_window (sample))
+ gtk_widget_get_allocation (widget, &allocation);
+
+ if (!gtk_widget_get_has_window (widget))
{
- *x += sample->allocation.x;
- *y += sample->allocation.y;
+ *x += allocation.x;
+ *y += allocation.y;
}
-
- gdk_window_get_root_coords (sample->window, *x, *y, x, y);
- *width = sample->allocation.width;
+ window = gtk_widget_get_window (widget);
+
+ gdk_window_get_root_coords (gtk_widget_get_window (widget),
+ *x, *y, x, y);
+
+ *width = allocation.width;
hpolicy = vpolicy = GTK_POLICY_NEVER;
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->scrolled_window),
hpolicy, vpolicy);
- gtk_widget_size_request (priv->scrolled_window, &popup_req);
- if (popup_req.width > *width)
+ /* XXX This set_size_request call is part of the hack outlined below and can
+ * go away once height-for-width is implemented on treeviews. */
+ gtk_widget_set_size_request (priv->tree_view, -1, -1);
+
+ if (combo_box->priv->popup_fixed_width)
{
- hpolicy = GTK_POLICY_ALWAYS;
- gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->scrolled_window),
- hpolicy, vpolicy);
- gtk_widget_size_request (priv->scrolled_window, &popup_req);
+ gtk_widget_get_preferred_size (priv->scrolled_window, &popup_req, NULL);
+
+ if (popup_req.width > *width)
+ {
+ hpolicy = GTK_POLICY_ALWAYS;
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->scrolled_window),
+ hpolicy, vpolicy);
+ }
+ }
+ else
+ {
+ gtk_combo_box_remeasure (combo_box);
+
+ if (priv->natural_width > *width)
+ {
+ hpolicy = GTK_POLICY_NEVER;
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->scrolled_window),
+ hpolicy, vpolicy);
+
+
+ /* XXX Currently we set the size-request on the internal treeview to be
+ * the natural width of the cells, this hack can go away once our
+ * treeview does height-for-width properly (i.e. just adjust *width
+ * here to be the natural width request of the scrolled-window).
+ *
+ * I can't tell why the magic number 5 is needed here (i.e. without it
+ * treeviews are left ellipsizing) , however it this all should be
+ * removed with height-for-width treeviews.
+ */
+ gtk_widget_set_size_request (priv->tree_view, priv->natural_width + 5, -1);
+ gtk_widget_get_preferred_size (priv->scrolled_window, NULL, &popup_req);
+
+ *width = popup_req.width;
+ }
}
*height = popup_req.height;
screen = gtk_widget_get_screen (GTK_WIDGET (combo_box));
- monitor_num = gdk_screen_get_monitor_at_window (screen,
- GTK_WIDGET (combo_box)->window);
+ monitor_num = gdk_screen_get_monitor_at_window (screen, window);
gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
+ if (gtk_widget_get_direction (GTK_WIDGET (combo_box)) == GTK_TEXT_DIR_RTL)
+ *x = *x + allocation.width - *width;
+
if (*x < monitor.x)
*x = monitor.x;
else if (*x + *width > monitor.x + monitor.width)
*x = monitor.x + monitor.width - *width;
- if (*y + sample->allocation.height + *height <= monitor.y + monitor.height)
- *y += sample->allocation.height;
+ if (*y + allocation.height + *height <= monitor.y + monitor.height)
+ *y += allocation.height;
else if (*y - *height >= monitor.y)
*y -= *height;
- else if (monitor.y + monitor.height - (*y + sample->allocation.height) > *y - monitor.y)
+ else if (monitor.y + monitor.height - (*y + allocation.height) > *y - monitor.y)
{
- *y += sample->allocation.height;
+ *y += allocation.height;
*height = monitor.y + monitor.height - *y;
}
else
for (child = children; child; child = child->next)
{
item = GTK_WIDGET (child->data);
- cell_view = GTK_BIN (item)->child;
+ cell_view = gtk_bin_get_child (GTK_BIN (item));
if (!GTK_IS_CELL_VIEW (cell_view))
continue;
GtkComboBoxPrivate *priv = combo_box->priv;
GtkTreePath *path;
gint active_item;
- GtkRequisition requisition;
- gint width;
+ gint width, min_width, nat_width;
update_menu_sensitivity (combo_box, priv->popup_widget);
if (priv->wrap_width == 0)
{
- width = GTK_WIDGET (combo_box)->allocation.width;
+ GtkAllocation allocation;
+
+ gtk_widget_get_allocation (GTK_WIDGET (combo_box), &allocation);
+ width = allocation.width;
gtk_widget_set_size_request (priv->popup_widget, -1, -1);
- gtk_widget_size_request (priv->popup_widget, &requisition);
-
- gtk_widget_set_size_request (priv->popup_widget,
- MAX (width, requisition.width), -1);
+ gtk_widget_get_preferred_width (priv->popup_widget, &min_width, &nat_width);
+
+ if (combo_box->priv->popup_fixed_width)
+ width = MAX (width, min_width);
+ else
+ width = MAX (width, nat_width);
+
+ gtk_widget_set_size_request (priv->popup_widget, width, -1);
}
gtk_menu_popup (GTK_MENU (priv->popup_widget),
static gboolean
popup_grab_on_window (GdkWindow *window,
- guint32 activate_time,
- gboolean grab_keyboard)
-{
- if ((gdk_pointer_grab (window, TRUE,
- GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
- GDK_POINTER_MOTION_MASK,
- NULL, NULL, activate_time) == 0))
+ GdkDevice *keyboard,
+ GdkDevice *pointer,
+ guint32 activate_time)
+{
+ if (keyboard &&
+ gdk_device_grab (keyboard, window,
+ GDK_OWNERSHIP_WINDOW, TRUE,
+ GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK,
+ NULL, activate_time) != GDK_GRAB_SUCCESS)
+ return FALSE;
+
+ if (pointer &&
+ gdk_device_grab (pointer, window,
+ GDK_OWNERSHIP_WINDOW, TRUE,
+ GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
+ GDK_POINTER_MOTION_MASK,
+ NULL, activate_time) != GDK_GRAB_SUCCESS)
{
- if (!grab_keyboard ||
- gdk_keyboard_grab (window, TRUE,
- activate_time) == 0)
- return TRUE;
- else
- {
- gdk_display_pointer_ungrab (gdk_drawable_get_display (window),
- activate_time);
- return FALSE;
- }
+ if (keyboard)
+ gdk_device_ungrab (keyboard, activate_time);
+
+ return FALSE;
}
- return FALSE;
+ return TRUE;
}
/**
g_signal_emit (combo_box, combo_box_signals[POPUP], 0);
}
-static void
-gtk_combo_box_real_popup (GtkComboBox *combo_box)
+/**
+ * gtk_combo_box_popup_for_device:
+ * @combo_box: a #GtkComboBox
+ * @device: a #GdkDevice
+ *
+ * Pops up the menu or dropdown list of @combo_box, the popup window
+ * will be grabbed so only @device and its associated pointer/keyboard
+ * are the only #GdkDevice<!-- -->s able to send events to it.
+ *
+ * Since: 3.0
+ **/
+void
+gtk_combo_box_popup_for_device (GtkComboBox *combo_box,
+ GdkDevice *device)
{
GtkComboBoxPrivate *priv = combo_box->priv;
gint x, y, width, height;
GtkTreePath *path = NULL, *ppath;
GtkWidget *toplevel;
+ GdkDevice *keyboard, *pointer;
+ guint32 time;
+
+ g_return_if_fail (GTK_IS_COMBO_BOX (combo_box));
+ g_return_if_fail (GDK_IS_DEVICE (device));
if (!gtk_widget_get_realized (GTK_WIDGET (combo_box)))
return;
if (gtk_widget_get_mapped (priv->popup_widget))
return;
+ if (priv->grab_pointer && priv->grab_keyboard)
+ return;
+
+ time = gtk_get_current_event_time ();
+
+ if (device->source == GDK_SOURCE_KEYBOARD)
+ {
+ keyboard = device;
+ pointer = gdk_device_get_associated_device (device);
+ }
+ else
+ {
+ pointer = device;
+ keyboard = gdk_device_get_associated_device (device);
+ }
+
if (GTK_IS_MENU (priv->popup_widget))
{
gtk_combo_box_menu_popup (combo_box,
if (!gtk_widget_has_focus (priv->tree_view))
gtk_widget_grab_focus (priv->tree_view);
- if (!popup_grab_on_window (priv->popup_window->window,
- GDK_CURRENT_TIME, TRUE))
+ if (!popup_grab_on_window (gtk_widget_get_window (priv->popup_window),
+ keyboard, pointer, time))
{
gtk_widget_hide (priv->popup_window);
return;
}
- gtk_grab_add (priv->popup_window);
+ gtk_device_grab_add (priv->popup_window, pointer, TRUE);
+ priv->grab_pointer = pointer;
+ priv->grab_keyboard = keyboard;
+}
+
+static void
+gtk_combo_box_real_popup (GtkComboBox *combo_box)
+{
+ GdkDevice *device;
+
+ device = gtk_get_current_event_device ();
+
+ if (!device)
+ {
+ GdkDeviceManager *device_manager;
+ GdkDisplay *display;
+ GList *devices;
+
+ display = gtk_widget_get_display (GTK_WIDGET (combo_box));
+ device_manager = gdk_display_get_device_manager (display);
+
+ /* No device was set, pick the first master device */
+ devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
+ device = devices->data;
+ g_list_free (devices);
+ }
+
+ gtk_combo_box_popup_for_device (combo_box, device);
}
static gboolean
if (!gtk_widget_get_realized (GTK_WIDGET (combo_box)))
return;
- gtk_grab_remove (priv->popup_window);
- gtk_widget_hide_all (priv->popup_window);
+ gtk_device_grab_remove (priv->popup_window, priv->grab_pointer);
+ gtk_widget_hide (priv->popup_window);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->button),
FALSE);
+
+ priv->grab_pointer = NULL;
+ priv->grab_keyboard = NULL;
}
-static gint
-gtk_combo_box_calc_requested_width (GtkComboBox *combo_box,
- GtkTreePath *path)
+static void
+gtk_combo_box_update_requested_width (GtkComboBox *combo_box,
+ GtkTreePath *path)
{
GtkComboBoxPrivate *priv = combo_box->priv;
- gint padding;
- GtkRequisition req;
+ gint padding, min_width, nat_width;
if (priv->cell_view)
gtk_widget_style_get (priv->cell_view,
padding += BONUS_PADDING;
if (priv->cell_view)
- gtk_cell_view_get_size_of_row (GTK_CELL_VIEW (priv->cell_view),
- path, &req);
+ gtk_cell_view_get_desired_width_of_row (GTK_CELL_VIEW (priv->cell_view),
+ path, &min_width, &nat_width);
else
- req.width = 0;
-
- return req.width + padding;
-}
-
-static void
-gtk_combo_box_remeasure (GtkComboBox *combo_box)
-{
- GtkComboBoxPrivate *priv = combo_box->priv;
- GtkTreeIter iter;
- GtkTreePath *path;
-
- if (!priv->model ||
- !gtk_tree_model_get_iter_first (priv->model, &iter))
- return;
+ min_width = nat_width = 0;
- priv->width = 0;
- priv->height = 0;
+ min_width += padding;
+ nat_width += padding;
- path = gtk_tree_path_new_from_indices (0, -1);
-
- do
+ if (min_width > priv->minimum_width || nat_width > priv->natural_width)
{
- GtkRequisition req;
+ priv->minimum_width = MAX (priv->minimum_width, min_width);
+ priv->natural_width = MAX (priv->natural_width, nat_width);
if (priv->cell_view)
- gtk_cell_view_get_size_of_row (GTK_CELL_VIEW (priv->cell_view),
- path, &req);
- else
- {
- req.width = 0;
- req.height = 0;
- }
-
- priv->width = MAX (priv->width, req.width);
- priv->height = MAX (priv->height, req.height);
-
- gtk_tree_path_next (path);
+ {
+ gtk_widget_set_size_request (priv->cell_view, min_width, -1);
+ gtk_widget_queue_resize (priv->cell_view);
+ }
}
- while (gtk_tree_model_iter_next (priv->model, &iter));
-
- gtk_tree_path_free (path);
}
+#define GTK_COMBO_BOX_SIZE_ALLOCATE_BUTTON \
+ gtk_widget_get_preferred_size (combo_box->priv->button, \
+ &req, NULL); \
+ \
+ if (is_rtl) \
+ child.x = allocation->x + shadow_width; \
+ else \
+ child.x = allocation->x + allocation->width - req.width - shadow_width; \
+ \
+ child.y = allocation->y + shadow_height; \
+ child.width = req.width; \
+ child.height = allocation->height - 2 * shadow_height; \
+ child.width = MAX (1, child.width); \
+ child.height = MAX (1, child.height); \
+ \
+ gtk_widget_size_allocate (combo_box->priv->button, &child);
+
static void
-gtk_combo_box_size_request (GtkWidget *widget,
- GtkRequisition *requisition)
+gtk_combo_box_size_allocate (GtkWidget *widget,
+ GtkAllocation *allocation)
{
- gint width, height;
- gint focus_width, focus_pad;
- gint font_size;
- gint arrow_size;
- GtkRequisition bin_req;
- PangoContext *context;
- PangoFontMetrics *metrics;
- PangoFontDescription *font_desc;
-
GtkComboBox *combo_box = GTK_COMBO_BOX (widget);
GtkComboBoxPrivate *priv = combo_box->priv;
-
- /* common */
- gtk_widget_size_request (GTK_BIN (widget)->child, &bin_req);
- gtk_combo_box_remeasure (combo_box);
- bin_req.width = MAX (bin_req.width, priv->width);
- bin_req.height = MAX (bin_req.height, priv->height);
+ GtkWidget *child_widget;
+ gint shadow_width, shadow_height;
+ gint focus_width, focus_pad;
+ GtkAllocation child;
+ GtkRequisition req;
+ GtkStyle *style;
+ gboolean is_rtl = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL;
- gtk_widget_style_get (GTK_WIDGET (widget),
+ gtk_widget_set_allocation (widget, allocation);
+ child_widget = gtk_bin_get_child (GTK_BIN (widget));
+
+ style = gtk_widget_get_style (widget);
+ gtk_widget_style_get (widget,
"focus-line-width", &focus_width,
"focus-padding", &focus_pad,
- "arrow-size", &arrow_size,
NULL);
- font_desc = GTK_BIN (widget)->child->style->font_desc;
- context = gtk_widget_get_pango_context (widget);
- metrics = pango_context_get_metrics (context, font_desc,
- pango_context_get_language (context));
- font_size = PANGO_PIXELS (pango_font_metrics_get_ascent (metrics) +
- pango_font_metrics_get_descent (metrics));
- pango_font_metrics_unref (metrics);
-
- arrow_size = MAX (arrow_size, font_size);
-
- gtk_widget_set_size_request (priv->arrow, arrow_size, arrow_size);
+ if (GTK_SHADOW_NONE != priv->shadow_type)
+ {
+ shadow_width = style->xthickness;
+ shadow_height = style->ythickness;
+ }
+ else
+ {
+ shadow_width = 0;
+ shadow_height = 0;
+ }
if (!priv->tree_view)
{
- /* menu mode */
-
if (priv->cell_view)
{
- GtkRequisition button_req, sep_req, arrow_req;
- gint border_width, xthickness, ythickness;
-
- gtk_widget_size_request (priv->button, &button_req);
- border_width = GTK_CONTAINER (combo_box)->border_width;
- xthickness = priv->button->style->xthickness;
- ythickness = priv->button->style->ythickness;
-
- bin_req.width = MAX (bin_req.width, priv->width);
- bin_req.height = MAX (bin_req.height, priv->height);
+ gint xthickness, ythickness;
+ gint width;
+ guint border_width;
- gtk_widget_size_request (priv->separator, &sep_req);
- gtk_widget_size_request (priv->arrow, &arrow_req);
+ /* menu mode */
+ allocation->x += shadow_width;
+ allocation->y += shadow_height;
+ allocation->width -= 2 * shadow_width;
+ allocation->height -= 2 * shadow_height;
- height = MAX (sep_req.height, arrow_req.height);
- height = MAX (height, bin_req.height);
+ gtk_widget_size_allocate (priv->button, allocation);
- width = bin_req.width + sep_req.width + arrow_req.width;
+ /* set some things ready */
+ border_width = gtk_container_get_border_width (GTK_CONTAINER (priv->button));
+ style = gtk_widget_get_style (priv->button);
+ xthickness = style->xthickness;
+ ythickness = style->ythickness;
- height += 2*(border_width + ythickness + focus_width + focus_pad);
- width += 2*(border_width + xthickness + focus_width + focus_pad);
-
- requisition->width = width;
- requisition->height = height;
- }
- else
- {
- GtkRequisition but_req;
-
- gtk_widget_size_request (priv->button, &but_req);
-
- requisition->width = bin_req.width + but_req.width;
- requisition->height = MAX (bin_req.height, but_req.height);
- }
- }
- else
- {
- /* list mode */
- GtkRequisition button_req, frame_req;
-
- /* sample + frame */
- *requisition = bin_req;
-
- requisition->width += 2 * focus_width;
-
- if (priv->cell_view_frame)
- {
- gtk_widget_size_request (priv->cell_view_frame, &frame_req);
- if (priv->has_frame)
- {
- requisition->width += 2 *
- (GTK_CONTAINER (priv->cell_view_frame)->border_width +
- GTK_WIDGET (priv->cell_view_frame)->style->xthickness);
- requisition->height += 2 *
- (GTK_CONTAINER (priv->cell_view_frame)->border_width +
- GTK_WIDGET (priv->cell_view_frame)->style->ythickness);
- }
- }
-
- /* the button */
- gtk_widget_size_request (priv->button, &button_req);
-
- requisition->height = MAX (requisition->height, button_req.height);
- requisition->width += button_req.width;
- }
-
- if (GTK_SHADOW_NONE != priv->shadow_type)
- {
- requisition->height += 2 * widget->style->ythickness;
- requisition->width += 2 * widget->style->xthickness;
- }
-}
-
-#define GTK_COMBO_BOX_SIZE_ALLOCATE_BUTTON \
- gtk_widget_size_request (combo_box->priv->button, &req); \
- \
- if (is_rtl) \
- child.x = allocation->x + shadow_width; \
- else \
- child.x = allocation->x + allocation->width - req.width - shadow_width; \
- \
- child.y = allocation->y + shadow_height; \
- child.width = req.width; \
- child.height = allocation->height - 2 * shadow_height; \
- child.width = MAX (1, child.width); \
- child.height = MAX (1, child.height); \
- \
- gtk_widget_size_allocate (combo_box->priv->button, &child);
-
-static void
-gtk_combo_box_size_allocate (GtkWidget *widget,
- GtkAllocation *allocation)
-{
- GtkComboBox *combo_box = GTK_COMBO_BOX (widget);
- GtkComboBoxPrivate *priv = combo_box->priv;
- gint shadow_width, shadow_height;
- gint focus_width, focus_pad;
- GtkAllocation child;
- GtkRequisition req;
- gboolean is_rtl = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL;
-
- widget->allocation = *allocation;
-
- gtk_widget_style_get (GTK_WIDGET (widget),
- "focus-line-width", &focus_width,
- "focus-padding", &focus_pad,
- NULL);
-
- if (GTK_SHADOW_NONE != priv->shadow_type)
- {
- shadow_width = widget->style->xthickness;
- shadow_height = widget->style->ythickness;
- }
- else
- {
- shadow_width = 0;
- shadow_height = 0;
- }
-
- if (!priv->tree_view)
- {
- if (priv->cell_view)
- {
- gint border_width, xthickness, ythickness;
- gint width;
-
- /* menu mode */
- allocation->x += shadow_width;
- allocation->y += shadow_height;
- allocation->width -= 2 * shadow_width;
- allocation->height -= 2 * shadow_height;
-
- gtk_widget_size_allocate (priv->button, allocation);
-
- /* set some things ready */
- border_width = GTK_CONTAINER (priv->button)->border_width;
- xthickness = priv->button->style->xthickness;
- ythickness = priv->button->style->ythickness;
-
- child.x = allocation->x;
- child.y = allocation->y;
- width = allocation->width;
- child.height = allocation->height;
+ child.x = allocation->x;
+ child.y = allocation->y;
+ width = allocation->width;
+ child.height = allocation->height;
if (!priv->is_cell_renderer)
{
/* handle the children */
- gtk_widget_size_request (priv->arrow, &req);
+ gtk_widget_get_preferred_size (priv->arrow, &req, NULL);
child.width = req.width;
if (!is_rtl)
child.x += width - req.width;
gtk_widget_size_allocate (priv->arrow, &child);
if (is_rtl)
child.x += req.width;
- gtk_widget_size_request (priv->separator, &req);
+ gtk_widget_get_preferred_size (priv->separator, &req, NULL);
child.width = req.width;
if (!is_rtl)
child.x -= req.width;
if (gtk_widget_get_visible (priv->popup_widget))
{
- gint width;
- GtkRequisition requisition;
+ gint width, menu_width;
- /* Warning here, without the check in the position func */
- gtk_menu_reposition (GTK_MENU (priv->popup_widget));
if (priv->wrap_width == 0)
{
- width = GTK_WIDGET (combo_box)->allocation.width;
+ GtkAllocation combo_box_allocation;
+
+ gtk_widget_get_allocation (GTK_WIDGET (combo_box), &combo_box_allocation);
+ width = combo_box_allocation.width;
gtk_widget_set_size_request (priv->popup_widget, -1, -1);
- gtk_widget_size_request (priv->popup_widget, &requisition);
+
+ if (combo_box->priv->popup_fixed_width)
+ gtk_widget_get_preferred_width (priv->popup_widget, &menu_width, NULL);
+ else
+ gtk_widget_get_preferred_width (priv->popup_widget, NULL, &menu_width);
+
gtk_widget_set_size_request (priv->popup_widget,
- MAX (width, requisition.width), -1);
+ MAX (width, menu_width), -1);
}
+
+ /* reposition the menu after giving it a new width */
+ gtk_menu_reposition (GTK_MENU (priv->popup_widget));
}
child.width = MAX (1, child.width);
child.height = MAX (1, child.height);
- gtk_widget_size_allocate (GTK_BIN (widget)->child, &child);
+ gtk_widget_size_allocate (child_widget, &child);
}
else
{
child.width = allocation->width - req.width - 2 * shadow_width;
child.width = MAX (1, child.width);
child.height = MAX (1, child.height);
- gtk_widget_size_allocate (GTK_BIN (widget)->child, &child);
+ gtk_widget_size_allocate (child_widget, &child);
}
}
else
/* list mode */
/* Combobox thickness + border-width */
- int delta_x = shadow_width + GTK_CONTAINER (widget)->border_width;
- int delta_y = shadow_height + GTK_CONTAINER (widget)->border_width;
+ guint border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
+ int delta_x = shadow_width + border_width;
+ int delta_y = shadow_height + border_width;
/* button */
GTK_COMBO_BOX_SIZE_ALLOCATE_BUTTON
/* the sample */
if (priv->has_frame)
{
- delta_x = GTK_CONTAINER (priv->cell_view_frame)->border_width +
- GTK_WIDGET (priv->cell_view_frame)->style->xthickness;
- delta_y = GTK_CONTAINER (priv->cell_view_frame)->border_width +
- GTK_WIDGET (priv->cell_view_frame)->style->ythickness;
+ border_width = gtk_container_get_border_width (GTK_CONTAINER (priv->cell_view_frame));
+ style = gtk_widget_get_style (priv->cell_view_frame);
+ delta_x = border_width + style->xthickness;
+ delta_y = border_width + style->ythickness;
child.x += delta_x;
child.y += delta_y;
child.width = MAX (1, child.width);
child.height = MAX (1, child.height);
- gtk_widget_size_allocate (GTK_BIN (combo_box)->child, &child);
+ gtk_widget_size_allocate (child_widget, &child);
}
}
{
GtkComboBox *combo_box = GTK_COMBO_BOX (container);
GtkComboBoxPrivate *priv = combo_box->priv;
+ GtkWidget *child;
if (include_internals)
{
(* callback) (priv->cell_view_frame, callback_data);
}
- if (GTK_BIN (container)->child)
- (* callback) (GTK_BIN (container)->child, callback_data);
+ child = gtk_bin_get_child (GTK_BIN (container));
+ if (child)
+ (* callback) (child, callback_data);
}
static void
}
static gboolean
-gtk_combo_box_expose_event (GtkWidget *widget,
- GdkEventExpose *event)
+gtk_combo_box_draw (GtkWidget *widget,
+ cairo_t *cr)
{
GtkComboBox *combo_box = GTK_COMBO_BOX (widget);
GtkComboBoxPrivate *priv = combo_box->priv;
- if (gtk_widget_is_drawable (widget) &&
- GTK_SHADOW_NONE != priv->shadow_type)
+ if (priv->shadow_type != GTK_SHADOW_NONE)
{
- gtk_paint_shadow (widget->style, widget->window,
+ gtk_paint_shadow (gtk_widget_get_style (widget),
+ cr,
GTK_STATE_NORMAL, priv->shadow_type,
- NULL, widget, "combobox",
- widget->allocation.x, widget->allocation.y,
- widget->allocation.width, widget->allocation.height);
+ widget, "combobox",
+ 0, 0,
+ gtk_widget_get_allocated_width (widget),
+ gtk_widget_get_allocated_height (widget));
}
- gtk_container_propagate_expose (GTK_CONTAINER (widget),
- priv->button, event);
+ gtk_container_propagate_draw (GTK_CONTAINER (widget),
+ priv->button, cr);
if (priv->tree_view && priv->cell_view_frame)
{
- gtk_container_propagate_expose (GTK_CONTAINER (widget),
- priv->cell_view_frame, event);
+ gtk_container_propagate_draw (GTK_CONTAINER (widget),
+ priv->cell_view_frame, cr);
}
- gtk_container_propagate_expose (GTK_CONTAINER (widget),
- GTK_BIN (widget)->child, event);
+ gtk_container_propagate_draw (GTK_CONTAINER (widget),
+ gtk_bin_get_child (GTK_BIN (widget)),
+ cr);
return FALSE;
}
gboolean add_children)
{
GtkComboBoxPrivate *priv = combo_box->priv;
+ GtkWidget *child;
GtkWidget *menu;
+ child = gtk_bin_get_child (GTK_BIN (combo_box));
+
if (priv->cell_view)
{
priv->button = gtk_toggle_button_new ();
g_signal_connect (priv->button, "toggled",
G_CALLBACK (gtk_combo_box_button_toggled), combo_box);
gtk_widget_set_parent (priv->button,
- GTK_BIN (combo_box)->child->parent);
+ gtk_widget_get_parent (child));
- priv->box = gtk_hbox_new (FALSE, 0);
+ priv->box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, FALSE, 0);
gtk_container_add (GTK_CONTAINER (priv->button), priv->box);
- priv->separator = gtk_vseparator_new ();
+ priv->separator = gtk_separator_new (GTK_ORIENTATION_VERTICAL);
gtk_container_add (GTK_CONTAINER (priv->box), priv->separator);
priv->arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_NONE);
g_signal_connect (priv->button, "toggled",
G_CALLBACK (gtk_combo_box_button_toggled), combo_box);
gtk_widget_set_parent (priv->button,
- GTK_BIN (combo_box)->child->parent);
+ gtk_widget_get_parent (child));
priv->arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_NONE);
gtk_container_add (GTK_CONTAINER (priv->button), priv->arrow);
gtk_tree_path_free (path);
gtk_combo_box_sync_cells (combo_box, GTK_CELL_LAYOUT (cell_view));
- gtk_widget_size_request (cell_view, &req);
+ gtk_widget_get_preferred_size (cell_view, &req, NULL);
gtk_widget_show (cell_view);
return item;
GtkTreePath *path;
GtkTreeIter iter;
- cell_view = GTK_BIN (item)->child;
+ cell_view = gtk_bin_get_child (GTK_BIN (item));
g_return_if_fail (GTK_IS_CELL_VIEW (cell_view));
gboolean skip_first)
{
GList *i, *list;
+ GtkWidget *child;
GtkWidget *item;
GtkWidget *submenu;
GtkTreeRowReference *mref;
item = NULL;
for (i = list; i; i = i->next)
{
+ child = gtk_bin_get_child (i->data);
if (GTK_IS_SEPARATOR_MENU_ITEM (i->data))
{
mref = g_object_get_data (G_OBJECT (i->data), "gtk-combo-box-item-path");
else
mpath = gtk_tree_row_reference_get_path (mref);
}
- else if (GTK_IS_CELL_VIEW (GTK_BIN (i->data)->child))
+ else if (GTK_IS_CELL_VIEW (child))
{
if (skip)
{
continue;
}
- mpath = gtk_cell_view_get_displayed_row (GTK_CELL_VIEW (GTK_BIN (i->data)->child));
+ mpath = gtk_cell_view_get_displayed_row (GTK_CELL_VIEW (child));
}
else
continue;
combo_box);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), separator);
- if (cell_view_is_sensitive (GTK_CELL_VIEW (GTK_BIN (item)->child)))
+ if (cell_view_is_sensitive (GTK_CELL_VIEW (gtk_bin_get_child (GTK_BIN (item)))))
{
gtk_widget_show (item);
gtk_widget_show (separator);
GtkComboBox *combo_box = GTK_COMBO_BOX (user_data);
GtkComboBoxPrivate *priv = combo_box->priv;
GtkWidget *item;
- gint width;
gboolean is_separator;
if (!priv->popup_widget)
gtk_combo_box_menu_row_inserted (model, path, iter, combo_box);
}
- if (priv->wrap_width && item->parent == priv->popup_widget)
+ if (priv->wrap_width &&
+ gtk_widget_get_parent (item) == priv->popup_widget)
{
GtkWidget *pitem = NULL;
GtkTreePath *prev;
gtk_combo_box_relayout_item (combo_box, item, iter, pitem);
}
- width = gtk_combo_box_calc_requested_width (combo_box, path);
-
- if (width > priv->width)
- {
- if (priv->cell_view)
- {
- gtk_widget_set_size_request (priv->cell_view, width, -1);
- gtk_widget_queue_resize (priv->cell_view);
- }
- priv->width = width;
- }
+ gtk_combo_box_update_requested_width (combo_box, path);
}
/*
GtkComboBoxPrivate *priv = combo_box->priv;
GtkTreeSelection *sel;
GtkStyle *style;
+ GtkWidget *child;
GtkWidget *widget = GTK_WIDGET (combo_box);
priv->button = gtk_toggle_button_new ();
+ child = gtk_bin_get_child (GTK_BIN (combo_box));
gtk_widget_set_parent (priv->button,
- GTK_BIN (combo_box)->child->parent);
+ gtk_widget_get_parent (child));
g_signal_connect (priv->button, "button-press-event",
G_CALLBACK (gtk_combo_box_list_button_pressed), combo_box);
g_signal_connect (priv->button, "toggled",
gtk_event_box_set_visible_window (GTK_EVENT_BOX (combo_box->priv->cell_view_frame),
FALSE);
}
-
+
gtk_widget_set_parent (priv->cell_view_frame,
- GTK_BIN (combo_box)->child->parent);
+ gtk_widget_get_parent (child));
gtk_container_add (GTK_CONTAINER (priv->cell_view_frame), priv->box);
gtk_widget_show_all (priv->cell_view_frame);
!gtk_widget_has_focus (priv->button))
gtk_widget_grab_focus (priv->button);
- gtk_combo_box_popup (combo_box);
+ gtk_combo_box_popup_for_device (combo_box, event->device);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->button), TRUE);
{
GtkComboBox *combo_box = GTK_COMBO_BOX (data);
- if (!gtk_bindings_activate_event (GTK_OBJECT (widget), event))
+ if (!gtk_bindings_activate_event (G_OBJECT (widget), event))
{
/* The menu hasn't managed the
* event, forward it to the combobox
*/
- gtk_bindings_activate_event (GTK_OBJECT (combo_box), event);
+ gtk_bindings_activate_event (G_OBJECT (combo_box), event);
}
return TRUE;
GtkComboBox *combo_box = GTK_COMBO_BOX (data);
GtkTreeIter iter;
- if (event->keyval == GDK_Return || event->keyval == GDK_ISO_Enter || event->keyval == GDK_KP_Enter ||
- event->keyval == GDK_space || event->keyval == GDK_KP_Space)
+ if (event->keyval == GDK_KEY_Return || event->keyval == GDK_KEY_ISO_Enter || event->keyval == GDK_KEY_KP_Enter ||
+ event->keyval == GDK_KEY_space || event->keyval == GDK_KEY_KP_Space)
{
GtkTreeModel *model = NULL;
return TRUE;
}
- if (!gtk_bindings_activate_event (GTK_OBJECT (widget), event))
+ if (!gtk_bindings_activate_event (G_OBJECT (widget), event))
{
/* The list hasn't managed the
* event, forward it to the combobox
*/
- gtk_bindings_activate_event (GTK_OBJECT (combo_box), event);
+ gtk_bindings_activate_event (G_OBJECT (combo_box), event);
}
return TRUE;
gint x,
gint y)
{
- GtkWidget *tree_view = combo_box->priv->tree_view;
GtkAdjustment *adj;
+ GtkAllocation allocation;
+ GtkWidget *tree_view = combo_box->priv->tree_view;
gdouble value;
+ gtk_widget_get_allocation (tree_view, &allocation);
+
adj = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (combo_box->priv->scrolled_window));
if (adj && adj->upper - adj->lower > adj->page_size)
{
- if (x <= tree_view->allocation.x &&
+ if (x <= allocation.x &&
adj->lower < adj->value)
{
- value = adj->value - (tree_view->allocation.x - x + 1);
- gtk_adjustment_set_value (adj, CLAMP (value, adj->lower, adj->upper - adj->page_size));
+ value = adj->value - (allocation.x - x + 1);
+ gtk_adjustment_set_value (adj, value);
}
- else if (x >= tree_view->allocation.x + tree_view->allocation.width &&
+ else if (x >= allocation.x + allocation.width &&
adj->upper - adj->page_size > adj->value)
{
- value = adj->value + (x - tree_view->allocation.x - tree_view->allocation.width + 1);
- gtk_adjustment_set_value (adj, CLAMP (value, 0.0, adj->upper - adj->page_size));
+ value = adj->value + (x - allocation.x - allocation.width + 1);
+ gtk_adjustment_set_value (adj, MAX (value, 0.0));
}
}
adj = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (combo_box->priv->scrolled_window));
if (adj && adj->upper - adj->lower > adj->page_size)
{
- if (y <= tree_view->allocation.y &&
+ if (y <= allocation.y &&
adj->lower < adj->value)
{
- value = adj->value - (tree_view->allocation.y - y + 1);
- gtk_adjustment_set_value (adj, CLAMP (value, adj->lower, adj->upper - adj->page_size));
+ value = adj->value - (allocation.y - y + 1);
+ gtk_adjustment_set_value (adj, value);
}
- else if (y >= tree_view->allocation.height &&
+ else if (y >= allocation.height &&
adj->upper - adj->page_size > adj->value)
{
- value = adj->value + (y - tree_view->allocation.height + 1);
- gtk_adjustment_set_value (adj, CLAMP (value, 0.0, adj->upper - adj->page_size));
+ value = adj->value + (y - allocation.height + 1);
+ gtk_adjustment_set_value (adj, MAX (value, 0.0));
}
}
}
if (priv->auto_scroll)
{
- gdk_window_get_pointer (priv->tree_view->window, &x, &y, NULL);
+ gdk_window_get_device_position (gtk_widget_get_window (priv->tree_view),
+ priv->grab_pointer,
+ &x, &y, NULL);
gtk_combo_box_list_auto_scroll (combo_box, x, y);
}
gpointer data)
{
GtkComboBox *combo_box = GTK_COMBO_BOX (data);
- GtkComboBoxPrivate *priv = combo_box->priv;
- gint width;
-
- width = gtk_combo_box_calc_requested_width (combo_box, path);
- if (width > priv->width)
- {
- if (priv->cell_view)
- {
- gtk_widget_set_size_request (priv->cell_view, width, -1);
- gtk_widget_queue_resize (priv->cell_view);
- }
- priv->width = width;
- }
+ gtk_combo_box_update_requested_width (combo_box, path);
}
/*
gboolean expand)
{
GList *i, *list;
+ GtkWidget *child;
GtkWidget *submenu;
list = gtk_container_get_children (GTK_CONTAINER (menu));
for (i = list; i; i = i->next)
{
- if (GTK_IS_CELL_LAYOUT (GTK_BIN (i->data)->child))
- gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (GTK_BIN (i->data)->child),
- cell, expand);
+ child = gtk_bin_get_child (GTK_BIN (i->data));
+ if (GTK_IS_CELL_LAYOUT (child))
+ gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (child),
+ cell, expand);
submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (i->data));
if (submenu != NULL)
priv->cells = g_slist_append (priv->cells, info);
if (priv->cell_view)
- gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (priv->cell_view),
- cell, expand);
+ {
+ gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (priv->cell_view),
+ cell, expand);
+
+ }
if (priv->column)
gtk_tree_view_column_pack_start (priv->column, cell, expand);
gboolean expand)
{
GList *i, *list;
+ GtkWidget *child;
GtkWidget *submenu;
list = gtk_container_get_children (GTK_CONTAINER (menu));
for (i = list; i; i = i->next)
{
- if (GTK_IS_CELL_LAYOUT (GTK_BIN (i->data)->child))
- gtk_cell_layout_pack_end (GTK_CELL_LAYOUT (GTK_BIN (i->data)->child),
- cell, expand);
+ child = gtk_bin_get_child (GTK_BIN (i->data));
+ if (GTK_IS_CELL_LAYOUT (child))
+ gtk_cell_layout_pack_end (GTK_CELL_LAYOUT (child),
+ cell, expand);
submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (i->data));
if (submenu != NULL)
clear_recurse (GtkWidget *menu)
{
GList *i, *list;
+ GtkWidget *child;
GtkWidget *submenu;
list = gtk_container_get_children (GTK_CONTAINER (menu));
for (i = list; i; i = i->next)
{
- if (GTK_IS_CELL_LAYOUT (GTK_BIN (i->data)->child))
- gtk_cell_layout_clear (GTK_CELL_LAYOUT (GTK_BIN (i->data)->child));
+ child = gtk_bin_get_child (GTK_BIN (i->data));
+ if (GTK_IS_CELL_LAYOUT (child))
+ gtk_cell_layout_clear (GTK_CELL_LAYOUT (child));
submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (i->data));
if (submenu != NULL)
gint column)
{
GList *i, *list;
+ GtkWidget *child;
GtkWidget *submenu;
-
+
list = gtk_container_get_children (GTK_CONTAINER (menu));
for (i = list; i; i = i->next)
{
- if (GTK_IS_CELL_LAYOUT (GTK_BIN (i->data)->child))
- gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (GTK_BIN (i->data)->child),
- cell, attribute, column);
+ child = gtk_bin_get_child (GTK_BIN (i->data));
+ if (GTK_IS_CELL_LAYOUT (child))
+ gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (child),
+ cell, attribute, column);
submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (i->data));
if (submenu != NULL)
list = gtk_container_get_children (GTK_CONTAINER (menu));
for (i = list; i; i = i->next)
{
- cell_view = GTK_BIN (i->data)->child;
+ cell_view = gtk_bin_get_child (GTK_BIN (i->data));
if (GTK_IS_CELL_LAYOUT (cell_view))
{
/* Override sensitivity for inner nodes; we don't
GtkCellRenderer *cell)
{
GList *i, *list;
- GtkWidget *submenu;
-
+ GtkWidget *submenu;
+ GtkWidget *child;
+
list = gtk_container_get_children (GTK_CONTAINER (menu));
for (i = list; i; i = i->next)
{
- if (GTK_IS_CELL_LAYOUT (GTK_BIN (i->data)->child))
- gtk_cell_layout_clear_attributes (GTK_CELL_LAYOUT (GTK_BIN (i->data)->child),
- cell);
-
+ child = gtk_bin_get_child (GTK_BIN (i->data));
+ if (GTK_IS_CELL_LAYOUT (child))
+ gtk_cell_layout_clear_attributes (GTK_CELL_LAYOUT (child), cell);
+
submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (i->data));
if (submenu != NULL)
clear_attributes_recurse (submenu, cell);
gint position)
{
GList *i, *list;
+ GtkWidget *child;
GtkWidget *submenu;
-
+
list = gtk_container_get_children (GTK_CONTAINER (menu));
for (i = list; i; i = i->next)
{
- if (GTK_IS_CELL_LAYOUT (GTK_BIN (i->data)->child))
- gtk_cell_layout_reorder (GTK_CELL_LAYOUT (GTK_BIN (i->data)->child),
- cell, position);
-
+ child = gtk_bin_get_child (GTK_BIN (i->data));
+ if (GTK_IS_CELL_LAYOUT (child))
+ gtk_cell_layout_reorder (GTK_CELL_LAYOUT (child),
+ cell, position);
+
submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (i->data));
if (submenu != NULL)
reorder_recurse (submenu, cell, position);
return g_object_new (GTK_TYPE_COMBO_BOX, NULL);
}
+/**
+ * gtk_combo_box_new_with_entry:
+ *
+ * Creates a new empty #GtkComboBox with an entry.
+ *
+ * Return value: A new #GtkComboBox.
+ */
+GtkWidget *
+gtk_combo_box_new_with_entry (void)
+{
+ return g_object_new (GTK_TYPE_COMBO_BOX, "has-entry", TRUE, NULL);
+}
+
/**
* gtk_combo_box_new_with_model:
* @model: A #GtkTreeModel.
return GTK_WIDGET (combo_box);
}
+/**
+ * gtk_combo_box_new_with_model_and_entry:
+ *
+ * Creates a new empty #GtkComboBox with an entry
+ * and with the model initialized to @model.
+ *
+ * Return value: A new #GtkComboBox
+ */
+GtkWidget *
+gtk_combo_box_new_with_model_and_entry (GtkTreeModel *model)
+{
+ return g_object_new (GTK_TYPE_COMBO_BOX,
+ "has-entry", TRUE,
+ "model", model,
+ NULL);
+}
+
/**
* gtk_combo_box_get_wrap_width:
* @combo_box: A #GtkComboBox
/**
* gtk_combo_box_get_active_iter:
* @combo_box: A #GtkComboBox
- * @iter: The uninitialized #GtkTreeIter
+ * @iter: (out): The uninitialized #GtkTreeIter
*
* Sets @iter to point to the current active item, if it exists.
*
*
* Sets the current active item to be the one referenced by @iter, or
* unsets the active item if @iter is %NULL.
- *
- * @iter must correspond to a path of depth one, or be %NULL.
*
* Since: 2.4
*/
}
/**
- * gtk_combo_box_get_model
+ * gtk_combo_box_get_model:
* @combo_box: A #GtkComboBox
*
* Returns the #GtkTreeModel which is acting as data source for @combo_box.
*
- * Return value: (transfer none): A #GtkTreeModel which was passed during construction.
+ * Return value: (transfer none): A #GtkTreeModel which was passed
+ * during construction.
*
* Since: 2.4
*/
return combo_box->priv->model;
}
-
-/* convenience API for simple text combos */
-
-/**
- * gtk_combo_box_new_text:
- *
- * Convenience function which constructs a new text combo box, which is a
- * #GtkComboBox just displaying strings. If you use this function to create
- * a text combo box, you should only manipulate its data source with the
- * following convenience functions: gtk_combo_box_append_text(),
- * gtk_combo_box_insert_text(), gtk_combo_box_prepend_text() and
- * gtk_combo_box_remove_text().
- *
- * Return value: (transfer none): A new text combo box.
- *
- * Since: 2.4
- */
-GtkWidget *
-gtk_combo_box_new_text (void)
+static void
+gtk_combo_box_real_move_active (GtkComboBox *combo_box,
+ GtkScrollType scroll)
{
- GtkWidget *combo_box;
- GtkCellRenderer *cell;
- GtkListStore *store;
+ GtkTreeIter iter;
+ GtkTreeIter new_iter;
+ gboolean active_iter;
+ gboolean found;
- store = gtk_list_store_new (1, G_TYPE_STRING);
- combo_box = gtk_combo_box_new_with_model (GTK_TREE_MODEL (store));
- g_object_unref (store);
+ if (!combo_box->priv->model)
+ {
+ gtk_widget_error_bell (GTK_WIDGET (combo_box));
+ return;
+ }
- cell = gtk_cell_renderer_text_new ();
- gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), cell, TRUE);
- gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), cell,
- "text", 0,
- NULL);
+ active_iter = gtk_combo_box_get_active_iter (combo_box, &iter);
- return combo_box;
-}
+ switch (scroll)
+ {
+ case GTK_SCROLL_STEP_BACKWARD:
+ case GTK_SCROLL_STEP_UP:
+ case GTK_SCROLL_STEP_LEFT:
+ if (active_iter)
+ {
+ found = tree_prev (combo_box, combo_box->priv->model,
+ &iter, &new_iter, FALSE);
+ break;
+ }
+ /* else fall through */
-/**
- * gtk_combo_box_append_text:
- * @combo_box: A #GtkComboBox constructed using gtk_combo_box_new_text()
- * @text: A string
- *
- * Appends @string to the list of strings stored in @combo_box. Note that
- * you can only use this function with combo boxes constructed with
- * gtk_combo_box_new_text().
- *
- * Since: 2.4
- */
-void
-gtk_combo_box_append_text (GtkComboBox *combo_box,
- const gchar *text)
-{
- GtkTreeIter iter;
- GtkListStore *store;
+ case GTK_SCROLL_PAGE_FORWARD:
+ case GTK_SCROLL_PAGE_DOWN:
+ case GTK_SCROLL_PAGE_RIGHT:
+ case GTK_SCROLL_END:
+ found = tree_last (combo_box, combo_box->priv->model, &new_iter, FALSE);
+ break;
- g_return_if_fail (GTK_IS_COMBO_BOX (combo_box));
- g_return_if_fail (GTK_IS_LIST_STORE (combo_box->priv->model));
- g_return_if_fail (gtk_tree_model_get_column_type (combo_box->priv->model, 0)
- == G_TYPE_STRING);
- g_return_if_fail (text != NULL);
+ case GTK_SCROLL_STEP_FORWARD:
+ case GTK_SCROLL_STEP_DOWN:
+ case GTK_SCROLL_STEP_RIGHT:
+ if (active_iter)
+ {
+ found = tree_next (combo_box, combo_box->priv->model,
+ &iter, &new_iter, FALSE);
+ break;
+ }
+ /* else fall through */
- store = GTK_LIST_STORE (combo_box->priv->model);
+ case GTK_SCROLL_PAGE_BACKWARD:
+ case GTK_SCROLL_PAGE_UP:
+ case GTK_SCROLL_PAGE_LEFT:
+ case GTK_SCROLL_START:
+ found = tree_first (combo_box, combo_box->priv->model, &new_iter, FALSE);
+ break;
- gtk_list_store_append (store, &iter);
- gtk_list_store_set (store, &iter, 0, text, -1);
-}
+ default:
+ return;
+ }
-/**
- * gtk_combo_box_insert_text:
- * @combo_box: A #GtkComboBox constructed using gtk_combo_box_new_text()
- * @position: An index to insert @text
- * @text: A string
- *
- * Inserts @string at @position in the list of strings stored in @combo_box.
- * Note that you can only use this function with combo boxes constructed
- * with gtk_combo_box_new_text().
- *
- * Since: 2.4
- */
-void
-gtk_combo_box_insert_text (GtkComboBox *combo_box,
- gint position,
- const gchar *text)
-{
- GtkTreeIter iter;
- GtkListStore *store;
+ if (found && active_iter)
+ {
+ GtkTreePath *old_path;
+ GtkTreePath *new_path;
- g_return_if_fail (GTK_IS_COMBO_BOX (combo_box));
- g_return_if_fail (GTK_IS_LIST_STORE (combo_box->priv->model));
- g_return_if_fail (position >= 0);
- g_return_if_fail (gtk_tree_model_get_column_type (combo_box->priv->model, 0)
- == G_TYPE_STRING);
- g_return_if_fail (text != NULL);
+ old_path = gtk_tree_model_get_path (combo_box->priv->model, &iter);
+ new_path = gtk_tree_model_get_path (combo_box->priv->model, &new_iter);
- store = GTK_LIST_STORE (combo_box->priv->model);
+ if (gtk_tree_path_compare (old_path, new_path) == 0)
+ found = FALSE;
- gtk_list_store_insert (store, &iter, position);
- gtk_list_store_set (store, &iter, 0, text, -1);
-}
-
-/**
- * gtk_combo_box_prepend_text:
- * @combo_box: A #GtkComboBox constructed with gtk_combo_box_new_text()
- * @text: A string
- *
- * Prepends @string to the list of strings stored in @combo_box. Note that
- * you can only use this function with combo boxes constructed with
- * gtk_combo_box_new_text().
- *
- * Since: 2.4
- */
-void
-gtk_combo_box_prepend_text (GtkComboBox *combo_box,
- const gchar *text)
-{
- GtkTreeIter iter;
- GtkListStore *store;
-
- g_return_if_fail (GTK_IS_COMBO_BOX (combo_box));
- g_return_if_fail (GTK_IS_LIST_STORE (combo_box->priv->model));
- g_return_if_fail (gtk_tree_model_get_column_type (combo_box->priv->model, 0)
- == G_TYPE_STRING);
- g_return_if_fail (text != NULL);
-
- store = GTK_LIST_STORE (combo_box->priv->model);
-
- gtk_list_store_prepend (store, &iter);
- gtk_list_store_set (store, &iter, 0, text, -1);
-}
-
-/**
- * gtk_combo_box_remove_text:
- * @combo_box: A #GtkComboBox constructed with gtk_combo_box_new_text()
- * @position: Index of the item to remove
- *
- * Removes the string at @position from @combo_box. Note that you can only use
- * this function with combo boxes constructed with gtk_combo_box_new_text().
- *
- * Since: 2.4
- */
-void
-gtk_combo_box_remove_text (GtkComboBox *combo_box,
- gint position)
-{
- GtkTreeIter iter;
- GtkListStore *store;
-
- g_return_if_fail (GTK_IS_COMBO_BOX (combo_box));
- g_return_if_fail (GTK_IS_LIST_STORE (combo_box->priv->model));
- g_return_if_fail (gtk_tree_model_get_column_type (combo_box->priv->model, 0)
- == G_TYPE_STRING);
- g_return_if_fail (position >= 0);
-
- store = GTK_LIST_STORE (combo_box->priv->model);
-
- if (gtk_tree_model_iter_nth_child (combo_box->priv->model, &iter,
- NULL, position))
- gtk_list_store_remove (store, &iter);
-}
-
-/**
- * gtk_combo_box_get_active_text:
- * @combo_box: A #GtkComboBox constructed with gtk_combo_box_new_text()
- *
- * Returns the currently active string in @combo_box or %NULL if none
- * is selected. Note that you can only use this function with combo
- * boxes constructed with gtk_combo_box_new_text() and with
- * #GtkComboBoxEntry<!-- -->s.
- *
- * Returns: a newly allocated string containing the currently active text.
- * Must be freed with g_free().
- *
- * Since: 2.6
- */
-gchar *
-gtk_combo_box_get_active_text (GtkComboBox *combo_box)
-{
- GtkComboBoxClass *class;
-
- g_return_val_if_fail (GTK_IS_COMBO_BOX (combo_box), NULL);
-
- class = GTK_COMBO_BOX_GET_CLASS (combo_box);
-
- if (class->get_active_text)
- return class->get_active_text (combo_box);
-
- return NULL;
-}
-
-static gchar *
-gtk_combo_box_real_get_active_text (GtkComboBox *combo_box)
-{
- GtkTreeIter iter;
- gchar *text = NULL;
-
- g_return_val_if_fail (GTK_IS_LIST_STORE (combo_box->priv->model), NULL);
- g_return_val_if_fail (gtk_tree_model_get_column_type (combo_box->priv->model, 0)
- == G_TYPE_STRING, NULL);
-
- if (gtk_combo_box_get_active_iter (combo_box, &iter))
- gtk_tree_model_get (combo_box->priv->model, &iter,
- 0, &text, -1);
-
- return text;
-}
-
-static void
-gtk_combo_box_real_move_active (GtkComboBox *combo_box,
- GtkScrollType scroll)
-{
- GtkTreeIter iter;
- GtkTreeIter new_iter;
- gboolean active_iter;
- gboolean found;
-
- if (!combo_box->priv->model)
- {
- gtk_widget_error_bell (GTK_WIDGET (combo_box));
- return;
- }
-
- active_iter = gtk_combo_box_get_active_iter (combo_box, &iter);
-
- switch (scroll)
- {
- case GTK_SCROLL_STEP_BACKWARD:
- case GTK_SCROLL_STEP_UP:
- case GTK_SCROLL_STEP_LEFT:
- if (active_iter)
- {
- found = tree_prev (combo_box, combo_box->priv->model,
- &iter, &new_iter, FALSE);
- break;
- }
- /* else fall through */
-
- case GTK_SCROLL_PAGE_FORWARD:
- case GTK_SCROLL_PAGE_DOWN:
- case GTK_SCROLL_PAGE_RIGHT:
- case GTK_SCROLL_END:
- found = tree_last (combo_box, combo_box->priv->model, &new_iter, FALSE);
- break;
-
- case GTK_SCROLL_STEP_FORWARD:
- case GTK_SCROLL_STEP_DOWN:
- case GTK_SCROLL_STEP_RIGHT:
- if (active_iter)
- {
- found = tree_next (combo_box, combo_box->priv->model,
- &iter, &new_iter, FALSE);
- break;
- }
- /* else fall through */
-
- case GTK_SCROLL_PAGE_BACKWARD:
- case GTK_SCROLL_PAGE_UP:
- case GTK_SCROLL_PAGE_LEFT:
- case GTK_SCROLL_START:
- found = tree_first (combo_box, combo_box->priv->model, &new_iter, FALSE);
- break;
-
- default:
- return;
- }
-
- if (found && active_iter)
- {
- GtkTreePath *old_path;
- GtkTreePath *new_path;
-
- old_path = gtk_tree_model_get_path (combo_box->priv->model, &iter);
- new_path = gtk_tree_model_get_path (combo_box->priv->model, &new_iter);
-
- if (gtk_tree_path_compare (old_path, new_path) == 0)
- found = FALSE;
-
- gtk_tree_path_free (old_path);
- gtk_tree_path_free (new_path);
- }
+ gtk_tree_path_free (old_path);
+ gtk_tree_path_free (new_path);
+ }
if (found)
{
{
GtkComboBox *combo_box = GTK_COMBO_BOX (widget);
- gtk_widget_grab_focus (combo_box->priv->button);
+ if (combo_box->priv->has_entry)
+ {
+ GtkWidget* child;
+
+ child = gtk_bin_get_child (GTK_BIN (combo_box));
+ if (child)
+ gtk_widget_grab_focus (child);
+ }
+ else
+ gtk_widget_grab_focus (combo_box->priv->button);
return TRUE;
}
{
GtkComboBox *combo_box = GTK_COMBO_BOX (widget);
- gtk_widget_grab_focus (combo_box->priv->button);
+ if (combo_box->priv->has_entry)
+ {
+ GtkWidget *child;
+
+ child = gtk_bin_get_child (GTK_BIN (combo_box));
+ if (child)
+ gtk_widget_grab_focus (child);
+ }
+ else
+ gtk_widget_grab_focus (combo_box->priv->button);
}
static void
-gtk_combo_box_destroy (GtkObject *object)
+gtk_combo_box_destroy (GtkWidget *widget)
{
- GtkComboBox *combo_box = GTK_COMBO_BOX (object);
+ GtkComboBox *combo_box = GTK_COMBO_BOX (widget);
if (combo_box->priv->popup_idle_id > 0)
{
combo_box->priv->row_separator_data = NULL;
combo_box->priv->row_separator_destroy = NULL;
- GTK_OBJECT_CLASS (gtk_combo_box_parent_class)->destroy (object);
+ GTK_WIDGET_CLASS (gtk_combo_box_parent_class)->destroy (widget);
combo_box->priv->cell_view = NULL;
}
+static void
+gtk_combo_box_entry_contents_changed (GtkEntry *entry,
+ gpointer user_data)
+{
+ GtkComboBox *combo_box = GTK_COMBO_BOX (user_data);
+
+ /*
+ * Fixes regression reported in bug #574059. The old functionality relied on
+ * bug #572478. As a bugfix, we now emit the "changed" signal ourselves
+ * when the selection was already set to -1.
+ */
+ if (gtk_combo_box_get_active(combo_box) == -1)
+ g_signal_emit_by_name (combo_box, "changed");
+ else
+ gtk_combo_box_set_active (combo_box, -1);
+}
+
+static void
+gtk_combo_box_entry_active_changed (GtkComboBox *combo_box,
+ gpointer user_data)
+{
+ GtkComboBoxPrivate *priv = combo_box->priv;
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+
+ if (gtk_combo_box_get_active_iter (combo_box, &iter))
+ {
+ GtkEntry *entry = GTK_ENTRY (gtk_bin_get_child (GTK_BIN (combo_box)));
+
+ if (entry)
+ {
+ GValue value = {0,};
+
+ g_signal_handlers_block_by_func (entry,
+ gtk_combo_box_entry_contents_changed,
+ combo_box);
+
+ model = gtk_combo_box_get_model (combo_box);
+
+ gtk_tree_model_get_value (model, &iter,
+ priv->text_column, &value);
+ g_object_set_property (G_OBJECT (entry), "text", &value);
+ g_value_unset (&value);
+
+ g_signal_handlers_unblock_by_func (entry,
+ gtk_combo_box_entry_contents_changed,
+ combo_box);
+ }
+ }
+}
+
+static GObject *
+gtk_combo_box_constructor (GType type,
+ guint n_construct_properties,
+ GObjectConstructParam *construct_properties)
+{
+ GObject *object;
+ GtkComboBox *combo_box;
+ GtkComboBoxPrivate *priv;
+
+ object = G_OBJECT_CLASS (gtk_combo_box_parent_class)->constructor
+ (type, n_construct_properties, construct_properties);
+
+ combo_box = GTK_COMBO_BOX (object);
+ priv = combo_box->priv;
+
+ if (priv->has_entry)
+ {
+ GtkWidget *entry;
+
+ entry = gtk_entry_new ();
+ gtk_widget_show (entry);
+ gtk_container_add (GTK_CONTAINER (combo_box), entry);
+
+ priv->text_renderer = gtk_cell_renderer_text_new ();
+ gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box),
+ priv->text_renderer, TRUE);
+
+ gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), -1);
+
+ g_signal_connect (combo_box, "changed",
+ G_CALLBACK (gtk_combo_box_entry_active_changed), NULL);
+ }
+
+ return object;
+}
+
+
static void
gtk_combo_box_dispose(GObject* object)
{
G_OBJECT_CLASS (gtk_combo_box_parent_class)->finalize (object);
}
+
static gboolean
gtk_cell_editable_key_press (GtkWidget *widget,
GdkEventKey *event,
{
GtkComboBox *combo_box = GTK_COMBO_BOX (data);
- if (event->keyval == GDK_Escape)
+ if (event->keyval == GDK_KEY_Escape)
{
g_object_set (combo_box,
"editing-canceled", TRUE,
return TRUE;
}
- else if (event->keyval == GDK_Return ||
- event->keyval == GDK_ISO_Enter ||
- event->keyval == GDK_KP_Enter)
+ else if (event->keyval == GDK_KEY_Return ||
+ event->keyval == GDK_KEY_ISO_Enter ||
+ event->keyval == GDK_KEY_KP_Enter)
{
gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (combo_box));
gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (combo_box));
GdkEvent *event)
{
GtkComboBox *combo_box = GTK_COMBO_BOX (cell_editable);
+ GtkWidget *child;
combo_box->priv->is_cell_renderer = TRUE;
}
else
{
- g_signal_connect_object (GTK_BIN (combo_box)->child, "key-press-event",
+ child = gtk_bin_get_child (GTK_BIN (combo_box));
+
+ g_signal_connect_object (child, "key-press-event",
G_CALLBACK (gtk_cell_editable_key_press),
cell_editable, 0);
- gtk_widget_grab_focus (GTK_WIDGET (GTK_BIN (combo_box)->child));
+ gtk_widget_grab_focus (child);
gtk_widget_set_can_focus (combo_box->priv->button, FALSE);
}
}
}
+
+/**
+ * gtk_combo_box_set_popup_fixed_width:
+ * @combo_box: a #GtkComboBox
+ * @fixed: whether to use a fixed popup width
+ *
+ * Specifies whether the popup's width should be a fixed width
+ * matching the allocated width of the combo box.
+ *
+ * Since: 3.0
+ **/
+void
+gtk_combo_box_set_popup_fixed_width (GtkComboBox *combo_box,
+ gboolean fixed)
+{
+ g_return_if_fail (GTK_IS_COMBO_BOX (combo_box));
+
+ if (combo_box->priv->popup_fixed_width != fixed)
+ {
+ combo_box->priv->popup_fixed_width = fixed;
+
+ g_object_notify (G_OBJECT (combo_box), "popup-fixed-width");
+ }
+}
+
+/**
+ * gtk_combo_box_get_popup_fixed_width:
+ * @combo_box: a #GtkComboBox
+ *
+ * Gets whether the popup uses a fixed width matching
+ * the allocated width of the combo box.
+ *
+ * Returns: %TRUE if the popup uses a fixed width
+ *
+ * Since: 3.0
+ **/
+gboolean
+gtk_combo_box_get_popup_fixed_width (GtkComboBox *combo_box)
+{
+ g_return_val_if_fail (GTK_IS_COMBO_BOX (combo_box), FALSE);
+
+ return combo_box->priv->popup_fixed_width;
+}
+
+
/**
* gtk_combo_box_get_popup_accessible:
* @combo_box: a #GtkComboBox
* This function is mostly intended for use by accessibility technologies;
* applications should have little use for it.
*
- * Returns: the accessible object corresponding to the combo box's popup.
+ * Returns: (transfer none): the accessible object corresponding
+ * to the combo box's popup.
*
* Since: 2.6
*/
}
+/**
+ * gtk_combo_box_get_has_entry:
+ * @combo_box: a #GtkComboBox
+ *
+ * Returns whether the combo box has an entry.
+ *
+ * Return Value: whether there is an entry in @combo_box.
+ *
+ * Since: 2.24
+ **/
+gboolean
+gtk_combo_box_get_has_entry (GtkComboBox *combo_box)
+{
+ g_return_val_if_fail (GTK_IS_COMBO_BOX (combo_box), FALSE);
+
+ return combo_box->priv->has_entry;
+}
+
+/**
+ * gtk_combo_box_set_entry_text_column:
+ * @combo_box: A #GtkComboBox
+ * @text_column: A column in @model to get the strings from for
+ * the internal entry
+ *
+ * Sets the model column which @combo_box should use to get strings from
+ * to be @text_column. The column @text_column in the model of @combo_box
+ * must be of type %G_TYPE_STRING.
+ *
+ * This is only relevant if @combo_box has been created with
+ * #GtkComboBox:has-entry as %TRUE.
+ *
+ * Since: 2.24
+ */
+void
+gtk_combo_box_set_entry_text_column (GtkComboBox *combo_box,
+ gint text_column)
+{
+ GtkComboBoxPrivate *priv = combo_box->priv;
+ GtkTreeModel *model;
+
+ g_return_if_fail (GTK_IS_COMBO_BOX (combo_box));
+
+ model = gtk_combo_box_get_model (combo_box);
+
+ g_return_if_fail (text_column >= 0);
+ g_return_if_fail (model == NULL || text_column < gtk_tree_model_get_n_columns (model));
+
+ priv->text_column = text_column;
+
+ if (priv->text_renderer != NULL)
+ gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box),
+ priv->text_renderer,
+ "text", text_column,
+ NULL);
+}
+
+/**
+ * gtk_combo_box_get_entry_text_column:
+ * @combo_box: A #GtkComboBox.
+ *
+ * Returns the column which @combo_box is using to get the strings
+ * from to display in the internal entry.
+ *
+ * Return value: A column in the data source model of @combo_box.
+ *
+ * Since: 2.24
+ */
+gint
+gtk_combo_box_get_entry_text_column (GtkComboBox *combo_box)
+{
+ g_return_val_if_fail (GTK_IS_COMBO_BOX (combo_box), 0);
+
+ return combo_box->priv->text_column;
+}
+
/**
* gtk_combo_box_set_focus_on_click:
* @combo: a #GtkComboBox
data);
}
-#define __GTK_COMBO_BOX_C__
-#include "gtkaliasdef.c"
+static GObject *
+gtk_combo_box_buildable_get_internal_child (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ const gchar *childname)
+{
+ GtkComboBox *combo_box = GTK_COMBO_BOX (buildable);
+
+ if (combo_box->priv->has_entry && strcmp (childname, "entry") == 0)
+ return G_OBJECT (gtk_bin_get_child (GTK_BIN (buildable)));
+
+ return parent_buildable_iface->get_internal_child (buildable, builder, childname);
+}
+
+static void
+gtk_combo_box_remeasure (GtkComboBox *combo_box)
+{
+ GtkComboBoxPrivate *priv = combo_box->priv;
+ GtkTreeIter iter;
+ GtkTreePath *path;
+
+ if (!priv->model ||
+ !gtk_tree_model_get_iter_first (priv->model, &iter))
+ return;
+
+ priv->minimum_width = priv->natural_width = 0;
+
+ path = gtk_tree_path_new_from_indices (0, -1);
+
+ do
+ {
+ gint row_min = 0, row_nat = 0;
+
+ if (priv->cell_view)
+ gtk_cell_view_get_desired_width_of_row (GTK_CELL_VIEW (priv->cell_view),
+ path, &row_min, &row_nat);
+
+ priv->minimum_width = MAX (priv->minimum_width, row_min);
+ priv->natural_width = MAX (priv->natural_width, row_nat);
+
+ gtk_tree_path_next (path);
+ }
+ while (gtk_tree_model_iter_next (priv->model, &iter));
+
+ gtk_tree_path_free (path);
+}
+
+
+static void
+gtk_combo_box_measure_height_for_width (GtkComboBox *combo_box,
+ gint avail_width,
+ gint *min_height,
+ gint *nat_height)
+{
+ GtkWidget *child;
+ GtkComboBoxPrivate *priv = combo_box->priv;
+ GtkTreeIter iter;
+ GtkTreePath *path;
+ gint child_min, child_nat;
+
+ child = gtk_bin_get_child (GTK_BIN (combo_box));
+
+ gtk_widget_get_preferred_height_for_width (child, avail_width,
+ &child_min, &child_nat);
+
+ if (!priv->model ||
+ !gtk_tree_model_get_iter_first (priv->model, &iter))
+ goto out;
+
+ path = gtk_tree_path_new_from_indices (0, -1);
+
+ do
+ {
+ gint row_min = 0, row_nat = 0;
+
+ if (priv->cell_view)
+ gtk_cell_view_get_desired_height_for_width_of_row (GTK_CELL_VIEW (priv->cell_view),
+ path, avail_width,
+ &row_min, &row_nat);
+
+ child_min = MAX (child_min, row_min);
+ child_nat = MAX (child_nat, row_nat);
+
+ gtk_tree_path_next (path);
+ }
+ while (gtk_tree_model_iter_next (priv->model, &iter));
+
+ gtk_tree_path_free (path);
+
+ out:
+
+ if (min_height)
+ *min_height = child_min;
+ if (nat_height)
+ *nat_height = child_nat;
+}
+
+
+static void
+gtk_combo_box_get_preferred_width (GtkWidget *widget,
+ gint *minimum_size,
+ gint *natural_size)
+{
+ GtkComboBox *combo_box = GTK_COMBO_BOX (widget);
+ GtkComboBoxPrivate *priv = combo_box->priv;
+ GtkStyle *style;
+ gint focus_width, focus_pad;
+ gint font_size, arrow_size;
+ PangoContext *context;
+ PangoFontMetrics *metrics;
+ PangoFontDescription *font_desc;
+ GtkWidget *child;
+ gint minimum_width, natural_width;
+ gint child_min, child_nat;
+
+ child = gtk_bin_get_child (GTK_BIN (widget));
+
+ /* common */
+ gtk_widget_get_preferred_width (child, &child_min, &child_nat);
+ gtk_combo_box_remeasure (combo_box);
+
+ child_min = MAX (child_min, priv->minimum_width);
+ child_nat = MAX (child_nat, priv->natural_width);
+
+ gtk_widget_style_get (GTK_WIDGET (widget),
+ "focus-line-width", &focus_width,
+ "focus-padding", &focus_pad,
+ "arrow-size", &arrow_size,
+ NULL);
+
+ font_desc = gtk_widget_get_style (child)->font_desc;
+ context = gtk_widget_get_pango_context (GTK_WIDGET (widget));
+ metrics = pango_context_get_metrics (context, font_desc,
+ pango_context_get_language (context));
+ font_size = PANGO_PIXELS (pango_font_metrics_get_ascent (metrics) +
+ pango_font_metrics_get_descent (metrics));
+ pango_font_metrics_unref (metrics);
+
+ arrow_size = MAX (arrow_size, font_size);
+
+ gtk_widget_set_size_request (priv->arrow, arrow_size, arrow_size);
+
+ if (!priv->tree_view)
+ {
+ /* menu mode */
+
+ if (priv->cell_view)
+ {
+ gint sep_width, arrow_width;
+ gint border_width, xthickness, xpad;
+
+ border_width = gtk_container_get_border_width (GTK_CONTAINER (combo_box));
+ xthickness = gtk_widget_get_style (priv->button)->xthickness;
+
+ gtk_widget_get_preferred_width (priv->separator, &sep_width, NULL);
+ gtk_widget_get_preferred_width (priv->arrow, &arrow_width, NULL);
+
+ xpad = 2*(border_width + xthickness + focus_width + focus_pad);
+
+ minimum_width = child_min + sep_width + arrow_width + xpad;
+ natural_width = child_nat + sep_width + arrow_width + xpad;
+ }
+ else
+ {
+ gint but_width, but_nat_width;
+
+ gtk_widget_get_preferred_width (priv->button,
+ &but_width, &but_nat_width);
+
+ minimum_width = child_min + but_width;
+ natural_width = child_nat + but_nat_width;
+ }
+ }
+ else
+ {
+ /* list mode */
+ gint button_width, button_nat_width;
+
+ /* sample + frame */
+ minimum_width = child_min;
+ natural_width = child_nat;
+
+ minimum_width += 2 * focus_width;
+ natural_width += 2 * focus_width;
+
+ if (priv->cell_view_frame)
+ {
+ if (priv->has_frame)
+ {
+ gint border_width = gtk_container_get_border_width (GTK_CONTAINER (priv->cell_view_frame));
+ gint xpad = 2 * (border_width + gtk_widget_get_style (GTK_WIDGET (priv->cell_view_frame))->xthickness);
+
+ minimum_width += xpad;
+ natural_width += xpad;
+ }
+ }
+
+ /* the button */
+ gtk_widget_get_preferred_width (priv->button,
+ &button_width, &button_nat_width);
+
+ minimum_width += button_width;
+ natural_width += button_nat_width;
+ }
+
+ if (GTK_SHADOW_NONE != priv->shadow_type)
+ {
+ style = gtk_widget_get_style (GTK_WIDGET (widget));
+
+ minimum_width += 2 * style->xthickness;
+ natural_width += 2 * style->xthickness;
+ }
+
+ if (minimum_size)
+ *minimum_size = minimum_width;
+
+ if (natural_size)
+ *natural_size = natural_width;
+}
+
+static void
+gtk_combo_box_get_preferred_height (GtkWidget *widget,
+ gint *minimum_size,
+ gint *natural_size)
+{
+ gint min_width;
+
+ /* Combo box is height-for-width only
+ * (so we always just reserve enough height for the minimum width) */
+ GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, &min_width, NULL);
+ GTK_WIDGET_GET_CLASS (widget)->get_preferred_height_for_width (widget, min_width, minimum_size, natural_size);
+}
+
+static void
+gtk_combo_box_get_preferred_width_for_height (GtkWidget *widget,
+ gint avail_size,
+ gint *minimum_size,
+ gint *natural_size)
+{
+ /* Combo box is height-for-width only
+ * (so we assume we always reserved enough height for the minimum width) */
+ GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, minimum_size, natural_size);
+}
+
+
+static void
+gtk_combo_box_get_preferred_height_for_width (GtkWidget *widget,
+ gint avail_size,
+ gint *minimum_size,
+ gint *natural_size)
+{
+ GtkComboBox *combo_box = GTK_COMBO_BOX (widget);
+ GtkComboBoxPrivate *priv = combo_box->priv;
+ GtkStyle *style;
+ gint focus_width, focus_pad;
+ gint min_height, nat_height;
+ gint size;
+
+ gtk_widget_style_get (GTK_WIDGET (widget),
+ "focus-line-width", &focus_width,
+ "focus-padding", &focus_pad,
+ NULL);
+
+ size = avail_size;
+
+ if (GTK_SHADOW_NONE != priv->shadow_type)
+ size -= gtk_widget_get_style (GTK_WIDGET (widget))->xthickness;
+
+ if (!priv->tree_view)
+ {
+ /* menu mode */
+ if (priv->cell_view)
+ {
+ GtkStyle *button_style;
+ /* calculate x/y padding and separator/arrow size */
+ gint sep_width, arrow_width, sep_height, arrow_height;
+ gint border_width, xthickness, ythickness, xpad, ypad;
+
+ border_width = gtk_container_get_border_width (GTK_CONTAINER (combo_box));
+ button_style = gtk_widget_get_style (priv->button);
+
+ xthickness = button_style->xthickness;
+ ythickness = button_style->ythickness;
+
+ gtk_widget_get_preferred_width (priv->separator, &sep_width, NULL);
+ gtk_widget_get_preferred_width (priv->arrow, &arrow_width, NULL);
+ gtk_widget_get_preferred_height_for_width (priv->separator,
+ sep_width, &sep_height, NULL);
+ gtk_widget_get_preferred_height_for_width (priv->arrow,
+ arrow_width, &arrow_height, NULL);
+
+ xpad = 2*(border_width + xthickness + focus_width + focus_pad);
+ ypad = 2*(border_width + ythickness + focus_width + focus_pad);
+
+ size -= sep_width + arrow_width + xpad;
+
+ gtk_combo_box_measure_height_for_width (combo_box, size, &min_height, &nat_height);
+
+ arrow_height = MAX (arrow_height, sep_height);
+ min_height = MAX (min_height, arrow_height);
+ nat_height = MAX (nat_height, arrow_height);
+
+ min_height += ypad;
+ nat_height += ypad;
+ }
+ else
+ {
+ /* there is a custom child widget inside (no priv->cell_view) */
+ gint but_width, but_height;
+
+ gtk_widget_get_preferred_width (priv->button, &but_width, NULL);
+ gtk_widget_get_preferred_height_for_width (priv->button,
+ but_width, &but_height, NULL);
+
+ size -= but_width;
+
+ gtk_combo_box_measure_height_for_width (combo_box, size, &min_height, &nat_height);
+
+ min_height = MAX (min_height, but_height);
+ nat_height = MAX (nat_height, but_height);
+ }
+ }
+ else
+ {
+ /* list mode */
+ gint but_width, but_height;
+ gint xpad = 0, ypad = 0;
+
+ gtk_widget_get_preferred_width (priv->button, &but_width, NULL);
+ gtk_widget_get_preferred_height_for_width (priv->button,
+ but_width, &but_height, NULL);
+
+ if (priv->cell_view_frame && priv->has_frame)
+ {
+ GtkStyle *cell_style;
+ gint border_width;
+
+ border_width = gtk_container_get_border_width (GTK_CONTAINER (priv->cell_view_frame));
+ cell_style = gtk_widget_get_style (GTK_WIDGET (priv->cell_view_frame));
+
+ xpad = 2 * (border_width + cell_style->xthickness);
+ ypad = 2 * (border_width + cell_style->ythickness);
+ }
+
+ size -= but_width;
+ size -= 2 * focus_width;
+ size -= xpad;
+
+ gtk_combo_box_measure_height_for_width (combo_box, size, &min_height, &nat_height);
+
+ min_height = MAX (min_height, but_height);
+ nat_height = MAX (nat_height, but_height);
+
+ min_height += ypad;
+ nat_height += ypad;
+ }
+
+ if (GTK_SHADOW_NONE != priv->shadow_type)
+ {
+ style = gtk_widget_get_style (GTK_WIDGET (widget));
+
+ min_height += 2 * style->ythickness;
+ nat_height += 2 * style->ythickness;
+ }
+
+ if (minimum_size)
+ *minimum_size = min_height;
+
+ if (natural_size)
+ *natural_size = nat_height;
+}
projects / ~andy / gtk / blobdiff