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