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"
29 #include "wx/validate.h" // for wxDefaultValidator (always include it)
32 #include "wx/palette.h"
33 #endif // wxUSE_PALETTE
39 #if wxUSE_ACCESSIBILITY
40 #include "wx/access.h"
43 // when building wxUniv/Foo we don't want the code for native menu use to be
44 // compiled in - it should only be used when building real wxFoo
45 #ifdef __WXUNIVERSAL__
46 #define wxUSE_MENUS_NATIVE 0
47 #else // !__WXUNIVERSAL__
48 #define wxUSE_MENUS_NATIVE wxUSE_MENUS
49 #endif // __WXUNIVERSAL__/!__WXUNIVERSAL__
51 // ----------------------------------------------------------------------------
52 // forward declarations
53 // ----------------------------------------------------------------------------
55 class WXDLLEXPORT wxCaret
;
56 class WXDLLEXPORT wxControl
;
57 class WXDLLEXPORT wxCursor
;
58 class WXDLLEXPORT wxDC
;
59 class WXDLLEXPORT wxDropTarget
;
60 class WXDLLEXPORT wxItemResource
;
61 class WXDLLEXPORT wxLayoutConstraints
;
62 class WXDLLEXPORT wxResourceTable
;
63 class WXDLLEXPORT wxSizer
;
64 class WXDLLEXPORT wxToolTip
;
65 class WXDLLEXPORT wxWindowBase
;
66 class WXDLLEXPORT wxWindow
;
68 #if wxUSE_ACCESSIBILITY
69 class WXDLLEXPORT wxAccessible
;
72 // ----------------------------------------------------------------------------
73 // helper stuff used by wxWindow
74 // ----------------------------------------------------------------------------
76 // struct containing all the visual attributes of a control
77 struct WXDLLEXPORT wxVisualAttributes
79 // the font used for control label/text inside it
82 // the foreground colour
85 // the background colour, may be wxNullColour if the controls background
86 // colour is not solid
90 // different window variants, on platforms like eg mac uses different
94 wxWINDOW_VARIANT_NORMAL
, // Normal size
95 wxWINDOW_VARIANT_SMALL
, // Smaller size (about 25 % smaller than normal)
96 wxWINDOW_VARIANT_MINI
, // Mini size (about 33 % smaller than normal)
97 wxWINDOW_VARIANT_LARGE
, // Large size (about 25 % larger than normal)
101 #if wxUSE_SYSTEM_OPTIONS
102 #define wxWINDOW_DEFAULT_VARIANT wxT("window-default-variant")
105 // ----------------------------------------------------------------------------
106 // (pseudo)template list classes
107 // ----------------------------------------------------------------------------
109 WX_DECLARE_LIST_3(wxWindow
, wxWindowBase
, wxWindowList
, wxWindowListNode
, class WXDLLEXPORT
);
111 // ----------------------------------------------------------------------------
113 // ----------------------------------------------------------------------------
115 extern WXDLLEXPORT_DATA(wxWindowList
) wxTopLevelWindows
;
117 // ----------------------------------------------------------------------------
118 // wxWindowBase is the base class for all GUI controls/widgets, this is the public
119 // interface of this class.
121 // Event handler: windows have themselves as their event handlers by default,
122 // but their event handlers could be set to another object entirely. This
123 // separation can reduce the amount of derivation required, and allow
124 // alteration of a window's functionality (e.g. by a resource editor that
125 // temporarily switches event handlers).
126 // ----------------------------------------------------------------------------
128 class WXDLLEXPORT wxWindowBase
: public wxEvtHandler
131 // creating the window
132 // -------------------
134 // default ctor, initializes everything which can be initialized before
138 // pseudo ctor (can't be virtual, called from ctor)
139 bool CreateBase(wxWindowBase
*parent
,
141 const wxPoint
& pos
= wxDefaultPosition
,
142 const wxSize
& size
= wxDefaultSize
,
144 const wxValidator
& validator
= wxDefaultValidator
,
145 const wxString
& name
= wxPanelNameStr
);
147 virtual ~wxWindowBase();
149 // deleting the window
150 // -------------------
152 // ask the window to close itself, return true if the event handler
153 // honoured our request
154 bool Close( bool force
= false );
156 // the following functions delete the C++ objects (the window itself
157 // or its children) as well as the GUI windows and normally should
158 // never be used directly
160 // delete window unconditionally (dangerous!), returns true if ok
161 virtual bool Destroy();
162 // delete all children of this window, returns true if ok
163 bool DestroyChildren();
165 // is the window being deleted?
166 bool IsBeingDeleted() const { return m_isBeingDeleted
; }
171 #if !defined(__WXMSW__) && \
172 !defined(__WXMGL__) && \
173 !defined(__WXMOTIF__) && \
174 !defined(__WXPM__) && \
175 !defined(__WXMAC__) && \
178 // FIXME: This is work in progress about moving SetTitle/GetTitle from wxWindow
179 // to wxTopLevelWindow so initially enabled in wxMSW only to observe results
180 // and continue on other platforms
182 virtual void SetTitle( const wxString
& WXUNUSED(title
) ) {}
183 virtual wxString
GetTitle() const { return wxEmptyString
; }
185 // label is just the same as the title (but for, e.g., buttons it
186 // makes more sense to speak about labels)
187 virtual void SetLabel(const wxString
& label
) { SetTitle(label
); }
188 virtual wxString
GetLabel() const { return GetTitle(); }
190 // label is just the same as the title (but for, e.g., buttons it
191 // makes more sense to speak about labels)
192 virtual void SetLabel(const wxString
& label
) = 0;
193 virtual wxString
GetLabel() const = 0;
196 // the window name is used for ressource setting in X, it is not the
197 // same as the window title/label
198 virtual void SetName( const wxString
&name
) { m_windowName
= name
; }
199 virtual wxString
GetName() const { return m_windowName
; }
201 // sets the window variant, calls internally DoSetVariant if variant has changed
202 void SetWindowVariant( wxWindowVariant variant
) ;
203 wxWindowVariant
GetWindowVariant() const { return m_windowVariant
; }
206 // window id uniquely identifies the window among its siblings unless
207 // it is wxID_ANY which means "don't care"
208 void SetId( wxWindowID winid
) { m_windowId
= winid
; }
209 wxWindowID
GetId() const { return m_windowId
; }
211 // generate a control id for the controls which were not given one by
213 static int NewControlId() { return --ms_lastControlId
; }
214 // get the id of the control following the one with the given
215 // (autogenerated) id
216 static int NextControlId(int winid
) { return winid
- 1; }
217 // get the id of the control preceding the one with the given
218 // (autogenerated) id
219 static int PrevControlId(int winid
) { return winid
+ 1; }
224 // set the window size and/or position
225 void SetSize( int x
, int y
, int width
, int height
,
226 int sizeFlags
= wxSIZE_AUTO
)
227 { DoSetSize(x
, y
, width
, height
, sizeFlags
); }
229 void SetSize( int width
, int height
)
230 { DoSetSize( wxDefaultCoord
, wxDefaultCoord
, width
, height
, wxSIZE_USE_EXISTING
); }
232 void SetSize( const wxSize
& size
)
233 { SetSize( size
.x
, size
.y
); }
235 void SetSize(const wxRect
& rect
, int sizeFlags
= wxSIZE_AUTO
)
236 { DoSetSize(rect
.x
, rect
.y
, rect
.width
, rect
.height
, sizeFlags
); }
238 void Move(int x
, int y
, int flags
= wxSIZE_USE_EXISTING
)
239 { DoSetSize(x
, y
, wxDefaultCoord
, wxDefaultCoord
, flags
); }
241 void Move(const wxPoint
& pt
, int flags
= wxSIZE_USE_EXISTING
)
242 { Move(pt
.x
, pt
.y
, flags
); }
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 and/or size (pointers may be NULL)
259 void GetPosition( int *x
, int *y
) const { DoGetPosition(x
, y
); }
260 wxPoint
GetPosition() const
263 DoGetPosition(&w
, &h
);
265 return wxPoint(w
, h
);
268 void SetPosition( const wxPoint
& pt
) { Move( pt
) ; }
270 void GetSize( int *w
, int *h
) const { DoGetSize(w
, h
); }
271 wxSize
GetSize() const
278 wxRect
GetRect() const
281 GetPosition(& x
, & y
);
284 return wxRect(x
, y
, w
, h
);
287 void GetClientSize( int *w
, int *h
) const { DoGetClientSize(w
, h
); }
288 wxSize
GetClientSize() const
291 DoGetClientSize(& w
, & h
);
296 // get the origin of the client area of the window relative to the
297 // window top left corner (the client area may be shifted because of
298 // the borders, scrollbars, other decorations...)
299 virtual wxPoint
GetClientAreaOrigin() const;
301 // get the client rectangle in window (i.e. client) coordinates
302 wxRect
GetClientRect() const
304 return wxRect(GetClientAreaOrigin(), GetClientSize());
307 // get the size best suited for the window (in fact, minimal
308 // acceptable size using which it will still look "nice" in
310 wxSize
GetBestSize() const
312 if (m_bestSizeCache
.IsFullySpecified())
313 return m_bestSizeCache
;
314 return DoGetBestSize();
316 void GetBestSize(int *w
, int *h
) const
318 wxSize s
= GetBestSize();
325 // reset the cached best size value so it will be recalculated the
326 // next time it is needed.
327 void InvalidateBestSize();
328 void CacheBestSize(const wxSize
& size
) const
329 { wxConstCast(this, wxWindowBase
)->m_bestSizeCache
= size
; }
331 // There are times (and windows) where 'Best' size and 'Min' size
332 // are vastly out of sync. This should be remedied somehow, but in
333 // the meantime, this method will return the larger of BestSize
334 // (the window's smallest legible size), and any user specified
336 wxSize
GetAdjustedBestSize() const
338 wxSize
s( GetBestSize() );
339 return wxSize( wxMax( s
.x
, GetMinWidth() ), wxMax( s
.y
, GetMinHeight() ) );
342 // This function will merge the window's best size into the window's
343 // minimum size, giving priority to the min size components, and
344 // returns the results.
345 wxSize
GetBestFittingSize() const;
347 // A 'Smart' SetSize that will fill in default size values with 'best'
348 // size. Sets the minsize to what was passed in.
349 void SetBestFittingSize(const wxSize
& size
=wxDefaultSize
);
351 // the generic centre function - centers the window on parent by`
352 // default or on screen if it doesn't have parent or
353 // wxCENTER_ON_SCREEN flag is given
354 void Centre( int direction
= wxBOTH
);
355 void Center( int direction
= wxBOTH
) { Centre(direction
); }
357 // centre on screen (only works for top level windows)
358 void CentreOnScreen(int dir
= wxBOTH
) { Centre(dir
| wxCENTER_ON_SCREEN
); }
359 void CenterOnScreen(int dir
= wxBOTH
) { CentreOnScreen(dir
); }
361 // centre with respect to the the parent window
362 void CentreOnParent(int dir
= wxBOTH
) { Centre(dir
| wxCENTER_FRAME
); }
363 void CenterOnParent(int dir
= wxBOTH
) { CentreOnParent(dir
); }
365 // set window size to wrap around its children
368 // set virtual size to satisfy children
369 virtual void FitInside();
371 // set min/max size of the window
372 virtual void SetSizeHints( int minW
, int minH
,
373 int maxW
= wxDefaultCoord
, int maxH
= wxDefaultCoord
,
374 int incW
= wxDefaultCoord
, int incH
= wxDefaultCoord
)
376 DoSetSizeHints(minW
, minH
, maxW
, maxH
, incW
, incH
);
379 void SetSizeHints( const wxSize
& minSize
,
380 const wxSize
& maxSize
=wxDefaultSize
,
381 const wxSize
& incSize
=wxDefaultSize
)
383 DoSetSizeHints(minSize
.x
, minSize
.y
,
384 maxSize
.x
, maxSize
.y
,
385 incSize
.x
, incSize
.y
);
388 virtual void DoSetSizeHints(int minW
, int minH
,
389 int maxW
= wxDefaultCoord
, int maxH
= wxDefaultCoord
,
390 int incW
= wxDefaultCoord
, int incH
= wxDefaultCoord
);
392 virtual void SetVirtualSizeHints( int minW
, int minH
,
393 int maxW
= wxDefaultCoord
, int maxH
= wxDefaultCoord
);
394 void SetVirtualSizeHints( const wxSize
& minSize
,
395 const wxSize
& maxSize
=wxDefaultSize
)
397 SetVirtualSizeHints(minSize
.x
, minSize
.y
, maxSize
.x
, maxSize
.y
);
400 virtual int GetMinWidth() const { return m_minWidth
; }
401 virtual int GetMinHeight() const { return m_minHeight
; }
402 int GetMaxWidth() const { return m_maxWidth
; }
403 int GetMaxHeight() const { return m_maxHeight
; }
405 // Override this method to control the values given to Sizers etc.
406 virtual wxSize
GetMaxSize() const { return wxSize( m_maxWidth
, m_maxHeight
); }
407 virtual wxSize
GetMinSize() const { return wxSize( m_minWidth
, m_minHeight
); }
409 void SetMinSize(const wxSize
& minSize
) { SetSizeHints(minSize
); }
410 void SetMaxSize(const wxSize
& maxSize
) { SetSizeHints(GetMinSize(), maxSize
); }
412 // Methods for accessing the virtual size of a window. For most
413 // windows this is just the client area of the window, but for
414 // some like scrolled windows it is more or less independent of
415 // the screen window size. You may override the DoXXXVirtual
416 // methods below for classes where that is is the case.
418 void SetVirtualSize( const wxSize
&size
) { DoSetVirtualSize( size
.x
, size
.y
); }
419 void SetVirtualSize( int x
, int y
) { DoSetVirtualSize( x
, y
); }
421 wxSize
GetVirtualSize() const { return DoGetVirtualSize(); }
422 void GetVirtualSize( int *x
, int *y
) const
424 wxSize
s( DoGetVirtualSize() );
432 // Override these methods for windows that have a virtual size
433 // independent of their client size. eg. the virtual area of a
436 virtual void DoSetVirtualSize( int x
, int y
);
437 virtual wxSize
DoGetVirtualSize() const;
439 // Return the largest of ClientSize and BestSize (as determined
440 // by a sizer, interior children, or other means)
442 virtual wxSize
GetBestVirtualSize() const
444 wxSize
client( GetClientSize() );
445 wxSize
best( GetBestSize() );
447 return wxSize( wxMax( client
.x
, best
.x
), wxMax( client
.y
, best
.y
) );
453 // returns true if window was shown/hidden, false if the nothing was
454 // done (window was already shown/hidden)
455 virtual bool Show( bool show
= true );
456 bool Hide() { return Show(false); }
458 // returns true if window was enabled/disabled, false if nothing done
459 virtual bool Enable( bool enable
= true );
460 bool Disable() { return Enable(false); }
462 virtual bool IsShown() const { return m_isShown
; }
463 virtual bool IsEnabled() const { return m_isEnabled
; }
465 // get/set window style (setting style won't update the window and so
466 // is only useful for internal usage)
467 virtual void SetWindowStyleFlag( long style
) { m_windowStyle
= style
; }
468 virtual long GetWindowStyleFlag() const { return m_windowStyle
; }
470 // just some (somewhat shorter) synonims
471 void SetWindowStyle( long style
) { SetWindowStyleFlag(style
); }
472 long GetWindowStyle() const { return GetWindowStyleFlag(); }
474 bool HasFlag(int flag
) const { return (m_windowStyle
& flag
) != 0; }
475 virtual bool IsRetained() const { return HasFlag(wxRETAINED
); }
477 // extra style: the less often used style bits which can't be set with
478 // SetWindowStyleFlag()
479 virtual void SetExtraStyle(long exStyle
) { m_exStyle
= exStyle
; }
480 long GetExtraStyle() const { return m_exStyle
; }
482 // make the window modal (all other windows unresponsive)
483 virtual void MakeModal(bool modal
= true);
486 // (primitive) theming support
487 // ---------------------------
489 virtual void SetThemeEnabled(bool enableTheme
) { m_themeEnabled
= enableTheme
; }
490 virtual bool GetThemeEnabled() const { return m_themeEnabled
; }
493 // focus and keyboard handling
494 // ---------------------------
496 // set focus to this window
497 virtual void SetFocus() = 0;
499 // set focus to this window as the result of a keyboard action
500 virtual void SetFocusFromKbd() { SetFocus(); }
502 // return the window which currently has the focus or NULL
503 static wxWindow
*FindFocus();
505 static wxWindow
*DoFindFocus() /* = 0: implement in derived classes */;
507 // can this window have focus?
508 virtual bool AcceptsFocus() const { return IsShown() && IsEnabled(); }
510 // can this window be given focus by keyboard navigation? if not, the
511 // only way to give it focus (provided it accepts it at all) is to
513 virtual bool AcceptsFocusFromKeyboard() const { return AcceptsFocus(); }
515 // NB: these methods really don't belong here but with the current
516 // class hierarchy there is no other place for them :-(
518 // get the default child of this parent, i.e. the one which is
519 // activated by pressing <Enter>
520 virtual wxWindow
*GetDefaultItem() const { return NULL
; }
522 // set this child as default, return the old default
523 virtual wxWindow
*SetDefaultItem(wxWindow
* WXUNUSED(child
))
526 // set this child as temporary default
527 virtual void SetTmpDefaultItem(wxWindow
* WXUNUSED(win
)) { }
529 // navigates in the specified direction by sending a wxNavigationKeyEvent
530 virtual bool Navigate(int flags
= wxNavigationKeyEvent
::IsForward
);
532 // move this window just before/after the specified one in tab order
533 // (the other window must be our sibling!)
534 void MoveBeforeInTabOrder(wxWindow
*win
)
535 { DoMoveInTabOrder(win
, MoveBefore
); }
536 void MoveAfterInTabOrder(wxWindow
*win
)
537 { DoMoveInTabOrder(win
, MoveAfter
); }
540 // parent/children relations
541 // -------------------------
543 // get the list of children
544 const wxWindowList
& GetChildren() const { return m_children
; }
545 wxWindowList
& GetChildren() { return m_children
; }
547 // needed just for extended runtime
548 const wxWindowList
& GetWindowChildren() const { return GetChildren() ; }
550 // get the parent or the parent of the parent
551 wxWindow
*GetParent() const { return m_parent
; }
552 inline wxWindow
*GetGrandParent() const;
554 // is this window a top level one?
555 virtual bool IsTopLevel() const;
557 // it doesn't really change parent, use Reparent() instead
558 void SetParent( wxWindowBase
*parent
) { m_parent
= (wxWindow
*)parent
; }
559 // change the real parent of this window, return true if the parent
560 // was changed, false otherwise (error or newParent == oldParent)
561 virtual bool Reparent( wxWindowBase
*newParent
);
563 // implementation mostly
564 virtual void AddChild( wxWindowBase
*child
);
565 virtual void RemoveChild( wxWindowBase
*child
);
567 // looking for windows
568 // -------------------
570 // find window among the descendants of this one either by id or by
571 // name (return NULL if not found)
572 wxWindow
*FindWindow(long winid
) const;
573 wxWindow
*FindWindow(const wxString
& name
) const;
575 // Find a window among any window (all return NULL if not found)
576 static wxWindow
*FindWindowById( long winid
, const wxWindow
*parent
= NULL
);
577 static wxWindow
*FindWindowByName( const wxString
& name
,
578 const wxWindow
*parent
= NULL
);
579 static wxWindow
*FindWindowByLabel( const wxString
& label
,
580 const wxWindow
*parent
= NULL
);
582 // event handler stuff
583 // -------------------
585 // get the current event handler
586 wxEvtHandler
*GetEventHandler() const { return m_eventHandler
; }
588 // replace the event handler (allows to completely subclass the
590 void SetEventHandler( wxEvtHandler
*handler
) { m_eventHandler
= handler
; }
592 // push/pop event handler: allows to chain a custom event handler to
593 // alreasy existing ones
594 void PushEventHandler( wxEvtHandler
*handler
);
595 wxEvtHandler
*PopEventHandler( bool deleteHandler
= false );
597 // find the given handler in the event handler chain and remove (but
598 // not delete) it from the event handler chain, return true if it was
599 // found and false otherwise (this also results in an assert failure so
600 // this function should only be called when the handler is supposed to
602 bool RemoveEventHandler(wxEvtHandler
*handler
);
608 // a window may have an associated validator which is used to control
610 virtual void SetValidator( const wxValidator
&validator
);
611 virtual wxValidator
*GetValidator() { return m_windowValidator
; }
612 #endif // wxUSE_VALIDATORS
615 // dialog oriented functions
616 // -------------------------
618 // validate the correctness of input, return true if ok
619 virtual bool Validate();
621 // transfer data between internal and GUI representations
622 virtual bool TransferDataToWindow();
623 virtual bool TransferDataFromWindow();
625 virtual void InitDialog();
630 virtual void SetAcceleratorTable( const wxAcceleratorTable
& accel
)
631 { m_acceleratorTable
= accel
; }
632 wxAcceleratorTable
*GetAcceleratorTable()
633 { return &m_acceleratorTable
; }
635 #endif // wxUSE_ACCEL
638 // hot keys (system wide accelerators)
639 // -----------------------------------
641 virtual bool RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
);
642 virtual bool UnregisterHotKey(int hotkeyId
);
643 #endif // wxUSE_HOTKEY
646 // dialog units translations
647 // -------------------------
649 wxPoint
ConvertPixelsToDialog( const wxPoint
& pt
);
650 wxPoint
ConvertDialogToPixels( const wxPoint
& pt
);
651 wxSize
ConvertPixelsToDialog( const wxSize
& sz
)
653 wxPoint
pt(ConvertPixelsToDialog(wxPoint(sz
.x
, sz
.y
)));
655 return wxSize(pt
.x
, pt
.y
);
658 wxSize
ConvertDialogToPixels( const wxSize
& sz
)
660 wxPoint
pt(ConvertDialogToPixels(wxPoint(sz
.x
, sz
.y
)));
662 return wxSize(pt
.x
, pt
.y
);
668 // move the mouse to the specified position
669 virtual void WarpPointer(int x
, int y
) = 0;
671 // start or end mouse capture, these functions maintain the stack of
672 // windows having captured the mouse and after calling ReleaseMouse()
673 // the mouse is not released but returns to the window which had had
674 // captured it previously (if any)
678 // get the window which currently captures the mouse or NULL
679 static wxWindow
*GetCapture();
681 // does this window have the capture?
682 virtual bool HasCapture() const
683 { return (wxWindow
*)this == GetCapture(); }
685 // painting the window
686 // -------------------
688 // mark the specified rectangle (or the whole window) as "dirty" so it
690 virtual void Refresh( bool eraseBackground
= true,
691 const wxRect
*rect
= (const wxRect
*) NULL
) = 0;
693 // a less awkward wrapper for Refresh
694 void RefreshRect(const wxRect
& rect
, bool eraseBackground
= true)
696 Refresh(eraseBackground
, &rect
);
699 // repaint all invalid areas of the window immediately
700 virtual void Update() { }
702 // clear the window background
703 virtual void ClearBackground();
705 // freeze the window: don't redraw it until it is thawed
706 virtual void Freeze() { }
708 // thaw the window: redraw it after it had been frozen
709 virtual void Thaw() { }
711 // adjust DC for drawing on this window
712 virtual void PrepareDC( wxDC
& WXUNUSED(dc
) ) { }
714 // the update region of the window contains the areas which must be
715 // repainted by the program
716 const wxRegion
& GetUpdateRegion() const { return m_updateRegion
; }
717 wxRegion
& GetUpdateRegion() { return m_updateRegion
; }
719 // get the update rectangleregion bounding box in client coords
720 wxRect
GetUpdateClientRect() const;
722 // these functions verify whether the given point/rectangle belongs to
723 // (or at least intersects with) the update region
724 bool IsExposed( int x
, int y
) const;
725 bool IsExposed( int x
, int y
, int w
, int h
) const;
727 bool IsExposed( const wxPoint
& pt
) const
728 { return IsExposed(pt
.x
, pt
.y
); }
729 bool IsExposed( const wxRect
& rect
) const
730 { return IsExposed(rect
.x
, rect
.y
, rect
.width
, rect
.height
); }
732 // colours, fonts and cursors
733 // --------------------------
735 // get the default attributes for the controls of this class: we
736 // provide a virtual function which can be used to query the default
737 // attributes of an existing control and a static function which can
738 // be used even when no existing object of the given class is
739 // available, but which won't return any styles specific to this
740 // particular control, of course (e.g. "Ok" button might have
741 // different -- bold for example -- font)
742 virtual wxVisualAttributes
GetDefaultAttributes() const
744 return GetClassDefaultAttributes(GetWindowVariant());
747 static wxVisualAttributes
748 GetClassDefaultAttributes(wxWindowVariant variant
= wxWINDOW_VARIANT_NORMAL
);
750 // set/retrieve the window colours (system defaults are used by
751 // default): SetXXX() functions return true if colour was changed,
752 // SetDefaultXXX() reset the "m_inheritXXX" flag after setting the
753 // value to prevent it from being inherited by our children
754 virtual bool SetBackgroundColour(const wxColour
& colour
);
755 void SetOwnBackgroundColour(const wxColour
& colour
)
757 if ( SetBackgroundColour(colour
) )
758 m_inheritBgCol
= false;
760 wxColour
GetBackgroundColour() const;
761 bool InheritsBackgroundColour() const
763 return m_inheritBgCol
;
765 bool UseBgCol() const
770 virtual bool SetForegroundColour(const wxColour
& colour
);
771 void SetOwnForegroundColour(const wxColour
& colour
)
773 if ( SetForegroundColour(colour
) )
774 m_inheritFgCol
= false;
776 wxColour
GetForegroundColour() const;
778 // Set/get the background style.
779 // Pass one of wxBG_STYLE_SYSTEM, wxBG_STYLE_COLOUR, wxBG_STYLE_CUSTOM
780 virtual bool SetBackgroundStyle(wxBackgroundStyle style
) { m_backgroundStyle
= style
; return true; }
781 virtual wxBackgroundStyle
GetBackgroundStyle() const { return m_backgroundStyle
; }
783 // returns true if the control has "transparent" areas such as a
784 // wxStaticText and wxCheckBox and the background should be adapted
785 // from a parent window
786 virtual bool HasTransparentBackground() { return false; }
788 // set/retrieve the font for the window (SetFont() returns true if the
789 // font really changed)
790 virtual bool SetFont(const wxFont
& font
) = 0;
791 void SetOwnFont(const wxFont
& font
)
794 m_inheritFont
= false;
796 wxFont
GetFont() const;
798 // set/retrieve the cursor for this window (SetCursor() returns true
799 // if the cursor was really changed)
800 virtual bool SetCursor( const wxCursor
&cursor
);
801 const wxCursor
& GetCursor() const { return m_cursor
; }
804 // associate a caret with the window
805 void SetCaret(wxCaret
*caret
);
806 // get the current caret (may be NULL)
807 wxCaret
*GetCaret() const { return m_caret
; }
808 #endif // wxUSE_CARET
810 // get the (average) character size for the current font
811 virtual int GetCharHeight() const = 0;
812 virtual int GetCharWidth() const = 0;
814 // get the width/height/... of the text using current or specified
816 virtual void GetTextExtent(const wxString
& string
,
818 int *descent
= (int *) NULL
,
819 int *externalLeading
= (int *) NULL
,
820 const wxFont
*theFont
= (const wxFont
*) NULL
)
823 // client <-> screen coords
824 // ------------------------
826 // translate to/from screen/client coordinates (pointers may be NULL)
827 void ClientToScreen( int *x
, int *y
) const
828 { DoClientToScreen(x
, y
); }
829 void ScreenToClient( int *x
, int *y
) const
830 { DoScreenToClient(x
, y
); }
832 // wxPoint interface to do the same thing
833 wxPoint
ClientToScreen(const wxPoint
& pt
) const
835 int x
= pt
.x
, y
= pt
.y
;
836 DoClientToScreen(&x
, &y
);
838 return wxPoint(x
, y
);
841 wxPoint
ScreenToClient(const wxPoint
& pt
) const
843 int x
= pt
.x
, y
= pt
.y
;
844 DoScreenToClient(&x
, &y
);
846 return wxPoint(x
, y
);
849 // test where the given (in client coords) point lies
850 wxHitTest
HitTest(wxCoord x
, wxCoord y
) const
851 { return DoHitTest(x
, y
); }
853 wxHitTest
HitTest(const wxPoint
& pt
) const
854 { return DoHitTest(pt
.x
, pt
.y
); }
859 // get the window border style from the given flags: this is different from
860 // simply doing flags & wxBORDER_MASK because it uses GetDefaultBorder() to
861 // translate wxBORDER_DEFAULT to something reasonable
862 wxBorder
GetBorder(long flags
) const;
864 // get border for the flags of this window
865 wxBorder
GetBorder() const { return GetBorder(GetWindowStyleFlag()); }
867 // send wxUpdateUIEvents to this window, and children if recurse is true
868 virtual void UpdateWindowUI(long flags
= wxUPDATE_UI_NONE
);
870 // do the window-specific processing after processing the update event
871 virtual void DoUpdateWindowUI(wxUpdateUIEvent
& event
) ;
874 bool PopupMenu(wxMenu
*menu
, const wxPoint
& pos
= wxDefaultPosition
)
875 { return DoPopupMenu(menu
, pos
.x
, pos
.y
); }
876 bool PopupMenu(wxMenu
*menu
, int x
, int y
)
877 { return DoPopupMenu(menu
, x
, y
); }
878 #endif // wxUSE_MENUS
883 // does the window have the scrollbar for this orientation?
884 bool HasScrollbar(int orient
) const
886 return (m_windowStyle
&
887 (orient
== wxHORIZONTAL ? wxHSCROLL
: wxVSCROLL
)) != 0;
890 // configure the window scrollbars
891 virtual void SetScrollbar( int orient
,
895 bool refresh
= true ) = 0;
896 virtual void SetScrollPos( int orient
, int pos
, bool refresh
= true ) = 0;
897 virtual int GetScrollPos( int orient
) const = 0;
898 virtual int GetScrollThumb( int orient
) const = 0;
899 virtual int GetScrollRange( int orient
) const = 0;
901 // scroll window to the specified position
902 virtual void ScrollWindow( int dx
, int dy
,
903 const wxRect
* rect
= (wxRect
*) NULL
) = 0;
905 // scrolls window by line/page: note that not all controls support this
907 // return true if the position changed, false otherwise
908 virtual bool ScrollLines(int WXUNUSED(lines
)) { return false; }
909 virtual bool ScrollPages(int WXUNUSED(pages
)) { return false; }
911 // convenient wrappers for ScrollLines/Pages
912 bool LineUp() { return ScrollLines(-1); }
913 bool LineDown() { return ScrollLines(1); }
914 bool PageUp() { return ScrollPages(-1); }
915 bool PageDown() { return ScrollPages(1); }
917 // context-sensitive help
918 // ----------------------
920 // these are the convenience functions wrapping wxHelpProvider methods
923 // associate this help text with this window
924 void SetHelpText(const wxString
& text
);
925 // associate this help text with all windows with the same id as this
927 void SetHelpTextForId(const wxString
& text
);
928 // get the help string associated with this window (may be empty)
929 wxString
GetHelpText() const;
931 // silently ignore SetHelpText() calls
932 void SetHelpText(const wxString
& WXUNUSED(text
)) { }
933 void SetHelpTextForId(const wxString
& WXUNUSED(text
)) { }
940 // the easiest way to set a tooltip for a window is to use this method
941 void SetToolTip( const wxString
&tip
);
942 // attach a tooltip to the window
943 void SetToolTip( wxToolTip
*tip
) { DoSetToolTip(tip
); }
944 // get the associated tooltip or NULL if none
945 wxToolTip
* GetToolTip() const { return m_tooltip
; }
946 wxString
GetToolTipText() const ;
948 // make it much easier to compile apps in an environment
949 // that doesn't support tooltips, such as PocketPC
950 inline void SetToolTip( const wxString
& WXUNUSED(tip
) ) {}
951 #endif // wxUSE_TOOLTIPS
955 #if wxUSE_DRAG_AND_DROP
956 // set/retrieve the drop target associated with this window (may be
957 // NULL; it's owned by the window and will be deleted by it)
958 virtual void SetDropTarget( wxDropTarget
*dropTarget
) = 0;
959 virtual wxDropTarget
*GetDropTarget() const { return m_dropTarget
; }
960 #endif // wxUSE_DRAG_AND_DROP
962 // constraints and sizers
963 // ----------------------
964 #if wxUSE_CONSTRAINTS
965 // set the constraints for this window or retrieve them (may be NULL)
966 void SetConstraints( wxLayoutConstraints
*constraints
);
967 wxLayoutConstraints
*GetConstraints() const { return m_constraints
; }
969 // implementation only
970 void UnsetConstraints(wxLayoutConstraints
*c
);
971 wxWindowList
*GetConstraintsInvolvedIn() const
972 { return m_constraintsInvolvedIn
; }
973 void AddConstraintReference(wxWindowBase
*otherWin
);
974 void RemoveConstraintReference(wxWindowBase
*otherWin
);
975 void DeleteRelatedConstraints();
976 void ResetConstraints();
978 // these methods may be overriden for special layout algorithms
979 virtual void SetConstraintSizes(bool recurse
= true);
980 virtual bool LayoutPhase1(int *noChanges
);
981 virtual bool LayoutPhase2(int *noChanges
);
982 virtual bool DoPhase(int phase
);
984 // these methods are virtual but normally won't be overridden
985 virtual void SetSizeConstraint(int x
, int y
, int w
, int h
);
986 virtual void MoveConstraint(int x
, int y
);
987 virtual void GetSizeConstraint(int *w
, int *h
) const ;
988 virtual void GetClientSizeConstraint(int *w
, int *h
) const ;
989 virtual void GetPositionConstraint(int *x
, int *y
) const ;
991 #endif // wxUSE_CONSTRAINTS
993 // when using constraints or sizers, it makes sense to update
994 // children positions automatically whenever the window is resized
995 // - this is done if autoLayout is on
996 void SetAutoLayout( bool autoLayout
) { m_autoLayout
= autoLayout
; }
997 bool GetAutoLayout() const { return m_autoLayout
; }
999 // lay out the window and its children
1000 virtual bool Layout();
1003 void SetSizer(wxSizer
*sizer
, bool deleteOld
= true );
1004 void SetSizerAndFit( wxSizer
*sizer
, bool deleteOld
= true );
1006 wxSizer
*GetSizer() const { return m_windowSizer
; }
1008 // Track if this window is a member of a sizer
1009 void SetContainingSizer(wxSizer
* sizer
);
1010 wxSizer
*GetContainingSizer() const { return m_containingSizer
; }
1013 // ----------------------
1014 #if wxUSE_ACCESSIBILITY
1015 // Override to create a specific accessible object.
1016 virtual wxAccessible
* CreateAccessible();
1018 // Sets the accessible object.
1019 void SetAccessible(wxAccessible
* accessible
) ;
1021 // Returns the accessible object.
1022 wxAccessible
* GetAccessible() { return m_accessible
; };
1024 // Returns the accessible object, creating if necessary.
1025 wxAccessible
* GetOrCreateAccessible() ;
1032 void OnSysColourChanged( wxSysColourChangedEvent
& event
);
1033 void OnInitDialog( wxInitDialogEvent
&event
);
1034 void OnMiddleClick( wxMouseEvent
& event
);
1036 void OnHelp(wxHelpEvent
& event
);
1037 #endif // wxUSE_HELP
1039 // virtual function for implementing internal idle
1041 virtual void OnInternalIdle() {}
1043 // call internal idle recursively
1044 // void ProcessInternalIdle() ;
1046 // get the handle of the window for the underlying window system: this
1047 // is only used for wxWin itself or for user code which wants to call
1048 // platform-specific APIs
1049 virtual WXWidget
GetHandle() const = 0;
1050 // associate the window with a new native handle
1051 virtual void AssociateHandle(WXWidget
WXUNUSED(handle
)) { }
1052 // dissociate the current native handle from the window
1053 virtual void DissociateHandle() { }
1056 // Store the palette used by DCs in wxWindow so that the dcs can share
1057 // a palette. And we can respond to palette messages.
1058 wxPalette
GetPalette() const { return m_palette
; }
1060 // When palette is changed tell the DC to set the system palette to the
1062 void SetPalette(const wxPalette
& pal
);
1064 // return true if we have a specific palette
1065 bool HasCustomPalette() const { return m_hasCustomPalette
; }
1067 // return the first parent window with a custom palette or NULL
1068 wxWindow
*GetAncestorWithCustomPalette() const;
1069 #endif // wxUSE_PALETTE
1071 // inherit the parents visual attributes if they had been explicitly set
1072 // by the user (i.e. we don't inherit default attributes) and if we don't
1073 // have our own explicitly set
1074 virtual void InheritAttributes();
1076 // returns false from here if this window doesn't want to inherit the
1077 // parents colours even if InheritAttributes() would normally do it
1079 // this just provides a simple way to customize InheritAttributes()
1080 // behaviour in the most common case
1081 virtual bool ShouldInheritColours() const { return false; }
1083 // Reserved for future use
1084 virtual void ReservedWindowFunc1() {}
1085 virtual void ReservedWindowFunc2() {}
1086 virtual void ReservedWindowFunc3() {}
1087 virtual void ReservedWindowFunc4() {}
1088 virtual void ReservedWindowFunc5() {}
1089 virtual void ReservedWindowFunc6() {}
1090 virtual void ReservedWindowFunc7() {}
1091 virtual void ReservedWindowFunc8() {}
1092 virtual void ReservedWindowFunc9() {}
1095 // event handling specific to wxWindow
1096 virtual bool TryValidator(wxEvent
& event
);
1097 virtual bool TryParent(wxEvent
& event
);
1099 // common part of MoveBefore/AfterInTabOrder()
1102 MoveBefore
, // insert before the given window
1103 MoveAfter
// insert after the given window
1105 virtual void DoMoveInTabOrder(wxWindow
*win
, MoveKind move
);
1107 #if wxUSE_CONSTRAINTS
1108 // satisfy the constraints for the windows but don't set the window sizes
1109 void SatisfyConstraints();
1110 #endif // wxUSE_CONSTRAINTS
1112 // Send the wxWindowDestroyEvent
1113 void SendDestroyEvent();
1115 // returns the main window of composite control; this is the window
1116 // that FindFocus returns if the focus is in one of composite control's
1118 virtual wxWindow
*GetMainWindowOfCompositeControl()
1119 { return (wxWindow
*)this; }
1121 // the window id - a number which uniquely identifies a window among
1122 // its siblings unless it is wxID_ANY
1123 wxWindowID m_windowId
;
1125 // the parent window of this window (or NULL) and the list of the children
1128 wxWindowList m_children
;
1130 // the minimal allowed size for the window (no minimal size if variable(s)
1131 // contain(s) wxDefaultCoord)
1137 // event handler for this window: usually is just 'this' but may be
1138 // changed with SetEventHandler()
1139 wxEvtHandler
*m_eventHandler
;
1141 #if wxUSE_VALIDATORS
1142 // associated validator or NULL if none
1143 wxValidator
*m_windowValidator
;
1144 #endif // wxUSE_VALIDATORS
1146 #if wxUSE_DRAG_AND_DROP
1147 wxDropTarget
*m_dropTarget
;
1148 #endif // wxUSE_DRAG_AND_DROP
1150 // visual window attributes
1152 wxFont m_font
; // see m_hasFont
1153 wxColour m_backgroundColour
, // m_hasBgCol
1154 m_foregroundColour
; // m_hasFgCol
1158 #endif // wxUSE_CARET
1160 // the region which should be repainted in response to paint event
1161 wxRegion m_updateRegion
;
1164 // the accelerator table for the window which translates key strokes into
1166 wxAcceleratorTable m_acceleratorTable
;
1167 #endif // wxUSE_ACCEL
1169 // the tooltip for this window (may be NULL)
1171 wxToolTip
*m_tooltip
;
1172 #endif // wxUSE_TOOLTIPS
1174 // constraints and sizers
1175 #if wxUSE_CONSTRAINTS
1176 // the constraints for this window or NULL
1177 wxLayoutConstraints
*m_constraints
;
1179 // constraints this window is involved in
1180 wxWindowList
*m_constraintsInvolvedIn
;
1181 #endif // wxUSE_CONSTRAINTS
1183 // this window's sizer
1184 wxSizer
*m_windowSizer
;
1186 // The sizer this window is a member of, if any
1187 wxSizer
*m_containingSizer
;
1189 // Layout() window automatically when its size changes?
1190 bool m_autoLayout
:1;
1195 bool m_isBeingDeleted
:1;
1197 // was the window colours/font explicitly changed by user?
1202 // and should it be inherited by children?
1203 bool m_inheritBgCol
:1;
1204 bool m_inheritFgCol
:1;
1205 bool m_inheritFont
:1;
1207 // window attributes
1210 wxString m_windowName
;
1211 bool m_themeEnabled
;
1212 wxBackgroundStyle m_backgroundStyle
;
1214 wxPalette m_palette
;
1215 bool m_hasCustomPalette
;
1216 #endif // wxUSE_PALETTE
1218 #if wxUSE_ACCESSIBILITY
1219 wxAccessible
* m_accessible
;
1222 // Virtual size (scrolling)
1223 wxSize m_virtualSize
;
1225 int m_minVirtualWidth
; // VirtualSizeHints
1226 int m_minVirtualHeight
;
1227 int m_maxVirtualWidth
;
1228 int m_maxVirtualHeight
;
1230 wxWindowVariant m_windowVariant
;
1232 // override this to change the default (i.e. used when no style is
1233 // specified) border for the window class
1234 virtual wxBorder
GetDefaultBorder() const;
1236 // Get the default size for the new window if no explicit size given. TLWs
1237 // have their own default size so this is just for non top-level windows.
1238 static int WidthDefault(int w
) { return w
== wxDefaultCoord ?
20 : w
; }
1239 static int HeightDefault(int h
) { return h
== wxDefaultCoord ?
20 : h
; }
1242 // Used to save the results of DoGetBestSize so it doesn't need to be
1243 // recalculated each time the value is needed.
1244 wxSize m_bestSizeCache
;
1246 // keep the old name for compatibility, at least until all the internal
1247 // usages of it are changed to SetBestFittingSize
1248 void SetBestSize(const wxSize
& size
) { SetBestFittingSize(size
); }
1250 // set the initial window size if none is given (i.e. at least one of the
1251 // components of the size passed to ctor/Create() is wxDefaultCoord)
1253 // normally just calls SetBestSize() for controls, but can be overridden
1254 // not to do it for the controls which have to do some additional
1255 // initialization (e.g. add strings to list box) before their best size
1256 // can be accurately calculated
1257 virtual void SetInitialBestSize(const wxSize
& WXUNUSED(size
)) {}
1261 // more pure virtual functions
1262 // ---------------------------
1264 // NB: we must have DoSomething() function when Something() is an overloaded
1265 // method: indeed, we can't just have "virtual Something()" in case when
1266 // the function is overloaded because then we'd have to make virtual all
1267 // the variants (otherwise only the virtual function may be called on a
1268 // pointer to derived class according to C++ rules) which is, in
1269 // general, absolutely not needed. So instead we implement all
1270 // overloaded Something()s in terms of DoSomething() which will be the
1271 // only one to be virtual.
1273 // coordinates translation
1274 virtual void DoClientToScreen( int *x
, int *y
) const = 0;
1275 virtual void DoScreenToClient( int *x
, int *y
) const = 0;
1277 virtual wxHitTest
DoHitTest(wxCoord x
, wxCoord y
) const;
1279 // capture/release the mouse, used by Capture/ReleaseMouse()
1280 virtual void DoCaptureMouse() = 0;
1281 virtual void DoReleaseMouse() = 0;
1283 // retrieve the position/size of the window
1284 virtual void DoGetPosition( int *x
, int *y
) const = 0;
1285 virtual void DoGetSize( int *width
, int *height
) const = 0;
1286 virtual void DoGetClientSize( int *width
, int *height
) const = 0;
1288 // get the size which best suits the window: for a control, it would be
1289 // the minimal size which doesn't truncate the control, for a panel - the
1290 // same size as it would have after a call to Fit()
1291 virtual wxSize
DoGetBestSize() const;
1293 // called from DoGetBestSize() to convert best virtual size (returned by
1294 // the window sizer) to the best size for the window itself; this is
1295 // overridden at wxScrolledWindow level to clump down virtual size to real
1296 virtual wxSize
GetWindowSizeForVirtualSize(const wxSize
& size
) const
1301 // this is the virtual function to be overriden in any derived class which
1302 // wants to change how SetSize() or Move() works - it is called by all
1303 // versions of these functions in the base class
1304 virtual void DoSetSize(int x
, int y
,
1305 int width
, int height
,
1306 int sizeFlags
= wxSIZE_AUTO
) = 0;
1308 // same as DoSetSize() for the client size
1309 virtual void DoSetClientSize(int width
, int height
) = 0;
1311 // move the window to the specified location and resize it: this is called
1312 // from both DoSetSize() and DoSetClientSize() and would usually just
1313 // reposition this window except for composite controls which will want to
1314 // arrange themselves inside the given rectangle
1315 virtual void DoMoveWindow(int x
, int y
, int width
, int height
) = 0;
1318 virtual void DoSetToolTip( wxToolTip
*tip
);
1319 #endif // wxUSE_TOOLTIPS
1322 virtual bool DoPopupMenu(wxMenu
*menu
, int x
, int y
) = 0;
1323 #endif // wxUSE_MENUS
1325 // Makes an adjustment to the window position to make it relative to the
1326 // parents client area, e.g. if the parent is a frame with a toolbar, its
1327 // (0, 0) is just below the toolbar
1328 virtual void AdjustForParentClientOrigin(int& x
, int& y
,
1329 int sizeFlags
= 0) const;
1331 // implements the window variants
1332 virtual void DoSetWindowVariant( wxWindowVariant variant
) ;
1334 // Reserved for future use
1335 void* m_windowReserved
;
1338 // contains the last id generated by NewControlId
1339 static int ms_lastControlId
;
1341 // the stack of windows which have captured the mouse
1342 static struct WXDLLEXPORT wxWindowNext
*ms_winCaptureNext
;
1344 DECLARE_ABSTRACT_CLASS(wxWindowBase
)
1345 DECLARE_NO_COPY_CLASS(wxWindowBase
)
1346 DECLARE_EVENT_TABLE()
1349 // ----------------------------------------------------------------------------
1350 // now include the declaration of wxWindow class
1351 // ----------------------------------------------------------------------------
1353 // include the declaration of the platform-specific class
1354 #if defined(__WXPALMOS__)
1355 #ifdef __WXUNIVERSAL__
1356 #define wxWindowNative wxWindowPalm
1358 #define wxWindowPalm wxWindow
1359 #endif // wxUniv/!wxUniv
1360 #include "wx/palmos/window.h"
1361 #elif defined(__WXMSW__)
1362 #ifdef __WXUNIVERSAL__
1363 #define wxWindowNative wxWindowMSW
1365 #define wxWindowMSW wxWindow
1366 #endif // wxUniv/!wxUniv
1367 #include "wx/msw/window.h"
1368 #elif defined(__WXMOTIF__)
1369 #include "wx/motif/window.h"
1370 #elif defined(__WXGTK__)
1371 #ifdef __WXUNIVERSAL__
1372 #define wxWindowNative wxWindowGTK
1374 #define wxWindowGTK wxWindow
1376 #include "wx/gtk/window.h"
1377 #elif defined(__WXX11__)
1378 #ifdef __WXUNIVERSAL__
1379 #define wxWindowNative wxWindowX11
1381 #define wxWindowX11 wxWindow
1383 #include "wx/x11/window.h"
1384 #elif defined(__WXMGL__)
1385 #ifdef __WXUNIVERSAL__
1386 #define wxWindowNative wxWindowMGL
1388 #define wxWindowMGL wxWindow
1390 #include "wx/mgl/window.h"
1391 #elif defined(__WXMAC__)
1392 #ifdef __WXUNIVERSAL__
1393 #define wxWindowNative wxWindowMac
1395 #define wxWindowMac wxWindow
1397 #include "wx/mac/window.h"
1398 #elif defined(__WXCOCOA__)
1399 #ifdef __WXUNIVERSAL__
1400 #define wxWindowNative wxWindowCocoa
1402 #define wxWindowCocoa wxWindow
1404 #include "wx/cocoa/window.h"
1405 #elif defined(__WXPM__)
1406 #ifdef __WXUNIVERSAL__
1407 #define wxWindowNative wxWindowOS2
1409 #define wxWindowOS2 wxWindow
1410 #endif // wxUniv/!wxUniv
1411 #include "wx/os2/window.h"
1414 // for wxUniversal, we now derive the real wxWindow from wxWindow<platform>,
1415 // for the native ports we already have defined it above
1416 #if defined(__WXUNIVERSAL__)
1417 #ifndef wxWindowNative
1418 #error "wxWindowNative must be defined above!"
1421 #include "wx/univ/window.h"
1424 // ----------------------------------------------------------------------------
1425 // inline functions which couldn't be declared in the class body because of
1426 // forward dependencies
1427 // ----------------------------------------------------------------------------
1429 inline wxWindow
*wxWindowBase
::GetGrandParent() const
1431 return m_parent ? m_parent
->GetParent() : (wxWindow
*)NULL
;
1434 // ----------------------------------------------------------------------------
1436 // ----------------------------------------------------------------------------
1438 // Find the wxWindow at the current mouse position, also returning the mouse
1440 extern WXDLLEXPORT wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
);
1442 // Get the current mouse position.
1443 extern WXDLLEXPORT wxPoint
wxGetMousePosition();
1445 // get the currently active window of this application or NULL
1446 extern WXDLLEXPORT wxWindow
*wxGetActiveWindow();
1448 // get the (first) top level parent window
1449 WXDLLEXPORT wxWindow
* wxGetTopLevelParent(wxWindow
*win
);
1451 // deprecated (doesn't start with 'wx' prefix), use wxWindow::NewControlId()
1452 inline int NewControlId() { return wxWindowBase
::NewControlId(); }
1454 #if wxUSE_ACCESSIBILITY
1455 // ----------------------------------------------------------------------------
1456 // accessible object for windows
1457 // ----------------------------------------------------------------------------
1459 class WXDLLEXPORT wxWindowAccessible
: public wxAccessible
1462 wxWindowAccessible(wxWindow
* win
): wxAccessible(win
) { if (win
) win
->SetAccessible(this); }
1463 virtual ~wxWindowAccessible() {}
1467 // Can return either a child object, or an integer
1468 // representing the child element, starting from 1.
1469 virtual wxAccStatus
HitTest(const wxPoint
& pt
, int* childId
, wxAccessible
** childObject
);
1471 // Returns the rectangle for this object (id = 0) or a child element (id > 0).
1472 virtual wxAccStatus
GetLocation(wxRect
& rect
, int elementId
);
1474 // Navigates from fromId to toId/toObject.
1475 virtual wxAccStatus
Navigate(wxNavDir navDir
, int fromId
,
1476 int* toId
, wxAccessible
** toObject
);
1478 // Gets the name of the specified object.
1479 virtual wxAccStatus
GetName(int childId
, wxString
* name
);
1481 // Gets the number of children.
1482 virtual wxAccStatus
GetChildCount(int* childCount
);
1484 // Gets the specified child (starting from 1).
1485 // If *child is NULL and return value is wxACC_OK,
1486 // this means that the child is a simple element and
1487 // not an accessible object.
1488 virtual wxAccStatus
GetChild(int childId
, wxAccessible
** child
);
1490 // Gets the parent, or NULL.
1491 virtual wxAccStatus
GetParent(wxAccessible
** parent
);
1493 // Performs the default action. childId is 0 (the action for this object)
1494 // or > 0 (the action for a child).
1495 // Return wxACC_NOT_SUPPORTED if there is no default action for this
1496 // window (e.g. an edit control).
1497 virtual wxAccStatus
DoDefaultAction(int childId
);
1499 // Gets the default action for this object (0) or > 0 (the action for a child).
1500 // Return wxACC_OK even if there is no action. actionName is the action, or the empty
1501 // string if there is no action.
1502 // The retrieved string describes the action that is performed on an object,
1503 // not what the object does as a result. For example, a toolbar button that prints
1504 // a document has a default action of "Press" rather than "Prints the current document."
1505 virtual wxAccStatus
GetDefaultAction(int childId
, wxString
* actionName
);
1507 // Returns the description for this object or a child.
1508 virtual wxAccStatus
GetDescription(int childId
, wxString
* description
);
1510 // Returns help text for this object or a child, similar to tooltip text.
1511 virtual wxAccStatus
GetHelpText(int childId
, wxString
* helpText
);
1513 // Returns the keyboard shortcut for this object or child.
1514 // Return e.g. ALT+K
1515 virtual wxAccStatus
GetKeyboardShortcut(int childId
, wxString
* shortcut
);
1517 // Returns a role constant.
1518 virtual wxAccStatus
GetRole(int childId
, wxAccRole
* role
);
1520 // Returns a state constant.
1521 virtual wxAccStatus
GetState(int childId
, long* state
);
1523 // Returns a localized string representing the value for the object
1525 virtual wxAccStatus
GetValue(int childId
, wxString
* strValue
);
1527 // Selects the object or child.
1528 virtual wxAccStatus
Select(int childId
, wxAccSelectionFlags selectFlags
);
1530 // Gets the window with the keyboard focus.
1531 // If childId is 0 and child is NULL, no object in
1532 // this subhierarchy has the focus.
1533 // If this object has the focus, child should be 'this'.
1534 virtual wxAccStatus
GetFocus(int* childId
, wxAccessible
** child
);
1536 // Gets a variant representing the selected children
1538 // Acceptable values:
1539 // - a null variant (IsNull() returns true)
1540 // - a list variant (GetType() == wxT("list")
1541 // - an integer representing the selected child element,
1542 // or 0 if this object is selected (GetType() == wxT("long")
1543 // - a "void*" pointer to a wxAccessible child object
1544 virtual wxAccStatus
GetSelections(wxVariant
* selections
);
1547 #endif // wxUSE_ACCESSIBILITY
1550 #endif // _WX_WINDOW_H_BASE_