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