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