]> git.saurik.com Git - wxWidgets.git/blame - include/wx/window.h
Compilo.
[wxWidgets.git] / include / wx / window.h
CommitLineData
f03fc89f 1///////////////////////////////////////////////////////////////////////////////
23895080 2// Name: wx/window.h
789295bf 3// Purpose: wxWindowBase class - the interface of wxWindow
f03fc89f 4// Author: Vadim Zeitlin
566d84a7 5// Modified by: Ron Lee
f03fc89f
VZ
6// Created: 01/02/97
7// RCS-ID: $Id$
77ffb593 8// Copyright: (c) wxWidgets team
65571936 9// Licence: wxWindows licence
f03fc89f
VZ
10///////////////////////////////////////////////////////////////////////////////
11
34138703
JS
12#ifndef _WX_WINDOW_H_BASE_
13#define _WX_WINDOW_H_BASE_
c801d85f 14
12028905 15#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
58654ed0
VZ
16 #pragma interface "windowbase.h"
17#endif
18
f03fc89f
VZ
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"
5e4ff78a 31#include "wx/utils.h"
88ac883a 32
674ac8b9 33#include "wx/validate.h" // for wxDefaultValidator (always include it)
8d99be5f 34
574c939e 35#if wxUSE_PALETTE
d577d610 36 #include "wx/palette.h"
574c939e
KB
37#endif // wxUSE_PALETTE
38
88ac883a
VZ
39#if wxUSE_ACCEL
40 #include "wx/accel.h"
41#endif // wxUSE_ACCEL
f03fc89f 42
45a959a3
JS
43#if wxUSE_ACCESSIBILITY
44#include "wx/access.h"
45#endif
46
6522713c
VZ
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
22dd3847 51#else // !__WXUNIVERSAL__
6522713c 52 #define wxUSE_MENUS_NATIVE wxUSE_MENUS
22dd3847 53#endif // __WXUNIVERSAL__/!__WXUNIVERSAL__
6522713c 54
f03fc89f
VZ
55// ----------------------------------------------------------------------------
56// forward declarations
57// ----------------------------------------------------------------------------
58
789295bf 59class WXDLLEXPORT wxCaret;
f03fc89f
VZ
60class WXDLLEXPORT wxControl;
61class WXDLLEXPORT wxCursor;
eb082a08 62class WXDLLEXPORT wxDC;
f03fc89f
VZ
63class WXDLLEXPORT wxDropTarget;
64class WXDLLEXPORT wxItemResource;
65class WXDLLEXPORT wxLayoutConstraints;
66class WXDLLEXPORT wxResourceTable;
67class WXDLLEXPORT wxSizer;
68class WXDLLEXPORT wxToolTip;
f03fc89f
VZ
69class WXDLLEXPORT wxWindowBase;
70class WXDLLEXPORT wxWindow;
71
45a959a3
JS
72#if wxUSE_ACCESSIBILITY
73class WXDLLEXPORT wxAccessible;
74#endif
75
1b69c815
VZ
76// ----------------------------------------------------------------------------
77// helper stuff used by wxWindow
78// ----------------------------------------------------------------------------
79
80// struct containing all the visual attributes of a control
81struct 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
400a9e41 96enum wxWindowVariant
1b69c815
VZ
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
ff9f7a12
SC
105#if wxUSE_SYSTEM_OPTIONS
106 #define wxWINDOW_DEFAULT_VARIANT wxT("window-default-variant")
107#endif
108
f03fc89f
VZ
109// ----------------------------------------------------------------------------
110// (pseudo)template list classes
111// ----------------------------------------------------------------------------
112
f6bcfd97 113WX_DECLARE_LIST_3(wxWindow, wxWindowBase, wxWindowList, wxWindowListNode, class WXDLLEXPORT);
f03fc89f
VZ
114
115// ----------------------------------------------------------------------------
116// global variables
117// ----------------------------------------------------------------------------
118
16cba29d 119extern WXDLLEXPORT_DATA(wxWindowList) wxTopLevelWindows;
f03fc89f 120
f03fc89f
VZ
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
132class WXDLLEXPORT wxWindowBase : public wxEvtHandler
133{
f03fc89f
VZ
134public:
135 // creating the window
136 // -------------------
137
06f6df7d
VZ
138 // default ctor, initializes everything which can be initialized before
139 // Create()
6463b9f5 140 wxWindowBase() ;
f03fc89f
VZ
141
142 // pseudo ctor (can't be virtual, called from ctor)
143 bool CreateBase(wxWindowBase *parent,
d9e2e4c2 144 wxWindowID winid,
f03fc89f
VZ
145 const wxPoint& pos = wxDefaultPosition,
146 const wxSize& size = wxDefaultSize,
147 long style = 0,
8d99be5f 148 const wxValidator& validator = wxDefaultValidator,
f03fc89f
VZ
149 const wxString& name = wxPanelNameStr);
150
151 virtual ~wxWindowBase();
152
f03fc89f
VZ
153 // deleting the window
154 // -------------------
155
d4864e97 156 // ask the window to close itself, return true if the event handler
f03fc89f 157 // honoured our request
d4864e97 158 bool Close( bool force = false );
f03fc89f
VZ
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
d4864e97 164 // delete window unconditionally (dangerous!), returns true if ok
f03fc89f 165 virtual bool Destroy();
d4864e97 166 // delete all children of this window, returns true if ok
f03fc89f
VZ
167 bool DestroyChildren();
168
169 // is the window being deleted?
170 bool IsBeingDeleted() const { return m_isBeingDeleted; }
171
172 // window attributes
173 // -----------------
174
77ffb593 175 // NB: in future versions of wxWidgets Set/GetTitle() will only work
456bc6d9
VZ
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
f03fc89f
VZ
179 // the title (or label, see below) of the window: the text which the
180 // window shows
fe6b43a3
VS
181 virtual void SetTitle( const wxString& WXUNUSED(title) ) {}
182 virtual wxString GetTitle() const { return wxEmptyString; }
f03fc89f
VZ
183
184 // label is just the same as the title (but for, e.g., buttons it
185 // makes more sense to speak about labels)
eba0e4d4
RR
186 virtual void SetLabel(const wxString& label) { SetTitle(label); }
187 virtual wxString GetLabel() const { return GetTitle(); }
f03fc89f
VZ
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
69d90995
SC
194 // sets the window variant, calls internally DoSetVariant if variant has changed
195 void SetWindowVariant( wxWindowVariant variant ) ;
196 wxWindowVariant GetWindowVariant() const { return m_windowVariant ; }
400a9e41 197
69d90995 198
f03fc89f 199 // window id uniquely identifies the window among its siblings unless
a0d9c6cb 200 // it is wxID_ANY which means "don't care"
d9e2e4c2 201 void SetId( wxWindowID winid ) { m_windowId = winid; }
f03fc89f
VZ
202 wxWindowID GetId() const { return m_windowId; }
203
204 // generate a control id for the controls which were not given one by
205 // user
69418a8e 206 static int NewControlId() { return --ms_lastControlId; }
c539ab55
VZ
207 // get the id of the control following the one with the given
208 // (autogenerated) id
d9e2e4c2 209 static int NextControlId(int winid) { return winid - 1; }
c539ab55
VZ
210 // get the id of the control preceding the one with the given
211 // (autogenerated) id
d9e2e4c2 212 static int PrevControlId(int winid) { return winid + 1; }
f03fc89f
VZ
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 )
a0d9c6cb 223 { DoSetSize( wxDefaultCoord, wxDefaultCoord, width, height, wxSIZE_USE_EXISTING ); }
f03fc89f
VZ
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
1e6feb95 231 void Move(int x, int y, int flags = wxSIZE_USE_EXISTING)
a0d9c6cb 232 { DoSetSize(x, y, wxDefaultCoord, wxDefaultCoord, flags); }
f03fc89f 233
1e6feb95
VZ
234 void Move(const wxPoint& pt, int flags = wxSIZE_USE_EXISTING)
235 { Move(pt.x, pt.y, flags); }
f03fc89f
VZ
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
311a173b 261 void SetPosition( const wxPoint& pt ) { Move( pt ) ; }
38759b67 262
f03fc89f
VZ
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
1e6feb95
VZ
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
f68586e5 300 // get the size best suited for the window (in fact, minimal
9f884528
RD
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 }
f68586e5
VZ
309 void GetBestSize(int *w, int *h) const
310 {
9f884528 311 wxSize s = GetBestSize();
f68586e5
VZ
312 if ( w )
313 *w = s.x;
314 if ( h )
315 *h = s.y;
316 }
317
9f884528
RD
318 // reset the cached best size value so it will be recalculated the
319 // next time it is needed.
992b2ec4 320 void InvalidateBestSize();
9f884528
RD
321 void CacheBestSize(const wxSize& size) const
322 { wxConstCast(this, wxWindowBase)->m_bestSizeCache = size; }
a0d9c6cb 323
2b5f62a0
VZ
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 {
9f884528 331 wxSize s( GetBestSize() );
2b5f62a0
VZ
332 return wxSize( wxMax( s.x, GetMinWidth() ), wxMax( s.y, GetMinHeight() ) );
333 }
334
9f884528
RD
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;
a0d9c6cb 339
9f884528
RD
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
2b5f62a0 344 // the generic centre function - centers the window on parent by`
7eb4e9cc
VZ
345 // default or on screen if it doesn't have parent or
346 // wxCENTER_ON_SCREEN flag is given
c39eda94
VZ
347 void Centre( int direction = wxBOTH );
348 void Center( int direction = wxBOTH ) { Centre(direction); }
7eb4e9cc
VZ
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); }
f03fc89f
VZ
357
358 // set window size to wrap around its children
359 virtual void Fit();
360
2b5f62a0
VZ
361 // set virtual size to satisfy children
362 virtual void FitInside();
363
f03fc89f
VZ
364 // set min/max size of the window
365 virtual void SetSizeHints( int minW, int minH,
a0d9c6cb 366 int maxW = wxDefaultCoord, int maxH = wxDefaultCoord,
571f6981
VS
367 int incW = wxDefaultCoord, int incH = wxDefaultCoord )
368 {
369 DoSetSizeHints(minW, minH, maxW, maxH, incW, incH);
370 }
6fb99eb3 371
1ec25e8f
RD
372 void SetSizeHints( const wxSize& minSize,
373 const wxSize& maxSize=wxDefaultSize,
374 const wxSize& incSize=wxDefaultSize)
375 {
571f6981
VS
376 DoSetSizeHints(minSize.x, minSize.y,
377 maxSize.x, maxSize.y,
378 incSize.x, incSize.y);
1ec25e8f 379 }
6fb99eb3 380
571f6981
VS
381 virtual void DoSetSizeHints(int minW, int minH,
382 int maxW = wxDefaultCoord, int maxH = wxDefaultCoord,
383 int incW = wxDefaultCoord, int incH = wxDefaultCoord );
f03fc89f 384
566d84a7 385 virtual void SetVirtualSizeHints( int minW, int minH,
a0d9c6cb 386 int maxW = wxDefaultCoord, int maxH = wxDefaultCoord );
1ec25e8f
RD
387 void SetVirtualSizeHints( const wxSize& minSize,
388 const wxSize& maxSize=wxDefaultSize)
389 {
390 SetVirtualSizeHints(minSize.x, minSize.y, maxSize.x, maxSize.y);
391 }
566d84a7 392
e7dda1ff
VS
393 virtual int GetMinWidth() const { return m_minWidth; }
394 virtual int GetMinHeight() const { return m_minHeight; }
738f9e5a
RR
395 int GetMaxWidth() const { return m_maxWidth; }
396 int GetMaxHeight() const { return m_maxHeight; }
57c4d796 397
34c3ffca
RL
398 // Override this method to control the values given to Sizers etc.
399 virtual wxSize GetMaxSize() const { return wxSize( m_maxWidth, m_maxHeight ); }
1ec25e8f 400 virtual wxSize GetMinSize() const { return wxSize( m_minWidth, m_minHeight ); }
400a9e41 401
49f1dc5e
RD
402 void SetMinSize(const wxSize& minSize) { SetSizeHints(minSize); }
403 void SetMaxSize(const wxSize& maxSize) { SetSizeHints(GetMinSize(), maxSize); }
a0d9c6cb 404
566d84a7
RL
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
e5ecf1fc 427 // wxScrolledWindow.
566d84a7
RL
428
429 virtual void DoSetVirtualSize( int x, int y );
85b38e0b 430 virtual wxSize DoGetVirtualSize() const;
e5ecf1fc 431
2b5f62a0
VZ
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
f03fc89f
VZ
443 // window state
444 // ------------
445
d4864e97 446 // returns true if window was shown/hidden, false if the nothing was
f03fc89f 447 // done (window was already shown/hidden)
d4864e97
VZ
448 virtual bool Show( bool show = true );
449 bool Hide() { return Show(false); }
f03fc89f 450
d4864e97
VZ
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); }
f03fc89f 454
b08cd3bf 455 virtual bool IsShown() const { return m_isShown; }
db101bd3 456 virtual bool IsEnabled() const { return m_isEnabled; }
f03fc89f
VZ
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; }
d80cd92a 468 virtual bool IsRetained() const { return HasFlag(wxRETAINED); }
f03fc89f 469
d80cd92a
VZ
470 // extra style: the less often used style bits which can't be set with
471 // SetWindowStyleFlag()
b2d5a7ee 472 virtual void SetExtraStyle(long exStyle) { m_exStyle = exStyle; }
d80cd92a 473 long GetExtraStyle() const { return m_exStyle; }
f03fc89f
VZ
474
475 // make the window modal (all other windows unresponsive)
d4864e97 476 virtual void MakeModal(bool modal = true);
f03fc89f 477
b8e7b673
VZ
478
479 // (primitive) theming support
480 // ---------------------------
481
a2d93e73
JS
482 virtual void SetThemeEnabled(bool enableTheme) { m_themeEnabled = enableTheme; }
483 virtual bool GetThemeEnabled() const { return m_themeEnabled; }
484
bd507486
RD
485 // Returns true if this class should have the background colour
486 // changed to match the parent window's theme. For example when a
a0d9c6cb 487 // page is added to a notebook it and its children may need to have
bd507486
RD
488 // the colours adjusted depending on the current theme settings, but
489 // not all windows/controls can do this without looking wrong.
cc0bffac
RD
490 virtual void ApplyParentThemeBackground(const wxColour& WXUNUSED(bg))
491 { /* do nothing */ }
400a9e41 492
d4864e97 493
456bc6d9
VZ
494 // focus and keyboard handling
495 // ---------------------------
f03fc89f
VZ
496
497 // set focus to this window
498 virtual void SetFocus() = 0;
499
d577d610
VZ
500 // set focus to this window as the result of a keyboard action
501 virtual void SetFocusFromKbd() { SetFocus(); }
502
f03fc89f 503 // return the window which currently has the focus or NULL
0fe02759 504 static wxWindow *FindFocus();
6fb99eb3 505
0fe02759 506 static wxWindow *DoFindFocus() /* = 0: implement in derived classes */;
f03fc89f
VZ
507
508 // can this window have focus?
509 virtual bool AcceptsFocus() const { return IsShown() && IsEnabled(); }
510
1e6feb95
VZ
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
456bc6d9
VZ
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
036da5e3
VZ
527 // set this child as temporary default
528 virtual void SetTmpDefaultItem(wxWindow * WXUNUSED(win)) { }
529
a24de76b 530 // navigates in the specified direction by sending a wxNavigationKeyEvent
eedc82f4 531 virtual bool Navigate(int flags = wxNavigationKeyEvent::IsForward);
5f6cfda7 532
a24de76b
VZ
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
f03fc89f
VZ
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
1978421a
SC
548 // needed just for extended runtime
549 const wxWindowList& GetWindowChildren() const { return GetChildren() ; }
550
f03fc89f
VZ
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?
8487f887 556 virtual bool IsTopLevel() const;
f03fc89f 557
87b6002d 558 // it doesn't really change parent, use Reparent() instead
f03fc89f 559 void SetParent( wxWindowBase *parent ) { m_parent = (wxWindow *)parent; }
d4864e97
VZ
560 // change the real parent of this window, return true if the parent
561 // was changed, false otherwise (error or newParent == oldParent)
f03fc89f
VZ
562 virtual bool Reparent( wxWindowBase *newParent );
563
146ba0fe
VZ
564 // implementation mostly
565 virtual void AddChild( wxWindowBase *child );
566 virtual void RemoveChild( wxWindowBase *child );
567
568 // looking for windows
569 // -------------------
570
f03fc89f
VZ
571 // find window among the descendants of this one either by id or by
572 // name (return NULL if not found)
6b73af79
VZ
573 wxWindow *FindWindow(long winid) const;
574 wxWindow *FindWindow(const wxString& name) const;
f03fc89f 575
146ba0fe 576 // Find a window among any window (all return NULL if not found)
d9e2e4c2 577 static wxWindow *FindWindowById( long winid, const wxWindow *parent = NULL );
146ba0fe
VZ
578 static wxWindow *FindWindowByName( const wxString& name,
579 const wxWindow *parent = NULL );
580 static wxWindow *FindWindowByLabel( const wxString& label,
581 const wxWindow *parent = NULL );
f03fc89f
VZ
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 );
d4864e97 596 wxEvtHandler *PopEventHandler( bool deleteHandler = false );
f03fc89f 597
2e36d5cf 598 // find the given handler in the event handler chain and remove (but
d4864e97
VZ
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
2e36d5cf
VZ
601 // this function should only be called when the handler is supposed to
602 // be there)
603 bool RemoveEventHandler(wxEvtHandler *handler);
604
1e6feb95
VZ
605 // validators
606 // ----------
f03fc89f 607
88ac883a 608#if wxUSE_VALIDATORS
f03fc89f
VZ
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; }
88ac883a 613#endif // wxUSE_VALIDATORS
f03fc89f 614
f03fc89f
VZ
615
616 // dialog oriented functions
617 // -------------------------
618
d4864e97 619 // validate the correctness of input, return true if ok
f03fc89f
VZ
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
88ac883a 628#if wxUSE_ACCEL
f03fc89f
VZ
629 // accelerators
630 // ------------
631 virtual void SetAcceleratorTable( const wxAcceleratorTable& accel )
632 { m_acceleratorTable = accel; }
633 wxAcceleratorTable *GetAcceleratorTable()
634 { return &m_acceleratorTable; }
5048c832 635
540b6b09
VZ
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);
5048c832 643 virtual bool UnregisterHotKey(int hotkeyId);
540b6b09 644#endif // wxUSE_HOTKEY
5048c832 645
f03fc89f
VZ
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
94633ad9
VZ
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();
f03fc89f 678
1e6feb95
VZ
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
f03fc89f
VZ
686 // painting the window
687 // -------------------
688
689 // mark the specified rectangle (or the whole window) as "dirty" so it
690 // will be repainted
d4864e97 691 virtual void Refresh( bool eraseBackground = true,
f03fc89f 692 const wxRect *rect = (const wxRect *) NULL ) = 0;
1e6feb95
VZ
693
694 // a less awkward wrapper for Refresh
8cfa09bd
VZ
695 void RefreshRect(const wxRect& rect, bool eraseBackground = true)
696 {
697 Refresh(eraseBackground, &rect);
698 }
1e6feb95
VZ
699
700 // repaint all invalid areas of the window immediately
701 virtual void Update() { }
702
5da0803c
VZ
703 // clear the window background
704 virtual void ClearBackground();
f03fc89f 705
0cc7251e
VZ
706 // freeze the window: don't redraw it until it is thawed
707 virtual void Freeze() { }
708
709 // thaw the window: redraw it after it had been frozen
710 virtual void Thaw() { }
711
f03fc89f 712 // adjust DC for drawing on this window
f6147cfc 713 virtual void PrepareDC( wxDC & WXUNUSED(dc) ) { }
f03fc89f
VZ
714
715 // the update region of the window contains the areas which must be
716 // repainted by the program
717 const wxRegion& GetUpdateRegion() const { return m_updateRegion; }
718 wxRegion& GetUpdateRegion() { return m_updateRegion; }
719
1e6feb95
VZ
720 // get the update rectangleregion bounding box in client coords
721 wxRect GetUpdateClientRect() const;
722
f03fc89f
VZ
723 // these functions verify whether the given point/rectangle belongs to
724 // (or at least intersects with) the update region
725 bool IsExposed( int x, int y ) const;
726 bool IsExposed( int x, int y, int w, int h ) const;
727
728 bool IsExposed( const wxPoint& pt ) const
729 { return IsExposed(pt.x, pt.y); }
730 bool IsExposed( const wxRect& rect ) const
731 { return IsExposed(rect.x, rect.y, rect.width, rect.height); }
732
733 // colours, fonts and cursors
734 // --------------------------
735
1b69c815
VZ
736 // get the default attributes for the controls of this class: we
737 // provide a virtual function which can be used to query the default
738 // attributes of an existing control and a static function which can
739 // be used even when no existing object of the given class is
740 // available, but which won't return any styles specific to this
741 // particular control, of course (e.g. "Ok" button might have
742 // different -- bold for example -- font)
743 virtual wxVisualAttributes GetDefaultAttributes() const
744 {
745 return GetClassDefaultAttributes(GetWindowVariant());
746 }
747
748 static wxVisualAttributes
749 GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
750
f03fc89f 751 // set/retrieve the window colours (system defaults are used by
b8e7b673 752 // default): SetXXX() functions return true if colour was changed,
f8ff87ed
VS
753 // SetDefaultXXX() reset the "m_inheritXXX" flag after setting the
754 // value to prevent it from being inherited by our children
b8e7b673 755 virtual bool SetBackgroundColour(const wxColour& colour);
fa47d7a7 756 void SetOwnBackgroundColour(const wxColour& colour)
b8e7b673
VZ
757 {
758 if ( SetBackgroundColour(colour) )
f8ff87ed 759 m_inheritBgCol = false;
b8e7b673 760 }
1b69c815 761 wxColour GetBackgroundColour() const;
e5ecf1fc
WS
762 bool InheritsBackgroundColour() const
763 {
764 return m_inheritBgCol;
765 }
766 bool UseBgCol() const
767 {
768 return m_hasBgCol;
769 }
b8e7b673 770
4cc4e7b6
VZ
771 // if the window shouldn't inherit its colour from the parent, override
772 // this function to return true
773 //
774 // this is currently only used by wxMSW and wxUniv but should be useful for
775 // the other ports too
776 virtual bool ProvidesBackground() const { return false; }
777
b8e7b673 778 virtual bool SetForegroundColour(const wxColour& colour);
fa47d7a7 779 void SetOwnForegroundColour(const wxColour& colour)
b8e7b673
VZ
780 {
781 if ( SetForegroundColour(colour) )
f8ff87ed 782 m_inheritFgCol = false;
b8e7b673 783 }
1b69c815 784 wxColour GetForegroundColour() const;
f03fc89f 785
50c53860
JS
786 // Set/get the background style.
787 // Pass one of wxBG_STYLE_SYSTEM, wxBG_STYLE_COLOUR, wxBG_STYLE_CUSTOM
788 virtual bool SetBackgroundStyle(wxBackgroundStyle style) { m_backgroundStyle = style; return true; }
789 virtual wxBackgroundStyle GetBackgroundStyle() const { return m_backgroundStyle; }
790
7c7a653b
VZ
791 // returns true if the control has "transparent" areas such as a
792 // wxStaticText and wxCheckBox and the background should be adapted
793 // from a parent window
794 virtual bool HasTransparentBackground() { return false; }
795
b8e7b673
VZ
796 // set/retrieve the font for the window (SetFont() returns true if the
797 // font really changed)
798 virtual bool SetFont(const wxFont& font) = 0;
fa47d7a7 799 void SetOwnFont(const wxFont& font)
b8e7b673
VZ
800 {
801 if ( SetFont(font) )
f8ff87ed 802 m_inheritFont = false;
b8e7b673 803 }
29094af0 804 wxFont GetFont() const;
b8e7b673 805
d4864e97 806 // set/retrieve the cursor for this window (SetCursor() returns true
f03fc89f
VZ
807 // if the cursor was really changed)
808 virtual bool SetCursor( const wxCursor &cursor );
809 const wxCursor& GetCursor() const { return m_cursor; }
f03fc89f 810
789295bf
VZ
811#if wxUSE_CARET
812 // associate a caret with the window
813 void SetCaret(wxCaret *caret);
814 // get the current caret (may be NULL)
815 wxCaret *GetCaret() const { return m_caret; }
816#endif // wxUSE_CARET
817
f03fc89f
VZ
818 // get the (average) character size for the current font
819 virtual int GetCharHeight() const = 0;
820 virtual int GetCharWidth() const = 0;
821
822 // get the width/height/... of the text using current or specified
823 // font
824 virtual void GetTextExtent(const wxString& string,
825 int *x, int *y,
826 int *descent = (int *) NULL,
827 int *externalLeading = (int *) NULL,
828 const wxFont *theFont = (const wxFont *) NULL)
829 const = 0;
830
1e6feb95
VZ
831 // client <-> screen coords
832 // ------------------------
833
f03fc89f 834 // translate to/from screen/client coordinates (pointers may be NULL)
dabc0cd5
VZ
835 void ClientToScreen( int *x, int *y ) const
836 { DoClientToScreen(x, y); }
837 void ScreenToClient( int *x, int *y ) const
838 { DoScreenToClient(x, y); }
1e6feb95
VZ
839
840 // wxPoint interface to do the same thing
dabc0cd5
VZ
841 wxPoint ClientToScreen(const wxPoint& pt) const
842 {
843 int x = pt.x, y = pt.y;
844 DoClientToScreen(&x, &y);
845
846 return wxPoint(x, y);
847 }
848
849 wxPoint ScreenToClient(const wxPoint& pt) const
850 {
851 int x = pt.x, y = pt.y;
852 DoScreenToClient(&x, &y);
853
854 return wxPoint(x, y);
855 }
f03fc89f 856
1e6feb95
VZ
857 // test where the given (in client coords) point lies
858 wxHitTest HitTest(wxCoord x, wxCoord y) const
859 { return DoHitTest(x, y); }
860
861 wxHitTest HitTest(const wxPoint& pt) const
862 { return DoHitTest(pt.x, pt.y); }
863
f03fc89f
VZ
864 // misc
865 // ----
866
aede4ebb
VZ
867 // get the window border style from the given flags: this is different from
868 // simply doing flags & wxBORDER_MASK because it uses GetDefaultBorder() to
869 // translate wxBORDER_DEFAULT to something reasonable
870 wxBorder GetBorder(long flags) const;
871
872 // get border for the flags of this window
873 wxBorder GetBorder() const { return GetBorder(GetWindowStyleFlag()); }
1e6feb95 874
d4864e97 875 // send wxUpdateUIEvents to this window, and children if recurse is true
e39af974
JS
876 virtual void UpdateWindowUI(long flags = wxUPDATE_UI_NONE);
877
878 // do the window-specific processing after processing the update event
879 virtual void DoUpdateWindowUI(wxUpdateUIEvent& event) ;
f03fc89f 880
1e6feb95 881#if wxUSE_MENUS
45b8a256 882 bool PopupMenu(wxMenu *menu, const wxPoint& pos = wxDefaultPosition)
a1665b22 883 { return DoPopupMenu(menu, pos.x, pos.y); }
971562cb 884 bool PopupMenu(wxMenu *menu, int x, int y)
a1665b22 885 { return DoPopupMenu(menu, x, y); }
1e6feb95 886#endif // wxUSE_MENUS
f03fc89f
VZ
887
888 // scrollbars
889 // ----------
890
1e6feb95
VZ
891 // does the window have the scrollbar for this orientation?
892 bool HasScrollbar(int orient) const
893 {
894 return (m_windowStyle &
895 (orient == wxHORIZONTAL ? wxHSCROLL : wxVSCROLL)) != 0;
896 }
897
f03fc89f
VZ
898 // configure the window scrollbars
899 virtual void SetScrollbar( int orient,
900 int pos,
1e6feb95 901 int thumbvisible,
f03fc89f 902 int range,
d4864e97
VZ
903 bool refresh = true ) = 0;
904 virtual void SetScrollPos( int orient, int pos, bool refresh = true ) = 0;
f03fc89f
VZ
905 virtual int GetScrollPos( int orient ) const = 0;
906 virtual int GetScrollThumb( int orient ) const = 0;
907 virtual int GetScrollRange( int orient ) const = 0;
908
909 // scroll window to the specified position
910 virtual void ScrollWindow( int dx, int dy,
911 const wxRect* rect = (wxRect *) NULL ) = 0;
912
b9b3393e 913 // scrolls window by line/page: note that not all controls support this
9cd6d737 914 //
d4864e97
VZ
915 // return true if the position changed, false otherwise
916 virtual bool ScrollLines(int WXUNUSED(lines)) { return false; }
917 virtual bool ScrollPages(int WXUNUSED(pages)) { return false; }
9cd6d737
VZ
918
919 // convenient wrappers for ScrollLines/Pages
920 bool LineUp() { return ScrollLines(-1); }
921 bool LineDown() { return ScrollLines(1); }
922 bool PageUp() { return ScrollPages(-1); }
923 bool PageDown() { return ScrollPages(1); }
b9b3393e 924
bd83cb56
VZ
925 // context-sensitive help
926 // ----------------------
927
928 // these are the convenience functions wrapping wxHelpProvider methods
929
930#if wxUSE_HELP
931 // associate this help text with this window
932 void SetHelpText(const wxString& text);
933 // associate this help text with all windows with the same id as this
934 // one
935 void SetHelpTextForId(const wxString& text);
936 // get the help string associated with this window (may be empty)
937 wxString GetHelpText() const;
938#endif // wxUSE_HELP
939
f03fc89f
VZ
940 // tooltips
941 // --------
bd83cb56 942
f03fc89f
VZ
943#if wxUSE_TOOLTIPS
944 // the easiest way to set a tooltip for a window is to use this method
945 void SetToolTip( const wxString &tip );
946 // attach a tooltip to the window
947 void SetToolTip( wxToolTip *tip ) { DoSetToolTip(tip); }
948 // get the associated tooltip or NULL if none
949 wxToolTip* GetToolTip() const { return m_tooltip; }
311a173b 950 wxString GetToolTipText() const ;
7649d8fc
JS
951#else
952 // make it much easier to compile apps in an environment
953 // that doesn't support tooltips, such as PocketPC
954 inline void SetToolTip( const wxString & WXUNUSED(tip) ) {}
f03fc89f
VZ
955#endif // wxUSE_TOOLTIPS
956
957 // drag and drop
958 // -------------
959#if wxUSE_DRAG_AND_DROP
960 // set/retrieve the drop target associated with this window (may be
961 // NULL; it's owned by the window and will be deleted by it)
962 virtual void SetDropTarget( wxDropTarget *dropTarget ) = 0;
963 virtual wxDropTarget *GetDropTarget() const { return m_dropTarget; }
964#endif // wxUSE_DRAG_AND_DROP
965
966 // constraints and sizers
967 // ----------------------
968#if wxUSE_CONSTRAINTS
969 // set the constraints for this window or retrieve them (may be NULL)
970 void SetConstraints( wxLayoutConstraints *constraints );
971 wxLayoutConstraints *GetConstraints() const { return m_constraints; }
972
f03fc89f
VZ
973 // implementation only
974 void UnsetConstraints(wxLayoutConstraints *c);
975 wxWindowList *GetConstraintsInvolvedIn() const
976 { return m_constraintsInvolvedIn; }
977 void AddConstraintReference(wxWindowBase *otherWin);
978 void RemoveConstraintReference(wxWindowBase *otherWin);
979 void DeleteRelatedConstraints();
980 void ResetConstraints();
981
982 // these methods may be overriden for special layout algorithms
d4864e97 983 virtual void SetConstraintSizes(bool recurse = true);
f03fc89f
VZ
984 virtual bool LayoutPhase1(int *noChanges);
985 virtual bool LayoutPhase2(int *noChanges);
4b7f2165 986 virtual bool DoPhase(int phase);
f03fc89f
VZ
987
988 // these methods are virtual but normally won't be overridden
f03fc89f
VZ
989 virtual void SetSizeConstraint(int x, int y, int w, int h);
990 virtual void MoveConstraint(int x, int y);
991 virtual void GetSizeConstraint(int *w, int *h) const ;
992 virtual void GetClientSizeConstraint(int *w, int *h) const ;
993 virtual void GetPositionConstraint(int *x, int *y) const ;
994
461e93f9
JS
995#endif // wxUSE_CONSTRAINTS
996
997 // when using constraints or sizers, it makes sense to update
998 // children positions automatically whenever the window is resized
999 // - this is done if autoLayout is on
1000 void SetAutoLayout( bool autoLayout ) { m_autoLayout = autoLayout; }
1001 bool GetAutoLayout() const { return m_autoLayout; }
1002
1003 // lay out the window and its children
1004 virtual bool Layout();
1005
f03fc89f 1006 // sizers
d4864e97
VZ
1007 void SetSizer(wxSizer *sizer, bool deleteOld = true );
1008 void SetSizerAndFit( wxSizer *sizer, bool deleteOld = true );
566d84a7 1009
f03fc89f 1010 wxSizer *GetSizer() const { return m_windowSizer; }
be90c029
RD
1011
1012 // Track if this window is a member of a sizer
1ebfafde 1013 void SetContainingSizer(wxSizer* sizer);
be90c029
RD
1014 wxSizer *GetContainingSizer() const { return m_containingSizer; }
1015
45a959a3
JS
1016 // accessibility
1017 // ----------------------
1018#if wxUSE_ACCESSIBILITY
1019 // Override to create a specific accessible object.
1020 virtual wxAccessible* CreateAccessible();
1021
1022 // Sets the accessible object.
1023 void SetAccessible(wxAccessible* accessible) ;
1024
1025 // Returns the accessible object.
1026 wxAccessible* GetAccessible() { return m_accessible; };
1027
1028 // Returns the accessible object, creating if necessary.
1029 wxAccessible* GetOrCreateAccessible() ;
1030#endif
1031
f03fc89f
VZ
1032 // implementation
1033 // --------------
1034
1035 // event handlers
1036 void OnSysColourChanged( wxSysColourChangedEvent& event );
1037 void OnInitDialog( wxInitDialogEvent &event );
72fc5caf 1038 void OnMiddleClick( wxMouseEvent& event );
bd83cb56
VZ
1039#if wxUSE_HELP
1040 void OnHelp(wxHelpEvent& event);
1041#endif // wxUSE_HELP
f03fc89f 1042
e39af974
JS
1043 // virtual function for implementing internal idle
1044 // behaviour
1045 virtual void OnInternalIdle() {}
1046
1047 // call internal idle recursively
5109ae5d 1048// void ProcessInternalIdle() ;
e39af974
JS
1049
1050 // get the handle of the window for the underlying window system: this
d7c24517
VZ
1051 // is only used for wxWin itself or for user code which wants to call
1052 // platform-specific APIs
d22699b5 1053 virtual WXWidget GetHandle() const = 0;
ed4780ea
VZ
1054 // associate the window with a new native handle
1055 virtual void AssociateHandle(WXWidget WXUNUSED(handle)) { }
1056 // dissociate the current native handle from the window
1057 virtual void DissociateHandle() { }
cc2b7472 1058
574c939e
KB
1059#if wxUSE_PALETTE
1060 // Store the palette used by DCs in wxWindow so that the dcs can share
1061 // a palette. And we can respond to palette messages.
1062 wxPalette GetPalette() const { return m_palette; }
b95edd47 1063
574c939e
KB
1064 // When palette is changed tell the DC to set the system palette to the
1065 // new one.
b95edd47
VZ
1066 void SetPalette(const wxPalette& pal);
1067
1068 // return true if we have a specific palette
1069 bool HasCustomPalette() const { return m_hasCustomPalette; }
1070
1071 // return the first parent window with a custom palette or NULL
1072 wxWindow *GetAncestorWithCustomPalette() const;
574c939e
KB
1073#endif // wxUSE_PALETTE
1074
b8e7b673
VZ
1075 // inherit the parents visual attributes if they had been explicitly set
1076 // by the user (i.e. we don't inherit default attributes) and if we don't
1077 // have our own explicitly set
1078 virtual void InheritAttributes();
1079
1080 // returns false from here if this window doesn't want to inherit the
1081 // parents colours even if InheritAttributes() would normally do it
1082 //
1083 // this just provides a simple way to customize InheritAttributes()
1084 // behaviour in the most common case
1085 virtual bool ShouldInheritColours() const { return false; }
1086
245c5d2e
RD
1087protected:
1088 // event handling specific to wxWindow
1089 virtual bool TryValidator(wxEvent& event);
1090 virtual bool TryParent(wxEvent& event);
1091
a24de76b
VZ
1092 // common part of MoveBefore/AfterInTabOrder()
1093 enum MoveKind
1094 {
1095 MoveBefore, // insert before the given window
1096 MoveAfter // insert after the given window
1097 };
1098 virtual void DoMoveInTabOrder(wxWindow *win, MoveKind move);
4caf847c 1099
ec5bb70d
VZ
1100#if wxUSE_CONSTRAINTS
1101 // satisfy the constraints for the windows but don't set the window sizes
1102 void SatisfyConstraints();
1103#endif // wxUSE_CONSTRAINTS
566d84a7 1104
7de59551
RD
1105 // Send the wxWindowDestroyEvent
1106 void SendDestroyEvent();
1107
0fe02759
VS
1108 // returns the main window of composite control; this is the window
1109 // that FindFocus returns if the focus is in one of composite control's
1110 // windows
6fb99eb3 1111 virtual wxWindow *GetMainWindowOfCompositeControl()
0fe02759
VS
1112 { return (wxWindow*)this; }
1113
7af6f327 1114 // the window id - a number which uniquely identifies a window among
a0d9c6cb 1115 // its siblings unless it is wxID_ANY
f03fc89f 1116 wxWindowID m_windowId;
456bc6d9 1117
f03fc89f
VZ
1118 // the parent window of this window (or NULL) and the list of the children
1119 // of this window
1120 wxWindow *m_parent;
1121 wxWindowList m_children;
1122
1123 // the minimal allowed size for the window (no minimal size if variable(s)
a0d9c6cb 1124 // contain(s) wxDefaultCoord)
ec5bb70d
VZ
1125 int m_minWidth,
1126 m_minHeight,
1127 m_maxWidth,
1128 m_maxHeight;
f03fc89f
VZ
1129
1130 // event handler for this window: usually is just 'this' but may be
1131 // changed with SetEventHandler()
1132 wxEvtHandler *m_eventHandler;
1133
88ac883a 1134#if wxUSE_VALIDATORS
f03fc89f
VZ
1135 // associated validator or NULL if none
1136 wxValidator *m_windowValidator;
88ac883a 1137#endif // wxUSE_VALIDATORS
f03fc89f
VZ
1138
1139#if wxUSE_DRAG_AND_DROP
1140 wxDropTarget *m_dropTarget;
1141#endif // wxUSE_DRAG_AND_DROP
1142
1143 // visual window attributes
1144 wxCursor m_cursor;
1b69c815
VZ
1145 wxFont m_font; // see m_hasFont
1146 wxColour m_backgroundColour, // m_hasBgCol
1147 m_foregroundColour; // m_hasFgCol
f03fc89f 1148
789295bf
VZ
1149#if wxUSE_CARET
1150 wxCaret *m_caret;
1151#endif // wxUSE_CARET
1152
f03fc89f
VZ
1153 // the region which should be repainted in response to paint event
1154 wxRegion m_updateRegion;
1155
88ac883a 1156#if wxUSE_ACCEL
f03fc89f
VZ
1157 // the accelerator table for the window which translates key strokes into
1158 // command events
1159 wxAcceleratorTable m_acceleratorTable;
88ac883a 1160#endif // wxUSE_ACCEL
f03fc89f 1161
f03fc89f
VZ
1162 // the tooltip for this window (may be NULL)
1163#if wxUSE_TOOLTIPS
1164 wxToolTip *m_tooltip;
1165#endif // wxUSE_TOOLTIPS
1166
1167 // constraints and sizers
1168#if wxUSE_CONSTRAINTS
1169 // the constraints for this window or NULL
1170 wxLayoutConstraints *m_constraints;
1171
1172 // constraints this window is involved in
1173 wxWindowList *m_constraintsInvolvedIn;
461e93f9 1174#endif // wxUSE_CONSTRAINTS
f03fc89f 1175
be90c029 1176 // this window's sizer
f03fc89f 1177 wxSizer *m_windowSizer;
be90c029
RD
1178
1179 // The sizer this window is a member of, if any
1180 wxSizer *m_containingSizer;
f03fc89f
VZ
1181
1182 // Layout() window automatically when its size changes?
1183 bool m_autoLayout:1;
f03fc89f
VZ
1184
1185 // window state
1186 bool m_isShown:1;
1187 bool m_isEnabled:1;
1188 bool m_isBeingDeleted:1;
1189
23895080
VZ
1190 // was the window colours/font explicitly changed by user?
1191 bool m_hasBgCol:1;
1192 bool m_hasFgCol:1;
1193 bool m_hasFont:1;
a0d9c6cb 1194
f8ff87ed
VS
1195 // and should it be inherited by children?
1196 bool m_inheritBgCol:1;
1197 bool m_inheritFgCol:1;
1198 bool m_inheritFont:1;
23895080 1199
f03fc89f 1200 // window attributes
d80cd92a
VZ
1201 long m_windowStyle,
1202 m_exStyle;
f03fc89f 1203 wxString m_windowName;
a2d93e73 1204 bool m_themeEnabled;
50c53860 1205 wxBackgroundStyle m_backgroundStyle;
071e5fd9 1206#if wxUSE_PALETTE
574c939e 1207 wxPalette m_palette;
b95edd47
VZ
1208 bool m_hasCustomPalette;
1209#endif // wxUSE_PALETTE
574c939e 1210
45a959a3
JS
1211#if wxUSE_ACCESSIBILITY
1212 wxAccessible* m_accessible;
1213#endif
2654f7e4 1214
566d84a7
RL
1215 // Virtual size (scrolling)
1216 wxSize m_virtualSize;
1217
1218 int m_minVirtualWidth; // VirtualSizeHints
1219 int m_minVirtualHeight;
1220 int m_maxVirtualWidth;
1221 int m_maxVirtualHeight;
400a9e41 1222
69d90995 1223 wxWindowVariant m_windowVariant ;
45e0dc94 1224
1e6feb95
VZ
1225 // override this to change the default (i.e. used when no style is
1226 // specified) border for the window class
1227 virtual wxBorder GetDefaultBorder() const;
1228
5c2be659
RD
1229 // Get the default size for the new window if no explicit size given. TLWs
1230 // have their own default size so this is just for non top-level windows.
a0d9c6cb
WS
1231 static int WidthDefault(int w) { return w == wxDefaultCoord ? 20 : w; }
1232 static int HeightDefault(int h) { return h == wxDefaultCoord ? 20 : h; }
f03fc89f 1233
9f884528
RD
1234
1235 // Used to save the results of DoGetBestSize so it doesn't need to be
1236 // recalculated each time the value is needed.
1237 wxSize m_bestSizeCache;
1238
fe161a26
RD
1239 // keep the old name for compatibility, at least until all the internal
1240 // usages of it are changed to SetBestFittingSize
1241 void SetBestSize(const wxSize& size) { SetBestFittingSize(size); }
a0d9c6cb 1242
d3b5db4b 1243 // set the initial window size if none is given (i.e. at least one of the
cab1a605 1244 // components of the size passed to ctor/Create() is wxDefaultCoord)
d3b5db4b
RD
1245 //
1246 // normally just calls SetBestSize() for controls, but can be overridden
1247 // not to do it for the controls which have to do some additional
1248 // initialization (e.g. add strings to list box) before their best size
1249 // can be accurately calculated
1250 virtual void SetInitialBestSize(const wxSize& WXUNUSED(size)) {}
1251
a0d9c6cb 1252
d3b5db4b 1253
f03fc89f
VZ
1254 // more pure virtual functions
1255 // ---------------------------
1256
1257 // NB: we must have DoSomething() function when Something() is an overloaded
1258 // method: indeed, we can't just have "virtual Something()" in case when
1259 // the function is overloaded because then we'd have to make virtual all
1260 // the variants (otherwise only the virtual function may be called on a
1261 // pointer to derived class according to C++ rules) which is, in
1262 // general, absolutely not needed. So instead we implement all
1263 // overloaded Something()s in terms of DoSomething() which will be the
1264 // only one to be virtual.
1265
dabc0cd5
VZ
1266 // coordinates translation
1267 virtual void DoClientToScreen( int *x, int *y ) const = 0;
1268 virtual void DoScreenToClient( int *x, int *y ) const = 0;
1269
1e6feb95
VZ
1270 virtual wxHitTest DoHitTest(wxCoord x, wxCoord y) const;
1271
94633ad9 1272 // capture/release the mouse, used by Capture/ReleaseMouse()
a83e1475
VZ
1273 virtual void DoCaptureMouse() = 0;
1274 virtual void DoReleaseMouse() = 0;
be90c029 1275
f03fc89f
VZ
1276 // retrieve the position/size of the window
1277 virtual void DoGetPosition( int *x, int *y ) const = 0;
1278 virtual void DoGetSize( int *width, int *height ) const = 0;
1279 virtual void DoGetClientSize( int *width, int *height ) const = 0;
1280
f68586e5
VZ
1281 // get the size which best suits the window: for a control, it would be
1282 // the minimal size which doesn't truncate the control, for a panel - the
1283 // same size as it would have after a call to Fit()
1284 virtual wxSize DoGetBestSize() const;
1285
f03fc89f
VZ
1286 // this is the virtual function to be overriden in any derived class which
1287 // wants to change how SetSize() or Move() works - it is called by all
1288 // versions of these functions in the base class
1289 virtual void DoSetSize(int x, int y,
1290 int width, int height,
1291 int sizeFlags = wxSIZE_AUTO) = 0;
1292
1293 // same as DoSetSize() for the client size
1294 virtual void DoSetClientSize(int width, int height) = 0;
1295
9d9b7755
VZ
1296 // move the window to the specified location and resize it: this is called
1297 // from both DoSetSize() and DoSetClientSize() and would usually just
1298 // reposition this window except for composite controls which will want to
1299 // arrange themselves inside the given rectangle
1300 virtual void DoMoveWindow(int x, int y, int width, int height) = 0;
1301
f03fc89f
VZ
1302#if wxUSE_TOOLTIPS
1303 virtual void DoSetToolTip( wxToolTip *tip );
1304#endif // wxUSE_TOOLTIPS
1305
1e6feb95 1306#if wxUSE_MENUS
971562cb 1307 virtual bool DoPopupMenu(wxMenu *menu, int x, int y) = 0;
1e6feb95 1308#endif // wxUSE_MENUS
a1665b22 1309
716e96df
VZ
1310 // Makes an adjustment to the window position to make it relative to the
1311 // parents client area, e.g. if the parent is a frame with a toolbar, its
1312 // (0, 0) is just below the toolbar
1313 virtual void AdjustForParentClientOrigin(int& x, int& y,
1314 int sizeFlags = 0) const;
8d99be5f 1315
69d90995
SC
1316 // implements the window variants
1317 virtual void DoSetWindowVariant( wxWindowVariant variant ) ;
45e0dc94 1318
f03fc89f
VZ
1319private:
1320 // contains the last id generated by NewControlId
1321 static int ms_lastControlId;
1322
a83e1475
VZ
1323 // the stack of windows which have captured the mouse
1324 static struct WXDLLEXPORT wxWindowNext *ms_winCaptureNext;
1325
1e6feb95
VZ
1326 DECLARE_ABSTRACT_CLASS(wxWindowBase)
1327 DECLARE_NO_COPY_CLASS(wxWindowBase)
f03fc89f
VZ
1328 DECLARE_EVENT_TABLE()
1329};
1330
1331// ----------------------------------------------------------------------------
1332// now include the declaration of wxWindow class
1333// ----------------------------------------------------------------------------
1334
1e6feb95 1335// include the declaration of the platform-specific class
4055ed82 1336#if defined(__WXPALMOS__)
ffecfa5a
JS
1337 #ifdef __WXUNIVERSAL__
1338 #define wxWindowNative wxWindowPalm
1339 #else // !wxUniv
1340 #define wxWindowPalm wxWindow
1341 #endif // wxUniv/!wxUniv
1342 #include "wx/palmos/window.h"
1343#elif defined(__WXMSW__)
a5b3669d
VZ
1344 #ifdef __WXUNIVERSAL__
1345 #define wxWindowNative wxWindowMSW
1346 #else // !wxUniv
1e6feb95 1347 #define wxWindowMSW wxWindow
a5b3669d 1348 #endif // wxUniv/!wxUniv
f03fc89f 1349 #include "wx/msw/window.h"
2049ba38 1350#elif defined(__WXMOTIF__)
f03fc89f 1351 #include "wx/motif/window.h"
2049ba38 1352#elif defined(__WXGTK__)
a5b3669d
VZ
1353 #ifdef __WXUNIVERSAL__
1354 #define wxWindowNative wxWindowGTK
1355 #else // !wxUniv
1e6feb95 1356 #define wxWindowGTK wxWindow
1e6feb95 1357 #endif // wxUniv
f03fc89f 1358 #include "wx/gtk/window.h"
83df96d6
JS
1359#elif defined(__WXX11__)
1360 #ifdef __WXUNIVERSAL__
1361 #define wxWindowNative wxWindowX11
1362 #else // !wxUniv
1363 #define wxWindowX11 wxWindow
83df96d6
JS
1364 #endif // wxUniv
1365 #include "wx/x11/window.h"
711c76db 1366#elif defined(__WXMGL__)
386c7058
VS
1367 #ifdef __WXUNIVERSAL__
1368 #define wxWindowNative wxWindowMGL
1369 #else // !wxUniv
1370 #define wxWindowMGL wxWindow
386c7058
VS
1371 #endif // wxUniv
1372 #include "wx/mgl/window.h"
34138703 1373#elif defined(__WXMAC__)
e766c8a9
SC
1374 #ifdef __WXUNIVERSAL__
1375 #define wxWindowNative wxWindowMac
1376 #else // !wxUniv
1377 #define wxWindowMac wxWindow
e766c8a9 1378 #endif // wxUniv
f03fc89f 1379 #include "wx/mac/window.h"
e64df9bc
DE
1380#elif defined(__WXCOCOA__)
1381 #ifdef __WXUNIVERSAL__
1382 #define wxWindowNative wxWindowCocoa
1383 #else // !wxUniv
1384 #define wxWindowCocoa wxWindow
e64df9bc
DE
1385 #endif // wxUniv
1386 #include "wx/cocoa/window.h"
1777b9bb 1387#elif defined(__WXPM__)
210a651b
DW
1388 #ifdef __WXUNIVERSAL__
1389 #define wxWindowNative wxWindowOS2
1390 #else // !wxUniv
1391 #define wxWindowOS2 wxWindow
210a651b 1392 #endif // wxUniv/!wxUniv
1777b9bb 1393 #include "wx/os2/window.h"
c801d85f
KB
1394#endif
1395
1e6feb95
VZ
1396// for wxUniversal, we now derive the real wxWindow from wxWindow<platform>,
1397// for the native ports we already have defined it above
1398#if defined(__WXUNIVERSAL__)
a5b3669d
VZ
1399 #ifndef wxWindowNative
1400 #error "wxWindowNative must be defined above!"
1401 #endif
1402
1e6feb95
VZ
1403 #include "wx/univ/window.h"
1404#endif // wxUniv
1405
f03fc89f
VZ
1406// ----------------------------------------------------------------------------
1407// inline functions which couldn't be declared in the class body because of
1408// forward dependencies
1409// ----------------------------------------------------------------------------
1410
bacd69f9 1411inline wxWindow *wxWindowBase::GetGrandParent() const
f03fc89f
VZ
1412{
1413 return m_parent ? m_parent->GetParent() : (wxWindow *)NULL;
1414}
1415
1416// ----------------------------------------------------------------------------
3723b7b1 1417// global functions
f03fc89f
VZ
1418// ----------------------------------------------------------------------------
1419
3723b7b1
JS
1420// Find the wxWindow at the current mouse position, also returning the mouse
1421// position.
16cba29d 1422extern WXDLLEXPORT wxWindow* wxFindWindowAtPointer(wxPoint& pt);
3723b7b1
JS
1423
1424// Get the current mouse position.
16cba29d 1425extern WXDLLEXPORT wxPoint wxGetMousePosition();
3723b7b1 1426
1e6feb95 1427// get the currently active window of this application or NULL
16cba29d 1428extern WXDLLEXPORT wxWindow *wxGetActiveWindow();
1e6feb95 1429
33b494d6
VZ
1430// get the (first) top level parent window
1431WXDLLEXPORT wxWindow* wxGetTopLevelParent(wxWindow *win);
1432
f68586e5 1433// deprecated (doesn't start with 'wx' prefix), use wxWindow::NewControlId()
6d56eb5c 1434inline int NewControlId() { return wxWindowBase::NewControlId(); }
f03fc89f 1435
45a959a3
JS
1436#if wxUSE_ACCESSIBILITY
1437// ----------------------------------------------------------------------------
1438// accessible object for windows
1439// ----------------------------------------------------------------------------
1440
1441class WXDLLEXPORT wxWindowAccessible: public wxAccessible
1442{
1443public:
f81387bd 1444 wxWindowAccessible(wxWindow* win): wxAccessible(win) { if (win) win->SetAccessible(this); }
6fb99eb3 1445 virtual ~wxWindowAccessible() {}
45a959a3
JS
1446
1447// Overridables
1448
1449 // Can return either a child object, or an integer
1450 // representing the child element, starting from 1.
1451 virtual wxAccStatus HitTest(const wxPoint& pt, int* childId, wxAccessible** childObject);
1452
1453 // Returns the rectangle for this object (id = 0) or a child element (id > 0).
1454 virtual wxAccStatus GetLocation(wxRect& rect, int elementId);
1455
1456 // Navigates from fromId to toId/toObject.
1457 virtual wxAccStatus Navigate(wxNavDir navDir, int fromId,
1458 int* toId, wxAccessible** toObject);
1459
1460 // Gets the name of the specified object.
1461 virtual wxAccStatus GetName(int childId, wxString* name);
1462
1463 // Gets the number of children.
a37e4a07 1464 virtual wxAccStatus GetChildCount(int* childCount);
45a959a3
JS
1465
1466 // Gets the specified child (starting from 1).
1467 // If *child is NULL and return value is wxACC_OK,
1468 // this means that the child is a simple element and
1469 // not an accessible object.
1470 virtual wxAccStatus GetChild(int childId, wxAccessible** child);
1471
1472 // Gets the parent, or NULL.
1473 virtual wxAccStatus GetParent(wxAccessible** parent);
1474
1475 // Performs the default action. childId is 0 (the action for this object)
1476 // or > 0 (the action for a child).
1477 // Return wxACC_NOT_SUPPORTED if there is no default action for this
1478 // window (e.g. an edit control).
1479 virtual wxAccStatus DoDefaultAction(int childId);
1480
1481 // Gets the default action for this object (0) or > 0 (the action for a child).
1482 // Return wxACC_OK even if there is no action. actionName is the action, or the empty
1483 // string if there is no action.
1484 // The retrieved string describes the action that is performed on an object,
1485 // not what the object does as a result. For example, a toolbar button that prints
1486 // a document has a default action of "Press" rather than "Prints the current document."
1487 virtual wxAccStatus GetDefaultAction(int childId, wxString* actionName);
1488
1489 // Returns the description for this object or a child.
1490 virtual wxAccStatus GetDescription(int childId, wxString* description);
1491
1492 // Returns help text for this object or a child, similar to tooltip text.
1493 virtual wxAccStatus GetHelpText(int childId, wxString* helpText);
1494
1495 // Returns the keyboard shortcut for this object or child.
1496 // Return e.g. ALT+K
1497 virtual wxAccStatus GetKeyboardShortcut(int childId, wxString* shortcut);
1498
1499 // Returns a role constant.
1500 virtual wxAccStatus GetRole(int childId, wxAccRole* role);
1501
1502 // Returns a state constant.
1503 virtual wxAccStatus GetState(int childId, long* state);
1504
1505 // Returns a localized string representing the value for the object
1506 // or child.
1507 virtual wxAccStatus GetValue(int childId, wxString* strValue);
1508
1509 // Selects the object or child.
1510 virtual wxAccStatus Select(int childId, wxAccSelectionFlags selectFlags);
1511
1512 // Gets the window with the keyboard focus.
1513 // If childId is 0 and child is NULL, no object in
1514 // this subhierarchy has the focus.
1515 // If this object has the focus, child should be 'this'.
1516 virtual wxAccStatus GetFocus(int* childId, wxAccessible** child);
1517
1518 // Gets a variant representing the selected children
1519 // of this object.
1520 // Acceptable values:
d4864e97 1521 // - a null variant (IsNull() returns true)
45a959a3
JS
1522 // - a list variant (GetType() == wxT("list")
1523 // - an integer representing the selected child element,
1524 // or 0 if this object is selected (GetType() == wxT("long")
1525 // - a "void*" pointer to a wxAccessible child object
1526 virtual wxAccStatus GetSelections(wxVariant* selections);
1527};
1528
1529#endif // wxUSE_ACCESSIBILITY
1530
1531
c801d85f 1532#endif
34138703 1533 // _WX_WINDOW_H_BASE_
34c3ffca 1534