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