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