1 /////////////////////////////////////////////////////////////////////////////// 2 // Name: wx/combo.h 3 // Purpose: wxComboCtrl declaration 4 // Author: Jaakko Salli 5 // Modified by: 6 // Created: Apr-30-2006 7 // Copyright: (c) Jaakko Salli 8 // Licence: wxWindows licence 9 /////////////////////////////////////////////////////////////////////////////// 10 11 #ifndef _WX_COMBOCONTROL_H_BASE_ 12 #define _WX_COMBOCONTROL_H_BASE_ 13 14 15 /* 16 A few words about all the classes defined in this file are probably in 17 order: why do we need extra wxComboCtrl and wxComboPopup classes? 18 19 This is because a traditional combobox is a combination of a text control 20 (with a button allowing to open the pop down list) with a listbox and 21 wxComboBox class is exactly such control, however we want to also have other 22 combinations - in fact, we want to allow anything at all to be used as pop 23 down list, not just a wxListBox. 24 25 So we define a base wxComboCtrl which can use any control as pop down 26 list and wxComboBox deriving from it which implements the standard wxWidgets 27 combobox API. wxComboCtrl needs to be told somehow which control to use 28 and this is done by SetPopupControl(). However, we need something more than 29 just a wxControl in this method as, for example, we need to call 30 SetSelection("initial text value") and wxControl doesn't have such method. 31 So we also need a wxComboPopup which is just a very simple interface which 32 must be implemented by a control to be usable as a popup. 33 34 We couldn't derive wxComboPopup from wxControl as this would make it 35 impossible to have a class deriving from both wxListBx and from it, so 36 instead it is just a mix-in. 37 */ 38 39 40 #include "wx/defs.h" 41 42 #if wxUSE_COMBOCTRL 43 44 #include "wx/control.h" 45 #include "wx/renderer.h" // this is needed for wxCONTROL_XXX flags 46 #include "wx/bitmap.h" // wxBitmap used by-value 47 #include "wx/textentry.h" 48 #include "wx/time.h" // needed for wxMilliClock_t 49 50 class WXDLLIMPEXP_FWD_CORE wxTextCtrl; 51 class WXDLLIMPEXP_FWD_CORE wxComboPopup; 52 53 // 54 // New window styles for wxComboCtrlBase 55 // 56 enum 57 { 58 // Double-clicking a read-only combo triggers call to popup's OnComboPopup. 59 // In wxOwnerDrawnComboBox, for instance, it cycles item. 60 wxCC_SPECIAL_DCLICK = 0x0100, 61 62 // Dropbutton acts like standard push button. 63 wxCC_STD_BUTTON = 0x0200 64 }; 65 66 67 // wxComboCtrl internal flags 68 enum 69 { 70 // First those that can be passed to Customize. 71 // It is Windows style for all flags to be clear. 72 73 // Button is preferred outside the border (GTK style) 74 wxCC_BUTTON_OUTSIDE_BORDER = 0x0001, 75 // Show popup on mouse up instead of mouse down (which is the Windows style) 76 wxCC_POPUP_ON_MOUSE_UP = 0x0002, 77 // All text is not automatically selected on click 78 wxCC_NO_TEXT_AUTO_SELECT = 0x0004, 79 // Drop-button stays down as long as popup is displayed. 80 wxCC_BUTTON_STAYS_DOWN = 0x0008, 81 // Drop-button covers the entire control. 82 wxCC_FULL_BUTTON = 0x0010, 83 // Drop-button goes over the custom-border (used under WinVista). 84 wxCC_BUTTON_COVERS_BORDER = 0x0020, 85 86 // Internal use: signals creation is complete 87 wxCC_IFLAG_CREATED = 0x0100, 88 // Internal use: really put button outside 89 wxCC_IFLAG_BUTTON_OUTSIDE = 0x0200, 90 // Internal use: SetMargins has been successfully called 91 wxCC_IFLAG_LEFT_MARGIN_SET = 0x0400, 92 // Internal use: Set wxTAB_TRAVERSAL to parent when popup is dismissed 93 wxCC_IFLAG_PARENT_TAB_TRAVERSAL = 0x0800, 94 // Internal use: Secondary popup window type should be used (if available). 95 wxCC_IFLAG_USE_ALT_POPUP = 0x1000, 96 // Internal use: Skip popup animation. 97 wxCC_IFLAG_DISABLE_POPUP_ANIM = 0x2000, 98 // Internal use: Drop-button is a bitmap button or has non-default size 99 // (but can still be on either side of the control), regardless whether 100 // specified by the platform or the application. 101 wxCC_IFLAG_HAS_NONSTANDARD_BUTTON = 0x4000 102 }; 103 104 105 // Flags used by PreprocessMouseEvent and HandleButtonMouseEvent 106 enum 107 { 108 wxCC_MF_ON_BUTTON = 0x0001, // cursor is on dropbutton area 109 wxCC_MF_ON_CLICK_AREA = 0x0002 // cursor is on dropbutton or other area 110 // that can be clicked to show the popup. 111 }; 112 113 114 // Namespace for wxComboCtrl feature flags 115 struct wxComboCtrlFeatures 116 { 117 enum 118 { 119 MovableButton = 0x0001, // Button can be on either side of control 120 BitmapButton = 0x0002, // Button may be replaced with bitmap 121 ButtonSpacing = 0x0004, // Button can have spacing from the edge 122 // of the control 123 TextIndent = 0x0008, // SetMargins can be used to control 124 // left margin. 125 PaintControl = 0x0010, // Combo control itself can be custom painted 126 PaintWritable = 0x0020, // A variable-width area in front of writable 127 // combo control's textctrl can be custom 128 // painted 129 Borderless = 0x0040, // wxNO_BORDER window style works 130 131 // There are no feature flags for... 132 // PushButtonBitmapBackground - if its in wxRendererNative, then it should be 133 // not an issue to have it automatically under the bitmap. 134 135 All = MovableButton|BitmapButton| 136 ButtonSpacing|TextIndent| 137 PaintControl|PaintWritable| 138 Borderless 139 }; 140 }; 141 142 143 class WXDLLIMPEXP_CORE wxComboCtrlBase : public wxControl, 144 public wxTextEntry 145 { 146 friend class wxComboPopup; 147 friend class wxComboPopupEvtHandler; 148 public: 149 // ctors and such wxComboCtrlBase()150 wxComboCtrlBase() : wxControl(), wxTextEntry() { Init(); } 151 152 bool Create(wxWindow *parent, 153 wxWindowID id, 154 const wxString& value, 155 const wxPoint& pos, 156 const wxSize& size, 157 long style, 158 const wxValidator& validator, 159 const wxString& name); 160 161 virtual ~wxComboCtrlBase(); 162 163 // Show/hide popup window (wxComboBox-compatible methods) 164 virtual void Popup(); Dismiss()165 virtual void Dismiss() 166 { 167 HidePopup(true); 168 } 169 170 // Show/hide popup window. 171 // TODO: Maybe deprecate in favor of Popup()/Dismiss(). 172 // However, these functions are still called internally 173 // so it is not straightforward. 174 virtual void ShowPopup(); 175 virtual void HidePopup(bool generateEvent=false); 176 177 // Override for totally custom combo action 178 virtual void OnButtonClick(); 179 180 // return true if the popup is currently shown IsPopupShown()181 bool IsPopupShown() const { return m_popupWinState == Visible; } 182 183 // set interface class instance derived from wxComboPopup 184 // NULL popup can be used to indicate default in a derived class SetPopupControl(wxComboPopup * popup)185 void SetPopupControl( wxComboPopup* popup ) 186 { 187 DoSetPopupControl(popup); 188 } 189 190 // get interface class instance derived from wxComboPopup GetPopupControl()191 wxComboPopup* GetPopupControl() 192 { 193 EnsurePopupControl(); 194 return m_popupInterface; 195 } 196 197 // get the popup window containing the popup control GetPopupWindow()198 wxWindow *GetPopupWindow() const { return m_winPopup; } 199 200 // Get the text control which is part of the combobox. GetTextCtrl()201 wxTextCtrl *GetTextCtrl() const { return m_text; } 202 203 // get the dropdown button which is part of the combobox 204 // note: its not necessarily a wxButton or wxBitmapButton GetButton()205 wxWindow *GetButton() const { return m_btn; } 206 207 // forward these methods to all subcontrols 208 virtual bool Enable(bool enable = true) wxOVERRIDE; 209 virtual bool Show(bool show = true) wxOVERRIDE; 210 virtual bool SetFont(const wxFont& font) wxOVERRIDE; 211 212 // 213 // wxTextEntry methods 214 // 215 // NB: We basically need to override all of them because there is 216 // no guarantee how platform-specific wxTextEntry is implemented. 217 // SetValue(const wxString & value)218 virtual void SetValue(const wxString& value) wxOVERRIDE 219 { wxTextEntryBase::SetValue(value); } ChangeValue(const wxString & value)220 virtual void ChangeValue(const wxString& value) wxOVERRIDE 221 { wxTextEntryBase::ChangeValue(value); } 222 223 virtual void WriteText(const wxString& text) wxOVERRIDE; AppendText(const wxString & text)224 virtual void AppendText(const wxString& text) wxOVERRIDE 225 { wxTextEntryBase::AppendText(text); } 226 GetValue()227 virtual wxString GetValue() const wxOVERRIDE 228 { return wxTextEntryBase::GetValue(); } 229 GetRange(long from,long to)230 virtual wxString GetRange(long from, long to) const wxOVERRIDE 231 { return wxTextEntryBase::GetRange(from, to); } 232 233 // Replace() and DoSetValue() need to be fully re-implemented since 234 // EventSuppressor utility class does not work with the way 235 // wxComboCtrl is implemented. 236 virtual void Replace(long from, long to, const wxString& value) wxOVERRIDE; 237 238 virtual void Remove(long from, long to) wxOVERRIDE; 239 240 virtual void Copy() wxOVERRIDE; 241 virtual void Cut() wxOVERRIDE; 242 virtual void Paste() wxOVERRIDE; 243 244 virtual void Undo() wxOVERRIDE; 245 virtual void Redo() wxOVERRIDE; 246 virtual bool CanUndo() const wxOVERRIDE; 247 virtual bool CanRedo() const wxOVERRIDE; 248 249 virtual void SetInsertionPoint(long pos) wxOVERRIDE; 250 virtual long GetInsertionPoint() const wxOVERRIDE; 251 virtual long GetLastPosition() const wxOVERRIDE; 252 253 virtual void SetSelection(long from, long to) wxOVERRIDE; 254 virtual void GetSelection(long *from, long *to) const wxOVERRIDE; 255 256 virtual bool IsEditable() const wxOVERRIDE; 257 virtual void SetEditable(bool editable) wxOVERRIDE; 258 259 virtual bool SetHint(const wxString& hint) wxOVERRIDE; 260 virtual wxString GetHint() const wxOVERRIDE; 261 262 // This method sets the text without affecting list selection 263 // (ie. wxComboPopup::SetStringValue doesn't get called). 264 void SetText(const wxString& value); 265 266 // This method sets value and also optionally sends EVT_TEXT 267 // (needed by combo popups) 268 wxDEPRECATED( void SetValueWithEvent(const wxString& value, 269 bool withEvent = true) ); 270 271 // Changes value of the control as if user had done it by selecting an 272 // item from a combo box drop-down list. Needs to be public so that 273 // derived popup classes can call it. 274 void SetValueByUser(const wxString& value); 275 276 // 277 // Popup customization methods 278 // 279 280 // Sets minimum width of the popup. If wider than combo control, it will extend to the left. 281 // Remarks: 282 // * Value -1 indicates the default. 283 // * Custom popup may choose to ignore this (wxOwnerDrawnComboBox does not). SetPopupMinWidth(int width)284 void SetPopupMinWidth( int width ) 285 { 286 m_widthMinPopup = width; 287 } 288 289 // Sets preferred maximum height of the popup. 290 // Remarks: 291 // * Value -1 indicates the default. 292 // * Custom popup may choose to ignore this (wxOwnerDrawnComboBox does not). SetPopupMaxHeight(int height)293 void SetPopupMaxHeight( int height ) 294 { 295 m_heightPopup = height; 296 } 297 298 // Extends popup size horizontally, relative to the edges of the combo control. 299 // Remarks: 300 // * Popup minimum width may override extLeft (ie. it has higher precedence). 301 // * Values 0 indicate default. 302 // * Custom popup may not take this fully into account (wxOwnerDrawnComboBox takes). SetPopupExtents(int extLeft,int extRight)303 void SetPopupExtents( int extLeft, int extRight ) 304 { 305 m_extLeft = extLeft; 306 m_extRight = extRight; 307 } 308 309 // Set width, in pixels, of custom paint area in writable combo. 310 // In read-only, used to indicate area that is not covered by the 311 // focus rectangle (which may or may not be drawn, depending on the 312 // popup type). 313 void SetCustomPaintWidth( int width ); GetCustomPaintWidth()314 int GetCustomPaintWidth() const { return m_widthCustomPaint; } 315 316 // Set side of the control to which the popup will align itself. 317 // Valid values are wxLEFT, wxRIGHT and 0. The default value 0 wmeans 318 // that the side of the button will be used. SetPopupAnchor(int anchorSide)319 void SetPopupAnchor( int anchorSide ) 320 { 321 m_anchorSide = anchorSide; 322 } 323 324 // Set position of dropdown button. 325 // width: button width. <= 0 for default. 326 // height: button height. <= 0 for default. 327 // side: wxLEFT or wxRIGHT, indicates on which side the button will be placed. 328 // spacingX: empty space on sides of the button. Default is 0. 329 // Remarks: 330 // There is no spacingY - the button will be centred vertically. 331 void SetButtonPosition( int width = -1, 332 int height = -1, 333 int side = wxRIGHT, 334 int spacingX = 0 ); 335 336 // Returns current size of the dropdown button. 337 wxSize GetButtonSize(); 338 339 // 340 // Sets dropbutton to be drawn with custom bitmaps. 341 // 342 // bmpNormal: drawn when cursor is not on button 343 // pushButtonBg: Draw push button background below the image. 344 // NOTE! This is usually only properly supported on platforms with appropriate 345 // method in wxRendererNative. 346 // bmpPressed: drawn when button is depressed 347 // bmpHover: drawn when cursor hovers on button. This is ignored on platforms 348 // that do not generally display hover differently. 349 // bmpDisabled: drawn when combobox is disabled. 350 void SetButtonBitmaps( const wxBitmap& bmpNormal, 351 bool pushButtonBg = false, 352 const wxBitmap& bmpPressed = wxNullBitmap, 353 const wxBitmap& bmpHover = wxNullBitmap, 354 const wxBitmap& bmpDisabled = wxNullBitmap ); 355 356 #if WXWIN_COMPATIBILITY_2_8 357 // 358 // This will set the space in pixels between left edge of the control and the 359 // text, regardless whether control is read-only (ie. no wxTextCtrl) or not. 360 // Platform-specific default can be set with value-1. 361 // Remarks 362 // * This method may do nothing on some native implementations. 363 wxDEPRECATED( void SetTextIndent( int indent ) ); 364 365 // Returns actual indentation in pixels. 366 wxDEPRECATED( wxCoord GetTextIndent() const ); 367 #endif 368 369 // Returns area covered by the text field. GetTextRect()370 const wxRect& GetTextRect() const 371 { 372 return m_tcArea; 373 } 374 375 // Call with enable as true to use a type of popup window that guarantees ability 376 // to focus the popup control, and normal function of common native controls. 377 // This alternative popup window is usually a wxDialog, and as such it's parent 378 // frame will appear as if the focus has been lost from it. 379 void UseAltPopupWindow( bool enable = true ) 380 { 381 wxASSERT_MSG( !m_winPopup, 382 wxT("call this only before SetPopupControl") ); 383 384 if ( enable ) 385 m_iFlags |= wxCC_IFLAG_USE_ALT_POPUP; 386 else 387 m_iFlags &= ~wxCC_IFLAG_USE_ALT_POPUP; 388 } 389 390 // Call with false to disable popup animation, if any. 391 void EnablePopupAnimation( bool enable = true ) 392 { 393 if ( enable ) 394 m_iFlags &= ~wxCC_IFLAG_DISABLE_POPUP_ANIM; 395 else 396 m_iFlags |= wxCC_IFLAG_DISABLE_POPUP_ANIM; 397 } 398 399 // 400 // Utilities needed by the popups or native implementations 401 // 402 403 // Returns true if given key combination should toggle the popup. 404 // NB: This is a separate from other keyboard handling because: 405 // 1) Replaceability. 406 // 2) Centralized code (otherwise it'd be split up between 407 // wxComboCtrl key handler and wxVListBoxComboPopup's 408 // key handler). 409 virtual bool IsKeyPopupToggle(const wxKeyEvent& event) const = 0; 410 411 // Prepare background of combo control or an item in a dropdown list 412 // in a way typical on platform. This includes painting the focus/disabled 413 // background and setting the clipping region. 414 // Unless you plan to paint your own focus indicator, you should always call this 415 // in your wxComboPopup::PaintComboControl implementation. 416 // In addition, it sets pen and text colour to what looks good and proper 417 // against the background. 418 // flags: wxRendererNative flags: wxCONTROL_ISSUBMENU: is drawing a list item instead of combo control 419 // wxCONTROL_SELECTED: list item is selected 420 // wxCONTROL_DISABLED: control/item is disabled 421 virtual void PrepareBackground( wxDC& dc, const wxRect& rect, int flags ) const; 422 423 // Returns true if focus indicator should be drawn in the control. ShouldDrawFocus()424 bool ShouldDrawFocus() const 425 { 426 const wxWindow* curFocus = FindFocus(); 427 return ( IsPopupWindowState(Hidden) && 428 (curFocus == m_mainCtrlWnd || (m_btn && curFocus == m_btn)) && 429 (m_windowStyle & wxCB_READONLY) ); 430 } 431 432 // These methods return references to appropriate dropbutton bitmaps GetBitmapNormal()433 const wxBitmap& GetBitmapNormal() const { return m_bmpNormal; } GetBitmapPressed()434 const wxBitmap& GetBitmapPressed() const { return m_bmpPressed; } GetBitmapHover()435 const wxBitmap& GetBitmapHover() const { return m_bmpHover; } GetBitmapDisabled()436 const wxBitmap& GetBitmapDisabled() const { return m_bmpDisabled; } 437 438 // Set custom style flags for embedded wxTextCtrl. Usually must be used 439 // with two-step creation, before Create() call. 440 void SetTextCtrlStyle( int style ); 441 442 // Return internal flags GetInternalFlags()443 wxUint32 GetInternalFlags() const { return m_iFlags; } 444 445 // Return true if Create has finished IsCreated()446 bool IsCreated() const { return m_iFlags & wxCC_IFLAG_CREATED ? true : false; } 447 448 // Need to override to return text area background colour 449 wxColour GetBackgroundColour() const; 450 451 // common code to be called on popup hide/dismiss 452 void OnPopupDismiss(bool generateEvent); 453 454 // PopupShown states 455 enum 456 { 457 Hidden = 0, 458 Closing = 1, 459 Animating = 2, 460 Visible = 3 461 }; 462 IsPopupWindowState(int state)463 bool IsPopupWindowState( int state ) const { return (state == m_popupWinState) ? true : false; } 464 GetPopupWindowState()465 wxByte GetPopupWindowState() const { return m_popupWinState; } 466 467 // Set value returned by GetMainWindowOfCompositeControl SetCtrlMainWnd(wxWindow * wnd)468 void SetCtrlMainWnd( wxWindow* wnd ) { m_mainCtrlWnd = wnd; } 469 470 // This is public so we can access it from wxComboCtrlTextCtrl GetMainWindowOfCompositeControl()471 virtual wxWindow *GetMainWindowOfCompositeControl() wxOVERRIDE 472 { return m_mainCtrlWnd; } 473 474 // also set the embedded wxTextCtrl colours 475 virtual bool SetForegroundColour(const wxColour& colour) wxOVERRIDE; 476 virtual bool SetBackgroundColour(const wxColour& colour) wxOVERRIDE; 477 478 protected: 479 480 // Returns true if hint text should be drawn in the control 481 bool ShouldUseHintText(int flags = 0) const 482 { 483 return ( !m_text && 484 !(flags & wxCONTROL_ISSUBMENU) && 485 m_valueString.empty() && 486 !m_hintText.empty() && 487 !ShouldDrawFocus() ); 488 } 489 490 // 491 // Override these for customization purposes 492 // 493 494 // called from wxSizeEvent handler 495 virtual void OnResize() = 0; 496 497 // Return native text indentation 498 // (i.e. text margin, for pure text, not textctrl) 499 virtual wxCoord GetNativeTextIndent() const; 500 501 // Called in syscolourchanged handler and base create 502 virtual void OnThemeChange(); 503 504 // Creates wxTextCtrl. 505 // extraStyle: Extra style parameters 506 void CreateTextCtrl( int extraStyle ); 507 508 // Called when text was changed programmatically 509 // (e.g. from WriteText()) 510 void OnSetValue(const wxString& value); 511 512 // Installs standard input handler to combo (and optionally to the textctrl) 513 void InstallInputHandlers(); 514 515 // Flags for DrawButton 516 enum 517 { 518 Button_PaintBackground = 0x0001, // Paints control background below the button 519 Button_BitmapOnly = 0x0002 // Only paints the bitmap 520 }; 521 522 // Draws dropbutton. Using wxRenderer or bitmaps, as appropriate. 523 // Flags are defined above. 524 virtual void DrawButton( wxDC& dc, const wxRect& rect, int flags = Button_PaintBackground ); 525 526 // Call if cursor is on button area or mouse is captured for the button. 527 //bool HandleButtonMouseEvent( wxMouseEvent& event, bool isInside ); 528 bool HandleButtonMouseEvent( wxMouseEvent& event, int flags ); 529 530 // returns true if event was consumed or filtered (event type is also set to 0 in this case) 531 bool PreprocessMouseEvent( wxMouseEvent& event, int flags ); 532 533 // 534 // This will handle left_down and left_dclick events outside button in a Windows-like manner. 535 // If you need alternate behaviour, it is recommended you manipulate and filter events to it 536 // instead of building your own handling routine (for reference, on wxEVT_LEFT_DOWN it will 537 // toggle popup and on wxEVT_LEFT_DCLICK it will do the same or run the popup's dclick method, 538 // if defined - you should pass events of other types of it for common processing). 539 void HandleNormalMouseEvent( wxMouseEvent& event ); 540 541 // Creates popup window, calls interface->Create(), etc 542 void CreatePopup(); 543 544 // Destroy popup window and all related constructs 545 void DestroyPopup(); 546 547 // override the base class virtuals involved in geometry calculations 548 // The common version only sets a default width, so the derived classes 549 // should override it and set the height and change the width as needed. 550 virtual wxSize DoGetBestSize() const wxOVERRIDE; 551 virtual wxSize DoGetSizeFromTextSize(int xlen, int ylen = -1) const wxOVERRIDE; 552 553 // NULL popup can be used to indicate default in a derived class 554 virtual void DoSetPopupControl(wxComboPopup* popup); 555 556 // ensures there is at least the default popup 557 void EnsurePopupControl(); 558 559 // Recalculates button and textctrl areas. Called when size or button setup change. 560 // btnWidth: default/calculated width of the dropbutton. 0 means unchanged, 561 // just recalculate. 562 void CalculateAreas( int btnWidth = 0 ); 563 564 // Standard textctrl positioning routine. Just give it platform-dependent 565 // textctrl coordinate adjustment. 566 virtual void PositionTextCtrl( int textCtrlXAdjust = 0, 567 int textCtrlYAdjust = 0); 568 569 // event handlers 570 void OnSizeEvent( wxSizeEvent& event ); 571 void OnFocusEvent(wxFocusEvent& event); 572 void OnIdleEvent(wxIdleEvent& event); 573 void OnTextCtrlEvent(wxCommandEvent& event); 574 void OnSysColourChanged(wxSysColourChangedEvent& event); 575 void OnKeyEvent(wxKeyEvent& event); 576 void OnCharEvent(wxKeyEvent& event); 577 578 // Set customization flags (directs how wxComboCtrlBase helpers behave) Customize(wxUint32 flags)579 void Customize( wxUint32 flags ) { m_iFlags |= flags; } 580 581 // Dispatches size event and refreshes 582 void RecalcAndRefresh(); 583 584 // Flags for DoShowPopup and AnimateShow 585 enum 586 { 587 ShowBelow = 0x0000, // Showing popup below the control 588 ShowAbove = 0x0001, // Showing popup above the control 589 CanDeferShow = 0x0002 // Can only return true from AnimateShow if this is set 590 }; 591 592 // Shows and positions the popup. 593 virtual void DoShowPopup( const wxRect& rect, int flags ); 594 595 // Implement in derived class to create a drop-down animation. 596 // Return true if finished immediately. Otherwise popup is only 597 // shown when the derived class call DoShowPopup. 598 // Flags are same as for DoShowPopup. 599 virtual bool AnimateShow( const wxRect& rect, int flags ); 600 601 #if wxUSE_TOOLTIPS 602 virtual void DoSetToolTip( wxToolTip *tip ) wxOVERRIDE; 603 #endif 604 605 // protected wxTextEntry methods 606 virtual void DoSetValue(const wxString& value, int flags) wxOVERRIDE; 607 virtual wxString DoGetValue() const wxOVERRIDE; GetEditableWindow()608 virtual wxWindow *GetEditableWindow() wxOVERRIDE { return this; } 609 610 // margins functions 611 virtual bool DoSetMargins(const wxPoint& pt) wxOVERRIDE; 612 virtual wxPoint DoGetMargins() const wxOVERRIDE; 613 614 // This is used when m_text is hidden (readonly). 615 wxString m_valueString; 616 617 // This is used when control is unfocused and m_valueString is empty 618 wxString m_hintText; 619 620 // the text control and button we show all the time 621 wxTextCtrl* m_text; 622 wxWindow* m_btn; 623 624 // wxPopupWindow or similar containing the window managed by the interface. 625 wxWindow* m_winPopup; 626 627 // the popup control/panel 628 wxWindow* m_popup; 629 630 // popup interface 631 wxComboPopup* m_popupInterface; 632 633 // this is input etc. handler for the text control 634 wxEvtHandler* m_textEvtHandler; 635 636 // this is for the top level window 637 wxEvtHandler* m_toplevEvtHandler; 638 639 // this is for the control in popup 640 wxEvtHandler* m_popupEvtHandler; 641 642 // this is for the popup window 643 wxEvtHandler* m_popupWinEvtHandler; 644 645 // main (ie. topmost) window of a composite control (default = this) 646 wxWindow* m_mainCtrlWnd; 647 648 // used to prevent immediate re-popupping in case closed popup 649 // by clicking on the combo control (needed because of inconsistent 650 // transient implementation across platforms). 651 wxMilliClock_t m_timeCanAcceptClick; 652 653 // how much popup should expand to the left/right of the control 654 wxCoord m_extLeft; 655 wxCoord m_extRight; 656 657 // minimum popup width 658 wxCoord m_widthMinPopup; 659 660 // preferred popup height 661 wxCoord m_heightPopup; 662 663 // how much of writable combo is custom-paint by callback? 664 // also used to indicate area that is not covered by "blue" 665 // selection indicator. 666 wxCoord m_widthCustomPaint; 667 668 // left margin, in pixels 669 wxCoord m_marginLeft; 670 671 // side on which the popup is aligned 672 int m_anchorSide; 673 674 // Width of the "fake" border 675 wxCoord m_widthCustomBorder; 676 677 // The button and textctrl click/paint areas 678 wxRect m_tcArea; 679 wxRect m_btnArea; 680 681 // Colour of the text area, in case m_text is NULL 682 wxColour m_tcBgCol; 683 684 // current button state (uses renderer flags) 685 int m_btnState; 686 687 // button position 688 int m_btnWid; 689 int m_btnHei; 690 int m_btnSide; 691 int m_btnSpacingX; 692 693 // last default button width 694 int m_btnWidDefault; 695 696 // custom dropbutton bitmaps 697 wxBitmap m_bmpNormal; 698 wxBitmap m_bmpPressed; 699 wxBitmap m_bmpHover; 700 wxBitmap m_bmpDisabled; 701 702 // area used by the button 703 wxSize m_btnSize; 704 705 // platform-dependent customization and other flags 706 wxUint32 m_iFlags; 707 708 // custom style for m_text 709 int m_textCtrlStyle; 710 711 // draw blank button background under bitmap? 712 bool m_blankButtonBg; 713 714 // is the popup window currently shown? 715 wxByte m_popupWinState; 716 717 // should the focus be reset to the textctrl in idle time? 718 bool m_resetFocus; 719 720 // is the text-area background colour overridden? 721 bool m_hasTcBgCol; 722 723 private: 724 void Init(); 725 726 wxByte m_ignoreEvtText; // Number of next EVT_TEXTs to ignore 727 728 // Is popup window wxPopupTransientWindow, wxPopupWindow or wxDialog? 729 wxByte m_popupWinType; 730 731 wxDECLARE_EVENT_TABLE(); 732 733 wxDECLARE_ABSTRACT_CLASS(wxComboCtrlBase); 734 }; 735 736 737 // ---------------------------------------------------------------------------- 738 // wxComboPopup is the interface which must be implemented by a control to be 739 // used as a popup by wxComboCtrl 740 // ---------------------------------------------------------------------------- 741 742 743 // wxComboPopup internal flags 744 enum 745 { 746 wxCP_IFLAG_CREATED = 0x0001 // Set by wxComboCtrlBase after Create is called 747 }; 748 749 class WXDLLIMPEXP_FWD_CORE wxComboCtrl; 750 751 752 class WXDLLIMPEXP_CORE wxComboPopup 753 { 754 friend class wxComboCtrlBase; 755 public: wxComboPopup()756 wxComboPopup() 757 { 758 m_combo = NULL; 759 m_iFlags = 0; 760 } 761 762 // This is called immediately after construction finishes. m_combo member 763 // variable has been initialized before the call. 764 // NOTE: It is not in constructor so the derived class doesn't need to redefine 765 // a default constructor of its own. Init()766 virtual void Init() { } 767 768 virtual ~wxComboPopup(); 769 770 // Create the popup child control. 771 // Return true for success. 772 virtual bool Create(wxWindow* parent) = 0; 773 774 // Calls Destroy() for the popup control (i.e. one returned by 775 // GetControl()) and makes sure that 'this' is deleted at the end. 776 // Default implementation works for both cases where popup control 777 // class is multiple inherited or created on heap as a separate 778 // object. 779 virtual void DestroyPopup(); 780 781 // We must have an associated control which is subclassed by the combobox. 782 virtual wxWindow *GetControl() = 0; 783 784 // Called immediately after the popup is shown 785 virtual void OnPopup(); 786 787 // Called when popup is dismissed 788 virtual void OnDismiss(); 789 790 // Called just prior to displaying popup. 791 // Default implementation does nothing. 792 virtual void SetStringValue( const wxString& value ); 793 794 // Gets displayed string representation of the value. 795 virtual wxString GetStringValue() const = 0; 796 797 // Called to check if the popup - when an item container - actually 798 // has matching item. Case-sensitivity checking etc. is up to the 799 // implementation. If the found item matched the string, but is 800 // different, it should be written back to pItem. Default implementation 801 // always return true and does not alter trueItem. 802 virtual bool FindItem(const wxString& item, wxString* trueItem=NULL); 803 804 // This is called to custom paint in the combo control itself (ie. not the popup). 805 // Default implementation draws value as string. 806 virtual void PaintComboControl( wxDC& dc, const wxRect& rect ); 807 808 // Receives wxEVT_KEY_DOWN key events from the parent wxComboCtrl. 809 // Events not handled should be skipped, as usual. 810 virtual void OnComboKeyEvent( wxKeyEvent& event ); 811 812 // Receives wxEVT_CHAR key events from the parent wxComboCtrl. 813 // Events not handled should be skipped, as usual. 814 virtual void OnComboCharEvent( wxKeyEvent& event ); 815 816 // Implement if you need to support special action when user 817 // double-clicks on the parent wxComboCtrl. 818 virtual void OnComboDoubleClick(); 819 820 // Return final size of popup. Called on every popup, just prior to OnShow. 821 // minWidth = preferred minimum width for window 822 // prefHeight = preferred height. Only applies if > 0, 823 // maxHeight = max height for window, as limited by screen size 824 // and should only be rounded down, if necessary. 825 virtual wxSize GetAdjustedSize( int minWidth, int prefHeight, int maxHeight ); 826 827 // Return true if you want delay call to Create until the popup is shown 828 // for the first time. It is more efficient, but note that it is often 829 // more convenient to have the control created immediately. 830 // Default returns false. 831 virtual bool LazyCreate(); 832 833 // 834 // Utilities 835 // 836 837 // Hides the popup 838 void Dismiss(); 839 840 // Returns true if Create has been called. IsCreated()841 bool IsCreated() const 842 { 843 return (m_iFlags & wxCP_IFLAG_CREATED) ? true : false; 844 } 845 846 // Returns pointer to the associated parent wxComboCtrl. 847 wxComboCtrl* GetComboCtrl() const; 848 849 // Default PaintComboControl behaviour 850 static void DefaultPaintComboControl( wxComboCtrlBase* combo, 851 wxDC& dc, 852 const wxRect& rect ); 853 854 protected: 855 wxComboCtrlBase* m_combo; 856 wxUint32 m_iFlags; 857 858 private: 859 // Called in wxComboCtrlBase::SetPopupControl InitBase(wxComboCtrlBase * combo)860 void InitBase(wxComboCtrlBase *combo) 861 { 862 m_combo = combo; 863 } 864 }; 865 866 867 // ---------------------------------------------------------------------------- 868 // include the platform-dependent header defining the real class 869 // ---------------------------------------------------------------------------- 870 871 #if defined(__WXUNIVERSAL__) 872 // No native universal (but it must still be first in the list) 873 #elif defined(__WXMSW__) 874 #include "wx/msw/combo.h" 875 #endif 876 877 // Any ports may need generic as an alternative 878 #include "wx/generic/combo.h" 879 880 #endif // wxUSE_COMBOCTRL 881 882 #endif 883 // _WX_COMBOCONTROL_H_BASE_ 884