src/gtkcombobox.c@cabd145237d8 (annotated)
src/gtkcombobox.c
Thu, 07 Apr 2005 14:55:02 +0000
- author
- Richard Laager <rlaager@pidgin.im>
- date
- Thu, 07 Apr 2005 14:55:02 +0000
- changeset 10789
- cabd145237d8
- parent 10708
- a32e607690ca
- child 11780
- 9aee3bde84b9
- permissions
- -rw-r--r--
[gaim-migrate @ 12431]
" The following log snippets should explain it: " --rlaager
(20:24:00) rlaager: Regarding the signal handling
conversation the other day... I've written a patch to stop
calling signal handlers and return as soon as we find one
signal handler that returns TRUE to indicate that it's
handled the signal. Is this the right approach?
(20:24:22) Ethan Blanton (Paco-Paco): the trouble is that it's
documented to behave exactly the way it does
(20:24:31) Ethan Blanton (Paco-Paco): so changing it is
notbackwards compatible
(20:24:31) rlaager: I'm talking for HEAD.
(20:24:41) Ethan Blanton (Paco-Paco): oh, I think that's a
good approach, yes
(20:24:53) rlaager: The way I've described is how I
*expected* it to work, having not read the documentation.
(20:25:09) Ethan Blanton (Paco-Paco): I'm convinced
(20:27:04) Stu Tomlinson (nosnilmot): rlaager: this, I
assume, breaks the generic-ness of signals, by assuming
that any that return values return booleans?
(20:27:26) Ethan Blanton (Paco-Paco): please break it
(20:27:33) Ethan Blanton (Paco-Paco): we already have
out-parameters
(20:27:42) rlaager: nosnilmot: from what I can see, the
return type is handled as a (void *)... so I'm checking that
ret_value != NULL
(20:27:57) rlaager: nosnilmot: that's the correct way to do it,
right?
...
(20:29:01) Ethan Blanton (Paco-Paco): allowing a
meaningful return value is an over-engineering
(20:30:07) rlaager: even after this patch, you should be able
to return meaningful return values
(20:30:15) rlaager: it'll just short-circuit on the first handler
that does
committer: Luke Schierer <lschiere@pidgin.im>
| 10708 | 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 | /* | |
| 21 | #include <config.h> | |
| 22 | */ | |
| 23 | #include <gtk/gtkversion.h> | |
| 24 | #if !GTK_CHECK_VERSION(2,4,0) | |
| 25 | #include "gtkcombobox.h" | |
| 26 | ||
| 27 | #include <gtk/gtkarrow.h> | |
| 28 | #include <gtk/gtkbindings.h> | |
| 29 | #include "gtkcelllayout.h" | |
| 30 | #include <gtk/gtkcellrenderertext.h> | |
| 31 | #include "gtkcellview.h" | |
| 32 | #include "gtkcellviewmenuitem.h" | |
| 33 | #include <gtk/gtkeventbox.h> | |
| 34 | #include <gtk/gtkframe.h> | |
| 35 | #include <gtk/gtkhbox.h> | |
| 36 | #include <gtk/gtkliststore.h> | |
| 37 | #include <gtk/gtkmain.h> | |
| 38 | #include <gtk/gtkmenu.h> | |
| 39 | #include <gtk/gtktogglebutton.h> | |
| 40 | #include <gtk/gtktreeselection.h> | |
| 41 | /* | |
| 42 | #include <gtk/gtktreeprivate.h> | |
| 43 | */ | |
| 44 | #include <gtk/gtkvseparator.h> | |
| 45 | #include <gtk/gtkwindow.h> | |
| 46 | ||
| 47 | #include <gdk/gdkkeysyms.h> | |
| 48 | ||
| 49 | #include <gobject/gvaluecollector.h> | |
| 50 | ||
| 51 | #include <string.h> | |
| 52 | #include <stdarg.h> | |
| 53 | ||
| 54 | #ifdef ENABLE_NLS | |
| 55 | # include <libintl.h> | |
| 56 | # define _(x) gettext(x) | |
| 57 | # ifdef gettext_noop | |
| 58 | # define N_(String) gettext_noop (String) | |
| 59 | # else | |
| 60 | # define N_(String) (String) | |
| 61 | # endif | |
| 62 | #else | |
| 63 | # define N_(String) (String) | |
| 64 | # define _(x) (x) | |
| 65 | #endif | |
| 66 | ||
| 67 | /* WELCOME, to THE house of evil code */ | |
| 68 | ||
| 69 | typedef struct _ComboCellInfo ComboCellInfo; | |
| 70 | struct _ComboCellInfo | |
| 71 | { | |
| 72 | GtkCellRenderer *cell; | |
| 73 | GSList *attributes; | |
| 74 | ||
| 75 | GtkCellLayoutDataFunc func; | |
| 76 | gpointer func_data; | |
| 77 | GDestroyNotify destroy; | |
| 78 | ||
| 79 | guint expand : 1; | |
| 80 | guint pack : 1; | |
| 81 | }; | |
| 82 | ||
| 83 | struct _GtkComboBoxPrivate | |
| 84 | { | |
| 85 | GtkTreeModel *model; | |
| 86 | ||
| 87 | gint col_column; | |
| 88 | gint row_column; | |
| 89 | ||
| 90 | gint wrap_width; | |
| 91 | ||
| 92 | gint active_item; | |
| 93 | ||
| 94 | GtkWidget *tree_view; | |
| 95 | GtkTreeViewColumn *column; | |
| 96 | ||
| 97 | GtkWidget *cell_view; | |
| 98 | GtkWidget *cell_view_frame; | |
| 99 | ||
| 100 | GtkWidget *button; | |
| 101 | GtkWidget *box; | |
| 102 | GtkWidget *arrow; | |
| 103 | GtkWidget *separator; | |
| 104 | ||
| 105 | GtkWidget *popup_widget; | |
| 106 | GtkWidget *popup_window; | |
| 107 | GtkWidget *popup_frame; | |
| 108 | ||
| 109 | guint inserted_id; | |
| 110 | guint deleted_id; | |
| 111 | guint reordered_id; | |
| 112 | guint changed_id; | |
| 113 | ||
| 114 | gint width; | |
| 115 | GSList *cells; | |
| 116 | ||
| 117 | guint popup_in_progress : 1; | |
| 118 | guint destroying : 1; | |
| 119 | }; | |
| 120 | ||
| 121 | /* While debugging this evil code, I have learned that | |
| 122 | * there are actually 4 modes to this widget, which can | |
| 123 | * be characterized as follows | |
| 124 | * | |
| 125 | * 1) menu mode, no child added | |
| 126 | * | |
| 127 | * tree_view -> NULL | |
| 128 | * cell_view -> GtkCellView, regular child | |
| 129 | * cell_view_frame -> NULL | |
| 130 | * button -> GtkToggleButton set_parent to combo | |
| 131 | * box -> child of button | |
| 132 | * arrow -> child of box | |
| 133 | * separator -> child of box | |
| 134 | * popup_widget -> GtkMenu | |
| 135 | * popup_window -> NULL | |
| 136 | * popup_frame -> NULL | |
| 137 | * | |
| 138 | * 2) menu mode, child added | |
| 139 | * | |
| 140 | * tree_view -> NULL | |
| 141 | * cell_view -> NULL | |
| 142 | * cell_view_frame -> NULL | |
| 143 | * button -> GtkToggleButton set_parent to combo | |
| 144 | * box -> NULL | |
| 145 | * arrow -> GtkArrow, child of button | |
| 146 | * separator -> NULL | |
| 147 | * popup_widget -> GtkMenu | |
| 148 | * popup_window -> NULL | |
| 149 | * popup_frame -> NULL | |
| 150 | * | |
| 151 | * 3) list mode, no child added | |
| 152 | * | |
| 153 | * tree_view -> GtkTreeView, child of popup_frame | |
| 154 | * cell_view -> GtkCellView, regular child | |
| 155 | * cell_view_frame -> GtkFrame, set parent to combo | |
| 156 | * button -> GtkToggleButton, set_parent to combo | |
| 157 | * box -> NULL | |
| 158 | * arrow -> GtkArrow, child of button | |
| 159 | * separator -> NULL | |
| 160 | * popup_widget -> tree_view | |
| 161 | * popup_window -> GtkWindow | |
| 162 | * popup_frame -> GtkFrame, child of popup_window | |
| 163 | * | |
| 164 | * 4) list mode, child added | |
| 165 | * | |
| 166 | * tree_view -> GtkTreeView, child of popup_frame | |
| 167 | * cell_view -> NULL | |
| 168 | * cell_view_frame -> NULL | |
| 169 | * button -> GtkToggleButton, set_parent to combo | |
| 170 | * box -> NULL | |
| 171 | * arrow -> GtkArrow, child of button | |
| 172 | * separator -> NULL | |
| 173 | * popup_widget -> tree_view | |
| 174 | * popup_window -> GtkWindow | |
| 175 | * popup_frame -> GtkFrame, child of popup_window | |
| 176 | * | |
| 177 | */ | |
| 178 | ||
| 179 | enum { | |
| 180 | CHANGED, | |
| 181 | LAST_SIGNAL | |
| 182 | }; | |
| 183 | ||
| 184 | enum { | |
| 185 | PROP_0, | |
| 186 | PROP_MODEL, | |
| 187 | PROP_WRAP_WIDTH, | |
| 188 | PROP_ROW_SPAN_COLUMN, | |
| 189 | PROP_COLUMN_SPAN_COLUMN, | |
| 190 | PROP_ACTIVE | |
| 191 | }; | |
| 192 | ||
| 193 | static GtkBinClass *parent_class = NULL; | |
| 194 | static guint combo_box_signals[LAST_SIGNAL] = {0,}; | |
| 195 | ||
| 196 | #define BONUS_PADDING 4 | |
| 197 | ||
| 198 | ||
| 199 | /* common */ | |
| 200 | static void gtk_combo_box_class_init (GtkComboBoxClass *klass); | |
| 201 | static void gtk_combo_box_cell_layout_init (GtkCellLayoutIface *iface); | |
| 202 | static void gtk_combo_box_init (GtkComboBox *combo_box); | |
| 203 | static void gtk_combo_box_finalize (GObject *object); | |
| 204 | static void gtk_combo_box_destroy (GtkObject *object); | |
| 205 | ||
| 206 | static void gtk_combo_box_set_property (GObject *object, | |
| 207 | guint prop_id, | |
| 208 | const GValue *value, | |
| 209 | GParamSpec *spec); | |
| 210 | static void gtk_combo_box_get_property (GObject *object, | |
| 211 | guint prop_id, | |
| 212 | GValue *value, | |
| 213 | GParamSpec *spec); | |
| 214 | ||
| 215 | static void gtk_combo_box_state_changed (GtkWidget *widget, | |
| 216 | GtkStateType previous); | |
| 217 | static void gtk_combo_box_style_set (GtkWidget *widget, | |
| 218 | GtkStyle *previous); | |
| 219 | static void gtk_combo_box_button_toggled (GtkWidget *widget, | |
| 220 | gpointer data); | |
| 221 | static void gtk_combo_box_add (GtkContainer *container, | |
| 222 | GtkWidget *widget); | |
| 223 | static void gtk_combo_box_remove (GtkContainer *container, | |
| 224 | GtkWidget *widget); | |
| 225 | ||
| 226 | static ComboCellInfo *gtk_combo_box_get_cell_info (GtkComboBox *combo_box, | |
| 227 | GtkCellRenderer *cell); | |
| 228 | ||
| 229 | static void gtk_combo_box_menu_show (GtkWidget *menu, | |
| 230 | gpointer user_data); | |
| 231 | static void gtk_combo_box_menu_hide (GtkWidget *menu, | |
| 232 | gpointer user_data); | |
| 233 | ||
| 234 | static void gtk_combo_box_set_popup_widget (GtkComboBox *combo_box, | |
| 235 | GtkWidget *popup); | |
| 236 | static void gtk_combo_box_menu_position_below (GtkMenu *menu, | |
| 237 | gint *x, | |
| 238 | gint *y, | |
| 239 | gint *push_in, | |
| 240 | gpointer user_data); | |
| 241 | static void gtk_combo_box_menu_position_over (GtkMenu *menu, | |
| 242 | gint *x, | |
| 243 | gint *y, | |
| 244 | gint *push_in, | |
| 245 | gpointer user_data); | |
| 246 | static void gtk_combo_box_menu_position (GtkMenu *menu, | |
| 247 | gint *x, | |
| 248 | gint *y, | |
| 249 | gint *push_in, | |
| 250 | gpointer user_data); | |
| 251 | ||
| 252 | static gint gtk_combo_box_calc_requested_width (GtkComboBox *combo_box, | |
| 253 | GtkTreePath *path); | |
| 254 | static void gtk_combo_box_remeasure (GtkComboBox *combo_box); | |
| 255 | ||
| 256 | static void gtk_combo_box_unset_model (GtkComboBox *combo_box); | |
| 257 | ||
| 258 | static void gtk_combo_box_size_request (GtkWidget *widget, | |
| 259 | GtkRequisition *requisition); | |
| 260 | static void gtk_combo_box_size_allocate (GtkWidget *widget, | |
| 261 | GtkAllocation *allocation); | |
| 262 | static void gtk_combo_box_forall (GtkContainer *container, | |
| 263 | gboolean include_internals, | |
| 264 | GtkCallback callback, | |
| 265 | gpointer callback_data); | |
| 266 | static gboolean gtk_combo_box_expose_event (GtkWidget *widget, | |
| 267 | GdkEventExpose *event); | |
| 268 | static gboolean gtk_combo_box_scroll_event (GtkWidget *widget, | |
| 269 | GdkEventScroll *event); | |
| 270 | static void gtk_combo_box_set_active_internal (GtkComboBox *combo_box, | |
| 271 | gint index); | |
| 272 | static gboolean gtk_combo_box_key_press (GtkWidget *widget, | |
| 273 | GdkEventKey *event, | |
| 274 | gpointer data); | |
| 275 | ||
| 276 | /* listening to the model */ | |
| 277 | static void gtk_combo_box_model_row_inserted (GtkTreeModel *model, | |
| 278 | GtkTreePath *path, | |
| 279 | GtkTreeIter *iter, | |
| 280 | gpointer user_data); | |
| 281 | static void gtk_combo_box_model_row_deleted (GtkTreeModel *model, | |
| 282 | GtkTreePath *path, | |
| 283 | gpointer user_data); | |
| 284 | static void gtk_combo_box_model_rows_reordered (GtkTreeModel *model, | |
| 285 | GtkTreePath *path, | |
| 286 | GtkTreeIter *iter, | |
| 287 | gint *new_order, | |
| 288 | gpointer user_data); | |
| 289 | static void gtk_combo_box_model_row_changed (GtkTreeModel *model, | |
| 290 | GtkTreePath *path, | |
| 291 | GtkTreeIter *iter, | |
| 292 | gpointer data); | |
| 293 | ||
| 294 | /* list */ | |
| 295 | static void gtk_combo_box_list_position (GtkComboBox *combo_box, | |
| 296 | gint *x, | |
| 297 | gint *y, | |
| 298 | gint *width, | |
| 299 | gint *height); | |
| 300 | static void gtk_combo_box_list_setup (GtkComboBox *combo_box); | |
| 301 | static void gtk_combo_box_list_destroy (GtkComboBox *combo_box); | |
| 302 | ||
| 303 | static void gtk_combo_box_list_remove_grabs (GtkComboBox *combo_box); | |
| 304 | ||
| 305 | static gboolean gtk_combo_box_list_button_released (GtkWidget *widget, | |
| 306 | GdkEventButton *event, | |
| 307 | gpointer data); | |
| 308 | static gboolean gtk_combo_box_list_key_press (GtkWidget *widget, | |
| 309 | GdkEventKey *event, | |
| 310 | gpointer data); | |
| 311 | static gboolean gtk_combo_box_list_button_pressed (GtkWidget *widget, | |
| 312 | GdkEventButton *event, | |
| 313 | gpointer data); | |
| 314 | ||
| 315 | static void gtk_combo_box_list_row_changed (GtkTreeModel *model, | |
| 316 | GtkTreePath *path, | |
| 317 | GtkTreeIter *iter, | |
| 318 | gpointer data); | |
| 319 | ||
| 320 | /* menu */ | |
| 321 | static void gtk_combo_box_menu_setup (GtkComboBox *combo_box, | |
| 322 | gboolean add_children); | |
| 323 | static void gtk_combo_box_menu_fill (GtkComboBox *combo_box); | |
| 324 | static void gtk_combo_box_menu_destroy (GtkComboBox *combo_box); | |
| 325 | ||
| 326 | static void gtk_combo_box_item_get_size (GtkComboBox *combo_box, | |
| 327 | gint index, | |
| 328 | gint *cols, | |
| 329 | gint *rows); | |
| 330 | static void gtk_combo_box_relayout_item (GtkComboBox *combo_box, | |
| 331 | gint index); | |
| 332 | static void gtk_combo_box_relayout (GtkComboBox *combo_box); | |
| 333 | ||
| 334 | static gboolean gtk_combo_box_menu_button_press (GtkWidget *widget, | |
| 335 | GdkEventButton *event, | |
| 336 | gpointer user_data); | |
| 337 | static void gtk_combo_box_menu_item_activate (GtkWidget *item, | |
| 338 | gpointer user_data); | |
| 339 | static void gtk_combo_box_menu_row_inserted (GtkTreeModel *model, | |
| 340 | GtkTreePath *path, | |
| 341 | GtkTreeIter *iter, | |
| 342 | gpointer user_data); | |
| 343 | static void gtk_combo_box_menu_row_deleted (GtkTreeModel *model, | |
| 344 | GtkTreePath *path, | |
| 345 | gpointer user_data); | |
| 346 | static void gtk_combo_box_menu_rows_reordered (GtkTreeModel *model, | |
| 347 | GtkTreePath *path, | |
| 348 | GtkTreeIter *iter, | |
| 349 | gint *new_order, | |
| 350 | gpointer user_data); | |
| 351 | static void gtk_combo_box_menu_row_changed (GtkTreeModel *model, | |
| 352 | GtkTreePath *path, | |
| 353 | GtkTreeIter *iter, | |
| 354 | gpointer data); | |
| 355 | static gboolean gtk_combo_box_menu_key_press (GtkWidget *widget, | |
| 356 | GdkEventKey *event, | |
| 357 | gpointer data); | |
| 358 | ||
| 359 | /* cell layout */ | |
| 360 | static void gtk_combo_box_cell_layout_pack_start (GtkCellLayout *layout, | |
| 361 | GtkCellRenderer *cell, | |
| 362 | gboolean expand); | |
| 363 | static void gtk_combo_box_cell_layout_pack_end (GtkCellLayout *layout, | |
| 364 | GtkCellRenderer *cell, | |
| 365 | gboolean expand); | |
| 366 | static void gtk_combo_box_cell_layout_clear (GtkCellLayout *layout); | |
| 367 | static void gtk_combo_box_cell_layout_add_attribute (GtkCellLayout *layout, | |
| 368 | GtkCellRenderer *cell, | |
| 369 | const gchar *attribute, | |
| 370 | gint column); | |
| 371 | static void gtk_combo_box_cell_layout_set_cell_data_func (GtkCellLayout *layout, | |
| 372 | GtkCellRenderer *cell, | |
| 373 | GtkCellLayoutDataFunc func, | |
| 374 | gpointer func_data, | |
| 375 | GDestroyNotify destroy); | |
| 376 | static void gtk_combo_box_cell_layout_clear_attributes (GtkCellLayout *layout, | |
| 377 | GtkCellRenderer *cell); | |
| 378 | static void gtk_combo_box_cell_layout_reorder (GtkCellLayout *layout, | |
| 379 | GtkCellRenderer *cell, | |
| 380 | gint position); | |
| 381 | static gboolean gtk_combo_box_mnemonic_activate (GtkWidget *widget, | |
| 382 | gboolean group_cycling); | |
| 383 | ||
| 384 | static void cell_view_sync_cells (GtkComboBox *combo_box, | |
| 385 | GtkCellView *cell_view); | |
| 386 | ||
| 387 | #if !GTK_CHECK_VERSION(2,4,0) | |
| 388 | static void gtk_menu_attach (GtkMenu *menu, | |
| 389 | GtkWidget *child, | |
| 390 | guint left_attach, | |
| 391 | guint right_attach, | |
| 392 | guint top_attach, | |
| 393 | guint bottom_attach); | |
| 394 | #endif | |
| 395 | ||
| 396 | GType | |
| 397 | gtk_combo_box_get_type (void) | |
| 398 | { | |
| 399 | static GType combo_box_type = 0; | |
| 400 | ||
| 401 | if (!combo_box_type) | |
| 402 | { | |
| 403 | static const GTypeInfo combo_box_info = | |
| 404 | { | |
| 405 | sizeof (GtkComboBoxClass), | |
| 406 | NULL, /* base_init */ | |
| 407 | NULL, /* base_finalize */ | |
| 408 | (GClassInitFunc) gtk_combo_box_class_init, | |
| 409 | NULL, /* class_finalize */ | |
| 410 | NULL, /* class_data */ | |
| 411 | sizeof (GtkComboBox), | |
| 412 | 0, | |
| 413 | (GInstanceInitFunc) gtk_combo_box_init | |
| 414 | }; | |
| 415 | ||
| 416 | static const GInterfaceInfo cell_layout_info = | |
| 417 | { | |
| 418 | (GInterfaceInitFunc) gtk_combo_box_cell_layout_init, | |
| 419 | NULL, | |
| 420 | NULL | |
| 421 | }; | |
| 422 | ||
| 423 | combo_box_type = g_type_register_static (GTK_TYPE_BIN, | |
| 424 | "GaimGtkComboBox", | |
| 425 | &combo_box_info, | |
| 426 | 0); | |
| 427 | ||
| 428 | g_type_add_interface_static (combo_box_type, | |
| 429 | GTK_TYPE_CELL_LAYOUT, | |
| 430 | &cell_layout_info); | |
| 431 | } | |
| 432 | ||
| 433 | return combo_box_type; | |
| 434 | } | |
| 435 | ||
| 436 | /* common */ | |
| 437 | static void | |
| 438 | gtk_combo_box_class_init (GtkComboBoxClass *klass) | |
| 439 | { | |
| 440 | GObjectClass *object_class; | |
| 441 | GtkBindingSet *binding_set; | |
| 442 | GtkObjectClass *gtk_object_class; | |
| 443 | GtkContainerClass *container_class; | |
| 444 | GtkWidgetClass *widget_class; | |
| 445 | ||
| 446 | binding_set = gtk_binding_set_by_class (klass); | |
| 447 | ||
| 448 | container_class = (GtkContainerClass *)klass; | |
| 449 | container_class->forall = gtk_combo_box_forall; | |
| 450 | container_class->add = gtk_combo_box_add; | |
| 451 | container_class->remove = gtk_combo_box_remove; | |
| 452 | ||
| 453 | widget_class = (GtkWidgetClass *)klass; | |
| 454 | widget_class->size_allocate = gtk_combo_box_size_allocate; | |
| 455 | widget_class->size_request = gtk_combo_box_size_request; | |
| 456 | widget_class->expose_event = gtk_combo_box_expose_event; | |
| 457 | widget_class->scroll_event = gtk_combo_box_scroll_event; | |
| 458 | widget_class->mnemonic_activate = gtk_combo_box_mnemonic_activate; | |
| 459 | widget_class->style_set = gtk_combo_box_style_set; | |
| 460 | widget_class->state_changed = gtk_combo_box_state_changed; | |
| 461 | ||
| 462 | gtk_object_class = (GtkObjectClass *)klass; | |
| 463 | gtk_object_class->destroy = gtk_combo_box_destroy; | |
| 464 | ||
| 465 | object_class = (GObjectClass *)klass; | |
| 466 | object_class->finalize = gtk_combo_box_finalize; | |
| 467 | object_class->set_property = gtk_combo_box_set_property; | |
| 468 | object_class->get_property = gtk_combo_box_get_property; | |
| 469 | ||
| 470 | parent_class = g_type_class_peek_parent (klass); | |
| 471 | ||
| 472 | /* signals */ | |
| 473 | combo_box_signals[CHANGED] = | |
| 474 | g_signal_new ("changed", | |
| 475 | G_OBJECT_CLASS_TYPE (klass), | |
| 476 | G_SIGNAL_RUN_LAST, | |
| 477 | G_STRUCT_OFFSET (GtkComboBoxClass, changed), | |
| 478 | NULL, NULL, | |
| 479 | g_cclosure_marshal_VOID__VOID, | |
| 480 | G_TYPE_NONE, 0); | |
| 481 | ||
| 482 | /* properties */ | |
| 483 | g_object_class_install_property (object_class, | |
| 484 | PROP_MODEL, | |
| 485 | g_param_spec_object ("model", | |
| 486 | _("ComboBox model"), | |
| 487 | _("The model for the combo box"), | |
| 488 | GTK_TYPE_TREE_MODEL, | |
| 489 | G_PARAM_READWRITE)); | |
| 490 | ||
| 491 | g_object_class_install_property (object_class, | |
| 492 | PROP_WRAP_WIDTH, | |
| 493 | g_param_spec_int ("wrap_width", | |
| 494 | _("Wrap width"), | |
| 495 | _("Wrap width for layouting the items in a grid"), | |
| 496 | 0, | |
| 497 | G_MAXINT, | |
| 498 | 0, | |
| 499 | G_PARAM_READWRITE)); | |
| 500 | ||
| 501 | g_object_class_install_property (object_class, | |
| 502 | PROP_ROW_SPAN_COLUMN, | |
| 503 | g_param_spec_int ("row_span_column", | |
| 504 | _("Row span column"), | |
| 505 | _("TreeModel column containing the row span values"), | |
| 506 | 0, | |
| 507 | G_MAXINT, | |
| 508 | 0, | |
| 509 | G_PARAM_READWRITE)); | |
| 510 | ||
| 511 | g_object_class_install_property (object_class, | |
| 512 | PROP_COLUMN_SPAN_COLUMN, | |
| 513 | g_param_spec_int ("column_span_column", | |
| 514 | _("Column span column"), | |
| 515 | ||
| 516 | _("TreeModel column containing the column span values"), | |
| 517 | 0, | |
| 518 | G_MAXINT, | |
| 519 | 0, | |
| 520 | G_PARAM_READWRITE)); | |
| 521 | ||
| 522 | g_object_class_install_property (object_class, | |
| 523 | PROP_ACTIVE, | |
| 524 | g_param_spec_int ("active", | |
| 525 | _("Active item"), | |
| 526 | _("The item which is currently active"), | |
| 527 | -1, | |
| 528 | G_MAXINT, | |
| 529 | -1, | |
| 530 | G_PARAM_READWRITE)); | |
| 531 | ||
| 532 | gtk_widget_class_install_style_property (widget_class, | |
| 533 | g_param_spec_boolean ("appears-as-list", | |
| 534 | _("Appears as list"), | |
| 535 | _("Whether combobox dropdowns should look like lists rather than menus"), | |
| 536 | FALSE, | |
| 537 | G_PARAM_READABLE)); | |
| 538 | } | |
| 539 | ||
| 540 | static void | |
| 541 | gtk_combo_box_cell_layout_init (GtkCellLayoutIface *iface) | |
| 542 | { | |
| 543 | iface->pack_start = gtk_combo_box_cell_layout_pack_start; | |
| 544 | iface->pack_end = gtk_combo_box_cell_layout_pack_end; | |
| 545 | iface->clear = gtk_combo_box_cell_layout_clear; | |
| 546 | iface->add_attribute = gtk_combo_box_cell_layout_add_attribute; | |
| 547 | iface->set_cell_data_func = gtk_combo_box_cell_layout_set_cell_data_func; | |
| 548 | iface->clear_attributes = gtk_combo_box_cell_layout_clear_attributes; | |
| 549 | iface->reorder = gtk_combo_box_cell_layout_reorder; | |
| 550 | } | |
| 551 | ||
| 552 | static void | |
| 553 | gtk_combo_box_init (GtkComboBox *combo_box) | |
| 554 | { | |
| 555 | combo_box->priv = g_new0(GtkComboBoxPrivate,1); | |
| 556 | ||
| 557 | combo_box->priv->cell_view = gtk_cell_view_new (); | |
| 558 | gtk_widget_set_parent (combo_box->priv->cell_view, GTK_WIDGET (combo_box)); | |
| 559 | GTK_BIN (combo_box)->child = combo_box->priv->cell_view; | |
| 560 | gtk_widget_show (combo_box->priv->cell_view); | |
| 561 | ||
| 562 | combo_box->priv->width = 0; | |
| 563 | combo_box->priv->wrap_width = 0; | |
| 564 | ||
| 565 | combo_box->priv->active_item = -1; | |
| 566 | combo_box->priv->col_column = -1; | |
| 567 | combo_box->priv->row_column = -1; | |
| 568 | } | |
| 569 | ||
| 570 | static void | |
| 571 | gtk_combo_box_set_property (GObject *object, | |
| 572 | guint prop_id, | |
| 573 | const GValue *value, | |
| 574 | GParamSpec *pspec) | |
| 575 | { | |
| 576 | GtkComboBox *combo_box = GTK_COMBO_BOX (object); | |
| 577 | ||
| 578 | switch (prop_id) | |
| 579 | { | |
| 580 | case PROP_MODEL: | |
| 581 | gtk_combo_box_set_model (combo_box, g_value_get_object (value)); | |
| 582 | break; | |
| 583 | ||
| 584 | case PROP_WRAP_WIDTH: | |
| 585 | gtk_combo_box_set_wrap_width (combo_box, g_value_get_int (value)); | |
| 586 | break; | |
| 587 | ||
| 588 | case PROP_ROW_SPAN_COLUMN: | |
| 589 | gtk_combo_box_set_row_span_column (combo_box, g_value_get_int (value)); | |
| 590 | break; | |
| 591 | ||
| 592 | case PROP_COLUMN_SPAN_COLUMN: | |
| 593 | gtk_combo_box_set_column_span_column (combo_box, g_value_get_int (value)); | |
| 594 | break; | |
| 595 | ||
| 596 | case PROP_ACTIVE: | |
| 597 | gtk_combo_box_set_active (combo_box, g_value_get_int (value)); | |
| 598 | break; | |
| 599 | ||
| 600 | default: | |
| 601 | break; | |
| 602 | } | |
| 603 | } | |
| 604 | ||
| 605 | static void | |
| 606 | gtk_combo_box_get_property (GObject *object, | |
| 607 | guint prop_id, | |
| 608 | GValue *value, | |
| 609 | GParamSpec *pspec) | |
| 610 | { | |
| 611 | GtkComboBox *combo_box = GTK_COMBO_BOX (object); | |
| 612 | ||
| 613 | switch (prop_id) | |
| 614 | { | |
| 615 | case PROP_MODEL: | |
| 616 | g_value_set_object (value, combo_box->priv->model); | |
| 617 | break; | |
| 618 | ||
| 619 | case PROP_WRAP_WIDTH: | |
| 620 | g_value_set_int (value, combo_box->priv->wrap_width); | |
| 621 | break; | |
| 622 | ||
| 623 | case PROP_ROW_SPAN_COLUMN: | |
| 624 | g_value_set_int (value, combo_box->priv->row_column); | |
| 625 | break; | |
| 626 | ||
| 627 | case PROP_COLUMN_SPAN_COLUMN: | |
| 628 | g_value_set_int (value, combo_box->priv->col_column); | |
| 629 | break; | |
| 630 | ||
| 631 | case PROP_ACTIVE: | |
| 632 | g_value_set_int (value, gtk_combo_box_get_active (combo_box)); | |
| 633 | break; | |
| 634 | ||
| 635 | default: | |
| 636 | G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); | |
| 637 | break; | |
| 638 | } | |
| 639 | } | |
| 640 | ||
| 641 | static void | |
| 642 | gtk_combo_box_state_changed (GtkWidget *widget, | |
| 643 | GtkStateType previous) | |
| 644 | { | |
| 645 | GtkComboBox *combo_box = GTK_COMBO_BOX (widget); | |
| 646 | ||
| 647 | if (GTK_WIDGET_REALIZED (widget)) | |
| 648 | { | |
| 649 | if (combo_box->priv->tree_view && combo_box->priv->cell_view) | |
| 650 | gtk_cell_view_set_background_color (GTK_CELL_VIEW (combo_box->priv->cell_view), | |
| 651 | &widget->style->base[GTK_WIDGET_STATE (widget)]); | |
| 652 | } | |
| 653 | ||
| 654 | gtk_widget_queue_draw (widget); | |
| 655 | } | |
| 656 | ||
| 657 | static void | |
| 658 | gtk_combo_box_check_appearance (GtkComboBox *combo_box) | |
| 659 | { | |
| 660 | gboolean appears_as_list; | |
| 661 | ||
| 662 | /* if wrap_width > 0, then we are in grid-mode and forced to use | |
| 663 | * unix style | |
| 664 | */ | |
| 665 | if (combo_box->priv->wrap_width) | |
| 666 | appears_as_list = FALSE; | |
| 667 | else | |
| 668 | gtk_widget_style_get (GTK_WIDGET (combo_box), | |
| 669 | "appears-as-list", &appears_as_list, | |
| 670 | NULL); | |
| 671 | ||
| 672 | if (appears_as_list) | |
| 673 | { | |
| 674 | /* Destroy all the menu mode widgets, if they exist. */ | |
| 675 | if (GTK_IS_MENU (combo_box->priv->popup_widget)) | |
| 676 | gtk_combo_box_menu_destroy (combo_box); | |
| 677 | ||
| 678 | /* Create the list mode widgets, if they don't already exist. */ | |
| 679 | if (!GTK_IS_TREE_VIEW (combo_box->priv->tree_view)) | |
| 680 | gtk_combo_box_list_setup (combo_box); | |
| 681 | } | |
| 682 | else | |
| 683 | { | |
| 684 | /* Destroy all the list mode widgets, if they exist. */ | |
| 685 | if (GTK_IS_TREE_VIEW (combo_box->priv->tree_view)) | |
| 686 | gtk_combo_box_list_destroy (combo_box); | |
| 687 | ||
| 688 | /* Create the menu mode widgets, if they don't already exist. */ | |
| 689 | if (!GTK_IS_MENU (combo_box->priv->popup_widget)) | |
| 690 | gtk_combo_box_menu_setup (combo_box, TRUE); | |
| 691 | } | |
| 692 | } | |
| 693 | ||
| 694 | static void | |
| 695 | gtk_combo_box_style_set (GtkWidget *widget, | |
| 696 | GtkStyle *previous) | |
| 697 | { | |
| 698 | GtkComboBox *combo_box = GTK_COMBO_BOX (widget); | |
| 699 | ||
| 700 | gtk_combo_box_check_appearance (combo_box); | |
| 701 | ||
| 702 | if (combo_box->priv->tree_view && combo_box->priv->cell_view) | |
| 703 | gtk_cell_view_set_background_color (GTK_CELL_VIEW (combo_box->priv->cell_view), | |
| 704 | &widget->style->base[GTK_WIDGET_STATE (widget)]); | |
| 705 | } | |
| 706 | ||
| 707 | static void | |
| 708 | gtk_combo_box_button_toggled (GtkWidget *widget, | |
| 709 | gpointer data) | |
| 710 | { | |
| 711 | GtkComboBox *combo_box = GTK_COMBO_BOX (data); | |
| 712 | ||
| 713 | if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget))) | |
| 714 | { | |
| 715 | if (!combo_box->priv->popup_in_progress) | |
| 716 | gtk_combo_box_popup (combo_box); | |
| 717 | } | |
| 718 | else | |
| 719 | gtk_combo_box_popdown (combo_box); | |
| 720 | } | |
| 721 | ||
| 722 | static void | |
| 723 | gtk_combo_box_add (GtkContainer *container, | |
| 724 | GtkWidget *widget) | |
| 725 | { | |
| 726 | GtkComboBox *combo_box = GTK_COMBO_BOX (container); | |
| 727 | ||
| 728 | if (combo_box->priv->cell_view && combo_box->priv->cell_view->parent) | |
| 729 | { | |
| 730 | gtk_widget_unparent (combo_box->priv->cell_view); | |
| 731 | GTK_BIN (container)->child = NULL; | |
| 732 | gtk_widget_queue_resize (GTK_WIDGET (container)); | |
| 733 | } | |
| 734 | ||
| 735 | gtk_widget_set_parent (widget, GTK_WIDGET (container)); | |
| 736 | GTK_BIN (container)->child = widget; | |
| 737 | ||
| 738 | if (combo_box->priv->cell_view && | |
| 739 | widget != combo_box->priv->cell_view) | |
| 740 | { | |
| 741 | /* since the cell_view was unparented, it's gone now */ | |
| 742 | combo_box->priv->cell_view = NULL; | |
| 743 | ||
| 744 | if (!combo_box->priv->tree_view && combo_box->priv->separator) | |
| 745 | { | |
| 746 | gtk_container_remove (GTK_CONTAINER (combo_box->priv->separator->parent), | |
| 747 | combo_box->priv->separator); | |
| 748 | combo_box->priv->separator = NULL; | |
| 749 | ||
| 750 | gtk_widget_queue_resize (GTK_WIDGET (container)); | |
| 751 | } | |
| 752 | else if (combo_box->priv->cell_view_frame) | |
| 753 | { | |
| 754 | gtk_widget_unparent (combo_box->priv->cell_view_frame); | |
| 755 | combo_box->priv->cell_view_frame = NULL; | |
| 756 | } | |
| 757 | } | |
| 758 | } | |
| 759 | ||
| 760 | static void | |
| 761 | gtk_combo_box_remove (GtkContainer *container, | |
| 762 | GtkWidget *widget) | |
| 763 | { | |
| 764 | GtkComboBox *combo_box = GTK_COMBO_BOX (container); | |
| 765 | gboolean appears_as_list; | |
| 766 | ||
| 767 | gtk_widget_unparent (widget); | |
| 768 | GTK_BIN (container)->child = NULL; | |
| 769 | ||
| 770 | if (combo_box->priv->destroying) | |
| 771 | return; | |
| 772 | ||
| 773 | gtk_widget_queue_resize (GTK_WIDGET (container)); | |
| 774 | ||
| 775 | if (!combo_box->priv->tree_view) | |
| 776 | appears_as_list = FALSE; | |
| 777 | else | |
| 778 | appears_as_list = TRUE; | |
| 779 | ||
| 780 | if (appears_as_list) | |
| 781 | gtk_combo_box_list_destroy (combo_box); | |
| 782 | else if (GTK_IS_MENU (combo_box->priv->popup_widget)) | |
| 783 | { | |
| 784 | gtk_combo_box_menu_destroy (combo_box); | |
| 785 | gtk_menu_detach (GTK_MENU (combo_box->priv->popup_widget)); | |
| 786 | combo_box->priv->popup_widget = NULL; | |
| 787 | } | |
| 788 | ||
| 789 | if (!combo_box->priv->cell_view) | |
| 790 | { | |
| 791 | combo_box->priv->cell_view = gtk_cell_view_new (); | |
| 792 | gtk_widget_set_parent (combo_box->priv->cell_view, GTK_WIDGET (container)); | |
| 793 | GTK_BIN (container)->child = combo_box->priv->cell_view; | |
| 794 | ||
| 795 | gtk_widget_show (combo_box->priv->cell_view); | |
| 796 | gtk_cell_view_set_model (GTK_CELL_VIEW (combo_box->priv->cell_view), | |
| 797 | combo_box->priv->model); | |
| 798 | cell_view_sync_cells (combo_box, GTK_CELL_VIEW (combo_box->priv->cell_view)); | |
| 799 | } | |
| 800 | ||
| 801 | ||
| 802 | if (appears_as_list) | |
| 803 | gtk_combo_box_list_setup (combo_box); | |
| 804 | else | |
| 805 | gtk_combo_box_menu_setup (combo_box, TRUE); | |
| 806 | ||
| 807 | gtk_combo_box_set_active_internal (combo_box, combo_box->priv->active_item); | |
| 808 | } | |
| 809 | ||
| 810 | static ComboCellInfo * | |
| 811 | gtk_combo_box_get_cell_info (GtkComboBox *combo_box, | |
| 812 | GtkCellRenderer *cell) | |
| 813 | { | |
| 814 | GSList *i; | |
| 815 | ||
| 816 | for (i = combo_box->priv->cells; i; i = i->next) | |
| 817 | { | |
| 818 | ComboCellInfo *info = (ComboCellInfo *)i->data; | |
| 819 | ||
| 820 | if (info && info->cell == cell) | |
| 821 | return info; | |
| 822 | } | |
| 823 | ||
| 824 | return NULL; | |
| 825 | } | |
| 826 | ||
| 827 | static void | |
| 828 | gtk_combo_box_menu_show (GtkWidget *menu, | |
| 829 | gpointer user_data) | |
| 830 | { | |
| 831 | GtkComboBox *combo_box = GTK_COMBO_BOX (user_data); | |
| 832 | ||
| 833 | gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (combo_box->priv->button), | |
| 834 | TRUE); | |
| 835 | combo_box->priv->popup_in_progress = FALSE; | |
| 836 | } | |
| 837 | ||
| 838 | static void | |
| 839 | gtk_combo_box_menu_hide (GtkWidget *menu, | |
| 840 | gpointer user_data) | |
| 841 | { | |
| 842 | GtkComboBox *combo_box = GTK_COMBO_BOX (user_data); | |
| 843 | ||
| 844 | gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (combo_box->priv->button), | |
| 845 | FALSE); | |
| 846 | } | |
| 847 | ||
| 848 | static void | |
| 849 | gtk_combo_box_detacher (GtkWidget *widget, | |
| 850 | GtkMenu *menu) | |
| 851 | { | |
| 852 | GtkComboBox *combo_box; | |
| 853 | ||
| 854 | g_return_if_fail (GTK_IS_COMBO_BOX (widget)); | |
| 855 | ||
| 856 | combo_box = GTK_COMBO_BOX (widget); | |
| 857 | g_return_if_fail (combo_box->priv->popup_widget == (GtkWidget*) menu); | |
| 858 | ||
| 859 | g_signal_handlers_disconnect_by_func (menu, | |
| 860 | gtk_combo_box_menu_show, | |
| 861 | combo_box); | |
| 862 | g_signal_handlers_disconnect_by_func (menu, | |
| 863 | gtk_combo_box_menu_hide, | |
| 864 | combo_box); | |
| 865 | ||
| 866 | combo_box->priv->popup_widget = NULL; | |
| 867 | } | |
| 868 | ||
| 869 | static void | |
| 870 | gtk_combo_box_set_popup_widget (GtkComboBox *combo_box, | |
| 871 | GtkWidget *popup) | |
| 872 | { | |
| 873 | if (GTK_IS_MENU (combo_box->priv->popup_widget)) | |
| 874 | { | |
| 875 | gtk_menu_detach (GTK_MENU (combo_box->priv->popup_widget)); | |
| 876 | combo_box->priv->popup_widget = NULL; | |
| 877 | } | |
| 878 | else if (combo_box->priv->popup_widget) | |
| 879 | { | |
| 880 | gtk_container_remove (GTK_CONTAINER (combo_box->priv->popup_frame), | |
| 881 | combo_box->priv->popup_widget); | |
| 882 | g_object_unref (G_OBJECT (combo_box->priv->popup_widget)); | |
| 883 | combo_box->priv->popup_widget = NULL; | |
| 884 | } | |
| 885 | ||
| 886 | if (GTK_IS_MENU (popup)) | |
| 887 | { | |
| 888 | if (combo_box->priv->popup_window) | |
| 889 | { | |
| 890 | gtk_widget_destroy (combo_box->priv->popup_window); | |
| 891 | combo_box->priv->popup_window = NULL; | |
| 892 | combo_box->priv->popup_frame = NULL; | |
| 893 | } | |
| 894 | ||
| 895 | combo_box->priv->popup_widget = popup; | |
| 896 | ||
| 897 | g_signal_connect (popup, "show", | |
| 898 | G_CALLBACK (gtk_combo_box_menu_show), combo_box); | |
| 899 | g_signal_connect (popup, "hide", | |
| 900 | G_CALLBACK (gtk_combo_box_menu_hide), combo_box); | |
| 901 | ||
| 902 | gtk_menu_attach_to_widget (GTK_MENU (popup), | |
| 903 | GTK_WIDGET (combo_box), | |
| 904 | gtk_combo_box_detacher); | |
| 905 | } | |
| 906 | else | |
| 907 | { | |
| 908 | if (!combo_box->priv->popup_window) | |
| 909 | { | |
| 910 | combo_box->priv->popup_window = gtk_window_new (GTK_WINDOW_POPUP); | |
| 911 | gtk_window_set_resizable (GTK_WINDOW (combo_box->priv->popup_window), FALSE); | |
| 912 | gtk_window_set_screen (GTK_WINDOW (combo_box->priv->popup_window), | |
| 913 | gtk_widget_get_screen (GTK_WIDGET (combo_box))); | |
| 914 | ||
| 915 | combo_box->priv->popup_frame = gtk_frame_new (NULL); | |
| 916 | gtk_frame_set_shadow_type (GTK_FRAME (combo_box->priv->popup_frame), | |
| 917 | GTK_SHADOW_ETCHED_IN); | |
| 918 | gtk_container_add (GTK_CONTAINER (combo_box->priv->popup_window), | |
| 919 | combo_box->priv->popup_frame); | |
| 920 | ||
| 921 | gtk_widget_show (combo_box->priv->popup_frame); | |
| 922 | } | |
| 923 | ||
| 924 | gtk_container_add (GTK_CONTAINER (combo_box->priv->popup_frame), | |
| 925 | popup); | |
| 926 | gtk_widget_show (popup); | |
| 927 | g_object_ref (G_OBJECT (popup)); | |
| 928 | combo_box->priv->popup_widget = popup; | |
| 929 | } | |
| 930 | } | |
| 931 | ||
| 932 | static void | |
| 933 | gtk_combo_box_menu_position_below (GtkMenu *menu, | |
| 934 | gint *x, | |
| 935 | gint *y, | |
| 936 | gint *push_in, | |
| 937 | gpointer user_data) | |
| 938 | { | |
| 939 | GtkComboBox *combo_box = GTK_COMBO_BOX (user_data); | |
| 940 | gint sx, sy; | |
| 941 | GtkWidget *child; | |
| 942 | GtkRequisition req; | |
| 943 | GdkScreen *screen; | |
| 944 | gint monitor_num; | |
| 945 | GdkRectangle monitor; | |
| 946 | ||
| 947 | /* FIXME: is using the size request here broken? */ | |
| 948 | child = GTK_BIN (combo_box)->child; | |
| 949 | ||
| 950 | gdk_window_get_origin (child->window, &sx, &sy); | |
| 951 | ||
| 952 | if (GTK_WIDGET_NO_WINDOW (child)) | |
| 953 | { | |
| 954 | sx += child->allocation.x; | |
| 955 | sy += child->allocation.y; | |
| 956 | } | |
| 957 | ||
| 958 | gtk_widget_size_request (GTK_WIDGET (menu), &req); | |
| 959 | ||
| 960 | if (gtk_widget_get_direction (GTK_WIDGET (combo_box)) == GTK_TEXT_DIR_LTR) | |
| 961 | *x = sx; | |
| 962 | else | |
| 963 | *x = sx + child->allocation.width - req.width; | |
| 964 | *y = sy; | |
| 965 | ||
| 966 | screen = gtk_widget_get_screen (GTK_WIDGET (combo_box)); | |
| 967 | monitor_num = gdk_screen_get_monitor_at_window (screen, | |
| 968 | GTK_WIDGET (combo_box)->window); | |
| 969 | gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor); | |
| 970 | ||
| 971 | if (*x < monitor.x) | |
| 972 | *x = monitor.x; | |
| 973 | else if (*x + req.width > monitor.x + monitor.width) | |
| 974 | *x = monitor.x + monitor.width - req.width; | |
| 975 | ||
| 976 | if (monitor.y + monitor.height - *y - child->allocation.height >= req.height) | |
| 977 | *y += child->allocation.height; | |
| 978 | else if (*y - monitor.y >= req.height) | |
| 979 | *y -= req.height; | |
| 980 | else if (monitor.y + monitor.height - *y - child->allocation.height > *y - monitor.y) | |
| 981 | *y += child->allocation.height; | |
| 982 | else | |
| 983 | *y -= req.height; | |
| 984 | ||
| 985 | *push_in = FALSE; | |
| 986 | } | |
| 987 | ||
| 988 | static void | |
| 989 | gtk_combo_box_menu_position_over (GtkMenu *menu, | |
| 990 | gint *x, | |
| 991 | gint *y, | |
| 992 | gboolean *push_in, | |
| 993 | gpointer user_data) | |
| 994 | { | |
| 995 | GtkComboBox *combo_box; | |
| 996 | GtkWidget *active; | |
| 997 | GtkWidget *child; | |
| 998 | GtkWidget *widget; | |
| 999 | GtkRequisition requisition; | |
| 1000 | GList *children; | |
| 1001 | gint screen_width; | |
| 1002 | gint menu_xpos; | |
| 1003 | gint menu_ypos; | |
| 1004 | gint menu_width; | |
| 1005 | ||
| 1006 | g_return_if_fail (GTK_IS_COMBO_BOX (user_data)); | |
| 1007 | ||
| 1008 | combo_box = GTK_COMBO_BOX (user_data); | |
| 1009 | widget = GTK_WIDGET (combo_box); | |
| 1010 | ||
| 1011 | gtk_widget_get_child_requisition (GTK_WIDGET (menu), &requisition); | |
| 1012 | menu_width = requisition.width; | |
| 1013 | ||
| 1014 | active = gtk_menu_get_active (GTK_MENU (combo_box->priv->popup_widget)); | |
| 1015 | gdk_window_get_origin (widget->window, &menu_xpos, &menu_ypos); | |
| 1016 | ||
| 1017 | menu_xpos += widget->allocation.x; | |
| 1018 | menu_ypos += widget->allocation.y + widget->allocation.height / 2 - 2; | |
| 1019 | ||
| 1020 | if (active != NULL) | |
| 1021 | { | |
| 1022 | gtk_widget_get_child_requisition (active, &requisition); | |
| 1023 | menu_ypos -= requisition.height / 2; | |
| 1024 | } | |
| 1025 | ||
| 1026 | children = GTK_MENU_SHELL (combo_box->priv->popup_widget)->children; | |
| 1027 | while (children) | |
| 1028 | { | |
| 1029 | child = children->data; | |
| 1030 | ||
| 1031 | if (active == child) | |
| 1032 | break; | |
| 1033 | ||
| 1034 | if (GTK_WIDGET_VISIBLE (child)) | |
| 1035 | { | |
| 1036 | gtk_widget_get_child_requisition (child, &requisition); | |
| 1037 | menu_ypos -= requisition.height; | |
| 1038 | } | |
| 1039 | ||
| 1040 | children = children->next; | |
| 1041 | } | |
| 1042 | ||
| 1043 | if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) | |
| 1044 | menu_xpos = menu_xpos + widget->allocation.width - menu_width; | |
| 1045 | ||
| 1046 | /* Clamp the position on screen */ | |
| 1047 | screen_width = gdk_screen_get_width (gtk_widget_get_screen (widget)); | |
| 1048 | ||
| 1049 | if (menu_xpos < 0) | |
| 1050 | menu_xpos = 0; | |
| 1051 | else if ((menu_xpos + menu_width) > screen_width) | |
| 1052 | menu_xpos -= ((menu_xpos + menu_width) - screen_width); | |
| 1053 | ||
| 1054 | *x = menu_xpos; | |
| 1055 | *y = menu_ypos; | |
| 1056 | ||
| 1057 | *push_in = TRUE; | |
| 1058 | } | |
| 1059 | ||
| 1060 | static void | |
| 1061 | gtk_combo_box_menu_position (GtkMenu *menu, | |
| 1062 | gint *x, | |
| 1063 | gint *y, | |
| 1064 | gint *push_in, | |
| 1065 | gpointer user_data) | |
| 1066 | { | |
| 1067 | GtkComboBox *combo_box; | |
| 1068 | GtkWidget *menu_item; | |
| 1069 | ||
| 1070 | combo_box = GTK_COMBO_BOX (user_data); | |
| 1071 | ||
| 1072 | if (combo_box->priv->wrap_width > 0 || combo_box->priv->cell_view == NULL) | |
| 1073 | gtk_combo_box_menu_position_below (menu, x, y, push_in, user_data); | |
| 1074 | else | |
| 1075 | { | |
| 1076 | menu_item = gtk_menu_get_active (GTK_MENU (combo_box->priv->popup_widget)); | |
| 1077 | if (menu_item) | |
| 1078 | gtk_menu_shell_select_item (GTK_MENU_SHELL (combo_box->priv->popup_widget), | |
| 1079 | menu_item); | |
| 1080 | ||
| 1081 | gtk_combo_box_menu_position_over (menu, x, y, push_in, user_data); | |
| 1082 | } | |
| 1083 | ||
| 1084 | } | |
| 1085 | ||
| 1086 | static void | |
| 1087 | gtk_combo_box_list_position (GtkComboBox *combo_box, | |
| 1088 | gint *x, | |
| 1089 | gint *y, | |
| 1090 | gint *width, | |
| 1091 | gint *height) | |
| 1092 | { | |
| 1093 | GtkWidget *sample; | |
| 1094 | GdkScreen *screen; | |
| 1095 | gint monitor_num; | |
| 1096 | GdkRectangle monitor; | |
| 1097 | GtkRequisition popup_req; | |
| 1098 | ||
| 1099 | sample = GTK_BIN (combo_box)->child; | |
| 1100 | ||
| 1101 | *width = sample->allocation.width; | |
| 1102 | gtk_widget_size_request (combo_box->priv->popup_window, &popup_req); | |
| 1103 | *height = popup_req.height; | |
| 1104 | ||
| 1105 | gdk_window_get_origin (sample->window, x, y); | |
| 1106 | ||
| 1107 | if (combo_box->priv->cell_view_frame) | |
| 1108 | { | |
| 1109 | *x -= GTK_CONTAINER (combo_box->priv->cell_view_frame)->border_width + | |
| 1110 | GTK_WIDGET (combo_box->priv->cell_view_frame)->style->xthickness; | |
| 1111 | *width += 2 * (GTK_CONTAINER (combo_box->priv->cell_view_frame)->border_width + | |
| 1112 | GTK_WIDGET (combo_box->priv->cell_view_frame)->style->xthickness); | |
| 1113 | } | |
| 1114 | ||
| 1115 | if (GTK_WIDGET_NO_WINDOW (sample)) | |
| 1116 | { | |
| 1117 | *x += sample->allocation.x; | |
| 1118 | *y += sample->allocation.y; | |
| 1119 | } | |
| 1120 | ||
| 1121 | screen = gtk_widget_get_screen (GTK_WIDGET (combo_box)); | |
| 1122 | monitor_num = gdk_screen_get_monitor_at_window (screen, | |
| 1123 | GTK_WIDGET (combo_box)->window); | |
| 1124 | gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor); | |
| 1125 | ||
| 1126 | if (*x < monitor.x) | |
| 1127 | *x = monitor.x; | |
| 1128 | else if (*x + *width > monitor.x + monitor.width) | |
| 1129 | *x = monitor.x + monitor.width - *width; | |
| 1130 | ||
| 1131 | if (*y + sample->allocation.height + *height <= monitor.y + monitor.height) | |
| 1132 | *y += sample->allocation.height; | |
| 1133 | else | |
| 1134 | *y -= *height; | |
| 1135 | } | |
| 1136 | ||
| 1137 | /** | |
| 1138 | * gtk_combo_box_popup: | |
| 1139 | * @combo_box: a #GtkComboBox | |
| 1140 | * | |
| 1141 | * Pops up the menu or dropdown list of @combo_box. | |
| 1142 | * | |
| 1143 | * This function is mostly intended for use by accessibility technologies; | |
| 1144 | * applications should have little use for it. | |
| 1145 | * | |
| 1146 | * Since: 2.4 | |
| 1147 | **/ | |
| 1148 | void | |
| 1149 | gtk_combo_box_popup (GtkComboBox *combo_box) | |
| 1150 | { | |
| 1151 | gint x, y, width, height; | |
| 1152 | ||
| 1153 | g_return_if_fail (GTK_IS_COMBO_BOX (combo_box)); | |
| 1154 | ||
| 1155 | if (GTK_WIDGET_MAPPED (combo_box->priv->popup_widget)) | |
| 1156 | return; | |
| 1157 | ||
| 1158 | if (GTK_IS_MENU (combo_box->priv->popup_widget)) | |
| 1159 | { | |
| 1160 | gtk_menu_set_active (GTK_MENU (combo_box->priv->popup_widget), | |
| 1161 | combo_box->priv->active_item); | |
| 1162 | ||
| 1163 | if (combo_box->priv->wrap_width == 0) | |
| 1164 | { | |
| 1165 | GtkRequisition requisition; | |
| 1166 | ||
| 1167 | width = GTK_WIDGET (combo_box)->allocation.width; | |
| 1168 | gtk_widget_size_request (combo_box->priv->popup_widget, &requisition); | |
| 1169 | ||
| 1170 | gtk_widget_set_size_request (combo_box->priv->popup_widget, | |
| 1171 | MAX (width, requisition.width), -1); | |
| 1172 | } | |
| 1173 | ||
| 1174 | gtk_menu_popup (GTK_MENU (combo_box->priv->popup_widget), | |
| 1175 | NULL, NULL, | |
| 1176 | gtk_combo_box_menu_position, combo_box, | |
| 1177 | 0, 0); | |
| 1178 | return; | |
| 1179 | } | |
| 1180 | ||
| 1181 | gtk_widget_show_all (combo_box->priv->popup_frame); | |
| 1182 | gtk_combo_box_list_position (combo_box, &x, &y, &width, &height); | |
| 1183 | ||
| 1184 | gtk_widget_set_size_request (combo_box->priv->popup_window, width, -1); | |
| 1185 | gtk_window_move (GTK_WINDOW (combo_box->priv->popup_window), x, y); | |
| 1186 | ||
| 1187 | /* popup */ | |
| 1188 | gtk_widget_show (combo_box->priv->popup_window); | |
| 1189 | ||
| 1190 | gtk_widget_grab_focus (combo_box->priv->popup_window); | |
| 1191 | gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (combo_box->priv->button), | |
| 1192 | TRUE); | |
| 1193 | ||
| 1194 | if (!GTK_WIDGET_HAS_FOCUS (combo_box->priv->tree_view)) | |
| 1195 | { | |
| 1196 | gdk_keyboard_grab (combo_box->priv->popup_window->window, | |
| 1197 | FALSE, GDK_CURRENT_TIME); | |
| 1198 | gtk_widget_grab_focus (combo_box->priv->tree_view); | |
| 1199 | } | |
| 1200 | ||
| 1201 | gtk_grab_add (combo_box->priv->popup_window); | |
| 1202 | gdk_pointer_grab (combo_box->priv->popup_window->window, TRUE, | |
| 1203 | GDK_BUTTON_PRESS_MASK | | |
| 1204 | GDK_BUTTON_RELEASE_MASK | | |
| 1205 | GDK_POINTER_MOTION_MASK, | |
| 1206 | NULL, NULL, GDK_CURRENT_TIME); | |
| 1207 | ||
| 1208 | gtk_grab_add (combo_box->priv->tree_view); | |
| 1209 | } | |
| 1210 | ||
| 1211 | /** | |
| 1212 | * gtk_combo_box_popdown: | |
| 1213 | * @combo_box: a #GtkComboBox | |
| 1214 | * | |
| 1215 | * Hides the menu or dropdown list of @combo_box. | |
| 1216 | * | |
| 1217 | * This function is mostly intended for use by accessibility technologies; | |
| 1218 | * applications should have little use for it. | |
| 1219 | * | |
| 1220 | * Since: 2.4 | |
| 1221 | **/ | |
| 1222 | void | |
| 1223 | gtk_combo_box_popdown (GtkComboBox *combo_box) | |
| 1224 | { | |
| 1225 | g_return_if_fail (GTK_IS_COMBO_BOX (combo_box)); | |
| 1226 | ||
| 1227 | if (!GTK_WIDGET_REALIZED (GTK_WIDGET (combo_box))) | |
| 1228 | return; | |
| 1229 | ||
| 1230 | if (GTK_IS_MENU (combo_box->priv->popup_widget)) | |
| 1231 | { | |
| 1232 | gtk_menu_popdown (GTK_MENU (combo_box->priv->popup_widget)); | |
| 1233 | return; | |
| 1234 | } | |
| 1235 | ||
| 1236 | gtk_combo_box_list_remove_grabs (combo_box); | |
| 1237 | gtk_widget_hide_all (combo_box->priv->popup_window); | |
| 1238 | gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (combo_box->priv->button), | |
| 1239 | FALSE); | |
| 1240 | } | |
| 1241 | ||
| 1242 | static gint | |
| 1243 | gtk_combo_box_calc_requested_width (GtkComboBox *combo_box, | |
| 1244 | GtkTreePath *path) | |
| 1245 | { | |
| 1246 | gint padding; | |
| 1247 | GtkRequisition req; | |
| 1248 | ||
| 1249 | if (combo_box->priv->cell_view) | |
| 1250 | gtk_widget_style_get (combo_box->priv->cell_view, | |
| 1251 | "focus-line-width", &padding, | |
| 1252 | NULL); | |
| 1253 | else | |
| 1254 | padding = 0; | |
| 1255 | ||
| 1256 | /* add some pixels for good measure */ | |
| 1257 | padding += BONUS_PADDING; | |
| 1258 | ||
| 1259 | if (combo_box->priv->cell_view) | |
| 1260 | gtk_cell_view_get_size_of_row (GTK_CELL_VIEW (combo_box->priv->cell_view), | |
| 1261 | path, &req); | |
| 1262 | else | |
| 1263 | req.width = 0; | |
| 1264 | ||
| 1265 | return req.width + padding; | |
| 1266 | } | |
| 1267 | ||
| 1268 | static void | |
| 1269 | gtk_combo_box_remeasure (GtkComboBox *combo_box) | |
| 1270 | { | |
| 1271 | GtkTreeIter iter; | |
| 1272 | GtkTreePath *path; | |
| 1273 | gint padding = 0; | |
| 1274 | ||
| 1275 | if (!combo_box->priv->model || | |
| 1276 | !gtk_tree_model_get_iter_first (combo_box->priv->model, &iter)) | |
| 1277 | return; | |
| 1278 | ||
| 1279 | combo_box->priv->width = 0; | |
| 1280 | ||
| 1281 | path = gtk_tree_path_new_from_indices (0, -1); | |
| 1282 | ||
| 1283 | if (combo_box->priv->cell_view) | |
| 1284 | gtk_widget_style_get (combo_box->priv->cell_view, | |
| 1285 | "focus-line-width", &padding, | |
| 1286 | NULL); | |
| 1287 | else | |
| 1288 | padding = 0; | |
| 1289 | ||
| 1290 | /* add some pixels for good measure */ | |
| 1291 | padding += BONUS_PADDING; | |
| 1292 | ||
| 1293 | do | |
| 1294 | { | |
| 1295 | GtkRequisition req; | |
| 1296 | ||
| 1297 | if (combo_box->priv->cell_view) | |
| 1298 | gtk_cell_view_get_size_of_row (GTK_CELL_VIEW (combo_box->priv->cell_view), | |
| 1299 | path, &req); | |
| 1300 | else | |
| 1301 | req.width = 0; | |
| 1302 | ||
| 1303 | combo_box->priv->width = MAX (combo_box->priv->width, | |
| 1304 | req.width + padding); | |
| 1305 | ||
| 1306 | gtk_tree_path_next (path); | |
| 1307 | } | |
| 1308 | while (gtk_tree_model_iter_next (combo_box->priv->model, &iter)); | |
| 1309 | ||
| 1310 | gtk_tree_path_free (path); | |
| 1311 | } | |
| 1312 | ||
| 1313 | static void | |
| 1314 | gtk_combo_box_size_request (GtkWidget *widget, | |
| 1315 | GtkRequisition *requisition) | |
| 1316 | { | |
| 1317 | gint width, height; | |
| 1318 | GtkRequisition bin_req; | |
| 1319 | ||
| 1320 | GtkComboBox *combo_box = GTK_COMBO_BOX (widget); | |
| 1321 | ||
| 1322 | /* common */ | |
| 1323 | gtk_widget_size_request (GTK_BIN (widget)->child, &bin_req); | |
| 1324 | gtk_combo_box_remeasure (combo_box); | |
| 1325 | bin_req.width = MAX (bin_req.width, combo_box->priv->width); | |
| 1326 | ||
| 1327 | gtk_combo_box_check_appearance (combo_box); | |
| 1328 | ||
| 1329 | if (!combo_box->priv->tree_view) | |
| 1330 | { | |
| 1331 | /* menu mode */ | |
| 1332 | ||
| 1333 | if (combo_box->priv->cell_view) | |
| 1334 | { | |
| 1335 | GtkRequisition button_req, sep_req, arrow_req; | |
| 1336 | gint border_width, xthickness, ythickness; | |
| 1337 | ||
| 1338 | gtk_widget_size_request (combo_box->priv->button, &button_req); | |
| 1339 | border_width = GTK_CONTAINER (combo_box->priv->button)->border_width; | |
| 1340 | xthickness = combo_box->priv->button->style->xthickness; | |
| 1341 | ythickness = combo_box->priv->button->style->ythickness; | |
| 1342 | ||
| 1343 | bin_req.width = MAX (bin_req.width, combo_box->priv->width); | |
| 1344 | ||
| 1345 | gtk_widget_size_request (combo_box->priv->separator, &sep_req); | |
| 1346 | gtk_widget_size_request (combo_box->priv->arrow, &arrow_req); | |
| 1347 | ||
| 1348 | height = MAX (sep_req.height, arrow_req.height); | |
| 1349 | height = MAX (height, bin_req.height); | |
| 1350 | ||
| 1351 | width = bin_req.width + sep_req.width + arrow_req.width; | |
| 1352 | ||
| 1353 | height += border_width + 1 + ythickness * 2 + 4; | |
| 1354 | width += border_width + 1 + xthickness * 2 + 4; | |
| 1355 | ||
| 1356 | requisition->width = width; | |
| 1357 | requisition->height = height; | |
| 1358 | } | |
| 1359 | else | |
| 1360 | { | |
| 1361 | GtkRequisition but_req; | |
| 1362 | ||
| 1363 | gtk_widget_size_request (combo_box->priv->button, &but_req); | |
| 1364 | ||
| 1365 | requisition->width = bin_req.width + but_req.width; | |
| 1366 | requisition->height = MAX (bin_req.height, but_req.height); | |
| 1367 | } | |
| 1368 | } | |
| 1369 | else | |
| 1370 | { | |
| 1371 | /* list mode */ | |
| 1372 | GtkRequisition button_req, frame_req; | |
| 1373 | ||
| 1374 | /* sample + frame */ | |
| 1375 | *requisition = bin_req; | |
| 1376 | ||
| 1377 | if (combo_box->priv->cell_view_frame) | |
| 1378 | { | |
| 1379 | gtk_widget_size_request (combo_box->priv->cell_view_frame, &frame_req); | |
| 1380 | requisition->width += 2 * | |
| 1381 | (GTK_CONTAINER (combo_box->priv->cell_view_frame)->border_width + | |
| 1382 | GTK_WIDGET (combo_box->priv->cell_view_frame)->style->xthickness); | |
| 1383 | requisition->height += 2 * | |
| 1384 | (GTK_CONTAINER (combo_box->priv->cell_view_frame)->border_width + | |
| 1385 | GTK_WIDGET (combo_box->priv->cell_view_frame)->style->ythickness); | |
| 1386 | } | |
| 1387 | ||
| 1388 | /* the button */ | |
| 1389 | gtk_widget_size_request (combo_box->priv->button, &button_req); | |
| 1390 | ||
| 1391 | requisition->height = MAX (requisition->height, button_req.height); | |
| 1392 | requisition->width += button_req.width; | |
| 1393 | } | |
| 1394 | } | |
| 1395 | ||
| 1396 | static void | |
| 1397 | gtk_combo_box_size_allocate (GtkWidget *widget, | |
| 1398 | GtkAllocation *allocation) | |
| 1399 | { | |
| 1400 | GtkComboBox *combo_box = GTK_COMBO_BOX (widget); | |
| 1401 | GtkAllocation child; | |
| 1402 | GtkRequisition req; | |
| 1403 | gboolean is_rtl = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL; | |
| 1404 | ||
| 1405 | widget->allocation = *allocation; | |
| 1406 | ||
| 1407 | gtk_combo_box_check_appearance (combo_box); | |
| 1408 | ||
| 1409 | if (!combo_box->priv->tree_view) | |
| 1410 | { | |
| 1411 | if (combo_box->priv->cell_view) | |
| 1412 | { | |
| 1413 | gint border_width, xthickness, ythickness; | |
| 1414 | gint width; | |
| 1415 | ||
| 1416 | /* menu mode */ | |
| 1417 | gtk_widget_size_allocate (combo_box->priv->button, allocation); | |
| 1418 | ||
| 1419 | /* set some things ready */ | |
| 1420 | border_width = GTK_CONTAINER (combo_box->priv->button)->border_width; | |
| 1421 | xthickness = combo_box->priv->button->style->xthickness; | |
| 1422 | ythickness = combo_box->priv->button->style->ythickness; | |
| 1423 | ||
| 1424 | child.x = allocation->x + border_width + 1 + xthickness + 2; | |
| 1425 | child.y = allocation->y + border_width + 1 + ythickness + 2; | |
| 1426 | ||
| 1427 | width = MAX(1, allocation->width - (border_width + 1 + xthickness * 2 + 4)); | |
| 1428 | ||
| 1429 | /* handle the children */ | |
| 1430 | gtk_widget_size_request (combo_box->priv->arrow, &req); | |
| 1431 | child.width = req.width; | |
| 1432 | child.height = MAX(1, allocation->height - 2 * (child.y - allocation->y)); | |
| 1433 | if (!is_rtl) | |
| 1434 | child.x += width - req.width; | |
| 1435 | gtk_widget_size_allocate (combo_box->priv->arrow, &child); | |
| 1436 | if (is_rtl) | |
| 1437 | child.x += req.width; | |
| 1438 | gtk_widget_size_request (combo_box->priv->separator, &req); | |
| 1439 | child.width = req.width; | |
| 1440 | if (!is_rtl) | |
| 1441 | child.x -= req.width; | |
| 1442 | gtk_widget_size_allocate (combo_box->priv->separator, &child); | |
| 1443 | ||
| 1444 | if (is_rtl) | |
| 1445 | { | |
| 1446 | child.x += req.width; | |
| 1447 | child.width = MAX(1, allocation->x + allocation->width | |
| 1448 | - (border_width + 1 + xthickness + 2) - child.x); | |
| 1449 | } | |
| 1450 | else | |
| 1451 | { | |
| 1452 | child.width = child.x; | |
| 1453 | child.x = allocation->x + border_width + 1 + xthickness + 2; | |
| 1454 | child.width = MAX(1, child.width - child.x); | |
| 1455 | } | |
| 1456 | ||
| 1457 | gtk_widget_size_allocate (GTK_BIN (widget)->child, &child); | |
| 1458 | } | |
| 1459 | else | |
| 1460 | { | |
| 1461 | gtk_widget_size_request (combo_box->priv->button, &req); | |
| 1462 | if (is_rtl) | |
| 1463 | child.x = allocation->x; | |
| 1464 | else | |
| 1465 | child.x = allocation->x + allocation->width - req.width; | |
| 1466 | child.y = allocation->y; | |
| 1467 | child.width = req.width; | |
| 1468 | child.height = allocation->height; | |
| 1469 | gtk_widget_size_allocate (combo_box->priv->button, &child); | |
| 1470 | ||
| 1471 | if (is_rtl) | |
| 1472 | child.x = allocation->x + req.width; | |
| 1473 | else | |
| 1474 | child.x = allocation->x; | |
| 1475 | child.y = allocation->y; | |
| 1476 | child.width = MAX(1, allocation->width - req.width); | |
| 1477 | gtk_widget_size_allocate (GTK_BIN (widget)->child, &child); | |
| 1478 | } | |
| 1479 | } | |
| 1480 | else | |
| 1481 | { | |
| 1482 | /* list mode */ | |
| 1483 | ||
| 1484 | /* button */ | |
| 1485 | gtk_widget_size_request (combo_box->priv->button, &req); | |
| 1486 | if (is_rtl) | |
| 1487 | child.x = allocation->x; | |
| 1488 | else | |
| 1489 | child.x = allocation->x + allocation->width - req.width; | |
| 1490 | child.y = allocation->y; | |
| 1491 | child.width = req.width; | |
| 1492 | child.height = allocation->height; | |
| 1493 | gtk_widget_size_allocate (combo_box->priv->button, &child); | |
| 1494 | ||
| 1495 | /* frame */ | |
| 1496 | if (is_rtl) | |
| 1497 | child.x = allocation->x + req.width; | |
| 1498 | else | |
| 1499 | child.x = allocation->x; | |
| 1500 | child.y = allocation->y; | |
| 1501 | child.width = MAX (1, allocation->width - req.width); | |
| 1502 | child.height = allocation->height; | |
| 1503 | ||
| 1504 | if (combo_box->priv->cell_view_frame) | |
| 1505 | { | |
| 1506 | gtk_widget_size_allocate (combo_box->priv->cell_view_frame, &child); | |
| 1507 | ||
| 1508 | /* the sample */ | |
| 1509 | child.x += | |
| 1510 | GTK_CONTAINER (combo_box->priv->cell_view_frame)->border_width + | |
| 1511 | GTK_WIDGET (combo_box->priv->cell_view_frame)->style->xthickness; | |
| 1512 | child.y += | |
| 1513 | GTK_CONTAINER (combo_box->priv->cell_view_frame)->border_width + | |
| 1514 | GTK_WIDGET (combo_box->priv->cell_view_frame)->style->ythickness; | |
| 1515 | child.width -= 2 * ( | |
| 1516 | GTK_CONTAINER (combo_box->priv->cell_view_frame)->border_width + | |
| 1517 | GTK_WIDGET (combo_box->priv->cell_view_frame)->style->xthickness); | |
| 1518 | child.width = MAX(1,child.width); | |
| 1519 | child.height -= 2 * ( | |
| 1520 | GTK_CONTAINER (combo_box->priv->cell_view_frame)->border_width + | |
| 1521 | GTK_WIDGET (combo_box->priv->cell_view_frame)->style->ythickness); | |
| 1522 | child.height = MAX(1,child.height); | |
| 1523 | } | |
| 1524 | ||
| 1525 | gtk_widget_size_allocate (GTK_BIN (combo_box)->child, &child); | |
| 1526 | } | |
| 1527 | } | |
| 1528 | ||
| 1529 | static void | |
| 1530 | gtk_combo_box_unset_model (GtkComboBox *combo_box) | |
| 1531 | { | |
| 1532 | if (combo_box->priv->model) | |
| 1533 | { | |
| 1534 | g_signal_handler_disconnect (combo_box->priv->model, | |
| 1535 | combo_box->priv->inserted_id); | |
| 1536 | g_signal_handler_disconnect (combo_box->priv->model, | |
| 1537 | combo_box->priv->deleted_id); | |
| 1538 | g_signal_handler_disconnect (combo_box->priv->model, | |
| 1539 | combo_box->priv->reordered_id); | |
| 1540 | g_signal_handler_disconnect (combo_box->priv->model, | |
| 1541 | combo_box->priv->changed_id); | |
| 1542 | } | |
| 1543 | ||
| 1544 | /* menu mode */ | |
| 1545 | if (!combo_box->priv->tree_view) | |
| 1546 | { | |
| 1547 | if (combo_box->priv->popup_widget) | |
| 1548 | gtk_container_foreach (GTK_CONTAINER (combo_box->priv->popup_widget), | |
| 1549 | (GtkCallback)gtk_widget_destroy, NULL); | |
| 1550 | } | |
| 1551 | ||
| 1552 | if (combo_box->priv->model) | |
| 1553 | { | |
| 1554 | g_object_unref (G_OBJECT (combo_box->priv->model)); | |
| 1555 | combo_box->priv->model = NULL; | |
| 1556 | } | |
| 1557 | ||
| 1558 | if (combo_box->priv->cell_view) | |
| 1559 | gtk_cell_view_set_displayed_row (GTK_CELL_VIEW (combo_box->priv->cell_view), NULL); | |
| 1560 | } | |
| 1561 | ||
| 1562 | static void | |
| 1563 | gtk_combo_box_forall (GtkContainer *container, | |
| 1564 | gboolean include_internals, | |
| 1565 | GtkCallback callback, | |
| 1566 | gpointer callback_data) | |
| 1567 | { | |
| 1568 | GtkComboBox *combo_box = GTK_COMBO_BOX (container); | |
| 1569 | ||
| 1570 | if (include_internals) | |
| 1571 | { | |
| 1572 | if (combo_box->priv->button) | |
| 1573 | (* callback) (combo_box->priv->button, callback_data); | |
| 1574 | if (combo_box->priv->cell_view_frame) | |
| 1575 | (* callback) (combo_box->priv->cell_view_frame, callback_data); | |
| 1576 | } | |
| 1577 | ||
| 1578 | if (GTK_BIN (container)->child) | |
| 1579 | (* callback) (GTK_BIN (container)->child, callback_data); | |
| 1580 | } | |
| 1581 | ||
| 1582 | static gboolean | |
| 1583 | gtk_combo_box_expose_event (GtkWidget *widget, | |
| 1584 | GdkEventExpose *event) | |
| 1585 | { | |
| 1586 | GtkComboBox *combo_box = GTK_COMBO_BOX (widget); | |
| 1587 | ||
| 1588 | if (!combo_box->priv->tree_view) | |
| 1589 | { | |
| 1590 | gtk_container_propagate_expose (GTK_CONTAINER (widget), | |
| 1591 | combo_box->priv->button, event); | |
| 1592 | } | |
| 1593 | else | |
| 1594 | { | |
| 1595 | gtk_container_propagate_expose (GTK_CONTAINER (widget), | |
| 1596 | combo_box->priv->button, event); | |
| 1597 | ||
| 1598 | if (combo_box->priv->cell_view_frame) | |
| 1599 | gtk_container_propagate_expose (GTK_CONTAINER (widget), | |
| 1600 | combo_box->priv->cell_view_frame, event); | |
| 1601 | } | |
| 1602 | ||
| 1603 | gtk_container_propagate_expose (GTK_CONTAINER (widget), | |
| 1604 | GTK_BIN (widget)->child, event); | |
| 1605 | ||
| 1606 | return FALSE; | |
| 1607 | } | |
| 1608 | ||
| 1609 | static gboolean | |
| 1610 | gtk_combo_box_scroll_event (GtkWidget *widget, | |
| 1611 | GdkEventScroll *event) | |
| 1612 | { | |
| 1613 | GtkComboBox *combo_box = GTK_COMBO_BOX (widget); | |
| 1614 | gint index; | |
| 1615 | gint items; | |
| 1616 | ||
| 1617 | index = gtk_combo_box_get_active (combo_box); | |
| 1618 | ||
| 1619 | if (index != -1) | |
| 1620 | { | |
| 1621 | items = gtk_tree_model_iter_n_children (combo_box->priv->model, NULL); | |
| 1622 | ||
| 1623 | if (event->direction == GDK_SCROLL_UP) | |
| 1624 | index--; | |
| 1625 | else | |
| 1626 | index++; | |
| 1627 | ||
| 1628 | gtk_combo_box_set_active (combo_box, CLAMP (index, 0, items - 1)); | |
| 1629 | } | |
| 1630 | ||
| 1631 | return TRUE; | |
| 1632 | } | |
| 1633 | ||
| 1634 | /* | |
| 1635 | * menu style | |
| 1636 | */ | |
| 1637 | ||
| 1638 | static void | |
| 1639 | cell_view_sync_cells (GtkComboBox *combo_box, | |
| 1640 | GtkCellView *cell_view) | |
| 1641 | { | |
| 1642 | GSList *k; | |
| 1643 | ||
| 1644 | for (k = combo_box->priv->cells; k; k = k->next) | |
| 1645 | { | |
| 1646 | GSList *j; | |
| 1647 | ComboCellInfo *info = (ComboCellInfo *)k->data; | |
| 1648 | ||
| 1649 | if (info->pack == GTK_PACK_START) | |
| 1650 | gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (cell_view), | |
| 1651 | info->cell, info->expand); | |
| 1652 | else if (info->pack == GTK_PACK_END) | |
| 1653 | gtk_cell_layout_pack_end (GTK_CELL_LAYOUT (cell_view), | |
| 1654 | info->cell, info->expand); | |
| 1655 | ||
| 1656 | gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (cell_view), | |
| 1657 | info->cell, | |
| 1658 | info->func, info->func_data, NULL); | |
| 1659 | ||
| 1660 | for (j = info->attributes; j; j = j->next->next) | |
| 1661 | { | |
| 1662 | gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (cell_view), | |
| 1663 | info->cell, | |
| 1664 | j->data, | |
| 1665 | GPOINTER_TO_INT (j->next->data)); | |
| 1666 | } | |
| 1667 | } | |
| 1668 | } | |
| 1669 | ||
| 1670 | static void | |
| 1671 | gtk_combo_box_menu_setup (GtkComboBox *combo_box, | |
| 1672 | gboolean add_children) | |
| 1673 | { | |
| 1674 | GtkWidget *menu; | |
| 1675 | ||
| 1676 | if (combo_box->priv->cell_view) | |
| 1677 | { | |
| 1678 | combo_box->priv->button = gtk_toggle_button_new (); | |
| 1679 | g_signal_connect (combo_box->priv->button, "toggled", | |
| 1680 | G_CALLBACK (gtk_combo_box_button_toggled), combo_box); | |
| 1681 | g_signal_connect_after (combo_box->priv->button, "key_press_event", | |
| 1682 | G_CALLBACK (gtk_combo_box_key_press), combo_box); | |
| 1683 | gtk_widget_set_parent (combo_box->priv->button, | |
| 1684 | GTK_BIN (combo_box)->child->parent); | |
| 1685 | ||
| 1686 | combo_box->priv->box = gtk_hbox_new (FALSE, 0); | |
| 1687 | gtk_container_add (GTK_CONTAINER (combo_box->priv->button), | |
| 1688 | combo_box->priv->box); | |
| 1689 | ||
| 1690 | combo_box->priv->separator = gtk_vseparator_new (); | |
| 1691 | gtk_container_add (GTK_CONTAINER (combo_box->priv->box), | |
| 1692 | combo_box->priv->separator); | |
| 1693 | ||
| 1694 | combo_box->priv->arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_NONE); | |
| 1695 | gtk_container_add (GTK_CONTAINER (combo_box->priv->box), | |
| 1696 | combo_box->priv->arrow); | |
| 1697 | ||
| 1698 | gtk_widget_show_all (combo_box->priv->button); | |
| 1699 | } | |
| 1700 | else | |
| 1701 | { | |
| 1702 | combo_box->priv->button = gtk_toggle_button_new (); | |
| 1703 | g_signal_connect (combo_box->priv->button, "toggled", | |
| 1704 | G_CALLBACK (gtk_combo_box_button_toggled), combo_box); | |
| 1705 | g_signal_connect_after (combo_box, "key_press_event", | |
| 1706 | G_CALLBACK (gtk_combo_box_key_press), combo_box); | |
| 1707 | gtk_widget_set_parent (combo_box->priv->button, | |
| 1708 | GTK_BIN (combo_box)->child->parent); | |
| 1709 | ||
| 1710 | combo_box->priv->arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_NONE); | |
| 1711 | gtk_container_add (GTK_CONTAINER (combo_box->priv->button), | |
| 1712 | combo_box->priv->arrow); | |
| 1713 | gtk_widget_show_all (combo_box->priv->button); | |
| 1714 | } | |
| 1715 | ||
| 1716 | g_signal_connect (combo_box->priv->button, "button_press_event", | |
| 1717 | G_CALLBACK (gtk_combo_box_menu_button_press), | |
| 1718 | combo_box); | |
| 1719 | ||
| 1720 | /* create our funky menu */ | |
| 1721 | menu = gtk_menu_new (); | |
| 1722 | g_signal_connect (menu, "key_press_event", | |
| 1723 | G_CALLBACK (gtk_combo_box_menu_key_press), combo_box); | |
| 1724 | gtk_combo_box_set_popup_widget (combo_box, menu); | |
| 1725 | ||
| 1726 | /* add items */ | |
| 1727 | if (add_children) | |
| 1728 | gtk_combo_box_menu_fill (combo_box); | |
| 1729 | ||
| 1730 | } | |
| 1731 | ||
| 1732 | static void | |
| 1733 | gtk_combo_box_menu_fill (GtkComboBox *combo_box) | |
| 1734 | { | |
| 1735 | gint i, items; | |
| 1736 | GtkWidget *menu; | |
| 1737 | GtkWidget *tmp; | |
| 1738 | ||
| 1739 | if (!combo_box->priv->model) | |
| 1740 | return; | |
| 1741 | ||
| 1742 | items = gtk_tree_model_iter_n_children (combo_box->priv->model, NULL); | |
| 1743 | menu = combo_box->priv->popup_widget; | |
| 1744 | ||
| 1745 | for (i = 0; i < items; i++) | |
| 1746 | { | |
| 1747 | GtkTreePath *path; | |
| 1748 | ||
| 1749 | path = gtk_tree_path_new_from_indices (i, -1); | |
| 1750 | tmp = gtk_cell_view_menu_item_new_from_model (combo_box->priv->model, | |
| 1751 | path); | |
| 1752 | g_signal_connect (tmp, "activate", | |
| 1753 | G_CALLBACK (gtk_combo_box_menu_item_activate), | |
| 1754 | combo_box); | |
| 1755 | ||
| 1756 | cell_view_sync_cells (combo_box, | |
| 1757 | GTK_CELL_VIEW (GTK_BIN (tmp)->child)); | |
| 1758 | ||
| 1759 | gtk_menu_shell_append (GTK_MENU_SHELL (menu), tmp); | |
| 1760 | ||
| 1761 | if (combo_box->priv->wrap_width) | |
| 1762 | gtk_combo_box_relayout_item (combo_box, i); | |
| 1763 | ||
| 1764 | gtk_widget_show (tmp); | |
| 1765 | ||
| 1766 | gtk_tree_path_free (path); | |
| 1767 | } | |
| 1768 | } | |
| 1769 | ||
| 1770 | static void | |
| 1771 | gtk_combo_box_menu_destroy (GtkComboBox *combo_box) | |
| 1772 | { | |
| 1773 | g_signal_handlers_disconnect_matched (combo_box->priv->button, | |
| 1774 | G_SIGNAL_MATCH_DATA, | |
| 1775 | 0, 0, NULL, | |
| 1776 | gtk_combo_box_menu_button_press, NULL); | |
| 1777 | ||
| 1778 | /* unparent will remove our latest ref */ | |
| 1779 | gtk_widget_unparent (combo_box->priv->button); | |
| 1780 | ||
| 1781 | combo_box->priv->box = NULL; | |
| 1782 | combo_box->priv->button = NULL; | |
| 1783 | combo_box->priv->arrow = NULL; | |
| 1784 | combo_box->priv->separator = NULL; | |
| 1785 | ||
| 1786 | /* changing the popup window will unref the menu and the children */ | |
| 1787 | } | |
| 1788 | ||
| 1789 | /* | |
| 1790 | * grid | |
| 1791 | */ | |
| 1792 | ||
| 1793 | static void | |
| 1794 | gtk_combo_box_item_get_size (GtkComboBox *combo_box, | |
| 1795 | gint index_, | |
| 1796 | gint *cols, | |
| 1797 | gint *rows) | |
| 1798 | { | |
| 1799 | GtkTreeIter iter; | |
| 1800 | ||
| 1801 | gtk_tree_model_iter_nth_child (combo_box->priv->model, &iter, NULL, index_); | |
| 1802 | ||
| 1803 | if (cols) | |
| 1804 | { | |
| 1805 | if (combo_box->priv->col_column == -1) | |
| 1806 | *cols = 1; | |
| 1807 | else | |
| 1808 | gtk_tree_model_get (combo_box->priv->model, &iter, | |
| 1809 | combo_box->priv->col_column, cols, | |
| 1810 | -1); | |
| 1811 | } | |
| 1812 | ||
| 1813 | if (rows) | |
| 1814 | { | |
| 1815 | if (combo_box->priv->row_column == -1) | |
| 1816 | *rows = 1; | |
| 1817 | else | |
| 1818 | gtk_tree_model_get (combo_box->priv->model, &iter, | |
| 1819 | combo_box->priv->row_column, rows, | |
| 1820 | -1); | |
| 1821 | } | |
| 1822 | } | |
| 1823 | ||
| 1824 | static gboolean | |
| 1825 | menu_occupied (GtkMenu *menu, | |
| 1826 | guint left_attach, | |
| 1827 | guint right_attach, | |
| 1828 | guint top_attach, | |
| 1829 | guint bottom_attach) | |
| 1830 | { | |
| 1831 | GList *i; | |
| 1832 | ||
| 1833 | g_return_val_if_fail (GTK_IS_MENU (menu), TRUE); | |
| 1834 | g_return_val_if_fail (left_attach < right_attach, TRUE); | |
| 1835 | g_return_val_if_fail (top_attach < bottom_attach, TRUE); | |
| 1836 | ||
| 1837 | for (i = GTK_MENU_SHELL (menu)->children; i; i = i->next) | |
| 1838 | { | |
| 1839 | guint l, r, b, t; | |
| 1840 | gboolean h_intersect = FALSE; | |
| 1841 | gboolean v_intersect = FALSE; | |
| 1842 | ||
| 1843 | gtk_container_child_get (GTK_CONTAINER (menu), i->data, | |
| 1844 | "left_attach", &l, | |
| 1845 | "right_attach", &r, | |
| 1846 | "bottom_attach", &b, | |
| 1847 | "top_attach", &t, | |
| 1848 | NULL); | |
| 1849 | ||
| 1850 | /* look if this item intersects with the given coordinates */ | |
| 1851 | h_intersect = left_attach <= l && l <= right_attach; | |
| 1852 | h_intersect &= left_attach <= r && r <= right_attach; | |
| 1853 | ||
| 1854 | v_intersect = top_attach <= t && t <= bottom_attach; | |
| 1855 | v_intersect &= top_attach <= b && b <= bottom_attach; | |
| 1856 | ||
| 1857 | if (h_intersect && v_intersect) | |
| 1858 | return TRUE; | |
| 1859 | } | |
| 1860 | ||
| 1861 | return FALSE; | |
| 1862 | } | |
| 1863 | ||
| 1864 | static void | |
| 1865 | gtk_combo_box_relayout_item (GtkComboBox *combo_box, | |
| 1866 | gint index) | |
| 1867 | { | |
| 1868 | gint current_col = 0, current_row = 0; | |
| 1869 | gint rows, cols; | |
| 1870 | GList *list, *nth; | |
| 1871 | GtkWidget *item, *last; | |
| 1872 | GtkWidget *menu; | |
| 1873 | ||
| 1874 | menu = combo_box->priv->popup_widget; | |
| 1875 | if (!GTK_IS_MENU_SHELL (menu)) | |
| 1876 | return; | |
| 1877 | ||
| 1878 | list = gtk_container_get_children (GTK_CONTAINER (menu)); | |
| 1879 | nth = g_list_nth (list, index); | |
| 1880 | item = nth->data; | |
| 1881 | if (nth->prev) | |
| 1882 | last = nth->prev->data; | |
| 1883 | else | |
| 1884 | last = NULL; | |
| 1885 | g_list_free (list); | |
| 1886 | ||
| 1887 | gtk_combo_box_item_get_size (combo_box, index, &cols, &rows); | |
| 1888 | ||
| 1889 | if (combo_box->priv->col_column == -1 && | |
| 1890 | combo_box->priv->row_column == -1 && | |
| 1891 | last) | |
| 1892 | { | |
| 1893 | gtk_container_child_get (GTK_CONTAINER (menu), | |
| 1894 | last, | |
| 1895 | "right_attach", ¤t_col, | |
| 1896 | "top_attach", ¤t_row, | |
| 1897 | NULL); | |
| 1898 | if (current_col + cols > combo_box->priv->wrap_width) | |
| 1899 | { | |
| 1900 | current_col = 0; | |
| 1901 | current_row++; | |
| 1902 | } | |
| 1903 | } | |
| 1904 | else | |
| 1905 | { | |
| 1906 | /* look for a good spot */ | |
| 1907 | while (1) | |
| 1908 | { | |
| 1909 | if (current_col + cols > combo_box->priv->wrap_width) | |
| 1910 | { | |
| 1911 | current_col = 0; | |
| 1912 | current_row++; | |
| 1913 | } | |
| 1914 | ||
| 1915 | if (!menu_occupied (GTK_MENU (menu), | |
| 1916 | current_col, current_col + cols, | |
| 1917 | current_row, current_row + rows)) | |
| 1918 | break; | |
| 1919 | ||
| 1920 | current_col++; | |
| 1921 | } | |
| 1922 | } | |
| 1923 | ||
| 1924 | /* set attach props */ | |
| 1925 | gtk_menu_attach (GTK_MENU (menu), item, | |
| 1926 | current_col, current_col + cols, | |
| 1927 | current_row, current_row + rows); | |
| 1928 | } | |
| 1929 | ||
| 1930 | static void | |
| 1931 | gtk_combo_box_relayout (GtkComboBox *combo_box) | |
| 1932 | { | |
| 1933 | GList *list, *j; | |
| 1934 | GtkWidget *menu; | |
| 1935 | ||
| 1936 | menu = combo_box->priv->popup_widget; | |
| 1937 | ||
| 1938 | /* do nothing unless we are in menu style and realized */ | |
| 1939 | if (combo_box->priv->tree_view || !GTK_IS_MENU_SHELL (menu)) | |
| 1940 | return; | |
| 1941 | ||
| 1942 | /* get rid of all children */ | |
| 1943 | list = gtk_container_get_children (GTK_CONTAINER (menu)); | |
| 1944 | ||
| 1945 | for (j = g_list_last (list); j; j = j->prev) | |
| 1946 | gtk_container_remove (GTK_CONTAINER (menu), j->data); | |
| 1947 | ||
| 1948 | g_list_free (list); | |
| 1949 | ||
| 1950 | /* and relayout */ | |
| 1951 | gtk_combo_box_menu_fill (combo_box); | |
| 1952 | } | |
| 1953 | ||
| 1954 | /* callbacks */ | |
| 1955 | static gboolean | |
| 1956 | gtk_combo_box_menu_button_press (GtkWidget *widget, | |
| 1957 | GdkEventButton *event, | |
| 1958 | gpointer user_data) | |
| 1959 | { | |
| 1960 | GtkComboBox *combo_box = GTK_COMBO_BOX (user_data); | |
| 1961 | ||
| 1962 | if (! GTK_IS_MENU (combo_box->priv->popup_widget)) | |
| 1963 | return FALSE; | |
| 1964 | ||
| 1965 | if (event->type == GDK_BUTTON_PRESS && event->button == 1) | |
| 1966 | { | |
| 1967 | combo_box->priv->popup_in_progress = TRUE; | |
| 1968 | ||
| 1969 | gtk_menu_set_active (GTK_MENU (combo_box->priv->popup_widget), | |
| 1970 | combo_box->priv->active_item); | |
| 1971 | ||
| 1972 | if (combo_box->priv->wrap_width == 0) | |
| 1973 | { | |
| 1974 | GtkRequisition requisition; | |
| 1975 | gint width; | |
| 1976 | ||
| 1977 | width = GTK_WIDGET (combo_box)->allocation.width; | |
| 1978 | gtk_widget_size_request (combo_box->priv->popup_widget, &requisition); | |
| 1979 | ||
| 1980 | gtk_widget_set_size_request (combo_box->priv->popup_widget, | |
| 1981 | MAX (width, requisition.width), -1); | |
| 1982 | } | |
| 1983 | ||
| 1984 | gtk_menu_popup (GTK_MENU (combo_box->priv->popup_widget), | |
| 1985 | NULL, NULL, | |
| 1986 | gtk_combo_box_menu_position, combo_box, | |
| 1987 | event->button, event->time); | |
| 1988 | ||
| 1989 | return TRUE; | |
| 1990 | } | |
| 1991 | ||
| 1992 | return FALSE; | |
| 1993 | } | |
| 1994 | ||
| 1995 | static void | |
| 1996 | gtk_combo_box_menu_item_activate (GtkWidget *item, | |
| 1997 | gpointer user_data) | |
| 1998 | { | |
| 1999 | gint index; | |
| 2000 | GtkWidget *menu; | |
| 2001 | GtkComboBox *combo_box = GTK_COMBO_BOX (user_data); | |
| 2002 | ||
| 2003 | menu = combo_box->priv->popup_widget; | |
| 2004 | g_return_if_fail (GTK_IS_MENU (menu)); | |
| 2005 | ||
| 2006 | index = g_list_index (GTK_MENU_SHELL (menu)->children, item); | |
| 2007 | ||
| 2008 | gtk_combo_box_set_active (combo_box, index); | |
| 2009 | } | |
| 2010 | ||
| 2011 | static void | |
| 2012 | gtk_combo_box_model_row_inserted (GtkTreeModel *model, | |
| 2013 | GtkTreePath *path, | |
| 2014 | GtkTreeIter *iter, | |
| 2015 | gpointer user_data) | |
| 2016 | { | |
| 2017 | GtkComboBox *combo_box = GTK_COMBO_BOX (user_data); | |
| 2018 | gint index = gtk_tree_path_get_indices (path)[0]; | |
| 2019 | ||
| 2020 | if (combo_box->priv->active_item >= index) | |
| 2021 | combo_box->priv->active_item++; | |
| 2022 | ||
| 2023 | if (!combo_box->priv->tree_view) | |
| 2024 | gtk_combo_box_menu_row_inserted (model, path, iter, user_data); | |
| 2025 | } | |
| 2026 | ||
| 2027 | static void | |
| 2028 | gtk_combo_box_model_row_deleted (GtkTreeModel *model, | |
| 2029 | GtkTreePath *path, | |
| 2030 | gpointer user_data) | |
| 2031 | { | |
| 2032 | GtkComboBox *combo_box = GTK_COMBO_BOX (user_data); | |
| 2033 | gint index = gtk_tree_path_get_indices (path)[0]; | |
| 2034 | ||
| 2035 | if (!combo_box->priv->tree_view) | |
| 2036 | gtk_combo_box_menu_row_deleted (model, path, user_data); | |
| 2037 | ||
| 2038 | if (index == combo_box->priv->active_item) | |
| 2039 | { | |
| 2040 | gint items = gtk_tree_model_iter_n_children (model, NULL); | |
| 2041 | ||
| 2042 | if (items == 0) | |
| 2043 | gtk_combo_box_set_active_internal (combo_box, -1); | |
| 2044 | else if (index == items) | |
| 2045 | gtk_combo_box_set_active_internal (combo_box, index - 1); | |
| 2046 | else | |
| 2047 | gtk_combo_box_set_active_internal (combo_box, index); | |
| 2048 | } | |
| 2049 | else if (combo_box->priv->active_item > index) | |
| 2050 | combo_box->priv->active_item--; | |
| 2051 | } | |
| 2052 | ||
| 2053 | static void | |
| 2054 | gtk_combo_box_model_rows_reordered (GtkTreeModel *model, | |
| 2055 | GtkTreePath *path, | |
| 2056 | GtkTreeIter *iter, | |
| 2057 | gint *new_order, | |
| 2058 | gpointer user_data) | |
| 2059 | { | |
| 2060 | GtkComboBox *combo_box = GTK_COMBO_BOX (user_data); | |
| 2061 | gint items = gtk_tree_model_iter_n_children (model, NULL); | |
| 2062 | gint i; | |
| 2063 | ||
| 2064 | for (i = 0; i < items; i++) | |
| 2065 | if (new_order[i] == combo_box->priv->active_item) | |
| 2066 | { | |
| 2067 | combo_box->priv->active_item = i; | |
| 2068 | break; | |
| 2069 | } | |
| 2070 | ||
| 2071 | if (!combo_box->priv->tree_view) | |
| 2072 | gtk_combo_box_menu_rows_reordered (model, path, iter, new_order, user_data); | |
| 2073 | } | |
| 2074 | ||
| 2075 | static void | |
| 2076 | gtk_combo_box_model_row_changed (GtkTreeModel *model, | |
| 2077 | GtkTreePath *path, | |
| 2078 | GtkTreeIter *iter, | |
| 2079 | gpointer user_data) | |
| 2080 | { | |
| 2081 | GtkComboBox *combo_box = GTK_COMBO_BOX (user_data); | |
| 2082 | gint index = gtk_tree_path_get_indices (path)[0]; | |
| 2083 | ||
| 2084 | if (index == combo_box->priv->active_item && | |
| 2085 | combo_box->priv->cell_view) | |
| 2086 | gtk_widget_queue_resize (GTK_WIDGET (combo_box->priv->cell_view)); | |
| 2087 | ||
| 2088 | if (combo_box->priv->tree_view) | |
| 2089 | gtk_combo_box_list_row_changed (model, path, iter, user_data); | |
| 2090 | else | |
| 2091 | gtk_combo_box_menu_row_changed (model, path, iter, user_data); | |
| 2092 | } | |
| 2093 | ||
| 2094 | ||
| 2095 | static void | |
| 2096 | gtk_combo_box_menu_row_inserted (GtkTreeModel *model, | |
| 2097 | GtkTreePath *path, | |
| 2098 | GtkTreeIter *iter, | |
| 2099 | gpointer user_data) | |
| 2100 | { | |
| 2101 | GtkWidget *menu; | |
| 2102 | GtkWidget *item; | |
| 2103 | GtkComboBox *combo_box = GTK_COMBO_BOX (user_data); | |
| 2104 | ||
| 2105 | if (!combo_box->priv->popup_widget) | |
| 2106 | return; | |
| 2107 | ||
| 2108 | menu = combo_box->priv->popup_widget; | |
| 2109 | g_return_if_fail (GTK_IS_MENU (menu)); | |
| 2110 | ||
| 2111 | item = gtk_cell_view_menu_item_new_from_model (model, path); | |
| 2112 | g_signal_connect (item, "activate", | |
| 2113 | G_CALLBACK (gtk_combo_box_menu_item_activate), | |
| 2114 | combo_box); | |
| 2115 | ||
| 2116 | cell_view_sync_cells (combo_box, GTK_CELL_VIEW (GTK_BIN (item)->child)); | |
| 2117 | ||
| 2118 | gtk_menu_shell_insert (GTK_MENU_SHELL (menu), item, | |
| 2119 | gtk_tree_path_get_indices (path)[0]); | |
| 2120 | gtk_widget_show (item); | |
| 2121 | } | |
| 2122 | ||
| 2123 | static void | |
| 2124 | gtk_combo_box_menu_row_deleted (GtkTreeModel *model, | |
| 2125 | GtkTreePath *path, | |
| 2126 | gpointer user_data) | |
| 2127 | { | |
| 2128 | gint index; | |
| 2129 | GtkWidget *menu; | |
| 2130 | GtkWidget *item; | |
| 2131 | GtkComboBox *combo_box = GTK_COMBO_BOX (user_data); | |
| 2132 | ||
| 2133 | if (!combo_box->priv->popup_widget) | |
| 2134 | return; | |
| 2135 | ||
| 2136 | index = gtk_tree_path_get_indices (path)[0]; | |
| 2137 | ||
| 2138 | menu = combo_box->priv->popup_widget; | |
| 2139 | g_return_if_fail (GTK_IS_MENU (menu)); | |
| 2140 | ||
| 2141 | item = g_list_nth_data (GTK_MENU_SHELL (menu)->children, index); | |
| 2142 | g_return_if_fail (GTK_IS_MENU_ITEM (item)); | |
| 2143 | ||
| 2144 | gtk_container_remove (GTK_CONTAINER (menu), item); | |
| 2145 | } | |
| 2146 | ||
| 2147 | static void | |
| 2148 | gtk_combo_box_menu_rows_reordered (GtkTreeModel *model, | |
| 2149 | GtkTreePath *path, | |
| 2150 | GtkTreeIter *iter, | |
| 2151 | gint *new_order, | |
| 2152 | gpointer user_data) | |
| 2153 | { | |
| 2154 | GtkComboBox *combo_box = GTK_COMBO_BOX (user_data); | |
| 2155 | ||
| 2156 | gtk_combo_box_relayout (combo_box); | |
| 2157 | } | |
| 2158 | ||
| 2159 | static void | |
| 2160 | gtk_combo_box_menu_row_changed (GtkTreeModel *model, | |
| 2161 | GtkTreePath *path, | |
| 2162 | GtkTreeIter *iter, | |
| 2163 | gpointer user_data) | |
| 2164 | { | |
| 2165 | GtkComboBox *combo_box = GTK_COMBO_BOX (user_data); | |
| 2166 | gint width; | |
| 2167 | ||
| 2168 | if (!combo_box->priv->popup_widget) | |
| 2169 | return; | |
| 2170 | ||
| 2171 | if (combo_box->priv->wrap_width) | |
| 2172 | gtk_combo_box_relayout_item (combo_box, | |
| 2173 | gtk_tree_path_get_indices (path)[0]); | |
| 2174 | ||
| 2175 | width = gtk_combo_box_calc_requested_width (combo_box, path); | |
| 2176 | ||
| 2177 | if (width > combo_box->priv->width) | |
| 2178 | { | |
| 2179 | if (combo_box->priv->cell_view) | |
| 2180 | { | |
| 2181 | gtk_widget_set_size_request (combo_box->priv->cell_view, width, -1); | |
| 2182 | gtk_widget_queue_resize (combo_box->priv->cell_view); | |
| 2183 | } | |
| 2184 | combo_box->priv->width = width; | |
| 2185 | } | |
| 2186 | } | |
| 2187 | ||
| 2188 | /* | |
| 2189 | * list style | |
| 2190 | */ | |
| 2191 | ||
| 2192 | static void | |
| 2193 | gtk_combo_box_list_setup (GtkComboBox *combo_box) | |
| 2194 | { | |
| 2195 | GSList *i; | |
| 2196 | GtkTreeSelection *sel; | |
| 2197 | ||
| 2198 | combo_box->priv->button = gtk_toggle_button_new (); | |
| 2199 | gtk_widget_set_parent (combo_box->priv->button, | |
| 2200 | GTK_BIN (combo_box)->child->parent); | |
| 2201 | g_signal_connect (combo_box->priv->button, "button_press_event", | |
| 2202 | G_CALLBACK (gtk_combo_box_list_button_pressed), combo_box); | |
| 2203 | g_signal_connect (combo_box->priv->button, "toggled", | |
| 2204 | G_CALLBACK (gtk_combo_box_button_toggled), combo_box); | |
| 2205 | g_signal_connect_after (combo_box, "key_press_event", | |
| 2206 | G_CALLBACK (gtk_combo_box_key_press), combo_box); | |
| 2207 | ||
| 2208 | combo_box->priv->arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_NONE); | |
| 2209 | gtk_container_add (GTK_CONTAINER (combo_box->priv->button), | |
| 2210 | combo_box->priv->arrow); | |
| 2211 | combo_box->priv->separator = NULL; | |
| 2212 | gtk_widget_show_all (combo_box->priv->button); | |
| 2213 | ||
| 2214 | if (combo_box->priv->cell_view) | |
| 2215 | { | |
| 2216 | combo_box->priv->cell_view_frame = gtk_frame_new (NULL); | |
| 2217 | gtk_widget_set_parent (combo_box->priv->cell_view_frame, | |
| 2218 | GTK_BIN (combo_box)->child->parent); | |
| 2219 | gtk_frame_set_shadow_type (GTK_FRAME (combo_box->priv->cell_view_frame), | |
| 2220 | GTK_SHADOW_IN); | |
| 2221 | ||
| 2222 | gtk_cell_view_set_background_color (GTK_CELL_VIEW (combo_box->priv->cell_view), | |
| 2223 | >K_WIDGET (combo_box)->style->base[GTK_WIDGET_STATE (combo_box)]); | |
| 2224 | ||
| 2225 | combo_box->priv->box = gtk_event_box_new (); | |
| 2226 | /* | |
| 2227 | gtk_event_box_set_visible_window (GTK_EVENT_BOX (combo_box->priv->box), | |
| 2228 | FALSE); | |
| 2229 | */ | |
| 2230 | ||
| 2231 | gtk_container_add (GTK_CONTAINER (combo_box->priv->cell_view_frame), | |
| 2232 | combo_box->priv->box); | |
| 2233 | ||
| 2234 | gtk_widget_show_all (combo_box->priv->cell_view_frame); | |
| 2235 | ||
| 2236 | g_signal_connect (combo_box->priv->box, "button_press_event", | |
| 2237 | G_CALLBACK (gtk_combo_box_list_button_pressed), | |
| 2238 | combo_box); | |
| 2239 | } | |
| 2240 | ||
| 2241 | combo_box->priv->tree_view = gtk_tree_view_new (); | |
| 2242 | sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (combo_box->priv->tree_view)); | |
| 2243 | gtk_tree_selection_set_mode (sel, GTK_SELECTION_BROWSE); | |
| 2244 | gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (combo_box->priv->tree_view), | |
| 2245 | FALSE); | |
| 2246 | /* | |
| 2247 | _gtk_tree_view_set_hover_selection (GTK_TREE_VIEW (combo_box->priv->tree_view), | |
| 2248 | TRUE); | |
| 2249 | */ | |
| 2250 | if (combo_box->priv->model) | |
| 2251 | gtk_tree_view_set_model (GTK_TREE_VIEW (combo_box->priv->tree_view), | |
| 2252 | combo_box->priv->model); | |
| 2253 | ||
| 2254 | g_signal_connect (combo_box->priv->tree_view, "button_press_event", | |
| 2255 | G_CALLBACK (gtk_combo_box_list_button_pressed), | |
| 2256 | combo_box); | |
| 2257 | g_signal_connect (combo_box->priv->tree_view, "button_release_event", | |
| 2258 | G_CALLBACK (gtk_combo_box_list_button_released), | |
| 2259 | combo_box); | |
| 2260 | g_signal_connect (combo_box->priv->tree_view, "key_press_event", | |
| 2261 | G_CALLBACK (gtk_combo_box_list_key_press), | |
| 2262 | combo_box); | |
| 2263 | ||
| 2264 | combo_box->priv->column = gtk_tree_view_column_new (); | |
| 2265 | gtk_tree_view_append_column (GTK_TREE_VIEW (combo_box->priv->tree_view), | |
| 2266 | combo_box->priv->column); | |
| 2267 | ||
| 2268 | /* sync up */ | |
| 2269 | for (i = combo_box->priv->cells; i; i = i->next) | |
| 2270 | { | |
| 2271 | GSList *j; | |
| 2272 | ComboCellInfo *info = (ComboCellInfo *)i->data; | |
| 2273 | ||
| 2274 | if (info->pack == GTK_PACK_START) | |
| 2275 | gtk_tree_view_column_pack_start (combo_box->priv->column, | |
| 2276 | info->cell, info->expand); | |
| 2277 | else if (info->pack == GTK_PACK_END) | |
| 2278 | gtk_tree_view_column_pack_end (combo_box->priv->column, | |
| 2279 | info->cell, info->expand); | |
| 2280 | ||
| 2281 | for (j = info->attributes; j; j = j->next->next) | |
| 2282 | { | |
| 2283 | gtk_tree_view_column_add_attribute (combo_box->priv->column, | |
| 2284 | info->cell, | |
| 2285 | j->data, | |
| 2286 | GPOINTER_TO_INT (j->next->data)); | |
| 2287 | } | |
| 2288 | } | |
| 2289 | ||
| 2290 | if (combo_box->priv->active_item != -1) | |
| 2291 | { | |
| 2292 | GtkTreePath *path; | |
| 2293 | ||
| 2294 | path = gtk_tree_path_new_from_indices (combo_box->priv->active_item, -1); | |
| 2295 | if (path) | |
| 2296 | { | |
| 2297 | gtk_tree_view_set_cursor (GTK_TREE_VIEW (combo_box->priv->tree_view), | |
| 2298 | path, NULL, FALSE); | |
| 2299 | gtk_tree_path_free (path); | |
| 2300 | } | |
| 2301 | } | |
| 2302 | ||
| 2303 | /* set sample/popup widgets */ | |
| 2304 | gtk_combo_box_set_popup_widget (combo_box, combo_box->priv->tree_view); | |
| 2305 | ||
| 2306 | gtk_widget_show (combo_box->priv->tree_view); | |
| 2307 | } | |
| 2308 | ||
| 2309 | static void | |
| 2310 | gtk_combo_box_list_destroy (GtkComboBox *combo_box) | |
| 2311 | { | |
| 2312 | /* disconnect signals */ | |
| 2313 | g_signal_handlers_disconnect_matched (combo_box->priv->tree_view, | |
| 2314 | G_SIGNAL_MATCH_DATA, | |
| 2315 | 0, 0, NULL, NULL, combo_box); | |
| 2316 | g_signal_handlers_disconnect_matched (combo_box->priv->button, | |
| 2317 | G_SIGNAL_MATCH_DATA, | |
| 2318 | 0, 0, NULL, | |
| 2319 | gtk_combo_box_list_button_pressed, | |
| 2320 | NULL); | |
| 2321 | if (combo_box->priv->box) | |
| 2322 | g_signal_handlers_disconnect_matched (combo_box->priv->box, | |
| 2323 | G_SIGNAL_MATCH_DATA, | |
| 2324 | 0, 0, NULL, | |
| 2325 | gtk_combo_box_list_button_pressed, | |
| 2326 | NULL); | |
| 2327 | ||
| 2328 | /* destroy things (unparent will kill the latest ref from us) | |
| 2329 | * last unref on button will destroy the arrow | |
| 2330 | */ | |
| 2331 | gtk_widget_unparent (combo_box->priv->button); | |
| 2332 | combo_box->priv->button = NULL; | |
| 2333 | combo_box->priv->arrow = NULL; | |
| 2334 | ||
| 2335 | if (combo_box->priv->cell_view) | |
| 2336 | { | |
| 2337 | g_object_set (G_OBJECT (combo_box->priv->cell_view), | |
| 2338 | "background_set", FALSE, | |
| 2339 | NULL); | |
| 2340 | } | |
| 2341 | ||
| 2342 | if (combo_box->priv->cell_view_frame) | |
| 2343 | { | |
| 2344 | gtk_widget_unparent (combo_box->priv->cell_view_frame); | |
| 2345 | combo_box->priv->cell_view_frame = NULL; | |
| 2346 | combo_box->priv->box = NULL; | |
| 2347 | } | |
| 2348 | ||
| 2349 | gtk_widget_destroy (combo_box->priv->tree_view); | |
| 2350 | ||
| 2351 | combo_box->priv->tree_view = NULL; | |
| 2352 | combo_box->priv->popup_widget = NULL; | |
| 2353 | } | |
| 2354 | ||
| 2355 | /* callbacks */ | |
| 2356 | static void | |
| 2357 | gtk_combo_box_list_remove_grabs (GtkComboBox *combo_box) | |
| 2358 | { | |
| 2359 | if (combo_box->priv->tree_view && | |
| 2360 | GTK_WIDGET_HAS_GRAB (combo_box->priv->tree_view)) | |
| 2361 | { | |
| 2362 | gtk_grab_remove (combo_box->priv->tree_view); | |
| 2363 | } | |
| 2364 | ||
| 2365 | if (combo_box->priv->popup_window && | |
| 2366 | GTK_WIDGET_HAS_GRAB (combo_box->priv->popup_window)) | |
| 2367 | { | |
| 2368 | gtk_grab_remove (combo_box->priv->popup_window); | |
| 2369 | gdk_keyboard_ungrab (GDK_CURRENT_TIME); | |
| 2370 | gdk_pointer_ungrab (GDK_CURRENT_TIME); | |
| 2371 | } | |
| 2372 | } | |
| 2373 | ||
| 2374 | static gboolean | |
| 2375 | gtk_combo_box_list_button_pressed (GtkWidget *widget, | |
| 2376 | GdkEventButton *event, | |
| 2377 | gpointer data) | |
| 2378 | { | |
| 2379 | GtkComboBox *combo_box = GTK_COMBO_BOX (data); | |
| 2380 | ||
| 2381 | GtkWidget *ewidget = gtk_get_event_widget ((GdkEvent *)event); | |
| 2382 | ||
| 2383 | if (ewidget == combo_box->priv->tree_view) | |
| 2384 | return TRUE; | |
| 2385 | ||
| 2386 | if ((ewidget != combo_box->priv->button && ewidget != combo_box->priv->box) || | |
| 2387 | gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (combo_box->priv->button))) | |
| 2388 | return FALSE; | |
| 2389 | ||
| 2390 | gtk_combo_box_popup (combo_box); | |
| 2391 | ||
| 2392 | gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (combo_box->priv->button), | |
| 2393 | TRUE); | |
| 2394 | ||
| 2395 | combo_box->priv->popup_in_progress = TRUE; | |
| 2396 | ||
| 2397 | return TRUE; | |
| 2398 | } | |
| 2399 | ||
| 2400 | static gboolean | |
| 2401 | gtk_combo_box_list_button_released (GtkWidget *widget, | |
| 2402 | GdkEventButton *event, | |
| 2403 | gpointer data) | |
| 2404 | { | |
| 2405 | gboolean ret; | |
| 2406 | GtkTreePath *path = NULL; | |
| 2407 | ||
| 2408 | GtkComboBox *combo_box = GTK_COMBO_BOX (data); | |
| 2409 | ||
| 2410 | gboolean popup_in_progress = FALSE; | |
| 2411 | ||
| 2412 | GtkWidget *ewidget = gtk_get_event_widget ((GdkEvent *)event); | |
| 2413 | ||
| 2414 | if (combo_box->priv->popup_in_progress) | |
| 2415 | { | |
| 2416 | popup_in_progress = TRUE; | |
| 2417 | combo_box->priv->popup_in_progress = FALSE; | |
| 2418 | } | |
| 2419 | ||
| 2420 | if (ewidget != combo_box->priv->tree_view) | |
| 2421 | { | |
| 2422 | if (ewidget == combo_box->priv->button && | |
| 2423 | !popup_in_progress && | |
| 2424 | gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (combo_box->priv->button))) | |
| 2425 | { | |
| 2426 | gtk_combo_box_popdown (combo_box); | |
| 2427 | return TRUE; | |
| 2428 | } | |
| 2429 | ||
| 2430 | /* released outside treeview */ | |
| 2431 | if (ewidget != combo_box->priv->button) | |
| 2432 | { | |
| 2433 | gtk_combo_box_popdown (combo_box); | |
| 2434 | ||
| 2435 | return TRUE; | |
| 2436 | } | |
| 2437 | ||
| 2438 | return FALSE; | |
| 2439 | } | |
| 2440 | ||
| 2441 | /* select something cool */ | |
| 2442 | ret = gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget), | |
| 2443 | event->x, event->y, | |
| 2444 | &path, | |
| 2445 | NULL, NULL, NULL); | |
| 2446 | ||
| 2447 | if (!ret) | |
| 2448 | return TRUE; /* clicked outside window? */ | |
| 2449 | ||
| 2450 | gtk_combo_box_set_active (combo_box, gtk_tree_path_get_indices (path)[0]); | |
| 2451 | gtk_combo_box_popdown (combo_box); | |
| 2452 | ||
| 2453 | gtk_tree_path_free (path); | |
| 2454 | ||
| 2455 | return TRUE; | |
| 2456 | } | |
| 2457 | ||
| 2458 | static gboolean | |
| 2459 | gtk_combo_box_key_press (GtkWidget *widget, | |
| 2460 | GdkEventKey *event, | |
| 2461 | gpointer data) | |
| 2462 | { | |
| 2463 | GtkComboBox *combo_box = GTK_COMBO_BOX (data); | |
| 2464 | guint state = event->state & gtk_accelerator_get_default_mod_mask (); | |
| 2465 | gint items = 0; | |
| 2466 | gint index = gtk_combo_box_get_active (combo_box); | |
| 2467 | gint new_index; | |
| 2468 | ||
| 2469 | if (combo_box->priv->model) | |
| 2470 | items = gtk_tree_model_iter_n_children (combo_box->priv->model, NULL); | |
| 2471 | ||
| 2472 | if ((event->keyval == GDK_Down || event->keyval == GDK_KP_Down) && | |
| 2473 | state == GDK_MOD1_MASK) | |
| 2474 | { | |
| 2475 | gtk_combo_box_popup (combo_box); | |
| 2476 | ||
| 2477 | return TRUE; | |
| 2478 | } | |
| 2479 | ||
| 2480 | switch (event->keyval) | |
| 2481 | { | |
| 2482 | case GDK_Down: | |
| 2483 | case GDK_KP_Down: | |
| 2484 | new_index = index + 1; | |
| 2485 | break; | |
| 2486 | case GDK_Up: | |
| 2487 | case GDK_KP_Up: | |
| 2488 | new_index = index - 1; | |
| 2489 | break; | |
| 2490 | case GDK_Page_Up: | |
| 2491 | case GDK_KP_Page_Up: | |
| 2492 | case GDK_Home: | |
| 2493 | case GDK_KP_Home: | |
| 2494 | new_index = 0; | |
| 2495 | break; | |
| 2496 | case GDK_Page_Down: | |
| 2497 | case GDK_KP_Page_Down: | |
| 2498 | case GDK_End: | |
| 2499 | case GDK_KP_End: | |
| 2500 | new_index = items - 1; | |
| 2501 | break; | |
| 2502 | default: | |
| 2503 | return FALSE; | |
| 2504 | } | |
| 2505 | ||
| 2506 | if (items > 0) | |
| 2507 | gtk_combo_box_set_active (combo_box, CLAMP (new_index, 0, items - 1)); | |
| 2508 | ||
| 2509 | return TRUE; | |
| 2510 | } | |
| 2511 | ||
| 2512 | static gboolean | |
| 2513 | gtk_combo_box_menu_key_press (GtkWidget *widget, | |
| 2514 | GdkEventKey *event, | |
| 2515 | gpointer data) | |
| 2516 | { | |
| 2517 | GtkComboBox *combo_box = GTK_COMBO_BOX (data); | |
| 2518 | guint state = event->state & gtk_accelerator_get_default_mod_mask (); | |
| 2519 | ||
| 2520 | if ((event->keyval == GDK_Up || event->keyval == GDK_KP_Up) && | |
| 2521 | state == GDK_MOD1_MASK) | |
| 2522 | { | |
| 2523 | gtk_combo_box_popdown (combo_box); | |
| 2524 | ||
| 2525 | return TRUE; | |
| 2526 | } | |
| 2527 | ||
| 2528 | return FALSE; | |
| 2529 | } | |
| 2530 | ||
| 2531 | static gboolean | |
| 2532 | gtk_combo_box_list_key_press (GtkWidget *widget, | |
| 2533 | GdkEventKey *event, | |
| 2534 | gpointer data) | |
| 2535 | { | |
| 2536 | GtkComboBox *combo_box = GTK_COMBO_BOX (data); | |
| 2537 | guint state = event->state & gtk_accelerator_get_default_mod_mask (); | |
| 2538 | ||
| 2539 | if (event->keyval == GDK_Escape || | |
| 2540 | ((event->keyval == GDK_Up || event->keyval == GDK_KP_Up) && | |
| 2541 | state == GDK_MOD1_MASK)) | |
| 2542 | { | |
| 2543 | /* reset active item -- this is incredibly lame and ugly */ | |
| 2544 | gtk_combo_box_set_active (combo_box, | |
| 2545 | gtk_combo_box_get_active (combo_box)); | |
| 2546 | ||
| 2547 | gtk_combo_box_popdown (combo_box); | |
| 2548 | ||
| 2549 | return TRUE; | |
| 2550 | } | |
| 2551 | ||
| 2552 | if (event->keyval == GDK_Return || event->keyval == GDK_KP_Enter || | |
| 2553 | event->keyval == GDK_space || event->keyval == GDK_KP_Space) | |
| 2554 | { | |
| 2555 | gboolean ret = FALSE; | |
| 2556 | GtkTreeIter iter; | |
| 2557 | GtkTreeModel *model = NULL; | |
| 2558 | ||
| 2559 | if (combo_box->priv->model) | |
| 2560 | { | |
| 2561 | GtkTreeSelection *sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (combo_box->priv->tree_view)); | |
| 2562 | ||
| 2563 | ret = gtk_tree_selection_get_selected (sel, &model, &iter); | |
| 2564 | } | |
| 2565 | if (ret) | |
| 2566 | { | |
| 2567 | GtkTreePath *path; | |
| 2568 | ||
| 2569 | path = gtk_tree_model_get_path (model, &iter); | |
| 2570 | if (path) | |
| 2571 | { | |
| 2572 | gtk_combo_box_set_active (combo_box, gtk_tree_path_get_indices (path)[0]); | |
| 2573 | gtk_tree_path_free (path); | |
| 2574 | } | |
| 2575 | } | |
| 2576 | ||
| 2577 | gtk_combo_box_popdown (combo_box); | |
| 2578 | ||
| 2579 | return TRUE; | |
| 2580 | } | |
| 2581 | ||
| 2582 | return FALSE; | |
| 2583 | } | |
| 2584 | ||
| 2585 | static void | |
| 2586 | gtk_combo_box_list_row_changed (GtkTreeModel *model, | |
| 2587 | GtkTreePath *path, | |
| 2588 | GtkTreeIter *iter, | |
| 2589 | gpointer data) | |
| 2590 | { | |
| 2591 | GtkComboBox *combo_box = GTK_COMBO_BOX (data); | |
| 2592 | gint width; | |
| 2593 | ||
| 2594 | width = gtk_combo_box_calc_requested_width (combo_box, path); | |
| 2595 | ||
| 2596 | if (width > combo_box->priv->width) | |
| 2597 | { | |
| 2598 | if (combo_box->priv->cell_view) | |
| 2599 | { | |
| 2600 | gtk_widget_set_size_request (combo_box->priv->cell_view, width, -1); | |
| 2601 | gtk_widget_queue_resize (combo_box->priv->cell_view); | |
| 2602 | } | |
| 2603 | combo_box->priv->width = width; | |
| 2604 | } | |
| 2605 | } | |
| 2606 | ||
| 2607 | /* | |
| 2608 | * GtkCellLayout implementation | |
| 2609 | */ | |
| 2610 | static void | |
| 2611 | gtk_combo_box_cell_layout_pack_start (GtkCellLayout *layout, | |
| 2612 | GtkCellRenderer *cell, | |
| 2613 | gboolean expand) | |
| 2614 | { | |
| 2615 | ComboCellInfo *info; | |
| 2616 | GtkComboBox *combo_box; | |
| 2617 | GtkWidget *menu; | |
| 2618 | ||
| 2619 | g_return_if_fail (GTK_IS_COMBO_BOX (layout)); | |
| 2620 | g_return_if_fail (GTK_IS_CELL_RENDERER (cell)); | |
| 2621 | ||
| 2622 | combo_box = GTK_COMBO_BOX (layout); | |
| 2623 | ||
| 2624 | g_object_ref (G_OBJECT (cell)); | |
| 2625 | gtk_object_sink (GTK_OBJECT (cell)); | |
| 2626 | ||
| 2627 | info = g_new0 (ComboCellInfo, 1); | |
| 2628 | info->cell = cell; | |
| 2629 | info->expand = expand; | |
| 2630 | info->pack = GTK_PACK_START; | |
| 2631 | ||
| 2632 | combo_box->priv->cells = g_slist_append (combo_box->priv->cells, info); | |
| 2633 | ||
| 2634 | if (combo_box->priv->cell_view) | |
| 2635 | gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box->priv->cell_view), | |
| 2636 | cell, expand); | |
| 2637 | ||
| 2638 | if (combo_box->priv->column) | |
| 2639 | gtk_tree_view_column_pack_start (combo_box->priv->column, cell, expand); | |
| 2640 | ||
| 2641 | menu = combo_box->priv->popup_widget; | |
| 2642 | if (GTK_IS_MENU (menu)) | |
| 2643 | { | |
| 2644 | GList *i, *list; | |
| 2645 | ||
| 2646 | list = gtk_container_get_children (GTK_CONTAINER (menu)); | |
| 2647 | for (i = list; i; i = i->next) | |
| 2648 | { | |
| 2649 | GtkCellView *view; | |
| 2650 | ||
| 2651 | if (GTK_IS_CELL_VIEW_MENU_ITEM (i->data)) | |
| 2652 | view = GTK_CELL_VIEW (GTK_BIN (i->data)->child); | |
| 2653 | else | |
| 2654 | view = GTK_CELL_VIEW (i->data); | |
| 2655 | ||
| 2656 | gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (view), cell, expand); | |
| 2657 | } | |
| 2658 | g_list_free (list); | |
| 2659 | } | |
| 2660 | } | |
| 2661 | ||
| 2662 | static void | |
| 2663 | gtk_combo_box_cell_layout_pack_end (GtkCellLayout *layout, | |
| 2664 | GtkCellRenderer *cell, | |
| 2665 | gboolean expand) | |
| 2666 | { | |
| 2667 | ComboCellInfo *info; | |
| 2668 | GtkComboBox *combo_box; | |
| 2669 | GtkWidget *menu; | |
| 2670 | ||
| 2671 | g_return_if_fail (GTK_IS_COMBO_BOX (layout)); | |
| 2672 | g_return_if_fail (GTK_IS_CELL_RENDERER (cell)); | |
| 2673 | ||
| 2674 | combo_box = GTK_COMBO_BOX (layout); | |
| 2675 | ||
| 2676 | g_object_ref (G_OBJECT (cell)); | |
| 2677 | gtk_object_sink (GTK_OBJECT (cell)); | |
| 2678 | ||
| 2679 | info = g_new0 (ComboCellInfo, 1); | |
| 2680 | info->cell = cell; | |
| 2681 | info->expand = expand; | |
| 2682 | info->pack = GTK_PACK_END; | |
| 2683 | ||
| 2684 | combo_box->priv->cells = g_slist_append (combo_box->priv->cells, info); | |
| 2685 | ||
| 2686 | if (combo_box->priv->cell_view) | |
| 2687 | gtk_cell_layout_pack_end (GTK_CELL_LAYOUT (combo_box->priv->cell_view), | |
| 2688 | cell, expand); | |
| 2689 | ||
| 2690 | if (combo_box->priv->column) | |
| 2691 | gtk_tree_view_column_pack_end (combo_box->priv->column, cell, expand); | |
| 2692 | ||
| 2693 | menu = combo_box->priv->popup_widget; | |
| 2694 | if (GTK_IS_MENU (menu)) | |
| 2695 | { | |
| 2696 | GList *i, *list; | |
| 2697 | ||
| 2698 | list = gtk_container_get_children (GTK_CONTAINER (menu)); | |
| 2699 | for (i = list; i; i = i->next) | |
| 2700 | { | |
| 2701 | GtkCellView *view; | |
| 2702 | ||
| 2703 | if (GTK_IS_CELL_VIEW_MENU_ITEM (i->data)) | |
| 2704 | view = GTK_CELL_VIEW (GTK_BIN (i->data)->child); | |
| 2705 | else | |
| 2706 | view = GTK_CELL_VIEW (i->data); | |
| 2707 | ||
| 2708 | gtk_cell_layout_pack_end (GTK_CELL_LAYOUT (view), cell, expand); | |
| 2709 | } | |
| 2710 | g_list_free (list); | |
| 2711 | } | |
| 2712 | } | |
| 2713 | ||
| 2714 | static void | |
| 2715 | gtk_combo_box_cell_layout_clear (GtkCellLayout *layout) | |
| 2716 | { | |
| 2717 | GtkWidget *menu; | |
| 2718 | GtkComboBox *combo_box; | |
| 2719 | GSList *i; | |
| 2720 | ||
| 2721 | g_return_if_fail (GTK_IS_COMBO_BOX (layout)); | |
| 2722 | ||
| 2723 | combo_box = GTK_COMBO_BOX (layout); | |
| 2724 | ||
| 2725 | if (combo_box->priv->cell_view) | |
| 2726 | gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo_box->priv->cell_view)); | |
| 2727 | ||
| 2728 | if (combo_box->priv->column) | |
| 2729 | gtk_tree_view_column_clear (combo_box->priv->column); | |
| 2730 | ||
| 2731 | for (i = combo_box->priv->cells; i; i = i->next) | |
| 2732 | { | |
| 2733 | ComboCellInfo *info = (ComboCellInfo *)i->data; | |
| 2734 | ||
| 2735 | gtk_combo_box_cell_layout_clear_attributes (layout, info->cell); | |
| 2736 | g_object_unref (G_OBJECT (info->cell)); | |
| 2737 | g_free (info); | |
| 2738 | i->data = NULL; | |
| 2739 | } | |
| 2740 | g_slist_free (combo_box->priv->cells); | |
| 2741 | combo_box->priv->cells = NULL; | |
| 2742 | ||
| 2743 | menu = combo_box->priv->popup_widget; | |
| 2744 | if (GTK_IS_MENU (menu)) | |
| 2745 | { | |
| 2746 | GList *i, *list; | |
| 2747 | ||
| 2748 | list = gtk_container_get_children (GTK_CONTAINER (menu)); | |
| 2749 | for (i = list; i; i = i->next) | |
| 2750 | { | |
| 2751 | GtkCellView *view; | |
| 2752 | ||
| 2753 | if (GTK_IS_CELL_VIEW_MENU_ITEM (i->data)) | |
| 2754 | view = GTK_CELL_VIEW (GTK_BIN (i->data)->child); | |
| 2755 | else | |
| 2756 | view = GTK_CELL_VIEW (i->data); | |
| 2757 | ||
| 2758 | gtk_cell_layout_clear (GTK_CELL_LAYOUT (view)); | |
| 2759 | } | |
| 2760 | g_list_free (list); | |
| 2761 | } | |
| 2762 | } | |
| 2763 | ||
| 2764 | static void | |
| 2765 | gtk_combo_box_cell_layout_add_attribute (GtkCellLayout *layout, | |
| 2766 | GtkCellRenderer *cell, | |
| 2767 | const gchar *attribute, | |
| 2768 | gint column) | |
| 2769 | { | |
| 2770 | ComboCellInfo *info; | |
| 2771 | GtkComboBox *combo_box; | |
| 2772 | GtkWidget *menu; | |
| 2773 | ||
| 2774 | g_return_if_fail (GTK_IS_COMBO_BOX (layout)); | |
| 2775 | g_return_if_fail (GTK_IS_CELL_RENDERER (cell)); | |
| 2776 | ||
| 2777 | combo_box = GTK_COMBO_BOX (layout); | |
| 2778 | ||
| 2779 | info = gtk_combo_box_get_cell_info (combo_box, cell); | |
| 2780 | ||
| 2781 | info->attributes = g_slist_prepend (info->attributes, | |
| 2782 | GINT_TO_POINTER (column)); | |
| 2783 | info->attributes = g_slist_prepend (info->attributes, | |
| 2784 | g_strdup (attribute)); | |
| 2785 | ||
| 2786 | if (combo_box->priv->cell_view) | |
| 2787 | gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo_box->priv->cell_view), | |
| 2788 | cell, attribute, column); | |
| 2789 | ||
| 2790 | if (combo_box->priv->column) | |
| 2791 | gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo_box->priv->column), | |
| 2792 | cell, attribute, column); | |
| 2793 | ||
| 2794 | menu = combo_box->priv->popup_widget; | |
| 2795 | if (GTK_IS_MENU (menu)) | |
| 2796 | { | |
| 2797 | GList *i, *list; | |
| 2798 | ||
| 2799 | list = gtk_container_get_children (GTK_CONTAINER (menu)); | |
| 2800 | for (i = list; i; i = i->next) | |
| 2801 | { | |
| 2802 | GtkCellView *view; | |
| 2803 | ||
| 2804 | if (GTK_IS_CELL_VIEW_MENU_ITEM (i->data)) | |
| 2805 | view = GTK_CELL_VIEW (GTK_BIN (i->data)->child); | |
| 2806 | else | |
| 2807 | view = GTK_CELL_VIEW (i->data); | |
| 2808 | ||
| 2809 | gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (view), cell, | |
| 2810 | attribute, column); | |
| 2811 | } | |
| 2812 | g_list_free (list); | |
| 2813 | } | |
| 2814 | ||
| 2815 | gtk_widget_queue_resize (GTK_WIDGET (combo_box)); | |
| 2816 | } | |
| 2817 | ||
| 2818 | static void | |
| 2819 | gtk_combo_box_cell_layout_set_cell_data_func (GtkCellLayout *layout, | |
| 2820 | GtkCellRenderer *cell, | |
| 2821 | GtkCellLayoutDataFunc func, | |
| 2822 | gpointer func_data, | |
| 2823 | GDestroyNotify destroy) | |
| 2824 | { | |
| 2825 | ComboCellInfo *info; | |
| 2826 | GtkComboBox *combo_box; | |
| 2827 | GtkWidget *menu; | |
| 2828 | ||
| 2829 | g_return_if_fail (GTK_IS_COMBO_BOX (layout)); | |
| 2830 | ||
| 2831 | combo_box = GTK_COMBO_BOX (layout); | |
| 2832 | ||
| 2833 | info = gtk_combo_box_get_cell_info (combo_box, cell); | |
| 2834 | g_return_if_fail (info != NULL); | |
| 2835 | ||
| 2836 | if (info->destroy) | |
| 2837 | { | |
| 2838 | GDestroyNotify d = info->destroy; | |
| 2839 | ||
| 2840 | info->destroy = NULL; | |
| 2841 | d (info->func_data); | |
| 2842 | } | |
| 2843 | ||
| 2844 | info->func = func; | |
| 2845 | info->func_data = func_data; | |
| 2846 | info->destroy = destroy; | |
| 2847 | ||
| 2848 | if (combo_box->priv->cell_view) | |
| 2849 | gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combo_box->priv->cell_view), cell, func, func_data, NULL); | |
| 2850 | ||
| 2851 | if (combo_box->priv->column) | |
| 2852 | gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combo_box->priv->column), cell, func, func_data, NULL); | |
| 2853 | ||
| 2854 | menu = combo_box->priv->popup_widget; | |
| 2855 | if (GTK_IS_MENU (menu)) | |
| 2856 | { | |
| 2857 | GList *i, *list; | |
| 2858 | ||
| 2859 | list = gtk_container_get_children (GTK_CONTAINER (menu)); | |
| 2860 | for (i = list; i; i = i->next) | |
| 2861 | { | |
| 2862 | GtkCellView *view; | |
| 2863 | ||
| 2864 | if (GTK_IS_CELL_VIEW_MENU_ITEM (i->data)) | |
| 2865 | view = GTK_CELL_VIEW (GTK_BIN (i->data)->child); | |
| 2866 | else | |
| 2867 | view = GTK_CELL_VIEW (i->data); | |
| 2868 | ||
| 2869 | gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (view), cell, | |
| 2870 | func, func_data, NULL); | |
| 2871 | } | |
| 2872 | g_list_free (list); | |
| 2873 | } | |
| 2874 | ||
| 2875 | gtk_widget_queue_resize (GTK_WIDGET (combo_box)); | |
| 2876 | } | |
| 2877 | ||
| 2878 | static void | |
| 2879 | gtk_combo_box_cell_layout_clear_attributes (GtkCellLayout *layout, | |
| 2880 | GtkCellRenderer *cell) | |
| 2881 | { | |
| 2882 | ComboCellInfo *info; | |
| 2883 | GtkComboBox *combo_box; | |
| 2884 | GtkWidget *menu; | |
| 2885 | GSList *list; | |
| 2886 | ||
| 2887 | g_return_if_fail (GTK_IS_COMBO_BOX (layout)); | |
| 2888 | g_return_if_fail (GTK_IS_CELL_RENDERER (cell)); | |
| 2889 | ||
| 2890 | combo_box = GTK_COMBO_BOX (layout); | |
| 2891 | ||
| 2892 | info = gtk_combo_box_get_cell_info (combo_box, cell); | |
| 2893 | if (info) | |
| 2894 | { | |
| 2895 | list = info->attributes; | |
| 2896 | while (list && list->next) | |
| 2897 | { | |
| 2898 | g_free (list->data); | |
| 2899 | list = list->next->next; | |
| 2900 | } | |
| 2901 | g_slist_free (info->attributes); | |
| 2902 | info->attributes = NULL; | |
| 2903 | } | |
| 2904 | ||
| 2905 | if (combo_box->priv->cell_view) | |
| 2906 | gtk_cell_layout_clear_attributes (GTK_CELL_LAYOUT (combo_box->priv->cell_view), cell); | |
| 2907 | ||
| 2908 | if (combo_box->priv->column) | |
| 2909 | gtk_cell_layout_clear_attributes (GTK_CELL_LAYOUT (combo_box->priv->column), cell); | |
| 2910 | ||
| 2911 | menu = combo_box->priv->popup_widget; | |
| 2912 | if (GTK_IS_MENU (menu)) | |
| 2913 | { | |
| 2914 | GList *i, *list; | |
| 2915 | ||
| 2916 | list = gtk_container_get_children (GTK_CONTAINER (menu)); | |
| 2917 | for (i = list; i; i = i->next) | |
| 2918 | { | |
| 2919 | GtkCellView *view; | |
| 2920 | ||
| 2921 | if (GTK_IS_CELL_VIEW_MENU_ITEM (i->data)) | |
| 2922 | view = GTK_CELL_VIEW (GTK_BIN (i->data)->child); | |
| 2923 | else | |
| 2924 | view = GTK_CELL_VIEW (i->data); | |
| 2925 | ||
| 2926 | gtk_cell_layout_clear_attributes (GTK_CELL_LAYOUT (view), cell); | |
| 2927 | } | |
| 2928 | g_list_free (list); | |
| 2929 | } | |
| 2930 | ||
| 2931 | gtk_widget_queue_resize (GTK_WIDGET (combo_box)); | |
| 2932 | } | |
| 2933 | ||
| 2934 | static void | |
| 2935 | gtk_combo_box_cell_layout_reorder (GtkCellLayout *layout, | |
| 2936 | GtkCellRenderer *cell, | |
| 2937 | gint position) | |
| 2938 | { | |
| 2939 | ComboCellInfo *info; | |
| 2940 | GtkComboBox *combo_box; | |
| 2941 | GtkWidget *menu; | |
| 2942 | GSList *link; | |
| 2943 | ||
| 2944 | g_return_if_fail (GTK_IS_COMBO_BOX (layout)); | |
| 2945 | g_return_if_fail (GTK_IS_CELL_RENDERER (cell)); | |
| 2946 | ||
| 2947 | combo_box = GTK_COMBO_BOX (layout); | |
| 2948 | ||
| 2949 | info = gtk_combo_box_get_cell_info (combo_box, cell); | |
| 2950 | ||
| 2951 | g_return_if_fail (info != NULL); | |
| 2952 | g_return_if_fail (position >= 0); | |
| 2953 | ||
| 2954 | link = g_slist_find (combo_box->priv->cells, info); | |
| 2955 | ||
| 2956 | g_return_if_fail (link != NULL); | |
| 2957 | ||
| 2958 | combo_box->priv->cells = g_slist_remove_link (combo_box->priv->cells, link); | |
| 2959 | combo_box->priv->cells = g_slist_insert (combo_box->priv->cells, info, | |
| 2960 | position); | |
| 2961 | ||
| 2962 | if (combo_box->priv->cell_view) | |
| 2963 | gtk_cell_layout_reorder (GTK_CELL_LAYOUT (combo_box->priv->cell_view), | |
| 2964 | cell, position); | |
| 2965 | ||
| 2966 | if (combo_box->priv->column) | |
| 2967 | gtk_cell_layout_reorder (GTK_CELL_LAYOUT (combo_box->priv->column), | |
| 2968 | cell, position); | |
| 2969 | ||
| 2970 | menu = combo_box->priv->popup_widget; | |
| 2971 | if (GTK_IS_MENU (menu)) | |
| 2972 | { | |
| 2973 | GList *i, *list; | |
| 2974 | ||
| 2975 | list = gtk_container_get_children (GTK_CONTAINER (menu)); | |
| 2976 | for (i = list; i; i = i->next) | |
| 2977 | { | |
| 2978 | GtkCellView *view; | |
| 2979 | ||
| 2980 | if (GTK_IS_CELL_VIEW_MENU_ITEM (i->data)) | |
| 2981 | view = GTK_CELL_VIEW (GTK_BIN (i->data)->child); | |
| 2982 | else | |
| 2983 | view = GTK_CELL_VIEW (i->data); | |
| 2984 | ||
| 2985 | gtk_cell_layout_reorder (GTK_CELL_LAYOUT (view), cell, position); | |
| 2986 | } | |
| 2987 | g_list_free (list); | |
| 2988 | } | |
| 2989 | ||
| 2990 | gtk_widget_queue_draw (GTK_WIDGET (combo_box)); | |
| 2991 | } | |
| 2992 | ||
| 2993 | /* | |
| 2994 | * public API | |
| 2995 | */ | |
| 2996 | ||
| 2997 | /** | |
| 2998 | * gtk_combo_box_new: | |
| 2999 | * | |
| 3000 | * Creates a new empty #GtkComboBox. | |
| 3001 | * | |
| 3002 | * Return value: A new #GtkComboBox. | |
| 3003 | * | |
| 3004 | * Since: 2.4 | |
| 3005 | */ | |
| 3006 | GtkWidget * | |
| 3007 | gtk_combo_box_new (void) | |
| 3008 | { | |
| 3009 | return GTK_WIDGET (g_object_new (GTK_TYPE_COMBO_BOX, NULL)); | |
| 3010 | } | |
| 3011 | ||
| 3012 | /** | |
| 3013 | * gtk_combo_box_new_with_model: | |
| 3014 | * @model: A #GtkTreeModel. | |
| 3015 | * | |
| 3016 | * Creates a new #GtkComboBox with the model initialized to @model. | |
| 3017 | * | |
| 3018 | * Return value: A new #GtkComboBox. | |
| 3019 | * | |
| 3020 | * Since: 2.4 | |
| 3021 | */ | |
| 3022 | GtkWidget * | |
| 3023 | gtk_combo_box_new_with_model (GtkTreeModel *model) | |
| 3024 | { | |
| 3025 | GtkComboBox *combo_box; | |
| 3026 | ||
| 3027 | g_return_val_if_fail (GTK_IS_TREE_MODEL (model), NULL); | |
| 3028 | ||
| 3029 | combo_box = GTK_COMBO_BOX (g_object_new (GTK_TYPE_COMBO_BOX, | |
| 3030 | "model", model, | |
| 3031 | NULL)); | |
| 3032 | ||
| 3033 | return GTK_WIDGET (combo_box); | |
| 3034 | } | |
| 3035 | ||
| 3036 | /** | |
| 3037 | * gtk_combo_box_set_wrap_width: | |
| 3038 | * @combo_box: A #GtkComboBox. | |
| 3039 | * @width: Preferred number of columns. | |
| 3040 | * | |
| 3041 | * Sets the wrap width of @combo_box to be @width. The wrap width is basically | |
| 3042 | * the preferred number of columns when you want to the popup to be layed out | |
| 3043 | * in a table. | |
| 3044 | * | |
| 3045 | * Since: 2.4 | |
| 3046 | */ | |
| 3047 | void | |
| 3048 | gtk_combo_box_set_wrap_width (GtkComboBox *combo_box, | |
| 3049 | gint width) | |
| 3050 | { | |
| 3051 | g_return_if_fail (GTK_IS_COMBO_BOX (combo_box)); | |
| 3052 | g_return_if_fail (width >= 0); | |
| 3053 | ||
| 3054 | if (width != combo_box->priv->wrap_width) | |
| 3055 | { | |
| 3056 | combo_box->priv->wrap_width = width; | |
| 3057 | ||
| 3058 | gtk_combo_box_check_appearance (combo_box); | |
| 3059 | gtk_combo_box_relayout (combo_box); | |
| 3060 | ||
| 3061 | g_object_notify (G_OBJECT (combo_box), "wrap_width"); | |
| 3062 | } | |
| 3063 | } | |
| 3064 | ||
| 3065 | /** | |
| 3066 | * gtk_combo_box_set_row_span_column: | |
| 3067 | * @combo_box: A #GtkComboBox. | |
| 3068 | * @row_span: A column in the model passed during construction. | |
| 3069 | * | |
| 3070 | * Sets the column with row span information for @combo_box to be @row_span. | |
| 3071 | * The row span column contains integers which indicate how many rows | |
| 3072 | * an item should span. | |
| 3073 | * | |
| 3074 | * Since: 2.4 | |
| 3075 | */ | |
| 3076 | void | |
| 3077 | gtk_combo_box_set_row_span_column (GtkComboBox *combo_box, | |
| 3078 | gint row_span) | |
| 3079 | { | |
| 3080 | gint col; | |
| 3081 | ||
| 3082 | g_return_if_fail (GTK_IS_COMBO_BOX (combo_box)); | |
| 3083 | ||
| 3084 | col = gtk_tree_model_get_n_columns (combo_box->priv->model); | |
| 3085 | g_return_if_fail (row_span >= 0 && row_span < col); | |
| 3086 | ||
| 3087 | if (row_span != combo_box->priv->row_column) | |
| 3088 | { | |
| 3089 | combo_box->priv->row_column = row_span; | |
| 3090 | ||
| 3091 | gtk_combo_box_relayout (combo_box); | |
| 3092 | ||
| 3093 | g_object_notify (G_OBJECT (combo_box), "row_span_column"); | |
| 3094 | } | |
| 3095 | } | |
| 3096 | ||
| 3097 | /** | |
| 3098 | * gtk_combo_box_set_column_span_column: | |
| 3099 | * @combo_box: A #GtkComboBox. | |
| 3100 | * @column_span: A column in the model passed during construction. | |
| 3101 | * | |
| 3102 | * Sets the column with column span information for @combo_box to be | |
| 3103 | * @column_span. The column span column contains integers which indicate | |
| 3104 | * how many columns an item should span. | |
| 3105 | * | |
| 3106 | * Since: 2.4 | |
| 3107 | */ | |
| 3108 | void | |
| 3109 | gtk_combo_box_set_column_span_column (GtkComboBox *combo_box, | |
| 3110 | gint column_span) | |
| 3111 | { | |
| 3112 | gint col; | |
| 3113 | ||
| 3114 | g_return_if_fail (GTK_IS_COMBO_BOX (combo_box)); | |
| 3115 | ||
| 3116 | col = gtk_tree_model_get_n_columns (combo_box->priv->model); | |
| 3117 | g_return_if_fail (column_span >= 0 && column_span < col); | |
| 3118 | ||
| 3119 | if (column_span != combo_box->priv->col_column) | |
| 3120 | { | |
| 3121 | combo_box->priv->col_column = column_span; | |
| 3122 | ||
| 3123 | gtk_combo_box_relayout (combo_box); | |
| 3124 | ||
| 3125 | g_object_notify (G_OBJECT (combo_box), "column_span_column"); | |
| 3126 | } | |
| 3127 | } | |
| 3128 | ||
| 3129 | /** | |
| 3130 | * gtk_combo_box_get_active: | |
| 3131 | * @combo_box: A #GtkComboBox. | |
| 3132 | * | |
| 3133 | * Returns the index of the currently active item, or -1 if there's no | |
| 3134 | * active item. | |
| 3135 | * | |
| 3136 | * Return value: An integer which is the index of the currently active item, or | |
| 3137 | * -1 if there's no active item. | |
| 3138 | * | |
| 3139 | * Since: 2.4 | |
| 3140 | */ | |
| 3141 | gint | |
| 3142 | gtk_combo_box_get_active (GtkComboBox *combo_box) | |
| 3143 | { | |
| 3144 | g_return_val_if_fail (GTK_IS_COMBO_BOX (combo_box), 0); | |
| 3145 | ||
| 3146 | return combo_box->priv->active_item; | |
| 3147 | } | |
| 3148 | ||
| 3149 | /** | |
| 3150 | * gtk_combo_box_set_active: | |
| 3151 | * @combo_box: A #GtkComboBox. | |
| 3152 | * @index_: An index in the model passed during construction, or -1 to have | |
| 3153 | * no active item. | |
| 3154 | * | |
| 3155 | * Sets the active item of @combo_box to be the item at @index. | |
| 3156 | * | |
| 3157 | * Since: 2.4 | |
| 3158 | */ | |
| 3159 | void | |
| 3160 | gtk_combo_box_set_active (GtkComboBox *combo_box, | |
| 3161 | gint index_) | |
| 3162 | { | |
| 3163 | g_return_if_fail (GTK_IS_COMBO_BOX (combo_box)); | |
| 3164 | /* -1 means "no item selected" */ | |
| 3165 | g_return_if_fail (index_ >= -1); | |
| 3166 | ||
| 3167 | if (combo_box->priv->active_item == index_) | |
| 3168 | return; | |
| 3169 | ||
| 3170 | gtk_combo_box_set_active_internal (combo_box, index_); | |
| 3171 | } | |
| 3172 | ||
| 3173 | static void | |
| 3174 | gtk_combo_box_set_active_internal (GtkComboBox *combo_box, | |
| 3175 | gint index) | |
| 3176 | { | |
| 3177 | GtkTreePath *path; | |
| 3178 | ||
| 3179 | combo_box->priv->active_item = index; | |
| 3180 | ||
| 3181 | if (index == -1) | |
| 3182 | { | |
| 3183 | if (combo_box->priv->tree_view) | |
| 3184 | gtk_tree_selection_unselect_all (gtk_tree_view_get_selection (GTK_TREE_VIEW (combo_box->priv->tree_view))); | |
| 3185 | else | |
| 3186 | { | |
| 3187 | GtkMenu *menu = GTK_MENU (combo_box->priv->popup_widget); | |
| 3188 | ||
| 3189 | if (GTK_IS_MENU (menu)) | |
| 3190 | gtk_menu_set_active (menu, -1); | |
| 3191 | } | |
| 3192 | ||
| 3193 | if (combo_box->priv->cell_view) | |
| 3194 | gtk_cell_view_set_displayed_row (GTK_CELL_VIEW (combo_box->priv->cell_view), NULL); | |
| 3195 | } | |
| 3196 | else | |
| 3197 | { | |
| 3198 | path = gtk_tree_path_new_from_indices (index, -1); | |
| 3199 | ||
| 3200 | if (combo_box->priv->tree_view) | |
| 3201 | gtk_tree_view_set_cursor (GTK_TREE_VIEW (combo_box->priv->tree_view), path, NULL, FALSE); | |
| 3202 | else | |
| 3203 | { | |
| 3204 | GtkMenu *menu = GTK_MENU (combo_box->priv->popup_widget); | |
| 3205 | ||
| 3206 | if (GTK_IS_MENU (menu)) | |
| 3207 | gtk_menu_set_active (GTK_MENU (menu), index); | |
| 3208 | } | |
| 3209 | ||
| 3210 | if (combo_box->priv->cell_view) | |
| 3211 | gtk_cell_view_set_displayed_row (GTK_CELL_VIEW (combo_box->priv->cell_view), path); | |
| 3212 | ||
| 3213 | gtk_tree_path_free (path); | |
| 3214 | } | |
| 3215 | ||
| 3216 | g_signal_emit_by_name (combo_box, "changed", NULL, NULL); | |
| 3217 | } | |
| 3218 | ||
| 3219 | ||
| 3220 | /** | |
| 3221 | * gtk_combo_box_get_active_iter: | |
| 3222 | * @combo_box: A #GtkComboBox | |
| 3223 | * @iter: The uninitialized #GtkTreeIter. | |
| 3224 | * | |
| 3225 | * Sets @iter to point to the current active item, if it exists. | |
| 3226 | * | |
| 3227 | * Return value: %TRUE, if @iter was set | |
| 3228 | * | |
| 3229 | * Since: 2.4 | |
| 3230 | **/ | |
| 3231 | gboolean | |
| 3232 | gtk_combo_box_get_active_iter (GtkComboBox *combo_box, | |
| 3233 | GtkTreeIter *iter) | |
| 3234 | { | |
| 3235 | GtkTreePath *path; | |
| 3236 | gint active; | |
| 3237 | gboolean retval; | |
| 3238 | ||
| 3239 | g_return_val_if_fail (GTK_IS_COMBO_BOX (combo_box), FALSE); | |
| 3240 | ||
| 3241 | active = gtk_combo_box_get_active (combo_box); | |
| 3242 | if (active < 0) | |
| 3243 | return FALSE; | |
| 3244 | ||
| 3245 | path = gtk_tree_path_new_from_indices (active, -1); | |
| 3246 | retval = gtk_tree_model_get_iter (gtk_combo_box_get_model (combo_box), | |
| 3247 | iter, path); | |
| 3248 | gtk_tree_path_free (path); | |
| 3249 | ||
| 3250 | return retval; | |
| 3251 | } | |
| 3252 | ||
| 3253 | /** | |
| 3254 | * gtk_combo_box_set_active_iter: | |
| 3255 | * @combo_box: A #GtkComboBox | |
| 3256 | * @iter: The #GtkTreeIter. | |
| 3257 | * | |
| 3258 | * Sets the current active item to be the one referenced by @iter. | |
| 3259 | * @iter must correspond to a path of depth one. | |
| 3260 | * | |
| 3261 | * Since: 2.4 | |
| 3262 | **/ | |
| 3263 | void | |
| 3264 | gtk_combo_box_set_active_iter (GtkComboBox *combo_box, | |
| 3265 | GtkTreeIter *iter) | |
| 3266 | { | |
| 3267 | GtkTreePath *path; | |
| 3268 | ||
| 3269 | g_return_if_fail (GTK_IS_COMBO_BOX (combo_box)); | |
| 3270 | ||
| 3271 | path = gtk_tree_model_get_path (gtk_combo_box_get_model (combo_box), iter); | |
| 3272 | g_return_if_fail (path != NULL); | |
| 3273 | g_return_if_fail (gtk_tree_path_get_depth (path) == 1); | |
| 3274 | ||
| 3275 | gtk_combo_box_set_active (combo_box, gtk_tree_path_get_indices (path)[0]); | |
| 3276 | gtk_tree_path_free (path); | |
| 3277 | } | |
| 3278 | ||
| 3279 | /** | |
| 3280 | * gtk_combo_box_set_model: | |
| 3281 | * @combo_box: A #GtkComboBox. | |
| 3282 | * @model: A #GtkTreeModel. | |
| 3283 | * | |
| 3284 | * Sets the model used by @combo_box to be @model. Will unset a previously set | |
| 3285 | * model (if applicable). If @model is %NULL, then it will unset the model. | |
| 3286 | * | |
| 3287 | * Note that this function does not clear the cell renderers, you have to | |
| 3288 | * call gtk_combo_box_cell_layout_clear() yourself if you need to set up | |
| 3289 | * different cell renderers for the new model. | |
| 3290 | * | |
| 3291 | * Since: 2.4 | |
| 3292 | */ | |
| 3293 | void | |
| 3294 | gtk_combo_box_set_model (GtkComboBox *combo_box, | |
| 3295 | GtkTreeModel *model) | |
| 3296 | { | |
| 3297 | g_return_if_fail (GTK_IS_COMBO_BOX (combo_box)); | |
| 3298 | ||
| 3299 | if (!model) | |
| 3300 | { | |
| 3301 | gtk_combo_box_unset_model (combo_box); | |
| 3302 | return; | |
| 3303 | } | |
| 3304 | ||
| 3305 | g_return_if_fail (GTK_IS_TREE_MODEL (model)); | |
| 3306 | ||
| 3307 | if (model == combo_box->priv->model) | |
| 3308 | return; | |
| 3309 | ||
| 3310 | if (combo_box->priv->model) | |
| 3311 | gtk_combo_box_unset_model (combo_box); | |
| 3312 | ||
| 3313 | combo_box->priv->model = model; | |
| 3314 | g_object_ref (G_OBJECT (combo_box->priv->model)); | |
| 3315 | ||
| 3316 | combo_box->priv->inserted_id = | |
| 3317 | g_signal_connect (combo_box->priv->model, "row_inserted", | |
| 3318 | G_CALLBACK (gtk_combo_box_model_row_inserted), | |
| 3319 | combo_box); | |
| 3320 | combo_box->priv->deleted_id = | |
| 3321 | g_signal_connect (combo_box->priv->model, "row_deleted", | |
| 3322 | G_CALLBACK (gtk_combo_box_model_row_deleted), | |
| 3323 | combo_box); | |
| 3324 | combo_box->priv->reordered_id = | |
| 3325 | g_signal_connect (combo_box->priv->model, "rows_reordered", | |
| 3326 | G_CALLBACK (gtk_combo_box_model_rows_reordered), | |
| 3327 | combo_box); | |
| 3328 | combo_box->priv->changed_id = | |
| 3329 | g_signal_connect (combo_box->priv->model, "row_changed", | |
| 3330 | G_CALLBACK (gtk_combo_box_model_row_changed), | |
| 3331 | combo_box); | |
| 3332 | ||
| 3333 | if (combo_box->priv->tree_view) | |
| 3334 | { | |
| 3335 | /* list mode */ | |
| 3336 | gtk_tree_view_set_model (GTK_TREE_VIEW (combo_box->priv->tree_view), | |
| 3337 | combo_box->priv->model); | |
| 3338 | } | |
| 3339 | else | |
| 3340 | { | |
| 3341 | /* menu mode */ | |
| 3342 | if (combo_box->priv->popup_widget) | |
| 3343 | gtk_combo_box_menu_fill (combo_box); | |
| 3344 | ||
| 3345 | } | |
| 3346 | ||
| 3347 | if (combo_box->priv->cell_view) | |
| 3348 | gtk_cell_view_set_model (GTK_CELL_VIEW (combo_box->priv->cell_view), | |
| 3349 | combo_box->priv->model); | |
| 3350 | } | |
| 3351 | ||
| 3352 | /** | |
| 3353 | * gtk_combo_box_get_model | |
| 3354 | * @combo_box: A #GtkComboBox. | |
| 3355 | * | |
| 3356 | * Returns the #GtkTreeModel which is acting as data source for @combo_box. | |
| 3357 | * | |
| 3358 | * Return value: A #GtkTreeModel which was passed during construction. | |
| 3359 | * | |
| 3360 | * Since: 2.4 | |
| 3361 | */ | |
| 3362 | GtkTreeModel * | |
| 3363 | gtk_combo_box_get_model (GtkComboBox *combo_box) | |
| 3364 | { | |
| 3365 | g_return_val_if_fail (GTK_IS_COMBO_BOX (combo_box), NULL); | |
| 3366 | ||
| 3367 | return combo_box->priv->model; | |
| 3368 | } | |
| 3369 | ||
| 3370 | ||
| 3371 | /* convenience API for simple text combos */ | |
| 3372 | ||
| 3373 | /** | |
| 3374 | * gtk_combo_box_new_text: | |
| 3375 | * | |
| 3376 | * Convenience function which constructs a new text combo box, which is a | |
| 3377 | * #GtkComboBox just displaying strings. If you use this function to create | |
| 3378 | * a text combo box, you should only manipulate its data source with the | |
| 3379 | * following convenience functions: gtk_combo_box_append_text(), | |
| 3380 | * gtk_combo_box_insert_text(), gtk_combo_box_prepend_text() and | |
| 3381 | * gtk_combo_box_remove_text(). | |
| 3382 | * | |
| 3383 | * Return value: A new text combo box. | |
| 3384 | * | |
| 3385 | * Since: 2.4 | |
| 3386 | */ | |
| 3387 | GtkWidget * | |
| 3388 | gtk_combo_box_new_text (void) | |
| 3389 | { | |
| 3390 | GtkWidget *combo_box; | |
| 3391 | GtkCellRenderer *cell; | |
| 3392 | GtkListStore *store; | |
| 3393 | ||
| 3394 | store = gtk_list_store_new (1, G_TYPE_STRING); | |
| 3395 | combo_box = gtk_combo_box_new_with_model (GTK_TREE_MODEL (store)); | |
| 3396 | g_object_unref (store); | |
| 3397 | ||
| 3398 | cell = gtk_cell_renderer_text_new (); | |
| 3399 | gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), cell, TRUE); | |
| 3400 | gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), cell, | |
| 3401 | "text", 0, | |
| 3402 | NULL); | |
| 3403 | ||
| 3404 | return combo_box; | |
| 3405 | } | |
| 3406 | ||
| 3407 | /** | |
| 3408 | * gtk_combo_box_append_text: | |
| 3409 | * @combo_box: A #GtkComboBox constructed using gtk_combo_box_new_text(). | |
| 3410 | * @text: A string. | |
| 3411 | * | |
| 3412 | * Appends @string to the list of strings stored in @combo_box. Note that | |
| 3413 | * you can only use this function with combo boxes constructed with | |
| 3414 | * gtk_combo_box_new_text(). | |
| 3415 | * | |
| 3416 | * Since: 2.4 | |
| 3417 | */ | |
| 3418 | void | |
| 3419 | gtk_combo_box_append_text (GtkComboBox *combo_box, | |
| 3420 | const gchar *text) | |
| 3421 | { | |
| 3422 | GtkTreeIter iter; | |
| 3423 | GtkListStore *store; | |
| 3424 | ||
| 3425 | g_return_if_fail (GTK_IS_COMBO_BOX (combo_box)); | |
| 3426 | g_return_if_fail (GTK_IS_LIST_STORE (combo_box->priv->model)); | |
| 3427 | g_return_if_fail (text != NULL); | |
| 3428 | ||
| 3429 | store = GTK_LIST_STORE (combo_box->priv->model); | |
| 3430 | ||
| 3431 | gtk_list_store_append (store, &iter); | |
| 3432 | gtk_list_store_set (store, &iter, 0, text, -1); | |
| 3433 | } | |
| 3434 | ||
| 3435 | /** | |
| 3436 | * gtk_combo_box_insert_text: | |
| 3437 | * @combo_box: A #GtkComboBox constructed using gtk_combo_box_new_text(). | |
| 3438 | * @position: An index to insert @text. | |
| 3439 | * @text: A string. | |
| 3440 | * | |
| 3441 | * Inserts @string at @position in the list of strings stored in @combo_box. | |
| 3442 | * Note that you can only use this function with combo boxes constructed | |
| 3443 | * with gtk_combo_box_new_text(). | |
| 3444 | * | |
| 3445 | * Since: 2.4 | |
| 3446 | */ | |
| 3447 | void | |
| 3448 | gtk_combo_box_insert_text (GtkComboBox *combo_box, | |
| 3449 | gint position, | |
| 3450 | const gchar *text) | |
| 3451 | { | |
| 3452 | GtkTreeIter iter; | |
| 3453 | GtkListStore *store; | |
| 3454 | ||
| 3455 | g_return_if_fail (GTK_IS_COMBO_BOX (combo_box)); | |
| 3456 | g_return_if_fail (GTK_IS_LIST_STORE (combo_box->priv->model)); | |
| 3457 | g_return_if_fail (position >= 0); | |
| 3458 | g_return_if_fail (text != NULL); | |
| 3459 | ||
| 3460 | store = GTK_LIST_STORE (combo_box->priv->model); | |
| 3461 | ||
| 3462 | gtk_list_store_insert (store, &iter, position); | |
| 3463 | gtk_list_store_set (store, &iter, 0, text, -1); | |
| 3464 | } | |
| 3465 | ||
| 3466 | /** | |
| 3467 | * gtk_combo_box_prepend_text: | |
| 3468 | * @combo_box: A #GtkComboBox constructed with gtk_combo_box_new_text(). | |
| 3469 | * @text: A string. | |
| 3470 | * | |
| 3471 | * Prepends @string to the list of strings stored in @combo_box. Note that | |
| 3472 | * you can only use this function with combo boxes constructed with | |
| 3473 | * gtk_combo_box_new_text(). | |
| 3474 | * | |
| 3475 | * Since: 2.4 | |
| 3476 | */ | |
| 3477 | void | |
| 3478 | gtk_combo_box_prepend_text (GtkComboBox *combo_box, | |
| 3479 | const gchar *text) | |
| 3480 | { | |
| 3481 | GtkTreeIter iter; | |
| 3482 | GtkListStore *store; | |
| 3483 | ||
| 3484 | g_return_if_fail (GTK_IS_COMBO_BOX (combo_box)); | |
| 3485 | g_return_if_fail (GTK_IS_LIST_STORE (combo_box->priv->model)); | |
| 3486 | g_return_if_fail (text != NULL); | |
| 3487 | ||
| 3488 | store = GTK_LIST_STORE (combo_box->priv->model); | |
| 3489 | ||
| 3490 | gtk_list_store_prepend (store, &iter); | |
| 3491 | gtk_list_store_set (store, &iter, 0, text, -1); | |
| 3492 | } | |
| 3493 | ||
| 3494 | /** | |
| 3495 | * gtk_combo_box_remove_text: | |
| 3496 | * @combo_box: A #GtkComboBox constructed with gtk_combo_box_new_text(). | |
| 3497 | * @position: Index of the item to remove. | |
| 3498 | * | |
| 3499 | * Removes the string at @position from @combo_box. Note that you can only use | |
| 3500 | * this function with combo boxes constructed with gtk_combo_box_new_text(). | |
| 3501 | * | |
| 3502 | * Since: 2.4 | |
| 3503 | */ | |
| 3504 | void | |
| 3505 | gtk_combo_box_remove_text (GtkComboBox *combo_box, | |
| 3506 | gint position) | |
| 3507 | { | |
| 3508 | GtkTreeIter iter; | |
| 3509 | GtkListStore *store; | |
| 3510 | ||
| 3511 | g_return_if_fail (GTK_IS_COMBO_BOX (combo_box)); | |
| 3512 | g_return_if_fail (GTK_IS_LIST_STORE (combo_box->priv->model)); | |
| 3513 | g_return_if_fail (position >= 0); | |
| 3514 | ||
| 3515 | store = GTK_LIST_STORE (combo_box->priv->model); | |
| 3516 | ||
| 3517 | if (gtk_tree_model_iter_nth_child (combo_box->priv->model, &iter, | |
| 3518 | NULL, position)) | |
| 3519 | gtk_list_store_remove (store, &iter); | |
| 3520 | } | |
| 3521 | ||
| 3522 | ||
| 3523 | static gboolean | |
| 3524 | gtk_combo_box_mnemonic_activate (GtkWidget *widget, | |
| 3525 | gboolean group_cycling) | |
| 3526 | { | |
| 3527 | GtkComboBox *combo_box = GTK_COMBO_BOX (widget); | |
| 3528 | ||
| 3529 | gtk_widget_grab_focus (combo_box->priv->button); | |
| 3530 | ||
| 3531 | return TRUE; | |
| 3532 | } | |
| 3533 | ||
| 3534 | static void | |
| 3535 | gtk_combo_box_destroy (GtkObject *object) | |
| 3536 | { | |
| 3537 | GtkComboBox *combo_box = GTK_COMBO_BOX (object); | |
| 3538 | ||
| 3539 | gtk_combo_box_popdown (combo_box); | |
| 3540 | ||
| 3541 | combo_box->priv->destroying = 1; | |
| 3542 | ||
| 3543 | GTK_OBJECT_CLASS (parent_class)->destroy (object); | |
| 3544 | combo_box->priv->cell_view = NULL; | |
| 3545 | ||
| 3546 | combo_box->priv->destroying = 0; | |
| 3547 | } | |
| 3548 | ||
| 3549 | static void | |
| 3550 | gtk_combo_box_finalize (GObject *object) | |
| 3551 | { | |
| 3552 | GtkComboBox *combo_box = GTK_COMBO_BOX (object); | |
| 3553 | GSList *i; | |
| 3554 | ||
| 3555 | if (GTK_IS_MENU (combo_box->priv->popup_widget)) | |
| 3556 | { | |
| 3557 | gtk_combo_box_menu_destroy (combo_box); | |
| 3558 | gtk_menu_detach (GTK_MENU (combo_box->priv->popup_widget)); | |
| 3559 | combo_box->priv->popup_widget = NULL; | |
| 3560 | } | |
| 3561 | ||
| 3562 | if (GTK_IS_TREE_VIEW (combo_box->priv->tree_view)) | |
| 3563 | gtk_combo_box_list_destroy (combo_box); | |
| 3564 | ||
| 3565 | if (combo_box->priv->popup_window) | |
| 3566 | gtk_widget_destroy (combo_box->priv->popup_window); | |
| 3567 | ||
| 3568 | gtk_combo_box_unset_model (combo_box); | |
| 3569 | ||
| 3570 | for (i = combo_box->priv->cells; i; i = i->next) | |
| 3571 | { | |
| 3572 | ComboCellInfo *info = (ComboCellInfo *)i->data; | |
| 3573 | GSList *list = info->attributes; | |
| 3574 | ||
| 3575 | if (info->destroy) | |
| 3576 | info->destroy (info->func_data); | |
| 3577 | ||
| 3578 | while (list && list->next) | |
| 3579 | { | |
| 3580 | g_free (list->data); | |
| 3581 | list = list->next->next; | |
| 3582 | } | |
| 3583 | g_slist_free (info->attributes); | |
| 3584 | ||
| 3585 | g_object_unref (G_OBJECT (info->cell)); | |
| 3586 | g_free (info); | |
| 3587 | } | |
| 3588 | g_slist_free (combo_box->priv->cells); | |
| 3589 | ||
| 3590 | g_free (combo_box->priv); | |
| 3591 | ||
| 3592 | G_OBJECT_CLASS (parent_class)->finalize (object); | |
| 3593 | } | |
| 3594 | ||
| 3595 | ||
| 3596 | /** | |
| 3597 | * Code below this point has been pulled in from gtkmenu.c in 2.4.14 | |
| 3598 | * and is needed to provide gtk_menu_attach() | |
| 3599 | */ | |
| 3600 | ||
| 3601 | typedef struct | |
| 3602 | { | |
| 3603 | gint left_attach; | |
| 3604 | gint right_attach; | |
| 3605 | gint top_attach; | |
| 3606 | gint bottom_attach; | |
| 3607 | gint effective_left_attach; | |
| 3608 | gint effective_right_attach; | |
| 3609 | gint effective_top_attach; | |
| 3610 | gint effective_bottom_attach; | |
| 3611 | } AttachInfo; | |
| 3612 | ||
| 3613 | #define ATTACH_INFO_KEY "gtk-menu-child-attach-info-key" | |
| 3614 | ||
| 3615 | static AttachInfo * | |
| 3616 | get_attach_info (GtkWidget *child) | |
| 3617 | { | |
| 3618 | GObject *object = G_OBJECT (child); | |
| 3619 | AttachInfo *ai = g_object_get_data (object, ATTACH_INFO_KEY); | |
| 3620 | ||
| 3621 | if (!ai) | |
| 3622 | { | |
| 3623 | ai = g_new0 (AttachInfo, 1); | |
| 3624 | g_object_set_data_full (object, ATTACH_INFO_KEY, ai, g_free); | |
| 3625 | } | |
| 3626 | ||
| 3627 | return ai; | |
| 3628 | } | |
| 3629 | ||
| 3630 | /** | |
| 3631 | * gtk_menu_attach: | |
| 3632 | * @menu: a #GtkMenu. | |
| 3633 | * @child: a #GtkMenuItem. | |
| 3634 | * @left_attach: The column number to attach the left side of the item to. | |
| 3635 | * @right_attach: The column number to attach the right side of the item to. | |
| 3636 | * @top_attach: The row number to attach the top of the item to. | |
| 3637 | * @bottom_attach: The row number to attach the bottom of the item to. | |
| 3638 | * | |
| 3639 | * Adds a new #GtkMenuItem to a (table) menu. The number of 'cells' that | |
| 3640 | * an item will occupy is specified by @left_attach, @right_attach, | |
| 3641 | * @top_attach and @bottom_attach. These each represent the leftmost, | |
| 3642 | * rightmost, uppermost and lower column and row numbers of the table. | |
| 3643 | * (Columns and rows are indexed from zero). | |
| 3644 | * | |
| 3645 | * Note that this function is not related to gtk_menu_detach(). | |
| 3646 | * | |
| 3647 | * Since: 2.4 | |
| 3648 | **/ | |
| 3649 | static void | |
| 3650 | gtk_menu_attach (GtkMenu *menu, | |
| 3651 | GtkWidget *child, | |
| 3652 | guint left_attach, | |
| 3653 | guint right_attach, | |
| 3654 | guint top_attach, | |
| 3655 | guint bottom_attach) | |
| 3656 | { | |
| 3657 | GtkMenuShell *menu_shell; | |
| 3658 | ||
| 3659 | g_return_if_fail (GTK_IS_MENU (menu)); | |
| 3660 | g_return_if_fail (GTK_IS_MENU_ITEM (child)); | |
| 3661 | g_return_if_fail (child->parent == NULL || | |
| 3662 | child->parent == GTK_WIDGET (menu)); | |
| 3663 | g_return_if_fail (left_attach < right_attach); | |
| 3664 | g_return_if_fail (top_attach < bottom_attach); | |
| 3665 | ||
| 3666 | menu_shell = GTK_MENU_SHELL (menu); | |
| 3667 | ||
| 3668 | if (!child->parent) | |
| 3669 | { | |
| 3670 | AttachInfo *ai = get_attach_info (child); | |
| 3671 | ||
| 3672 | ai->left_attach = left_attach; | |
| 3673 | ai->right_attach = right_attach; | |
| 3674 | ai->top_attach = top_attach; | |
| 3675 | ai->bottom_attach = bottom_attach; | |
| 3676 | ||
| 3677 | menu_shell->children = g_list_append (menu_shell->children, child); | |
| 3678 | ||
| 3679 | gtk_widget_set_parent (child, GTK_WIDGET (menu)); | |
| 3680 | ||
| 3681 | /* | |
| 3682 | menu_queue_resize (menu); | |
| 3683 | */ | |
| 3684 | } | |
| 3685 | else | |
| 3686 | { | |
| 3687 | gtk_container_child_set (GTK_CONTAINER (child->parent), child, | |
| 3688 | "left_attach", left_attach, | |
| 3689 | "right_attach", right_attach, | |
| 3690 | "top_attach", top_attach, | |
| 3691 | "bottom_attach", bottom_attach, | |
| 3692 | NULL); | |
| 3693 | } | |
| 3694 | } | |
| 3695 | #endif /* Gtk 2.4 */ |
