src/univ/combobox.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        univ/combobox.cpp
   3 // Purpose:     wxComboControl and wxComboBox implementation
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     15.12.00
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "univcombobox.h"
  22 #endif
  23
  24 #include "wx/wxprec.h"
  25
  26 #ifdef __BORLANDC__
  27     #pragma hdrstop
  28 #endif
  29
  30 #if wxUSE_COMBOBOX
  31
  32 #ifndef WX_PRECOMP
  33     #include "wx/log.h"
  34
  35     #include "wx/button.h"
  36     #include "wx/combobox.h"
  37     #include "wx/listbox.h"
  38     #include "wx/textctrl.h"
  39     #include "wx/bmpbuttn.h"
  40
  41     #include "wx/validate.h"
  42 #endif
  43
  44 #include "wx/popupwin.h"
  45
  46 #include "wx/univ/renderer.h"
  47 #include "wx/univ/inphand.h"
  48 #include "wx/univ/theme.h"
  49
  50 /*
  51    The keyboard event flow:
  52
  53    1. they always come to the text ctrl
  54    2. it forwards the ones it doesn't process to the wxComboControl
  55    3. which passes them to the popup window if it is popped up
  56  */
  57
  58 // ----------------------------------------------------------------------------
  59 // wxComboButton is just a normal button except that it sends commands to the
  60 // combobox and not its parent
  61 // ----------------------------------------------------------------------------
  62
  63 class wxComboButton : public wxBitmapButton
  64 {
  65 public:
  66     wxComboButton(wxComboControl *combo)
  67         : wxBitmapButton(combo->GetParent(), -1, wxNullBitmap,
  68                          wxDefaultPosition, wxDefaultSize,
  69                          wxBORDER_NONE | wxBU_EXACTFIT)
  70     {
  71         m_combo = combo;
  72
  73         wxBitmap bmpNormal, bmpFocus, bmpPressed, bmpDisabled;
  74
  75         GetRenderer()->GetComboBitmaps(&bmpNormal,
  76                                        &bmpFocus,
  77                                        &bmpPressed,
  78                                        &bmpDisabled);
  79
  80         SetBitmapLabel(bmpNormal);
  81         SetBitmapFocus(bmpFocus.Ok() ? bmpFocus : bmpNormal);
  82         SetBitmapSelected(bmpPressed.Ok() ? bmpPressed : bmpNormal);
  83         SetBitmapDisabled(bmpDisabled.Ok() ? bmpDisabled : bmpNormal);
  84
  85         SetBestSize(wxDefaultSize);
  86     }
  87
  88 protected:
  89     void OnButton(wxCommandEvent& event) { m_combo->ShowPopup(); }
  90
  91     virtual wxSize DoGetBestClientSize() const
  92     {
  93         const wxBitmap& bmp = GetBitmapLabel();
  94
  95         return wxSize(bmp.GetWidth(), bmp.GetHeight());
  96
  97     }
  98
  99 private:
 100     wxComboControl *m_combo;
 101
 102     DECLARE_EVENT_TABLE()
 103 };
 104
 105 // ----------------------------------------------------------------------------
 106 // wxComboListBox is a listbox modified to be used as a popup window in a
 107 // combobox
 108 // ----------------------------------------------------------------------------
 109
 110 class wxComboListBox : public wxListBox, public wxComboPopup
 111 {
 112 public:
 113     // ctor and dtor
 114     wxComboListBox(wxComboControl *combo, int style = 0);
 115     virtual ~wxComboListBox();
 116
 117     // implement wxComboPopup methods
 118     virtual bool SetSelection(const wxString& value);
 119     virtual wxControl *GetControl() { return this; }
 120     virtual void OnShow();
 121
 122 protected:
 123     // we shouldn't return height too big from here
 124     virtual wxSize DoGetBestClientSize() const;
 125
 126     // filter mouse move events happening outside the list box
 127     void OnMouseMove(wxMouseEvent& event);
 128
 129     // set m_clicked value from here
 130     void OnLeftUp(wxMouseEvent& event);
 131
 132     // called whenever the user selects or activates a listbox item
 133     void OnSelect(wxCommandEvent& event);
 134
 135     // used to process wxUniv actions
 136     bool PerformAction(const wxControlAction& action,
 137                        long numArg,
 138                        const wxString& strArg);
 139
 140 private:
 141     // has the mouse been released on this control?
 142     bool m_clicked;
 143
 144     DECLARE_EVENT_TABLE()
 145 };
 146
 147 // ----------------------------------------------------------------------------
 148 // wxComboTextCtrl is a simple text ctrl which forwards
 149 // wxEVT_COMMAND_TEXT_UPDATED events and all key events to the combobox
 150 // ----------------------------------------------------------------------------
 151
 152 class wxComboTextCtrl : public wxTextCtrl
 153 {
 154 public:
 155     wxComboTextCtrl(wxComboControl *combo,
 156                     const wxString& value,
 157                     long style,
 158                     const wxValidator& validator);
 159
 160 protected:
 161     void OnKey(wxKeyEvent& event);
 162     void OnText(wxCommandEvent& event);
 163
 164 private:
 165     wxComboControl *m_combo;
 166
 167     DECLARE_EVENT_TABLE()
 168 };
 169
 170 // ----------------------------------------------------------------------------
 171 // event tables and such
 172 // ----------------------------------------------------------------------------
 173
 174 BEGIN_EVENT_TABLE(wxComboButton, wxButton)
 175     EVT_BUTTON(-1, wxComboButton::OnButton)
 176 END_EVENT_TABLE()
 177
 178 BEGIN_EVENT_TABLE(wxComboListBox, wxListBox)
 179     EVT_LISTBOX(-1, wxComboListBox::OnSelect)
 180     EVT_LISTBOX_DCLICK(-1, wxComboListBox::OnSelect)
 181     EVT_MOTION(wxComboListBox::OnMouseMove)
 182     EVT_LEFT_UP(wxComboListBox::OnLeftUp)
 183 END_EVENT_TABLE()
 184
 185 BEGIN_EVENT_TABLE(wxComboControl, wxControl)
 186     EVT_KEY_DOWN(wxComboControl::OnKey)
 187     EVT_KEY_UP(wxComboControl::OnKey)
 188 END_EVENT_TABLE()
 189
 190 BEGIN_EVENT_TABLE(wxComboTextCtrl, wxTextCtrl)
 191     EVT_KEY_DOWN(wxComboTextCtrl::OnKey)
 192     EVT_KEY_UP(wxComboTextCtrl::OnKey)
 193     EVT_TEXT(-1, wxComboTextCtrl::OnText)
 194 END_EVENT_TABLE()
 195
 196 IMPLEMENT_DYNAMIC_CLASS(wxComboBox, wxControl);
 197
 198 // ============================================================================
 199 // implementation
 200 // ============================================================================
 201
 202 // ----------------------------------------------------------------------------
 203 // wxComboControl creation
 204 // ----------------------------------------------------------------------------
 205
 206 void wxComboControl::Init()
 207 {
 208     m_popup = (wxComboPopup *)NULL;
 209     m_winPopup = (wxPopupComboWindow *)NULL;
 210     m_isPopupShown = FALSE;
 211     m_btn = NULL;
 212     m_text = NULL;
 213 }
 214
 215 bool wxComboControl::Create(wxWindow *parent,
 216                             wxWindowID id,
 217                             const wxString& value,
 218                             const wxPoint& pos,
 219                             const wxSize& size,
 220                             long style,
 221                             const wxValidator& validator,
 222                             const wxString& name)
 223 {
 224     // first create our own window, i.e. the one which will contain all
 225     // subcontrols
 226     style &= ~wxBORDER_NONE;
 227     style |= wxBORDER_SUNKEN;
 228     if ( !wxControl::Create(parent, id, pos, size, style, validator, name) )
 229         return FALSE;
 230
 231     // create the text control and the button as our siblings (*not* children),
 232     // don't care about size/position here - they will be set in DoMoveWindow()
 233     m_btn = new wxComboButton(this);
 234     m_text = new wxComboTextCtrl(this,
 235                                  value,
 236                                  style & wxCB_READONLY ? wxTE_READONLY : 0,
 237                                  validator);
 238
 239     // for compatibility with the other ports, the height specified is the
 240     // combined height of the combobox itself and the popup
 241     if ( size.y == -1 )
 242     {
 243         // ok, use default height for popup too
 244         m_heightPopup = -1;
 245     }
 246     else
 247     {
 248         m_heightPopup = size.y - DoGetBestSize().y;
 249     }
 250
 251     SetBestSize(size);
 252     Move(pos);
 253
 254     // create the popup window immediately here to allow creating the controls
 255     // with parent == GetPopupWindow() from the derived class ctor
 256     m_winPopup = new wxPopupComboWindow(this);
 257
 258     // have to disable this window to avoid interfering it with message
 259     // processing to the text and the button... but pretend it is enabled to
 260     // make IsEnabled() return TRUE
 261     wxControl::Enable(FALSE); // don't use non virtual Disable() here!
 262     m_isEnabled = TRUE;
 263
 264     CreateInputHandler(wxINP_HANDLER_COMBOBOX);
 265
 266     return TRUE;
 267 }
 268
 269 wxComboControl::~wxComboControl()
 270 {
 271     // as the button and the text control are the parent's children and not
 272     // ours, we have to delete them manually - they are not deleted
 273     // automatically by wxWindows when we're deleted
 274     delete m_btn;
 275     delete m_text;
 276
 277     delete m_winPopup;
 278 }
 279
 280 // ----------------------------------------------------------------------------
 281 // geometry stuff
 282 // ----------------------------------------------------------------------------
 283
 284 void wxComboControl::DoSetSize(int x, int y,
 285                                int width, int height,
 286                                int sizeFlags)
 287 {
 288     // combo height is always fixed
 289     wxControl::DoSetSize(x, y, width, DoGetBestSize().y, sizeFlags);
 290 }
 291
 292 wxSize wxComboControl::DoGetBestClientSize() const
 293 {
 294     wxSize sizeBtn = m_btn->GetBestSize(),
 295            sizeText = m_text->GetBestSize();
 296
 297     return wxSize(sizeBtn.x + sizeText.x, wxMax(sizeBtn.y, sizeText.y));
 298 }
 299
 300 void wxComboControl::DoMoveWindow(int x, int y, int width, int height)
 301 {
 302     wxControl::DoMoveWindow(x, y, width, height);
 303
 304     // position the subcontrols inside the client area
 305     wxRect rectBorders = GetRenderer()->GetBorderDimensions(GetBorder());
 306     x += rectBorders.x;
 307     y += rectBorders.y;
 308     width -= rectBorders.x + rectBorders.width;
 309     height -= rectBorders.y + rectBorders.height;
 310
 311     wxSize sizeBtn = m_btn->GetBestSize();
 312
 313     wxCoord wText = width - sizeBtn.x;
 314     wxPoint p = GetParent() ? GetParent()->GetClientAreaOrigin() : wxPoint(0,0);
 315     m_text->SetSize(x - p.x, y - p.y, wText, height);
 316     m_btn->SetSize(x - p.x + wText, y - p.y, sizeBtn.x, height);
 317 }
 318
 319 // ----------------------------------------------------------------------------
 320 // operations
 321 // ----------------------------------------------------------------------------
 322
 323 bool wxComboControl::Enable(bool enable)
 324 {
 325     if ( !wxControl::Enable(enable) )
 326         return FALSE;
 327
 328     m_btn->Enable(enable);
 329     m_text->Enable(enable);
 330
 331     return TRUE;
 332 }
 333
 334 bool wxComboControl::Show(bool show)
 335 {
 336     if ( !wxControl::Show(show) )
 337         return FALSE;
 338
 339     if (m_btn)
 340         m_btn->Show(show);
 341
 342     if (m_text)
 343         m_text->Show(show);
 344
 345     return TRUE;
 346 }
 347
 348 // ----------------------------------------------------------------------------
 349 // popup window handling
 350 // ----------------------------------------------------------------------------
 351
 352 void wxComboControl::SetPopupControl(wxComboPopup *popup)
 353 {
 354     m_popup = popup;
 355 }
 356
 357 void wxComboControl::ShowPopup()
 358 {
 359     wxCHECK_RET( m_popup, _T("no popup to show in wxComboControl") );
 360     wxCHECK_RET( !IsPopupShown(), _T("popup window already shown") );
 361
 362     wxControl *control = m_popup->GetControl();
 363
 364     // size and position the popup window correctly
 365     m_winPopup->SetSize(GetSize().x,
 366                         m_heightPopup == -1 ? control->GetBestSize().y
 367                                             : m_heightPopup);
 368     wxSize sizePopup = m_winPopup->GetClientSize();
 369     control->SetSize(0, 0, sizePopup.x, sizePopup.y);
 370
 371     // some controls don't accept the size we give then: e.g. a listbox may
 372     // require more space to show its last row
 373     wxSize sizeReal = control->GetSize();
 374     if ( sizeReal != sizePopup )
 375     {
 376         m_winPopup->SetClientSize(sizeReal);
 377     }
 378
 379     m_winPopup->PositionNearCombo();
 380
 381     // show it
 382     m_popup->OnShow();
 383     m_winPopup->Popup(m_text);
 384     m_text->SelectAll();
 385     m_popup->SetSelection(m_text->GetValue());
 386
 387     m_isPopupShown = TRUE;
 388 }
 389
 390 void wxComboControl::HidePopup()
 391 {
 392     wxCHECK_RET( m_popup, _T("no popup to hide in wxComboControl") );
 393     wxCHECK_RET( IsPopupShown(), _T("popup window not shown") );
 394
 395     m_winPopup->Dismiss();
 396
 397     m_isPopupShown = FALSE;
 398 }
 399
 400 void wxComboControl::OnSelect(const wxString& value)
 401 {
 402     m_text->SetValue(value);
 403     m_text->SelectAll();
 404
 405     OnDismiss();
 406 }
 407
 408 void wxComboControl::OnDismiss()
 409 {
 410     HidePopup();
 411     m_text->SetFocus();
 412 }
 413
 414 // ----------------------------------------------------------------------------
 415 // wxComboTextCtrl
 416 // ----------------------------------------------------------------------------
 417
 418 wxComboTextCtrl::wxComboTextCtrl(wxComboControl *combo,
 419                                  const wxString& value,
 420                                  long style,
 421                                  const wxValidator& validator)
 422                : wxTextCtrl(combo->GetParent(), -1, value,
 423                             wxDefaultPosition, wxDefaultSize,
 424                             wxBORDER_NONE | style,
 425                             validator)
 426 {
 427     m_combo = combo;
 428 }
 429
 430 void wxComboTextCtrl::OnText(wxCommandEvent& event)
 431 {
 432     if ( m_combo->IsPopupShown() )
 433     {
 434         m_combo->GetPopupControl()->SetSelection(GetValue());
 435     }
 436
 437     // we need to make a copy of the event to have the correct originating
 438     // object and id
 439     wxCommandEvent event2 = event;
 440     event2.SetEventObject(m_combo);
 441     event2.SetId(m_combo->GetId());
 442
 443     // there is a small incompatibility with wxMSW here: the combobox gets the
 444     // event before the text control in our case which corresponds to SMW
 445     // CBN_EDITUPDATE notification and not CBN_EDITCHANGE one wxMSW currently
 446     // uses
 447     //
 448     // if this is really a problem, we can play games with the event handlers
 449     // to circumvent this
 450     (void)m_combo->ProcessEvent(event2);
 451
 452     event.Skip();
 453 }
 454
 455 // pass the keys we don't process to the combo first
 456 void wxComboTextCtrl::OnKey(wxKeyEvent& event)
 457 {
 458     switch ( event.GetKeyCode() )
 459     {
 460         case WXK_RETURN:
 461             // the popup control gets it first but only if it is shown
 462             if ( !m_combo->IsPopupShown() )
 463                 break;
 464             //else: fall through
 465
 466         case WXK_UP:
 467         case WXK_DOWN:
 468         case WXK_ESCAPE:
 469         case WXK_PAGEDOWN:
 470         case WXK_PAGEUP:
 471         case WXK_PRIOR:
 472         case WXK_NEXT:
 473             (void)m_combo->ProcessEvent(event);
 474             return;
 475     }
 476
 477     event.Skip();
 478 }
 479
 480 // ----------------------------------------------------------------------------
 481 // wxComboListBox
 482 // ----------------------------------------------------------------------------
 483
 484 wxComboListBox::wxComboListBox(wxComboControl *combo, int style)
 485               : wxListBox(combo->GetPopupWindow(), -1,
 486                           wxDefaultPosition, wxDefaultSize,
 487                           0, NULL,
 488                           wxBORDER_SIMPLE | wxLB_INT_HEIGHT | style),
 489                 wxComboPopup(combo)
 490 {
 491     // we don't react to the mouse events outside the window at all
 492     StopAutoScrolling();
 493 }
 494
 495 wxComboListBox::~wxComboListBox()
 496 {
 497 }
 498
 499 bool wxComboListBox::SetSelection(const wxString& value)
 500 {
 501     // FindItem() would just find the current item for an empty string (it
 502     // always matches), but we want to show the first one in such case
 503     if ( value.empty() )
 504     {
 505         if ( GetCount() )
 506         {
 507             wxListBox::SetSelection(0);
 508         }
 509         //else: empty listbox - nothing to do
 510     }
 511     else if ( !FindItem(value) )
 512     {
 513         // no match att all
 514         return FALSE;
 515     }
 516
 517     return TRUE;
 518 }
 519
 520 void wxComboListBox::OnSelect(wxCommandEvent& event)
 521 {
 522     if ( m_clicked )
 523     {
 524         // first update the combo and close the listbox
 525         m_combo->OnSelect(event.GetString());
 526
 527         // next let the user code have the event
 528
 529         // all fields are already filled by the listbox, just change the event
 530         // type and send it to the combo
 531         wxCommandEvent event2 = event;
 532         event2.SetEventType(wxEVT_COMMAND_COMBOBOX_SELECTED);
 533         event2.SetEventObject(m_combo);
 534         event2.SetId(m_combo->GetId());
 535         m_combo->ProcessEvent(event2);
 536     }
 537     //else: ignore the events resultign from just moving the mouse initially
 538 }
 539
 540 void wxComboListBox::OnShow()
 541 {
 542     // nobody clicked us yet
 543     m_clicked = FALSE;
 544 }
 545
 546 bool wxComboListBox::PerformAction(const wxControlAction& action,
 547                                    long numArg,
 548                                    const wxString& strArg)
 549
 550 {
 551     if ( action == wxACTION_LISTBOX_FIND )
 552     {
 553         // we don't let the listbox handle this as instead of just using the
 554         // single key presses, as usual, we use the text ctrl value as prefix
 555         // and this is done by wxComboControl itself
 556         return TRUE;
 557     }
 558
 559     return wxListBox::PerformAction(action, numArg, strArg);
 560 }
 561
 562 void wxComboListBox::OnLeftUp(wxMouseEvent& event)
 563 {
 564     // we should dismiss the combo now
 565     m_clicked = TRUE;
 566
 567     event.Skip();
 568 }
 569
 570 void wxComboListBox::OnMouseMove(wxMouseEvent& event)
 571 {
 572     // while a wxComboListBox is shown, it always has capture, so if it doesn't
 573     // we're about to go away anyhow (normally this shouldn't happen at all,
 574     // but I don't put assert here as it just might do on other platforms and
 575     // it doesn't break anythign anyhow)
 576     if ( this == wxWindow::GetCapture() )
 577     {
 578         if ( HitTest(event.GetPosition()) == wxHT_WINDOW_INSIDE )
 579         {
 580             event.Skip();
 581         }
 582         //else: popup shouldn't react to the mouse motions outside it, it only
 583         //      captures the mouse to be able to detect when it must be
 584         //      dismissed, so don't call Skip()
 585     }
 586 }
 587
 588 wxSize wxComboListBox::DoGetBestClientSize() const
 589 {
 590     // don't return size too big or we risk to not fit on the screen
 591     wxSize size = wxListBox::DoGetBestClientSize();
 592     wxCoord hChar = GetCharHeight();
 593
 594     int nLines = size.y / hChar;
 595
 596     // 10 is the same limit as used by wxMSW
 597     if ( nLines > 10 )
 598     {
 599         size.y = 10*hChar;
 600     }
 601
 602     return size;
 603 }
 604
 605 // ----------------------------------------------------------------------------
 606 // wxComboBox
 607 // ----------------------------------------------------------------------------
 608
 609 void wxComboBox::Init()
 610 {
 611     m_lbox = (wxListBox *)NULL;
 612 }
 613
 614 bool wxComboBox::Create(wxWindow *parent,
 615                         wxWindowID id,
 616                         const wxString& value,
 617                         const wxPoint& pos,
 618                         const wxSize& size,
 619                         int n,
 620                         const wxString *choices,
 621                         long style,
 622                         const wxValidator& validator,
 623                         const wxString& name)
 624 {
 625     if ( !wxComboControl::Create(parent, id, value, pos, size, style,
 626                                  validator, name) )
 627     {
 628         return FALSE;
 629     }
 630
 631     wxComboListBox *combolbox =
 632         new wxComboListBox(this, style & wxCB_SORT ? wxLB_SORT : 0);
 633     m_lbox = combolbox;
 634     m_lbox->Set(n, choices);
 635
 636     SetPopupControl(combolbox);
 637
 638     return TRUE;
 639 }
 640
 641 wxComboBox::~wxComboBox()
 642 {
 643 }
 644
 645 // ----------------------------------------------------------------------------
 646 // wxComboBox methods forwarded to wxTextCtrl
 647 // ----------------------------------------------------------------------------
 648
 649 wxString wxComboBox::GetValue() const
 650 {
 651     return GetText()->GetValue();
 652 }
 653
 654 void wxComboBox::SetValue(const wxString& value)
 655 {
 656     GetText()->SetValue(value);
 657 }
 658
 659 void wxComboBox::Copy()
 660 {
 661     GetText()->Copy();
 662 }
 663
 664 void wxComboBox::Cut()
 665 {
 666     GetText()->Cut();
 667 }
 668
 669 void wxComboBox::Paste()
 670 {
 671     GetText()->Paste();
 672 }
 673
 674 void wxComboBox::SetInsertionPoint(long pos)
 675 {
 676     GetText()->SetInsertionPoint(pos);
 677 }
 678
 679 void wxComboBox::SetInsertionPointEnd()
 680 {
 681     GetText()->SetInsertionPointEnd();
 682 }
 683
 684 long wxComboBox::GetInsertionPoint() const
 685 {
 686     return GetText()->GetInsertionPoint();
 687 }
 688
 689 long wxComboBox::GetLastPosition() const
 690 {
 691     return GetText()->GetLastPosition();
 692 }
 693
 694 void wxComboBox::Replace(long from, long to, const wxString& value)
 695 {
 696     GetText()->Replace(from, to, value);
 697 }
 698
 699 void wxComboBox::Remove(long from, long to)
 700 {
 701     GetText()->Remove(from, to);
 702 }
 703
 704 void wxComboBox::SetSelection(long from, long to)
 705 {
 706     GetText()->SetSelection(from, to);
 707 }
 708
 709 void wxComboBox::SetEditable(bool editable)
 710 {
 711     GetText()->SetEditable(editable);
 712 }
 713
 714 // ----------------------------------------------------------------------------
 715 // wxComboBox methods forwarded to wxListBox
 716 // ----------------------------------------------------------------------------
 717
 718 void wxComboBox::Clear()
 719 {
 720     GetLBox()->Clear();
 721 }
 722
 723 void wxComboBox::Delete(int n)
 724 {
 725     GetLBox()->Delete(n);
 726 }
 727
 728 int wxComboBox::GetCount() const
 729 {
 730     return GetLBox()->GetCount();
 731 }
 732
 733 wxString wxComboBox::GetString(int n) const
 734 {
 735     return GetLBox()->GetString(n);
 736 }
 737
 738 void wxComboBox::SetString(int n, const wxString& s)
 739 {
 740     GetLBox()->SetString(n, s);
 741 }
 742
 743 int wxComboBox::FindString(const wxString& s) const
 744 {
 745     return GetLBox()->FindString(s);
 746 }
 747
 748 void wxComboBox::Select(int n)
 749 {
 750     wxCHECK_RET( (n >= 0) && (n < GetCount()), _T("invalid combobox index") );
 751
 752     GetLBox()->SetSelection(n);
 753     GetText()->SetValue(GetLBox()->GetString(n));
 754 }
 755
 756 int wxComboBox::GetSelection() const
 757 {
 758     // if the current value isn't one of the listbox strings, return -1
 759     return FindString(GetText()->GetValue());
 760 }
 761
 762 int wxComboBox::DoAppend(const wxString& item)
 763 {
 764     return GetLBox()->Append(item);
 765 }
 766
 767 void wxComboBox::DoSetItemClientData(int n, void* clientData)
 768 {
 769     GetLBox()->SetClientData(n, clientData);
 770 }
 771
 772 void *wxComboBox::DoGetItemClientData(int n) const
 773 {
 774     return GetLBox()->GetClientData(n);
 775 }
 776
 777 void wxComboBox::DoSetItemClientObject(int n, wxClientData* clientData)
 778 {
 779     GetLBox()->SetClientObject(n, clientData);
 780 }
 781
 782 wxClientData* wxComboBox::DoGetItemClientObject(int n) const
 783 {
 784     return GetLBox()->GetClientObject(n);
 785 }
 786
 787 // ----------------------------------------------------------------------------
 788 // input handling
 789 // ----------------------------------------------------------------------------
 790
 791 void wxComboControl::OnKey(wxKeyEvent& event)
 792 {
 793     if ( m_isPopupShown )
 794     {
 795         // pass it to the popped up control
 796         (void)m_popup->GetControl()->ProcessEvent(event);
 797     }
 798     else // no popup
 799     {
 800         event.Skip();
 801     }
 802 }
 803
 804 bool wxComboControl::PerformAction(const wxControlAction& action,
 805                                    long numArg,
 806                                    const wxString& strArg)
 807 {
 808     bool processed = FALSE;
 809     if ( action == wxACTION_COMBOBOX_POPUP )
 810     {
 811         if ( !m_isPopupShown )
 812         {
 813             ShowPopup();
 814
 815             processed = TRUE;
 816         }
 817     }
 818     else if ( action == wxACTION_COMBOBOX_DISMISS )
 819     {
 820         if ( m_isPopupShown )
 821         {
 822             HidePopup();
 823
 824             processed = TRUE;
 825         }
 826     }
 827
 828     if ( !processed )
 829     {
 830         // pass along
 831         return wxControl::PerformAction(action, numArg, strArg);
 832     }
 833
 834     return TRUE;
 835 }
 836
 837 // ----------------------------------------------------------------------------
 838 // wxStdComboBoxInputHandler
 839 // ----------------------------------------------------------------------------
 840
 841 wxStdComboBoxInputHandler::wxStdComboBoxInputHandler(wxInputHandler *inphand)
 842                          : wxStdInputHandler(inphand)
 843 {
 844 }
 845
 846 bool wxStdComboBoxInputHandler::HandleKey(wxInputConsumer *consumer,
 847                                           const wxKeyEvent& event,
 848                                           bool pressed)
 849 {
 850     if ( pressed )
 851     {
 852         wxControlAction action;
 853         switch ( event.GetKeyCode() )
 854         {
 855             case WXK_DOWN:
 856                 action = wxACTION_COMBOBOX_POPUP;
 857                 break;
 858
 859             case WXK_ESCAPE:
 860                 action = wxACTION_COMBOBOX_DISMISS;
 861                 break;
 862         }
 863
 864         if ( !!action )
 865         {
 866             consumer->PerformAction(action);
 867
 868             return TRUE;
 869         }
 870     }
 871
 872     return wxStdInputHandler::HandleKey(consumer, event, pressed);
 873 }
 874
 875 #endif // wxUSE_COMBOBOX