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