1 ///////////////////////////////////////////////////////////////////////////////
3 // Purpose: wxWindowBase class - the interface of wxWindow
4 // Author: Vadim Zeitlin
5 // Modified by: Ron Lee
8 // Copyright: (c) Vadim Zeitlin
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
12 #ifndef _WX_WINDOW_H_BASE_
13 #define _WX_WINDOW_H_BASE_
15 // ----------------------------------------------------------------------------
16 // headers which we must include here
17 // ----------------------------------------------------------------------------
19 #include "wx/event.h" // the base class
21 #include "wx/list.h" // defines wxWindowList
23 #include "wx/cursor.h" // we have member variables of these classes
24 #include "wx/font.h" // so we can't do without them
25 #include "wx/colour.h"
26 #include "wx/region.h"
30 #include "wx/validate.h" // for wxDefaultValidator (always include it)
33 #include "wx/palette.h"
34 #endif // wxUSE_PALETTE
40 #if wxUSE_ACCESSIBILITY
41 #include "wx/access.h"
44 // when building wxUniv/Foo we don't want the code for native menu use to be
45 // compiled in - it should only be used when building real wxFoo
46 #ifdef __WXUNIVERSAL__
47 #define wxUSE_MENUS_NATIVE 0
48 #else // !__WXUNIVERSAL__
49 #define wxUSE_MENUS_NATIVE wxUSE_MENUS
50 #endif // __WXUNIVERSAL__/!__WXUNIVERSAL__
52 // ----------------------------------------------------------------------------
53 // forward declarations
54 // ----------------------------------------------------------------------------
56 class WXDLLEXPORT wxCaret
;
57 class WXDLLEXPORT wxControl
;
58 class WXDLLEXPORT wxCursor
;
59 class WXDLLEXPORT wxDC
;
60 class WXDLLEXPORT wxDropTarget
;
61 class WXDLLEXPORT wxItemResource
;
62 class WXDLLEXPORT wxLayoutConstraints
;
63 class WXDLLEXPORT wxResourceTable
;
64 class WXDLLEXPORT wxSizer
;
65 class WXDLLEXPORT wxToolTip
;
66 class WXDLLEXPORT wxWindowBase
;
67 class WXDLLEXPORT wxWindow
;
68 class WXDLLEXPORT wxScrollHelper
;
70 #if wxUSE_ACCESSIBILITY
71 class WXDLLEXPORT wxAccessible
;
74 // ----------------------------------------------------------------------------
75 // helper stuff used by wxWindow
76 // ----------------------------------------------------------------------------
78 // struct containing all the visual attributes of a control
79 struct WXDLLEXPORT wxVisualAttributes
81 // the font used for control label/text inside it
84 // the foreground colour
87 // the background colour, may be wxNullColour if the controls background
88 // colour is not solid
92 // different window variants, on platforms like eg mac uses different
96 wxWINDOW_VARIANT_NORMAL
, // Normal size
97 wxWINDOW_VARIANT_SMALL
, // Smaller size (about 25 % smaller than normal)
98 wxWINDOW_VARIANT_MINI
, // Mini size (about 33 % smaller than normal)
99 wxWINDOW_VARIANT_LARGE
, // Large size (about 25 % larger than normal)
103 #if wxUSE_SYSTEM_OPTIONS
104 #define wxWINDOW_DEFAULT_VARIANT wxT("window-default-variant")
107 // ----------------------------------------------------------------------------
108 // (pseudo)template list classes
109 // ----------------------------------------------------------------------------
111 WX_DECLARE_LIST_3(wxWindow
, wxWindowBase
, wxWindowList
, wxWindowListNode
, class WXDLLEXPORT
);
113 // ----------------------------------------------------------------------------
115 // ----------------------------------------------------------------------------
117 extern WXDLLEXPORT_DATA(wxWindowList
) wxTopLevelWindows
;
118 extern WXDLLIMPEXP_DATA_CORE(wxList
) wxPendingDelete
;
120 // ----------------------------------------------------------------------------
121 // wxWindowBase is the base class for all GUI controls/widgets, this is the public
122 // interface of this class.
124 // Event handler: windows have themselves as their event handlers by default,
125 // but their event handlers could be set to another object entirely. This
126 // separation can reduce the amount of derivation required, and allow
127 // alteration of a window's functionality (e.g. by a resource editor that
128 // temporarily switches event handlers).
129 // ----------------------------------------------------------------------------
131 class WXDLLEXPORT wxWindowBase
: public wxEvtHandler
134 // creating the window
135 // -------------------
137 // default ctor, initializes everything which can be initialized before
141 // pseudo ctor (can't be virtual, called from ctor)
142 bool CreateBase(wxWindowBase
*parent
,
144 const wxPoint
& pos
= wxDefaultPosition
,
145 const wxSize
& size
= wxDefaultSize
,
147 const wxValidator
& validator
= wxDefaultValidator
,
148 const wxString
& name
= wxPanelNameStr
);
150 virtual ~wxWindowBase();
152 // deleting the window
153 // -------------------
155 // ask the window to close itself, return true if the event handler
156 // honoured our request
157 bool Close( bool force
= false );
159 // the following functions delete the C++ objects (the window itself
160 // or its children) as well as the GUI windows and normally should
161 // never be used directly
163 // delete window unconditionally (dangerous!), returns true if ok
164 virtual bool Destroy();
165 // delete all children of this window, returns true if ok
166 bool DestroyChildren();
168 // is the window being deleted?
169 bool IsBeingDeleted() const { return m_isBeingDeleted
; }
174 // label is just the same as the title (but for, e.g., buttons it
175 // makes more sense to speak about labels), title access
176 // is available from wxTLW classes only (frames, dialogs)
177 virtual void SetLabel(const wxString
& label
) = 0;
178 virtual wxString
GetLabel() const = 0;
180 // the window name is used for ressource setting in X, it is not the
181 // same as the window title/label
182 virtual void SetName( const wxString
&name
) { m_windowName
= name
; }
183 virtual wxString
GetName() const { return m_windowName
; }
185 // sets the window variant, calls internally DoSetVariant if variant
187 void SetWindowVariant(wxWindowVariant variant
);
188 wxWindowVariant
GetWindowVariant() const { return m_windowVariant
; }
191 // window id uniquely identifies the window among its siblings unless
192 // it is wxID_ANY which means "don't care"
193 void SetId( wxWindowID winid
) { m_windowId
= winid
; }
194 wxWindowID
GetId() const { return m_windowId
; }
196 // get or change the layout direction (LTR or RTL) for this window,
197 // wxLayout_Default is returned if layout direction is not supported
198 virtual wxLayoutDirection
GetLayoutDirection() const
199 { return wxLayout_Default
; }
200 virtual void SetLayoutDirection(wxLayoutDirection
WXUNUSED(dir
))
203 // mirror coordinates for RTL layout if this window uses it and if the
204 // mirroring is not done automatically like Win32
205 virtual wxCoord
AdjustForLayoutDirection(wxCoord x
,
207 wxCoord widthTotal
) const;
209 // generate a control id for the controls which were not given one by
211 static int NewControlId() { return --ms_lastControlId
; }
212 // get the id of the control following the one with the given
213 // (autogenerated) id
214 static int NextControlId(int winid
) { return winid
- 1; }
215 // get the id of the control preceding the one with the given
216 // (autogenerated) id
217 static int PrevControlId(int winid
) { return winid
+ 1; }
222 // set the window size and/or position
223 void SetSize( int x
, int y
, int width
, int height
,
224 int sizeFlags
= wxSIZE_AUTO
)
225 { DoSetSize(x
, y
, width
, height
, sizeFlags
); }
227 void SetSize( int width
, int height
)
228 { DoSetSize( wxDefaultCoord
, wxDefaultCoord
, width
, height
, wxSIZE_USE_EXISTING
); }
230 void SetSize( const wxSize
& size
)
231 { SetSize( size
.x
, size
.y
); }
233 void SetSize(const wxRect
& rect
, int sizeFlags
= wxSIZE_AUTO
)
234 { DoSetSize(rect
.x
, rect
.y
, rect
.width
, rect
.height
, sizeFlags
); }
236 void Move(int x
, int y
, int flags
= wxSIZE_USE_EXISTING
)
237 { DoSetSize(x
, y
, wxDefaultCoord
, wxDefaultCoord
, flags
); }
239 void Move(const wxPoint
& pt
, int flags
= wxSIZE_USE_EXISTING
)
240 { Move(pt
.x
, pt
.y
, flags
); }
242 void SetPosition(const wxPoint
& pt
) { Move(pt
); }
245 virtual void Raise() = 0;
246 virtual void Lower() = 0;
248 // client size is the size of area available for subwindows
249 void SetClientSize( int width
, int height
)
250 { DoSetClientSize(width
, height
); }
252 void SetClientSize( const wxSize
& size
)
253 { DoSetClientSize(size
.x
, size
.y
); }
255 void SetClientSize(const wxRect
& rect
)
256 { SetClientSize( rect
.width
, rect
.height
); }
258 // get the window position (pointers may be NULL): notice that it is in
259 // client coordinates for child windows and screen coordinates for the
260 // top level ones, use GetScreenPosition() if you need screen
261 // coordinates for all kinds of windows
262 void GetPosition( int *x
, int *y
) const { DoGetPosition(x
, y
); }
263 wxPoint
GetPosition() const
266 DoGetPosition(&x
, &y
);
268 return wxPoint(x
, y
);
271 // get the window position in screen coordinates
272 void GetScreenPosition(int *x
, int *y
) const { DoGetScreenPosition(x
, y
); }
273 wxPoint
GetScreenPosition() const
276 DoGetScreenPosition(&x
, &y
);
278 return wxPoint(x
, y
);
281 // get the window size (pointers may be NULL)
282 void GetSize( int *w
, int *h
) const { DoGetSize(w
, h
); }
283 wxSize
GetSize() const
290 void GetClientSize( int *w
, int *h
) const { DoGetClientSize(w
, h
); }
291 wxSize
GetClientSize() const
294 DoGetClientSize(&w
, &h
);
299 // get the position and size at once
300 wxRect
GetRect() const
306 return wxRect(x
, y
, w
, h
);
309 wxRect
GetScreenRect() const
312 GetScreenPosition(&x
, &y
);
315 return wxRect(x
, y
, w
, h
);
318 // get the origin of the client area of the window relative to the
319 // window top left corner (the client area may be shifted because of
320 // the borders, scrollbars, other decorations...)
321 virtual wxPoint
GetClientAreaOrigin() const;
323 // get the client rectangle in window (i.e. client) coordinates
324 wxRect
GetClientRect() const
326 return wxRect(GetClientAreaOrigin(), GetClientSize());
329 // get the size best suited for the window (in fact, minimal
330 // acceptable size using which it will still look "nice" in
332 wxSize
GetBestSize() const
334 if (m_bestSizeCache
.IsFullySpecified())
335 return m_bestSizeCache
;
336 return DoGetBestSize();
338 void GetBestSize(int *w
, int *h
) const
340 wxSize s
= GetBestSize();
347 void SetScrollHelper( wxScrollHelper
*sh
) { m_scrollHelper
= sh
; }
348 wxScrollHelper
*GetScrollHelper() { return m_scrollHelper
; }
350 // reset the cached best size value so it will be recalculated the
351 // next time it is needed.
352 void InvalidateBestSize();
353 void CacheBestSize(const wxSize
& size
) const
354 { wxConstCast(this, wxWindowBase
)->m_bestSizeCache
= size
; }
357 // This function will merge the window's best size into the window's
358 // minimum size, giving priority to the min size components, and
359 // returns the results.
360 wxSize
GetEffectiveMinSize() const;
361 wxDEPRECATED( wxSize
GetBestFittingSize() const ); // replaced by GetEffectiveMinSize
362 wxDEPRECATED( wxSize
GetAdjustedMinSize() const ); // replaced by GetEffectiveMinSize
364 // A 'Smart' SetSize that will fill in default size values with 'best'
365 // size. Sets the minsize to what was passed in.
366 void SetInitialSize(const wxSize
& size
=wxDefaultSize
);
367 wxDEPRECATED( void SetBestFittingSize(const wxSize
& size
=wxDefaultSize
) ); // replaced by SetInitialSize
370 // the generic centre function - centers the window on parent by`
371 // default or on screen if it doesn't have parent or
372 // wxCENTER_ON_SCREEN flag is given
373 void Centre(int dir
= wxBOTH
) { DoCentre(dir
); }
374 void Center(int dir
= wxBOTH
) { DoCentre(dir
); }
376 // centre with respect to the the parent window
377 void CentreOnParent(int dir
= wxBOTH
) { DoCentre(dir
); }
378 void CenterOnParent(int dir
= wxBOTH
) { CentreOnParent(dir
); }
380 // set window size to wrap around its children
383 // set virtual size to satisfy children
384 virtual void FitInside();
387 // SetSizeHints is actually for setting the size hints
388 // for the wxTLW for a Window Manager - hence the name -
389 // and it is therefore overridden in wxTLW to do that.
390 // In wxWindow(Base), it has (unfortunately) been abused
391 // to mean the same as SetMinSize() and SetMaxSize().
393 virtual void SetSizeHints( int minW
, int minH
,
394 int maxW
= wxDefaultCoord
, int maxH
= wxDefaultCoord
,
395 int incW
= wxDefaultCoord
, int incH
= wxDefaultCoord
)
396 { DoSetSizeHints(minW
, minH
, maxW
, maxH
, incW
, incH
); }
398 void SetSizeHints( const wxSize
& minSize
,
399 const wxSize
& maxSize
=wxDefaultSize
,
400 const wxSize
& incSize
=wxDefaultSize
)
401 { DoSetSizeHints(minSize
.x
, minSize
.y
, maxSize
.x
, maxSize
.y
, incSize
.x
, incSize
.y
); }
403 virtual void DoSetSizeHints( int minW
, int minH
,
405 int incW
, int incH
);
407 // Methods for setting virtual size hints
408 // FIXME: What are virtual size hints?
410 virtual void SetVirtualSizeHints( int minW
, int minH
,
411 int maxW
= wxDefaultCoord
, int maxH
= wxDefaultCoord
);
412 void SetVirtualSizeHints( const wxSize
& minSize
,
413 const wxSize
& maxSize
=wxDefaultSize
)
415 SetVirtualSizeHints(minSize
.x
, minSize
.y
, maxSize
.x
, maxSize
.y
);
419 // Call these to override what GetBestSize() returns. This
420 // method is only virtual because it is overriden in wxTLW
421 // as a different API for SetSizeHints().
422 virtual void SetMinSize(const wxSize
& minSize
) { m_minWidth
= minSize
.x
; m_minHeight
= minSize
.y
; }
423 virtual void SetMaxSize(const wxSize
& maxSize
) { m_maxWidth
= maxSize
.x
; m_maxHeight
= maxSize
.y
; }
425 // Override these methods to impose restrictions on min/max size.
426 // The easier way is to call SetMinSize() and SetMaxSize() which
427 // will have the same effect. Doing both is non-sense.
428 virtual wxSize
GetMinSize() const { return wxSize(m_minWidth
, m_minHeight
); }
429 virtual wxSize
GetMaxSize() const { return wxSize(m_maxWidth
, m_maxHeight
); }
431 // Get the min and max values one by one
432 int GetMinWidth() const { return GetMinSize().x
; }
433 int GetMinHeight() const { return GetMinSize().y
; }
434 int GetMaxWidth() const { return GetMaxSize().x
; }
435 int GetMaxHeight() const { return GetMaxSize().y
; }
438 // Methods for accessing the virtual size of a window. For most
439 // windows this is just the client area of the window, but for
440 // some like scrolled windows it is more or less independent of
441 // the screen window size. You may override the DoXXXVirtual
442 // methods below for classes where that is is the case.
444 void SetVirtualSize( const wxSize
&size
) { DoSetVirtualSize( size
.x
, size
.y
); }
445 void SetVirtualSize( int x
, int y
) { DoSetVirtualSize( x
, y
); }
447 wxSize
GetVirtualSize() const { return DoGetVirtualSize(); }
448 void GetVirtualSize( int *x
, int *y
) const
450 wxSize
s( DoGetVirtualSize() );
458 // Override these methods for windows that have a virtual size
459 // independent of their client size. eg. the virtual area of a
462 virtual void DoSetVirtualSize( int x
, int y
);
463 virtual wxSize
DoGetVirtualSize() const;
465 // Return the largest of ClientSize and BestSize (as determined
466 // by a sizer, interior children, or other means)
468 virtual wxSize
GetBestVirtualSize() const
470 wxSize
client( GetClientSize() );
471 wxSize
best( GetBestSize() );
473 return wxSize( wxMax( client
.x
, best
.x
), wxMax( client
.y
, best
.y
) );
476 // return the size of the left/right and top/bottom borders in x and y
477 // components of the result respectively
478 virtual wxSize
GetWindowBorderSize() const;
484 // returns true if window was shown/hidden, false if the nothing was
485 // done (window was already shown/hidden)
486 virtual bool Show( bool show
= true );
487 bool Hide() { return Show(false); }
489 // returns true if window was enabled/disabled, false if nothing done
490 virtual bool Enable( bool enable
= true );
491 bool Disable() { return Enable(false); }
493 virtual bool IsShown() const { return m_isShown
; }
494 virtual bool IsEnabled() const { return m_isEnabled
; }
496 // returns true if the window is visible, i.e. IsShown() returns true
497 // if called on it and all its parents up to the first TLW
498 virtual bool IsShownOnScreen() const;
500 // get/set window style (setting style won't update the window and so
501 // is only useful for internal usage)
502 virtual void SetWindowStyleFlag( long style
) { m_windowStyle
= style
; }
503 virtual long GetWindowStyleFlag() const { return m_windowStyle
; }
505 // just some (somewhat shorter) synonims
506 void SetWindowStyle( long style
) { SetWindowStyleFlag(style
); }
507 long GetWindowStyle() const { return GetWindowStyleFlag(); }
509 // check if the flag is set
510 bool HasFlag(int flag
) const { return (m_windowStyle
& flag
) != 0; }
511 virtual bool IsRetained() const { return HasFlag(wxRETAINED
); }
513 // turn the flag on if it had been turned off before and vice versa,
514 // return true if the flag is currently turned on
515 bool ToggleWindowStyle(int flag
);
517 // extra style: the less often used style bits which can't be set with
518 // SetWindowStyleFlag()
519 virtual void SetExtraStyle(long exStyle
) { m_exStyle
= exStyle
; }
520 long GetExtraStyle() const { return m_exStyle
; }
522 // make the window modal (all other windows unresponsive)
523 virtual void MakeModal(bool modal
= true);
526 // (primitive) theming support
527 // ---------------------------
529 virtual void SetThemeEnabled(bool enableTheme
) { m_themeEnabled
= enableTheme
; }
530 virtual bool GetThemeEnabled() const { return m_themeEnabled
; }
533 // focus and keyboard handling
534 // ---------------------------
536 // set focus to this window
537 virtual void SetFocus() = 0;
539 // set focus to this window as the result of a keyboard action
540 virtual void SetFocusFromKbd() { SetFocus(); }
542 // return the window which currently has the focus or NULL
543 static wxWindow
*FindFocus();
545 static wxWindow
*DoFindFocus() /* = 0: implement in derived classes */;
547 // can this window have focus?
548 virtual bool AcceptsFocus() const { return IsShown() && IsEnabled(); }
550 // can this window be given focus by keyboard navigation? if not, the
551 // only way to give it focus (provided it accepts it at all) is to
553 virtual bool AcceptsFocusFromKeyboard() const { return AcceptsFocus(); }
555 // navigates in the specified direction by sending a wxNavigationKeyEvent
556 virtual bool Navigate(int flags
= wxNavigationKeyEvent::IsForward
);
558 // move this window just before/after the specified one in tab order
559 // (the other window must be our sibling!)
560 void MoveBeforeInTabOrder(wxWindow
*win
)
561 { DoMoveInTabOrder(win
, MoveBefore
); }
562 void MoveAfterInTabOrder(wxWindow
*win
)
563 { DoMoveInTabOrder(win
, MoveAfter
); }
566 // parent/children relations
567 // -------------------------
569 // get the list of children
570 const wxWindowList
& GetChildren() const { return m_children
; }
571 wxWindowList
& GetChildren() { return m_children
; }
573 // needed just for extended runtime
574 const wxWindowList
& GetWindowChildren() const { return GetChildren() ; }
576 // get the parent or the parent of the parent
577 wxWindow
*GetParent() const { return m_parent
; }
578 inline wxWindow
*GetGrandParent() const;
580 // is this window a top level one?
581 virtual bool IsTopLevel() const;
583 // it doesn't really change parent, use Reparent() instead
584 void SetParent( wxWindowBase
*parent
) { m_parent
= (wxWindow
*)parent
; }
585 // change the real parent of this window, return true if the parent
586 // was changed, false otherwise (error or newParent == oldParent)
587 virtual bool Reparent( wxWindowBase
*newParent
);
589 // implementation mostly
590 virtual void AddChild( wxWindowBase
*child
);
591 virtual void RemoveChild( wxWindowBase
*child
);
593 // looking for windows
594 // -------------------
596 // find window among the descendants of this one either by id or by
597 // name (return NULL if not found)
598 wxWindow
*FindWindow(long winid
) const;
599 wxWindow
*FindWindow(const wxString
& name
) const;
601 // Find a window among any window (all return NULL if not found)
602 static wxWindow
*FindWindowById( long winid
, const wxWindow
*parent
= NULL
);
603 static wxWindow
*FindWindowByName( const wxString
& name
,
604 const wxWindow
*parent
= NULL
);
605 static wxWindow
*FindWindowByLabel( const wxString
& label
,
606 const wxWindow
*parent
= NULL
);
608 // event handler stuff
609 // -------------------
611 // get the current event handler
612 wxEvtHandler
*GetEventHandler() const { return m_eventHandler
; }
614 // replace the event handler (allows to completely subclass the
616 void SetEventHandler( wxEvtHandler
*handler
) { m_eventHandler
= handler
; }
618 // push/pop event handler: allows to chain a custom event handler to
619 // alreasy existing ones
620 void PushEventHandler( wxEvtHandler
*handler
);
621 wxEvtHandler
*PopEventHandler( bool deleteHandler
= false );
623 // find the given handler in the event handler chain and remove (but
624 // not delete) it from the event handler chain, return true if it was
625 // found and false otherwise (this also results in an assert failure so
626 // this function should only be called when the handler is supposed to
628 bool RemoveEventHandler(wxEvtHandler
*handler
);
634 // a window may have an associated validator which is used to control
636 virtual void SetValidator( const wxValidator
&validator
);
637 virtual wxValidator
*GetValidator() { return m_windowValidator
; }
638 #endif // wxUSE_VALIDATORS
641 // dialog oriented functions
642 // -------------------------
644 // validate the correctness of input, return true if ok
645 virtual bool Validate();
647 // transfer data between internal and GUI representations
648 virtual bool TransferDataToWindow();
649 virtual bool TransferDataFromWindow();
651 virtual void InitDialog();
656 virtual void SetAcceleratorTable( const wxAcceleratorTable
& accel
)
657 { m_acceleratorTable
= accel
; }
658 wxAcceleratorTable
*GetAcceleratorTable()
659 { return &m_acceleratorTable
; }
661 #endif // wxUSE_ACCEL
664 // hot keys (system wide accelerators)
665 // -----------------------------------
667 virtual bool RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
);
668 virtual bool UnregisterHotKey(int hotkeyId
);
669 #endif // wxUSE_HOTKEY
672 // dialog units translations
673 // -------------------------
675 wxPoint
ConvertPixelsToDialog( const wxPoint
& pt
);
676 wxPoint
ConvertDialogToPixels( const wxPoint
& pt
);
677 wxSize
ConvertPixelsToDialog( const wxSize
& sz
)
679 wxPoint
pt(ConvertPixelsToDialog(wxPoint(sz
.x
, sz
.y
)));
681 return wxSize(pt
.x
, pt
.y
);
684 wxSize
ConvertDialogToPixels( const wxSize
& sz
)
686 wxPoint
pt(ConvertDialogToPixels(wxPoint(sz
.x
, sz
.y
)));
688 return wxSize(pt
.x
, pt
.y
);
694 // move the mouse to the specified position
695 virtual void WarpPointer(int x
, int y
) = 0;
697 // start or end mouse capture, these functions maintain the stack of
698 // windows having captured the mouse and after calling ReleaseMouse()
699 // the mouse is not released but returns to the window which had had
700 // captured it previously (if any)
704 // get the window which currently captures the mouse or NULL
705 static wxWindow
*GetCapture();
707 // does this window have the capture?
708 virtual bool HasCapture() const
709 { return (wxWindow
*)this == GetCapture(); }
711 // painting the window
712 // -------------------
714 // mark the specified rectangle (or the whole window) as "dirty" so it
716 virtual void Refresh( bool eraseBackground
= true,
717 const wxRect
*rect
= (const wxRect
*) NULL
) = 0;
719 // a less awkward wrapper for Refresh
720 void RefreshRect(const wxRect
& rect
, bool eraseBackground
= true)
722 Refresh(eraseBackground
, &rect
);
725 // repaint all invalid areas of the window immediately
726 virtual void Update() { }
728 // clear the window background
729 virtual void ClearBackground();
731 // freeze the window: don't redraw it until it is thawed
732 virtual void Freeze() { }
734 // thaw the window: redraw it after it had been frozen
735 virtual void Thaw() { }
737 // return true if window had been frozen and not unthawed yet
738 virtual bool IsFrozen() const { return false; }
740 // adjust DC for drawing on this window
741 virtual void PrepareDC( wxDC
& WXUNUSED(dc
) ) { }
743 // return true if the window contents is double buffered by the system
744 virtual bool IsDoubleBuffered() const { return false; }
746 // the update region of the window contains the areas which must be
747 // repainted by the program
748 const wxRegion
& GetUpdateRegion() const { return m_updateRegion
; }
749 wxRegion
& GetUpdateRegion() { return m_updateRegion
; }
751 // get the update rectangleregion bounding box in client coords
752 wxRect
GetUpdateClientRect() const;
754 // these functions verify whether the given point/rectangle belongs to
755 // (or at least intersects with) the update region
756 virtual bool DoIsExposed( int x
, int y
) const;
757 virtual bool DoIsExposed( int x
, int y
, int w
, int h
) const;
759 bool IsExposed( int x
, int y
) const
760 { return DoIsExposed(x
, y
); }
761 bool IsExposed( int x
, int y
, int w
, int h
) const
762 { return DoIsExposed(x
, y
, w
, h
); }
763 bool IsExposed( const wxPoint
& pt
) const
764 { return DoIsExposed(pt
.x
, pt
.y
); }
765 bool IsExposed( const wxRect
& rect
) const
766 { return DoIsExposed(rect
.x
, rect
.y
, rect
.width
, rect
.height
); }
768 // colours, fonts and cursors
769 // --------------------------
771 // get the default attributes for the controls of this class: we
772 // provide a virtual function which can be used to query the default
773 // attributes of an existing control and a static function which can
774 // be used even when no existing object of the given class is
775 // available, but which won't return any styles specific to this
776 // particular control, of course (e.g. "Ok" button might have
777 // different -- bold for example -- font)
778 virtual wxVisualAttributes
GetDefaultAttributes() const
780 return GetClassDefaultAttributes(GetWindowVariant());
783 static wxVisualAttributes
784 GetClassDefaultAttributes(wxWindowVariant variant
= wxWINDOW_VARIANT_NORMAL
);
786 // set/retrieve the window colours (system defaults are used by
787 // default): SetXXX() functions return true if colour was changed,
788 // SetDefaultXXX() reset the "m_inheritXXX" flag after setting the
789 // value to prevent it from being inherited by our children
790 virtual bool SetBackgroundColour(const wxColour
& colour
);
791 void SetOwnBackgroundColour(const wxColour
& colour
)
793 if ( SetBackgroundColour(colour
) )
794 m_inheritBgCol
= false;
796 wxColour
GetBackgroundColour() const;
797 bool InheritsBackgroundColour() const
799 return m_inheritBgCol
;
801 bool UseBgCol() const
806 virtual bool SetForegroundColour(const wxColour
& colour
);
807 void SetOwnForegroundColour(const wxColour
& colour
)
809 if ( SetForegroundColour(colour
) )
810 m_inheritFgCol
= false;
812 wxColour
GetForegroundColour() const;
814 // Set/get the background style.
815 // Pass one of wxBG_STYLE_SYSTEM, wxBG_STYLE_COLOUR, wxBG_STYLE_CUSTOM
816 virtual bool SetBackgroundStyle(wxBackgroundStyle style
) { m_backgroundStyle
= style
; return true; }
817 virtual wxBackgroundStyle
GetBackgroundStyle() const { return m_backgroundStyle
; }
819 // returns true if the control has "transparent" areas such as a
820 // wxStaticText and wxCheckBox and the background should be adapted
821 // from a parent window
822 virtual bool HasTransparentBackground() { return false; }
824 // set/retrieve the font for the window (SetFont() returns true if the
825 // font really changed)
826 virtual bool SetFont(const wxFont
& font
) = 0;
827 void SetOwnFont(const wxFont
& font
)
830 m_inheritFont
= false;
832 wxFont
GetFont() const;
834 // set/retrieve the cursor for this window (SetCursor() returns true
835 // if the cursor was really changed)
836 virtual bool SetCursor( const wxCursor
&cursor
);
837 const wxCursor
& GetCursor() const { return m_cursor
; }
840 // associate a caret with the window
841 void SetCaret(wxCaret
*caret
);
842 // get the current caret (may be NULL)
843 wxCaret
*GetCaret() const { return m_caret
; }
844 #endif // wxUSE_CARET
846 // get the (average) character size for the current font
847 virtual int GetCharHeight() const = 0;
848 virtual int GetCharWidth() const = 0;
850 // get the width/height/... of the text using current or specified
852 virtual void GetTextExtent(const wxString
& string
,
854 int *descent
= (int *) NULL
,
855 int *externalLeading
= (int *) NULL
,
856 const wxFont
*theFont
= (const wxFont
*) NULL
)
859 // client <-> screen coords
860 // ------------------------
862 // translate to/from screen/client coordinates (pointers may be NULL)
863 void ClientToScreen( int *x
, int *y
) const
864 { DoClientToScreen(x
, y
); }
865 void ScreenToClient( int *x
, int *y
) const
866 { DoScreenToClient(x
, y
); }
868 // wxPoint interface to do the same thing
869 wxPoint
ClientToScreen(const wxPoint
& pt
) const
871 int x
= pt
.x
, y
= pt
.y
;
872 DoClientToScreen(&x
, &y
);
874 return wxPoint(x
, y
);
877 wxPoint
ScreenToClient(const wxPoint
& pt
) const
879 int x
= pt
.x
, y
= pt
.y
;
880 DoScreenToClient(&x
, &y
);
882 return wxPoint(x
, y
);
885 // test where the given (in client coords) point lies
886 wxHitTest
HitTest(wxCoord x
, wxCoord y
) const
887 { return DoHitTest(x
, y
); }
889 wxHitTest
HitTest(const wxPoint
& pt
) const
890 { return DoHitTest(pt
.x
, pt
.y
); }
895 // get the window border style from the given flags: this is different from
896 // simply doing flags & wxBORDER_MASK because it uses GetDefaultBorder() to
897 // translate wxBORDER_DEFAULT to something reasonable
898 wxBorder
GetBorder(long flags
) const;
900 // get border for the flags of this window
901 wxBorder
GetBorder() const { return GetBorder(GetWindowStyleFlag()); }
903 // send wxUpdateUIEvents to this window, and children if recurse is true
904 virtual void UpdateWindowUI(long flags
= wxUPDATE_UI_NONE
);
906 // do the window-specific processing after processing the update event
907 virtual void DoUpdateWindowUI(wxUpdateUIEvent
& event
) ;
910 bool PopupMenu(wxMenu
*menu
, const wxPoint
& pos
= wxDefaultPosition
)
911 { return DoPopupMenu(menu
, pos
.x
, pos
.y
); }
912 bool PopupMenu(wxMenu
*menu
, int x
, int y
)
913 { return DoPopupMenu(menu
, x
, y
); }
914 #endif // wxUSE_MENUS
916 // override this method to return true for controls having multiple pages
917 virtual bool HasMultiplePages() const { return false; }
923 // does the window have the scrollbar for this orientation?
924 bool HasScrollbar(int orient
) const
926 return (m_windowStyle
&
927 (orient
== wxHORIZONTAL
? wxHSCROLL
: wxVSCROLL
)) != 0;
930 // configure the window scrollbars
931 virtual void SetScrollbar( int orient
,
935 bool refresh
= true ) = 0;
936 virtual void SetScrollPos( int orient
, int pos
, bool refresh
= true ) = 0;
937 virtual int GetScrollPos( int orient
) const = 0;
938 virtual int GetScrollThumb( int orient
) const = 0;
939 virtual int GetScrollRange( int orient
) const = 0;
941 // scroll window to the specified position
942 virtual void ScrollWindow( int dx
, int dy
,
943 const wxRect
* rect
= (wxRect
*) NULL
) = 0;
945 // scrolls window by line/page: note that not all controls support this
947 // return true if the position changed, false otherwise
948 virtual bool ScrollLines(int WXUNUSED(lines
)) { return false; }
949 virtual bool ScrollPages(int WXUNUSED(pages
)) { return false; }
951 // convenient wrappers for ScrollLines/Pages
952 bool LineUp() { return ScrollLines(-1); }
953 bool LineDown() { return ScrollLines(1); }
954 bool PageUp() { return ScrollPages(-1); }
955 bool PageDown() { return ScrollPages(1); }
957 // context-sensitive help
958 // ----------------------
960 // these are the convenience functions wrapping wxHelpProvider methods
963 // associate this help text with this window
964 void SetHelpText(const wxString
& text
);
965 // associate this help text with all windows with the same id as this
967 void SetHelpTextForId(const wxString
& text
);
968 // get the help string associated with the given position in this window
970 // notice that pt may be invalid if event origin is keyboard or unknown
971 // and this method should return the global window help text then
972 virtual wxString
GetHelpTextAtPoint(const wxPoint
& pt
,
973 wxHelpEvent::Origin origin
) const;
974 // returns the position-independent help text
975 wxString
GetHelpText() const
977 return GetHelpTextAtPoint(wxDefaultPosition
, wxHelpEvent::Origin_Unknown
);
981 // silently ignore SetHelpText() calls
982 void SetHelpText(const wxString
& WXUNUSED(text
)) { }
983 void SetHelpTextForId(const wxString
& WXUNUSED(text
)) { }
990 // the easiest way to set a tooltip for a window is to use this method
991 void SetToolTip( const wxString
&tip
);
992 // attach a tooltip to the window
993 void SetToolTip( wxToolTip
*tip
) { DoSetToolTip(tip
); }
994 // get the associated tooltip or NULL if none
995 wxToolTip
* GetToolTip() const { return m_tooltip
; }
996 wxString
GetToolTipText() const ;
998 // make it much easier to compile apps in an environment
999 // that doesn't support tooltips, such as PocketPC
1000 inline void SetToolTip( const wxString
& WXUNUSED(tip
) ) {}
1001 #endif // wxUSE_TOOLTIPS
1005 #if wxUSE_DRAG_AND_DROP
1006 // set/retrieve the drop target associated with this window (may be
1007 // NULL; it's owned by the window and will be deleted by it)
1008 virtual void SetDropTarget( wxDropTarget
*dropTarget
) = 0;
1009 virtual wxDropTarget
*GetDropTarget() const { return m_dropTarget
; }
1010 #endif // wxUSE_DRAG_AND_DROP
1012 // constraints and sizers
1013 // ----------------------
1014 #if wxUSE_CONSTRAINTS
1015 // set the constraints for this window or retrieve them (may be NULL)
1016 void SetConstraints( wxLayoutConstraints
*constraints
);
1017 wxLayoutConstraints
*GetConstraints() const { return m_constraints
; }
1019 // implementation only
1020 void UnsetConstraints(wxLayoutConstraints
*c
);
1021 wxWindowList
*GetConstraintsInvolvedIn() const
1022 { return m_constraintsInvolvedIn
; }
1023 void AddConstraintReference(wxWindowBase
*otherWin
);
1024 void RemoveConstraintReference(wxWindowBase
*otherWin
);
1025 void DeleteRelatedConstraints();
1026 void ResetConstraints();
1028 // these methods may be overridden for special layout algorithms
1029 virtual void SetConstraintSizes(bool recurse
= true);
1030 virtual bool LayoutPhase1(int *noChanges
);
1031 virtual bool LayoutPhase2(int *noChanges
);
1032 virtual bool DoPhase(int phase
);
1034 // these methods are virtual but normally won't be overridden
1035 virtual void SetSizeConstraint(int x
, int y
, int w
, int h
);
1036 virtual void MoveConstraint(int x
, int y
);
1037 virtual void GetSizeConstraint(int *w
, int *h
) const ;
1038 virtual void GetClientSizeConstraint(int *w
, int *h
) const ;
1039 virtual void GetPositionConstraint(int *x
, int *y
) const ;
1041 #endif // wxUSE_CONSTRAINTS
1043 // when using constraints or sizers, it makes sense to update
1044 // children positions automatically whenever the window is resized
1045 // - this is done if autoLayout is on
1046 void SetAutoLayout( bool autoLayout
) { m_autoLayout
= autoLayout
; }
1047 bool GetAutoLayout() const { return m_autoLayout
; }
1049 // lay out the window and its children
1050 virtual bool Layout();
1053 void SetSizer(wxSizer
*sizer
, bool deleteOld
= true );
1054 void SetSizerAndFit( wxSizer
*sizer
, bool deleteOld
= true );
1056 wxSizer
*GetSizer() const { return m_windowSizer
; }
1058 // Track if this window is a member of a sizer
1059 void SetContainingSizer(wxSizer
* sizer
);
1060 wxSizer
*GetContainingSizer() const { return m_containingSizer
; }
1063 // ----------------------
1064 #if wxUSE_ACCESSIBILITY
1065 // Override to create a specific accessible object.
1066 virtual wxAccessible
* CreateAccessible();
1068 // Sets the accessible object.
1069 void SetAccessible(wxAccessible
* accessible
) ;
1071 // Returns the accessible object.
1072 wxAccessible
* GetAccessible() { return m_accessible
; };
1074 // Returns the accessible object, creating if necessary.
1075 wxAccessible
* GetOrCreateAccessible() ;
1079 // Set window transparency if the platform supports it
1080 virtual bool SetTransparent(wxByte
WXUNUSED(alpha
)) { return false; }
1081 virtual bool CanSetTransparent() { return false; }
1088 void OnSysColourChanged( wxSysColourChangedEvent
& event
);
1089 void OnInitDialog( wxInitDialogEvent
&event
);
1090 void OnMiddleClick( wxMouseEvent
& event
);
1092 void OnHelp(wxHelpEvent
& event
);
1093 #endif // wxUSE_HELP
1095 // virtual function for implementing internal idle
1097 virtual void OnInternalIdle() {}
1099 // call internal idle recursively
1100 // void ProcessInternalIdle() ;
1102 // get the handle of the window for the underlying window system: this
1103 // is only used for wxWin itself or for user code which wants to call
1104 // platform-specific APIs
1105 virtual WXWidget
GetHandle() const = 0;
1106 // associate the window with a new native handle
1107 virtual void AssociateHandle(WXWidget
WXUNUSED(handle
)) { }
1108 // dissociate the current native handle from the window
1109 virtual void DissociateHandle() { }
1112 // Store the palette used by DCs in wxWindow so that the dcs can share
1113 // a palette. And we can respond to palette messages.
1114 wxPalette
GetPalette() const { return m_palette
; }
1116 // When palette is changed tell the DC to set the system palette to the
1118 void SetPalette(const wxPalette
& pal
);
1120 // return true if we have a specific palette
1121 bool HasCustomPalette() const { return m_hasCustomPalette
; }
1123 // return the first parent window with a custom palette or NULL
1124 wxWindow
*GetAncestorWithCustomPalette() const;
1125 #endif // wxUSE_PALETTE
1127 // inherit the parents visual attributes if they had been explicitly set
1128 // by the user (i.e. we don't inherit default attributes) and if we don't
1129 // have our own explicitly set
1130 virtual void InheritAttributes();
1132 // returns false from here if this window doesn't want to inherit the
1133 // parents colours even if InheritAttributes() would normally do it
1135 // this just provides a simple way to customize InheritAttributes()
1136 // behaviour in the most common case
1137 virtual bool ShouldInheritColours() const { return false; }
1139 // returns true if the window can be positioned outside of parent's client
1140 // area (normal windows can't, but e.g. menubar or statusbar can):
1141 virtual bool CanBeOutsideClientArea() const { return false; }
1144 // event handling specific to wxWindow
1145 virtual bool TryValidator(wxEvent
& event
);
1146 virtual bool TryParent(wxEvent
& event
);
1148 // common part of MoveBefore/AfterInTabOrder()
1151 MoveBefore
, // insert before the given window
1152 MoveAfter
// insert after the given window
1154 virtual void DoMoveInTabOrder(wxWindow
*win
, MoveKind move
);
1156 #if wxUSE_CONSTRAINTS
1157 // satisfy the constraints for the windows but don't set the window sizes
1158 void SatisfyConstraints();
1159 #endif // wxUSE_CONSTRAINTS
1161 // Send the wxWindowDestroyEvent
1162 void SendDestroyEvent();
1164 // returns the main window of composite control; this is the window
1165 // that FindFocus returns if the focus is in one of composite control's
1167 virtual wxWindow
*GetMainWindowOfCompositeControl()
1168 { return (wxWindow
*)this; }
1170 // the window id - a number which uniquely identifies a window among
1171 // its siblings unless it is wxID_ANY
1172 wxWindowID m_windowId
;
1174 // the parent window of this window (or NULL) and the list of the children
1177 wxWindowList m_children
;
1179 // the minimal allowed size for the window (no minimal size if variable(s)
1180 // contain(s) wxDefaultCoord)
1186 // event handler for this window: usually is just 'this' but may be
1187 // changed with SetEventHandler()
1188 wxEvtHandler
*m_eventHandler
;
1190 #if wxUSE_VALIDATORS
1191 // associated validator or NULL if none
1192 wxValidator
*m_windowValidator
;
1193 #endif // wxUSE_VALIDATORS
1195 #if wxUSE_DRAG_AND_DROP
1196 wxDropTarget
*m_dropTarget
;
1197 #endif // wxUSE_DRAG_AND_DROP
1199 // visual window attributes
1201 wxFont m_font
; // see m_hasFont
1202 wxColour m_backgroundColour
, // m_hasBgCol
1203 m_foregroundColour
; // m_hasFgCol
1207 #endif // wxUSE_CARET
1209 // the region which should be repainted in response to paint event
1210 wxRegion m_updateRegion
;
1213 // the accelerator table for the window which translates key strokes into
1215 wxAcceleratorTable m_acceleratorTable
;
1216 #endif // wxUSE_ACCEL
1218 // the tooltip for this window (may be NULL)
1220 wxToolTip
*m_tooltip
;
1221 #endif // wxUSE_TOOLTIPS
1223 // constraints and sizers
1224 #if wxUSE_CONSTRAINTS
1225 // the constraints for this window or NULL
1226 wxLayoutConstraints
*m_constraints
;
1228 // constraints this window is involved in
1229 wxWindowList
*m_constraintsInvolvedIn
;
1230 #endif // wxUSE_CONSTRAINTS
1232 // this window's sizer
1233 wxSizer
*m_windowSizer
;
1235 // The sizer this window is a member of, if any
1236 wxSizer
*m_containingSizer
;
1238 // Layout() window automatically when its size changes?
1239 bool m_autoLayout
:1;
1244 bool m_isBeingDeleted
:1;
1246 // was the window colours/font explicitly changed by user?
1251 // and should it be inherited by children?
1252 bool m_inheritBgCol
:1;
1253 bool m_inheritFgCol
:1;
1254 bool m_inheritFont
:1;
1256 // window attributes
1259 wxString m_windowName
;
1260 bool m_themeEnabled
;
1261 wxBackgroundStyle m_backgroundStyle
;
1263 wxPalette m_palette
;
1264 bool m_hasCustomPalette
;
1265 #endif // wxUSE_PALETTE
1267 #if wxUSE_ACCESSIBILITY
1268 wxAccessible
* m_accessible
;
1271 // Virtual size (scrolling)
1272 wxSize m_virtualSize
;
1274 wxScrollHelper
*m_scrollHelper
;
1276 int m_minVirtualWidth
; // VirtualSizeHints
1277 int m_minVirtualHeight
;
1278 int m_maxVirtualWidth
;
1279 int m_maxVirtualHeight
;
1281 wxWindowVariant m_windowVariant
;
1283 // override this to change the default (i.e. used when no style is
1284 // specified) border for the window class
1285 virtual wxBorder
GetDefaultBorder() const;
1287 // Get the default size for the new window if no explicit size given. TLWs
1288 // have their own default size so this is just for non top-level windows.
1289 static int WidthDefault(int w
) { return w
== wxDefaultCoord
? 20 : w
; }
1290 static int HeightDefault(int h
) { return h
== wxDefaultCoord
? 20 : h
; }
1293 // Used to save the results of DoGetBestSize so it doesn't need to be
1294 // recalculated each time the value is needed.
1295 wxSize m_bestSizeCache
;
1297 wxDEPRECATED( void SetBestSize(const wxSize
& size
) ); // use SetInitialSize
1298 wxDEPRECATED( virtual void SetInitialBestSize(const wxSize
& size
) ); // use SetInitialSize
1302 // more pure virtual functions
1303 // ---------------------------
1305 // NB: we must have DoSomething() function when Something() is an overloaded
1306 // method: indeed, we can't just have "virtual Something()" in case when
1307 // the function is overloaded because then we'd have to make virtual all
1308 // the variants (otherwise only the virtual function may be called on a
1309 // pointer to derived class according to C++ rules) which is, in
1310 // general, absolutely not needed. So instead we implement all
1311 // overloaded Something()s in terms of DoSomething() which will be the
1312 // only one to be virtual.
1314 // coordinates translation
1315 virtual void DoClientToScreen( int *x
, int *y
) const = 0;
1316 virtual void DoScreenToClient( int *x
, int *y
) const = 0;
1318 virtual wxHitTest
DoHitTest(wxCoord x
, wxCoord y
) const;
1320 // capture/release the mouse, used by Capture/ReleaseMouse()
1321 virtual void DoCaptureMouse() = 0;
1322 virtual void DoReleaseMouse() = 0;
1324 // retrieve the position/size of the window
1325 virtual void DoGetPosition(int *x
, int *y
) const = 0;
1326 virtual void DoGetScreenPosition(int *x
, int *y
) const;
1327 virtual void DoGetSize(int *width
, int *height
) const = 0;
1328 virtual void DoGetClientSize(int *width
, int *height
) const = 0;
1330 // get the size which best suits the window: for a control, it would be
1331 // the minimal size which doesn't truncate the control, for a panel - the
1332 // same size as it would have after a call to Fit()
1333 virtual wxSize
DoGetBestSize() const;
1335 // called from DoGetBestSize() to convert best virtual size (returned by
1336 // the window sizer) to the best size for the window itself; this is
1337 // overridden at wxScrolledWindow level to clump down virtual size to real
1338 virtual wxSize
GetWindowSizeForVirtualSize(const wxSize
& size
) const
1343 // this is the virtual function to be overriden in any derived class which
1344 // wants to change how SetSize() or Move() works - it is called by all
1345 // versions of these functions in the base class
1346 virtual void DoSetSize(int x
, int y
,
1347 int width
, int height
,
1348 int sizeFlags
= wxSIZE_AUTO
) = 0;
1350 // same as DoSetSize() for the client size
1351 virtual void DoSetClientSize(int width
, int height
) = 0;
1353 // move the window to the specified location and resize it: this is called
1354 // from both DoSetSize() and DoSetClientSize() and would usually just
1355 // reposition this window except for composite controls which will want to
1356 // arrange themselves inside the given rectangle
1358 // Important note: the coordinates passed to this method are in parent's
1359 // *window* coordinates and not parent's client coordinates (as the values
1360 // passed to DoSetSize and returned by DoGetPosition are)!
1361 virtual void DoMoveWindow(int x
, int y
, int width
, int height
) = 0;
1363 // centre the window in the specified direction on parent, note that
1364 // wxCENTRE_ON_SCREEN shouldn't be specified here, it only makes sense for
1366 virtual void DoCentre(int dir
);
1369 virtual void DoSetToolTip( wxToolTip
*tip
);
1370 #endif // wxUSE_TOOLTIPS
1373 virtual bool DoPopupMenu(wxMenu
*menu
, int x
, int y
) = 0;
1374 #endif // wxUSE_MENUS
1376 // Makes an adjustment to the window position to make it relative to the
1377 // parents client area, e.g. if the parent is a frame with a toolbar, its
1378 // (0, 0) is just below the toolbar
1379 virtual void AdjustForParentClientOrigin(int& x
, int& y
,
1380 int sizeFlags
= 0) const;
1382 // implements the window variants
1383 virtual void DoSetWindowVariant( wxWindowVariant variant
) ;
1385 // Must be called when mouse capture is lost to send
1386 // wxMouseCaptureLostEvent to windows on capture stack.
1387 static void NotifyCaptureLost();
1390 // contains the last id generated by NewControlId
1391 static int ms_lastControlId
;
1393 // the stack of windows which have captured the mouse
1394 static struct WXDLLEXPORT wxWindowNext
*ms_winCaptureNext
;
1395 // the window that currently has mouse capture
1396 static wxWindow
*ms_winCaptureCurrent
;
1397 // indicates if execution is inside CaptureMouse/ReleaseMouse
1398 static bool ms_winCaptureChanging
;
1400 DECLARE_ABSTRACT_CLASS(wxWindowBase
)
1401 DECLARE_NO_COPY_CLASS(wxWindowBase
)
1402 DECLARE_EVENT_TABLE()
1407 // Inlines for some deprecated methods
1408 inline wxSize
wxWindowBase::GetBestFittingSize() const
1410 return GetEffectiveMinSize();
1413 inline void wxWindowBase::SetBestFittingSize(const wxSize
& size
)
1415 SetInitialSize(size
);
1418 inline void wxWindowBase::SetBestSize(const wxSize
& size
)
1420 SetInitialSize(size
);
1423 inline void wxWindowBase::SetInitialBestSize(const wxSize
& size
)
1425 SetInitialSize(size
);
1429 // ----------------------------------------------------------------------------
1430 // now include the declaration of wxWindow class
1431 // ----------------------------------------------------------------------------
1433 // include the declaration of the platform-specific class
1434 #if defined(__WXPALMOS__)
1435 #ifdef __WXUNIVERSAL__
1436 #define wxWindowNative wxWindowPalm
1438 #define wxWindowPalm wxWindow
1439 #endif // wxUniv/!wxUniv
1440 #include "wx/palmos/window.h"
1441 #elif defined(__WXMSW__)
1442 #ifdef __WXUNIVERSAL__
1443 #define wxWindowNative wxWindowMSW
1445 #define wxWindowMSW wxWindow
1446 #endif // wxUniv/!wxUniv
1447 #include "wx/msw/window.h"
1448 #elif defined(__WXMOTIF__)
1449 #include "wx/motif/window.h"
1450 #elif defined(__WXGTK20__)
1451 #ifdef __WXUNIVERSAL__
1452 #define wxWindowNative wxWindowGTK
1454 #define wxWindowGTK wxWindow
1456 #include "wx/gtk/window.h"
1457 #elif defined(__WXGTK__)
1458 #ifdef __WXUNIVERSAL__
1459 #define wxWindowNative wxWindowGTK
1461 #define wxWindowGTK wxWindow
1463 #include "wx/gtk1/window.h"
1464 #elif defined(__WXX11__)
1465 #ifdef __WXUNIVERSAL__
1466 #define wxWindowNative wxWindowX11
1468 #define wxWindowX11 wxWindow
1470 #include "wx/x11/window.h"
1471 #elif defined(__WXMGL__)
1472 #define wxWindowNative wxWindowMGL
1473 #include "wx/mgl/window.h"
1474 #elif defined(__WXDFB__)
1475 #define wxWindowNative wxWindowDFB
1476 #include "wx/dfb/window.h"
1477 #elif defined(__WXMAC__)
1478 #ifdef __WXUNIVERSAL__
1479 #define wxWindowNative wxWindowMac
1481 #define wxWindowMac wxWindow
1483 #include "wx/mac/window.h"
1484 #elif defined(__WXCOCOA__)
1485 #ifdef __WXUNIVERSAL__
1486 #define wxWindowNative wxWindowCocoa
1488 #define wxWindowCocoa wxWindow
1490 #include "wx/cocoa/window.h"
1491 #elif defined(__WXPM__)
1492 #ifdef __WXUNIVERSAL__
1493 #define wxWindowNative wxWindowOS2
1495 #define wxWindowOS2 wxWindow
1496 #endif // wxUniv/!wxUniv
1497 #include "wx/os2/window.h"
1500 // for wxUniversal, we now derive the real wxWindow from wxWindow<platform>,
1501 // for the native ports we already have defined it above
1502 #if defined(__WXUNIVERSAL__)
1503 #ifndef wxWindowNative
1504 #error "wxWindowNative must be defined above!"
1507 #include "wx/univ/window.h"
1510 // ----------------------------------------------------------------------------
1511 // inline functions which couldn't be declared in the class body because of
1512 // forward dependencies
1513 // ----------------------------------------------------------------------------
1515 inline wxWindow
*wxWindowBase::GetGrandParent() const
1517 return m_parent
? m_parent
->GetParent() : (wxWindow
*)NULL
;
1520 // ----------------------------------------------------------------------------
1522 // ----------------------------------------------------------------------------
1524 // Find the wxWindow at the current mouse position, also returning the mouse
1526 extern WXDLLEXPORT wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
);
1528 // Get the current mouse position.
1529 extern WXDLLEXPORT wxPoint
wxGetMousePosition();
1531 // get the currently active window of this application or NULL
1532 extern WXDLLEXPORT wxWindow
*wxGetActiveWindow();
1534 // get the (first) top level parent window
1535 WXDLLEXPORT wxWindow
* wxGetTopLevelParent(wxWindow
*win
);
1537 #if WXWIN_COMPATIBILITY_2_6
1538 // deprecated (doesn't start with 'wx' prefix), use wxWindow::NewControlId()
1539 wxDEPRECATED( int NewControlId() );
1540 inline int NewControlId() { return wxWindowBase::NewControlId(); }
1541 #endif // WXWIN_COMPATIBILITY_2_6
1543 #if wxUSE_ACCESSIBILITY
1544 // ----------------------------------------------------------------------------
1545 // accessible object for windows
1546 // ----------------------------------------------------------------------------
1548 class WXDLLEXPORT wxWindowAccessible
: public wxAccessible
1551 wxWindowAccessible(wxWindow
* win
): wxAccessible(win
) { if (win
) win
->SetAccessible(this); }
1552 virtual ~wxWindowAccessible() {}
1556 // Can return either a child object, or an integer
1557 // representing the child element, starting from 1.
1558 virtual wxAccStatus
HitTest(const wxPoint
& pt
, int* childId
, wxAccessible
** childObject
);
1560 // Returns the rectangle for this object (id = 0) or a child element (id > 0).
1561 virtual wxAccStatus
GetLocation(wxRect
& rect
, int elementId
);
1563 // Navigates from fromId to toId/toObject.
1564 virtual wxAccStatus
Navigate(wxNavDir navDir
, int fromId
,
1565 int* toId
, wxAccessible
** toObject
);
1567 // Gets the name of the specified object.
1568 virtual wxAccStatus
GetName(int childId
, wxString
* name
);
1570 // Gets the number of children.
1571 virtual wxAccStatus
GetChildCount(int* childCount
);
1573 // Gets the specified child (starting from 1).
1574 // If *child is NULL and return value is wxACC_OK,
1575 // this means that the child is a simple element and
1576 // not an accessible object.
1577 virtual wxAccStatus
GetChild(int childId
, wxAccessible
** child
);
1579 // Gets the parent, or NULL.
1580 virtual wxAccStatus
GetParent(wxAccessible
** parent
);
1582 // Performs the default action. childId is 0 (the action for this object)
1583 // or > 0 (the action for a child).
1584 // Return wxACC_NOT_SUPPORTED if there is no default action for this
1585 // window (e.g. an edit control).
1586 virtual wxAccStatus
DoDefaultAction(int childId
);
1588 // Gets the default action for this object (0) or > 0 (the action for a child).
1589 // Return wxACC_OK even if there is no action. actionName is the action, or the empty
1590 // string if there is no action.
1591 // The retrieved string describes the action that is performed on an object,
1592 // not what the object does as a result. For example, a toolbar button that prints
1593 // a document has a default action of "Press" rather than "Prints the current document."
1594 virtual wxAccStatus
GetDefaultAction(int childId
, wxString
* actionName
);
1596 // Returns the description for this object or a child.
1597 virtual wxAccStatus
GetDescription(int childId
, wxString
* description
);
1599 // Returns help text for this object or a child, similar to tooltip text.
1600 virtual wxAccStatus
GetHelpText(int childId
, wxString
* helpText
);
1602 // Returns the keyboard shortcut for this object or child.
1603 // Return e.g. ALT+K
1604 virtual wxAccStatus
GetKeyboardShortcut(int childId
, wxString
* shortcut
);
1606 // Returns a role constant.
1607 virtual wxAccStatus
GetRole(int childId
, wxAccRole
* role
);
1609 // Returns a state constant.
1610 virtual wxAccStatus
GetState(int childId
, long* state
);
1612 // Returns a localized string representing the value for the object
1614 virtual wxAccStatus
GetValue(int childId
, wxString
* strValue
);
1616 // Selects the object or child.
1617 virtual wxAccStatus
Select(int childId
, wxAccSelectionFlags selectFlags
);
1619 // Gets the window with the keyboard focus.
1620 // If childId is 0 and child is NULL, no object in
1621 // this subhierarchy has the focus.
1622 // If this object has the focus, child should be 'this'.
1623 virtual wxAccStatus
GetFocus(int* childId
, wxAccessible
** child
);
1626 // Gets a variant representing the selected children
1628 // Acceptable values:
1629 // - a null variant (IsNull() returns true)
1630 // - a list variant (GetType() == wxT("list")
1631 // - an integer representing the selected child element,
1632 // or 0 if this object is selected (GetType() == wxT("long")
1633 // - a "void*" pointer to a wxAccessible child object
1634 virtual wxAccStatus
GetSelections(wxVariant
* selections
);
1635 #endif // wxUSE_VARIANT
1638 #endif // wxUSE_ACCESSIBILITY
1641 #endif // _WX_WINDOW_H_BASE_