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