added Get(Class)DefaultAttributes()
[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) wxWindows team
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
11
12 #ifndef _WX_WINDOW_H_BASE_
13 #define _WX_WINDOW_H_BASE_
14
15 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
16 #pragma interface "windowbase.h"
17 #endif
18
19 // ----------------------------------------------------------------------------
20 // headers which we must include here
21 // ----------------------------------------------------------------------------
22
23 #include "wx/event.h" // the base class
24
25 #include "wx/list.h" // defines wxWindowList
26
27 #include "wx/cursor.h" // we have member variables of these classes
28 #include "wx/font.h" // so we can't do without them
29 #include "wx/colour.h"
30 #include "wx/region.h"
31 #include "wx/utils.h"
32
33 #include "wx/validate.h" // for wxDefaultValidator (always include it)
34
35 #if wxUSE_PALETTE
36 #include "wx/palette.h"
37 #endif // wxUSE_PALETTE
38
39 #if wxUSE_ACCEL
40 #include "wx/accel.h"
41 #endif // wxUSE_ACCEL
42
43 #if wxUSE_ACCESSIBILITY
44 #include "wx/access.h"
45 #endif
46
47 // when building wxUniv/Foo we don't want the code for native menu use to be
48 // compiled in - it should only be used when building real wxFoo
49 #ifdef __WXUNIVERSAL__
50 #define wxUSE_MENUS_NATIVE 0
51 #else // __WXMSW__
52 #define wxUSE_MENUS_NATIVE wxUSE_MENUS
53 #endif // __WXUNIVERSAL__/__WXMSW__
54
55 // ----------------------------------------------------------------------------
56 // forward declarations
57 // ----------------------------------------------------------------------------
58
59 class WXDLLEXPORT wxCaret;
60 class WXDLLEXPORT wxControl;
61 class WXDLLEXPORT wxCursor;
62 class WXDLLEXPORT wxDC;
63 class WXDLLEXPORT wxDropTarget;
64 class WXDLLEXPORT wxItemResource;
65 class WXDLLEXPORT wxLayoutConstraints;
66 class WXDLLEXPORT wxResourceTable;
67 class WXDLLEXPORT wxSizer;
68 class WXDLLEXPORT wxToolTip;
69 class WXDLLEXPORT wxWindowBase;
70 class WXDLLEXPORT wxWindow;
71
72 #if wxUSE_ACCESSIBILITY
73 class WXDLLEXPORT wxAccessible;
74 #endif
75
76 // ----------------------------------------------------------------------------
77 // helper stuff used by wxWindow
78 // ----------------------------------------------------------------------------
79
80 // struct containing all the visual attributes of a control
81 struct WXDLLEXPORT wxVisualAttributes
82 {
83 // the font used for control label/text inside it
84 wxFont font;
85
86 // the foreground colour
87 wxColour colFg;
88
89 // the background colour, may be wxNullColour if the controls background
90 // colour is not solid
91 wxColour colBg;
92 };
93
94 // different window variants, on platforms like eg mac uses different
95 // rendering sizes
96 enum wxWindowVariant
97 {
98 wxWINDOW_VARIANT_NORMAL, // Normal size
99 wxWINDOW_VARIANT_SMALL, // Smaller size (about 25 % smaller than normal)
100 wxWINDOW_VARIANT_MINI, // Mini size (about 33 % smaller than normal)
101 wxWINDOW_VARIANT_LARGE, // Large size (about 25 % larger than normal)
102 wxWINDOW_VARIANT_MAX
103 };
104
105 // ----------------------------------------------------------------------------
106 // (pseudo)template list classes
107 // ----------------------------------------------------------------------------
108
109 WX_DECLARE_LIST_3(wxWindow, wxWindowBase, wxWindowList, wxWindowListNode, class WXDLLEXPORT);
110
111 // ----------------------------------------------------------------------------
112 // global variables
113 // ----------------------------------------------------------------------------
114
115 WXDLLEXPORT_DATA(extern wxWindowList) wxTopLevelWindows;
116
117 // ----------------------------------------------------------------------------
118 // wxWindowBase is the base class for all GUI controls/widgets, this is the public
119 // interface of this class.
120 //
121 // Event handler: windows have themselves as their event handlers by default,
122 // but their event handlers could be set to another object entirely. This
123 // separation can reduce the amount of derivation required, and allow
124 // alteration of a window's functionality (e.g. by a resource editor that
125 // temporarily switches event handlers).
126 // ----------------------------------------------------------------------------
127
128 class WXDLLEXPORT wxWindowBase : public wxEvtHandler
129 {
130 public:
131 // creating the window
132 // -------------------
133
134 // default ctor, initializes everything which can be initialized before
135 // Create()
136 wxWindowBase() ;
137
138 // pseudo ctor (can't be virtual, called from ctor)
139 bool CreateBase(wxWindowBase *parent,
140 wxWindowID winid,
141 const wxPoint& pos = wxDefaultPosition,
142 const wxSize& size = wxDefaultSize,
143 long style = 0,
144 const wxValidator& validator = wxDefaultValidator,
145 const wxString& name = wxPanelNameStr);
146
147 virtual ~wxWindowBase();
148
149 // deleting the window
150 // -------------------
151
152 // ask the window to close itself, return true if the event handler
153 // honoured our request
154 bool Close( bool force = false );
155
156 // the following functions delete the C++ objects (the window itself
157 // or its children) as well as the GUI windows and normally should
158 // never be used directly
159
160 // delete window unconditionally (dangerous!), returns true if ok
161 virtual bool Destroy();
162 // delete all children of this window, returns true if ok
163 bool DestroyChildren();
164
165 // is the window being deleted?
166 bool IsBeingDeleted() const { return m_isBeingDeleted; }
167
168 // window attributes
169 // -----------------
170
171 // NB: in future versions of wxWindows Set/GetTitle() will only work
172 // with the top level windows (such as dialogs and frames) and
173 // Set/GetLabel() only with the other ones (i.e. all controls).
174
175 // the title (or label, see below) of the window: the text which the
176 // window shows
177 virtual void SetTitle( const wxString& WXUNUSED(title) ) {}
178 virtual wxString GetTitle() const { return wxEmptyString; }
179
180 // label is just the same as the title (but for, e.g., buttons it
181 // makes more sense to speak about labels)
182 virtual void SetLabel(const wxString& label) { SetTitle(label); }
183 virtual wxString GetLabel() const { return GetTitle(); }
184
185 // the window name is used for ressource setting in X, it is not the
186 // same as the window title/label
187 virtual void SetName( const wxString &name ) { m_windowName = name; }
188 virtual wxString GetName() const { return m_windowName; }
189
190 // sets the window variant, calls internally DoSetVariant if variant has changed
191 void SetWindowVariant( wxWindowVariant variant ) ;
192 wxWindowVariant GetWindowVariant() const { return m_windowVariant ; }
193
194
195 // window id uniquely identifies the window among its siblings unless
196 // it is -1 which means "don't care"
197 void SetId( wxWindowID winid ) { m_windowId = winid; }
198 wxWindowID GetId() const { return m_windowId; }
199
200 // generate a control id for the controls which were not given one by
201 // user
202 static int NewControlId() { return --ms_lastControlId; }
203 // get the id of the control following the one with the given
204 // (autogenerated) id
205 static int NextControlId(int winid) { return winid - 1; }
206 // get the id of the control preceding the one with the given
207 // (autogenerated) id
208 static int PrevControlId(int winid) { return winid + 1; }
209
210 // moving/resizing
211 // ---------------
212
213 // set the window size and/or position
214 void SetSize( int x, int y, int width, int height,
215 int sizeFlags = wxSIZE_AUTO )
216 { DoSetSize(x, y, width, height, sizeFlags); }
217
218 void SetSize( int width, int height )
219 { DoSetSize( -1, -1, width, height, wxSIZE_USE_EXISTING ); }
220
221 void SetSize( const wxSize& size )
222 { SetSize( size.x, size.y); }
223
224 void SetSize(const wxRect& rect, int sizeFlags = wxSIZE_AUTO)
225 { DoSetSize(rect.x, rect.y, rect.width, rect.height, sizeFlags); }
226
227 void Move(int x, int y, int flags = wxSIZE_USE_EXISTING)
228 { DoSetSize(x, y, -1, -1, flags); }
229
230 void Move(const wxPoint& pt, int flags = wxSIZE_USE_EXISTING)
231 { Move(pt.x, pt.y, flags); }
232
233 // Z-order
234 virtual void Raise() = 0;
235 virtual void Lower() = 0;
236
237 // client size is the size of area available for subwindows
238 void SetClientSize( int width, int height )
239 { DoSetClientSize(width, height); }
240
241 void SetClientSize( const wxSize& size )
242 { DoSetClientSize(size.x, size.y); }
243
244 void SetClientSize(const wxRect& rect)
245 { SetClientSize( rect.width, rect.height ); }
246
247 // get the window position and/or size (pointers may be NULL)
248 void GetPosition( int *x, int *y ) const { DoGetPosition(x, y); }
249 wxPoint GetPosition() const
250 {
251 int w, h;
252 DoGetPosition(&w, &h);
253
254 return wxPoint(w, h);
255 }
256
257 void SetPosition( const wxPoint& pt ) { Move( pt ) ; }
258
259 void GetSize( int *w, int *h ) const { DoGetSize(w, h); }
260 wxSize GetSize() const
261 {
262 int w, h;
263 DoGetSize(& w, & h);
264 return wxSize(w, h);
265 }
266
267 wxRect GetRect() const
268 {
269 int x, y, w, h;
270 GetPosition(& x, & y);
271 GetSize(& w, & h);
272
273 return wxRect(x, y, w, h);
274 }
275
276 void GetClientSize( int *w, int *h ) const { DoGetClientSize(w, h); }
277 wxSize GetClientSize() const
278 {
279 int w, h;
280 DoGetClientSize(& w, & h);
281
282 return wxSize(w, h);
283 }
284
285 // get the origin of the client area of the window relative to the
286 // window top left corner (the client area may be shifted because of
287 // the borders, scrollbars, other decorations...)
288 virtual wxPoint GetClientAreaOrigin() const;
289
290 // get the client rectangle in window (i.e. client) coordinates
291 wxRect GetClientRect() const
292 {
293 return wxRect(GetClientAreaOrigin(), GetClientSize());
294 }
295
296 // get the size best suited for the window (in fact, minimal
297 // acceptable size using which it will still look "nice")
298 wxSize GetBestSize() const { return DoGetBestSize(); }
299 void GetBestSize(int *w, int *h) const
300 {
301 wxSize s = DoGetBestSize();
302 if ( w )
303 *w = s.x;
304 if ( h )
305 *h = s.y;
306 }
307
308 // There are times (and windows) where 'Best' size and 'Min' size
309 // are vastly out of sync. This should be remedied somehow, but in
310 // the meantime, this method will return the larger of BestSize
311 // (the window's smallest legible size), and any user specified
312 // MinSize hint.
313 wxSize GetAdjustedBestSize() const
314 {
315 wxSize s( DoGetBestSize() );
316 return wxSize( wxMax( s.x, GetMinWidth() ), wxMax( s.y, GetMinHeight() ) );
317 }
318
319 // the generic centre function - centers the window on parent by`
320 // default or on screen if it doesn't have parent or
321 // wxCENTER_ON_SCREEN flag is given
322 void Centre( int direction = wxBOTH );
323 void Center( int direction = wxBOTH ) { Centre(direction); }
324
325 // centre on screen (only works for top level windows)
326 void CentreOnScreen(int dir = wxBOTH) { Centre(dir | wxCENTER_ON_SCREEN); }
327 void CenterOnScreen(int dir = wxBOTH) { CentreOnScreen(dir); }
328
329 // centre with respect to the the parent window
330 void CentreOnParent(int dir = wxBOTH) { Centre(dir | wxCENTER_FRAME); }
331 void CenterOnParent(int dir = wxBOTH) { CentreOnParent(dir); }
332
333 // set window size to wrap around its children
334 virtual void Fit();
335
336 // set virtual size to satisfy children
337 virtual void FitInside();
338
339 // set min/max size of the window
340 virtual void SetSizeHints( int minW, int minH,
341 int maxW = -1, int maxH = -1,
342 int incW = -1, int incH = -1 );
343
344 virtual void SetVirtualSizeHints( int minW, int minH,
345 int maxW = -1, int maxH = -1 );
346
347 virtual int GetMinWidth() const { return m_minWidth; }
348 virtual int GetMinHeight() const { return m_minHeight; }
349 int GetMaxWidth() const { return m_maxWidth; }
350 int GetMaxHeight() const { return m_maxHeight; }
351
352 // Override this method to control the values given to Sizers etc.
353 virtual wxSize GetMaxSize() const { return wxSize( m_maxWidth, m_maxHeight ); }
354
355 // Methods for accessing the virtual size of a window. For most
356 // windows this is just the client area of the window, but for
357 // some like scrolled windows it is more or less independent of
358 // the screen window size. You may override the DoXXXVirtual
359 // methods below for classes where that is is the case.
360
361 void SetVirtualSize( const wxSize &size ) { DoSetVirtualSize( size.x, size.y ); }
362 void SetVirtualSize( int x, int y ) { DoSetVirtualSize( x, y ); }
363
364 wxSize GetVirtualSize() const { return DoGetVirtualSize(); }
365 void GetVirtualSize( int *x, int *y ) const
366 {
367 wxSize s( DoGetVirtualSize() );
368
369 if( x )
370 *x = s.GetWidth();
371 if( y )
372 *y = s.GetHeight();
373 }
374
375 // Override these methods for windows that have a virtual size
376 // independent of their client size. eg. the virtual area of a
377 // wxScrolledWindow. Default is to alias VirtualSize to ClientSize.
378
379 virtual void DoSetVirtualSize( int x, int y );
380 virtual wxSize DoGetVirtualSize() const; // { return m_virtualSize; }
381
382 // Return the largest of ClientSize and BestSize (as determined
383 // by a sizer, interior children, or other means)
384
385 virtual wxSize GetBestVirtualSize() const
386 {
387 wxSize client( GetClientSize() );
388 wxSize best( GetBestSize() );
389
390 return wxSize( wxMax( client.x, best.x ), wxMax( client.y, best.y ) );
391 }
392
393 // window state
394 // ------------
395
396 // returns true if window was shown/hidden, false if the nothing was
397 // done (window was already shown/hidden)
398 virtual bool Show( bool show = true );
399 bool Hide() { return Show(false); }
400
401 // returns true if window was enabled/disabled, false if nothing done
402 virtual bool Enable( bool enable = true );
403 bool Disable() { return Enable(false); }
404
405 bool IsShown() const { return m_isShown; }
406 bool IsEnabled() const { return m_isEnabled; }
407
408 // get/set window style (setting style won't update the window and so
409 // is only useful for internal usage)
410 virtual void SetWindowStyleFlag( long style ) { m_windowStyle = style; }
411 virtual long GetWindowStyleFlag() const { return m_windowStyle; }
412
413 // just some (somewhat shorter) synonims
414 void SetWindowStyle( long style ) { SetWindowStyleFlag(style); }
415 long GetWindowStyle() const { return GetWindowStyleFlag(); }
416
417 bool HasFlag(int flag) const { return (m_windowStyle & flag) != 0; }
418 virtual bool IsRetained() const { return HasFlag(wxRETAINED); }
419
420 // extra style: the less often used style bits which can't be set with
421 // SetWindowStyleFlag()
422 virtual void SetExtraStyle(long exStyle) { m_exStyle = exStyle; }
423 long GetExtraStyle() const { return m_exStyle; }
424
425 // make the window modal (all other windows unresponsive)
426 virtual void MakeModal(bool modal = true);
427
428 virtual void SetThemeEnabled(bool enableTheme) { m_themeEnabled = enableTheme; }
429 virtual bool GetThemeEnabled() const { return m_themeEnabled; }
430
431 // Returns true if this class should have the background colour
432 // changed to match the parent window's theme. For example when a
433 // page is added to a notebook it and it's children may need to have
434 // the colours adjusted depending on the current theme settings, but
435 // not all windows/controls can do this without looking wrong.
436 virtual void ApplyParentThemeBackground(const wxColour& WXUNUSED(bg))
437 { /* do nothing */ }
438
439 // returns true if this window should inherit its parent colours on
440 // creation
441 virtual bool ShouldInheritColours() const { return false; }
442
443
444 // focus and keyboard handling
445 // ---------------------------
446
447 // set focus to this window
448 virtual void SetFocus() = 0;
449
450 // set focus to this window as the result of a keyboard action
451 virtual void SetFocusFromKbd() { SetFocus(); }
452
453 // return the window which currently has the focus or NULL
454 static wxWindow *FindFocus() /* = 0: implement in derived classes */;
455
456 // can this window have focus?
457 virtual bool AcceptsFocus() const { return IsShown() && IsEnabled(); }
458
459 // can this window be given focus by keyboard navigation? if not, the
460 // only way to give it focus (provided it accepts it at all) is to
461 // click it
462 virtual bool AcceptsFocusFromKeyboard() const { return AcceptsFocus(); }
463
464 // NB: these methods really don't belong here but with the current
465 // class hierarchy there is no other place for them :-(
466
467 // get the default child of this parent, i.e. the one which is
468 // activated by pressing <Enter>
469 virtual wxWindow *GetDefaultItem() const { return NULL; }
470
471 // set this child as default, return the old default
472 virtual wxWindow *SetDefaultItem(wxWindow * WXUNUSED(child))
473 { return NULL; }
474
475 // set this child as temporary default
476 virtual void SetTmpDefaultItem(wxWindow * WXUNUSED(win)) { }
477
478 // parent/children relations
479 // -------------------------
480
481 // get the list of children
482 const wxWindowList& GetChildren() const { return m_children; }
483 wxWindowList& GetChildren() { return m_children; }
484
485 // needed just for extended runtime
486 const wxWindowList& GetWindowChildren() const { return GetChildren() ; }
487
488 // get the parent or the parent of the parent
489 wxWindow *GetParent() const { return m_parent; }
490 inline wxWindow *GetGrandParent() const;
491
492 // is this window a top level one?
493 virtual bool IsTopLevel() const;
494
495 // it doesn't really change parent, use ReParent() instead
496 void SetParent( wxWindowBase *parent ) { m_parent = (wxWindow *)parent; }
497 // change the real parent of this window, return true if the parent
498 // was changed, false otherwise (error or newParent == oldParent)
499 virtual bool Reparent( wxWindowBase *newParent );
500
501 // implementation mostly
502 virtual void AddChild( wxWindowBase *child );
503 virtual void RemoveChild( wxWindowBase *child );
504
505 // looking for windows
506 // -------------------
507
508 // find window among the descendants of this one either by id or by
509 // name (return NULL if not found)
510 wxWindow *FindWindow( long winid );
511 wxWindow *FindWindow( const wxString& name );
512
513 // Find a window among any window (all return NULL if not found)
514 static wxWindow *FindWindowById( long winid, const wxWindow *parent = NULL );
515 static wxWindow *FindWindowByName( const wxString& name,
516 const wxWindow *parent = NULL );
517 static wxWindow *FindWindowByLabel( const wxString& label,
518 const wxWindow *parent = NULL );
519
520 // event handler stuff
521 // -------------------
522
523 // get the current event handler
524 wxEvtHandler *GetEventHandler() const { return m_eventHandler; }
525
526 // replace the event handler (allows to completely subclass the
527 // window)
528 void SetEventHandler( wxEvtHandler *handler ) { m_eventHandler = handler; }
529
530 // push/pop event handler: allows to chain a custom event handler to
531 // alreasy existing ones
532 void PushEventHandler( wxEvtHandler *handler );
533 wxEvtHandler *PopEventHandler( bool deleteHandler = false );
534
535 // find the given handler in the event handler chain and remove (but
536 // not delete) it from the event handler chain, return true if it was
537 // found and false otherwise (this also results in an assert failure so
538 // this function should only be called when the handler is supposed to
539 // be there)
540 bool RemoveEventHandler(wxEvtHandler *handler);
541
542 // validators
543 // ----------
544
545 #if wxUSE_VALIDATORS
546 // a window may have an associated validator which is used to control
547 // user input
548 virtual void SetValidator( const wxValidator &validator );
549 virtual wxValidator *GetValidator() { return m_windowValidator; }
550 #endif // wxUSE_VALIDATORS
551
552
553 // dialog oriented functions
554 // -------------------------
555
556 // validate the correctness of input, return true if ok
557 virtual bool Validate();
558
559 // transfer data between internal and GUI representations
560 virtual bool TransferDataToWindow();
561 virtual bool TransferDataFromWindow();
562
563 virtual void InitDialog();
564
565 #if wxUSE_ACCEL
566 // accelerators
567 // ------------
568 virtual void SetAcceleratorTable( const wxAcceleratorTable& accel )
569 { m_acceleratorTable = accel; }
570 wxAcceleratorTable *GetAcceleratorTable()
571 { return &m_acceleratorTable; }
572
573 #endif // wxUSE_ACCEL
574
575 #if wxUSE_HOTKEY
576 // hot keys (system wide accelerators)
577 // -----------------------------------
578
579 virtual bool RegisterHotKey(int hotkeyId, int modifiers, int keycode);
580 virtual bool UnregisterHotKey(int hotkeyId);
581 #endif // wxUSE_HOTKEY
582
583
584 // dialog units translations
585 // -------------------------
586
587 wxPoint ConvertPixelsToDialog( const wxPoint& pt );
588 wxPoint ConvertDialogToPixels( const wxPoint& pt );
589 wxSize ConvertPixelsToDialog( const wxSize& sz )
590 {
591 wxPoint pt(ConvertPixelsToDialog(wxPoint(sz.x, sz.y)));
592
593 return wxSize(pt.x, pt.y);
594 }
595
596 wxSize ConvertDialogToPixels( const wxSize& sz )
597 {
598 wxPoint pt(ConvertDialogToPixels(wxPoint(sz.x, sz.y)));
599
600 return wxSize(pt.x, pt.y);
601 }
602
603 // mouse functions
604 // ---------------
605
606 // move the mouse to the specified position
607 virtual void WarpPointer(int x, int y) = 0;
608
609 // start or end mouse capture, these functions maintain the stack of
610 // windows having captured the mouse and after calling ReleaseMouse()
611 // the mouse is not released but returns to the window which had had
612 // captured it previously (if any)
613 void CaptureMouse();
614 void ReleaseMouse();
615
616 // get the window which currently captures the mouse or NULL
617 static wxWindow *GetCapture();
618
619 // does this window have the capture?
620 virtual bool HasCapture() const
621 { return (wxWindow *)this == GetCapture(); }
622
623 // painting the window
624 // -------------------
625
626 // mark the specified rectangle (or the whole window) as "dirty" so it
627 // will be repainted
628 virtual void Refresh( bool eraseBackground = true,
629 const wxRect *rect = (const wxRect *) NULL ) = 0;
630
631 // a less awkward wrapper for Refresh
632 void RefreshRect(const wxRect& rect) { Refresh(true, &rect); }
633
634 // repaint all invalid areas of the window immediately
635 virtual void Update() { }
636
637 // clear the window background
638 virtual void ClearBackground();
639
640 // freeze the window: don't redraw it until it is thawed
641 virtual void Freeze() { }
642
643 // thaw the window: redraw it after it had been frozen
644 virtual void Thaw() { }
645
646 // adjust DC for drawing on this window
647 virtual void PrepareDC( wxDC & WXUNUSED(dc) ) { }
648
649 // the update region of the window contains the areas which must be
650 // repainted by the program
651 const wxRegion& GetUpdateRegion() const { return m_updateRegion; }
652 wxRegion& GetUpdateRegion() { return m_updateRegion; }
653
654 // get the update rectangleregion bounding box in client coords
655 wxRect GetUpdateClientRect() const;
656
657 // these functions verify whether the given point/rectangle belongs to
658 // (or at least intersects with) the update region
659 bool IsExposed( int x, int y ) const;
660 bool IsExposed( int x, int y, int w, int h ) const;
661
662 bool IsExposed( const wxPoint& pt ) const
663 { return IsExposed(pt.x, pt.y); }
664 bool IsExposed( const wxRect& rect ) const
665 { return IsExposed(rect.x, rect.y, rect.width, rect.height); }
666
667 // colours, fonts and cursors
668 // --------------------------
669
670 // get the default attributes for the controls of this class: we
671 // provide a virtual function which can be used to query the default
672 // attributes of an existing control and a static function which can
673 // be used even when no existing object of the given class is
674 // available, but which won't return any styles specific to this
675 // particular control, of course (e.g. "Ok" button might have
676 // different -- bold for example -- font)
677 virtual wxVisualAttributes GetDefaultAttributes() const
678 {
679 return GetClassDefaultAttributes(GetWindowVariant());
680 }
681
682 static wxVisualAttributes
683 GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
684
685 // set/retrieve the window colours (system defaults are used by
686 // default): Set functions return true if colour was changed
687 virtual bool SetBackgroundColour( const wxColour &colour );
688 virtual bool SetForegroundColour( const wxColour &colour );
689
690 wxColour GetBackgroundColour() const;
691 wxColour GetForegroundColour() const;
692
693 // set/retrieve the cursor for this window (SetCursor() returns true
694 // if the cursor was really changed)
695 virtual bool SetCursor( const wxCursor &cursor );
696 const wxCursor& GetCursor() const { return m_cursor; }
697 wxCursor& GetCursor() { return m_cursor; }
698
699 // set/retrieve the font for the window (SetFont() returns true if the
700 // font really changed)
701 virtual bool SetFont( const wxFont &font ) = 0;
702 const wxFont& GetFont() const { return DoGetFont(); }
703 wxFont& GetFont() { return DoGetFont(); }
704
705 #if wxUSE_CARET
706 // associate a caret with the window
707 void SetCaret(wxCaret *caret);
708 // get the current caret (may be NULL)
709 wxCaret *GetCaret() const { return m_caret; }
710 #endif // wxUSE_CARET
711
712 // get the (average) character size for the current font
713 virtual int GetCharHeight() const = 0;
714 virtual int GetCharWidth() const = 0;
715
716 // get the width/height/... of the text using current or specified
717 // font
718 virtual void GetTextExtent(const wxString& string,
719 int *x, int *y,
720 int *descent = (int *) NULL,
721 int *externalLeading = (int *) NULL,
722 const wxFont *theFont = (const wxFont *) NULL)
723 const = 0;
724
725 // client <-> screen coords
726 // ------------------------
727
728 // translate to/from screen/client coordinates (pointers may be NULL)
729 void ClientToScreen( int *x, int *y ) const
730 { DoClientToScreen(x, y); }
731 void ScreenToClient( int *x, int *y ) const
732 { DoScreenToClient(x, y); }
733
734 // wxPoint interface to do the same thing
735 wxPoint ClientToScreen(const wxPoint& pt) const
736 {
737 int x = pt.x, y = pt.y;
738 DoClientToScreen(&x, &y);
739
740 return wxPoint(x, y);
741 }
742
743 wxPoint ScreenToClient(const wxPoint& pt) const
744 {
745 int x = pt.x, y = pt.y;
746 DoScreenToClient(&x, &y);
747
748 return wxPoint(x, y);
749 }
750
751 // test where the given (in client coords) point lies
752 wxHitTest HitTest(wxCoord x, wxCoord y) const
753 { return DoHitTest(x, y); }
754
755 wxHitTest HitTest(const wxPoint& pt) const
756 { return DoHitTest(pt.x, pt.y); }
757
758 // misc
759 // ----
760
761 // get the window border style from the given flags: this is different from
762 // simply doing flags & wxBORDER_MASK because it uses GetDefaultBorder() to
763 // translate wxBORDER_DEFAULT to something reasonable
764 wxBorder GetBorder(long flags) const;
765
766 // get border for the flags of this window
767 wxBorder GetBorder() const { return GetBorder(GetWindowStyleFlag()); }
768
769 // send wxUpdateUIEvents to this window, and children if recurse is true
770 virtual void UpdateWindowUI(long flags = wxUPDATE_UI_NONE);
771
772 // do the window-specific processing after processing the update event
773 virtual void DoUpdateWindowUI(wxUpdateUIEvent& event) ;
774
775 #if wxUSE_MENUS
776 bool PopupMenu( wxMenu *menu, const wxPoint& pos )
777 { return DoPopupMenu(menu, pos.x, pos.y); }
778 bool PopupMenu( wxMenu *menu, int x, int y )
779 { return DoPopupMenu(menu, x, y); }
780 #endif // wxUSE_MENUS
781
782 // scrollbars
783 // ----------
784
785 // does the window have the scrollbar for this orientation?
786 bool HasScrollbar(int orient) const
787 {
788 return (m_windowStyle &
789 (orient == wxHORIZONTAL ? wxHSCROLL : wxVSCROLL)) != 0;
790 }
791
792 // configure the window scrollbars
793 virtual void SetScrollbar( int orient,
794 int pos,
795 int thumbvisible,
796 int range,
797 bool refresh = true ) = 0;
798 virtual void SetScrollPos( int orient, int pos, bool refresh = true ) = 0;
799 virtual int GetScrollPos( int orient ) const = 0;
800 virtual int GetScrollThumb( int orient ) const = 0;
801 virtual int GetScrollRange( int orient ) const = 0;
802
803 // scroll window to the specified position
804 virtual void ScrollWindow( int dx, int dy,
805 const wxRect* rect = (wxRect *) NULL ) = 0;
806
807 // scrolls window by line/page: note that not all controls support this
808 //
809 // return true if the position changed, false otherwise
810 virtual bool ScrollLines(int WXUNUSED(lines)) { return false; }
811 virtual bool ScrollPages(int WXUNUSED(pages)) { return false; }
812
813 // convenient wrappers for ScrollLines/Pages
814 bool LineUp() { return ScrollLines(-1); }
815 bool LineDown() { return ScrollLines(1); }
816 bool PageUp() { return ScrollPages(-1); }
817 bool PageDown() { return ScrollPages(1); }
818
819 // context-sensitive help
820 // ----------------------
821
822 // these are the convenience functions wrapping wxHelpProvider methods
823
824 #if wxUSE_HELP
825 // associate this help text with this window
826 void SetHelpText(const wxString& text);
827 // associate this help text with all windows with the same id as this
828 // one
829 void SetHelpTextForId(const wxString& text);
830 // get the help string associated with this window (may be empty)
831 wxString GetHelpText() const;
832 #endif // wxUSE_HELP
833
834 // tooltips
835 // --------
836
837 #if wxUSE_TOOLTIPS
838 // the easiest way to set a tooltip for a window is to use this method
839 void SetToolTip( const wxString &tip );
840 // attach a tooltip to the window
841 void SetToolTip( wxToolTip *tip ) { DoSetToolTip(tip); }
842 // get the associated tooltip or NULL if none
843 wxToolTip* GetToolTip() const { return m_tooltip; }
844 wxString GetToolTipText() const ;
845 #endif // wxUSE_TOOLTIPS
846
847 // drag and drop
848 // -------------
849 #if wxUSE_DRAG_AND_DROP
850 // set/retrieve the drop target associated with this window (may be
851 // NULL; it's owned by the window and will be deleted by it)
852 virtual void SetDropTarget( wxDropTarget *dropTarget ) = 0;
853 virtual wxDropTarget *GetDropTarget() const { return m_dropTarget; }
854 #endif // wxUSE_DRAG_AND_DROP
855
856 // constraints and sizers
857 // ----------------------
858 #if wxUSE_CONSTRAINTS
859 // set the constraints for this window or retrieve them (may be NULL)
860 void SetConstraints( wxLayoutConstraints *constraints );
861 wxLayoutConstraints *GetConstraints() const { return m_constraints; }
862
863 // implementation only
864 void UnsetConstraints(wxLayoutConstraints *c);
865 wxWindowList *GetConstraintsInvolvedIn() const
866 { return m_constraintsInvolvedIn; }
867 void AddConstraintReference(wxWindowBase *otherWin);
868 void RemoveConstraintReference(wxWindowBase *otherWin);
869 void DeleteRelatedConstraints();
870 void ResetConstraints();
871
872 // these methods may be overriden for special layout algorithms
873 virtual void SetConstraintSizes(bool recurse = true);
874 virtual bool LayoutPhase1(int *noChanges);
875 virtual bool LayoutPhase2(int *noChanges);
876 virtual bool DoPhase(int phase);
877
878 // these methods are virtual but normally won't be overridden
879 virtual void SetSizeConstraint(int x, int y, int w, int h);
880 virtual void MoveConstraint(int x, int y);
881 virtual void GetSizeConstraint(int *w, int *h) const ;
882 virtual void GetClientSizeConstraint(int *w, int *h) const ;
883 virtual void GetPositionConstraint(int *x, int *y) const ;
884
885 #endif // wxUSE_CONSTRAINTS
886
887 // when using constraints or sizers, it makes sense to update
888 // children positions automatically whenever the window is resized
889 // - this is done if autoLayout is on
890 void SetAutoLayout( bool autoLayout ) { m_autoLayout = autoLayout; }
891 bool GetAutoLayout() const { return m_autoLayout; }
892
893 // lay out the window and its children
894 virtual bool Layout();
895
896 // sizers
897 void SetSizer(wxSizer *sizer, bool deleteOld = true );
898 void SetSizerAndFit( wxSizer *sizer, bool deleteOld = true );
899
900 wxSizer *GetSizer() const { return m_windowSizer; }
901
902 // Track if this window is a member of a sizer
903 void SetContainingSizer(wxSizer* sizer)
904 {
905 // adding a window to a sizer twice is going to result in fatal and
906 // hard to debug problems later because when deleting the second
907 // associated wxSizerItem we're going to dereference a dangling
908 // pointer; so try to detect this as early as possible
909 wxASSERT_MSG( !sizer || m_containingSizer != sizer,
910 _T("Adding a window to the same sizer twice?") );
911
912 m_containingSizer = sizer;
913 }
914 wxSizer *GetContainingSizer() const { return m_containingSizer; }
915
916 // accessibility
917 // ----------------------
918 #if wxUSE_ACCESSIBILITY
919 // Override to create a specific accessible object.
920 virtual wxAccessible* CreateAccessible();
921
922 // Sets the accessible object.
923 void SetAccessible(wxAccessible* accessible) ;
924
925 // Returns the accessible object.
926 wxAccessible* GetAccessible() { return m_accessible; };
927
928 // Returns the accessible object, creating if necessary.
929 wxAccessible* GetOrCreateAccessible() ;
930 #endif
931
932 // implementation
933 // --------------
934
935 // event handlers
936 void OnSysColourChanged( wxSysColourChangedEvent& event );
937 void OnInitDialog( wxInitDialogEvent &event );
938 void OnMiddleClick( wxMouseEvent& event );
939 #if wxUSE_HELP
940 void OnHelp(wxHelpEvent& event);
941 #endif // wxUSE_HELP
942
943 // virtual function for implementing internal idle
944 // behaviour
945 virtual void OnInternalIdle() {}
946
947 // call internal idle recursively
948 // void ProcessInternalIdle() ;
949
950 // get the handle of the window for the underlying window system: this
951 // is only used for wxWin itself or for user code which wants to call
952 // platform-specific APIs
953 virtual WXWidget GetHandle() const = 0;
954
955 #if wxUSE_PALETTE
956 // Store the palette used by DCs in wxWindow so that the dcs can share
957 // a palette. And we can respond to palette messages.
958 wxPalette GetPalette() const { return m_palette; }
959
960 // When palette is changed tell the DC to set the system palette to the
961 // new one.
962 void SetPalette(const wxPalette& pal);
963
964 // return true if we have a specific palette
965 bool HasCustomPalette() const { return m_hasCustomPalette; }
966
967 // return the first parent window with a custom palette or NULL
968 wxWindow *GetAncestorWithCustomPalette() const;
969 #endif // wxUSE_PALETTE
970
971 protected:
972 // event handling specific to wxWindow
973 virtual bool TryValidator(wxEvent& event);
974 virtual bool TryParent(wxEvent& event);
975
976
977 #if wxUSE_CONSTRAINTS
978 // satisfy the constraints for the windows but don't set the window sizes
979 void SatisfyConstraints();
980 #endif // wxUSE_CONSTRAINTS
981
982 // Send the wxWindowDestroyEvent
983 void SendDestroyEvent();
984
985 // the window id - a number which uniquely identifies a window among
986 // its siblings unless it is -1
987 wxWindowID m_windowId;
988
989 // the parent window of this window (or NULL) and the list of the children
990 // of this window
991 wxWindow *m_parent;
992 wxWindowList m_children;
993
994 // the minimal allowed size for the window (no minimal size if variable(s)
995 // contain(s) -1)
996 int m_minWidth,
997 m_minHeight,
998 m_maxWidth,
999 m_maxHeight;
1000
1001 // event handler for this window: usually is just 'this' but may be
1002 // changed with SetEventHandler()
1003 wxEvtHandler *m_eventHandler;
1004
1005 #if wxUSE_VALIDATORS
1006 // associated validator or NULL if none
1007 wxValidator *m_windowValidator;
1008 #endif // wxUSE_VALIDATORS
1009
1010 #if wxUSE_DRAG_AND_DROP
1011 wxDropTarget *m_dropTarget;
1012 #endif // wxUSE_DRAG_AND_DROP
1013
1014 // visual window attributes
1015 wxCursor m_cursor;
1016 wxFont m_font; // see m_hasFont
1017 wxColour m_backgroundColour, // m_hasBgCol
1018 m_foregroundColour; // m_hasFgCol
1019
1020 #if wxUSE_CARET
1021 wxCaret *m_caret;
1022 #endif // wxUSE_CARET
1023
1024 // the region which should be repainted in response to paint event
1025 wxRegion m_updateRegion;
1026
1027 #if wxUSE_ACCEL
1028 // the accelerator table for the window which translates key strokes into
1029 // command events
1030 wxAcceleratorTable m_acceleratorTable;
1031 #endif // wxUSE_ACCEL
1032
1033 // the tooltip for this window (may be NULL)
1034 #if wxUSE_TOOLTIPS
1035 wxToolTip *m_tooltip;
1036 #endif // wxUSE_TOOLTIPS
1037
1038 // constraints and sizers
1039 #if wxUSE_CONSTRAINTS
1040 // the constraints for this window or NULL
1041 wxLayoutConstraints *m_constraints;
1042
1043 // constraints this window is involved in
1044 wxWindowList *m_constraintsInvolvedIn;
1045 #endif // wxUSE_CONSTRAINTS
1046
1047 // this window's sizer
1048 wxSizer *m_windowSizer;
1049
1050 // The sizer this window is a member of, if any
1051 wxSizer *m_containingSizer;
1052
1053 // Layout() window automatically when its size changes?
1054 bool m_autoLayout:1;
1055
1056 // window state
1057 bool m_isShown:1;
1058 bool m_isEnabled:1;
1059 bool m_isBeingDeleted:1;
1060
1061 // was the window colours/font explicitly changed by user?
1062 bool m_hasBgCol:1;
1063 bool m_hasFgCol:1;
1064 bool m_hasFont:1;
1065
1066 // window attributes
1067 long m_windowStyle,
1068 m_exStyle;
1069 wxString m_windowName;
1070 bool m_themeEnabled;
1071
1072 #if wxUSE_PALETTE
1073 wxPalette m_palette;
1074 bool m_hasCustomPalette;
1075 #endif // wxUSE_PALETTE
1076
1077 #if wxUSE_ACCESSIBILITY
1078 wxAccessible* m_accessible;
1079 #endif
1080 // Virtual size (scrolling)
1081 wxSize m_virtualSize;
1082
1083 int m_minVirtualWidth; // VirtualSizeHints
1084 int m_minVirtualHeight;
1085 int m_maxVirtualWidth;
1086 int m_maxVirtualHeight;
1087
1088 wxWindowVariant m_windowVariant ;
1089
1090 // override this to change the default (i.e. used when no style is
1091 // specified) border for the window class
1092 virtual wxBorder GetDefaultBorder() const;
1093
1094 // Get the default size for the new window if no explicit size given. TLWs
1095 // have their own default size so this is just for non top-level windows.
1096 static int WidthDefault(int w) { return w == -1 ? 20 : w; }
1097 static int HeightDefault(int h) { return h == -1 ? 20 : h; }
1098
1099 // set the best size for the control if the default size was given:
1100 // replaces the fields of size == -1 with the best values for them and
1101 // calls SetSize() if needed
1102 //
1103 // This function is rather unfortunately named.. it's really just a
1104 // smarter SetSize / convenience function for expanding wxDefaultSize.
1105 // Note that it does not influence the value returned by GetBestSize
1106 // at all.
1107 void SetBestSize(const wxSize& size)
1108 {
1109 // the size only needs to be changed if the current size is incomplete,
1110 // i.e. one of the components was specified as default -- so if both
1111 // were given, simply don't do anything
1112 if ( size.x == -1 || size.y == -1 )
1113 {
1114 wxSize sizeBest = DoGetBestSize();
1115 if ( size.x != -1 )
1116 sizeBest.x = size.x;
1117 if ( size.y != -1 )
1118 sizeBest.y = size.y;
1119
1120 SetSize(sizeBest);
1121 }
1122 }
1123
1124 // more pure virtual functions
1125 // ---------------------------
1126
1127 // NB: we must have DoSomething() function when Something() is an overloaded
1128 // method: indeed, we can't just have "virtual Something()" in case when
1129 // the function is overloaded because then we'd have to make virtual all
1130 // the variants (otherwise only the virtual function may be called on a
1131 // pointer to derived class according to C++ rules) which is, in
1132 // general, absolutely not needed. So instead we implement all
1133 // overloaded Something()s in terms of DoSomething() which will be the
1134 // only one to be virtual.
1135
1136 // coordinates translation
1137 virtual void DoClientToScreen( int *x, int *y ) const = 0;
1138 virtual void DoScreenToClient( int *x, int *y ) const = 0;
1139
1140 virtual wxHitTest DoHitTest(wxCoord x, wxCoord y) const;
1141
1142 // capture/release the mouse, used by Capture/ReleaseMouse()
1143 virtual void DoCaptureMouse() = 0;
1144 virtual void DoReleaseMouse() = 0;
1145
1146 // retrieve the position/size of the window
1147 virtual void DoGetPosition( int *x, int *y ) const = 0;
1148 virtual void DoGetSize( int *width, int *height ) const = 0;
1149 virtual void DoGetClientSize( int *width, int *height ) const = 0;
1150
1151 // get the size which best suits the window: for a control, it would be
1152 // the minimal size which doesn't truncate the control, for a panel - the
1153 // same size as it would have after a call to Fit()
1154 virtual wxSize DoGetBestSize() const;
1155
1156 // this is the virtual function to be overriden in any derived class which
1157 // wants to change how SetSize() or Move() works - it is called by all
1158 // versions of these functions in the base class
1159 virtual void DoSetSize(int x, int y,
1160 int width, int height,
1161 int sizeFlags = wxSIZE_AUTO) = 0;
1162
1163 // same as DoSetSize() for the client size
1164 virtual void DoSetClientSize(int width, int height) = 0;
1165
1166 // move the window to the specified location and resize it: this is called
1167 // from both DoSetSize() and DoSetClientSize() and would usually just
1168 // reposition this window except for composite controls which will want to
1169 // arrange themselves inside the given rectangle
1170 virtual void DoMoveWindow(int x, int y, int width, int height) = 0;
1171
1172 #if wxUSE_TOOLTIPS
1173 virtual void DoSetToolTip( wxToolTip *tip );
1174 #endif // wxUSE_TOOLTIPS
1175
1176 #if wxUSE_MENUS
1177 virtual bool DoPopupMenu( wxMenu *menu, int x, int y ) = 0;
1178 #endif // wxUSE_MENUS
1179
1180 // Makes an adjustment to the window position to make it relative to the
1181 // parents client area, e.g. if the parent is a frame with a toolbar, its
1182 // (0, 0) is just below the toolbar
1183 virtual void AdjustForParentClientOrigin(int& x, int& y,
1184 int sizeFlags = 0) const;
1185
1186 // implements the window variants
1187 virtual void DoSetWindowVariant( wxWindowVariant variant ) ;
1188
1189 private:
1190 // contains the last id generated by NewControlId
1191 static int ms_lastControlId;
1192
1193 // the stack of windows which have captured the mouse
1194 static struct WXDLLEXPORT wxWindowNext *ms_winCaptureNext;
1195
1196 // implementation of both const and non-const versions of GetFont()
1197 wxFont& DoGetFont() const;
1198
1199
1200 DECLARE_ABSTRACT_CLASS(wxWindowBase)
1201 DECLARE_NO_COPY_CLASS(wxWindowBase)
1202 DECLARE_EVENT_TABLE()
1203 };
1204
1205 // ----------------------------------------------------------------------------
1206 // now include the declaration of wxWindow class
1207 // ----------------------------------------------------------------------------
1208
1209 // include the declaration of the platform-specific class
1210 #if defined(__WXMSW__)
1211 #ifdef __WXUNIVERSAL__
1212 #define wxWindowNative wxWindowMSW
1213 #else // !wxUniv
1214 #define wxWindowMSW wxWindow
1215 #endif // wxUniv/!wxUniv
1216 #include "wx/msw/window.h"
1217 #elif defined(__WXMOTIF__)
1218 #include "wx/motif/window.h"
1219 #elif defined(__WXGTK__)
1220 #ifdef __WXUNIVERSAL__
1221 #define wxWindowNative wxWindowGTK
1222 #else // !wxUniv
1223 #define wxWindowGTK wxWindow
1224 #endif // wxUniv
1225 #include "wx/gtk/window.h"
1226 #elif defined(__WXX11__)
1227 #ifdef __WXUNIVERSAL__
1228 #define wxWindowNative wxWindowX11
1229 #else // !wxUniv
1230 #define wxWindowX11 wxWindow
1231 #endif // wxUniv
1232 #include "wx/x11/window.h"
1233 #elif defined(__WXMGL__)
1234 #ifdef __WXUNIVERSAL__
1235 #define wxWindowNative wxWindowMGL
1236 #else // !wxUniv
1237 #define wxWindowMGL wxWindow
1238 #endif // wxUniv
1239 #include "wx/mgl/window.h"
1240 #elif defined(__WXMAC__)
1241 #ifdef __WXUNIVERSAL__
1242 #define wxWindowNative wxWindowMac
1243 #else // !wxUniv
1244 #define wxWindowMac wxWindow
1245 #endif // wxUniv
1246 #include "wx/mac/window.h"
1247 #elif defined(__WXCOCOA__)
1248 #ifdef __WXUNIVERSAL__
1249 #define wxWindowNative wxWindowCocoa
1250 #else // !wxUniv
1251 #define wxWindowCocoa wxWindow
1252 #endif // wxUniv
1253 #include "wx/cocoa/window.h"
1254 #elif defined(__WXPM__)
1255 #ifdef __WXUNIVERSAL__
1256 #define wxWindowNative wxWindowOS2
1257 #else // !wxUniv
1258 #define wxWindowOS2 wxWindow
1259 #endif // wxUniv/!wxUniv
1260 #include "wx/os2/window.h"
1261 #endif
1262
1263 // for wxUniversal, we now derive the real wxWindow from wxWindow<platform>,
1264 // for the native ports we already have defined it above
1265 #if defined(__WXUNIVERSAL__)
1266 #ifndef wxWindowNative
1267 #error "wxWindowNative must be defined above!"
1268 #endif
1269
1270 #include "wx/univ/window.h"
1271 #endif // wxUniv
1272
1273 // ----------------------------------------------------------------------------
1274 // inline functions which couldn't be declared in the class body because of
1275 // forward dependencies
1276 // ----------------------------------------------------------------------------
1277
1278 inline wxWindow *wxWindowBase::GetGrandParent() const
1279 {
1280 return m_parent ? m_parent->GetParent() : (wxWindow *)NULL;
1281 }
1282
1283 // ----------------------------------------------------------------------------
1284 // global functions
1285 // ----------------------------------------------------------------------------
1286
1287 // Find the wxWindow at the current mouse position, also returning the mouse
1288 // position.
1289 WXDLLEXPORT extern wxWindow* wxFindWindowAtPointer(wxPoint& pt);
1290
1291 // Get the current mouse position.
1292 WXDLLEXPORT extern wxPoint wxGetMousePosition();
1293
1294 // get the currently active window of this application or NULL
1295 WXDLLEXPORT extern wxWindow *wxGetActiveWindow();
1296
1297 // get the (first) top level parent window
1298 WXDLLEXPORT wxWindow* wxGetTopLevelParent(wxWindow *win);
1299
1300 // deprecated (doesn't start with 'wx' prefix), use wxWindow::NewControlId()
1301 inline int NewControlId() { return wxWindowBase::NewControlId(); }
1302
1303 #if wxUSE_ACCESSIBILITY
1304 // ----------------------------------------------------------------------------
1305 // accessible object for windows
1306 // ----------------------------------------------------------------------------
1307
1308 class WXDLLEXPORT wxWindowAccessible: public wxAccessible
1309 {
1310 public:
1311 wxWindowAccessible(wxWindow* win): wxAccessible(win) { if (win) win->SetAccessible(this); }
1312 virtual ~wxWindowAccessible() {};
1313
1314 // Overridables
1315
1316 // Can return either a child object, or an integer
1317 // representing the child element, starting from 1.
1318 virtual wxAccStatus HitTest(const wxPoint& pt, int* childId, wxAccessible** childObject);
1319
1320 // Returns the rectangle for this object (id = 0) or a child element (id > 0).
1321 virtual wxAccStatus GetLocation(wxRect& rect, int elementId);
1322
1323 // Navigates from fromId to toId/toObject.
1324 virtual wxAccStatus Navigate(wxNavDir navDir, int fromId,
1325 int* toId, wxAccessible** toObject);
1326
1327 // Gets the name of the specified object.
1328 virtual wxAccStatus GetName(int childId, wxString* name);
1329
1330 // Gets the number of children.
1331 virtual wxAccStatus GetChildCount(int* childCount);
1332
1333 // Gets the specified child (starting from 1).
1334 // If *child is NULL and return value is wxACC_OK,
1335 // this means that the child is a simple element and
1336 // not an accessible object.
1337 virtual wxAccStatus GetChild(int childId, wxAccessible** child);
1338
1339 // Gets the parent, or NULL.
1340 virtual wxAccStatus GetParent(wxAccessible** parent);
1341
1342 // Performs the default action. childId is 0 (the action for this object)
1343 // or > 0 (the action for a child).
1344 // Return wxACC_NOT_SUPPORTED if there is no default action for this
1345 // window (e.g. an edit control).
1346 virtual wxAccStatus DoDefaultAction(int childId);
1347
1348 // Gets the default action for this object (0) or > 0 (the action for a child).
1349 // Return wxACC_OK even if there is no action. actionName is the action, or the empty
1350 // string if there is no action.
1351 // The retrieved string describes the action that is performed on an object,
1352 // not what the object does as a result. For example, a toolbar button that prints
1353 // a document has a default action of "Press" rather than "Prints the current document."
1354 virtual wxAccStatus GetDefaultAction(int childId, wxString* actionName);
1355
1356 // Returns the description for this object or a child.
1357 virtual wxAccStatus GetDescription(int childId, wxString* description);
1358
1359 // Returns help text for this object or a child, similar to tooltip text.
1360 virtual wxAccStatus GetHelpText(int childId, wxString* helpText);
1361
1362 // Returns the keyboard shortcut for this object or child.
1363 // Return e.g. ALT+K
1364 virtual wxAccStatus GetKeyboardShortcut(int childId, wxString* shortcut);
1365
1366 // Returns a role constant.
1367 virtual wxAccStatus GetRole(int childId, wxAccRole* role);
1368
1369 // Returns a state constant.
1370 virtual wxAccStatus GetState(int childId, long* state);
1371
1372 // Returns a localized string representing the value for the object
1373 // or child.
1374 virtual wxAccStatus GetValue(int childId, wxString* strValue);
1375
1376 // Selects the object or child.
1377 virtual wxAccStatus Select(int childId, wxAccSelectionFlags selectFlags);
1378
1379 // Gets the window with the keyboard focus.
1380 // If childId is 0 and child is NULL, no object in
1381 // this subhierarchy has the focus.
1382 // If this object has the focus, child should be 'this'.
1383 virtual wxAccStatus GetFocus(int* childId, wxAccessible** child);
1384
1385 // Gets a variant representing the selected children
1386 // of this object.
1387 // Acceptable values:
1388 // - a null variant (IsNull() returns true)
1389 // - a list variant (GetType() == wxT("list")
1390 // - an integer representing the selected child element,
1391 // or 0 if this object is selected (GetType() == wxT("long")
1392 // - a "void*" pointer to a wxAccessible child object
1393 virtual wxAccStatus GetSelections(wxVariant* selections);
1394 };
1395
1396 #endif // wxUSE_ACCESSIBILITY
1397
1398
1399 #endif
1400 // _WX_WINDOW_H_BASE_
1401