]> git.saurik.com Git - wxWidgets.git/blob - include/wx/window.h
Fix showing MDI child from wxDocManager::ActivateDocument().
[wxWidgets.git] / include / wx / window.h
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: wx/window.h
3 // Purpose: wxWindowBase class - the interface of wxWindow
4 // Author: Vadim Zeitlin
5 // Modified by: Ron Lee
6 // Created: 01/02/97
7 // RCS-ID: $Id$
8 // Copyright: (c) Vadim Zeitlin
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
11
12 #ifndef _WX_WINDOW_H_BASE_
13 #define _WX_WINDOW_H_BASE_
14
15 // ----------------------------------------------------------------------------
16 // headers which we must include here
17 // ----------------------------------------------------------------------------
18
19 #include "wx/event.h" // the base class
20
21 #include "wx/list.h" // defines wxWindowList
22
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"
27 #include "wx/utils.h"
28 #include "wx/intl.h"
29
30 #include "wx/validate.h" // for wxDefaultValidator (always include it)
31
32 #if wxUSE_PALETTE
33 #include "wx/palette.h"
34 #endif // wxUSE_PALETTE
35
36 #if wxUSE_ACCEL
37 #include "wx/accel.h"
38 #endif // wxUSE_ACCEL
39
40 #if wxUSE_ACCESSIBILITY
41 #include "wx/access.h"
42 #endif
43
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__
51
52
53 // Define this macro if the corresponding operating system handles the state
54 // of children windows automatically when the parent is enabled/disabled.
55 // Otherwise wx itself must ensure that when the parent is disabled its
56 // children are disabled too, and their initial state is restored when the
57 // parent is enabled back.
58 #if defined(__WXMSW__) || defined(__WXPM__)
59 // must do everything ourselves
60 #undef wxHAS_NATIVE_ENABLED_MANAGEMENT
61 #else
62 #define wxHAS_NATIVE_ENABLED_MANAGEMENT
63 #endif
64
65 // ----------------------------------------------------------------------------
66 // forward declarations
67 // ----------------------------------------------------------------------------
68
69 class WXDLLIMPEXP_FWD_CORE wxCaret;
70 class WXDLLIMPEXP_FWD_CORE wxControl;
71 class WXDLLIMPEXP_FWD_CORE wxCursor;
72 class WXDLLIMPEXP_FWD_CORE wxDC;
73 class WXDLLIMPEXP_FWD_CORE wxDropTarget;
74 class WXDLLIMPEXP_FWD_CORE wxLayoutConstraints;
75 class WXDLLIMPEXP_FWD_CORE wxSizer;
76 class WXDLLIMPEXP_FWD_CORE wxToolTip;
77 class WXDLLIMPEXP_FWD_CORE wxWindowBase;
78 class WXDLLIMPEXP_FWD_CORE wxWindow;
79 class WXDLLIMPEXP_FWD_CORE wxScrollHelper;
80
81 #if wxUSE_ACCESSIBILITY
82 class WXDLLIMPEXP_FWD_CORE wxAccessible;
83 #endif
84
85 // ----------------------------------------------------------------------------
86 // helper stuff used by wxWindow
87 // ----------------------------------------------------------------------------
88
89 // struct containing all the visual attributes of a control
90 struct WXDLLIMPEXP_CORE wxVisualAttributes
91 {
92 // the font used for control label/text inside it
93 wxFont font;
94
95 // the foreground colour
96 wxColour colFg;
97
98 // the background colour, may be wxNullColour if the controls background
99 // colour is not solid
100 wxColour colBg;
101 };
102
103 // different window variants, on platforms like eg mac uses different
104 // rendering sizes
105 enum wxWindowVariant
106 {
107 wxWINDOW_VARIANT_NORMAL, // Normal size
108 wxWINDOW_VARIANT_SMALL, // Smaller size (about 25 % smaller than normal)
109 wxWINDOW_VARIANT_MINI, // Mini size (about 33 % smaller than normal)
110 wxWINDOW_VARIANT_LARGE, // Large size (about 25 % larger than normal)
111 wxWINDOW_VARIANT_MAX
112 };
113
114 #if wxUSE_SYSTEM_OPTIONS
115 #define wxWINDOW_DEFAULT_VARIANT wxT("window-default-variant")
116 #endif
117
118 // valid values for Show/HideWithEffect()
119 enum wxShowEffect
120 {
121 wxSHOW_EFFECT_NONE,
122 wxSHOW_EFFECT_ROLL_TO_LEFT,
123 wxSHOW_EFFECT_ROLL_TO_RIGHT,
124 wxSHOW_EFFECT_ROLL_TO_TOP,
125 wxSHOW_EFFECT_ROLL_TO_BOTTOM,
126 wxSHOW_EFFECT_SLIDE_TO_LEFT,
127 wxSHOW_EFFECT_SLIDE_TO_RIGHT,
128 wxSHOW_EFFECT_SLIDE_TO_TOP,
129 wxSHOW_EFFECT_SLIDE_TO_BOTTOM,
130 wxSHOW_EFFECT_BLEND,
131 wxSHOW_EFFECT_EXPAND,
132 wxSHOW_EFFECT_MAX
133 };
134
135 // flags for SendSizeEvent()
136 enum
137 {
138 wxSEND_EVENT_POST = 1
139 };
140
141 // ----------------------------------------------------------------------------
142 // (pseudo)template list classes
143 // ----------------------------------------------------------------------------
144
145 WX_DECLARE_LIST_3(wxWindow, wxWindowBase, wxWindowList, wxWindowListNode, class WXDLLIMPEXP_CORE);
146
147 // ----------------------------------------------------------------------------
148 // global variables
149 // ----------------------------------------------------------------------------
150
151 extern WXDLLIMPEXP_DATA_CORE(wxWindowList) wxTopLevelWindows;
152
153 // declared here for compatibility only, main declaration is in wx/app.h
154 extern WXDLLIMPEXP_DATA_BASE(wxList) wxPendingDelete;
155
156 // ----------------------------------------------------------------------------
157 // wxWindowBase is the base class for all GUI controls/widgets, this is the public
158 // interface of this class.
159 //
160 // Event handler: windows have themselves as their event handlers by default,
161 // but their event handlers could be set to another object entirely. This
162 // separation can reduce the amount of derivation required, and allow
163 // alteration of a window's functionality (e.g. by a resource editor that
164 // temporarily switches event handlers).
165 // ----------------------------------------------------------------------------
166
167 class WXDLLIMPEXP_CORE wxWindowBase : public wxEvtHandler
168 {
169 public:
170 // creating the window
171 // -------------------
172
173 // default ctor, initializes everything which can be initialized before
174 // Create()
175 wxWindowBase() ;
176
177 virtual ~wxWindowBase();
178
179 // deleting the window
180 // -------------------
181
182 // ask the window to close itself, return true if the event handler
183 // honoured our request
184 bool Close( bool force = false );
185
186 // the following functions delete the C++ objects (the window itself
187 // or its children) as well as the GUI windows and normally should
188 // never be used directly
189
190 // delete window unconditionally (dangerous!), returns true if ok
191 virtual bool Destroy();
192 // delete all children of this window, returns true if ok
193 bool DestroyChildren();
194
195 // is the window being deleted?
196 bool IsBeingDeleted() const;
197
198 // window attributes
199 // -----------------
200
201 // label is just the same as the title (but for, e.g., buttons it
202 // makes more sense to speak about labels), title access
203 // is available from wxTLW classes only (frames, dialogs)
204 virtual void SetLabel(const wxString& label) = 0;
205 virtual wxString GetLabel() const = 0;
206
207 // the window name is used for ressource setting in X, it is not the
208 // same as the window title/label
209 virtual void SetName( const wxString &name ) { m_windowName = name; }
210 virtual wxString GetName() const { return m_windowName; }
211
212 // sets the window variant, calls internally DoSetVariant if variant
213 // has changed
214 void SetWindowVariant(wxWindowVariant variant);
215 wxWindowVariant GetWindowVariant() const { return m_windowVariant; }
216
217
218 // get or change the layout direction (LTR or RTL) for this window,
219 // wxLayout_Default is returned if layout direction is not supported
220 virtual wxLayoutDirection GetLayoutDirection() const
221 { return wxLayout_Default; }
222 virtual void SetLayoutDirection(wxLayoutDirection WXUNUSED(dir))
223 { }
224
225 // mirror coordinates for RTL layout if this window uses it and if the
226 // mirroring is not done automatically like Win32
227 virtual wxCoord AdjustForLayoutDirection(wxCoord x,
228 wxCoord width,
229 wxCoord widthTotal) const;
230
231
232 // window id uniquely identifies the window among its siblings unless
233 // it is wxID_ANY which means "don't care"
234 void SetId( wxWindowID winid ) { m_windowId = winid; }
235 wxWindowID GetId() const { return m_windowId; }
236
237 // generate a unique id (or count of them consecutively), returns a
238 // valid id in the auto-id range or wxID_NONE if failed. If using
239 // autoid management, it will mark the id as reserved until it is
240 // used (by assigning it to a wxWindowIDRef) or unreserved.
241 static wxWindowID NewControlId(int count = 1)
242 {
243 return wxIdManager::ReserveId(count);
244 }
245
246 // If an ID generated from NewControlId is not assigned to a wxWindowIDRef,
247 // it must be unreserved
248 static void UnreserveControlId(wxWindowID id, int count = 1)
249 {
250 wxIdManager::UnreserveId(id, count);
251 }
252
253
254 // moving/resizing
255 // ---------------
256
257 // set the window size and/or position
258 void SetSize( int x, int y, int width, int height,
259 int sizeFlags = wxSIZE_AUTO )
260 { DoSetSize(x, y, width, height, sizeFlags); }
261
262 void SetSize( int width, int height )
263 { DoSetSize( wxDefaultCoord, wxDefaultCoord, width, height, wxSIZE_USE_EXISTING ); }
264
265 void SetSize( const wxSize& size )
266 { SetSize( size.x, size.y); }
267
268 void SetSize(const wxRect& rect, int sizeFlags = wxSIZE_AUTO)
269 { DoSetSize(rect.x, rect.y, rect.width, rect.height, sizeFlags); }
270
271 void Move(int x, int y, int flags = wxSIZE_USE_EXISTING)
272 { DoSetSize(x, y, wxDefaultCoord, wxDefaultCoord, flags); }
273
274 void Move(const wxPoint& pt, int flags = wxSIZE_USE_EXISTING)
275 { Move(pt.x, pt.y, flags); }
276
277 void SetPosition(const wxPoint& pt) { Move(pt); }
278
279 // Z-order
280 virtual void Raise() = 0;
281 virtual void Lower() = 0;
282
283 // client size is the size of area available for subwindows
284 void SetClientSize( int width, int height )
285 { DoSetClientSize(width, height); }
286
287 void SetClientSize( const wxSize& size )
288 { DoSetClientSize(size.x, size.y); }
289
290 void SetClientSize(const wxRect& rect)
291 { SetClientSize( rect.width, rect.height ); }
292
293 // get the window position (pointers may be NULL): notice that it is in
294 // client coordinates for child windows and screen coordinates for the
295 // top level ones, use GetScreenPosition() if you need screen
296 // coordinates for all kinds of windows
297 void GetPosition( int *x, int *y ) const { DoGetPosition(x, y); }
298 wxPoint GetPosition() const
299 {
300 int x, y;
301 DoGetPosition(&x, &y);
302
303 return wxPoint(x, y);
304 }
305
306 // get the window position in screen coordinates
307 void GetScreenPosition(int *x, int *y) const { DoGetScreenPosition(x, y); }
308 wxPoint GetScreenPosition() const
309 {
310 int x, y;
311 DoGetScreenPosition(&x, &y);
312
313 return wxPoint(x, y);
314 }
315
316 // get the window size (pointers may be NULL)
317 void GetSize( int *w, int *h ) const { DoGetSize(w, h); }
318 wxSize GetSize() const
319 {
320 int w, h;
321 DoGetSize(& w, & h);
322 return wxSize(w, h);
323 }
324
325 void GetClientSize( int *w, int *h ) const { DoGetClientSize(w, h); }
326 wxSize GetClientSize() const
327 {
328 int w, h;
329 DoGetClientSize(&w, &h);
330
331 return wxSize(w, h);
332 }
333
334 // get the position and size at once
335 wxRect GetRect() const
336 {
337 int x, y, w, h;
338 GetPosition(&x, &y);
339 GetSize(&w, &h);
340
341 return wxRect(x, y, w, h);
342 }
343
344 wxRect GetScreenRect() const
345 {
346 int x, y, w, h;
347 GetScreenPosition(&x, &y);
348 GetSize(&w, &h);
349
350 return wxRect(x, y, w, h);
351 }
352
353 // get the origin of the client area of the window relative to the
354 // window top left corner (the client area may be shifted because of
355 // the borders, scrollbars, other decorations...)
356 virtual wxPoint GetClientAreaOrigin() const;
357
358 // get the client rectangle in window (i.e. client) coordinates
359 wxRect GetClientRect() const
360 {
361 return wxRect(GetClientAreaOrigin(), GetClientSize());
362 }
363
364 // client<->window size conversion
365 virtual wxSize ClientToWindowSize(const wxSize& size) const;
366 virtual wxSize WindowToClientSize(const wxSize& size) const;
367
368 // get the size best suited for the window (in fact, minimal
369 // acceptable size using which it will still look "nice" in
370 // most situations)
371 wxSize GetBestSize() const;
372
373 void GetBestSize(int *w, int *h) const
374 {
375 wxSize s = GetBestSize();
376 if ( w )
377 *w = s.x;
378 if ( h )
379 *h = s.y;
380 }
381
382 void SetScrollHelper( wxScrollHelper *sh ) { m_scrollHelper = sh; }
383 wxScrollHelper *GetScrollHelper() { return m_scrollHelper; }
384
385 // reset the cached best size value so it will be recalculated the
386 // next time it is needed.
387 void InvalidateBestSize();
388 void CacheBestSize(const wxSize& size) const
389 { wxConstCast(this, wxWindowBase)->m_bestSizeCache = size; }
390
391
392 // This function will merge the window's best size into the window's
393 // minimum size, giving priority to the min size components, and
394 // returns the results.
395 virtual wxSize GetEffectiveMinSize() const;
396 wxDEPRECATED( wxSize GetBestFittingSize() const ); // replaced by GetEffectiveMinSize
397 wxDEPRECATED( wxSize GetAdjustedMinSize() const ); // replaced by GetEffectiveMinSize
398
399 // A 'Smart' SetSize that will fill in default size values with 'best'
400 // size. Sets the minsize to what was passed in.
401 void SetInitialSize(const wxSize& size=wxDefaultSize);
402 wxDEPRECATED( void SetBestFittingSize(const wxSize& size=wxDefaultSize) ); // replaced by SetInitialSize
403
404
405 // the generic centre function - centers the window on parent by`
406 // default or on screen if it doesn't have parent or
407 // wxCENTER_ON_SCREEN flag is given
408 void Centre(int dir = wxBOTH) { DoCentre(dir); }
409 void Center(int dir = wxBOTH) { DoCentre(dir); }
410
411 // centre with respect to the parent window
412 void CentreOnParent(int dir = wxBOTH) { DoCentre(dir); }
413 void CenterOnParent(int dir = wxBOTH) { CentreOnParent(dir); }
414
415 // set window size to wrap around its children
416 virtual void Fit();
417
418 // set virtual size to satisfy children
419 virtual void FitInside();
420
421
422 // SetSizeHints is actually for setting the size hints
423 // for the wxTLW for a Window Manager - hence the name -
424 // and it is therefore overridden in wxTLW to do that.
425 // In wxWindow(Base), it has (unfortunately) been abused
426 // to mean the same as SetMinSize() and SetMaxSize().
427
428 virtual void SetSizeHints( int minW, int minH,
429 int maxW = wxDefaultCoord, int maxH = wxDefaultCoord,
430 int incW = wxDefaultCoord, int incH = wxDefaultCoord )
431 { DoSetSizeHints(minW, minH, maxW, maxH, incW, incH); }
432
433 void SetSizeHints( const wxSize& minSize,
434 const wxSize& maxSize=wxDefaultSize,
435 const wxSize& incSize=wxDefaultSize)
436 { DoSetSizeHints(minSize.x, minSize.y, maxSize.x, maxSize.y, incSize.x, incSize.y); }
437
438
439 #if WXWIN_COMPATIBILITY_2_8
440 // these are useless and do nothing since wxWidgets 2.9
441 wxDEPRECATED( virtual void SetVirtualSizeHints( int minW, int minH,
442 int maxW = wxDefaultCoord, int maxH = wxDefaultCoord ) );
443 wxDEPRECATED( void SetVirtualSizeHints( const wxSize& minSize,
444 const wxSize& maxSize=wxDefaultSize) );
445 #endif // WXWIN_COMPATIBILITY_2_8
446
447
448 // Call these to override what GetBestSize() returns. This
449 // method is only virtual because it is overridden in wxTLW
450 // as a different API for SetSizeHints().
451 virtual void SetMinSize(const wxSize& minSize);
452 virtual void SetMaxSize(const wxSize& maxSize);
453
454 // Like Set*Size, but for client, not window, size
455 virtual void SetMinClientSize(const wxSize& size)
456 { SetMinSize(ClientToWindowSize(size)); }
457 virtual void SetMaxClientSize(const wxSize& size)
458 { SetMaxSize(ClientToWindowSize(size)); }
459
460 // Override these methods to impose restrictions on min/max size.
461 // The easier way is to call SetMinSize() and SetMaxSize() which
462 // will have the same effect. Doing both is non-sense.
463 virtual wxSize GetMinSize() const { return wxSize(m_minWidth, m_minHeight); }
464 virtual wxSize GetMaxSize() const { return wxSize(m_maxWidth, m_maxHeight); }
465
466 // Like Get*Size, but for client, not window, size
467 virtual wxSize GetMinClientSize() const
468 { return WindowToClientSize(GetMinSize()); }
469 virtual wxSize GetMaxClientSize() const
470 { return WindowToClientSize(GetMaxSize()); }
471
472 // Get the min and max values one by one
473 int GetMinWidth() const { return GetMinSize().x; }
474 int GetMinHeight() const { return GetMinSize().y; }
475 int GetMaxWidth() const { return GetMaxSize().x; }
476 int GetMaxHeight() const { return GetMaxSize().y; }
477
478
479 // Methods for accessing the virtual size of a window. For most
480 // windows this is just the client area of the window, but for
481 // some like scrolled windows it is more or less independent of
482 // the screen window size. You may override the DoXXXVirtual
483 // methods below for classes where that is the case.
484
485 void SetVirtualSize( const wxSize &size ) { DoSetVirtualSize( size.x, size.y ); }
486 void SetVirtualSize( int x, int y ) { DoSetVirtualSize( x, y ); }
487
488 wxSize GetVirtualSize() const { return DoGetVirtualSize(); }
489 void GetVirtualSize( int *x, int *y ) const
490 {
491 wxSize s( DoGetVirtualSize() );
492
493 if( x )
494 *x = s.GetWidth();
495 if( y )
496 *y = s.GetHeight();
497 }
498
499 // Override these methods for windows that have a virtual size
500 // independent of their client size. eg. the virtual area of a
501 // wxScrolledWindow.
502
503 virtual void DoSetVirtualSize( int x, int y );
504 virtual wxSize DoGetVirtualSize() const;
505
506 // Return the largest of ClientSize and BestSize (as determined
507 // by a sizer, interior children, or other means)
508
509 virtual wxSize GetBestVirtualSize() const
510 {
511 wxSize client( GetClientSize() );
512 wxSize best( GetBestSize() );
513
514 return wxSize( wxMax( client.x, best.x ), wxMax( client.y, best.y ) );
515 }
516
517 // return the size of the left/right and top/bottom borders in x and y
518 // components of the result respectively
519 virtual wxSize GetWindowBorderSize() const;
520
521 // wxSizer and friends use this to give a chance to a component to recalc
522 // its min size once one of the final size components is known. Override
523 // this function when that is useful (such as for wxStaticText which can
524 // stretch over several lines). Parameter availableOtherDir
525 // tells the item how much more space there is available in the opposite
526 // direction (-1 if unknown).
527 virtual bool
528 InformFirstDirection(int direction, int size, int availableOtherDir);
529
530 // sends a size event to the window using its current size -- this has an
531 // effect of refreshing the window layout
532 //
533 // by default the event is sent, i.e. processed immediately, but if flags
534 // value includes wxSEND_EVENT_POST then it's posted, i.e. only schedule
535 // for later processing
536 virtual void SendSizeEvent(int flags = 0);
537
538 // this is a safe wrapper for GetParent()->SendSizeEvent(): it checks that
539 // we have a parent window and it's not in process of being deleted
540 //
541 // this is used by controls such as tool/status bars changes to which must
542 // also result in parent re-layout
543 void SendSizeEventToParent(int flags = 0);
544
545 // this is a more readable synonym for SendSizeEvent(wxSEND_EVENT_POST)
546 void PostSizeEvent() { SendSizeEvent(wxSEND_EVENT_POST); }
547
548 // this is the same as SendSizeEventToParent() but using PostSizeEvent()
549 void PostSizeEventToParent() { SendSizeEventToParent(wxSEND_EVENT_POST); }
550
551
552 // window state
553 // ------------
554
555 // returns true if window was shown/hidden, false if the nothing was
556 // done (window was already shown/hidden)
557 virtual bool Show( bool show = true );
558 bool Hide() { return Show(false); }
559
560 // show or hide the window with a special effect, not implemented on
561 // most platforms (where it is the same as Show()/Hide() respectively)
562 //
563 // timeout specifies how long the animation should take, in ms, the
564 // default value of 0 means to use the default (system-dependent) value
565 virtual bool ShowWithEffect(wxShowEffect WXUNUSED(effect),
566 unsigned WXUNUSED(timeout) = 0)
567 {
568 return Show();
569 }
570
571 virtual bool HideWithEffect(wxShowEffect WXUNUSED(effect),
572 unsigned WXUNUSED(timeout) = 0)
573 {
574 return Hide();
575 }
576
577 // returns true if window was enabled/disabled, false if nothing done
578 virtual bool Enable( bool enable = true );
579 bool Disable() { return Enable(false); }
580
581 virtual bool IsShown() const { return m_isShown; }
582 // returns true if the window is really enabled and false otherwise,
583 // whether because it had been explicitly disabled itself or because
584 // its parent is currently disabled -- then this method returns false
585 // whatever is the intrinsic state of this window, use IsThisEnabled(0
586 // to retrieve it. In other words, this relation always holds:
587 //
588 // IsEnabled() == IsThisEnabled() && parent.IsEnabled()
589 //
590 bool IsEnabled() const;
591
592 // returns the internal window state independently of the parent(s)
593 // state, i.e. the state in which the window would be if all its
594 // parents were enabled (use IsEnabled() above to get the effective
595 // window state)
596 bool IsThisEnabled() const { return m_isEnabled; }
597
598 // returns true if the window is visible, i.e. IsShown() returns true
599 // if called on it and all its parents up to the first TLW
600 virtual bool IsShownOnScreen() const;
601
602 // get/set window style (setting style won't update the window and so
603 // is only useful for internal usage)
604 virtual void SetWindowStyleFlag( long style ) { m_windowStyle = style; }
605 virtual long GetWindowStyleFlag() const { return m_windowStyle; }
606
607 // just some (somewhat shorter) synonyms
608 void SetWindowStyle( long style ) { SetWindowStyleFlag(style); }
609 long GetWindowStyle() const { return GetWindowStyleFlag(); }
610
611 // check if the flag is set
612 bool HasFlag(int flag) const { return (m_windowStyle & flag) != 0; }
613 virtual bool IsRetained() const { return HasFlag(wxRETAINED); }
614
615 // turn the flag on if it had been turned off before and vice versa,
616 // return true if the flag is currently turned on
617 bool ToggleWindowStyle(int flag);
618
619 // extra style: the less often used style bits which can't be set with
620 // SetWindowStyleFlag()
621 virtual void SetExtraStyle(long exStyle) { m_exStyle = exStyle; }
622 long GetExtraStyle() const { return m_exStyle; }
623
624 bool HasExtraStyle(int exFlag) const { return (m_exStyle & exFlag) != 0; }
625
626 // make the window modal (all other windows unresponsive)
627 virtual void MakeModal(bool modal = true);
628
629
630 // (primitive) theming support
631 // ---------------------------
632
633 virtual void SetThemeEnabled(bool enableTheme) { m_themeEnabled = enableTheme; }
634 virtual bool GetThemeEnabled() const { return m_themeEnabled; }
635
636
637 // focus and keyboard handling
638 // ---------------------------
639
640 // set focus to this window
641 virtual void SetFocus() = 0;
642
643 // set focus to this window as the result of a keyboard action
644 virtual void SetFocusFromKbd() { SetFocus(); }
645
646 // return the window which currently has the focus or NULL
647 static wxWindow *FindFocus();
648
649 static wxWindow *DoFindFocus() /* = 0: implement in derived classes */;
650
651 // return true if the window has focus (handles composite windows
652 // correctly - returns true if GetMainWindowOfCompositeControl()
653 // has focus)
654 virtual bool HasFocus() const;
655
656 // can this window have focus in principle?
657 //
658 // the difference between AcceptsFocus[FromKeyboard]() and CanAcceptFocus
659 // [FromKeyboard]() is that the former functions are meant to be
660 // overridden in the derived classes to simply return false if the
661 // control can't have focus, while the latter are meant to be used by
662 // this class clients and take into account the current window state
663 virtual bool AcceptsFocus() const { return true; }
664
665 // can this window or one of its children accept focus?
666 //
667 // usually it's the same as AcceptsFocus() but is overridden for
668 // container windows
669 virtual bool AcceptsFocusRecursively() const { return AcceptsFocus(); }
670
671 // can this window be given focus by keyboard navigation? if not, the
672 // only way to give it focus (provided it accepts it at all) is to
673 // click it
674 virtual bool AcceptsFocusFromKeyboard() const { return AcceptsFocus(); }
675
676
677 // this is mostly a helper for the various functions using it below
678 bool CanBeFocused() const { return IsShown() && IsEnabled(); }
679
680 // can this window itself have focus?
681 bool IsFocusable() const { return AcceptsFocus() && CanBeFocused(); }
682
683 // can this window have focus right now?
684 //
685 // if this method returns true, it means that calling SetFocus() will
686 // put focus either to this window or one of its children, if you need
687 // to know whether this window accepts focus itself, use IsFocusable()
688 bool CanAcceptFocus() const
689 { return AcceptsFocusRecursively() && CanBeFocused(); }
690
691 // can this window be assigned focus from keyboard right now?
692 bool CanAcceptFocusFromKeyboard() const
693 { return AcceptsFocusFromKeyboard() && CanBeFocused(); }
694
695 // call this when the return value of AcceptsFocus() changes
696 virtual void SetCanFocus(bool WXUNUSED(canFocus)) { }
697
698 // navigates inside this window
699 bool NavigateIn(int flags = wxNavigationKeyEvent::IsForward)
700 { return DoNavigateIn(flags); }
701
702 // navigates in the specified direction from this window, this is
703 // equivalent to GetParent()->NavigateIn()
704 bool Navigate(int flags = wxNavigationKeyEvent::IsForward)
705 { return m_parent && ((wxWindowBase *)m_parent)->DoNavigateIn(flags); }
706
707 // this function will generate the appropriate call to Navigate() if the
708 // key event is one normally used for keyboard navigation and return true
709 // in this case
710 bool HandleAsNavigationKey(const wxKeyEvent& event);
711
712 // move this window just before/after the specified one in tab order
713 // (the other window must be our sibling!)
714 void MoveBeforeInTabOrder(wxWindow *win)
715 { DoMoveInTabOrder(win, OrderBefore); }
716 void MoveAfterInTabOrder(wxWindow *win)
717 { DoMoveInTabOrder(win, OrderAfter); }
718
719
720 // parent/children relations
721 // -------------------------
722
723 // get the list of children
724 const wxWindowList& GetChildren() const { return m_children; }
725 wxWindowList& GetChildren() { return m_children; }
726
727 // needed just for extended runtime
728 const wxWindowList& GetWindowChildren() const { return GetChildren() ; }
729
730 // get the window before/after this one in the parents children list,
731 // returns NULL if this is the first/last window
732 wxWindow *GetPrevSibling() const { return DoGetSibling(OrderBefore); }
733 wxWindow *GetNextSibling() const { return DoGetSibling(OrderAfter); }
734
735 // get the parent or the parent of the parent
736 wxWindow *GetParent() const { return m_parent; }
737 inline wxWindow *GetGrandParent() const;
738
739 // is this window a top level one?
740 virtual bool IsTopLevel() const;
741
742 // it doesn't really change parent, use Reparent() instead
743 void SetParent( wxWindowBase *parent ) { m_parent = (wxWindow *)parent; }
744 // change the real parent of this window, return true if the parent
745 // was changed, false otherwise (error or newParent == oldParent)
746 virtual bool Reparent( wxWindowBase *newParent );
747
748 // implementation mostly
749 virtual void AddChild( wxWindowBase *child );
750 virtual void RemoveChild( wxWindowBase *child );
751
752 // returns true if the child is in the client area of the window, i.e. is
753 // not scrollbar, toolbar etc.
754 virtual bool IsClientAreaChild(const wxWindow *WXUNUSED(child)) const
755 { return true; }
756
757 // looking for windows
758 // -------------------
759
760 // find window among the descendants of this one either by id or by
761 // name (return NULL if not found)
762 wxWindow *FindWindow(long winid) const;
763 wxWindow *FindWindow(const wxString& name) const;
764
765 // Find a window among any window (all return NULL if not found)
766 static wxWindow *FindWindowById( long winid, const wxWindow *parent = NULL );
767 static wxWindow *FindWindowByName( const wxString& name,
768 const wxWindow *parent = NULL );
769 static wxWindow *FindWindowByLabel( const wxString& label,
770 const wxWindow *parent = NULL );
771
772 // event handler stuff
773 // -------------------
774
775 // get the current event handler
776 wxEvtHandler *GetEventHandler() const { return m_eventHandler; }
777
778 // replace the event handler (allows to completely subclass the
779 // window)
780 void SetEventHandler( wxEvtHandler *handler );
781
782 // push/pop event handler: allows to chain a custom event handler to
783 // alreasy existing ones
784 void PushEventHandler( wxEvtHandler *handler );
785 wxEvtHandler *PopEventHandler( bool deleteHandler = false );
786
787 // find the given handler in the event handler chain and remove (but
788 // not delete) it from the event handler chain, return true if it was
789 // found and false otherwise (this also results in an assert failure so
790 // this function should only be called when the handler is supposed to
791 // be there)
792 bool RemoveEventHandler(wxEvtHandler *handler);
793
794 // Process an event by calling GetEventHandler()->ProcessEvent(): this
795 // is a straightforward replacement for ProcessEvent() itself which
796 // shouldn't be used directly with windows as it doesn't take into
797 // account any event handlers associated with the window
798 bool ProcessWindowEvent(wxEvent& event)
799 { return GetEventHandler()->ProcessEvent(event); }
800
801 // Call GetEventHandler()->ProcessEventLocally(): this should be used
802 // instead of calling ProcessEventLocally() directly on the window
803 // itself as this wouldn't take any pushed event handlers into account
804 // correctly
805 bool ProcessWindowEventLocally(wxEvent& event)
806 { return GetEventHandler()->ProcessEventLocally(event); }
807
808 // Process an event by calling GetEventHandler()->ProcessEvent() and
809 // handling any exceptions thrown by event handlers. It's mostly useful
810 // when processing wx events when called from C code (e.g. in GTK+
811 // callback) when the exception wouldn't correctly propagate to
812 // wxEventLoop.
813 bool HandleWindowEvent(wxEvent& event) const;
814
815 // disable wxEvtHandler double-linked list mechanism:
816 virtual void SetNextHandler(wxEvtHandler *handler);
817 virtual void SetPreviousHandler(wxEvtHandler *handler);
818
819
820 // Watcom doesn't allow reducing access with using access declaration, see
821 // #10749
822 #ifndef __WATCOMC__
823 protected:
824
825 // NOTE: we change the access specifier of the following wxEvtHandler functions
826 // so that the user won't be able to call them directly.
827 // Calling wxWindow::ProcessEvent in fact only works when there are NO
828 // event handlers pushed on the window.
829 // To ensure correct operation, instead of wxWindow::ProcessEvent
830 // you must always call wxWindow::GetEventHandler()->ProcessEvent()
831 // or HandleWindowEvent().
832 // The same holds for all other wxEvtHandler functions.
833
834 using wxEvtHandler::ProcessEvent;
835 using wxEvtHandler::ProcessEventLocally;
836 #if wxUSE_THREADS
837 using wxEvtHandler::ProcessThreadEvent;
838 #endif
839 using wxEvtHandler::SafelyProcessEvent;
840 using wxEvtHandler::ProcessPendingEvents;
841 using wxEvtHandler::AddPendingEvent;
842 using wxEvtHandler::QueueEvent;
843 #endif // __WATCOMC__
844
845 public:
846
847 // validators
848 // ----------
849
850 #if wxUSE_VALIDATORS
851 // a window may have an associated validator which is used to control
852 // user input
853 virtual void SetValidator( const wxValidator &validator );
854 virtual wxValidator *GetValidator() { return m_windowValidator; }
855 #endif // wxUSE_VALIDATORS
856
857
858 // dialog oriented functions
859 // -------------------------
860
861 // validate the correctness of input, return true if ok
862 virtual bool Validate();
863
864 // transfer data between internal and GUI representations
865 virtual bool TransferDataToWindow();
866 virtual bool TransferDataFromWindow();
867
868 virtual void InitDialog();
869
870 #if wxUSE_ACCEL
871 // accelerators
872 // ------------
873 virtual void SetAcceleratorTable( const wxAcceleratorTable& accel )
874 { m_acceleratorTable = accel; }
875 wxAcceleratorTable *GetAcceleratorTable()
876 { return &m_acceleratorTable; }
877
878 #endif // wxUSE_ACCEL
879
880 #if wxUSE_HOTKEY
881 // hot keys (system wide accelerators)
882 // -----------------------------------
883
884 virtual bool RegisterHotKey(int hotkeyId, int modifiers, int keycode);
885 virtual bool UnregisterHotKey(int hotkeyId);
886 #endif // wxUSE_HOTKEY
887
888
889 // dialog units translations
890 // -------------------------
891
892 wxPoint ConvertPixelsToDialog( const wxPoint& pt ) const;
893 wxPoint ConvertDialogToPixels( const wxPoint& pt ) const;
894 wxSize ConvertPixelsToDialog( const wxSize& sz ) const
895 {
896 wxPoint pt(ConvertPixelsToDialog(wxPoint(sz.x, sz.y)));
897
898 return wxSize(pt.x, pt.y);
899 }
900
901 wxSize ConvertDialogToPixels( const wxSize& sz ) const
902 {
903 wxPoint pt(ConvertDialogToPixels(wxPoint(sz.x, sz.y)));
904
905 return wxSize(pt.x, pt.y);
906 }
907
908 // mouse functions
909 // ---------------
910
911 // move the mouse to the specified position
912 virtual void WarpPointer(int x, int y) = 0;
913
914 // start or end mouse capture, these functions maintain the stack of
915 // windows having captured the mouse and after calling ReleaseMouse()
916 // the mouse is not released but returns to the window which had had
917 // captured it previously (if any)
918 void CaptureMouse();
919 void ReleaseMouse();
920
921 // get the window which currently captures the mouse or NULL
922 static wxWindow *GetCapture();
923
924 // does this window have the capture?
925 virtual bool HasCapture() const
926 { return (wxWindow *)this == GetCapture(); }
927
928 // painting the window
929 // -------------------
930
931 // mark the specified rectangle (or the whole window) as "dirty" so it
932 // will be repainted
933 virtual void Refresh( bool eraseBackground = true,
934 const wxRect *rect = (const wxRect *) NULL ) = 0;
935
936 // a less awkward wrapper for Refresh
937 void RefreshRect(const wxRect& rect, bool eraseBackground = true)
938 {
939 Refresh(eraseBackground, &rect);
940 }
941
942 // repaint all invalid areas of the window immediately
943 virtual void Update() { }
944
945 // clear the window background
946 virtual void ClearBackground();
947
948 // freeze the window: don't redraw it until it is thawed
949 void Freeze();
950
951 // thaw the window: redraw it after it had been frozen
952 void Thaw();
953
954 // return true if window had been frozen and not unthawed yet
955 bool IsFrozen() const { return m_freezeCount != 0; }
956
957 // adjust DC for drawing on this window
958 virtual void PrepareDC( wxDC & WXUNUSED(dc) ) { }
959
960 // return true if the window contents is double buffered by the system
961 virtual bool IsDoubleBuffered() const { return false; }
962
963 // the update region of the window contains the areas which must be
964 // repainted by the program
965 const wxRegion& GetUpdateRegion() const { return m_updateRegion; }
966 wxRegion& GetUpdateRegion() { return m_updateRegion; }
967
968 // get the update rectangleregion bounding box in client coords
969 wxRect GetUpdateClientRect() const;
970
971 // these functions verify whether the given point/rectangle belongs to
972 // (or at least intersects with) the update region
973 virtual bool DoIsExposed( int x, int y ) const;
974 virtual bool DoIsExposed( int x, int y, int w, int h ) const;
975
976 bool IsExposed( int x, int y ) const
977 { return DoIsExposed(x, y); }
978 bool IsExposed( int x, int y, int w, int h ) const
979 { return DoIsExposed(x, y, w, h); }
980 bool IsExposed( const wxPoint& pt ) const
981 { return DoIsExposed(pt.x, pt.y); }
982 bool IsExposed( const wxRect& rect ) const
983 { return DoIsExposed(rect.x, rect.y, rect.width, rect.height); }
984
985 // colours, fonts and cursors
986 // --------------------------
987
988 // get the default attributes for the controls of this class: we
989 // provide a virtual function which can be used to query the default
990 // attributes of an existing control and a static function which can
991 // be used even when no existing object of the given class is
992 // available, but which won't return any styles specific to this
993 // particular control, of course (e.g. "Ok" button might have
994 // different -- bold for example -- font)
995 virtual wxVisualAttributes GetDefaultAttributes() const
996 {
997 return GetClassDefaultAttributes(GetWindowVariant());
998 }
999
1000 static wxVisualAttributes
1001 GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
1002
1003 // set/retrieve the window colours (system defaults are used by
1004 // default): SetXXX() functions return true if colour was changed,
1005 // SetDefaultXXX() reset the "m_inheritXXX" flag after setting the
1006 // value to prevent it from being inherited by our children
1007 virtual bool SetBackgroundColour(const wxColour& colour);
1008 void SetOwnBackgroundColour(const wxColour& colour)
1009 {
1010 if ( SetBackgroundColour(colour) )
1011 m_inheritBgCol = false;
1012 }
1013 wxColour GetBackgroundColour() const;
1014 bool InheritsBackgroundColour() const
1015 {
1016 return m_inheritBgCol;
1017 }
1018 bool UseBgCol() const
1019 {
1020 return m_hasBgCol;
1021 }
1022
1023 virtual bool SetForegroundColour(const wxColour& colour);
1024 void SetOwnForegroundColour(const wxColour& colour)
1025 {
1026 if ( SetForegroundColour(colour) )
1027 m_inheritFgCol = false;
1028 }
1029 wxColour GetForegroundColour() const;
1030
1031 // Set/get the background style.
1032 virtual bool SetBackgroundStyle(wxBackgroundStyle style);
1033 wxBackgroundStyle GetBackgroundStyle() const
1034 { return m_backgroundStyle; }
1035
1036 // returns true if the control has "transparent" areas such as a
1037 // wxStaticText and wxCheckBox and the background should be adapted
1038 // from a parent window
1039 virtual bool HasTransparentBackground() { return false; }
1040
1041 // Returns true if background transparency is supported for this
1042 // window, i.e. if calling SetBackgroundStyle(wxBG_STYLE_TRANSPARENT)
1043 // has a chance of succeeding. If reason argument is non-NULL, returns a
1044 // user-readable explanation of why it isn't supported if the return
1045 // value is false.
1046 virtual bool IsTransparentBackgroundSupported(wxString* reason = NULL) const;
1047
1048 // set/retrieve the font for the window (SetFont() returns true if the
1049 // font really changed)
1050 virtual bool SetFont(const wxFont& font) = 0;
1051 void SetOwnFont(const wxFont& font)
1052 {
1053 if ( SetFont(font) )
1054 m_inheritFont = false;
1055 }
1056 wxFont GetFont() const;
1057
1058 // set/retrieve the cursor for this window (SetCursor() returns true
1059 // if the cursor was really changed)
1060 virtual bool SetCursor( const wxCursor &cursor );
1061 const wxCursor& GetCursor() const { return m_cursor; }
1062
1063 #if wxUSE_CARET
1064 // associate a caret with the window
1065 void SetCaret(wxCaret *caret);
1066 // get the current caret (may be NULL)
1067 wxCaret *GetCaret() const { return m_caret; }
1068 #endif // wxUSE_CARET
1069
1070 // get the (average) character size for the current font
1071 virtual int GetCharHeight() const = 0;
1072 virtual int GetCharWidth() const = 0;
1073
1074 // get the width/height/... of the text using current or specified
1075 // font
1076 void GetTextExtent(const wxString& string,
1077 int *x, int *y,
1078 int *descent = NULL,
1079 int *externalLeading = NULL,
1080 const wxFont *font = NULL) const
1081 {
1082 DoGetTextExtent(string, x, y, descent, externalLeading, font);
1083 }
1084
1085 wxSize GetTextExtent(const wxString& string) const
1086 {
1087 wxCoord w, h;
1088 GetTextExtent(string, &w, &h);
1089 return wxSize(w, h);
1090 }
1091
1092 // client <-> screen coords
1093 // ------------------------
1094
1095 // translate to/from screen/client coordinates (pointers may be NULL)
1096 void ClientToScreen( int *x, int *y ) const
1097 { DoClientToScreen(x, y); }
1098 void ScreenToClient( int *x, int *y ) const
1099 { DoScreenToClient(x, y); }
1100
1101 // wxPoint interface to do the same thing
1102 wxPoint ClientToScreen(const wxPoint& pt) const
1103 {
1104 int x = pt.x, y = pt.y;
1105 DoClientToScreen(&x, &y);
1106
1107 return wxPoint(x, y);
1108 }
1109
1110 wxPoint ScreenToClient(const wxPoint& pt) const
1111 {
1112 int x = pt.x, y = pt.y;
1113 DoScreenToClient(&x, &y);
1114
1115 return wxPoint(x, y);
1116 }
1117
1118 // test where the given (in client coords) point lies
1119 wxHitTest HitTest(wxCoord x, wxCoord y) const
1120 { return DoHitTest(x, y); }
1121
1122 wxHitTest HitTest(const wxPoint& pt) const
1123 { return DoHitTest(pt.x, pt.y); }
1124
1125 // misc
1126 // ----
1127
1128 // get the window border style from the given flags: this is different from
1129 // simply doing flags & wxBORDER_MASK because it uses GetDefaultBorder() to
1130 // translate wxBORDER_DEFAULT to something reasonable
1131 wxBorder GetBorder(long flags) const;
1132
1133 // get border for the flags of this window
1134 wxBorder GetBorder() const { return GetBorder(GetWindowStyleFlag()); }
1135
1136 // send wxUpdateUIEvents to this window, and children if recurse is true
1137 virtual void UpdateWindowUI(long flags = wxUPDATE_UI_NONE);
1138
1139 // do the window-specific processing after processing the update event
1140 virtual void DoUpdateWindowUI(wxUpdateUIEvent& event) ;
1141
1142 #if wxUSE_MENUS
1143 // show popup menu at the given position, generate events for the items
1144 // selected in it
1145 bool PopupMenu(wxMenu *menu, const wxPoint& pos = wxDefaultPosition)
1146 { return PopupMenu(menu, pos.x, pos.y); }
1147 bool PopupMenu(wxMenu *menu, int x, int y);
1148
1149 // simply return the id of the selected item or wxID_NONE without
1150 // generating any events
1151 int GetPopupMenuSelectionFromUser(wxMenu& menu,
1152 const wxPoint& pos = wxDefaultPosition)
1153 { return DoGetPopupMenuSelectionFromUser(menu, pos.x, pos.y); }
1154 int GetPopupMenuSelectionFromUser(wxMenu& menu, int x, int y)
1155 { return DoGetPopupMenuSelectionFromUser(menu, x, y); }
1156 #endif // wxUSE_MENUS
1157
1158 // override this method to return true for controls having multiple pages
1159 virtual bool HasMultiplePages() const { return false; }
1160
1161
1162 // scrollbars
1163 // ----------
1164
1165 // can the window have the scrollbar in this orientation?
1166 bool CanScroll(int orient) const
1167 {
1168 return (m_windowStyle &
1169 (orient == wxHORIZONTAL ? wxHSCROLL : wxVSCROLL)) != 0;
1170 }
1171
1172 // does the window have the scrollbar in this orientation?
1173 bool HasScrollbar(int orient) const;
1174
1175 // configure the window scrollbars
1176 virtual void SetScrollbar( int orient,
1177 int pos,
1178 int thumbvisible,
1179 int range,
1180 bool refresh = true ) = 0;
1181 virtual void SetScrollPos( int orient, int pos, bool refresh = true ) = 0;
1182 virtual int GetScrollPos( int orient ) const = 0;
1183 virtual int GetScrollThumb( int orient ) const = 0;
1184 virtual int GetScrollRange( int orient ) const = 0;
1185
1186 // scroll window to the specified position
1187 virtual void ScrollWindow( int dx, int dy,
1188 const wxRect* rect = NULL ) = 0;
1189
1190 // scrolls window by line/page: note that not all controls support this
1191 //
1192 // return true if the position changed, false otherwise
1193 virtual bool ScrollLines(int WXUNUSED(lines)) { return false; }
1194 virtual bool ScrollPages(int WXUNUSED(pages)) { return false; }
1195
1196 // convenient wrappers for ScrollLines/Pages
1197 bool LineUp() { return ScrollLines(-1); }
1198 bool LineDown() { return ScrollLines(1); }
1199 bool PageUp() { return ScrollPages(-1); }
1200 bool PageDown() { return ScrollPages(1); }
1201
1202 // call this to always show one or both scrollbars, even if the window
1203 // is big enough to not require them
1204 virtual void AlwaysShowScrollbars(bool WXUNUSED(horz) = true,
1205 bool WXUNUSED(vert) = true)
1206 {
1207 }
1208
1209 // return true if AlwaysShowScrollbars() had been called before for the
1210 // corresponding orientation
1211 virtual bool IsScrollbarAlwaysShown(int WXUNUSED(orient)) const
1212 {
1213 return false;
1214 }
1215
1216 // context-sensitive help
1217 // ----------------------
1218
1219 // these are the convenience functions wrapping wxHelpProvider methods
1220
1221 #if wxUSE_HELP
1222 // associate this help text with this window
1223 void SetHelpText(const wxString& text);
1224
1225 #if WXWIN_COMPATIBILITY_2_8
1226 // Associate this help text with all windows with the same id as this one.
1227 // Don't use this, do wxHelpProvider::Get()->AddHelp(id, text);
1228 wxDEPRECATED( void SetHelpTextForId(const wxString& text) );
1229 #endif // WXWIN_COMPATIBILITY_2_8
1230
1231 // get the help string associated with the given position in this window
1232 //
1233 // notice that pt may be invalid if event origin is keyboard or unknown
1234 // and this method should return the global window help text then
1235 virtual wxString GetHelpTextAtPoint(const wxPoint& pt,
1236 wxHelpEvent::Origin origin) const;
1237 // returns the position-independent help text
1238 wxString GetHelpText() const
1239 {
1240 return GetHelpTextAtPoint(wxDefaultPosition, wxHelpEvent::Origin_Unknown);
1241 }
1242
1243 #else // !wxUSE_HELP
1244 // silently ignore SetHelpText() calls
1245 void SetHelpText(const wxString& WXUNUSED(text)) { }
1246 void SetHelpTextForId(const wxString& WXUNUSED(text)) { }
1247 #endif // wxUSE_HELP
1248
1249 // tooltips
1250 // --------
1251
1252 #if wxUSE_TOOLTIPS
1253 // the easiest way to set a tooltip for a window is to use this method
1254 void SetToolTip( const wxString &tip );
1255 // attach a tooltip to the window, pointer can be NULL to remove
1256 // existing tooltip
1257 void SetToolTip( wxToolTip *tip ) { DoSetToolTip(tip); }
1258 // more readable synonym for SetToolTip(NULL)
1259 void UnsetToolTip() { SetToolTip(NULL); }
1260 // get the associated tooltip or NULL if none
1261 wxToolTip* GetToolTip() const { return m_tooltip; }
1262 wxString GetToolTipText() const;
1263
1264 // Use the same tool tip as the given one (which can be NULL to indicate
1265 // that no tooltip should be used) for this window. This is currently only
1266 // used by wxCompositeWindow::DoSetToolTip() implementation and is not part
1267 // of the public wx API.
1268 //
1269 // Returns true if tip was valid and we copied it or false if it was NULL
1270 // and we reset our own tooltip too.
1271 bool CopyToolTip(wxToolTip *tip);
1272 #else // !wxUSE_TOOLTIPS
1273 // make it much easier to compile apps in an environment
1274 // that doesn't support tooltips, such as PocketPC
1275 void SetToolTip(const wxString & WXUNUSED(tip)) { }
1276 void UnsetToolTip() { }
1277 #endif // wxUSE_TOOLTIPS/!wxUSE_TOOLTIPS
1278
1279 // drag and drop
1280 // -------------
1281 #if wxUSE_DRAG_AND_DROP
1282 // set/retrieve the drop target associated with this window (may be
1283 // NULL; it's owned by the window and will be deleted by it)
1284 virtual void SetDropTarget( wxDropTarget *dropTarget ) = 0;
1285 virtual wxDropTarget *GetDropTarget() const { return m_dropTarget; }
1286
1287 // Accept files for dragging
1288 virtual void DragAcceptFiles(bool accept)
1289 #ifdef __WXMSW__
1290 // it does have common implementation but not for MSW which has its own
1291 // native version of it
1292 = 0
1293 #endif // __WXMSW__
1294 ;
1295
1296 #endif // wxUSE_DRAG_AND_DROP
1297
1298 // constraints and sizers
1299 // ----------------------
1300 #if wxUSE_CONSTRAINTS
1301 // set the constraints for this window or retrieve them (may be NULL)
1302 void SetConstraints( wxLayoutConstraints *constraints );
1303 wxLayoutConstraints *GetConstraints() const { return m_constraints; }
1304
1305 // implementation only
1306 void UnsetConstraints(wxLayoutConstraints *c);
1307 wxWindowList *GetConstraintsInvolvedIn() const
1308 { return m_constraintsInvolvedIn; }
1309 void AddConstraintReference(wxWindowBase *otherWin);
1310 void RemoveConstraintReference(wxWindowBase *otherWin);
1311 void DeleteRelatedConstraints();
1312 void ResetConstraints();
1313
1314 // these methods may be overridden for special layout algorithms
1315 virtual void SetConstraintSizes(bool recurse = true);
1316 virtual bool LayoutPhase1(int *noChanges);
1317 virtual bool LayoutPhase2(int *noChanges);
1318 virtual bool DoPhase(int phase);
1319
1320 // these methods are virtual but normally won't be overridden
1321 virtual void SetSizeConstraint(int x, int y, int w, int h);
1322 virtual void MoveConstraint(int x, int y);
1323 virtual void GetSizeConstraint(int *w, int *h) const ;
1324 virtual void GetClientSizeConstraint(int *w, int *h) const ;
1325 virtual void GetPositionConstraint(int *x, int *y) const ;
1326
1327 #endif // wxUSE_CONSTRAINTS
1328
1329 // when using constraints or sizers, it makes sense to update
1330 // children positions automatically whenever the window is resized
1331 // - this is done if autoLayout is on
1332 void SetAutoLayout( bool autoLayout ) { m_autoLayout = autoLayout; }
1333 bool GetAutoLayout() const { return m_autoLayout; }
1334
1335 // lay out the window and its children
1336 virtual bool Layout();
1337
1338 // sizers
1339 void SetSizer(wxSizer *sizer, bool deleteOld = true );
1340 void SetSizerAndFit( wxSizer *sizer, bool deleteOld = true );
1341
1342 wxSizer *GetSizer() const { return m_windowSizer; }
1343
1344 // Track if this window is a member of a sizer
1345 void SetContainingSizer(wxSizer* sizer);
1346 wxSizer *GetContainingSizer() const { return m_containingSizer; }
1347
1348 // accessibility
1349 // ----------------------
1350 #if wxUSE_ACCESSIBILITY
1351 // Override to create a specific accessible object.
1352 virtual wxAccessible* CreateAccessible();
1353
1354 // Sets the accessible object.
1355 void SetAccessible(wxAccessible* accessible) ;
1356
1357 // Returns the accessible object.
1358 wxAccessible* GetAccessible() { return m_accessible; }
1359
1360 // Returns the accessible object, creating if necessary.
1361 wxAccessible* GetOrCreateAccessible() ;
1362 #endif
1363
1364
1365 // Set window transparency if the platform supports it
1366 virtual bool SetTransparent(wxByte WXUNUSED(alpha)) { return false; }
1367 virtual bool CanSetTransparent() { return false; }
1368
1369
1370 // implementation
1371 // --------------
1372
1373 // event handlers
1374 void OnSysColourChanged( wxSysColourChangedEvent& event );
1375 void OnInitDialog( wxInitDialogEvent &event );
1376 void OnMiddleClick( wxMouseEvent& event );
1377 #if wxUSE_HELP
1378 void OnHelp(wxHelpEvent& event);
1379 #endif // wxUSE_HELP
1380
1381 // virtual function for implementing internal idle
1382 // behaviour
1383 virtual void OnInternalIdle();
1384
1385 // Send idle event to window and all subwindows
1386 // Returns true if more idle time is requested.
1387 virtual bool SendIdleEvents(wxIdleEvent& event);
1388
1389 // get the handle of the window for the underlying window system: this
1390 // is only used for wxWin itself or for user code which wants to call
1391 // platform-specific APIs
1392 virtual WXWidget GetHandle() const = 0;
1393 // associate the window with a new native handle
1394 virtual void AssociateHandle(WXWidget WXUNUSED(handle)) { }
1395 // dissociate the current native handle from the window
1396 virtual void DissociateHandle() { }
1397
1398 #if wxUSE_PALETTE
1399 // Store the palette used by DCs in wxWindow so that the dcs can share
1400 // a palette. And we can respond to palette messages.
1401 wxPalette GetPalette() const { return m_palette; }
1402
1403 // When palette is changed tell the DC to set the system palette to the
1404 // new one.
1405 void SetPalette(const wxPalette& pal);
1406
1407 // return true if we have a specific palette
1408 bool HasCustomPalette() const { return m_hasCustomPalette; }
1409
1410 // return the first parent window with a custom palette or NULL
1411 wxWindow *GetAncestorWithCustomPalette() const;
1412 #endif // wxUSE_PALETTE
1413
1414 // inherit the parents visual attributes if they had been explicitly set
1415 // by the user (i.e. we don't inherit default attributes) and if we don't
1416 // have our own explicitly set
1417 virtual void InheritAttributes();
1418
1419 // returns false from here if this window doesn't want to inherit the
1420 // parents colours even if InheritAttributes() would normally do it
1421 //
1422 // this just provides a simple way to customize InheritAttributes()
1423 // behaviour in the most common case
1424 virtual bool ShouldInheritColours() const { return false; }
1425
1426 // returns true if the window can be positioned outside of parent's client
1427 // area (normal windows can't, but e.g. menubar or statusbar can):
1428 virtual bool CanBeOutsideClientArea() const { return false; }
1429
1430 // returns true if the platform should explicitly apply a theme border. Currently
1431 // used only by Windows
1432 virtual bool CanApplyThemeBorder() const { return true; }
1433
1434 // returns the main window of composite control; this is the window
1435 // that FindFocus returns if the focus is in one of composite control's
1436 // windows
1437 virtual wxWindow *GetMainWindowOfCompositeControl()
1438 { return (wxWindow*)this; }
1439
1440 // If this function returns true, keyboard navigation events shouldn't
1441 // escape from it. A typical example of such "navigation domain" is a top
1442 // level window because pressing TAB in one of them must not transfer focus
1443 // to a different top level window. But it's not limited to them, e.g. MDI
1444 // children frames are not top level windows (and their IsTopLevel()
1445 // returns false) but still are self-contained navigation domains as well.
1446 virtual bool IsTopNavigationDomain() const { return false; }
1447
1448
1449 protected:
1450 // helper for the derived class Create() methods: the first overload, with
1451 // validator parameter, should be used for child windows while the second
1452 // one is used for top level ones
1453 bool CreateBase(wxWindowBase *parent,
1454 wxWindowID winid,
1455 const wxPoint& pos = wxDefaultPosition,
1456 const wxSize& size = wxDefaultSize,
1457 long style = 0,
1458 const wxValidator& validator = wxDefaultValidator,
1459 const wxString& name = wxPanelNameStr);
1460
1461 bool CreateBase(wxWindowBase *parent,
1462 wxWindowID winid,
1463 const wxPoint& pos,
1464 const wxSize& size,
1465 long style,
1466 const wxString& name);
1467
1468 // event handling specific to wxWindow
1469 virtual bool TryBefore(wxEvent& event);
1470 virtual bool TryAfter(wxEvent& event);
1471
1472 enum WindowOrder
1473 {
1474 OrderBefore, // insert before the given window
1475 OrderAfter // insert after the given window
1476 };
1477
1478 // common part of GetPrev/NextSibling()
1479 wxWindow *DoGetSibling(WindowOrder order) const;
1480
1481 // common part of MoveBefore/AfterInTabOrder()
1482 virtual void DoMoveInTabOrder(wxWindow *win, WindowOrder move);
1483
1484 // implementation of Navigate() and NavigateIn()
1485 virtual bool DoNavigateIn(int flags);
1486
1487 #if wxUSE_CONSTRAINTS
1488 // satisfy the constraints for the windows but don't set the window sizes
1489 void SatisfyConstraints();
1490 #endif // wxUSE_CONSTRAINTS
1491
1492 // Send the wxWindowDestroyEvent if not done yet and sets m_isBeingDeleted
1493 // to true
1494 void SendDestroyEvent();
1495
1496 // this method should be implemented to use operating system specific code
1497 // to really enable/disable the widget, it will only be called when we
1498 // really need to enable/disable window and so no additional checks on the
1499 // widgets state are necessary
1500 virtual void DoEnable(bool WXUNUSED(enable)) { }
1501
1502 // called when the on-screen widget state changes and provides an
1503 // an opportunity for the widget to update its visual state (colours,
1504 // fonts, anything else) as necessary
1505 virtual void OnEnabled(bool WXUNUSED(enabled)) { }
1506
1507
1508 // the window id - a number which uniquely identifies a window among
1509 // its siblings unless it is wxID_ANY
1510 wxWindowIDRef m_windowId;
1511
1512 // the parent window of this window (or NULL) and the list of the children
1513 // of this window
1514 wxWindow *m_parent;
1515 wxWindowList m_children;
1516
1517 // the minimal allowed size for the window (no minimal size if variable(s)
1518 // contain(s) wxDefaultCoord)
1519 int m_minWidth,
1520 m_minHeight,
1521 m_maxWidth,
1522 m_maxHeight;
1523
1524 // event handler for this window: usually is just 'this' but may be
1525 // changed with SetEventHandler()
1526 wxEvtHandler *m_eventHandler;
1527
1528 #if wxUSE_VALIDATORS
1529 // associated validator or NULL if none
1530 wxValidator *m_windowValidator;
1531 #endif // wxUSE_VALIDATORS
1532
1533 #if wxUSE_DRAG_AND_DROP
1534 wxDropTarget *m_dropTarget;
1535 #endif // wxUSE_DRAG_AND_DROP
1536
1537 // visual window attributes
1538 wxCursor m_cursor;
1539 wxFont m_font; // see m_hasFont
1540 wxColour m_backgroundColour, // m_hasBgCol
1541 m_foregroundColour; // m_hasFgCol
1542
1543 #if wxUSE_CARET
1544 wxCaret *m_caret;
1545 #endif // wxUSE_CARET
1546
1547 // the region which should be repainted in response to paint event
1548 wxRegion m_updateRegion;
1549
1550 #if wxUSE_ACCEL
1551 // the accelerator table for the window which translates key strokes into
1552 // command events
1553 wxAcceleratorTable m_acceleratorTable;
1554 #endif // wxUSE_ACCEL
1555
1556 // the tooltip for this window (may be NULL)
1557 #if wxUSE_TOOLTIPS
1558 wxToolTip *m_tooltip;
1559 #endif // wxUSE_TOOLTIPS
1560
1561 // constraints and sizers
1562 #if wxUSE_CONSTRAINTS
1563 // the constraints for this window or NULL
1564 wxLayoutConstraints *m_constraints;
1565
1566 // constraints this window is involved in
1567 wxWindowList *m_constraintsInvolvedIn;
1568 #endif // wxUSE_CONSTRAINTS
1569
1570 // this window's sizer
1571 wxSizer *m_windowSizer;
1572
1573 // The sizer this window is a member of, if any
1574 wxSizer *m_containingSizer;
1575
1576 // Layout() window automatically when its size changes?
1577 bool m_autoLayout:1;
1578
1579 // window state
1580 bool m_isShown:1;
1581 bool m_isEnabled:1;
1582 bool m_isBeingDeleted:1;
1583
1584 // was the window colours/font explicitly changed by user?
1585 bool m_hasBgCol:1;
1586 bool m_hasFgCol:1;
1587 bool m_hasFont:1;
1588
1589 // and should it be inherited by children?
1590 bool m_inheritBgCol:1;
1591 bool m_inheritFgCol:1;
1592 bool m_inheritFont:1;
1593
1594 // window attributes
1595 long m_windowStyle,
1596 m_exStyle;
1597 wxString m_windowName;
1598 bool m_themeEnabled;
1599 wxBackgroundStyle m_backgroundStyle;
1600 #if wxUSE_PALETTE
1601 wxPalette m_palette;
1602 bool m_hasCustomPalette;
1603 #endif // wxUSE_PALETTE
1604
1605 #if wxUSE_ACCESSIBILITY
1606 wxAccessible* m_accessible;
1607 #endif
1608
1609 // Virtual size (scrolling)
1610 wxSize m_virtualSize;
1611
1612 wxScrollHelper *m_scrollHelper;
1613
1614 wxWindowVariant m_windowVariant ;
1615
1616 // override this to change the default (i.e. used when no style is
1617 // specified) border for the window class
1618 virtual wxBorder GetDefaultBorder() const;
1619
1620 // this allows you to implement standard control borders without
1621 // repeating the code in different classes that are not derived from
1622 // wxControl
1623 virtual wxBorder GetDefaultBorderForControl() const { return wxBORDER_THEME; }
1624
1625 // Get the default size for the new window if no explicit size given. TLWs
1626 // have their own default size so this is just for non top-level windows.
1627 static int WidthDefault(int w) { return w == wxDefaultCoord ? 20 : w; }
1628 static int HeightDefault(int h) { return h == wxDefaultCoord ? 20 : h; }
1629
1630
1631 // Used to save the results of DoGetBestSize so it doesn't need to be
1632 // recalculated each time the value is needed.
1633 wxSize m_bestSizeCache;
1634
1635 wxDEPRECATED( void SetBestSize(const wxSize& size) ); // use SetInitialSize
1636 wxDEPRECATED( virtual void SetInitialBestSize(const wxSize& size) ); // use SetInitialSize
1637
1638
1639
1640 // more pure virtual functions
1641 // ---------------------------
1642
1643 // NB: we must have DoSomething() function when Something() is an overloaded
1644 // method: indeed, we can't just have "virtual Something()" in case when
1645 // the function is overloaded because then we'd have to make virtual all
1646 // the variants (otherwise only the virtual function may be called on a
1647 // pointer to derived class according to C++ rules) which is, in
1648 // general, absolutely not needed. So instead we implement all
1649 // overloaded Something()s in terms of DoSomething() which will be the
1650 // only one to be virtual.
1651
1652 // text extent
1653 virtual void DoGetTextExtent(const wxString& string,
1654 int *x, int *y,
1655 int *descent = NULL,
1656 int *externalLeading = NULL,
1657 const wxFont *font = NULL) const = 0;
1658
1659 // coordinates translation
1660 virtual void DoClientToScreen( int *x, int *y ) const = 0;
1661 virtual void DoScreenToClient( int *x, int *y ) const = 0;
1662
1663 virtual wxHitTest DoHitTest(wxCoord x, wxCoord y) const;
1664
1665 // capture/release the mouse, used by Capture/ReleaseMouse()
1666 virtual void DoCaptureMouse() = 0;
1667 virtual void DoReleaseMouse() = 0;
1668
1669 // retrieve the position/size of the window
1670 virtual void DoGetPosition(int *x, int *y) const = 0;
1671 virtual void DoGetScreenPosition(int *x, int *y) const;
1672 virtual void DoGetSize(int *width, int *height) const = 0;
1673 virtual void DoGetClientSize(int *width, int *height) const = 0;
1674
1675 // get the size which best suits the window: for a control, it would be
1676 // the minimal size which doesn't truncate the control, for a panel - the
1677 // same size as it would have after a call to Fit()
1678 virtual wxSize DoGetBestSize() const;
1679
1680 // this method can be overridden instead of DoGetBestSize() if it computes
1681 // the best size of the client area of the window only, excluding borders
1682 // (GetBorderSize() will be used to add them)
1683 virtual wxSize DoGetBestClientSize() const { return wxDefaultSize; }
1684
1685 // this is the virtual function to be overridden in any derived class which
1686 // wants to change how SetSize() or Move() works - it is called by all
1687 // versions of these functions in the base class
1688 virtual void DoSetSize(int x, int y,
1689 int width, int height,
1690 int sizeFlags = wxSIZE_AUTO) = 0;
1691
1692 // same as DoSetSize() for the client size
1693 virtual void DoSetClientSize(int width, int height) = 0;
1694
1695 virtual void DoSetSizeHints( int minW, int minH,
1696 int maxW, int maxH,
1697 int incW, int incH );
1698
1699 // return the total size of the window borders, i.e. the sum of the widths
1700 // of the left and the right border in the x component of the returned size
1701 // and the sum of the heights of the top and bottom borders in the y one
1702 //
1703 // NB: this is currently only implemented properly for wxMSW, wxGTK and
1704 // wxUniv and doesn't behave correctly in the presence of scrollbars in
1705 // the other ports
1706 virtual wxSize DoGetBorderSize() const;
1707
1708 // move the window to the specified location and resize it: this is called
1709 // from both DoSetSize() and DoSetClientSize() and would usually just
1710 // reposition this window except for composite controls which will want to
1711 // arrange themselves inside the given rectangle
1712 //
1713 // Important note: the coordinates passed to this method are in parent's
1714 // *window* coordinates and not parent's client coordinates (as the values
1715 // passed to DoSetSize and returned by DoGetPosition are)!
1716 virtual void DoMoveWindow(int x, int y, int width, int height) = 0;
1717
1718 // centre the window in the specified direction on parent, note that
1719 // wxCENTRE_ON_SCREEN shouldn't be specified here, it only makes sense for
1720 // TLWs
1721 virtual void DoCentre(int dir);
1722
1723 #if wxUSE_TOOLTIPS
1724 virtual void DoSetToolTip( wxToolTip *tip );
1725 #endif // wxUSE_TOOLTIPS
1726
1727 #if wxUSE_MENUS
1728 virtual bool DoPopupMenu(wxMenu *menu, int x, int y) = 0;
1729 #endif // wxUSE_MENUS
1730
1731 // Makes an adjustment to the window position to make it relative to the
1732 // parents client area, e.g. if the parent is a frame with a toolbar, its
1733 // (0, 0) is just below the toolbar
1734 virtual void AdjustForParentClientOrigin(int& x, int& y,
1735 int sizeFlags = 0) const;
1736
1737 // implements the window variants
1738 virtual void DoSetWindowVariant( wxWindowVariant variant ) ;
1739
1740
1741 // really freeze/thaw the window (should have port-specific implementation)
1742 virtual void DoFreeze() { }
1743 virtual void DoThaw() { }
1744
1745
1746 // Must be called when mouse capture is lost to send
1747 // wxMouseCaptureLostEvent to windows on capture stack.
1748 static void NotifyCaptureLost();
1749
1750 private:
1751 // recursively call our own and our children OnEnabled() when the
1752 // enabled/disabled status changed because a parent window had been
1753 // enabled/disabled
1754 void NotifyWindowOnEnableChange(bool enabled);
1755
1756 #if wxUSE_MENUS
1757 // temporary event handlers used by GetPopupMenuSelectionFromUser()
1758 void InternalOnPopupMenu(wxCommandEvent& event);
1759 void InternalOnPopupMenuUpdate(wxUpdateUIEvent& event);
1760
1761 // implementation of the public GetPopupMenuSelectionFromUser() method
1762 int DoGetPopupMenuSelectionFromUser(wxMenu& menu, int x, int y);
1763 #endif // wxUSE_MENUS
1764
1765 // layout the window children when its size changes unless this was
1766 // explicitly disabled with SetAutoLayout(false)
1767 void InternalOnSize(wxSizeEvent& event);
1768
1769 // base for dialog unit conversion, i.e. average character size
1770 wxSize GetDlgUnitBase() const;
1771
1772 // the stack of windows which have captured the mouse
1773 static struct WXDLLIMPEXP_FWD_CORE wxWindowNext *ms_winCaptureNext;
1774
1775 // the window that currently has mouse capture
1776 static wxWindow *ms_winCaptureCurrent;
1777
1778 // indicates if execution is inside CaptureMouse/ReleaseMouse
1779 static bool ms_winCaptureChanging;
1780
1781
1782 // number of Freeze() calls minus the number of Thaw() calls: we're frozen
1783 // (i.e. not being updated) if it is positive
1784 unsigned int m_freezeCount;
1785
1786
1787 DECLARE_ABSTRACT_CLASS(wxWindowBase)
1788 wxDECLARE_NO_COPY_CLASS(wxWindowBase);
1789 DECLARE_EVENT_TABLE()
1790 };
1791
1792
1793
1794 // Inlines for some deprecated methods
1795 inline wxSize wxWindowBase::GetBestFittingSize() const
1796 {
1797 return GetEffectiveMinSize();
1798 }
1799
1800 inline void wxWindowBase::SetBestFittingSize(const wxSize& size)
1801 {
1802 SetInitialSize(size);
1803 }
1804
1805 inline void wxWindowBase::SetBestSize(const wxSize& size)
1806 {
1807 SetInitialSize(size);
1808 }
1809
1810 inline void wxWindowBase::SetInitialBestSize(const wxSize& size)
1811 {
1812 SetInitialSize(size);
1813 }
1814
1815
1816 // ----------------------------------------------------------------------------
1817 // now include the declaration of wxWindow class
1818 // ----------------------------------------------------------------------------
1819
1820 // include the declaration of the platform-specific class
1821 #if defined(__WXMSW__)
1822 #ifdef __WXUNIVERSAL__
1823 #define wxWindowNative wxWindowMSW
1824 #else // !wxUniv
1825 #define wxWindowMSW wxWindow
1826 #endif // wxUniv/!wxUniv
1827 #include "wx/msw/window.h"
1828 #elif defined(__WXMOTIF__)
1829 #include "wx/motif/window.h"
1830 #elif defined(__WXGTK20__)
1831 #ifdef __WXUNIVERSAL__
1832 #define wxWindowNative wxWindowGTK
1833 #else // !wxUniv
1834 #define wxWindowGTK wxWindow
1835 #endif // wxUniv
1836 #include "wx/gtk/window.h"
1837 #elif defined(__WXGTK__)
1838 #ifdef __WXUNIVERSAL__
1839 #define wxWindowNative wxWindowGTK
1840 #else // !wxUniv
1841 #define wxWindowGTK wxWindow
1842 #endif // wxUniv
1843 #include "wx/gtk1/window.h"
1844 #elif defined(__WXX11__)
1845 #ifdef __WXUNIVERSAL__
1846 #define wxWindowNative wxWindowX11
1847 #else // !wxUniv
1848 #define wxWindowX11 wxWindow
1849 #endif // wxUniv
1850 #include "wx/x11/window.h"
1851 #elif defined(__WXDFB__)
1852 #define wxWindowNative wxWindowDFB
1853 #include "wx/dfb/window.h"
1854 #elif defined(__WXMAC__)
1855 #ifdef __WXUNIVERSAL__
1856 #define wxWindowNative wxWindowMac
1857 #else // !wxUniv
1858 #define wxWindowMac wxWindow
1859 #endif // wxUniv
1860 #include "wx/osx/window.h"
1861 #elif defined(__WXCOCOA__)
1862 #ifdef __WXUNIVERSAL__
1863 #define wxWindowNative wxWindowCocoa
1864 #else // !wxUniv
1865 #define wxWindowCocoa wxWindow
1866 #endif // wxUniv
1867 #include "wx/cocoa/window.h"
1868 #elif defined(__WXPM__)
1869 #ifdef __WXUNIVERSAL__
1870 #define wxWindowNative wxWindowOS2
1871 #else // !wxUniv
1872 #define wxWindowOS2 wxWindow
1873 #endif // wxUniv/!wxUniv
1874 #include "wx/os2/window.h"
1875 #endif
1876
1877 // for wxUniversal, we now derive the real wxWindow from wxWindow<platform>,
1878 // for the native ports we already have defined it above
1879 #if defined(__WXUNIVERSAL__)
1880 #ifndef wxWindowNative
1881 #error "wxWindowNative must be defined above!"
1882 #endif
1883
1884 #include "wx/univ/window.h"
1885 #endif // wxUniv
1886
1887 // ----------------------------------------------------------------------------
1888 // inline functions which couldn't be declared in the class body because of
1889 // forward dependencies
1890 // ----------------------------------------------------------------------------
1891
1892 inline wxWindow *wxWindowBase::GetGrandParent() const
1893 {
1894 return m_parent ? m_parent->GetParent() : NULL;
1895 }
1896
1897 // ----------------------------------------------------------------------------
1898 // global functions
1899 // ----------------------------------------------------------------------------
1900
1901 // Find the wxWindow at the current mouse position, also returning the mouse
1902 // position.
1903 extern WXDLLIMPEXP_CORE wxWindow* wxFindWindowAtPointer(wxPoint& pt);
1904
1905 // Get the current mouse position.
1906 extern WXDLLIMPEXP_CORE wxPoint wxGetMousePosition();
1907
1908 // get the currently active window of this application or NULL
1909 extern WXDLLIMPEXP_CORE wxWindow *wxGetActiveWindow();
1910
1911 // get the (first) top level parent window
1912 WXDLLIMPEXP_CORE wxWindow* wxGetTopLevelParent(wxWindow *win);
1913
1914 #if WXWIN_COMPATIBILITY_2_6
1915 // deprecated (doesn't start with 'wx' prefix), use wxWindow::NewControlId()
1916 wxDEPRECATED( wxWindowID NewControlId() );
1917 inline wxWindowID NewControlId() { return wxWindowBase::NewControlId(); }
1918 #endif // WXWIN_COMPATIBILITY_2_6
1919
1920 #if wxUSE_ACCESSIBILITY
1921 // ----------------------------------------------------------------------------
1922 // accessible object for windows
1923 // ----------------------------------------------------------------------------
1924
1925 class WXDLLIMPEXP_CORE wxWindowAccessible: public wxAccessible
1926 {
1927 public:
1928 wxWindowAccessible(wxWindow* win): wxAccessible(win) { if (win) win->SetAccessible(this); }
1929 virtual ~wxWindowAccessible() {}
1930
1931 // Overridables
1932
1933 // Can return either a child object, or an integer
1934 // representing the child element, starting from 1.
1935 virtual wxAccStatus HitTest(const wxPoint& pt, int* childId, wxAccessible** childObject);
1936
1937 // Returns the rectangle for this object (id = 0) or a child element (id > 0).
1938 virtual wxAccStatus GetLocation(wxRect& rect, int elementId);
1939
1940 // Navigates from fromId to toId/toObject.
1941 virtual wxAccStatus Navigate(wxNavDir navDir, int fromId,
1942 int* toId, wxAccessible** toObject);
1943
1944 // Gets the name of the specified object.
1945 virtual wxAccStatus GetName(int childId, wxString* name);
1946
1947 // Gets the number of children.
1948 virtual wxAccStatus GetChildCount(int* childCount);
1949
1950 // Gets the specified child (starting from 1).
1951 // If *child is NULL and return value is wxACC_OK,
1952 // this means that the child is a simple element and
1953 // not an accessible object.
1954 virtual wxAccStatus GetChild(int childId, wxAccessible** child);
1955
1956 // Gets the parent, or NULL.
1957 virtual wxAccStatus GetParent(wxAccessible** parent);
1958
1959 // Performs the default action. childId is 0 (the action for this object)
1960 // or > 0 (the action for a child).
1961 // Return wxACC_NOT_SUPPORTED if there is no default action for this
1962 // window (e.g. an edit control).
1963 virtual wxAccStatus DoDefaultAction(int childId);
1964
1965 // Gets the default action for this object (0) or > 0 (the action for a child).
1966 // Return wxACC_OK even if there is no action. actionName is the action, or the empty
1967 // string if there is no action.
1968 // The retrieved string describes the action that is performed on an object,
1969 // not what the object does as a result. For example, a toolbar button that prints
1970 // a document has a default action of "Press" rather than "Prints the current document."
1971 virtual wxAccStatus GetDefaultAction(int childId, wxString* actionName);
1972
1973 // Returns the description for this object or a child.
1974 virtual wxAccStatus GetDescription(int childId, wxString* description);
1975
1976 // Returns help text for this object or a child, similar to tooltip text.
1977 virtual wxAccStatus GetHelpText(int childId, wxString* helpText);
1978
1979 // Returns the keyboard shortcut for this object or child.
1980 // Return e.g. ALT+K
1981 virtual wxAccStatus GetKeyboardShortcut(int childId, wxString* shortcut);
1982
1983 // Returns a role constant.
1984 virtual wxAccStatus GetRole(int childId, wxAccRole* role);
1985
1986 // Returns a state constant.
1987 virtual wxAccStatus GetState(int childId, long* state);
1988
1989 // Returns a localized string representing the value for the object
1990 // or child.
1991 virtual wxAccStatus GetValue(int childId, wxString* strValue);
1992
1993 // Selects the object or child.
1994 virtual wxAccStatus Select(int childId, wxAccSelectionFlags selectFlags);
1995
1996 // Gets the window with the keyboard focus.
1997 // If childId is 0 and child is NULL, no object in
1998 // this subhierarchy has the focus.
1999 // If this object has the focus, child should be 'this'.
2000 virtual wxAccStatus GetFocus(int* childId, wxAccessible** child);
2001
2002 #if wxUSE_VARIANT
2003 // Gets a variant representing the selected children
2004 // of this object.
2005 // Acceptable values:
2006 // - a null variant (IsNull() returns true)
2007 // - a list variant (GetType() == wxT("list")
2008 // - an integer representing the selected child element,
2009 // or 0 if this object is selected (GetType() == wxT("long")
2010 // - a "void*" pointer to a wxAccessible child object
2011 virtual wxAccStatus GetSelections(wxVariant* selections);
2012 #endif // wxUSE_VARIANT
2013 };
2014
2015 #endif // wxUSE_ACCESSIBILITY
2016
2017
2018 #endif // _WX_WINDOW_H_BASE_