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