/[pcsx2_0.9.7]/branch/r3113_0.9.7_beta/3rdparty/wxWidgets/include/wx/window.h
ViewVC logotype

Contents of /branch/r3113_0.9.7_beta/3rdparty/wxWidgets/include/wx/window.h

Parent Directory Parent Directory | Revision Log Revision Log


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

  ViewVC Help
Powered by ViewVC 1.1.22