]> git.saurik.com Git - wxWidgets.git/blob - include/wx/combo.h
Fixes for OpenVMS on IA64
[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 #include "wx/textentry.h"
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
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();
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
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
185 void SetPopupControl( wxComboPopup* popup )
186 {
187 DoSetPopupControl(popup);
188 }
189
190 // get interface class instance derived from wxComboPopup
191 wxComboPopup* GetPopupControl()
192 {
193 EnsurePopupControl();
194 return m_popupInterface;
195 }
196
197 // get the popup window containing the popup control
198 wxWindow *GetPopupWindow() const { return m_winPopup; }
199
200 // Get the text control which is part of the combobox.
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
205 wxWindow *GetButton() const { return m_btn; }
206
207 // forward these methods to all subcontrols
208 virtual bool Enable(bool enable = true);
209 virtual bool Show(bool show = true);
210 virtual bool SetFont(const wxFont& font);
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 //
218 virtual void SetValue(const wxString& value)
219 { wxTextEntryBase::SetValue(value); }
220 virtual void ChangeValue(const wxString& value)
221 { wxTextEntryBase::ChangeValue(value); }
222
223 virtual void WriteText(const wxString& text);
224 virtual void AppendText(const wxString& text)
225 { wxTextEntryBase::AppendText(text); }
226
227 virtual wxString GetValue() const
228 { return wxTextEntryBase::GetValue(); }
229
230 virtual wxString GetRange(long from, long to) const
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);
237
238 virtual void Remove(long from, long to);
239
240 virtual void Copy();
241 virtual void Cut();
242 virtual void Paste();
243
244 virtual void Undo();
245 virtual void Redo();
246 virtual bool CanUndo() const;
247 virtual bool CanRedo() const;
248
249 virtual void SetInsertionPoint(long pos);
250 virtual long GetInsertionPoint() const;
251 virtual long GetLastPosition() const;
252
253 virtual void SetSelection(long from, long to);
254 virtual void GetSelection(long *from, long *to) const;
255
256 virtual bool IsEditable() const;
257 virtual void SetEditable(bool editable);
258
259 virtual bool SetHint(const wxString& hint);
260 virtual wxString GetHint() const;
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).
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).
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).
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 );
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.
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 centered 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.
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 // Utilies 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.
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
433 const wxBitmap& GetBitmapNormal() const { return m_bmpNormal; }
434 const wxBitmap& GetBitmapPressed() const { return m_bmpPressed; }
435 const wxBitmap& GetBitmapHover() const { return m_bmpHover; }
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
443 wxUint32 GetInternalFlags() const { return m_iFlags; }
444
445 // Return true if Create has finished
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
463 bool IsPopupWindowState( int state ) const { return (state == m_popupWinState) ? true : false; }
464
465 wxByte GetPopupWindowState() const { return m_popupWinState; }
466
467 // Set value returned by GetMainWindowOfCompositeControl
468 void SetCtrlMainWnd( wxWindow* wnd ) { m_mainCtrlWnd = wnd; }
469
470 // This is public so we can access it from wxComboCtrlTextCtrl
471 virtual wxWindow *GetMainWindowOfCompositeControl()
472 { return m_mainCtrlWnd; }
473
474 protected:
475
476 // Returns true if hint text should be drawn in the control
477 bool ShouldUseHintText(int flags = 0) const
478 {
479 return ( !m_text &&
480 !(flags & wxCONTROL_ISSUBMENU) &&
481 !m_valueString.length() &&
482 m_hintText.length() &&
483 !ShouldDrawFocus() );
484 }
485
486 //
487 // Override these for customization purposes
488 //
489
490 // called from wxSizeEvent handler
491 virtual void OnResize() = 0;
492
493 // Return native text identation
494 // (i.e. text margin, for pure text, not textctrl)
495 virtual wxCoord GetNativeTextIndent() const;
496
497 // Called in syscolourchanged handler and base create
498 virtual void OnThemeChange();
499
500 // Creates wxTextCtrl.
501 // extraStyle: Extra style parameters
502 void CreateTextCtrl( int extraStyle );
503
504 // Called when text was changed programmatically
505 // (e.g. from WriteText())
506 void OnSetValue(const wxString& value);
507
508 // Installs standard input handler to combo (and optionally to the textctrl)
509 void InstallInputHandlers();
510
511 // Flags for DrawButton
512 enum
513 {
514 Button_PaintBackground = 0x0001, // Paints control background below the button
515 Button_BitmapOnly = 0x0002 // Only paints the bitmap
516 };
517
518 // Draws dropbutton. Using wxRenderer or bitmaps, as appropriate.
519 // Flags are defined above.
520 virtual void DrawButton( wxDC& dc, const wxRect& rect, int flags = Button_PaintBackground );
521
522 // Call if cursor is on button area or mouse is captured for the button.
523 //bool HandleButtonMouseEvent( wxMouseEvent& event, bool isInside );
524 bool HandleButtonMouseEvent( wxMouseEvent& event, int flags );
525
526 // returns true if event was consumed or filtered (event type is also set to 0 in this case)
527 bool PreprocessMouseEvent( wxMouseEvent& event, int flags );
528
529 //
530 // This will handle left_down and left_dclick events outside button in a Windows-like manner.
531 // If you need alternate behaviour, it is recommended you manipulate and filter events to it
532 // instead of building your own handling routine (for reference, on wxEVT_LEFT_DOWN it will
533 // toggle popup and on wxEVT_LEFT_DCLICK it will do the same or run the popup's dclick method,
534 // if defined - you should pass events of other types of it for common processing).
535 void HandleNormalMouseEvent( wxMouseEvent& event );
536
537 // Creates popup window, calls interface->Create(), etc
538 void CreatePopup();
539
540 // Destroy popup window and all related constructs
541 void DestroyPopup();
542
543 // override the base class virtuals involved in geometry calculations
544 virtual wxSize DoGetBestSize() const;
545
546 // also set the embedded wxTextCtrl colours
547 virtual bool SetForegroundColour(const wxColour& colour);
548 virtual bool SetBackgroundColour(const wxColour& colour);
549
550 // NULL popup can be used to indicate default in a derived class
551 virtual void DoSetPopupControl(wxComboPopup* popup);
552
553 // ensures there is atleast the default popup
554 void EnsurePopupControl();
555
556 // Recalculates button and textctrl areas. Called when size or button setup change.
557 // btnWidth: default/calculated width of the dropbutton. 0 means unchanged,
558 // just recalculate.
559 void CalculateAreas( int btnWidth = 0 );
560
561 // Standard textctrl positioning routine. Just give it platform-dependant
562 // textctrl coordinate adjustment.
563 virtual void PositionTextCtrl( int textCtrlXAdjust, int textCtrlYAdjust );
564
565 // event handlers
566 void OnSizeEvent( wxSizeEvent& event );
567 void OnFocusEvent(wxFocusEvent& event);
568 void OnIdleEvent(wxIdleEvent& event);
569 void OnTextCtrlEvent(wxCommandEvent& event);
570 void OnSysColourChanged(wxSysColourChangedEvent& event);
571 void OnKeyEvent(wxKeyEvent& event);
572 void OnCharEvent(wxKeyEvent& event);
573
574 // Set customization flags (directs how wxComboCtrlBase helpers behave)
575 void Customize( wxUint32 flags ) { m_iFlags |= flags; }
576
577 // Dispatches size event and refreshes
578 void RecalcAndRefresh();
579
580 // Flags for DoShowPopup and AnimateShow
581 enum
582 {
583 ShowBelow = 0x0000, // Showing popup below the control
584 ShowAbove = 0x0001, // Showing popup above the control
585 CanDeferShow = 0x0002 // Can only return true from AnimateShow if this is set
586 };
587
588 // Shows and positions the popup.
589 virtual void DoShowPopup( const wxRect& rect, int flags );
590
591 // Implement in derived class to create a drop-down animation.
592 // Return true if finished immediately. Otherwise popup is only
593 // shown when the derived class call DoShowPopup.
594 // Flags are same as for DoShowPopup.
595 virtual bool AnimateShow( const wxRect& rect, int flags );
596
597 #if wxUSE_TOOLTIPS
598 virtual void DoSetToolTip( wxToolTip *tip );
599 #endif
600
601 // protected wxTextEntry methods
602 virtual void DoSetValue(const wxString& value, int flags);
603 virtual wxString DoGetValue() const;
604 virtual wxWindow *GetEditableWindow() { return this; }
605
606 // margins functions
607 virtual bool DoSetMargins(const wxPoint& pt);
608 virtual wxPoint DoGetMargins() const;
609
610 // This is used when m_text is hidden (readonly).
611 wxString m_valueString;
612
613 // This is used when control is unfocused and m_valueString is empty
614 wxString m_hintText;
615
616 // the text control and button we show all the time
617 wxTextCtrl* m_text;
618 wxWindow* m_btn;
619
620 // wxPopupWindow or similar containing the window managed by the interface.
621 wxWindow* m_winPopup;
622
623 // the popup control/panel
624 wxWindow* m_popup;
625
626 // popup interface
627 wxComboPopup* m_popupInterface;
628
629 // this is input etc. handler for the text control
630 wxEvtHandler* m_textEvtHandler;
631
632 // this is for the top level window
633 wxEvtHandler* m_toplevEvtHandler;
634
635 // this is for the control in popup
636 wxEvtHandler* m_popupEvtHandler;
637
638 // this is for the popup window
639 wxEvtHandler* m_popupWinEvtHandler;
640
641 // main (ie. topmost) window of a composite control (default = this)
642 wxWindow* m_mainCtrlWnd;
643
644 // used to prevent immediate re-popupping in case closed popup
645 // by clicking on the combo control (needed because of inconsistent
646 // transient implementation across platforms).
647 wxLongLong m_timeCanAcceptClick;
648
649 // how much popup should expand to the left/right of the control
650 wxCoord m_extLeft;
651 wxCoord m_extRight;
652
653 // minimum popup width
654 wxCoord m_widthMinPopup;
655
656 // preferred popup height
657 wxCoord m_heightPopup;
658
659 // how much of writable combo is custom-paint by callback?
660 // also used to indicate area that is not covered by "blue"
661 // selection indicator.
662 wxCoord m_widthCustomPaint;
663
664 // left margin, in pixels
665 wxCoord m_marginLeft;
666
667 // side on which the popup is aligned
668 int m_anchorSide;
669
670 // Width of the "fake" border
671 wxCoord m_widthCustomBorder;
672
673 // The button and textctrl click/paint areas
674 wxRect m_tcArea;
675 wxRect m_btnArea;
676
677 // Colour of the text area, in case m_text is NULL
678 wxColour m_tcBgCol;
679
680 // current button state (uses renderer flags)
681 int m_btnState;
682
683 // button position
684 int m_btnWid;
685 int m_btnHei;
686 int m_btnSide;
687 int m_btnSpacingX;
688
689 // last default button width
690 int m_btnWidDefault;
691
692 // custom dropbutton bitmaps
693 wxBitmap m_bmpNormal;
694 wxBitmap m_bmpPressed;
695 wxBitmap m_bmpHover;
696 wxBitmap m_bmpDisabled;
697
698 // area used by the button
699 wxSize m_btnSize;
700
701 // platform-dependant customization and other flags
702 wxUint32 m_iFlags;
703
704 // custom style for m_text
705 int m_textCtrlStyle;
706
707 // draw blank button background under bitmap?
708 bool m_blankButtonBg;
709
710 // is the popup window currenty shown?
711 wxByte m_popupWinState;
712
713 // should the focus be reset to the textctrl in idle time?
714 bool m_resetFocus;
715
716 // is the text-area background colour overridden?
717 bool m_hasTcBgCol;
718
719 private:
720 void Init();
721
722 wxByte m_ignoreEvtText; // Number of next EVT_TEXTs to ignore
723
724 // Is popup window wxPopupTransientWindow, wxPopupWindow or wxDialog?
725 wxByte m_popupWinType;
726
727 DECLARE_EVENT_TABLE()
728
729 DECLARE_ABSTRACT_CLASS(wxComboCtrlBase)
730 };
731
732
733 // ----------------------------------------------------------------------------
734 // wxComboPopup is the interface which must be implemented by a control to be
735 // used as a popup by wxComboCtrl
736 // ----------------------------------------------------------------------------
737
738
739 // wxComboPopup internal flags
740 enum
741 {
742 wxCP_IFLAG_CREATED = 0x0001 // Set by wxComboCtrlBase after Create is called
743 };
744
745 class WXDLLIMPEXP_FWD_CORE wxComboCtrl;
746
747
748 class WXDLLIMPEXP_CORE wxComboPopup
749 {
750 friend class wxComboCtrlBase;
751 public:
752 wxComboPopup()
753 {
754 m_combo = NULL;
755 m_iFlags = 0;
756 }
757
758 // This is called immediately after construction finishes. m_combo member
759 // variable has been initialized before the call.
760 // NOTE: It is not in constructor so the derived class doesn't need to redefine
761 // a default constructor of its own.
762 virtual void Init() { }
763
764 virtual ~wxComboPopup();
765
766 // Create the popup child control.
767 // Return true for success.
768 virtual bool Create(wxWindow* parent) = 0;
769
770 // Calls Destroy() for the popup control (i.e. one returned by
771 // GetControl()) and makes sure that 'this' is deleted at the end.
772 // Default implementation works for both cases where popup control
773 // class is multiple inherited or created on heap as a separate
774 // object.
775 virtual void DestroyPopup();
776
777 // We must have an associated control which is subclassed by the combobox.
778 virtual wxWindow *GetControl() = 0;
779
780 // Called immediately after the popup is shown
781 virtual void OnPopup();
782
783 // Called when popup is dismissed
784 virtual void OnDismiss();
785
786 // Called just prior to displaying popup.
787 // Default implementation does nothing.
788 virtual void SetStringValue( const wxString& value );
789
790 // Gets displayed string representation of the value.
791 virtual wxString GetStringValue() const = 0;
792
793 // Called to check if the popup - when an item container - actually
794 // has matching item. Case-sensitivity checking etc. is up to the
795 // implementation. If the found item matched the string, but is
796 // different, it should be written back to pItem. Default implementation
797 // always return true and does not alter trueItem.
798 virtual bool FindItem(const wxString& item, wxString* trueItem=NULL);
799
800 // This is called to custom paint in the combo control itself (ie. not the popup).
801 // Default implementation draws value as string.
802 virtual void PaintComboControl( wxDC& dc, const wxRect& rect );
803
804 // Receives wxEVT_KEY_DOWN key events from the parent wxComboCtrl.
805 // Events not handled should be skipped, as usual.
806 virtual void OnComboKeyEvent( wxKeyEvent& event );
807
808 // Receives wxEVT_CHAR key events from the parent wxComboCtrl.
809 // Events not handled should be skipped, as usual.
810 virtual void OnComboCharEvent( wxKeyEvent& event );
811
812 // Implement if you need to support special action when user
813 // double-clicks on the parent wxComboCtrl.
814 virtual void OnComboDoubleClick();
815
816 // Return final size of popup. Called on every popup, just prior to OnShow.
817 // minWidth = preferred minimum width for window
818 // prefHeight = preferred height. Only applies if > 0,
819 // maxHeight = max height for window, as limited by screen size
820 // and should only be rounded down, if necessary.
821 virtual wxSize GetAdjustedSize( int minWidth, int prefHeight, int maxHeight );
822
823 // Return true if you want delay call to Create until the popup is shown
824 // for the first time. It is more efficient, but note that it is often
825 // more convenient to have the control created immediately.
826 // Default returns false.
827 virtual bool LazyCreate();
828
829 //
830 // Utilies
831 //
832
833 // Hides the popup
834 void Dismiss();
835
836 // Returns true if Create has been called.
837 bool IsCreated() const
838 {
839 return (m_iFlags & wxCP_IFLAG_CREATED) ? true : false;
840 }
841
842 // Returns pointer to the associated parent wxComboCtrl.
843 wxComboCtrl* GetComboCtrl() const;
844
845 // Default PaintComboControl behaviour
846 static void DefaultPaintComboControl( wxComboCtrlBase* combo,
847 wxDC& dc,
848 const wxRect& rect );
849
850 protected:
851 wxComboCtrlBase* m_combo;
852 wxUint32 m_iFlags;
853
854 private:
855 // Called in wxComboCtrlBase::SetPopupControl
856 void InitBase(wxComboCtrlBase *combo)
857 {
858 m_combo = combo;
859 }
860 };
861
862
863 // ----------------------------------------------------------------------------
864 // include the platform-dependent header defining the real class
865 // ----------------------------------------------------------------------------
866
867 #if defined(__WXUNIVERSAL__)
868 // No native universal (but it must still be first in the list)
869 #elif defined(__WXMSW__)
870 #include "wx/msw/combo.h"
871 #endif
872
873 // Any ports may need generic as an alternative
874 #include "wx/generic/combo.h"
875
876 #endif // wxUSE_COMBOCTRL
877
878 #endif
879 // _WX_COMBOCONTROL_H_BASE_