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