]> git.saurik.com Git - wxWidgets.git/blame - include/wx/combo.h
implemented SetFocus
[wxWidgets.git] / include / wx / combo.h
CommitLineData
a340b80d
VZ
1///////////////////////////////////////////////////////////////////////////////
2// Name: wx/combo.h
a57d600f 3// Purpose: wxComboCtrl declaration
a340b80d 4// Author: Jaakko Salli
40b26d75 5// Modified by:
a340b80d
VZ
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
a57d600f 18 order: why do we need extra wxComboCtrl and wxComboPopup classes?
a340b80d
VZ
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
a57d600f 26 So we define a base wxComboCtrl which can use any control as pop down
a340b80d 27 list and wxComboBox deriving from it which implements the standard wxWidgets
a57d600f 28 combobox API. wxComboCtrl needs to be told somehow which control to use
a340b80d
VZ
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
a57d600f 43#if wxUSE_COMBOCTRL
a340b80d 44
dbaf49a9 45#include "wx/control.h"
a340b80d 46#include "wx/renderer.h" // this is needed for wxCONTROL_XXX flags
7e983dab 47#include "wx/bitmap.h" // wxBitmap used by-value
a340b80d 48
dbaf49a9 49class WXDLLIMPEXP_CORE wxTextCtrl;
a340b80d
VZ
50class WXDLLEXPORT wxComboPopup;
51
52//
a57d600f 53// New window styles for wxComboCtrlBase
a340b80d
VZ
54//
55enum
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
a340b80d 61 // Dropbutton acts like standard push button.
21d6b09b 62 wxCC_STD_BUTTON = 0x0200
a340b80d
VZ
63};
64
65
a57d600f 66// wxComboCtrl internal flags
a340b80d
VZ
67enum
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
79 // Internal use: signals creation is complete
80 wxCC_IFLAG_CREATED = 0x0100,
81 // Internal use: really put button outside
82 wxCC_IFLAG_BUTTON_OUTSIDE = 0x0200,
83 // Internal use: SetTextIndent has been called
84 wxCC_IFLAG_INDENT_SET = 0x0400,
85 // Internal use: Set wxTAB_TRAVERSAL to parent when popup is dismissed
899eacc7 86 wxCC_IFLAG_PARENT_TAB_TRAVERSAL = 0x0800
a340b80d
VZ
87};
88
89
90// Flags used by PreprocessMouseEvent and HandleButtonMouseEvent
91enum
92{
899eacc7 93 wxCC_MF_ON_BUTTON = 0x0001 // cursor is on dropbutton area
a340b80d
VZ
94};
95
96
a57d600f
VZ
97// Namespace for wxComboCtrl feature flags
98struct wxComboCtrlFeatures
a340b80d
VZ
99{
100 enum
101 {
102 MovableButton = 0x0001, // Button can be on either side of control
103 BitmapButton = 0x0002, // Button may be replaced with bitmap
104 ButtonSpacing = 0x0004, // Button can have spacing from the edge
105 // of the control
106 TextIndent = 0x0008, // SetTextIndent can be used
107 PaintControl = 0x0010, // Combo control itself can be custom painted
108 PaintWritable = 0x0020, // A variable-width area in front of writable
109 // combo control's textctrl can be custom
110 // painted
111 Borderless = 0x0040, // wxNO_BORDER window style works
112
113 // There are no feature flags for...
114 // PushButtonBitmapBackground - if its in wxRendererNative, then it should be
115 // not an issue to have it automatically under the bitmap.
116
117 All = MovableButton|BitmapButton|
118 ButtonSpacing|TextIndent|
119 PaintControl|PaintWritable|
899eacc7 120 Borderless
a340b80d
VZ
121 };
122};
123
124
a57d600f 125class WXDLLEXPORT wxComboCtrlBase : public wxControl
a340b80d
VZ
126{
127 friend class wxComboPopup;
128public:
129 // ctors and such
a57d600f 130 wxComboCtrlBase() : wxControl() { Init(); }
a340b80d
VZ
131
132 bool Create(wxWindow *parent,
133 wxWindowID id,
134 const wxString& value,
135 const wxPoint& pos,
136 const wxSize& size,
137 long style,
138 const wxValidator& validator,
139 const wxString& name);
140
a57d600f 141 virtual ~wxComboCtrlBase();
a340b80d
VZ
142
143 // show/hide popup window
144 virtual void ShowPopup();
145 virtual void HidePopup();
146
147 // Override for totally custom combo action
148 virtual void OnButtonClick();
149
150 // return true if the popup is currently shown
151 bool IsPopupShown() const { return m_isPopupShown; }
152
153 // set interface class instance derived from wxComboPopup
6d0ce565 154 // NULL popup can be used to indicate default in a derived class
db53c6ea
WS
155 void SetPopupControl( wxComboPopup* popup )
156 {
157 DoSetPopupControl(popup);
158 }
a340b80d
VZ
159
160 // get interface class instance derived from wxComboPopup
e4e11217
WS
161 wxComboPopup* GetPopupControl()
162 {
163 EnsurePopupControl();
164 return m_popupInterface;
165 }
a340b80d
VZ
166
167 // get the popup window containing the popup control
168 wxWindow *GetPopupWindow() const { return m_winPopup; }
169
a340b80d
VZ
170 // Get the text control which is part of the combobox.
171 wxTextCtrl *GetTextCtrl() const { return m_text; }
172
173 // get the dropdown button which is part of the combobox
174 // note: its not necessarily a wxButton or wxBitmapButton
175 wxWindow *GetButton() const { return m_btn; }
176
177 // forward these methods to all subcontrols
178 virtual bool Enable(bool enable = true);
179 virtual bool Show(bool show = true);
180 virtual bool SetFont(const wxFont& font);
a340b80d
VZ
181
182 // wxTextCtrl methods - for readonly combo they should return
183 // without errors.
184 virtual wxString GetValue() const;
185 virtual void SetValue(const wxString& value);
186 virtual void Copy();
187 virtual void Cut();
188 virtual void Paste();
189 virtual void SetInsertionPoint(long pos);
190 virtual void SetInsertionPointEnd();
191 virtual long GetInsertionPoint() const;
192 virtual long GetLastPosition() const;
193 virtual void Replace(long from, long to, const wxString& value);
194 virtual void Remove(long from, long to);
195 virtual void SetSelection(long from, long to);
196 virtual void Undo();
197
6d0ce565
VZ
198 // This method sets the text without affecting list selection
199 // (ie. wxComboPopup::SetStringValue doesn't get called).
200 void SetText(const wxString& value);
201
a340b80d
VZ
202 //
203 // Popup customization methods
204 //
205
206 // Sets minimum width of the popup. If wider than combo control, it will extend to the left.
207 // Remarks:
208 // * Value -1 indicates the default.
209 // * Custom popup may choose to ignore this (wxOwnerDrawnComboBox does not).
210 void SetPopupMinWidth( int width )
211 {
212 m_widthMinPopup = width;
213 }
214
215 // Sets preferred maximum height of the popup.
216 // Remarks:
217 // * Value -1 indicates the default.
218 // * Custom popup may choose to ignore this (wxOwnerDrawnComboBox does not).
219 void SetPopupMaxHeight( int height )
220 {
221 m_heightPopup = height;
222 }
223
224 // Extends popup size horizontally, relative to the edges of the combo control.
225 // Remarks:
226 // * Popup minimum width may override extLeft (ie. it has higher precedence).
227 // * Values 0 indicate default.
228 // * Custom popup may not take this fully into account (wxOwnerDrawnComboBox takes).
229 void SetPopupExtents( int extLeft, int extRight )
230 {
231 m_extLeft = extLeft;
232 m_extRight = extRight;
233 }
234
235 // Set width, in pixels, of custom paint area in writable combo.
236 // In read-only, used to indicate area that is not covered by the
237 // focus rectangle (which may or may not be drawn, depending on the
238 // popup type).
239 void SetCustomPaintWidth( int width );
240 int GetCustomPaintWidth() const { return m_widthCustomPaint; }
241
242 // Set side of the control to which the popup will align itself.
243 // Valid values are wxLEFT, wxRIGHT and 0. The default value 0 wmeans
244 // that the side of the button will be used.
245 void SetPopupAnchor( int anchorSide )
246 {
247 m_anchorSide = anchorSide;
248 }
249
250 // Set position of dropdown button.
7dc234d6
WS
251 // width: button width. <= 0 for default.
252 // height: button height. <= 0 for default.
a340b80d
VZ
253 // side: wxLEFT or wxRIGHT, indicates on which side the button will be placed.
254 // spacingX: empty space on sides of the button. Default is 0.
255 // Remarks:
256 // There is no spacingY - the button will be centered vertically.
7dc234d6
WS
257 void SetButtonPosition( int width = -1,
258 int height = -1,
6d0ce565
VZ
259 int side = wxRIGHT,
260 int spacingX = 0 );
a340b80d 261
7dc234d6
WS
262 // Returns current size of the dropdown button.
263 wxSize GetButtonSize();
a340b80d
VZ
264
265 //
266 // Sets dropbutton to be drawn with custom bitmaps.
267 //
268 // bmpNormal: drawn when cursor is not on button
6d0ce565
VZ
269 // pushButtonBg: Draw push button background below the image.
270 // NOTE! This is usually only properly supported on platforms with appropriate
271 // method in wxRendererNative.
a340b80d
VZ
272 // bmpPressed: drawn when button is depressed
273 // bmpHover: drawn when cursor hovers on button. This is ignored on platforms
274 // that do not generally display hover differently.
275 // bmpDisabled: drawn when combobox is disabled.
276 void SetButtonBitmaps( const wxBitmap& bmpNormal,
6d0ce565 277 bool pushButtonBg = false,
a340b80d
VZ
278 const wxBitmap& bmpPressed = wxNullBitmap,
279 const wxBitmap& bmpHover = wxNullBitmap,
280 const wxBitmap& bmpDisabled = wxNullBitmap );
281
282 //
283 // This will set the space in pixels between left edge of the control and the
284 // text, regardless whether control is read-only (ie. no wxTextCtrl) or not.
285 // Platform-specific default can be set with value-1.
286 // Remarks
287 // * This method may do nothing on some native implementations.
288 void SetTextIndent( int indent );
289
290 // Returns actual indentation in pixels.
291 wxCoord GetTextIndent() const
292 {
293 return m_absIndent;
294 }
295
b104d1f0
RR
296 // Returns area covered by the text field.
297 const wxRect& GetTextRect() const
298 {
299 return m_tcArea;
300 }
301
a340b80d
VZ
302 //
303 // Utilies needed by the popups or native implementations
304 //
305
b445b6a7
VZ
306 // Returns true if given key combination should toggle the popup.
307 // NB: This is a separate from other keyboard handling because:
308 // 1) Replaceability.
309 // 2) Centralized code (otherwise it'd be split up between
310 // wxComboCtrl key handler and wxVListBoxComboPopup's
311 // key handler).
312 virtual bool IsKeyPopupToggle(const wxKeyEvent& event) const = 0;
313
118f5fbd
RR
314 // Prepare background of combo control or an item in a dropdown list
315 // in a way typical on platform. This includes painting the focus/disabled
316 // background and setting the clipping region.
a340b80d
VZ
317 // Unless you plan to paint your own focus indicator, you should always call this
318 // in your wxComboPopup::PaintComboControl implementation.
319 // In addition, it sets pen and text colour to what looks good and proper
320 // against the background.
321 // flags: wxRendererNative flags: wxCONTROL_ISSUBMENU: is drawing a list item instead of combo control
322 // wxCONTROL_SELECTED: list item is selected
323 // wxCONTROL_DISABLED: control/item is disabled
118f5fbd 324 virtual void PrepareBackground( wxDC& dc, const wxRect& rect, int flags ) const;
a340b80d 325
6d0ce565 326 // Returns true if focus indicator should be drawn in the control.
a340b80d
VZ
327 bool ShouldDrawFocus() const
328 {
329 const wxWindow* curFocus = FindFocus();
330 return ( !m_isPopupShown &&
331 (curFocus == this || (m_btn && curFocus == m_btn)) &&
332 (m_windowStyle & wxCB_READONLY) );
333 }
334
335 // These methods return references to appropriate dropbutton bitmaps
336 const wxBitmap& GetBitmapNormal() const { return m_bmpNormal; }
337 const wxBitmap& GetBitmapPressed() const { return m_bmpPressed; }
338 const wxBitmap& GetBitmapHover() const { return m_bmpHover; }
339 const wxBitmap& GetBitmapDisabled() const { return m_bmpDisabled; }
340
341 // Return internal flags
342 wxUint32 GetInternalFlags() const { return m_iFlags; }
343
344 // Return true if Create has finished
345 bool IsCreated() const { return m_iFlags & wxCC_IFLAG_CREATED ? true : false; }
346
a340b80d
VZ
347 // common code to be called on popup hide/dismiss
348 void OnPopupDismiss();
349
350protected:
351
352 //
353 // Override these for customization purposes
354 //
355
356 // called from wxSizeEvent handler
357 virtual void OnResize() = 0;
358
359 // Return native text identation (for pure text, not textctrl)
360 virtual wxCoord GetNativeTextIndent() const;
361
362 // Called in syscolourchanged handler and base create
363 virtual void OnThemeChange();
364
365 // Creates wxTextCtrl.
366 // extraStyle: Extra style parameters
367 void CreateTextCtrl( int extraStyle, const wxValidator& validator );
368
369 // Installs standard input handler to combo (and optionally to the textctrl)
b445b6a7 370 void InstallInputHandlers();
a340b80d
VZ
371
372 // Draws dropbutton. Using wxRenderer or bitmaps, as appropriate.
373 void DrawButton( wxDC& dc, const wxRect& rect, bool paintBg = true );
374
375 // Call if cursor is on button area or mouse is captured for the button.
376 //bool HandleButtonMouseEvent( wxMouseEvent& event, bool isInside );
377 bool HandleButtonMouseEvent( wxMouseEvent& event, int flags );
378
a340b80d 379 // returns true if event was consumed or filtered (event type is also set to 0 in this case)
a340b80d
VZ
380 bool PreprocessMouseEvent( wxMouseEvent& event, int flags );
381
382 //
383 // This will handle left_down and left_dclick events outside button in a Windows-like manner.
384 // If you need alternate behaviour, it is recommended you manipulate and filter events to it
385 // instead of building your own handling routine (for reference, on wxEVT_LEFT_DOWN it will
386 // toggle popup and on wxEVT_LEFT_DCLICK it will do the same or run the popup's dclick method,
387 // if defined - you should pass events of other types of it for common processing).
388 void HandleNormalMouseEvent( wxMouseEvent& event );
389
390 // Creates popup window, calls interface->Create(), etc
391 void CreatePopup();
392
7ca4ac63
WS
393 // Destroy popup window and all related constructs
394 void DestroyPopup();
395
a340b80d 396 // override the base class virtuals involved in geometry calculations
a340b80d
VZ
397 virtual wxSize DoGetBestSize() const;
398
db53c6ea
WS
399 // NULL popup can be used to indicate default in a derived class
400 virtual void DoSetPopupControl(wxComboPopup* popup);
401
6d0ce565
VZ
402 // ensures there is atleast the default popup
403 void EnsurePopupControl();
404
a340b80d
VZ
405 // Recalculates button and textctrl areas. Called when size or button setup change.
406 // btnWidth: default/calculated width of the dropbutton. 0 means unchanged,
407 // just recalculate.
408 void CalculateAreas( int btnWidth = 0 );
409
410 // Standard textctrl positioning routine. Just give it platform-dependant
411 // textctrl coordinate adjustment.
412 void PositionTextCtrl( int textCtrlXAdjust, int textCtrlYAdjust );
413
414 // event handlers
415 void OnSizeEvent( wxSizeEvent& event );
416 void OnFocusEvent(wxFocusEvent& event);
417 void OnTextCtrlEvent(wxCommandEvent& event);
418 void OnSysColourChanged(wxSysColourChangedEvent& event);
b445b6a7 419 void OnKeyEvent(wxKeyEvent& event);
a340b80d 420
a57d600f 421 // Set customization flags (directs how wxComboCtrlBase helpers behave)
a340b80d
VZ
422 void Customize( wxUint32 flags ) { m_iFlags |= flags; }
423
424 // Dispatches size event and refreshes
425 void RecalcAndRefresh();
426
dcc8cf5a
PC
427#if wxUSE_TOOLTIPS
428 virtual void DoSetToolTip( wxToolTip *tip );
429#endif
430
a340b80d
VZ
431 // Used by OnPaints of derived classes
432 wxBitmap& GetBufferBitmap(const wxSize& sz) const;
433
434 // This is used when m_text is hidden (readonly).
435 wxString m_valueString;
436
437 // the text control and button we show all the time
438 wxTextCtrl* m_text;
439 wxWindow* m_btn;
440
441 // wxPopupWindow or similar containing the window managed by the interface.
442 wxWindow* m_winPopup;
443
444 // the popup control/panel
445 wxWindow* m_popup;
446
447 // popup interface
6d0ce565 448 wxComboPopup* m_popupInterface;
a340b80d 449
b445b6a7 450 // this is input etc. handler for the text control
a340b80d
VZ
451 wxEvtHandler* m_textEvtHandler;
452
453 // this is for the top level window
454 wxEvtHandler* m_toplevEvtHandler;
455
456 // this is for the control in popup
457 wxEvtHandler* m_popupExtraHandler;
458
a340b80d
VZ
459 // used to prevent immediate re-popupping incase closed popup
460 // by clicking on the combo control (needed because of inconsistent
461 // transient implementation across platforms).
462 wxLongLong m_timeCanAcceptClick;
463
464 // how much popup should expand to the left/right of the control
465 wxCoord m_extLeft;
466 wxCoord m_extRight;
467
468 // minimum popup width
469 wxCoord m_widthMinPopup;
470
471 // preferred popup height
472 wxCoord m_heightPopup;
473
474 // how much of writable combo is custom-paint by callback?
475 // also used to indicate area that is not covered by "blue"
476 // selection indicator.
477 wxCoord m_widthCustomPaint;
478
479 // absolute text indentation, in pixels
480 wxCoord m_absIndent;
481
482 // side on which the popup is aligned
483 int m_anchorSide;
484
485 // Width of the "fake" border
486 wxCoord m_widthCustomBorder;
487
488 // The button and textctrl click/paint areas
489 wxRect m_tcArea;
490 wxRect m_btnArea;
491
492 // current button state (uses renderer flags)
493 int m_btnState;
494
495 // button position
496 int m_btnWid;
497 int m_btnHei;
498 int m_btnSide;
499 int m_btnSpacingX;
500
501 // last default button width
502 int m_btnWidDefault;
503
504 // custom dropbutton bitmaps
505 wxBitmap m_bmpNormal;
506 wxBitmap m_bmpPressed;
507 wxBitmap m_bmpHover;
508 wxBitmap m_bmpDisabled;
509
510 // area used by the button
511 wxSize m_btnSize;
512
513 // platform-dependant customization and other flags
514 wxUint32 m_iFlags;
515
516 // draw blank button background under bitmap?
517 bool m_blankButtonBg;
518
519 // is the popup window currenty shown?
520 bool m_isPopupShown;
521
a340b80d
VZ
522private:
523 void Init();
524
525 DECLARE_EVENT_TABLE()
526
a57d600f 527 DECLARE_ABSTRACT_CLASS(wxComboCtrlBase)
a340b80d
VZ
528};
529
530
531// ----------------------------------------------------------------------------
532// wxComboPopup is the interface which must be implemented by a control to be
a57d600f 533// used as a popup by wxComboCtrl
a340b80d
VZ
534// ----------------------------------------------------------------------------
535
536
537// wxComboPopup internal flags
538enum
539{
a57d600f 540 wxCP_IFLAG_CREATED = 0x0001 // Set by wxComboCtrlBase after Create is called
a340b80d
VZ
541};
542
543
544class WXDLLEXPORT wxComboPopup
545{
a57d600f 546 friend class wxComboCtrlBase;
a340b80d 547public:
6d0ce565 548 wxComboPopup()
a340b80d 549 {
a57d600f 550 m_combo = (wxComboCtrlBase*) NULL;
a340b80d
VZ
551 m_iFlags = 0;
552 }
553
6d0ce565
VZ
554 // This is called immediately after construction finishes. m_combo member
555 // variable has been initialized before the call.
556 // NOTE: It is not in constructor so the derived class doesn't need to redefine
557 // a default constructor of its own.
558 virtual void Init() { };
559
a340b80d
VZ
560 virtual ~wxComboPopup();
561
562 // Create the popup child control.
563 // Return true for success.
564 virtual bool Create(wxWindow* parent) = 0;
565
566 // We must have an associated control which is subclassed by the combobox.
567 virtual wxWindow *GetControl() = 0;
568
569 // Called immediately after the popup is shown
570 virtual void OnPopup();
571
572 // Called when popup is dismissed
573 virtual void OnDismiss();
574
575 // Called just prior to displaying popup.
576 // Default implementation does nothing.
577 virtual void SetStringValue( const wxString& value );
578
579 // Gets displayed string representation of the value.
580 virtual wxString GetStringValue() const = 0;
581
582 // This is called to custom paint in the combo control itself (ie. not the popup).
583 // Default implementation draws value as string.
584 virtual void PaintComboControl( wxDC& dc, const wxRect& rect );
585
a57d600f 586 // Receives key events from the parent wxComboCtrl.
a340b80d
VZ
587 // Events not handled should be skipped, as usual.
588 virtual void OnComboKeyEvent( wxKeyEvent& event );
589
590 // Implement if you need to support special action when user
a57d600f 591 // double-clicks on the parent wxComboCtrl.
a340b80d
VZ
592 virtual void OnComboDoubleClick();
593
594 // Return final size of popup. Called on every popup, just prior to OnShow.
595 // minWidth = preferred minimum width for window
596 // prefHeight = preferred height. Only applies if > 0,
597 // maxHeight = max height for window, as limited by screen size
598 // and should only be rounded down, if necessary.
599 virtual wxSize GetAdjustedSize( int minWidth, int prefHeight, int maxHeight );
600
601 // Return true if you want delay call to Create until the popup is shown
602 // for the first time. It is more efficient, but note that it is often
603 // more convenient to have the control created immediately.
604 // Default returns false.
605 virtual bool LazyCreate();
606
607 //
608 // Utilies
609 //
610
611 // Hides the popup
612 void Dismiss();
613
614 // Returns true if Create has been called.
615 bool IsCreated() const
616 {
617 return (m_iFlags & wxCP_IFLAG_CREATED) ? true : false;
618 }
619
6d0ce565 620 // Default PaintComboControl behaviour
a57d600f 621 static void DefaultPaintComboControl( wxComboCtrlBase* combo,
6d0ce565
VZ
622 wxDC& dc,
623 const wxRect& rect );
624
a340b80d 625protected:
a57d600f 626 wxComboCtrlBase* m_combo;
a340b80d 627 wxUint32 m_iFlags;
6d0ce565
VZ
628
629private:
a57d600f
VZ
630 // Called in wxComboCtrlBase::SetPopupControl
631 void InitBase(wxComboCtrlBase *combo)
6d0ce565
VZ
632 {
633 m_combo = combo;
634 }
a340b80d
VZ
635};
636
637
638// ----------------------------------------------------------------------------
639// include the platform-dependent header defining the real class
640// ----------------------------------------------------------------------------
641
642#if defined(__WXUNIVERSAL__)
643 // No native universal (but it must still be first in the list)
644#elif defined(__WXMSW__)
645 #include "wx/msw/combo.h"
646#endif
647
648// Any ports may need generic as an alternative
649#include "wx/generic/combo.h"
650
a57d600f 651#endif // wxUSE_COMBOCTRL
a340b80d
VZ
652
653#endif
654 // _WX_COMBOCONTROL_H_BASE_