1 ///////////////////////////////////////////////////////////////////////////////
3 // Purpose: wxWindowBase class - the interface of wxWindow
4 // Author: Vadim Zeitlin
8 // Copyright: (c) wxWindows team
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
12 #ifndef _WX_WINDOW_H_BASE_
13 #define _WX_WINDOW_H_BASE_
16 #pragma interface "windowbase.h"
19 // ----------------------------------------------------------------------------
20 // headers which we must include here
21 // ----------------------------------------------------------------------------
23 #include "wx/event.h" // the base class
25 #include "wx/list.h" // defines wxWindowList
27 #include "wx/cursor.h" // we have member variables of these classes
28 #include "wx/font.h" // so we can't do without them
29 #include "wx/colour.h"
30 #include "wx/region.h"
33 #include "wx/validate.h" // for wxDefaultValidator (always include it)
39 // ----------------------------------------------------------------------------
40 // forward declarations
41 // ----------------------------------------------------------------------------
43 class WXDLLEXPORT wxCaret
;
44 class WXDLLEXPORT wxClientData
;
45 class WXDLLEXPORT wxControl
;
46 class WXDLLEXPORT wxCursor
;
47 class WXDLLEXPORT wxDC
;
48 class WXDLLEXPORT wxDropTarget
;
49 class WXDLLEXPORT wxItemResource
;
50 class WXDLLEXPORT wxLayoutConstraints
;
51 class WXDLLEXPORT wxResourceTable
;
52 class WXDLLEXPORT wxSizer
;
53 class WXDLLEXPORT wxToolTip
;
54 class WXDLLEXPORT wxWindowBase
;
55 class WXDLLEXPORT wxWindow
;
57 // ----------------------------------------------------------------------------
58 // (pseudo)template list classes
59 // ----------------------------------------------------------------------------
61 WX_DECLARE_LIST_3(wxWindow
, wxWindowBase
, wxWindowList
, wxWindowListNode
, class WXDLLEXPORT
);
63 // ----------------------------------------------------------------------------
65 // ----------------------------------------------------------------------------
67 WXDLLEXPORT_DATA(extern wxWindowList
) wxTopLevelWindows
;
69 // ----------------------------------------------------------------------------
70 // helper classes used by [SG]etClientObject/Data
72 // TODO move into a separate header?
73 // ----------------------------------------------------------------------------
79 virtual ~wxClientData() { }
82 class wxStringClientData
: public wxClientData
85 wxStringClientData() { }
86 wxStringClientData( const wxString
&data
) : m_data(data
) { }
87 void SetData( const wxString
&data
) { m_data
= data
; }
88 const wxString
& GetData() const { return m_data
; }
94 // ----------------------------------------------------------------------------
95 // wxWindowBase is the base class for all GUI controls/widgets, this is the public
96 // interface of this class.
98 // Event handler: windows have themselves as their event handlers by default,
99 // but their event handlers could be set to another object entirely. This
100 // separation can reduce the amount of derivation required, and allow
101 // alteration of a window's functionality (e.g. by a resource editor that
102 // temporarily switches event handlers).
103 // ----------------------------------------------------------------------------
105 class WXDLLEXPORT wxWindowBase
: public wxEvtHandler
107 DECLARE_ABSTRACT_CLASS(wxWindowBase
);
110 // creating the window
111 // -------------------
114 wxWindowBase() { InitBase(); }
116 // pseudo ctor (can't be virtual, called from ctor)
117 bool CreateBase(wxWindowBase
*parent
,
119 const wxPoint
& pos
= wxDefaultPosition
,
120 const wxSize
& size
= wxDefaultSize
,
122 const wxValidator
& validator
= wxDefaultValidator
,
123 const wxString
& name
= wxPanelNameStr
);
125 virtual ~wxWindowBase();
127 #if wxUSE_WX_RESOURCES
128 // these functions are implemented in resource.cpp and resourc2.cpp
129 virtual bool LoadFromResource(wxWindow
*parent
,
130 const wxString
& resourceName
,
131 const wxResourceTable
*table
= (const wxResourceTable
*) NULL
);
132 virtual wxControl
*CreateItem(const wxItemResource
* childResource
,
133 const wxItemResource
* parentResource
,
134 const wxResourceTable
*table
= (const wxResourceTable
*) NULL
);
135 #endif // wxUSE_WX_RESOURCES
137 // deleting the window
138 // -------------------
140 // ask the window to close itself, return TRUE if the event handler
141 // honoured our request
142 bool Close( bool force
= FALSE
);
144 // the following functions delete the C++ objects (the window itself
145 // or its children) as well as the GUI windows and normally should
146 // never be used directly
148 // delete window unconditionally (dangerous!), returns TRUE if ok
149 virtual bool Destroy();
150 // delete all children of this window, returns TRUE if ok
151 bool DestroyChildren();
153 // is the window being deleted?
154 bool IsBeingDeleted() const { return m_isBeingDeleted
; }
159 // the title (or label, see below) of the window: the text which the
161 virtual void SetTitle( const wxString
& WXUNUSED(title
) ) { }
162 virtual wxString
GetTitle() const { return ""; }
164 // label is just the same as the title (but for, e.g., buttons it
165 // makes more sense to speak about labels)
166 virtual void SetLabel(const wxString
& label
) { SetTitle(label
); }
167 virtual wxString
GetLabel() const { return GetTitle(); }
169 // the window name is used for ressource setting in X, it is not the
170 // same as the window title/label
171 virtual void SetName( const wxString
&name
) { m_windowName
= name
; }
172 virtual wxString
GetName() const { return m_windowName
; }
174 // window id uniquely identifies the window among its siblings unless
175 // it is -1 which means "don't care"
176 void SetId( wxWindowID id
) { m_windowId
= id
; }
177 wxWindowID
GetId() const { return m_windowId
; }
179 // generate a control id for the controls which were not given one by
181 static int NewControlId() { return --ms_lastControlId
; }
182 // get the id of the control following the one with the given
183 // (autogenerated) id
184 static int NextControlId(int id
) { return id
- 1; }
185 // get the id of the control preceding the one with the given
186 // (autogenerated) id
187 static int PrevControlId(int id
) { return id
+ 1; }
192 // set the window size and/or position
193 void SetSize( int x
, int y
, int width
, int height
,
194 int sizeFlags
= wxSIZE_AUTO
)
195 { DoSetSize(x
, y
, width
, height
, sizeFlags
); }
197 void SetSize( int width
, int height
)
198 { DoSetSize( -1, -1, width
, height
, wxSIZE_USE_EXISTING
); }
200 void SetSize( const wxSize
& size
)
201 { SetSize( size
.x
, size
.y
); }
203 void SetSize(const wxRect
& rect
, int sizeFlags
= wxSIZE_AUTO
)
204 { DoSetSize(rect
.x
, rect
.y
, rect
.width
, rect
.height
, sizeFlags
); }
206 void Move( int x
, int y
)
207 { DoSetSize( x
, y
, -1, -1, wxSIZE_USE_EXISTING
); }
209 void Move(const wxPoint
& pt
)
210 { Move(pt
.x
, pt
.y
); }
213 virtual void Raise() = 0;
214 virtual void Lower() = 0;
216 // client size is the size of area available for subwindows
217 void SetClientSize( int width
, int height
)
218 { DoSetClientSize(width
, height
); }
220 void SetClientSize( const wxSize
& size
)
221 { DoSetClientSize(size
.x
, size
.y
); }
223 void SetClientSize(const wxRect
& rect
)
224 { SetClientSize( rect
.width
, rect
.height
); }
226 // get the window position and/or size (pointers may be NULL)
227 void GetPosition( int *x
, int *y
) const { DoGetPosition(x
, y
); }
228 wxPoint
GetPosition() const
231 DoGetPosition(&w
, &h
);
233 return wxPoint(w
, h
);
236 void GetSize( int *w
, int *h
) const { DoGetSize(w
, h
); }
237 wxSize
GetSize() const
244 wxRect
GetRect() const
247 GetPosition(& x
, & y
);
250 return wxRect(x
, y
, w
, h
);
253 void GetClientSize( int *w
, int *h
) const { DoGetClientSize(w
, h
); }
254 wxSize
GetClientSize() const
257 DoGetClientSize(& w
, & h
);
262 // get the size best suited for the window (in fact, minimal
263 // acceptable size using which it will still look "nice")
264 wxSize
GetBestSize() const { return DoGetBestSize(); }
265 void GetBestSize(int *w
, int *h
) const
267 wxSize s
= DoGetBestSize();
274 // the generic centre function - centers the window on parent by
275 // default or on screen if it doesn't have parent or
276 // wxCENTER_ON_SCREEN flag is given
277 void Centre( int direction
= wxBOTH
);
278 void Center( int direction
= wxBOTH
) { Centre(direction
); }
280 // centre on screen (only works for top level windows)
281 void CentreOnScreen(int dir
= wxBOTH
) { Centre(dir
| wxCENTER_ON_SCREEN
); }
282 void CenterOnScreen(int dir
= wxBOTH
) { CentreOnScreen(dir
); }
284 // centre with respect to the the parent window
285 void CentreOnParent(int dir
= wxBOTH
) { Centre(dir
| wxCENTER_FRAME
); }
286 void CenterOnParent(int dir
= wxBOTH
) { CentreOnParent(dir
); }
288 // set window size to wrap around its children
291 // set min/max size of the window
292 virtual void SetSizeHints( int minW
, int minH
,
293 int maxW
= -1, int maxH
= -1,
294 int incW
= -1, int incH
= -1 );
296 int GetMinWidth() const { return m_minWidth
; }
297 int GetMinHeight() const { return m_minHeight
; }
298 int GetMaxWidth() const { return m_maxWidth
; }
299 int GetMaxHeight() const { return m_maxHeight
; }
304 // returns TRUE if window was shown/hidden, FALSE if the nothing was
305 // done (window was already shown/hidden)
306 virtual bool Show( bool show
= TRUE
);
307 bool Hide() { return Show(FALSE
); }
309 // returns TRUE if window was enabled/disabled, FALSE if nothing done
310 virtual bool Enable( bool enable
= TRUE
);
311 bool Disable() { return Enable(FALSE
); }
313 bool IsShown() const { return m_isShown
; }
314 bool IsEnabled() const { return m_isEnabled
; }
316 // get/set window style (setting style won't update the window and so
317 // is only useful for internal usage)
318 virtual void SetWindowStyleFlag( long style
) { m_windowStyle
= style
; }
319 virtual long GetWindowStyleFlag() const { return m_windowStyle
; }
321 // just some (somewhat shorter) synonims
322 void SetWindowStyle( long style
) { SetWindowStyleFlag(style
); }
323 long GetWindowStyle() const { return GetWindowStyleFlag(); }
325 bool HasFlag(int flag
) const { return (m_windowStyle
& flag
) != 0; }
326 virtual bool IsRetained() const { return HasFlag(wxRETAINED
); }
328 // extra style: the less often used style bits which can't be set with
329 // SetWindowStyleFlag()
330 void SetExtraStyle(long exStyle
) { m_exStyle
= exStyle
; }
331 long GetExtraStyle() const { return m_exStyle
; }
333 // make the window modal (all other windows unresponsive)
334 virtual void MakeModal(bool modal
= TRUE
);
339 // set focus to this window
340 virtual void SetFocus() = 0;
342 // return the window which currently has the focus or NULL
343 static wxWindow
*FindFocus() /* = 0: implement in derived classes */;
345 // can this window have focus?
346 virtual bool AcceptsFocus() const { return IsShown() && IsEnabled(); }
348 // parent/children relations
349 // -------------------------
351 // get the list of children
352 const wxWindowList
& GetChildren() const { return m_children
; }
353 wxWindowList
& GetChildren() { return m_children
; }
355 // get the parent or the parent of the parent
356 wxWindow
*GetParent() const { return m_parent
; }
357 inline wxWindow
*GetGrandParent() const;
359 // is this window a top level one?
360 virtual bool IsTopLevel() const;
362 // it doesn't really change parent, use ReParent() instead
363 void SetParent( wxWindowBase
*parent
) { m_parent
= (wxWindow
*)parent
; }
364 // change the real parent of this window, return TRUE if the parent
365 // was changed, FALSE otherwise (error or newParent == oldParent)
366 virtual bool Reparent( wxWindowBase
*newParent
);
368 // find window among the descendants of this one either by id or by
369 // name (return NULL if not found)
370 wxWindow
*FindWindow( long id
);
371 wxWindow
*FindWindow( const wxString
& name
);
373 // implementation mostly
374 virtual void AddChild( wxWindowBase
*child
);
375 virtual void RemoveChild( wxWindowBase
*child
);
377 // event handler stuff
378 // -------------------
380 // get the current event handler
381 wxEvtHandler
*GetEventHandler() const { return m_eventHandler
; }
383 // replace the event handler (allows to completely subclass the
385 void SetEventHandler( wxEvtHandler
*handler
) { m_eventHandler
= handler
; }
387 // push/pop event handler: allows to chain a custom event handler to
388 // alreasy existing ones
389 void PushEventHandler( wxEvtHandler
*handler
);
390 wxEvtHandler
*PopEventHandler( bool deleteHandler
= FALSE
);
392 // validators and client data
393 // --------------------------
396 // a window may have an associated validator which is used to control
398 virtual void SetValidator( const wxValidator
&validator
);
399 virtual wxValidator
*GetValidator() { return m_windowValidator
; }
400 #endif // wxUSE_VALIDATORS
402 // each window may have associated client data: either a pointer to
403 // wxClientData object in which case it is managed by the window (i.e.
404 // it will delete the data when it's destroyed) or an untyped pointer
405 // which won't be deleted by the window - but not both of them
406 void SetClientObject( wxClientData
*data
) { DoSetClientObject(data
); }
407 wxClientData
*GetClientObject() const { return DoGetClientObject(); }
409 void SetClientData( void *data
) { DoSetClientData(data
); }
410 void *GetClientData() const { return DoGetClientData(); }
412 // dialog oriented functions
413 // -------------------------
415 // validate the correctness of input, return TRUE if ok
416 virtual bool Validate();
418 // transfer data between internal and GUI representations
419 virtual bool TransferDataToWindow();
420 virtual bool TransferDataFromWindow();
422 virtual void InitDialog();
427 virtual void SetAcceleratorTable( const wxAcceleratorTable
& accel
)
428 { m_acceleratorTable
= accel
; }
429 wxAcceleratorTable
*GetAcceleratorTable()
430 { return &m_acceleratorTable
; }
431 #endif // wxUSE_ACCEL
433 // dialog units translations
434 // -------------------------
436 wxPoint
ConvertPixelsToDialog( const wxPoint
& pt
);
437 wxPoint
ConvertDialogToPixels( const wxPoint
& pt
);
438 wxSize
ConvertPixelsToDialog( const wxSize
& sz
)
440 wxPoint
pt(ConvertPixelsToDialog(wxPoint(sz
.x
, sz
.y
)));
442 return wxSize(pt
.x
, pt
.y
);
445 wxSize
ConvertDialogToPixels( const wxSize
& sz
)
447 wxPoint
pt(ConvertDialogToPixels(wxPoint(sz
.x
, sz
.y
)));
449 return wxSize(pt
.x
, pt
.y
);
455 // move the mouse to the specified position
456 virtual void WarpPointer(int x
, int y
) = 0;
458 // start or end mouse capture
459 virtual void CaptureMouse() = 0;
460 virtual void ReleaseMouse() = 0;
462 // painting the window
463 // -------------------
465 // mark the specified rectangle (or the whole window) as "dirty" so it
467 virtual void Refresh( bool eraseBackground
= TRUE
,
468 const wxRect
*rect
= (const wxRect
*) NULL
) = 0;
469 // clear the window entirely
470 virtual void Clear() = 0;
472 // adjust DC for drawing on this window
473 virtual void PrepareDC( wxDC
& WXUNUSED(dc
) ) { }
475 // the update region of the window contains the areas which must be
476 // repainted by the program
477 const wxRegion
& GetUpdateRegion() const { return m_updateRegion
; }
478 wxRegion
& GetUpdateRegion() { return m_updateRegion
; }
480 // these functions verify whether the given point/rectangle belongs to
481 // (or at least intersects with) the update region
482 bool IsExposed( int x
, int y
) const;
483 bool IsExposed( int x
, int y
, int w
, int h
) const;
485 bool IsExposed( const wxPoint
& pt
) const
486 { return IsExposed(pt
.x
, pt
.y
); }
487 bool IsExposed( const wxRect
& rect
) const
488 { return IsExposed(rect
.x
, rect
.y
, rect
.width
, rect
.height
); }
490 // colours, fonts and cursors
491 // --------------------------
493 // set/retrieve the window colours (system defaults are used by
494 // default): Set functions return TRUE if colour was changed
495 virtual bool SetBackgroundColour( const wxColour
&colour
);
496 virtual bool SetForegroundColour( const wxColour
&colour
);
498 wxColour
GetBackgroundColour() const { return m_backgroundColour
; }
499 wxColour
GetForegroundColour() const { return m_foregroundColour
; }
501 // set/retrieve the cursor for this window (SetCursor() returns TRUE
502 // if the cursor was really changed)
503 virtual bool SetCursor( const wxCursor
&cursor
);
504 const wxCursor
& GetCursor() const { return m_cursor
; }
505 wxCursor
& GetCursor() { return m_cursor
; }
507 // set/retrieve the font for the window (SetFont() returns TRUE if the
508 // font really changed)
509 virtual bool SetFont( const wxFont
&font
) = 0;
510 const wxFont
& GetFont() const { return m_font
; }
511 wxFont
& GetFont() { return m_font
; }
514 // associate a caret with the window
515 void SetCaret(wxCaret
*caret
);
516 // get the current caret (may be NULL)
517 wxCaret
*GetCaret() const { return m_caret
; }
518 #endif // wxUSE_CARET
520 // get the (average) character size for the current font
521 virtual int GetCharHeight() const = 0;
522 virtual int GetCharWidth() const = 0;
524 // get the width/height/... of the text using current or specified
526 virtual void GetTextExtent(const wxString
& string
,
528 int *descent
= (int *) NULL
,
529 int *externalLeading
= (int *) NULL
,
530 const wxFont
*theFont
= (const wxFont
*) NULL
)
533 // translate to/from screen/client coordinates (pointers may be NULL)
534 void ClientToScreen( int *x
, int *y
) const
535 { DoClientToScreen(x
, y
); }
536 void ScreenToClient( int *x
, int *y
) const
537 { DoScreenToClient(x
, y
); }
538 wxPoint
ClientToScreen(const wxPoint
& pt
) const
540 int x
= pt
.x
, y
= pt
.y
;
541 DoClientToScreen(&x
, &y
);
543 return wxPoint(x
, y
);
546 wxPoint
ScreenToClient(const wxPoint
& pt
) const
548 int x
= pt
.x
, y
= pt
.y
;
549 DoScreenToClient(&x
, &y
);
551 return wxPoint(x
, y
);
557 void UpdateWindowUI();
559 bool PopupMenu( wxMenu
*menu
, const wxPoint
& pos
)
560 { return DoPopupMenu(menu
, pos
.x
, pos
.y
); }
561 bool PopupMenu( wxMenu
*menu
, int x
, int y
)
562 { return DoPopupMenu(menu
, x
, y
); }
567 // configure the window scrollbars
568 virtual void SetScrollbar( int orient
,
572 bool refresh
= TRUE
) = 0;
573 virtual void SetScrollPos( int orient
, int pos
, bool refresh
= TRUE
) = 0;
574 virtual int GetScrollPos( int orient
) const = 0;
575 virtual int GetScrollThumb( int orient
) const = 0;
576 virtual int GetScrollRange( int orient
) const = 0;
578 // scroll window to the specified position
579 virtual void ScrollWindow( int dx
, int dy
,
580 const wxRect
* rect
= (wxRect
*) NULL
) = 0;
585 // the easiest way to set a tooltip for a window is to use this method
586 void SetToolTip( const wxString
&tip
);
587 // attach a tooltip to the window
588 void SetToolTip( wxToolTip
*tip
) { DoSetToolTip(tip
); }
589 // get the associated tooltip or NULL if none
590 wxToolTip
* GetToolTip() const { return m_tooltip
; }
591 #endif // wxUSE_TOOLTIPS
595 #if wxUSE_DRAG_AND_DROP
596 // set/retrieve the drop target associated with this window (may be
597 // NULL; it's owned by the window and will be deleted by it)
598 virtual void SetDropTarget( wxDropTarget
*dropTarget
) = 0;
599 virtual wxDropTarget
*GetDropTarget() const { return m_dropTarget
; }
600 #endif // wxUSE_DRAG_AND_DROP
602 // constraints and sizers
603 // ----------------------
604 #if wxUSE_CONSTRAINTS
605 // set the constraints for this window or retrieve them (may be NULL)
606 void SetConstraints( wxLayoutConstraints
*constraints
);
607 wxLayoutConstraints
*GetConstraints() const { return m_constraints
; }
609 // when using constraints, it makes sense to update children positions
610 // automatically whenever the window is resized - this is done if
612 void SetAutoLayout( bool autoLayout
) { m_autoLayout
= autoLayout
; }
613 bool GetAutoLayout() const { return m_autoLayout
; }
615 // do layout the window and its children
616 virtual bool Layout();
618 // implementation only
619 void UnsetConstraints(wxLayoutConstraints
*c
);
620 wxWindowList
*GetConstraintsInvolvedIn() const
621 { return m_constraintsInvolvedIn
; }
622 void AddConstraintReference(wxWindowBase
*otherWin
);
623 void RemoveConstraintReference(wxWindowBase
*otherWin
);
624 void DeleteRelatedConstraints();
625 void ResetConstraints();
627 // these methods may be overriden for special layout algorithms
628 virtual void SetConstraintSizes(bool recurse
= TRUE
);
629 virtual bool LayoutPhase1(int *noChanges
);
630 virtual bool LayoutPhase2(int *noChanges
);
631 virtual bool DoPhase(int phase
);
633 // these methods are virtual but normally won't be overridden
634 virtual void SetSizeConstraint(int x
, int y
, int w
, int h
);
635 virtual void MoveConstraint(int x
, int y
);
636 virtual void GetSizeConstraint(int *w
, int *h
) const ;
637 virtual void GetClientSizeConstraint(int *w
, int *h
) const ;
638 virtual void GetPositionConstraint(int *x
, int *y
) const ;
641 // TODO: what are they and how do they work??
642 void SetSizer( wxSizer
*sizer
);
643 wxSizer
*GetSizer() const { return m_windowSizer
; }
644 #endif // wxUSE_CONSTRAINTS
646 // backward compatibility
647 // ----------------------
648 #if WXWIN_COMPATIBILITY
649 bool Enabled() const { return IsEnabled(); }
651 void SetButtonFont(const wxFont
& font
) { SetFont(font
); }
652 void SetLabelFont(const wxFont
& font
) { SetFont(font
); }
653 wxFont
& GetLabelFont() { return GetFont(); };
654 wxFont
& GetButtonFont() { return GetFont(); };
655 #endif // WXWIN_COMPATIBILITY
661 void OnSysColourChanged( wxSysColourChangedEvent
& event
);
662 void OnInitDialog( wxInitDialogEvent
&event
);
663 void OnMiddleClick( wxMouseEvent
& event
);
665 // get the haqndle of the window for the underlying window system: this
666 // is only used for wxWin itself or for user code which wants to call
667 // platform-specific APIs
668 virtual WXWidget
GetHandle() const = 0;
671 // the window id - a number which uniquely identifies a window among
672 // its siblings unless it is -1
673 wxWindowID m_windowId
;
675 // the parent window of this window (or NULL) and the list of the children
678 wxWindowList m_children
;
680 // the minimal allowed size for the window (no minimal size if variable(s)
682 int m_minWidth
, m_minHeight
, m_maxWidth
, m_maxHeight
;
684 // event handler for this window: usually is just 'this' but may be
685 // changed with SetEventHandler()
686 wxEvtHandler
*m_eventHandler
;
689 // associated validator or NULL if none
690 wxValidator
*m_windowValidator
;
691 #endif // wxUSE_VALIDATORS
693 #if wxUSE_DRAG_AND_DROP
694 wxDropTarget
*m_dropTarget
;
695 #endif // wxUSE_DRAG_AND_DROP
697 // visual window attributes
700 wxColour m_backgroundColour
, m_foregroundColour
;
704 #endif // wxUSE_CARET
706 // the region which should be repainted in response to paint event
707 wxRegion m_updateRegion
;
710 // the accelerator table for the window which translates key strokes into
712 wxAcceleratorTable m_acceleratorTable
;
713 #endif // wxUSE_ACCEL
715 // user data associated with the window: either an object which will be
716 // deleted by the window when it's deleted or some raw pointer which we do
717 // nothing with - only one type of data can be used with the given window
718 // (i.e. you cannot set the void data and then associate the window with
719 // wxClientData or vice versa)
722 wxClientData
*m_clientObject
;
726 // the tooltip for this window (may be NULL)
728 wxToolTip
*m_tooltip
;
729 #endif // wxUSE_TOOLTIPS
731 // constraints and sizers
732 #if wxUSE_CONSTRAINTS
733 // the constraints for this window or NULL
734 wxLayoutConstraints
*m_constraints
;
736 // constraints this window is involved in
737 wxWindowList
*m_constraintsInvolvedIn
;
739 // top level and the parent sizers
740 // TODO what's this and how does it work?)
741 wxSizer
*m_windowSizer
;
742 wxWindowBase
*m_sizerParent
;
744 // Layout() window automatically when its size changes?
746 #endif // wxUSE_CONSTRAINTS
751 bool m_isBeingDeleted
:1;
756 wxString m_windowName
;
759 // common part of all ctors: it is not virtual because it is called from
763 // get the default size for the new window if no explicit size given
764 // FIXME why 20 and not 30, 10 or ...?
765 static int WidthDefault(int w
) { return w
== -1 ? 20 : w
; }
766 static int HeightDefault(int h
) { return h
== -1 ? 20 : h
; }
768 // sets the size to be size but take width and/or height from
769 // DoGetBestSize() if width/height of size is -1
771 // NB: when calling this function from the ctor, the DoGetBestSize() of
772 // the class with the same name as the ctor, not the real (most
773 // derived) one - but this is what we usually want
774 void SetSizeOrDefault(const wxSize
& size
= wxDefaultSize
)
776 if ( size
.x
== -1 || size
.y
== -1 )
778 wxSize sizeDef
= GetBestSize();
779 SetSize( size
.x
== -1 ? sizeDef
.x
: size
.x
,
780 size
.y
== -1 ? sizeDef
.y
: size
.y
);
788 // more pure virtual functions
789 // ---------------------------
791 // NB: we must have DoSomething() function when Something() is an overloaded
792 // method: indeed, we can't just have "virtual Something()" in case when
793 // the function is overloaded because then we'd have to make virtual all
794 // the variants (otherwise only the virtual function may be called on a
795 // pointer to derived class according to C++ rules) which is, in
796 // general, absolutely not needed. So instead we implement all
797 // overloaded Something()s in terms of DoSomething() which will be the
798 // only one to be virtual.
800 // coordinates translation
801 virtual void DoClientToScreen( int *x
, int *y
) const = 0;
802 virtual void DoScreenToClient( int *x
, int *y
) const = 0;
804 // retrieve the position/size of the window
805 virtual void DoGetPosition( int *x
, int *y
) const = 0;
806 virtual void DoGetSize( int *width
, int *height
) const = 0;
807 virtual void DoGetClientSize( int *width
, int *height
) const = 0;
809 // get the size which best suits the window: for a control, it would be
810 // the minimal size which doesn't truncate the control, for a panel - the
811 // same size as it would have after a call to Fit()
812 virtual wxSize
DoGetBestSize() const;
814 // this is the virtual function to be overriden in any derived class which
815 // wants to change how SetSize() or Move() works - it is called by all
816 // versions of these functions in the base class
817 virtual void DoSetSize(int x
, int y
,
818 int width
, int height
,
819 int sizeFlags
= wxSIZE_AUTO
) = 0;
821 // same as DoSetSize() for the client size
822 virtual void DoSetClientSize(int width
, int height
) = 0;
824 // move the window to the specified location and resize it: this is called
825 // from both DoSetSize() and DoSetClientSize() and would usually just
826 // reposition this window except for composite controls which will want to
827 // arrange themselves inside the given rectangle
828 virtual void DoMoveWindow(int x
, int y
, int width
, int height
) = 0;
831 virtual void DoSetToolTip( wxToolTip
*tip
);
832 #endif // wxUSE_TOOLTIPS
834 virtual bool DoPopupMenu( wxMenu
*menu
, int x
, int y
) = 0;
836 // client data accessors
837 virtual void DoSetClientObject( wxClientData
*data
);
838 virtual wxClientData
*DoGetClientObject() const;
840 virtual void DoSetClientData( void *data
);
841 virtual void *DoGetClientData() const;
843 // what kind of data do we have?
844 enum wxClientDataType
846 ClientData_None
, // we don't know yet because we don't have it at all
847 ClientData_Object
, // our client data is typed and we own it
848 ClientData_Void
// client data is untyped and we don't own it
852 // contains the last id generated by NewControlId
853 static int ms_lastControlId
;
855 DECLARE_NO_COPY_CLASS(wxWindowBase
);
856 DECLARE_EVENT_TABLE()
859 // ----------------------------------------------------------------------------
860 // now include the declaration of wxWindow class
861 // ----------------------------------------------------------------------------
863 #if defined(__WXMSW__)
864 #include "wx/msw/window.h"
865 #elif defined(__WXMOTIF__)
866 #include "wx/motif/window.h"
867 #elif defined(__WXGTK__)
868 #include "wx/gtk/window.h"
869 #elif defined(__WXQT__)
870 #include "wx/qt/window.h"
871 #elif defined(__WXMAC__)
872 #include "wx/mac/window.h"
873 #elif defined(__WXPM__)
874 #include "wx/os2/window.h"
877 // ----------------------------------------------------------------------------
878 // inline functions which couldn't be declared in the class body because of
879 // forward dependencies
880 // ----------------------------------------------------------------------------
882 inline wxWindow
*wxWindowBase::GetGrandParent() const
884 return m_parent
? m_parent
->GetParent() : (wxWindow
*)NULL
;
887 // ----------------------------------------------------------------------------
889 // ----------------------------------------------------------------------------
891 WXDLLEXPORT
extern wxWindow
* wxGetActiveWindow();
893 // deprecated (doesn't start with 'wx' prefix), use wxWindow::NewControlId()
894 inline WXDLLEXPORT
int NewControlId() { return wxWindowBase::NewControlId(); }
897 // _WX_WINDOW_H_BASE_