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