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

   1 /* gtkcombo - combo widget for gtk+
   2  * Copyright 1997 Paolo Molaro
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser 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  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser 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  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 /* Do NOT, I repeat, NOT, copy any of the code in this file.
  28  * The code here relies on all sorts of internal details of GTK+
  29  */
  30
  31 #undef GTK_DISABLE_DEPRECATED
  32
  33 #include <config.h>
  34 #include <string.h>
  35
  36 #include "gtkarrow.h"
  37 #include "gtklabel.h"
  38 #include "gtklist.h"
  39 #include "gtkentry.h"
  40 #include "gtkeventbox.h"
  41 #include "gtkbutton.h"
  42 #include "gtklistitem.h"
  43 #include "gtkscrolledwindow.h"
  44 #include "gtkmain.h"
  45 #include "gtkwindow.h"
  46 #include "gdk/gdkkeysyms.h"
  47 #include "gtkcombo.h"
  48 #include "gtkframe.h"
  49 #include "gtkprivate.h"
  50 #include "gtkintl.h"
  51 #include "gtkalias.h"
  52
  53 static const gchar gtk_combo_string_key[] = "gtk-combo-string-value";
  54
  55 #define COMBO_LIST_MAX_HEIGHT   (400)
  56 #define EMPTY_LIST_HEIGHT       (15)
  57
  58 enum {
  59   PROP_0,
  60   PROP_ENABLE_ARROW_KEYS,
  61   PROP_ENABLE_ARROWS_ALWAYS,
  62   PROP_CASE_SENSITIVE,
  63   PROP_ALLOW_EMPTY,
  64   PROP_VALUE_IN_LIST
  65 };
  66
  67 static void         gtk_combo_realize            (GtkWidget        *widget);
  68 static void         gtk_combo_unrealize          (GtkWidget        *widget);
  69 static void         gtk_combo_destroy            (GtkObject        *combo);
  70 static GtkListItem *gtk_combo_find               (GtkCombo         *combo);
  71 static gchar *      gtk_combo_func               (GtkListItem      *li);
  72 static gboolean     gtk_combo_focus_idle         (GtkCombo         *combo);
  73 static gint         gtk_combo_entry_focus_out    (GtkEntry         *entry,
  74                                                   GdkEventFocus    *event,
  75                                                   GtkCombo         *combo);
  76 static void         gtk_combo_get_pos            (GtkCombo         *combo,
  77                                                   gint             *x,
  78                                                   gint             *y,
  79                                                   gint             *height,
  80                                                   gint             *width);
  81 static void         gtk_combo_popup_list         (GtkCombo         *combo);
  82 static void         gtk_combo_popdown_list       (GtkCombo         *combo);
  83
  84 static void         gtk_combo_activate           (GtkWidget        *widget,
  85                                                   GtkCombo         *combo);
  86 static gboolean     gtk_combo_popup_button_press (GtkWidget        *button,
  87                                                   GdkEventButton   *event,
  88                                                   GtkCombo         *combo);
  89 static gboolean     gtk_combo_popup_button_leave (GtkWidget        *button,
  90                                                   GdkEventCrossing *event,
  91                                                   GtkCombo         *combo);
  92 static void         gtk_combo_update_entry       (GtkCombo         *combo);
  93 static void         gtk_combo_update_list        (GtkEntry         *entry,
  94                                                   GtkCombo         *combo);
  95 static gint         gtk_combo_button_press       (GtkWidget        *widget,
  96                                                   GdkEvent         *event,
  97                                                   GtkCombo         *combo);
  98 static void         gtk_combo_button_event_after (GtkWidget        *widget,
  99                                                   GdkEvent         *event,
 100                                                   GtkCombo         *combo);
 101 static gint         gtk_combo_list_enter         (GtkWidget        *widget,
 102                                                   GdkEventCrossing *event,
 103                                                   GtkCombo         *combo);
 104 static gint         gtk_combo_list_key_press     (GtkWidget        *widget,
 105                                                   GdkEventKey      *event,
 106                                                   GtkCombo         *combo);
 107 static gint         gtk_combo_entry_key_press    (GtkEntry         *widget,
 108                                                   GdkEventKey      *event,
 109                                                   GtkCombo         *combo);
 110 static gint         gtk_combo_window_key_press   (GtkWidget        *window,
 111                                                   GdkEventKey      *event,
 112                                                   GtkCombo         *combo);
 113 static void         gtk_combo_size_allocate      (GtkWidget        *widget,
 114                                                   GtkAllocation   *allocation);
 115 static void         gtk_combo_set_property       (GObject         *object,
 116                                                   guint            prop_id,
 117                                                   const GValue    *value,
 118                                                   GParamSpec      *pspec);
 119 static void         gtk_combo_get_property       (GObject         *object,
 120                                                   guint            prop_id,
 121                                                   GValue          *value,
 122                                                   GParamSpec      *pspec);
 123
 124 G_DEFINE_TYPE (GtkCombo, gtk_combo, GTK_TYPE_HBOX)
 125
 126 static void
 127 gtk_combo_class_init (GtkComboClass * klass)
 128 {
 129   GObjectClass *gobject_class;
 130   GtkObjectClass *oclass;
 131   GtkWidgetClass *widget_class;
 132
 133   gobject_class = (GObjectClass *) klass;
 134   oclass = (GtkObjectClass *) klass;
 135   widget_class = (GtkWidgetClass *) klass;
 136
 137   gobject_class->set_property = gtk_combo_set_property;
 138   gobject_class->get_property = gtk_combo_get_property;
 139
 140   g_object_class_install_property (gobject_class,
 141                                    PROP_ENABLE_ARROW_KEYS,
 142                                    g_param_spec_boolean ("enable-arrow-keys",
 143                                                          P_("Enable arrow keys"),
 144                                                          P_("Whether the arrow keys move through the list of items"),
 145                                                          TRUE,
 146                                                          GTK_PARAM_READWRITE));
 147   g_object_class_install_property (gobject_class,
 148                                    PROP_ENABLE_ARROWS_ALWAYS,
 149                                    g_param_spec_boolean ("enable-arrows-always",
 150                                                          P_("Always enable arrows"),
 151                                                          P_("Obsolete property, ignored"),
 152                                                          TRUE,
 153                                                          GTK_PARAM_READWRITE));
 154   g_object_class_install_property (gobject_class,
 155                                    PROP_CASE_SENSITIVE,
 156                                    g_param_spec_boolean ("case-sensitive",
 157                                                          P_("Case sensitive"),
 158                                                          P_("Whether list item matching is case sensitive"),
 159                                                          FALSE,
 160                                                          GTK_PARAM_READWRITE));
 161
 162   g_object_class_install_property (gobject_class,
 163                                    PROP_ALLOW_EMPTY,
 164                                    g_param_spec_boolean ("allow-empty",
 165                                                          P_("Allow empty"),
 166                                                          P_("Whether an empty value may be entered in this field"),
 167                                                          TRUE,
 168                                                          GTK_PARAM_READWRITE));
 169
 170   g_object_class_install_property (gobject_class,
 171                                    PROP_VALUE_IN_LIST,
 172                                    g_param_spec_boolean ("value-in-list",
 173                                                          P_("Value in list"),
 174                                                          P_("Whether entered values must already be present in the list"),
 175                                                          FALSE,
 176                                                          GTK_PARAM_READWRITE));
 177
 178
 179   oclass->destroy = gtk_combo_destroy;
 180
 181   widget_class->size_allocate = gtk_combo_size_allocate;
 182   widget_class->realize = gtk_combo_realize;
 183   widget_class->unrealize = gtk_combo_unrealize;
 184 }
 185
 186 static void
 187 gtk_combo_destroy (GtkObject *object)
 188 {
 189   GtkCombo *combo = GTK_COMBO (object);
 190
 191   if (combo->popwin)
 192     {
 193       gtk_widget_destroy (combo->popwin);
 194       g_object_unref (combo->popwin);
 195       combo->popwin = NULL;
 196     }
 197
 198   GTK_OBJECT_CLASS (gtk_combo_parent_class)->destroy (object);
 199 }
 200
 201 static int
 202 gtk_combo_entry_key_press (GtkEntry * entry, GdkEventKey * event, GtkCombo * combo)
 203 {
 204   GList *li;
 205   guint state = event->state & gtk_accelerator_get_default_mod_mask ();
 206
 207   /* completion */
 208   if ((event->keyval == GDK_Tab ||  event->keyval == GDK_KP_Tab) &&
 209       state == GDK_MOD1_MASK)
 210     {
 211       GtkEditable *editable = GTK_EDITABLE (entry);
 212       GCompletion * cmpl;
 213       gchar* prefix;
 214       gchar* nprefix = NULL;
 215       gint pos;
 216
 217       if ( !GTK_LIST (combo->list)->children )
 218         return FALSE;
 219
 220       cmpl = g_completion_new ((GCompletionFunc)gtk_combo_func);
 221       g_completion_add_items (cmpl, GTK_LIST (combo->list)->children);
 222
 223       pos = gtk_editable_get_position (editable);
 224       prefix = gtk_editable_get_chars (editable, 0, pos);
 225
 226       g_completion_complete_utf8 (cmpl, prefix, &nprefix);
 227
 228       if (nprefix && strlen (nprefix) > strlen (prefix))
 229         {
 230           gtk_editable_insert_text (editable, g_utf8_offset_to_pointer (nprefix, pos),
 231                                     strlen (nprefix) - strlen (prefix), &pos);
 232           gtk_editable_set_position (editable, pos);
 233         }
 234
 235       g_free (nprefix);
 236       g_free (prefix);
 237       g_completion_free (cmpl);
 238
 239       return TRUE;
 240     }
 241
 242   if ((event->keyval == GDK_Down || event->keyval == GDK_KP_Down) &&
 243       state == GDK_MOD1_MASK)
 244     {
 245       gtk_combo_activate (NULL, combo);
 246       return TRUE;
 247     }
 248
 249   if (!combo->use_arrows || !GTK_LIST (combo->list)->children)
 250     return FALSE;
 251
 252   gtk_combo_update_list (GTK_ENTRY (combo->entry), combo);
 253   li = g_list_find (GTK_LIST (combo->list)->children, gtk_combo_find (combo));
 254
 255   if (((event->keyval == GDK_Up || event->keyval == GDK_KP_Up) && state == 0) ||
 256       ((event->keyval == 'p' || event->keyval == 'P') && state == GDK_MOD1_MASK))
 257     {
 258       if (!li)
 259         li = g_list_last (GTK_LIST (combo->list)->children);
 260       else
 261         li = li->prev;
 262
 263       if (li)
 264         {
 265           gtk_list_select_child (GTK_LIST (combo->list), GTK_WIDGET (li->data));
 266           gtk_combo_update_entry (combo);
 267         }
 268
 269       return TRUE;
 270     }
 271   if (((event->keyval == GDK_Down || event->keyval == GDK_KP_Down) && state == 0) ||
 272       ((event->keyval == 'n' || event->keyval == 'N') && state == GDK_MOD1_MASK))
 273     {
 274       if (!li)
 275         li = GTK_LIST (combo->list)->children;
 276       else if (li)
 277         li = li->next;
 278       if (li)
 279         {
 280           gtk_list_select_child (GTK_LIST (combo->list), GTK_WIDGET (li->data));
 281           gtk_combo_update_entry (combo);
 282         }
 283
 284       return TRUE;
 285     }
 286   return FALSE;
 287 }
 288
 289 static int
 290 gtk_combo_window_key_press (GtkWidget   *window,
 291                             GdkEventKey *event,
 292                             GtkCombo    *combo)
 293 {
 294   guint state = event->state & gtk_accelerator_get_default_mod_mask ();
 295
 296   if ((event->keyval == GDK_Return || event->keyval == GDK_KP_Enter) &&
 297       state == 0)
 298     {
 299       gtk_combo_popdown_list (combo);
 300       gtk_combo_update_entry (combo);
 301
 302       return TRUE;
 303     }
 304   else if ((event->keyval == GDK_Up || event->keyval == GDK_KP_Up) &&
 305            state == GDK_MOD1_MASK)
 306     {
 307       gtk_combo_popdown_list (combo);
 308
 309       return TRUE;
 310     }
 311   else if ((event->keyval == GDK_space || event->keyval == GDK_KP_Space) &&
 312            state == 0)
 313     {
 314       gtk_combo_update_entry (combo);
 315     }
 316
 317   return FALSE;
 318 }
 319
 320 static GtkListItem *
 321 gtk_combo_find (GtkCombo * combo)
 322 {
 323   const gchar *text;
 324   GtkListItem *found = NULL;
 325   gchar *ltext;
 326   gchar *compare_text;
 327   GList *clist;
 328
 329   text = gtk_entry_get_text (GTK_ENTRY (combo->entry));
 330   if (combo->case_sensitive)
 331     compare_text = (gchar *)text;
 332   else
 333     compare_text = g_utf8_casefold (text, -1);
 334
 335   for (clist = GTK_LIST (combo->list)->children;
 336        !found && clist;
 337        clist = clist->next)
 338     {
 339       ltext = gtk_combo_func (GTK_LIST_ITEM (clist->data));
 340       if (!ltext)
 341         continue;
 342
 343       if (!combo->case_sensitive)
 344         ltext = g_utf8_casefold (ltext, -1);
 345
 346       if (strcmp (ltext, compare_text) == 0)
 347         found = clist->data;
 348
 349       if (!combo->case_sensitive)
 350         g_free (ltext);
 351     }
 352
 353   if (!combo->case_sensitive)
 354     g_free (compare_text);
 355
 356   return found;
 357 }
 358
 359 static gchar *
 360 gtk_combo_func (GtkListItem * li)
 361 {
 362   GtkWidget *label;
 363   gchar *ltext = NULL;
 364
 365   ltext = g_object_get_data (G_OBJECT (li), I_(gtk_combo_string_key));
 366   if (!ltext)
 367     {
 368       label = GTK_BIN (li)->child;
 369       if (!label || !GTK_IS_LABEL (label))
 370         return NULL;
 371       ltext = (gchar *) gtk_label_get_text (GTK_LABEL (label));
 372     }
 373   return ltext;
 374 }
 375
 376 static gint
 377 gtk_combo_focus_idle (GtkCombo * combo)
 378 {
 379   if (combo)
 380     {
 381       GDK_THREADS_ENTER ();
 382       gtk_widget_grab_focus (combo->entry);
 383       GDK_THREADS_LEAVE ();
 384     }
 385   return FALSE;
 386 }
 387
 388 static gint
 389 gtk_combo_entry_focus_out (GtkEntry * entry, GdkEventFocus * event, GtkCombo * combo)
 390 {
 391
 392   if (combo->value_in_list && !gtk_combo_find (combo))
 393     {
 394       GSource *focus_idle;
 395
 396       /* gdk_beep(); *//* this can be annoying */
 397       if (combo->ok_if_empty && !strcmp (gtk_entry_get_text (entry), ""))
 398         return FALSE;
 399 #ifdef TEST
 400       printf ("INVALID ENTRY: `%s'\n", gtk_entry_get_text (entry));
 401 #endif
 402       gtk_grab_add (GTK_WIDGET (combo));
 403       /* this is needed because if we call gtk_widget_grab_focus()
 404          it isn't guaranteed it's the *last* call before the main-loop,
 405          so the focus can be lost anyway...
 406          the signal_stop_emission doesn't seem to work either...
 407        */
 408       focus_idle = g_idle_source_new ();
 409       g_source_set_closure (focus_idle,
 410                             g_cclosure_new_object (G_CALLBACK (gtk_combo_focus_idle),
 411                                                    G_OBJECT (combo)));
 412       g_source_attach (focus_idle, NULL);
 413         g_source_unref (focus_idle);
 414
 415       /*g_signal_stop_emission_by_name (entry, "focus_out_event"); */
 416       return TRUE;
 417     }
 418   return FALSE;
 419 }
 420
 421 static void
 422 gtk_combo_get_pos (GtkCombo * combo, gint * x, gint * y, gint * height, gint * width)
 423 {
 424   GtkBin *popwin;
 425   GtkWidget *widget;
 426   GtkScrolledWindow *popup;
 427
 428   gint real_height;
 429   GtkRequisition list_requisition;
 430   gboolean show_hscroll = FALSE;
 431   gboolean show_vscroll = FALSE;
 432   gint avail_height;
 433   gint min_height;
 434   gint alloc_width;
 435   gint work_height;
 436   gint old_height;
 437   gint old_width;
 438   gint scrollbar_spacing;
 439
 440   widget = GTK_WIDGET (combo);
 441   popup  = GTK_SCROLLED_WINDOW (combo->popup);
 442   popwin = GTK_BIN (combo->popwin);
 443
 444   scrollbar_spacing = _gtk_scrolled_window_get_scrollbar_spacing (popup);
 445
 446   gdk_window_get_origin (combo->entry->window, x, y);
 447   if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
 448     *x -= widget->allocation.width - combo->entry->allocation.width;
 449   real_height = MIN (combo->entry->requisition.height,
 450                      combo->entry->allocation.height);
 451   *y += real_height;
 452   avail_height = gdk_screen_get_height (gtk_widget_get_screen (widget)) - *y;
 453
 454   gtk_widget_size_request (combo->list, &list_requisition);
 455   min_height = MIN (list_requisition.height,
 456                     popup->vscrollbar->requisition.height);
 457   if (!GTK_LIST (combo->list)->children)
 458     list_requisition.height += EMPTY_LIST_HEIGHT;
 459
 460   alloc_width = (widget->allocation.width -
 461                  2 * popwin->child->style->xthickness -
 462                  2 * GTK_CONTAINER (popwin->child)->border_width -
 463                  2 * GTK_CONTAINER (combo->popup)->border_width -
 464                  2 * GTK_CONTAINER (GTK_BIN (popup)->child)->border_width -
 465                  2 * GTK_BIN (popup)->child->style->xthickness);
 466
 467   work_height = (2 * popwin->child->style->ythickness +
 468                  2 * GTK_CONTAINER (popwin->child)->border_width +
 469                  2 * GTK_CONTAINER (combo->popup)->border_width +
 470                  2 * GTK_CONTAINER (GTK_BIN (popup)->child)->border_width +
 471                  2 * GTK_BIN (popup)->child->style->ythickness);
 472
 473   do
 474     {
 475       old_width = alloc_width;
 476       old_height = work_height;
 477
 478       if (!show_hscroll &&
 479           alloc_width < list_requisition.width)
 480         {
 481           GtkRequisition requisition;
 482
 483           gtk_widget_size_request (popup->hscrollbar, &requisition);
 484           work_height += (requisition.height + scrollbar_spacing);
 485
 486           show_hscroll = TRUE;
 487         }
 488       if (!show_vscroll &&
 489           work_height + list_requisition.height > avail_height)
 490         {
 491           GtkRequisition requisition;
 492
 493           if (work_height + min_height > avail_height &&
 494               *y - real_height > avail_height)
 495             {
 496               *y -= (work_height + list_requisition.height + real_height);
 497               break;
 498             }
 499           gtk_widget_size_request (popup->hscrollbar, &requisition);
 500           alloc_width -= (requisition.width + scrollbar_spacing);
 501           show_vscroll = TRUE;
 502         }
 503     } while (old_width != alloc_width || old_height != work_height);
 504
 505   *width = widget->allocation.width;
 506   if (show_vscroll)
 507     *height = avail_height;
 508   else
 509     *height = work_height + list_requisition.height;
 510
 511   if (*x < 0)
 512     *x = 0;
 513 }
 514
 515 static void
 516 gtk_combo_popup_list (GtkCombo *combo)
 517 {
 518   GtkWidget *toplevel;
 519   GtkList *list;
 520   gint height, width, x, y;
 521   gint old_width, old_height;
 522
 523   old_width = combo->popwin->allocation.width;
 524   old_height  = combo->popwin->allocation.height;
 525
 526   gtk_combo_get_pos (combo, &x, &y, &height, &width);
 527
 528   /* workaround for gtk_scrolled_window_size_allocate bug */
 529   if (old_width != width || old_height != height)
 530     {
 531       gtk_widget_hide (GTK_SCROLLED_WINDOW (combo->popup)->hscrollbar);
 532       gtk_widget_hide (GTK_SCROLLED_WINDOW (combo->popup)->vscrollbar);
 533     }
 534
 535   gtk_combo_update_list (GTK_ENTRY (combo->entry), combo);
 536
 537   /* We need to make sure some child of combo->popwin
 538    * is focused to disable GtkWindow's automatic
 539    * "focus-the-first-item" code. If there is no selected
 540    * child, we focus the list itself with some hackery.
 541    */
 542   list = GTK_LIST (combo->list);
 543
 544   if (list->selection)
 545     {
 546       gtk_widget_grab_focus (list->selection->data);
 547     }
 548   else
 549     {
 550       GTK_WIDGET_SET_FLAGS (list, GTK_CAN_FOCUS);
 551       gtk_widget_grab_focus (combo->list);
 552       GTK_LIST (combo->list)->last_focus_child = NULL;
 553       GTK_WIDGET_UNSET_FLAGS (list, GTK_CAN_FOCUS);
 554     }
 555
 556   gtk_window_move (GTK_WINDOW (combo->popwin), x, y);
 557
 558   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (combo));
 559
 560   if (GTK_IS_WINDOW (toplevel))
 561     {
 562       gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
 563                                    GTK_WINDOW (combo->popwin));
 564       gtk_window_set_transient_for (GTK_WINDOW (combo->popwin), GTK_WINDOW (toplevel));
 565     }
 566
 567   gtk_widget_set_size_request (combo->popwin, width, height);
 568   gtk_widget_show (combo->popwin);
 569
 570   gtk_widget_grab_focus (combo->popwin);
 571 }
 572
 573 static void
 574 gtk_combo_popdown_list (GtkCombo *combo)
 575 {
 576   combo->current_button = 0;
 577
 578   if (GTK_BUTTON (combo->button)->in_button)
 579     {
 580       GTK_BUTTON (combo->button)->in_button = FALSE;
 581       gtk_button_released (GTK_BUTTON (combo->button));
 582     }
 583
 584   if (GTK_WIDGET_HAS_GRAB (combo->popwin))
 585     {
 586       gtk_grab_remove (combo->popwin);
 587       gdk_display_pointer_ungrab (gtk_widget_get_display (GTK_WIDGET (combo)),
 588                                   gtk_get_current_event_time ());
 589       gdk_display_keyboard_ungrab (gtk_widget_get_display (GTK_WIDGET (combo)),
 590                                    gtk_get_current_event_time ());
 591     }
 592
 593   gtk_widget_hide (combo->popwin);
 594
 595   gtk_window_group_add_window (gtk_window_get_group (NULL), GTK_WINDOW (combo->popwin));
 596 }
 597
 598 static gboolean
 599 popup_grab_on_window (GdkWindow *window,
 600                       guint32    activate_time)
 601 {
 602   if ((gdk_pointer_grab (window, TRUE,
 603                          GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
 604                          GDK_POINTER_MOTION_MASK,
 605                          NULL, NULL, activate_time) == 0))
 606     {
 607       if (gdk_keyboard_grab (window, TRUE,
 608                              activate_time) == 0)
 609         return TRUE;
 610       else
 611         {
 612           gdk_display_pointer_ungrab (gdk_drawable_get_display (window),
 613                                       activate_time);
 614           return FALSE;
 615         }
 616     }
 617
 618   return FALSE;
 619 }
 620
 621 static void
 622 gtk_combo_activate (GtkWidget        *widget,
 623                     GtkCombo         *combo)
 624 {
 625   if (!combo->button->window ||
 626       !popup_grab_on_window (combo->button->window,
 627                              gtk_get_current_event_time ()))
 628     return;
 629
 630   gtk_combo_popup_list (combo);
 631
 632   /* This must succeed since we already have the grab */
 633   popup_grab_on_window (combo->popwin->window,
 634                         gtk_get_current_event_time ());
 635
 636   if (!GTK_WIDGET_HAS_FOCUS (combo->entry))
 637     gtk_widget_grab_focus (combo->entry);
 638
 639   gtk_grab_add (combo->popwin);
 640 }
 641
 642 static gboolean
 643 gtk_combo_popup_button_press (GtkWidget        *button,
 644                               GdkEventButton   *event,
 645                               GtkCombo         *combo)
 646 {
 647   if (!GTK_WIDGET_HAS_FOCUS (combo->entry))
 648     gtk_widget_grab_focus (combo->entry);
 649
 650   if (event->button != 1)
 651     return FALSE;
 652
 653   if (!popup_grab_on_window (combo->button->window,
 654                              gtk_get_current_event_time ()))
 655     return FALSE;
 656
 657   combo->current_button = event->button;
 658
 659   gtk_combo_popup_list (combo);
 660
 661   /* This must succeed since we already have the grab */
 662   popup_grab_on_window (combo->popwin->window,
 663                         gtk_get_current_event_time ());
 664
 665   gtk_button_pressed (GTK_BUTTON (button));
 666
 667   gtk_grab_add (combo->popwin);
 668
 669   return TRUE;
 670 }
 671
 672 static gboolean
 673 gtk_combo_popup_button_leave (GtkWidget        *button,
 674                               GdkEventCrossing *event,
 675                               GtkCombo         *combo)
 676 {
 677   /* The idea here is that we want to keep the button down if the
 678    * popup is popped up.
 679    */
 680   return combo->current_button != 0;
 681 }
 682
 683 static void
 684 gtk_combo_update_entry (GtkCombo * combo)
 685 {
 686   GtkList *list = GTK_LIST (combo->list);
 687   char *text;
 688
 689   g_signal_handler_block (list, combo->list_change_id);
 690   if (list->selection)
 691     {
 692       text = gtk_combo_func (GTK_LIST_ITEM (list->selection->data));
 693       if (!text)
 694         text = "";
 695       gtk_entry_set_text (GTK_ENTRY (combo->entry), text);
 696     }
 697   g_signal_handler_unblock (list, combo->list_change_id);
 698 }
 699
 700 static void
 701 gtk_combo_selection_changed (GtkList  *list,
 702                              GtkCombo *combo)
 703 {
 704   if (!GTK_WIDGET_VISIBLE (combo->popwin))
 705     gtk_combo_update_entry (combo);
 706 }
 707
 708 static void
 709 gtk_combo_update_list (GtkEntry * entry, GtkCombo * combo)
 710 {
 711   GtkList *list = GTK_LIST (combo->list);
 712   GList *slist = list->selection;
 713   GtkListItem *li;
 714
 715   gtk_grab_remove (GTK_WIDGET (combo));
 716
 717   g_signal_handler_block (entry, combo->entry_change_id);
 718   if (slist && slist->data)
 719     gtk_list_unselect_child (list, GTK_WIDGET (slist->data));
 720   li = gtk_combo_find (combo);
 721   if (li)
 722     gtk_list_select_child (list, GTK_WIDGET (li));
 723   g_signal_handler_unblock (entry, combo->entry_change_id);
 724 }
 725
 726 static gint
 727 gtk_combo_button_press (GtkWidget * widget, GdkEvent * event, GtkCombo * combo)
 728 {
 729   GtkWidget *child;
 730
 731   child = gtk_get_event_widget (event);
 732
 733   /* We don't ask for button press events on the grab widget, so
 734    *  if an event is reported directly to the grab widget, it must
 735    *  be on a window outside the application (and thus we remove
 736    *  the popup window). Otherwise, we check if the widget is a child
 737    *  of the grab widget, and only remove the popup window if it
 738    *  is not.
 739    */
 740   if (child != widget)
 741     {
 742       while (child)
 743         {
 744           if (child == widget)
 745             return FALSE;
 746           child = child->parent;
 747         }
 748     }
 749
 750   gtk_combo_popdown_list (combo);
 751
 752   return TRUE;
 753 }
 754
 755 static gboolean
 756 is_within (GtkWidget *widget,
 757            GtkWidget *ancestor)
 758 {
 759   return widget == ancestor || gtk_widget_is_ancestor (widget, ancestor);
 760 }
 761
 762 static void
 763 gtk_combo_button_event_after (GtkWidget *widget,
 764                               GdkEvent  *event,
 765                               GtkCombo  *combo)
 766 {
 767   GtkWidget *child;
 768
 769   if (event->type != GDK_BUTTON_RELEASE)
 770     return;
 771
 772   child = gtk_get_event_widget ((GdkEvent*) event);
 773
 774   if ((combo->current_button != 0) && (event->button.button == 1))
 775     {
 776       /* This was the initial button press */
 777
 778       combo->current_button = 0;
 779
 780       /* Check to see if we released inside the button */
 781       if (child && is_within (child, combo->button))
 782         {
 783           gtk_grab_add (combo->popwin);
 784           gdk_pointer_grab (combo->popwin->window, TRUE,
 785                             GDK_BUTTON_PRESS_MASK |
 786                             GDK_BUTTON_RELEASE_MASK |
 787                             GDK_POINTER_MOTION_MASK,
 788                             NULL, NULL, GDK_CURRENT_TIME);
 789           return;
 790         }
 791     }
 792
 793   if (is_within (child, combo->list))
 794     gtk_combo_update_entry (combo);
 795
 796   gtk_combo_popdown_list (combo);
 797
 798 }
 799
 800 static void
 801 find_child_foreach (GtkWidget *widget,
 802                     gpointer   data)
 803 {
 804   GdkEventButton *event = data;
 805
 806   if (!event->window)
 807     {
 808       if (event->x >= widget->allocation.x &&
 809           event->x < widget->allocation.x + widget->allocation.width &&
 810           event->y >= widget->allocation.y &&
 811           event->y < widget->allocation.y + widget->allocation.height)
 812         event->window = g_object_ref (widget->window);
 813     }
 814 }
 815
 816 static void
 817 find_child_window (GtkContainer   *container,
 818                    GdkEventButton *event)
 819 {
 820   gtk_container_foreach (container, find_child_foreach, event);
 821 }
 822
 823 static gint
 824 gtk_combo_list_enter (GtkWidget        *widget,
 825                       GdkEventCrossing *event,
 826                       GtkCombo         *combo)
 827 {
 828   GtkWidget *event_widget;
 829
 830   event_widget = gtk_get_event_widget ((GdkEvent*) event);
 831
 832   if ((event_widget == combo->list) &&
 833       (combo->current_button != 0) &&
 834       (!GTK_WIDGET_HAS_GRAB (combo->list)))
 835     {
 836       GdkEvent *tmp_event = gdk_event_new (GDK_BUTTON_PRESS);
 837       gint x, y;
 838       GdkModifierType mask;
 839
 840       gtk_grab_remove (combo->popwin);
 841
 842       /* Transfer the grab over to the list by synthesizing
 843        * a button press event
 844        */
 845       gdk_window_get_pointer (combo->list->window, &x, &y, &mask);
 846
 847       tmp_event->button.send_event = TRUE;
 848       tmp_event->button.time = GDK_CURRENT_TIME; /* bad */
 849       tmp_event->button.x = x;
 850       tmp_event->button.y = y;
 851       /* We leave all the XInput fields unfilled here, in the expectation
 852        * that GtkList doesn't care.
 853        */
 854       tmp_event->button.button = combo->current_button;
 855       tmp_event->button.state = mask;
 856
 857       find_child_window (GTK_CONTAINER (combo->list), &tmp_event->button);
 858       if (!tmp_event->button.window)
 859         {
 860           GtkWidget *child;
 861
 862           if (GTK_LIST (combo->list)->children)
 863             child = GTK_LIST (combo->list)->children->data;
 864           else
 865             child = combo->list;
 866
 867           tmp_event->button.window = g_object_ref (child->window);
 868         }
 869
 870       gtk_widget_event (combo->list, tmp_event);
 871       gdk_event_free (tmp_event);
 872     }
 873
 874   return FALSE;
 875 }
 876
 877 static int
 878 gtk_combo_list_key_press (GtkWidget * widget, GdkEventKey * event, GtkCombo * combo)
 879 {
 880   guint state = event->state & gtk_accelerator_get_default_mod_mask ();
 881
 882   if (event->keyval == GDK_Escape && state == 0)
 883     {
 884       if (GTK_WIDGET_HAS_GRAB (combo->list))
 885         gtk_list_end_drag_selection (GTK_LIST (combo->list));
 886
 887       gtk_combo_popdown_list (combo);
 888
 889       return TRUE;
 890     }
 891   return FALSE;
 892 }
 893
 894 static void
 895 combo_event_box_realize (GtkWidget *widget)
 896 {
 897   GdkCursor *cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
 898                                                   GDK_TOP_LEFT_ARROW);
 899   gdk_window_set_cursor (widget->window, cursor);
 900   gdk_cursor_unref (cursor);
 901 }
 902
 903 static void
 904 gtk_combo_init (GtkCombo * combo)
 905 {
 906   GtkWidget *arrow;
 907   GtkWidget *frame;
 908   GtkWidget *event_box;
 909
 910   combo->case_sensitive = FALSE;
 911   combo->value_in_list = FALSE;
 912   combo->ok_if_empty = TRUE;
 913   combo->use_arrows = TRUE;
 914   combo->use_arrows_always = TRUE;
 915   combo->entry = gtk_entry_new ();
 916   combo->button = gtk_button_new ();
 917   combo->current_button = 0;
 918   arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_OUT);
 919   gtk_widget_show (arrow);
 920   gtk_container_add (GTK_CONTAINER (combo->button), arrow);
 921   gtk_box_pack_start (GTK_BOX (combo), combo->entry, TRUE, TRUE, 0);
 922   gtk_box_pack_end (GTK_BOX (combo), combo->button, FALSE, FALSE, 0);
 923   GTK_WIDGET_UNSET_FLAGS (combo->button, GTK_CAN_FOCUS);
 924   gtk_widget_show (combo->entry);
 925   gtk_widget_show (combo->button);
 926   combo->entry_change_id = g_signal_connect (combo->entry, "changed",
 927                                              G_CALLBACK (gtk_combo_update_list),
 928                                              combo);
 929   g_signal_connect_after (combo->entry, "key_press_event",
 930                           G_CALLBACK (gtk_combo_entry_key_press), combo);
 931   g_signal_connect_after (combo->entry, "focus_out_event",
 932                           G_CALLBACK (gtk_combo_entry_focus_out), combo);
 933   combo->activate_id = g_signal_connect (combo->entry, "activate",
 934                                          G_CALLBACK (gtk_combo_activate),
 935                                          combo);
 936   g_signal_connect (combo->button, "button_press_event",
 937                     G_CALLBACK (gtk_combo_popup_button_press), combo);
 938   g_signal_connect (combo->button, "leave_notify_event",
 939                     G_CALLBACK (gtk_combo_popup_button_leave), combo);
 940
 941   combo->popwin = gtk_window_new (GTK_WINDOW_POPUP);
 942   gtk_widget_set_name (combo->popwin, "gtk-combo-popup-window");
 943   gtk_window_set_type_hint (GTK_WINDOW (combo->popwin), GDK_WINDOW_TYPE_HINT_COMBO);
 944   g_object_ref (combo->popwin);
 945   gtk_window_set_resizable (GTK_WINDOW (combo->popwin), FALSE);
 946
 947   g_signal_connect (combo->popwin, "key_press_event",
 948                     G_CALLBACK (gtk_combo_window_key_press), combo);
 949
 950   gtk_widget_set_events (combo->popwin, GDK_KEY_PRESS_MASK);
 951
 952   event_box = gtk_event_box_new ();
 953   gtk_container_add (GTK_CONTAINER (combo->popwin), event_box);
 954   g_signal_connect (event_box, "realize",
 955                     G_CALLBACK (combo_event_box_realize), NULL);
 956   gtk_widget_show (event_box);
 957
 958
 959   frame = gtk_frame_new (NULL);
 960   gtk_container_add (GTK_CONTAINER (event_box), frame);
 961   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
 962   gtk_widget_show (frame);
 963
 964   combo->popup = gtk_scrolled_window_new (NULL, NULL);
 965   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (combo->popup),
 966                                   GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 967   GTK_WIDGET_UNSET_FLAGS (GTK_SCROLLED_WINDOW (combo->popup)->hscrollbar, GTK_CAN_FOCUS);
 968   GTK_WIDGET_UNSET_FLAGS (GTK_SCROLLED_WINDOW (combo->popup)->vscrollbar, GTK_CAN_FOCUS);
 969   gtk_container_add (GTK_CONTAINER (frame), combo->popup);
 970   gtk_widget_show (combo->popup);
 971
 972   combo->list = gtk_list_new ();
 973   /* We'll use enter notify events to figure out when to transfer
 974    * the grab to the list
 975    */
 976   gtk_widget_set_events (combo->list, GDK_ENTER_NOTIFY_MASK);
 977
 978   gtk_list_set_selection_mode (GTK_LIST(combo->list), GTK_SELECTION_BROWSE);
 979   gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (combo->popup), combo->list);
 980   gtk_container_set_focus_vadjustment (GTK_CONTAINER (combo->list),
 981                                        gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (combo->popup)));
 982   gtk_container_set_focus_hadjustment (GTK_CONTAINER (combo->list),
 983                                        gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (combo->popup)));
 984   gtk_widget_show (combo->list);
 985
 986   combo->list_change_id = g_signal_connect (combo->list, "selection-changed",
 987                                             G_CALLBACK (gtk_combo_selection_changed), combo);
 988
 989   g_signal_connect (combo->popwin, "key_press_event",
 990                     G_CALLBACK (gtk_combo_list_key_press), combo);
 991   g_signal_connect (combo->popwin, "button_press_event",
 992                     G_CALLBACK (gtk_combo_button_press), combo);
 993
 994   g_signal_connect (combo->popwin, "event_after",
 995                     G_CALLBACK (gtk_combo_button_event_after), combo);
 996   g_signal_connect (combo->list, "event_after",
 997                     G_CALLBACK (gtk_combo_button_event_after), combo);
 998
 999   g_signal_connect (combo->list, "enter_notify_event",
1000                     G_CALLBACK (gtk_combo_list_enter), combo);
1001 }
1002
1003 static void
1004 gtk_combo_realize (GtkWidget *widget)
1005 {
1006   GtkCombo *combo = GTK_COMBO (widget);
1007
1008   gtk_window_set_screen (GTK_WINDOW (combo->popwin),
1009                          gtk_widget_get_screen (widget));
1010
1011   GTK_WIDGET_CLASS (gtk_combo_parent_class)->realize (widget);
1012 }
1013
1014 static void
1015 gtk_combo_unrealize (GtkWidget *widget)
1016 {
1017   GtkCombo *combo = GTK_COMBO (widget);
1018
1019   gtk_combo_popdown_list (combo);
1020   gtk_widget_unrealize (combo->popwin);
1021
1022   GTK_WIDGET_CLASS (gtk_combo_parent_class)->unrealize (widget);
1023 }
1024
1025 GtkWidget*
1026 gtk_combo_new (void)
1027 {
1028   return g_object_new (GTK_TYPE_COMBO, NULL);
1029 }
1030
1031 void
1032 gtk_combo_set_value_in_list (GtkCombo * combo, gboolean val, gboolean ok_if_empty)
1033 {
1034   g_return_if_fail (GTK_IS_COMBO (combo));
1035   val = val != FALSE;
1036   ok_if_empty = ok_if_empty != FALSE;
1037
1038   g_object_freeze_notify (G_OBJECT (combo));
1039   if (combo->value_in_list != val)
1040     {
1041        combo->value_in_list = val;
1042   g_object_notify (G_OBJECT (combo), "value-in-list");
1043     }
1044   if (combo->ok_if_empty != ok_if_empty)
1045     {
1046        combo->ok_if_empty = ok_if_empty;
1047   g_object_notify (G_OBJECT (combo), "allow-empty");
1048     }
1049   g_object_thaw_notify (G_OBJECT (combo));
1050 }
1051
1052 void
1053 gtk_combo_set_case_sensitive (GtkCombo * combo, gboolean val)
1054 {
1055   g_return_if_fail (GTK_IS_COMBO (combo));
1056   val = val != FALSE;
1057
1058   if (combo->case_sensitive != val)
1059     {
1060   combo->case_sensitive = val;
1061   g_object_notify (G_OBJECT (combo), "case-sensitive");
1062     }
1063 }
1064
1065 void
1066 gtk_combo_set_use_arrows (GtkCombo * combo, gboolean val)
1067 {
1068   g_return_if_fail (GTK_IS_COMBO (combo));
1069   val = val != FALSE;
1070
1071   if (combo->use_arrows != val)
1072     {
1073   combo->use_arrows = val;
1074   g_object_notify (G_OBJECT (combo), "enable-arrow-keys");
1075     }
1076 }
1077
1078 void
1079 gtk_combo_set_use_arrows_always (GtkCombo * combo, gboolean val)
1080 {
1081   g_return_if_fail (GTK_IS_COMBO (combo));
1082   val = val != FALSE;
1083
1084   if (combo->use_arrows_always != val)
1085     {
1086        g_object_freeze_notify (G_OBJECT (combo));
1087   combo->use_arrows_always = val;
1088        g_object_notify (G_OBJECT (combo), "enable-arrows-always");
1089
1090        if (combo->use_arrows != TRUE)
1091          {
1092   combo->use_arrows = TRUE;
1093   g_object_notify (G_OBJECT (combo), "enable-arrow-keys");
1094          }
1095   g_object_thaw_notify (G_OBJECT (combo));
1096     }
1097 }
1098
1099 void
1100 gtk_combo_set_popdown_strings (GtkCombo *combo,
1101                                GList    *strings)
1102 {
1103   GList *list;
1104   GtkWidget *li;
1105
1106   g_return_if_fail (GTK_IS_COMBO (combo));
1107
1108   gtk_combo_popdown_list (combo);
1109
1110   gtk_list_clear_items (GTK_LIST (combo->list), 0, -1);
1111   list = strings;
1112   while (list)
1113     {
1114       li = gtk_list_item_new_with_label ((gchar *) list->data);
1115       gtk_widget_show (li);
1116       gtk_container_add (GTK_CONTAINER (combo->list), li);
1117       list = list->next;
1118     }
1119 }
1120
1121 void
1122 gtk_combo_set_item_string (GtkCombo * combo, GtkItem * item, const gchar * item_value)
1123 {
1124   g_return_if_fail (GTK_IS_COMBO (combo));
1125   g_return_if_fail (item != NULL);
1126
1127   g_object_set_data_full (G_OBJECT (item), I_(gtk_combo_string_key),
1128                           g_strdup (item_value), g_free);
1129 }
1130
1131 static void
1132 gtk_combo_size_allocate (GtkWidget     *widget,
1133                          GtkAllocation *allocation)
1134 {
1135   GtkCombo *combo = GTK_COMBO (widget);
1136
1137   GTK_WIDGET_CLASS (gtk_combo_parent_class)->size_allocate (widget, allocation);
1138
1139   if (combo->entry->allocation.height > combo->entry->requisition.height)
1140     {
1141       GtkAllocation button_allocation;
1142
1143       button_allocation = combo->button->allocation;
1144       button_allocation.height = combo->entry->requisition.height;
1145       button_allocation.y = combo->entry->allocation.y +
1146         (combo->entry->allocation.height - combo->entry->requisition.height)
1147         / 2;
1148       gtk_widget_size_allocate (combo->button, &button_allocation);
1149     }
1150 }
1151
1152 void
1153 gtk_combo_disable_activate (GtkCombo* combo)
1154 {
1155   g_return_if_fail (GTK_IS_COMBO (combo));
1156
1157   if ( combo->activate_id ) {
1158     g_signal_handler_disconnect (combo->entry, combo->activate_id);
1159     combo->activate_id = 0;
1160   }
1161 }
1162
1163 static void
1164 gtk_combo_set_property (GObject         *object,
1165                         guint            prop_id,
1166                         const GValue    *value,
1167                         GParamSpec      *pspec)
1168 {
1169   GtkCombo *combo = GTK_COMBO (object);
1170
1171   switch (prop_id)
1172     {
1173     case PROP_ENABLE_ARROW_KEYS:
1174       gtk_combo_set_use_arrows (combo, g_value_get_boolean (value));
1175       break;
1176     case PROP_ENABLE_ARROWS_ALWAYS:
1177       gtk_combo_set_use_arrows_always (combo, g_value_get_boolean (value));
1178       break;
1179     case PROP_CASE_SENSITIVE:
1180       gtk_combo_set_case_sensitive (combo, g_value_get_boolean (value));
1181       break;
1182     case PROP_ALLOW_EMPTY:
1183       combo->ok_if_empty = g_value_get_boolean (value);
1184       break;
1185     case PROP_VALUE_IN_LIST:
1186       combo->value_in_list = g_value_get_boolean (value);
1187       break;
1188     default:
1189       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1190       break;
1191     }
1192
1193 }
1194
1195 static void
1196 gtk_combo_get_property (GObject         *object,
1197                         guint            prop_id,
1198                         GValue          *value,
1199                         GParamSpec      *pspec)
1200 {
1201   GtkCombo *combo = GTK_COMBO (object);
1202
1203   switch (prop_id)
1204     {
1205     case PROP_ENABLE_ARROW_KEYS:
1206       g_value_set_boolean (value, combo->use_arrows);
1207       break;
1208     case PROP_ENABLE_ARROWS_ALWAYS:
1209       g_value_set_boolean (value, combo->use_arrows_always);
1210       break;
1211     case PROP_CASE_SENSITIVE:
1212       g_value_set_boolean (value, combo->case_sensitive);
1213       break;
1214     case PROP_ALLOW_EMPTY:
1215       g_value_set_boolean (value, combo->ok_if_empty);
1216       break;
1217     case PROP_VALUE_IN_LIST:
1218       g_value_set_boolean (value, combo->value_in_list);
1219       break;
1220     default:
1221       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1222       break;
1223     }
1224
1225 }
1226
1227 #define __GTK_SMART_COMBO_C__
1228 #include "gtkaliasdef.c"