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