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