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