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