src/common/combocmn.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/combocmn.cpp
   3 // Purpose:     wxComboCtrlBase
   4 // Author:      Jaakko Salli
   5 // Modified by:
   6 // Created:     Apr-30-2006
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2005 Jaakko Salli
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #include "wx/wxprec.h"
  21
  22 #ifdef __BORLANDC__
  23     #pragma hdrstop
  24 #endif
  25
  26 #if wxUSE_COMBOCTRL
  27
  28 #include "wx/combobox.h"
  29
  30 #ifndef WX_PRECOMP
  31     #include "wx/app.h"
  32     #include "wx/log.h"
  33     #include "wx/dcclient.h"
  34     #include "wx/settings.h"
  35     #include "wx/dialog.h"
  36     #include "wx/timer.h"
  37     #include "wx/textctrl.h"
  38 #endif
  39
  40 #include "wx/tooltip.h"
  41
  42 #include "wx/combo.h"
  43
  44
  45
  46 // constants
  47 // ----------------------------------------------------------------------------
  48
  49 #define DEFAULT_DROPBUTTON_WIDTH                19
  50
  51 #define BMP_BUTTON_MARGIN                       4
  52
  53 #define DEFAULT_POPUP_HEIGHT                    400
  54
  55 #define DEFAULT_TEXT_INDENT                     3
  56
  57 #define COMBO_MARGIN                            2 // spacing right of wxTextCtrl
  58
  59
  60 #if defined(__WXMSW__)
  61
  62 #define USE_TRANSIENT_POPUP           1 // Use wxPopupWindowTransient (preferred, if it works properly on platform)
  63 #define TRANSIENT_POPUPWIN_IS_PERFECT 0 // wxPopupTransientWindow works, its child can have focus, and common
  64                                         // native controls work on it like normal.
  65 #define POPUPWIN_IS_PERFECT           0 // Same, but for non-transient popup window.
  66 #define TEXTCTRL_TEXT_CENTERED        0 // 1 if text in textctrl is vertically centered
  67 #define FOCUS_RING                    0 // No focus ring on wxMSW
  68
  69 //#undef wxUSE_POPUPWIN
  70 //#define wxUSE_POPUPWIN 0
  71
  72 #elif defined(__WXGTK__)
  73
  74 // NB: It is not recommended to use wxDialog as popup on wxGTK, because of
  75 //     this bug: If wxDialog is hidden, its position becomes corrupt
  76 //     between hide and next show, but without internal coordinates being
  77 //     reflected (or something like that - atleast commenting out ->Hide()
  78 //     seemed to eliminate the position change).
  79
  80 #define USE_TRANSIENT_POPUP           1 // Use wxPopupWindowTransient (preferred, if it works properly on platform)
  81 #define TRANSIENT_POPUPWIN_IS_PERFECT 0 // wxPopupTransientWindow works, its child can have focus, and common
  82                                         // native controls work on it like normal.
  83 #define POPUPWIN_IS_PERFECT           1 // Same, but for non-transient popup window.
  84 #define TEXTCTRL_TEXT_CENTERED        1 // 1 if text in textctrl is vertically centered
  85 #define FOCUS_RING                    0 // No focus ring on wxGTK
  86
  87 #elif defined(__WXMAC__)
  88
  89 #define USE_TRANSIENT_POPUP           0 // Use wxPopupWindowTransient (preferred, if it works properly on platform)
  90 #define TRANSIENT_POPUPWIN_IS_PERFECT 0 // wxPopupTransientWindow works, its child can have focus, and common
  91                                         // native controls work on it like normal.
  92 #define POPUPWIN_IS_PERFECT           0 // Same, but for non-transient popup window.
  93 #define TEXTCTRL_TEXT_CENTERED        1 // 1 if text in textctrl is vertically centered
  94 #define FOCUS_RING                    3 // Reserve room for the textctrl's focus ring to display
  95
  96 #undef DEFAULT_DROPBUTTON_WIDTH
  97 #define DEFAULT_DROPBUTTON_WIDTH      22
  98 #undef COMBO_MARGIN
  99 #define COMBO_MARGIN                  FOCUS_RING
 100
 101 #else
 102
 103 #define USE_TRANSIENT_POPUP           0 // Use wxPopupWindowTransient (preferred, if it works properly on platform)
 104 #define TRANSIENT_POPUPWIN_IS_PERFECT 0 // wxPopupTransientWindow works, its child can have focus, and common
 105                                         // native controls work on it like normal.
 106 #define POPUPWIN_IS_PERFECT           0 // Same, but for non-transient popup window.
 107 #define TEXTCTRL_TEXT_CENTERED        1 // 1 if text in textctrl is vertically centered
 108 #define FOCUS_RING                    0
 109
 110 #endif
 111
 112
 113 // Popupwin is really only supported on wxMSW (not WINCE) and wxGTK, regardless
 114 // what the wxUSE_POPUPWIN says.
 115 // FIXME: Why isn't wxUSE_POPUPWIN reliable any longer? (it was in wxW2.6.2)
 116 #if (!defined(__WXMSW__) && !defined(__WXGTK__)) || defined(__WXWINCE__)
 117 #undef wxUSE_POPUPWIN
 118 #define wxUSE_POPUPWIN 0
 119 #endif
 120
 121
 122 #if wxUSE_POPUPWIN
 123     #include "wx/popupwin.h"
 124 #else
 125     #undef USE_TRANSIENT_POPUP
 126     #define USE_TRANSIENT_POPUP 0
 127 #endif
 128
 129
 130 // Define different types of popup windows
 131 enum
 132 {
 133     POPUPWIN_NONE                   = 0,
 134     POPUPWIN_WXPOPUPTRANSIENTWINDOW = 1,
 135     POPUPWIN_WXPOPUPWINDOW          = 2,
 136     POPUPWIN_WXDIALOG               = 3
 137 };
 138
 139
 140 #if USE_TRANSIENT_POPUP
 141     // wxPopupTransientWindow is implemented
 142
 143     #define wxComboPopupWindowBase  wxPopupTransientWindow
 144     #define PRIMARY_POPUP_TYPE      POPUPWIN_WXPOPUPTRANSIENTWINDOW
 145     #define USES_WXPOPUPTRANSIENTWINDOW 1
 146
 147     #if TRANSIENT_POPUPWIN_IS_PERFECT
 148         //
 149     #elif POPUPWIN_IS_PERFECT
 150         #define wxComboPopupWindowBase2     wxPopupWindow
 151         #define SECONDARY_POPUP_TYPE        POPUPWIN_WXPOPUPWINDOW
 152         #define USES_WXPOPUPWINDOW          1
 153     #else
 154         #define wxComboPopupWindowBase2     wxDialog
 155         #define SECONDARY_POPUP_TYPE        POPUPWIN_WXDIALOG
 156         #define USES_WXDIALOG               1
 157     #endif
 158
 159 #elif wxUSE_POPUPWIN
 160     // wxPopupWindow (but not wxPopupTransientWindow) is properly implemented
 161
 162     #define wxComboPopupWindowBase      wxPopupWindow
 163     #define PRIMARY_POPUP_TYPE          POPUPWIN_WXPOPUPWINDOW
 164     #define USES_WXPOPUPWINDOW          1
 165
 166     #if !POPUPWIN_IS_PERFECT
 167         #define wxComboPopupWindowBase2     wxDialog
 168         #define SECONDARY_POPUP_TYPE        POPUPWIN_WXDIALOG
 169         #define USES_WXDIALOG               1
 170     #endif
 171
 172 #else
 173     // wxPopupWindow is not implemented
 174
 175     #define wxComboPopupWindowBase      wxDialog
 176     #define PRIMARY_POPUP_TYPE          POPUPWIN_WXDIALOG
 177     #define USES_WXDIALOG               1
 178
 179 #endif
 180
 181
 182 #ifndef USES_WXPOPUPTRANSIENTWINDOW
 183     #define USES_WXPOPUPTRANSIENTWINDOW 0
 184 #endif
 185
 186 #ifndef USES_WXPOPUPWINDOW
 187     #define USES_WXPOPUPWINDOW          0
 188 #endif
 189
 190 #ifndef USES_WXDIALOG
 191     #define USES_WXDIALOG               0
 192 #endif
 193
 194
 195 #if USES_WXPOPUPWINDOW
 196     #define INSTALL_TOPLEV_HANDLER      1
 197 #else
 198     #define INSTALL_TOPLEV_HANDLER      0
 199 #endif
 200
 201
 202 //
 203 // ** TODO **
 204 // * wxComboPopupWindow for external use (ie. replace old wxUniv wxPopupComboWindow)
 205 //
 206
 207
 208 // ----------------------------------------------------------------------------
 209 // wxComboFrameEventHandler takes care of hiding the popup when events happen
 210 // in its top level parent.
 211 // ----------------------------------------------------------------------------
 212
 213 #if INSTALL_TOPLEV_HANDLER
 214
 215 //
 216 // This will no longer be necessary after wxTransientPopupWindow
 217 // works well on all platforms.
 218 //
 219
 220 class wxComboFrameEventHandler : public wxEvtHandler
 221 {
 222 public:
 223     wxComboFrameEventHandler( wxComboCtrlBase* pCb );
 224     virtual ~wxComboFrameEventHandler();
 225
 226     void OnPopup();
 227
 228     void OnIdle( wxIdleEvent& event );
 229     void OnMouseEvent( wxMouseEvent& event );
 230     void OnActivate( wxActivateEvent& event );
 231     void OnResize( wxSizeEvent& event );
 232     void OnMove( wxMoveEvent& event );
 233     void OnMenuEvent( wxMenuEvent& event );
 234     void OnClose( wxCloseEvent& event );
 235
 236 protected:
 237     wxWindow*                       m_focusStart;
 238     wxComboCtrlBase*     m_combo;
 239
 240 private:
 241     DECLARE_EVENT_TABLE()
 242 };
 243
 244 BEGIN_EVENT_TABLE(wxComboFrameEventHandler, wxEvtHandler)
 245     EVT_IDLE(wxComboFrameEventHandler::OnIdle)
 246     EVT_LEFT_DOWN(wxComboFrameEventHandler::OnMouseEvent)
 247     EVT_RIGHT_DOWN(wxComboFrameEventHandler::OnMouseEvent)
 248     EVT_SIZE(wxComboFrameEventHandler::OnResize)
 249     EVT_MOVE(wxComboFrameEventHandler::OnMove)
 250     EVT_MENU_HIGHLIGHT(wxID_ANY,wxComboFrameEventHandler::OnMenuEvent)
 251     EVT_MENU_OPEN(wxComboFrameEventHandler::OnMenuEvent)
 252     EVT_ACTIVATE(wxComboFrameEventHandler::OnActivate)
 253     EVT_CLOSE(wxComboFrameEventHandler::OnClose)
 254 END_EVENT_TABLE()
 255
 256 wxComboFrameEventHandler::wxComboFrameEventHandler( wxComboCtrlBase* combo )
 257     : wxEvtHandler()
 258 {
 259     m_combo = combo;
 260 }
 261
 262 wxComboFrameEventHandler::~wxComboFrameEventHandler()
 263 {
 264 }
 265
 266 void wxComboFrameEventHandler::OnPopup()
 267 {
 268     m_focusStart = ::wxWindow::FindFocus();
 269 }
 270
 271 void wxComboFrameEventHandler::OnIdle( wxIdleEvent& event )
 272 {
 273     wxWindow* winFocused = ::wxWindow::FindFocus();
 274
 275     wxWindow* popup = m_combo->GetPopupControl()->GetControl();
 276     wxWindow* winpopup = m_combo->GetPopupWindow();
 277
 278     if (
 279          winFocused != m_focusStart &&
 280          winFocused != popup &&
 281          winFocused->GetParent() != popup &&
 282          winFocused != winpopup &&
 283          winFocused->GetParent() != winpopup &&
 284          winFocused != m_combo &&
 285          winFocused != m_combo->GetButton() // GTK (atleast) requires this
 286         )
 287     {
 288         m_combo->HidePopup();
 289     }
 290
 291     event.Skip();
 292 }
 293
 294 void wxComboFrameEventHandler::OnMenuEvent( wxMenuEvent& event )
 295 {
 296     m_combo->HidePopup();
 297     event.Skip();
 298 }
 299
 300 void wxComboFrameEventHandler::OnMouseEvent( wxMouseEvent& event )
 301 {
 302     m_combo->HidePopup();
 303     event.Skip();
 304 }
 305
 306 void wxComboFrameEventHandler::OnClose( wxCloseEvent& event )
 307 {
 308     m_combo->HidePopup();
 309     event.Skip();
 310 }
 311
 312 void wxComboFrameEventHandler::OnActivate( wxActivateEvent& event )
 313 {
 314     m_combo->HidePopup();
 315     event.Skip();
 316 }
 317
 318 void wxComboFrameEventHandler::OnResize( wxSizeEvent& event )
 319 {
 320     m_combo->HidePopup();
 321     event.Skip();
 322 }
 323
 324 void wxComboFrameEventHandler::OnMove( wxMoveEvent& event )
 325 {
 326     m_combo->HidePopup();
 327     event.Skip();
 328 }
 329
 330 #endif // INSTALL_TOPLEV_HANDLER
 331
 332 // ----------------------------------------------------------------------------
 333 // wxComboPopupWindow is, in essence, wxPopupWindow customized for
 334 // wxComboCtrl.
 335 // ----------------------------------------------------------------------------
 336
 337 class wxComboPopupWindow : public wxComboPopupWindowBase
 338 {
 339 public:
 340
 341     wxComboPopupWindow( wxComboCtrlBase *parent,
 342                         int style )
 343     #if USES_WXPOPUPWINDOW || USES_WXPOPUPTRANSIENTWINDOW
 344                        : wxComboPopupWindowBase(parent,style)
 345     #else
 346                        : wxComboPopupWindowBase(parent,
 347                                                 wxID_ANY,
 348                                                 wxEmptyString,
 349                                                 wxPoint(-21,-21),
 350                                                 wxSize(20,20),
 351                                                 style)
 352     #endif
 353     {
 354         m_inShow = 0;
 355     }
 356
 357 #if USES_WXPOPUPTRANSIENTWINDOW
 358     virtual bool Show( bool show );
 359     virtual bool ProcessLeftDown(wxMouseEvent& event);
 360 protected:
 361     virtual void OnDismiss();
 362 #endif
 363
 364 private:
 365     wxByte      m_inShow;
 366 };
 367
 368
 369 #if USES_WXPOPUPTRANSIENTWINDOW
 370 bool wxComboPopupWindow::Show( bool show )
 371 {
 372     // Guard against recursion
 373     if ( m_inShow )
 374         return wxComboPopupWindowBase::Show(show);
 375
 376     m_inShow++;
 377
 378     wxASSERT( IsKindOf(CLASSINFO(wxPopupTransientWindow)) );
 379
 380     wxPopupTransientWindow* ptw = (wxPopupTransientWindow*) this;
 381
 382     if ( show != ptw->IsShown() )
 383     {
 384         if ( show )
 385             // We used to do wxPopupTransientWindow::Popup here,
 386             // but this would hide normal Show, which we are
 387             // also going to need.
 388             ptw->Show();
 389         else
 390             ptw->Dismiss();
 391     }
 392
 393     m_inShow--;
 394
 395     return true;
 396 }
 397
 398 bool wxComboPopupWindow::ProcessLeftDown(wxMouseEvent& event)
 399 {
 400     return wxPopupTransientWindow::ProcessLeftDown(event);
 401 }
 402
 403 // First thing that happens when a transient popup closes is that this method gets called.
 404 void wxComboPopupWindow::OnDismiss()
 405 {
 406     wxComboCtrlBase* combo = (wxComboCtrlBase*) GetParent();
 407     wxASSERT_MSG( combo->IsKindOf(CLASSINFO(wxComboCtrlBase)),
 408                   wxT("parent might not be wxComboCtrl, but check IMPLEMENT_DYNAMIC_CLASS(2) macro for correctness") );
 409
 410     combo->OnPopupDismiss();
 411 }
 412 #endif // USES_WXPOPUPTRANSIENTWINDOW
 413
 414
 415 // ----------------------------------------------------------------------------
 416 // wxComboPopupWindowEvtHandler does bulk of the custom event handling
 417 // of a popup window. It is separate so we can have different types
 418 // of popup windows.
 419 // ----------------------------------------------------------------------------
 420
 421 class wxComboPopupWindowEvtHandler : public wxEvtHandler
 422 {
 423 public:
 424
 425     wxComboPopupWindowEvtHandler( wxComboCtrlBase *parent )
 426     {
 427         m_combo = parent;
 428     }
 429
 430     void OnSizeEvent( wxSizeEvent& event );
 431     void OnKeyEvent(wxKeyEvent& event);
 432 #if USES_WXDIALOG
 433     void OnActivate( wxActivateEvent& event );
 434 #endif
 435
 436 private:
 437     wxComboCtrlBase*    m_combo;
 438
 439     DECLARE_EVENT_TABLE()
 440 };
 441
 442
 443 BEGIN_EVENT_TABLE(wxComboPopupWindowEvtHandler, wxEvtHandler)
 444     EVT_KEY_DOWN(wxComboPopupWindowEvtHandler::OnKeyEvent)
 445     EVT_KEY_UP(wxComboPopupWindowEvtHandler::OnKeyEvent)
 446 #if USES_WXDIALOG
 447     EVT_ACTIVATE(wxComboPopupWindowEvtHandler::OnActivate)
 448 #endif
 449     EVT_SIZE(wxComboPopupWindowEvtHandler::OnSizeEvent)
 450 END_EVENT_TABLE()
 451
 452
 453 void wxComboPopupWindowEvtHandler::OnSizeEvent( wxSizeEvent& WXUNUSED(event) )
 454 {
 455     // Block the event so that the popup control does not get auto-resized.
 456 }
 457
 458 void wxComboPopupWindowEvtHandler::OnKeyEvent( wxKeyEvent& event )
 459 {
 460     // Relay keyboard event to the main child controls
 461     wxWindowList children = m_combo->GetPopupWindow()->GetChildren();
 462     wxWindowList::iterator node = children.begin();
 463     wxWindow* child = (wxWindow*)*node;
 464     child->AddPendingEvent(event);
 465 }
 466
 467 #if USES_WXDIALOG
 468 void wxComboPopupWindowEvtHandler::OnActivate( wxActivateEvent& event )
 469 {
 470     if ( !event.GetActive() )
 471     {
 472         // Tell combo control that we are dismissed.
 473         m_combo->HidePopup();
 474
 475         event.Skip();
 476     }
 477 }
 478 #endif
 479
 480
 481 // ----------------------------------------------------------------------------
 482 // wxComboPopup
 483 //
 484 // ----------------------------------------------------------------------------
 485
 486 wxComboPopup::~wxComboPopup()
 487 {
 488 }
 489
 490 void wxComboPopup::OnPopup()
 491 {
 492 }
 493
 494 void wxComboPopup::OnDismiss()
 495 {
 496 }
 497
 498 wxSize wxComboPopup::GetAdjustedSize( int minWidth,
 499                                       int prefHeight,
 500                                       int WXUNUSED(maxHeight) )
 501 {
 502     return wxSize(minWidth,prefHeight);
 503 }
 504
 505 void wxComboPopup::DefaultPaintComboControl( wxComboCtrlBase* combo,
 506                                              wxDC& dc, const wxRect& rect )
 507 {
 508     if ( combo->GetWindowStyle() & wxCB_READONLY ) // ie. no textctrl
 509     {
 510         combo->PrepareBackground(dc,rect,0);
 511
 512         dc.DrawText( combo->GetValue(),
 513                      rect.x + combo->GetTextIndent(),
 514                      (rect.height-dc.GetCharHeight())/2 + rect.y );
 515     }
 516 }
 517
 518 void wxComboPopup::PaintComboControl( wxDC& dc, const wxRect& rect )
 519 {
 520     DefaultPaintComboControl(m_combo,dc,rect);
 521 }
 522
 523 void wxComboPopup::OnComboKeyEvent( wxKeyEvent& event )
 524 {
 525     event.Skip();
 526 }
 527
 528 void wxComboPopup::OnComboDoubleClick()
 529 {
 530 }
 531
 532 void wxComboPopup::SetStringValue( const wxString& WXUNUSED(value) )
 533 {
 534 }
 535
 536 bool wxComboPopup::LazyCreate()
 537 {
 538     return false;
 539 }
 540
 541 void wxComboPopup::Dismiss()
 542 {
 543     m_combo->HidePopup();
 544 }
 545
 546 // ----------------------------------------------------------------------------
 547 // input handling
 548 // ----------------------------------------------------------------------------
 549
 550 //
 551 // This is pushed to the event handler queue of the child textctrl.
 552 //
 553 class wxComboBoxExtraInputHandler : public wxEvtHandler
 554 {
 555 public:
 556
 557     wxComboBoxExtraInputHandler( wxComboCtrlBase* combo )
 558         : wxEvtHandler()
 559     {
 560         m_combo = combo;
 561     }
 562     virtual ~wxComboBoxExtraInputHandler() { }
 563     void OnKey(wxKeyEvent& event);
 564     void OnFocus(wxFocusEvent& event);
 565
 566 protected:
 567     wxComboCtrlBase*   m_combo;
 568
 569 private:
 570     DECLARE_EVENT_TABLE()
 571 };
 572
 573
 574 BEGIN_EVENT_TABLE(wxComboBoxExtraInputHandler, wxEvtHandler)
 575     EVT_KEY_DOWN(wxComboBoxExtraInputHandler::OnKey)
 576     EVT_SET_FOCUS(wxComboBoxExtraInputHandler::OnFocus)
 577     EVT_KILL_FOCUS(wxComboBoxExtraInputHandler::OnFocus)
 578 END_EVENT_TABLE()
 579
 580
 581 void wxComboBoxExtraInputHandler::OnKey(wxKeyEvent& event)
 582 {
 583     // Let the wxComboCtrl event handler have a go first.
 584     wxComboCtrlBase* combo = m_combo;
 585     wxObject* prevObj = event.GetEventObject();
 586
 587     event.SetId(combo->GetId());
 588     event.SetEventObject(combo);
 589     combo->GetEventHandler()->ProcessEvent(event);
 590
 591     event.SetId(((wxWindow*)prevObj)->GetId());
 592     event.SetEventObject(prevObj);
 593 }
 594
 595 void wxComboBoxExtraInputHandler::OnFocus(wxFocusEvent& event)
 596 {
 597     // FIXME: This code does run when control is clicked,
 598     //        yet on Windows it doesn't select all the text.
 599     if ( event.GetEventType() == wxEVT_SET_FOCUS &&
 600         !(m_combo->GetInternalFlags() & wxCC_NO_TEXT_AUTO_SELECT) )
 601     {
 602         if ( m_combo->GetTextCtrl() )
 603             m_combo->GetTextCtrl()->SelectAll();
 604         else
 605             m_combo->SetSelection(-1,-1);
 606     }
 607
 608     // Send focus indication to parent.
 609     // NB: This is needed for cases where the textctrl gets focus
 610     //     instead of its parent. While this may trigger multiple
 611     //     wxEVT_SET_FOCUSes (since m_text->SetFocus is called
 612     //     from combo's focus event handler), they should be quite
 613     //     harmless.
 614     wxFocusEvent evt2(event.GetEventType(),m_combo->GetId());
 615     evt2.SetEventObject(m_combo);
 616     m_combo->GetEventHandler()->ProcessEvent(evt2);
 617
 618     event.Skip();
 619 }
 620
 621
 622 //
 623 // This is pushed to the event handler queue of the control in popup.
 624 //
 625
 626 class wxComboPopupExtraEventHandler : public wxEvtHandler
 627 {
 628 public:
 629
 630     wxComboPopupExtraEventHandler( wxComboCtrlBase* combo )
 631         : wxEvtHandler()
 632     {
 633         m_combo = combo;
 634         m_beenInside = false;
 635     }
 636     virtual ~wxComboPopupExtraEventHandler() { }
 637
 638     void OnMouseEvent( wxMouseEvent& event );
 639
 640     // Called from wxComboCtrlBase::OnPopupDismiss
 641     void OnPopupDismiss()
 642     {
 643         m_beenInside = false;
 644     }
 645
 646 protected:
 647     wxComboCtrlBase*     m_combo;
 648
 649     bool                    m_beenInside;
 650
 651 private:
 652     DECLARE_EVENT_TABLE()
 653 };
 654
 655
 656 BEGIN_EVENT_TABLE(wxComboPopupExtraEventHandler, wxEvtHandler)
 657     EVT_MOUSE_EVENTS(wxComboPopupExtraEventHandler::OnMouseEvent)
 658 END_EVENT_TABLE()
 659
 660
 661 void wxComboPopupExtraEventHandler::OnMouseEvent( wxMouseEvent& event )
 662 {
 663     wxPoint pt = event.GetPosition();
 664     wxSize sz = m_combo->GetPopupControl()->GetControl()->GetClientSize();
 665     int evtType = event.GetEventType();
 666     bool isInside = pt.x >= 0 && pt.y >= 0 && pt.x < sz.x && pt.y < sz.y;
 667     bool relayToButton = false;
 668
 669     event.Skip();
 670
 671     if ( evtType == wxEVT_MOTION ||
 672          evtType == wxEVT_LEFT_DOWN ||
 673          evtType == wxEVT_RIGHT_DOWN )
 674     {
 675         // Block motion and click events outside the popup
 676         if ( !isInside || !m_combo->IsPopupShown() )
 677         {
 678             event.Skip(false);
 679         }
 680     }
 681     else if ( evtType == wxEVT_LEFT_UP )
 682     {
 683         if ( !m_combo->IsPopupShown() )
 684         {
 685             event.Skip(false);
 686             relayToButton = true;
 687         }
 688         else if ( !m_beenInside )
 689         {
 690             if ( isInside )
 691             {
 692                 m_beenInside = true;
 693             }
 694             else
 695             {
 696                 relayToButton = true;
 697             }
 698         }
 699     }
 700
 701     if ( relayToButton )
 702     {
 703         //
 704         // Some mouse events to popup that happen outside it, before cursor
 705         // has been inside the popup, need to be ignored by it but relayed to
 706         // the dropbutton.
 707         //
 708         wxWindow* eventSink = m_combo;
 709         wxWindow* btn = m_combo->GetButton();
 710         if ( btn )
 711             eventSink = btn;
 712
 713         eventSink->GetEventHandler()->ProcessEvent(event);
 714     }
 715 }
 716
 717 // ----------------------------------------------------------------------------
 718 // wxComboCtrlTextCtrl
 719 // ----------------------------------------------------------------------------
 720
 721 class wxComboCtrlTextCtrl : public wxTextCtrl
 722 {
 723 public:
 724     wxComboCtrlTextCtrl() : wxTextCtrl() { }
 725     virtual ~wxComboCtrlTextCtrl() { }
 726
 727     virtual wxWindow *GetMainWindowOfCompositeControl()
 728     {
 729         wxComboCtrl* combo = (wxComboCtrl*) GetParent();
 730
 731         // Returning this instead of just 'parent' lets FindFocus work
 732         // correctly even when parent control is a child of a composite
 733         // generic control (as is case with wxGenericDatePickerCtrl).
 734         return combo->GetMainWindowOfCompositeControl();
 735     }
 736 };
 737
 738 // ----------------------------------------------------------------------------
 739 // wxComboCtrlBase
 740 // ----------------------------------------------------------------------------
 741
 742
 743 BEGIN_EVENT_TABLE(wxComboCtrlBase, wxControl)
 744     EVT_TEXT(wxID_ANY,wxComboCtrlBase::OnTextCtrlEvent)
 745     EVT_SIZE(wxComboCtrlBase::OnSizeEvent)
 746     EVT_SET_FOCUS(wxComboCtrlBase::OnFocusEvent)
 747     EVT_KILL_FOCUS(wxComboCtrlBase::OnFocusEvent)
 748     EVT_IDLE(wxComboCtrlBase::OnIdleEvent)
 749     //EVT_BUTTON(wxID_ANY,wxComboCtrlBase::OnButtonClickEvent)
 750     EVT_KEY_DOWN(wxComboCtrlBase::OnKeyEvent)
 751     EVT_TEXT_ENTER(wxID_ANY,wxComboCtrlBase::OnTextCtrlEvent)
 752     EVT_SYS_COLOUR_CHANGED(wxComboCtrlBase::OnSysColourChanged)
 753 END_EVENT_TABLE()
 754
 755
 756 IMPLEMENT_ABSTRACT_CLASS(wxComboCtrlBase, wxControl)
 757
 758 void wxComboCtrlBase::Init()
 759 {
 760     m_winPopup = (wxWindow *)NULL;
 761     m_popup = (wxWindow *)NULL;
 762     m_popupWinState = Hidden;
 763     m_btn = (wxWindow*) NULL;
 764     m_text = (wxTextCtrl*) NULL;
 765     m_popupInterface = (wxComboPopup*) NULL;
 766
 767     m_popupExtraHandler = (wxEvtHandler*) NULL;
 768     m_textEvtHandler = (wxEvtHandler*) NULL;
 769
 770 #if INSTALL_TOPLEV_HANDLER
 771     m_toplevEvtHandler = (wxEvtHandler*) NULL;
 772 #endif
 773
 774     m_mainCtrlWnd = this;
 775
 776     m_heightPopup = -1;
 777     m_widthMinPopup = -1;
 778     m_anchorSide = 0;
 779     m_widthCustomPaint = 0;
 780     m_widthCustomBorder = 0;
 781
 782     m_btnState = 0;
 783     m_btnWidDefault = 0;
 784     m_blankButtonBg = false;
 785     m_ignoreEvtText = 0;
 786     m_popupWinType = POPUPWIN_NONE;
 787     m_btnWid = m_btnHei = -1;
 788     m_btnSide = wxRIGHT;
 789     m_btnSpacingX = 0;
 790
 791     m_extLeft = 0;
 792     m_extRight = 0;
 793     m_absIndent = -1;
 794     m_iFlags = 0;
 795     m_timeCanAcceptClick = 0;
 796
 797     m_resetFocus = false;
 798 }
 799
 800 bool wxComboCtrlBase::Create(wxWindow *parent,
 801                              wxWindowID id,
 802                              const wxString& value,
 803                              const wxPoint& pos,
 804                              const wxSize& size,
 805                              long style,
 806                              const wxValidator& validator,
 807                              const wxString& name)
 808 {
 809     if ( !wxControl::Create(parent,
 810                             id,
 811                             pos,
 812                             size,
 813                             style | wxWANTS_CHARS,
 814                             validator,
 815                             name) )
 816         return false;
 817
 818     m_valueString = value;
 819
 820     // Get colours
 821     OnThemeChange();
 822     m_absIndent = GetNativeTextIndent();
 823
 824     m_iFlags |= wxCC_IFLAG_CREATED;
 825
 826     // If x and y indicate valid size, wxSizeEvent won't be
 827     // emitted automatically, so we need to add artifical one.
 828     if ( size.x > 0 && size.y > 0 )
 829     {
 830         wxSizeEvent evt(size,GetId());
 831         GetEventHandler()->AddPendingEvent(evt);
 832     }
 833
 834     return true;
 835 }
 836
 837 void wxComboCtrlBase::InstallInputHandlers()
 838 {
 839     if ( m_text )
 840     {
 841         m_textEvtHandler = new wxComboBoxExtraInputHandler(this);
 842         m_text->PushEventHandler(m_textEvtHandler);
 843     }
 844 }
 845
 846 void
 847 wxComboCtrlBase::CreateTextCtrl(int style, const wxValidator& validator)
 848 {
 849     if ( !(m_windowStyle & wxCB_READONLY) )
 850     {
 851         if ( m_text )
 852             m_text->Destroy();
 853
 854         // wxTE_PROCESS_TAB is needed because on Windows, wxTAB_TRAVERSAL is
 855         // not used by the wxPropertyGrid and therefore the tab is processed by
 856         // looking at ancestors to see if they have wxTAB_TRAVERSAL. The
 857         // navigation event is then sent to the wrong window.
 858         style |= wxTE_PROCESS_TAB;
 859
 860         if ( HasFlag(wxTE_PROCESS_ENTER) )
 861             style |= wxTE_PROCESS_ENTER;
 862
 863         // Ignore EVT_TEXT generated by the constructor (but only
 864         // if the event redirector already exists)
 865         // NB: This must be " = 1" instead of "++";
 866         if ( m_textEvtHandler )
 867             m_ignoreEvtText = 1;
 868         else
 869             m_ignoreEvtText = 0;
 870
 871         m_text = new wxComboCtrlTextCtrl();
 872         m_text->Create(this, wxID_ANY, m_valueString,
 873                        wxDefaultPosition, wxSize(10,-1),
 874                        style, validator);
 875     }
 876 }
 877
 878 void wxComboCtrlBase::OnThemeChange()
 879 {
 880     // Leave the default bg on the Mac so the area used by the focus ring will
 881     // be the correct colour and themed brush.  Instead we'll use
 882     // wxSYS_COLOUR_WINDOW in the EVT_PAINT handler as needed.
 883 #ifndef __WXMAC__
 884     SetOwnBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
 885 #endif
 886 }
 887
 888 wxComboCtrlBase::~wxComboCtrlBase()
 889 {
 890     if ( HasCapture() )
 891         ReleaseMouse();
 892
 893 #if INSTALL_TOPLEV_HANDLER
 894     delete ((wxComboFrameEventHandler*)m_toplevEvtHandler);
 895     m_toplevEvtHandler = (wxEvtHandler*) NULL;
 896 #endif
 897
 898     DestroyPopup();
 899
 900     if ( m_text )
 901         m_text->RemoveEventHandler(m_textEvtHandler);
 902
 903     delete m_textEvtHandler;
 904 }
 905
 906
 907 // ----------------------------------------------------------------------------
 908 // geometry stuff
 909 // ----------------------------------------------------------------------------
 910
 911 // Recalculates button and textctrl areas
 912 void wxComboCtrlBase::CalculateAreas( int btnWidth )
 913 {
 914     wxSize sz = GetClientSize();
 915     int customBorder = m_widthCustomBorder;
 916     int btnBorder; // border for button only
 917
 918     // check if button should really be outside the border: we'll do it it if
 919     // its platform default or bitmap+pushbutton background is used, but not if
 920     // there is vertical size adjustment or horizontal spacing.
 921     if ( ( (m_iFlags & wxCC_BUTTON_OUTSIDE_BORDER) ||
 922                 (m_bmpNormal.Ok() && m_blankButtonBg) ) &&
 923          m_btnSpacingX == 0 &&
 924          m_btnHei <= 0 )
 925     {
 926         m_iFlags |= wxCC_IFLAG_BUTTON_OUTSIDE;
 927         btnBorder = 0;
 928     }
 929     else if ( (m_iFlags & wxCC_BUTTON_COVERS_BORDER) &&
 930               m_btnSpacingX == 0 && !m_bmpNormal.Ok() )
 931     {
 932         m_iFlags &= ~(wxCC_IFLAG_BUTTON_OUTSIDE);
 933         btnBorder = 0;
 934     }
 935     else
 936     {
 937         m_iFlags &= ~(wxCC_IFLAG_BUTTON_OUTSIDE);
 938         btnBorder = customBorder;
 939     }
 940
 941     // Defaul indentation
 942     if ( m_absIndent < 0 )
 943         m_absIndent = GetNativeTextIndent();
 944
 945     int butWidth = btnWidth;
 946
 947     if ( butWidth <= 0 )
 948         butWidth = m_btnWidDefault;
 949     else
 950         m_btnWidDefault = butWidth;
 951
 952     if ( butWidth <= 0 )
 953         return;
 954
 955     int butHeight = sz.y - btnBorder*2;
 956
 957     // Adjust button width
 958     if ( m_btnWid > 0 )
 959         butWidth = m_btnWid;
 960     else
 961     {
 962         // Adjust button width to match aspect ratio
 963         // (but only if control is smaller than best size).
 964         int bestHeight = GetBestSize().y;
 965         int height = GetSize().y;
 966
 967         if ( height < bestHeight )
 968         {
 969             // Make very small buttons square, as it makes
 970             // them accommodate arrow image better and still
 971             // looks decent.
 972             if ( height > 18 )
 973                 butWidth = (height*butWidth)/bestHeight;
 974             else
 975                 butWidth = butHeight;
 976         }
 977     }
 978
 979     // Adjust button height
 980     if ( m_btnHei > 0 )
 981         butHeight = m_btnHei;
 982
 983     // Use size of normal bitmap if...
 984     //   It is larger
 985     //   OR
 986     //   button width is set to default and blank button bg is not drawn
 987     if ( m_bmpNormal.Ok() )
 988     {
 989         int bmpReqWidth = m_bmpNormal.GetWidth();
 990         int bmpReqHeight = m_bmpNormal.GetHeight();
 991
 992         // If drawing blank button background, we need to add some margin.
 993         if ( m_blankButtonBg )
 994         {
 995             bmpReqWidth += BMP_BUTTON_MARGIN*2;
 996             bmpReqHeight += BMP_BUTTON_MARGIN*2;
 997         }
 998
 999         if ( butWidth < bmpReqWidth || ( m_btnWid == 0 && !m_blankButtonBg ) )
1000             butWidth = bmpReqWidth;
1001         if ( butHeight < bmpReqHeight || ( m_btnHei == 0 && !m_blankButtonBg ) )
1002             butHeight = bmpReqHeight;
1003
1004         // Need to fix height?
1005         if ( (sz.y-(customBorder*2)) < butHeight && btnWidth == 0 )
1006         {
1007             int newY = butHeight+(customBorder*2);
1008             SetClientSize(wxDefaultCoord,newY);
1009             if ( m_bmpNormal.Ok() || m_btnArea.width != butWidth || m_btnArea.height != butHeight )
1010                 m_iFlags |= wxCC_IFLAG_HAS_NONSTANDARD_BUTTON;
1011             else
1012                 m_iFlags &= ~wxCC_IFLAG_HAS_NONSTANDARD_BUTTON;
1013
1014             sz.y = newY;
1015         }
1016     }
1017
1018     int butAreaWid = butWidth + (m_btnSpacingX*2);
1019
1020     m_btnSize.x = butWidth;
1021     m_btnSize.y = butHeight;
1022
1023     m_btnArea.x = ( m_btnSide==wxRIGHT ? sz.x - butAreaWid - btnBorder : btnBorder );
1024     m_btnArea.y = btnBorder + FOCUS_RING;
1025     m_btnArea.width = butAreaWid;
1026     m_btnArea.height = sz.y - ((btnBorder+FOCUS_RING)*2);
1027
1028     m_tcArea.x = ( m_btnSide==wxRIGHT ? 0 : butAreaWid ) + customBorder + FOCUS_RING;
1029     m_tcArea.y = customBorder + FOCUS_RING;
1030     m_tcArea.width = sz.x - butAreaWid - (customBorder*2) - (FOCUS_RING*2);
1031     m_tcArea.height = sz.y - ((customBorder+FOCUS_RING)*2);
1032
1033 /*
1034     if ( m_text )
1035     {
1036         ::wxMessageBox(wxString::Format(wxT("ButtonArea (%i,%i,%i,%i)\n"),m_btnArea.x,m_btnArea.y,m_btnArea.width,m_btnArea.height) +
1037                        wxString::Format(wxT("TextCtrlArea (%i,%i,%i,%i)"),m_tcArea.x,m_tcArea.y,m_tcArea.width,m_tcArea.height));
1038     }
1039 */
1040 }
1041
1042 void wxComboCtrlBase::PositionTextCtrl( int textCtrlXAdjust, int textCtrlYAdjust )
1043 {
1044     if ( !m_text )
1045         return;
1046
1047 #if !TEXTCTRL_TEXT_CENTERED
1048
1049     wxSize sz = GetClientSize();
1050
1051     int customBorder = m_widthCustomBorder;
1052     if ( (m_text->GetWindowStyleFlag() & wxBORDER_MASK) == wxNO_BORDER )
1053     {
1054         // Centre textctrl
1055         int tcSizeY = m_text->GetBestSize().y;
1056         int diff = sz.y - tcSizeY;
1057         int y = textCtrlYAdjust + (diff/2);
1058
1059         if ( y < customBorder )
1060             y = customBorder;
1061
1062         m_text->SetSize( m_tcArea.x + m_widthCustomPaint + m_absIndent + textCtrlXAdjust,
1063                          y,
1064                          m_tcArea.width - COMBO_MARGIN -
1065                          (textCtrlXAdjust + m_widthCustomPaint + m_absIndent),
1066                          -1 );
1067
1068         // Make sure textctrl doesn't exceed the bottom custom border
1069         wxSize tsz = m_text->GetSize();
1070         diff = (y + tsz.y) - (sz.y - customBorder);
1071         if ( diff >= 0 )
1072         {
1073             tsz.y = tsz.y - diff - 1;
1074             m_text->SetSize(tsz);
1075         }
1076     }
1077     else
1078 #else // TEXTCTRL_TEXT_CENTERED
1079     wxUnusedVar(textCtrlXAdjust);
1080     wxUnusedVar(textCtrlYAdjust);
1081 #endif // !TEXTCTRL_TEXT_CENTERED/TEXTCTRL_TEXT_CENTERED
1082     {
1083         // If it has border, have textctrl will the entire text field.
1084         m_text->SetSize( m_tcArea.x + m_widthCustomPaint,
1085                          m_tcArea.y,
1086                          m_tcArea.width - m_widthCustomPaint,
1087                          m_tcArea.height );
1088     }
1089 }
1090
1091 wxSize wxComboCtrlBase::DoGetBestSize() const
1092 {
1093     wxSize sizeText(150,0);
1094
1095     if ( m_text )
1096         sizeText = m_text->GetBestSize();
1097
1098     // TODO: Better method to calculate close-to-native control height.
1099
1100     int fhei;
1101     if ( m_font.Ok() )
1102         fhei = (m_font.GetPointSize()*2) + 5;
1103     else if ( wxNORMAL_FONT->Ok() )
1104         fhei = (wxNORMAL_FONT->GetPointSize()*2) + 5;
1105     else
1106         fhei = sizeText.y + 4;
1107
1108     // Need to force height to accomodate bitmap?
1109     int btnSizeY = m_btnSize.y;
1110     if ( m_bmpNormal.Ok() && fhei < btnSizeY )
1111         fhei = btnSizeY;
1112
1113     // Control height doesn't depend on border
1114 /*
1115     // Add border
1116     int border = m_windowStyle & wxBORDER_MASK;
1117     if ( border == wxSIMPLE_BORDER )
1118         fhei += 2;
1119     else if ( border == wxNO_BORDER )
1120         fhei += (m_widthCustomBorder*2);
1121     else
1122         // Sunken etc.
1123         fhei += 4;
1124 */
1125
1126     // Final adjustments
1127 #ifdef __WXGTK__
1128     fhei += 1;
1129 #endif
1130
1131 #ifdef __WXMAC__
1132     // these are the numbers from the HIG:
1133     switch ( m_windowVariant )
1134     {
1135         case wxWINDOW_VARIANT_NORMAL:
1136         default :
1137             fhei = 22;
1138             break;
1139         case wxWINDOW_VARIANT_SMALL:
1140             fhei = 19;
1141             break;
1142         case wxWINDOW_VARIANT_MINI:
1143             fhei = 15;
1144             break;
1145     }
1146 #endif
1147
1148     fhei += 2 * FOCUS_RING;
1149     int width = sizeText.x + FOCUS_RING + COMBO_MARGIN + DEFAULT_DROPBUTTON_WIDTH;
1150
1151     wxSize ret(width, fhei);
1152     CacheBestSize(ret);
1153     return ret;
1154 }
1155
1156 void wxComboCtrlBase::OnSizeEvent( wxSizeEvent& event )
1157 {
1158     if ( !IsCreated() )
1159         return;
1160
1161     // defined by actual wxComboCtrls
1162     OnResize();
1163
1164     event.Skip();
1165 }
1166
1167 // ----------------------------------------------------------------------------
1168 // standard operations
1169 // ----------------------------------------------------------------------------
1170
1171 bool wxComboCtrlBase::Enable(bool enable)
1172 {
1173     if ( !wxControl::Enable(enable) )
1174         return false;
1175
1176     if ( m_btn )
1177         m_btn->Enable(enable);
1178     if ( m_text )
1179         m_text->Enable(enable);
1180
1181     return true;
1182 }
1183
1184 bool wxComboCtrlBase::Show(bool show)
1185 {
1186     if ( !wxControl::Show(show) )
1187         return false;
1188
1189     if (m_btn)
1190         m_btn->Show(show);
1191
1192     if (m_text)
1193         m_text->Show(show);
1194
1195     return true;
1196 }
1197
1198 bool wxComboCtrlBase::SetFont ( const wxFont& font )
1199 {
1200     if ( !wxControl::SetFont(font) )
1201         return false;
1202
1203     if (m_text)
1204         m_text->SetFont(font);
1205
1206     return true;
1207 }
1208
1209 #if wxUSE_TOOLTIPS
1210 void wxComboCtrlBase::DoSetToolTip(wxToolTip *tooltip)
1211 {
1212     wxControl::DoSetToolTip(tooltip);
1213
1214     // Set tool tip for button and text box
1215     if ( tooltip )
1216     {
1217         const wxString &tip = tooltip->GetTip();
1218         if ( m_text ) m_text->SetToolTip(tip);
1219         if ( m_btn ) m_btn->SetToolTip(tip);
1220     }
1221     else
1222     {
1223         if ( m_text ) m_text->SetToolTip( (wxToolTip*) NULL );
1224         if ( m_btn ) m_btn->SetToolTip( (wxToolTip*) NULL );
1225     }
1226 }
1227 #endif // wxUSE_TOOLTIPS
1228
1229 #if wxUSE_VALIDATORS
1230 void wxComboCtrlBase::SetValidator(const wxValidator& validator)
1231 {
1232     wxTextCtrl* textCtrl = GetTextCtrl();
1233
1234     if ( textCtrl )
1235         textCtrl->SetValidator( validator );
1236 }
1237
1238 wxValidator* wxComboCtrlBase::GetValidator()
1239 {
1240     wxTextCtrl* textCtrl = GetTextCtrl();
1241
1242     if ( textCtrl )
1243         return textCtrl->GetValidator();
1244
1245     return wxControl::GetValidator();
1246 }
1247 #endif // wxUSE_VALIDATORS
1248
1249 // ----------------------------------------------------------------------------
1250 // painting
1251 // ----------------------------------------------------------------------------
1252
1253 #if (!defined(__WXMSW__)) || defined(__WXUNIVERSAL__)
1254 // prepare combo box background on area in a way typical on platform
1255 void wxComboCtrlBase::PrepareBackground( wxDC& dc, const wxRect& rect, int flags ) const
1256 {
1257     wxSize sz = GetClientSize();
1258     bool isEnabled;
1259     bool doDrawFocusRect; // also selected
1260
1261     // For smaller size control (and for disabled background) use less spacing
1262     int focusSpacingX;
1263     int focusSpacingY;
1264
1265     if ( !(flags & wxCONTROL_ISSUBMENU) )
1266     {
1267         // Drawing control
1268         isEnabled = IsEnabled();
1269         doDrawFocusRect = ShouldDrawFocus() && !(m_iFlags & wxCC_FULL_BUTTON);
1270
1271         // Windows-style: for smaller size control (and for disabled background) use less spacing
1272         focusSpacingX = isEnabled ? 2 : 1;
1273         focusSpacingY = sz.y > (GetCharHeight()+2) && isEnabled ? 2 : 1;
1274     }
1275     else
1276     {
1277         // Drawing a list item
1278         isEnabled = true; // they are never disabled
1279         doDrawFocusRect = (flags & wxCONTROL_SELECTED) != 0;
1280
1281         focusSpacingX = 0;
1282         focusSpacingY = 0;
1283     }
1284
1285     // Set the background sub-rectangle for selection, disabled etc
1286     wxRect selRect(rect);
1287     selRect.y += focusSpacingY;
1288     selRect.height -= (focusSpacingY*2);
1289
1290     int wcp = 0;
1291
1292     if ( !(flags & wxCONTROL_ISSUBMENU) )
1293         wcp += m_widthCustomPaint;
1294
1295     selRect.x += wcp + focusSpacingX;
1296     selRect.width -= wcp + (focusSpacingX*2);
1297
1298     wxColour bgCol;
1299     bool doDrawSelRect = true;
1300
1301     if ( isEnabled )
1302     {
1303         // If popup is hidden and this control is focused,
1304         // then draw the focus-indicator (selbgcolor background etc.).
1305         if ( doDrawFocusRect )
1306         {
1307             dc.SetTextForeground( wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT) );
1308             bgCol = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
1309         }
1310         else
1311         {
1312             dc.SetTextForeground( wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT) );
1313 #ifndef __WXMAC__  // see note in OnThemeChange
1314             doDrawSelRect = false;
1315             bgCol = GetBackgroundColour();
1316 #else
1317             bgCol = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW);
1318 #endif
1319         }
1320     }
1321     else
1322     {
1323         dc.SetTextForeground( wxSystemSettings::GetColour(wxSYS_COLOUR_GRAYTEXT) );
1324 #ifndef __WXMAC__  // see note in OnThemeChange
1325         bgCol = GetBackgroundColour();
1326 #else
1327         bgCol = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW);
1328 #endif
1329     }
1330
1331     dc.SetBrush( bgCol );
1332     if ( doDrawSelRect )
1333     {
1334         dc.SetPen( bgCol );
1335         dc.DrawRectangle( selRect );
1336     }
1337
1338     // Don't clip exactly to the selection rectangle so we can draw
1339     // to the non-selected area in front of it.
1340     wxRect clipRect(rect.x,rect.y,
1341                     (selRect.x+selRect.width)-rect.x,rect.height);
1342     dc.SetClippingRegion(clipRect);
1343 }
1344 #else
1345 // Save the library size a bit for platforms that re-implement this.
1346 void wxComboCtrlBase::PrepareBackground( wxDC&, const wxRect&, int ) const
1347 {
1348 }
1349 #endif
1350
1351 void wxComboCtrlBase::DrawButton( wxDC& dc, const wxRect& rect, int flags )
1352 {
1353     int drawState = m_btnState;
1354
1355     if ( (m_iFlags & wxCC_BUTTON_STAYS_DOWN) &&
1356          GetPopupWindowState() >= Animating )
1357         drawState |= wxCONTROL_PRESSED;
1358
1359     wxRect drawRect(rect.x+m_btnSpacingX,
1360                     rect.y+((rect.height-m_btnSize.y)/2),
1361                     m_btnSize.x,
1362                     m_btnSize.y);
1363
1364     // Make sure area is not larger than the control
1365     if ( drawRect.y < rect.y )
1366         drawRect.y = rect.y;
1367     if ( drawRect.height > rect.height )
1368         drawRect.height = rect.height;
1369
1370     bool enabled = IsEnabled();
1371
1372     if ( !enabled )
1373         drawState |= wxCONTROL_DISABLED;
1374
1375     if ( !m_bmpNormal.Ok() )
1376     {
1377         if ( flags & Button_BitmapOnly )
1378             return;
1379
1380         // Need to clear button background even if m_btn is present
1381         if ( flags & Button_PaintBackground )
1382         {
1383             wxColour bgCol;
1384
1385             if ( m_iFlags & wxCC_IFLAG_BUTTON_OUTSIDE )
1386                 bgCol = GetParent()->GetBackgroundColour();
1387             else
1388                 bgCol = GetBackgroundColour();
1389
1390             dc.SetBrush(bgCol);
1391             dc.SetPen(bgCol);
1392             dc.DrawRectangle(rect);
1393         }
1394
1395         // Draw standard button
1396         wxRendererNative::Get().DrawComboBoxDropButton(this,
1397                                                        dc,
1398                                                        drawRect,
1399                                                        drawState);
1400     }
1401     else
1402     {
1403         // Draw bitmap
1404
1405         wxBitmap* pBmp;
1406
1407         if ( !enabled )
1408             pBmp = &m_bmpDisabled;
1409         else if ( m_btnState & wxCONTROL_PRESSED )
1410             pBmp = &m_bmpPressed;
1411         else if ( m_btnState & wxCONTROL_CURRENT )
1412             pBmp = &m_bmpHover;
1413         else
1414             pBmp = &m_bmpNormal;
1415
1416         if ( m_blankButtonBg )
1417         {
1418             // If using blank button background, we need to clear its background
1419             // with button face colour instead of colour for rest of the control.
1420             if ( flags & Button_PaintBackground )
1421             {
1422                 wxColour bgCol = GetParent()->GetBackgroundColour(); //wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE);
1423                 //wxColour bgCol = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW);
1424                 dc.SetPen(bgCol);
1425                 dc.SetBrush(bgCol);
1426                 dc.DrawRectangle(rect);
1427             }
1428
1429             if ( !(flags & Button_BitmapOnly) )
1430             {
1431                 wxRendererNative::Get().DrawPushButton(this,
1432                                                        dc,
1433                                                        drawRect,
1434                                                        drawState);
1435             }
1436         }
1437         else
1438
1439         {
1440             // Need to clear button background even if m_btn is present
1441             // (assume non-button background was cleared just before this call so brushes are good)
1442             if ( flags & Button_PaintBackground )
1443                 dc.DrawRectangle(rect);
1444         }
1445
1446         // Draw bitmap centered in drawRect
1447         dc.DrawBitmap(*pBmp,
1448                       drawRect.x + (drawRect.width-pBmp->GetWidth())/2,
1449                       drawRect.y + (drawRect.height-pBmp->GetHeight())/2,
1450                       true);
1451     }
1452 }
1453
1454 void wxComboCtrlBase::RecalcAndRefresh()
1455 {
1456     if ( IsCreated() )
1457     {
1458         wxSizeEvent evt(GetSize(),GetId());
1459         GetEventHandler()->ProcessEvent(evt);
1460         Refresh();
1461     }
1462 }
1463
1464 // ----------------------------------------------------------------------------
1465 // miscellaneous event handlers
1466 // ----------------------------------------------------------------------------
1467
1468 void wxComboCtrlBase::OnTextCtrlEvent(wxCommandEvent& event)
1469 {
1470     if ( event.GetEventType() == wxEVT_COMMAND_TEXT_UPDATED )
1471     {
1472         if ( m_ignoreEvtText > 0 )
1473         {
1474             m_ignoreEvtText--;
1475             return;
1476         }
1477     }
1478
1479     // Change event id, object and string before relaying it forward
1480     event.SetId(GetId());
1481     wxString s = event.GetString();
1482     event.SetEventObject(this);
1483     event.SetString(s);
1484     event.Skip();
1485 }
1486
1487 // call if cursor is on button area or mouse is captured for the button
1488 bool wxComboCtrlBase::HandleButtonMouseEvent( wxMouseEvent& event,
1489                                               int flags )
1490 {
1491     int type = event.GetEventType();
1492
1493     if ( type == wxEVT_MOTION )
1494     {
1495         if ( (flags & wxCC_MF_ON_BUTTON) &&
1496              IsPopupWindowState(Hidden) )
1497         {
1498             if ( !(m_btnState & wxCONTROL_CURRENT) )
1499             {
1500                 // Mouse hover begins
1501                 m_btnState |= wxCONTROL_CURRENT;
1502                 if ( HasCapture() ) // Retain pressed state.
1503                     m_btnState |= wxCONTROL_PRESSED;
1504                 Refresh();
1505             }
1506         }
1507         else if ( (m_btnState & wxCONTROL_CURRENT) )
1508         {
1509             // Mouse hover ends
1510             m_btnState &= ~(wxCONTROL_CURRENT|wxCONTROL_PRESSED);
1511             Refresh();
1512         }
1513     }
1514     else if ( type == wxEVT_LEFT_DOWN || type == wxEVT_LEFT_DCLICK )
1515     {
1516         if ( flags & (wxCC_MF_ON_CLICK_AREA|wxCC_MF_ON_BUTTON) )
1517         {
1518             m_btnState |= wxCONTROL_PRESSED;
1519             Refresh();
1520
1521             if ( !(m_iFlags & wxCC_POPUP_ON_MOUSE_UP) )
1522                 OnButtonClick();
1523             else
1524                 // If showing popup now, do not capture mouse or there will be interference
1525                 CaptureMouse();
1526         }
1527     }
1528     else if ( type == wxEVT_LEFT_UP )
1529     {
1530
1531         // Only accept event if mouse was left-press was previously accepted
1532         if ( HasCapture() )
1533             ReleaseMouse();
1534
1535         if ( m_btnState & wxCONTROL_PRESSED )
1536         {
1537             // If mouse was inside, fire the click event.
1538             if ( m_iFlags & wxCC_POPUP_ON_MOUSE_UP )
1539             {
1540                 if ( flags & (wxCC_MF_ON_CLICK_AREA|wxCC_MF_ON_BUTTON) )
1541                     OnButtonClick();
1542             }
1543
1544             m_btnState &= ~(wxCONTROL_PRESSED);
1545             Refresh();
1546         }
1547     }
1548     else if ( type == wxEVT_LEAVE_WINDOW )
1549     {
1550         if ( m_btnState & (wxCONTROL_CURRENT|wxCONTROL_PRESSED) )
1551         {
1552             m_btnState &= ~(wxCONTROL_CURRENT);
1553
1554             // Mouse hover ends
1555             if ( IsPopupWindowState(Hidden) )
1556             {
1557                 m_btnState &= ~(wxCONTROL_PRESSED);
1558                 Refresh();
1559             }
1560         }
1561     }
1562     else
1563         return false;
1564
1565     // Never have 'hot' state when popup is being shown
1566     // (this is mostly needed because of the animation).
1567     if ( !IsPopupWindowState(Hidden) )
1568         m_btnState &= ~wxCONTROL_CURRENT;
1569
1570     return true;
1571 }
1572
1573 // returns true if event was consumed or filtered
1574 bool wxComboCtrlBase::PreprocessMouseEvent( wxMouseEvent& event,
1575                                             int WXUNUSED(flags) )
1576 {
1577     wxLongLong t = ::wxGetLocalTimeMillis();
1578     int evtType = event.GetEventType();
1579
1580 #if USES_WXPOPUPWINDOW || USES_WXDIALOG
1581     if ( m_popupWinType != POPUPWIN_WXPOPUPTRANSIENTWINDOW )
1582     {
1583         if ( IsPopupWindowState(Visible) &&
1584              ( evtType == wxEVT_LEFT_DOWN || evtType == wxEVT_RIGHT_DOWN ) )
1585         {
1586             HidePopup();
1587             return true;
1588         }
1589     }
1590 #endif
1591
1592     // Filter out clicks on button immediately after popup dismiss
1593     if ( evtType == wxEVT_LEFT_DOWN && t < m_timeCanAcceptClick )
1594     {
1595         event.SetEventType(0);
1596         return true;
1597     }
1598
1599     return false;
1600 }
1601
1602 void wxComboCtrlBase::HandleNormalMouseEvent( wxMouseEvent& event )
1603 {
1604     int evtType = event.GetEventType();
1605
1606     if ( (evtType == wxEVT_LEFT_DOWN || evtType == wxEVT_LEFT_DCLICK) &&
1607          (m_windowStyle & wxCB_READONLY) )
1608     {
1609         if ( GetPopupWindowState() >= Animating )
1610         {
1611     #if USES_WXPOPUPWINDOW
1612             // Click here always hides the popup.
1613             if ( m_popupWinType == POPUPWIN_WXPOPUPWINDOW )
1614                 HidePopup();
1615     #endif
1616         }
1617         else
1618         {
1619             if ( !(m_windowStyle & wxCC_SPECIAL_DCLICK) )
1620             {
1621                 // In read-only mode, clicking the text is the
1622                 // same as clicking the button.
1623                 OnButtonClick();
1624             }
1625             else if ( /*evtType == wxEVT_LEFT_UP || */evtType == wxEVT_LEFT_DCLICK )
1626             {
1627                 //if ( m_popupInterface->CycleValue() )
1628                 //    Refresh();
1629                 if ( m_popupInterface )
1630                     m_popupInterface->OnComboDoubleClick();
1631             }
1632         }
1633     }
1634     else
1635     if ( IsPopupShown() )
1636     {
1637         // relay (some) mouse events to the popup
1638         if ( evtType == wxEVT_MOUSEWHEEL )
1639             m_popup->AddPendingEvent(event);
1640     }
1641     else if ( evtType )
1642         event.Skip();
1643 }
1644
1645 void wxComboCtrlBase::OnKeyEvent(wxKeyEvent& event)
1646 {
1647     if ( IsPopupShown() )
1648     {
1649         // pass it to the popped up control
1650         GetPopupControl()->GetControl()->AddPendingEvent(event);
1651     }
1652     else // no popup
1653     {
1654         int keycode = event.GetKeyCode();
1655
1656         if ( keycode == WXK_TAB )
1657         {
1658             wxNavigationKeyEvent evt;
1659
1660             wxWindow* mainCtrl = GetMainWindowOfCompositeControl();
1661
1662             evt.SetFlags(wxNavigationKeyEvent::FromTab|
1663                          (!event.ShiftDown() ? wxNavigationKeyEvent::IsForward
1664                                              : wxNavigationKeyEvent::IsBackward));
1665             evt.SetEventObject(mainCtrl);
1666             evt.SetCurrentFocus(mainCtrl);
1667             mainCtrl->GetParent()->GetEventHandler()->AddPendingEvent(evt);
1668             return;
1669         }
1670
1671         if ( IsKeyPopupToggle(event) )
1672         {
1673             OnButtonClick();
1674             return;
1675         }
1676
1677         int comboStyle = GetWindowStyle();
1678         wxComboPopup* popupInterface = GetPopupControl();
1679
1680         if ( !popupInterface )
1681         {
1682             event.Skip();
1683             return;
1684         }
1685
1686         if ( (comboStyle & wxCB_READONLY) ||
1687              (keycode != WXK_RIGHT && keycode != WXK_LEFT) )
1688         {
1689             popupInterface->OnComboKeyEvent(event);
1690         }
1691         else
1692             event.Skip();
1693     }
1694 }
1695
1696 void wxComboCtrlBase::OnFocusEvent( wxFocusEvent& event )
1697 {
1698     if ( event.GetEventType() == wxEVT_SET_FOCUS )
1699     {
1700         wxWindow* tc = GetTextCtrl();
1701         if ( tc && tc != DoFindFocus() )
1702 #ifdef __WXMAC__
1703             m_resetFocus = true;
1704 #else
1705         {
1706             tc->SetFocus();
1707         }
1708 #endif
1709     }
1710
1711     Refresh();
1712 }
1713
1714 void wxComboCtrlBase::OnIdleEvent( wxIdleEvent& WXUNUSED(event) )
1715 {
1716     if ( m_resetFocus )
1717     {
1718         m_resetFocus = false;
1719         wxWindow* tc = GetTextCtrl();
1720         if ( tc )
1721             tc->SetFocus();
1722     }
1723 }
1724
1725 void wxComboCtrlBase::OnSysColourChanged(wxSysColourChangedEvent& WXUNUSED(event))
1726 {
1727     OnThemeChange();
1728     // indentation may also have changed
1729     if ( !(m_iFlags & wxCC_IFLAG_INDENT_SET) )
1730         m_absIndent = GetNativeTextIndent();
1731     RecalcAndRefresh();
1732 }
1733
1734 // ----------------------------------------------------------------------------
1735 // popup handling
1736 // ----------------------------------------------------------------------------
1737
1738 // Create popup window and the child control
1739 void wxComboCtrlBase::CreatePopup()
1740 {
1741     wxComboPopup* popupInterface = m_popupInterface;
1742     wxWindow* popup;
1743
1744     if ( !m_winPopup )
1745     {
1746 #ifdef wxComboPopupWindowBase2
1747         if ( m_iFlags & wxCC_IFLAG_USE_ALT_POPUP )
1748         {
1749         #if !USES_WXDIALOG
1750             m_winPopup = new wxComboPopupWindowBase2( this, wxNO_BORDER );
1751         #else
1752             m_winPopup = new wxComboPopupWindowBase2( this, wxID_ANY, wxEmptyString,
1753                                                       wxPoint(-21,-21), wxSize(20, 20),
1754                                                       wxNO_BORDER );
1755         #endif
1756             m_popupWinType = SECONDARY_POPUP_TYPE;
1757         }
1758         else
1759 #endif // wxComboPopupWindowBase2
1760         {
1761             m_winPopup = new wxComboPopupWindow( this, wxNO_BORDER );
1762             m_popupWinType = PRIMARY_POPUP_TYPE;
1763         }
1764         m_popupWinEvtHandler = new wxComboPopupWindowEvtHandler(this);
1765         m_winPopup->PushEventHandler(m_popupWinEvtHandler);
1766     }
1767
1768     popupInterface->Create(m_winPopup);
1769     m_popup = popup = popupInterface->GetControl();
1770
1771     m_popupExtraHandler = new wxComboPopupExtraEventHandler(this);
1772     popup->PushEventHandler( m_popupExtraHandler );
1773
1774     // This may be helpful on some platforms
1775     //   (eg. it bypasses a wxGTK popupwindow bug where
1776     //    window is not initially hidden when it should be)
1777     m_winPopup->Hide();
1778
1779     popupInterface->m_iFlags |= wxCP_IFLAG_CREATED;
1780 }
1781
1782 // Destroy popup window and the child control
1783 void wxComboCtrlBase::DestroyPopup()
1784 {
1785     HidePopup();
1786
1787     if ( m_popup )
1788         m_popup->RemoveEventHandler(m_popupExtraHandler);
1789
1790     delete m_popupExtraHandler;
1791
1792     delete m_popupInterface;
1793
1794     if ( m_winPopup )
1795     {
1796         m_winPopup->RemoveEventHandler(m_popupWinEvtHandler);
1797         delete m_popupWinEvtHandler;
1798         m_popupWinEvtHandler = NULL;
1799         m_winPopup->Destroy();
1800     }
1801
1802     m_popupExtraHandler = (wxEvtHandler*) NULL;
1803     m_popupInterface = (wxComboPopup*) NULL;
1804     m_winPopup = (wxWindow*) NULL;
1805     m_popup = (wxWindow*) NULL;
1806 }
1807
1808 void wxComboCtrlBase::DoSetPopupControl(wxComboPopup* iface)
1809 {
1810     wxCHECK_RET( iface, wxT("no popup interface set for wxComboCtrl") );
1811
1812     DestroyPopup();
1813
1814     iface->InitBase(this);
1815     iface->Init();
1816
1817     m_popupInterface = iface;
1818
1819     if ( !iface->LazyCreate() )
1820     {
1821         CreatePopup();
1822     }
1823     else
1824     {
1825         m_popup = (wxWindow*) NULL;
1826     }
1827
1828     // This must be done after creation
1829     if ( m_valueString.length() )
1830     {
1831         iface->SetStringValue(m_valueString);
1832         //Refresh();
1833     }
1834 }
1835
1836 // Ensures there is atleast the default popup
1837 void wxComboCtrlBase::EnsurePopupControl()
1838 {
1839     if ( !m_popupInterface )
1840         SetPopupControl(NULL);
1841 }
1842
1843 void wxComboCtrlBase::OnButtonClick()
1844 {
1845     // Derived classes can override this method for totally custom
1846     // popup action
1847     ShowPopup();
1848 }
1849
1850 void wxComboCtrlBase::ShowPopup()
1851 {
1852     EnsurePopupControl();
1853     wxCHECK_RET( !IsPopupWindowState(Visible), wxT("popup window already shown") );
1854
1855     if ( IsPopupWindowState(Animating) )
1856         return;
1857
1858     SetFocus();
1859
1860     // Space above and below
1861     int screenHeight;
1862     wxPoint scrPos;
1863     int spaceAbove;
1864     int spaceBelow;
1865     int maxHeightPopup;
1866     wxSize ctrlSz = GetSize();
1867
1868     screenHeight = wxSystemSettings::GetMetric( wxSYS_SCREEN_Y );
1869     scrPos = GetParent()->ClientToScreen(GetPosition());
1870
1871     spaceAbove = scrPos.y;
1872     spaceBelow = screenHeight - spaceAbove - ctrlSz.y;
1873
1874     maxHeightPopup = spaceBelow;
1875     if ( spaceAbove > spaceBelow )
1876         maxHeightPopup = spaceAbove;
1877
1878     // Width
1879     int widthPopup = ctrlSz.x + m_extLeft + m_extRight;
1880
1881     if ( widthPopup < m_widthMinPopup )
1882         widthPopup = m_widthMinPopup;
1883
1884     wxWindow* winPopup = m_winPopup;
1885     wxWindow* popup;
1886
1887     // Need to disable tab traversal of parent
1888     //
1889     // NB: This is to fix a bug in wxMSW. In theory it could also be fixed
1890     //     by, for instance, adding check to window.cpp:wxWindowMSW::MSWProcessMessage
1891     //     that if transient popup is open, then tab traversal is to be ignored.
1892     //     However, I think this code would still be needed for cases where
1893     //     transient popup doesn't work yet (wxWinCE?).
1894     wxWindow* parent = GetParent();
1895     int parentFlags = parent->GetWindowStyle();
1896     if ( parentFlags & wxTAB_TRAVERSAL )
1897     {
1898         parent->SetWindowStyle( parentFlags & ~(wxTAB_TRAVERSAL) );
1899         m_iFlags |= wxCC_IFLAG_PARENT_TAB_TRAVERSAL;
1900     }
1901
1902     if ( !winPopup )
1903     {
1904         CreatePopup();
1905         winPopup = m_winPopup;
1906         popup = m_popup;
1907     }
1908     else
1909     {
1910         popup = m_popup;
1911     }
1912
1913     winPopup->Enable();
1914
1915     wxASSERT( !m_popup || m_popup == popup ); // Consistency check.
1916
1917     wxSize adjustedSize = m_popupInterface->GetAdjustedSize(widthPopup,
1918                                                             m_heightPopup<=0?DEFAULT_POPUP_HEIGHT:m_heightPopup,
1919                                                             maxHeightPopup);
1920
1921     popup->SetSize(adjustedSize);
1922     popup->Move(0,0);
1923     m_popupInterface->OnPopup();
1924
1925     //
1926     // Reposition and resize popup window
1927     //
1928
1929     wxSize szp = popup->GetSize();
1930
1931     int popupX;
1932     int popupY = scrPos.y + ctrlSz.y;
1933
1934     // Default anchor is wxLEFT
1935     int anchorSide = m_anchorSide;
1936     if ( !anchorSide )
1937         anchorSide = wxLEFT;
1938
1939     int rightX = scrPos.x + ctrlSz.x + m_extRight - szp.x;
1940     int leftX = scrPos.x - m_extLeft;
1941
1942     if ( wxTheApp->GetLayoutDirection() == wxLayout_RightToLeft )
1943         leftX -= ctrlSz.x;
1944
1945     int screenWidth = wxSystemSettings::GetMetric( wxSYS_SCREEN_X );
1946
1947     // If there is not enough horizontal space, anchor on the other side.
1948     // If there is no space even then, place the popup at x 0.
1949     if ( anchorSide == wxRIGHT )
1950     {
1951         if ( rightX < 0 )
1952         {
1953             if ( (leftX+szp.x) < screenWidth )
1954                 anchorSide = wxLEFT;
1955             else
1956                 anchorSide = 0;
1957         }
1958     }
1959     else
1960     {
1961         if ( (leftX+szp.x) >= screenWidth )
1962         {
1963             if ( rightX >= 0 )
1964                 anchorSide = wxRIGHT;
1965             else
1966                 anchorSide = 0;
1967         }
1968     }
1969
1970     // Select x coordinate according to the anchor side
1971     if ( anchorSide == wxRIGHT )
1972         popupX = rightX;
1973     else if ( anchorSide == wxLEFT )
1974         popupX = leftX;
1975     else
1976         popupX = 0;
1977
1978     int showFlags = CanDeferShow;
1979
1980     if ( spaceBelow < szp.y )
1981     {
1982         popupY = scrPos.y - szp.y;
1983         showFlags |= ShowAbove;
1984     }
1985
1986 #if INSTALL_TOPLEV_HANDLER
1987     // Put top level window event handler into place
1988     if ( m_popupWinType == POPUPWIN_WXPOPUPWINDOW )
1989     {
1990         if ( !m_toplevEvtHandler )
1991             m_toplevEvtHandler = new wxComboFrameEventHandler(this);
1992
1993         wxWindow* toplev = ::wxGetTopLevelParent( this );
1994         wxASSERT( toplev );
1995         ((wxComboFrameEventHandler*)m_toplevEvtHandler)->OnPopup();
1996         toplev->PushEventHandler( m_toplevEvtHandler );
1997     }
1998 #endif
1999
2000     // Set string selection (must be this way instead of SetStringSelection)
2001     if ( m_text )
2002     {
2003         if ( !(m_iFlags & wxCC_NO_TEXT_AUTO_SELECT) )
2004             m_text->SelectAll();
2005
2006         m_popupInterface->SetStringValue( m_text->GetValue() );
2007     }
2008     else
2009     {
2010         // This is neede since focus/selection indication may change when popup is shown
2011         Refresh();
2012     }
2013
2014     // This must be after SetStringValue
2015     m_popupWinState = Animating;
2016
2017     wxRect popupWinRect( popupX, popupY, szp.x, szp.y );
2018
2019     m_popup = popup;
2020     if ( (m_iFlags & wxCC_IFLAG_DISABLE_POPUP_ANIM) ||
2021          AnimateShow( popupWinRect, showFlags ) )
2022     {
2023         DoShowPopup( popupWinRect, showFlags );
2024     }
2025 }
2026
2027 bool wxComboCtrlBase::AnimateShow( const wxRect& WXUNUSED(rect), int WXUNUSED(flags) )
2028 {
2029     return true;
2030 }
2031
2032 void wxComboCtrlBase::DoShowPopup( const wxRect& rect, int WXUNUSED(flags) )
2033 {
2034     wxWindow* winPopup = m_winPopup;
2035
2036     if ( IsPopupWindowState(Animating) )
2037     {
2038         // Make sure the popup window is shown in the right position.
2039         // Should not matter even if animation already did this.
2040
2041         // Some platforms (GTK) may like SetSize and Move to be separate
2042         // (though the bug was probably fixed).
2043         winPopup->SetSize( rect );
2044
2045 #if USES_WXPOPUPTRANSIENTWINDOW
2046         if ( m_popupWinType == POPUPWIN_WXPOPUPTRANSIENTWINDOW )
2047             ((wxPopupTransientWindow*)winPopup)->Popup(m_popup);
2048         else
2049 #endif
2050             winPopup->Show();
2051
2052         m_popupWinState = Visible;
2053     }
2054     else if ( IsPopupWindowState(Hidden) )
2055     {
2056         // Animation was aborted
2057
2058         wxASSERT( !winPopup->IsShown() );
2059
2060         m_popupWinState = Hidden;
2061     }
2062
2063     Refresh();
2064 }
2065
2066 void wxComboCtrlBase::OnPopupDismiss()
2067 {
2068     // Just in case, avoid double dismiss
2069     if ( IsPopupWindowState(Hidden) )
2070         return;
2071
2072     // This must be set before focus - otherwise there will be recursive
2073     // OnPopupDismisses.
2074     m_popupWinState = Hidden;
2075
2076     //SetFocus();
2077     m_winPopup->Disable();
2078
2079     // Inform popup control itself
2080     m_popupInterface->OnDismiss();
2081
2082     if ( m_popupExtraHandler )
2083         ((wxComboPopupExtraEventHandler*)m_popupExtraHandler)->OnPopupDismiss();
2084
2085 #if INSTALL_TOPLEV_HANDLER
2086     // Remove top level window event handler
2087     if ( m_toplevEvtHandler )
2088     {
2089         wxWindow* toplev = ::wxGetTopLevelParent( this );
2090         if ( toplev )
2091             toplev->RemoveEventHandler( m_toplevEvtHandler );
2092     }
2093 #endif
2094
2095     m_timeCanAcceptClick = ::wxGetLocalTimeMillis();
2096
2097     if ( m_popupWinType == POPUPWIN_WXPOPUPTRANSIENTWINDOW )
2098         m_timeCanAcceptClick += 150;
2099
2100     // If cursor not on dropdown button, then clear its state
2101     // (technically not required by all ports, but do it for all just in case)
2102     if ( !m_btnArea.Contains(ScreenToClient(::wxGetMousePosition())) )
2103         m_btnState = 0;
2104
2105     // Return parent's tab traversal flag.
2106     // See ShowPopup for notes.
2107     if ( m_iFlags & wxCC_IFLAG_PARENT_TAB_TRAVERSAL )
2108     {
2109         wxWindow* parent = GetParent();
2110         parent->SetWindowStyle( parent->GetWindowStyle() | wxTAB_TRAVERSAL );
2111         m_iFlags &= ~(wxCC_IFLAG_PARENT_TAB_TRAVERSAL);
2112     }
2113
2114     // refresh control (necessary even if m_text)
2115     Refresh();
2116
2117     SetFocus();
2118 }
2119
2120 void wxComboCtrlBase::HidePopup()
2121 {
2122     // Should be able to call this without popup interface
2123     if ( IsPopupWindowState(Hidden) )
2124         return;
2125
2126     // transfer value and show it in textctrl, if any
2127     if ( !IsPopupWindowState(Animating) )
2128         SetValue( m_popupInterface->GetStringValue() );
2129
2130     m_winPopup->Hide();
2131
2132     OnPopupDismiss();
2133 }
2134
2135 // ----------------------------------------------------------------------------
2136 // customization methods
2137 // ----------------------------------------------------------------------------
2138
2139 void wxComboCtrlBase::SetButtonPosition( int width, int height,
2140                                          int side, int spacingX )
2141 {
2142     m_btnWid = width;
2143     m_btnHei = height;
2144     m_btnSide = side;
2145     m_btnSpacingX = spacingX;
2146
2147     RecalcAndRefresh();
2148 }
2149
2150 wxSize wxComboCtrlBase::GetButtonSize()
2151 {
2152     if ( m_btnSize.x > 0 )
2153         return m_btnSize;
2154
2155     wxSize retSize(m_btnWid,m_btnHei);
2156
2157     // Need to call CalculateAreas now if button size is
2158     // is not explicitly specified.
2159     if ( retSize.x <= 0 || retSize.y <= 0)
2160     {
2161         OnResize();
2162
2163         retSize = m_btnSize;
2164     }
2165
2166     return retSize;
2167 }
2168
2169 void wxComboCtrlBase::SetButtonBitmaps( const wxBitmap& bmpNormal,
2170                                            bool blankButtonBg,
2171                                            const wxBitmap& bmpPressed,
2172                                            const wxBitmap& bmpHover,
2173                                            const wxBitmap& bmpDisabled )
2174 {
2175     m_bmpNormal = bmpNormal;
2176     m_blankButtonBg = blankButtonBg;
2177
2178     if ( bmpPressed.Ok() )
2179         m_bmpPressed = bmpPressed;
2180     else
2181         m_bmpPressed = bmpNormal;
2182
2183     if ( bmpHover.Ok() )
2184         m_bmpHover = bmpHover;
2185     else
2186         m_bmpHover = bmpNormal;
2187
2188     if ( bmpDisabled.Ok() )
2189         m_bmpDisabled = bmpDisabled;
2190     else
2191         m_bmpDisabled = bmpNormal;
2192
2193     RecalcAndRefresh();
2194 }
2195
2196 void wxComboCtrlBase::SetCustomPaintWidth( int width )
2197 {
2198     if ( m_text )
2199     {
2200         // move textctrl accordingly
2201         wxRect r = m_text->GetRect();
2202         int inc = width - m_widthCustomPaint;
2203         r.x += inc;
2204         r.width -= inc;
2205         m_text->SetSize( r );
2206     }
2207
2208     m_widthCustomPaint = width;
2209
2210     RecalcAndRefresh();
2211 }
2212
2213 void wxComboCtrlBase::SetTextIndent( int indent )
2214 {
2215     if ( indent < 0 )
2216     {
2217         m_absIndent = GetNativeTextIndent();
2218         m_iFlags &= ~(wxCC_IFLAG_INDENT_SET);
2219     }
2220     else
2221     {
2222         m_absIndent = indent;
2223         m_iFlags |= wxCC_IFLAG_INDENT_SET;
2224     }
2225
2226     RecalcAndRefresh();
2227 }
2228
2229 wxCoord wxComboCtrlBase::GetNativeTextIndent() const
2230 {
2231     return DEFAULT_TEXT_INDENT;
2232 }
2233
2234 // ----------------------------------------------------------------------------
2235 // methods forwarded to wxTextCtrl
2236 // ----------------------------------------------------------------------------
2237
2238 wxString wxComboCtrlBase::GetValue() const
2239 {
2240     if ( m_text )
2241         return m_text->GetValue();
2242     return m_valueString;
2243 }
2244
2245 void wxComboCtrlBase::SetValueWithEvent(const wxString& value, bool withEvent)
2246 {
2247     if ( m_text )
2248     {
2249         if ( !withEvent )
2250             m_ignoreEvtText++;
2251
2252         m_text->SetValue(value);
2253
2254         if ( !(m_iFlags & wxCC_NO_TEXT_AUTO_SELECT) )
2255             m_text->SelectAll();
2256     }
2257
2258     // Since wxComboPopup may want to paint the combo as well, we need
2259     // to set the string value here (as well as sometimes in ShowPopup).
2260     if ( m_valueString != value )
2261     {
2262         m_valueString = value;
2263
2264         EnsurePopupControl();
2265
2266         if (m_popupInterface)
2267             m_popupInterface->SetStringValue(value);
2268     }
2269
2270     Refresh();
2271 }
2272
2273 void wxComboCtrlBase::SetValue(const wxString& value)
2274 {
2275     SetValueWithEvent(value, false);
2276 }
2277
2278 // In this SetValue variant wxComboPopup::SetStringValue is not called
2279 void wxComboCtrlBase::SetText(const wxString& value)
2280 {
2281     // Unlike in SetValue(), this must be called here or
2282     // the behaviour will no be consistent in readonlys.
2283     EnsurePopupControl();
2284
2285     m_valueString = value;
2286
2287     if ( m_text )
2288     {
2289         m_ignoreEvtText++;
2290         m_text->SetValue( value );
2291     }
2292
2293     Refresh();
2294 }
2295
2296 void wxComboCtrlBase::Copy()
2297 {
2298     if ( m_text )
2299         m_text->Copy();
2300 }
2301
2302 void wxComboCtrlBase::Cut()
2303 {
2304     if ( m_text )
2305         m_text->Cut();
2306 }
2307
2308 void wxComboCtrlBase::Paste()
2309 {
2310     if ( m_text )
2311         m_text->Paste();
2312 }
2313
2314 void wxComboCtrlBase::SetInsertionPoint(long pos)
2315 {
2316     if ( m_text )
2317         m_text->SetInsertionPoint(pos);
2318 }
2319
2320 void wxComboCtrlBase::SetInsertionPointEnd()
2321 {
2322     if ( m_text )
2323         m_text->SetInsertionPointEnd();
2324 }
2325
2326 long wxComboCtrlBase::GetInsertionPoint() const
2327 {
2328     if ( m_text )
2329         return m_text->GetInsertionPoint();
2330
2331     return 0;
2332 }
2333
2334 long wxComboCtrlBase::GetLastPosition() const
2335 {
2336     if ( m_text )
2337         return m_text->GetLastPosition();
2338
2339     return 0;
2340 }
2341
2342 void wxComboCtrlBase::Replace(long from, long to, const wxString& value)
2343 {
2344     if ( m_text )
2345         m_text->Replace(from, to, value);
2346 }
2347
2348 void wxComboCtrlBase::Remove(long from, long to)
2349 {
2350     if ( m_text )
2351         m_text->Remove(from, to);
2352 }
2353
2354 void wxComboCtrlBase::SetSelection(long from, long to)
2355 {
2356     if ( m_text )
2357         m_text->SetSelection(from, to);
2358 }
2359
2360 void wxComboCtrlBase::Undo()
2361 {
2362     if ( m_text )
2363         m_text->Undo();
2364 }
2365
2366 #endif // wxUSE_COMBOCTRL