]> git.saurik.com Git - wxWidgets.git/blob - include/wx/window.h
Added simplistic makefile/project files for wxWinCE.
[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) wxWindows team
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
11
12 #ifndef _WX_WINDOW_H_BASE_
13 #define _WX_WINDOW_H_BASE_
14
15 #if defined(__GNUG__) && !defined(__APPLE__)
16 #pragma interface "windowbase.h"
17 #endif
18
19 // ----------------------------------------------------------------------------
20 // headers which we must include here
21 // ----------------------------------------------------------------------------
22
23 #include "wx/event.h" // the base class
24
25 #include "wx/list.h" // defines wxWindowList
26
27 #include "wx/cursor.h" // we have member variables of these classes
28 #include "wx/font.h" // so we can't do without them
29 #include "wx/colour.h"
30 #include "wx/region.h"
31 #include "wx/utils.h"
32
33 #include "wx/validate.h" // for wxDefaultValidator (always include it)
34
35 #if wxUSE_PALETTE
36 #include "wx/dcclient.h"
37 #include "wx/palette.h"
38 #endif // wxUSE_PALETTE
39
40 #if wxUSE_ACCEL
41 #include "wx/accel.h"
42 #endif // wxUSE_ACCEL
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 // __WXMSW__
49 #define wxUSE_MENUS_NATIVE wxUSE_MENUS
50 #endif // __WXUNIVERSAL__/__WXMSW__
51
52 // ----------------------------------------------------------------------------
53 // forward declarations
54 // ----------------------------------------------------------------------------
55
56 class WXDLLEXPORT wxCaret;
57 class WXDLLEXPORT wxControl;
58 class WXDLLEXPORT wxCursor;
59 class WXDLLEXPORT wxDC;
60 class WXDLLEXPORT wxDropTarget;
61 class WXDLLEXPORT wxItemResource;
62 class WXDLLEXPORT wxLayoutConstraints;
63 class WXDLLEXPORT wxResourceTable;
64 class WXDLLEXPORT wxSizer;
65 class WXDLLEXPORT wxToolTip;
66 class WXDLLEXPORT wxWindowBase;
67 class WXDLLEXPORT wxWindow;
68
69 // ----------------------------------------------------------------------------
70 // (pseudo)template list classes
71 // ----------------------------------------------------------------------------
72
73 WX_DECLARE_LIST_3(wxWindow, wxWindowBase, wxWindowList, wxWindowListNode, class WXDLLEXPORT);
74
75 // ----------------------------------------------------------------------------
76 // global variables
77 // ----------------------------------------------------------------------------
78
79 WXDLLEXPORT_DATA(extern wxWindowList) wxTopLevelWindows;
80
81 // ----------------------------------------------------------------------------
82 // wxWindowBase is the base class for all GUI controls/widgets, this is the public
83 // interface of this class.
84 //
85 // Event handler: windows have themselves as their event handlers by default,
86 // but their event handlers could be set to another object entirely. This
87 // separation can reduce the amount of derivation required, and allow
88 // alteration of a window's functionality (e.g. by a resource editor that
89 // temporarily switches event handlers).
90 // ----------------------------------------------------------------------------
91
92 class WXDLLEXPORT wxWindowBase : public wxEvtHandler
93 {
94 public:
95 // creating the window
96 // -------------------
97
98 // default ctor
99 wxWindowBase() { InitBase(); }
100
101 // pseudo ctor (can't be virtual, called from ctor)
102 bool CreateBase(wxWindowBase *parent,
103 wxWindowID id,
104 const wxPoint& pos = wxDefaultPosition,
105 const wxSize& size = wxDefaultSize,
106 long style = 0,
107 const wxValidator& validator = wxDefaultValidator,
108 const wxString& name = wxPanelNameStr);
109
110 virtual ~wxWindowBase();
111
112 #if wxUSE_WX_RESOURCES
113 // these functions are implemented in resource.cpp and resourc2.cpp
114 virtual bool LoadFromResource(wxWindow *parent,
115 const wxString& resourceName,
116 const wxResourceTable *table = (const wxResourceTable *) NULL);
117 virtual wxControl *CreateItem(const wxItemResource* childResource,
118 const wxItemResource* parentResource,
119 const wxResourceTable *table = (const wxResourceTable *) NULL);
120 #endif // wxUSE_WX_RESOURCES
121
122 // deleting the window
123 // -------------------
124
125 // ask the window to close itself, return TRUE if the event handler
126 // honoured our request
127 bool Close( bool force = FALSE );
128
129 // the following functions delete the C++ objects (the window itself
130 // or its children) as well as the GUI windows and normally should
131 // never be used directly
132
133 // delete window unconditionally (dangerous!), returns TRUE if ok
134 virtual bool Destroy();
135 // delete all children of this window, returns TRUE if ok
136 bool DestroyChildren();
137
138 // is the window being deleted?
139 bool IsBeingDeleted() const { return m_isBeingDeleted; }
140
141 // window attributes
142 // -----------------
143
144 // NB: in future versions of wxWindows Set/GetTitle() will only work
145 // with the top level windows (such as dialogs and frames) and
146 // Set/GetLabel() only with the other ones (i.e. all controls).
147
148 // the title (or label, see below) of the window: the text which the
149 // window shows
150 virtual void SetTitle( const wxString& WXUNUSED(title) ) {}
151 virtual wxString GetTitle() const { return wxEmptyString; }
152
153 // label is just the same as the title (but for, e.g., buttons it
154 // makes more sense to speak about labels)
155 virtual void SetLabel(const wxString& label) { SetTitle(label); }
156 virtual wxString GetLabel() const { return GetTitle(); }
157
158 // the window name is used for ressource setting in X, it is not the
159 // same as the window title/label
160 virtual void SetName( const wxString &name ) { m_windowName = name; }
161 virtual wxString GetName() const { return m_windowName; }
162
163 // window id uniquely identifies the window among its siblings unless
164 // it is -1 which means "don't care"
165 void SetId( wxWindowID id ) { m_windowId = id; }
166 wxWindowID GetId() const { return m_windowId; }
167
168 // generate a control id for the controls which were not given one by
169 // user
170 static int NewControlId() { return --ms_lastControlId; }
171 // get the id of the control following the one with the given
172 // (autogenerated) id
173 static int NextControlId(int id) { return id - 1; }
174 // get the id of the control preceding the one with the given
175 // (autogenerated) id
176 static int PrevControlId(int id) { return id + 1; }
177
178 // moving/resizing
179 // ---------------
180
181 // set the window size and/or position
182 void SetSize( int x, int y, int width, int height,
183 int sizeFlags = wxSIZE_AUTO )
184 { DoSetSize(x, y, width, height, sizeFlags); }
185
186 void SetSize( int width, int height )
187 { DoSetSize( -1, -1, width, height, wxSIZE_USE_EXISTING ); }
188
189 void SetSize( const wxSize& size )
190 { SetSize( size.x, size.y); }
191
192 void SetSize(const wxRect& rect, int sizeFlags = wxSIZE_AUTO)
193 { DoSetSize(rect.x, rect.y, rect.width, rect.height, sizeFlags); }
194
195 void Move(int x, int y, int flags = wxSIZE_USE_EXISTING)
196 { DoSetSize(x, y, -1, -1, flags); }
197
198 void Move(const wxPoint& pt, int flags = wxSIZE_USE_EXISTING)
199 { Move(pt.x, pt.y, flags); }
200
201 // Z-order
202 virtual void Raise() = 0;
203 virtual void Lower() = 0;
204
205 // client size is the size of area available for subwindows
206 void SetClientSize( int width, int height )
207 { DoSetClientSize(width, height); }
208
209 void SetClientSize( const wxSize& size )
210 { DoSetClientSize(size.x, size.y); }
211
212 void SetClientSize(const wxRect& rect)
213 { SetClientSize( rect.width, rect.height ); }
214
215 // get the window position and/or size (pointers may be NULL)
216 void GetPosition( int *x, int *y ) const { DoGetPosition(x, y); }
217 wxPoint GetPosition() const
218 {
219 int w, h;
220 DoGetPosition(&w, &h);
221
222 return wxPoint(w, h);
223 }
224
225 void GetSize( int *w, int *h ) const { DoGetSize(w, h); }
226 wxSize GetSize() const
227 {
228 int w, h;
229 DoGetSize(& w, & h);
230 return wxSize(w, h);
231 }
232
233 wxRect GetRect() const
234 {
235 int x, y, w, h;
236 GetPosition(& x, & y);
237 GetSize(& w, & h);
238
239 return wxRect(x, y, w, h);
240 }
241
242 void GetClientSize( int *w, int *h ) const { DoGetClientSize(w, h); }
243 wxSize GetClientSize() const
244 {
245 int w, h;
246 DoGetClientSize(& w, & h);
247
248 return wxSize(w, h);
249 }
250
251 // get the origin of the client area of the window relative to the
252 // window top left corner (the client area may be shifted because of
253 // the borders, scrollbars, other decorations...)
254 virtual wxPoint GetClientAreaOrigin() const;
255
256 // get the client rectangle in window (i.e. client) coordinates
257 wxRect GetClientRect() const
258 {
259 return wxRect(GetClientAreaOrigin(), GetClientSize());
260 }
261
262 // get the size best suited for the window (in fact, minimal
263 // acceptable size using which it will still look "nice")
264 wxSize GetBestSize() const { return DoGetBestSize(); }
265 void GetBestSize(int *w, int *h) const
266 {
267 wxSize s = DoGetBestSize();
268 if ( w )
269 *w = s.x;
270 if ( h )
271 *h = s.y;
272 }
273
274 // There are times (and windows) where 'Best' size and 'Min' size
275 // are vastly out of sync. This should be remedied somehow, but in
276 // the meantime, this method will return the larger of BestSize
277 // (the window's smallest legible size), and any user specified
278 // MinSize hint.
279 wxSize GetAdjustedBestSize() const
280 {
281 wxSize s( DoGetBestSize() );
282 return wxSize( wxMax( s.x, GetMinWidth() ), wxMax( s.y, GetMinHeight() ) );
283 }
284
285 // the generic centre function - centers the window on parent by`
286 // default or on screen if it doesn't have parent or
287 // wxCENTER_ON_SCREEN flag is given
288 void Centre( int direction = wxBOTH );
289 void Center( int direction = wxBOTH ) { Centre(direction); }
290
291 // centre on screen (only works for top level windows)
292 void CentreOnScreen(int dir = wxBOTH) { Centre(dir | wxCENTER_ON_SCREEN); }
293 void CenterOnScreen(int dir = wxBOTH) { CentreOnScreen(dir); }
294
295 // centre with respect to the the parent window
296 void CentreOnParent(int dir = wxBOTH) { Centre(dir | wxCENTER_FRAME); }
297 void CenterOnParent(int dir = wxBOTH) { CentreOnParent(dir); }
298
299 // set window size to wrap around its children
300 virtual void Fit();
301
302 // set virtual size to satisfy children
303 virtual void FitInside();
304
305 // set min/max size of the window
306 virtual void SetSizeHints( int minW, int minH,
307 int maxW = -1, int maxH = -1,
308 int incW = -1, int incH = -1 );
309
310 virtual void SetVirtualSizeHints( int minW, int minH,
311 int maxW = -1, int maxH = -1 );
312
313 virtual int GetMinWidth() const { return m_minWidth; }
314 virtual int GetMinHeight() const { return m_minHeight; }
315 int GetMaxWidth() const { return m_maxWidth; }
316 int GetMaxHeight() const { return m_maxHeight; }
317
318 // Override this method to control the values given to Sizers etc.
319 virtual wxSize GetMaxSize() const { return wxSize( m_maxWidth, m_maxHeight ); }
320
321 // Methods for accessing the virtual size of a window. For most
322 // windows this is just the client area of the window, but for
323 // some like scrolled windows it is more or less independent of
324 // the screen window size. You may override the DoXXXVirtual
325 // methods below for classes where that is is the case.
326
327 void SetVirtualSize( const wxSize &size ) { DoSetVirtualSize( size.x, size.y ); }
328 void SetVirtualSize( int x, int y ) { DoSetVirtualSize( x, y ); }
329
330 wxSize GetVirtualSize() const { return DoGetVirtualSize(); }
331 void GetVirtualSize( int *x, int *y ) const
332 {
333 wxSize s( DoGetVirtualSize() );
334
335 if( x )
336 *x = s.GetWidth();
337 if( y )
338 *y = s.GetHeight();
339 }
340
341 // Override these methods for windows that have a virtual size
342 // independent of their client size. eg. the virtual area of a
343 // wxScrolledWindow. Default is to alias VirtualSize to ClientSize.
344
345 virtual void DoSetVirtualSize( int x, int y );
346 virtual wxSize DoGetVirtualSize() const; // { return m_virtualSize; }
347
348 // Return the largest of ClientSize and BestSize (as determined
349 // by a sizer, interior children, or other means)
350
351 virtual wxSize GetBestVirtualSize() const
352 {
353 wxSize client( GetClientSize() );
354 wxSize best( GetBestSize() );
355
356 return wxSize( wxMax( client.x, best.x ), wxMax( client.y, best.y ) );
357 }
358
359 // window state
360 // ------------
361
362 // returns TRUE if window was shown/hidden, FALSE if the nothing was
363 // done (window was already shown/hidden)
364 virtual bool Show( bool show = TRUE );
365 bool Hide() { return Show(FALSE); }
366
367 // returns TRUE if window was enabled/disabled, FALSE if nothing done
368 virtual bool Enable( bool enable = TRUE );
369 bool Disable() { return Enable(FALSE); }
370
371 bool IsShown() const { return m_isShown; }
372 bool IsEnabled() const { return m_isEnabled; }
373
374 // get/set window style (setting style won't update the window and so
375 // is only useful for internal usage)
376 virtual void SetWindowStyleFlag( long style ) { m_windowStyle = style; }
377 virtual long GetWindowStyleFlag() const { return m_windowStyle; }
378
379 // just some (somewhat shorter) synonims
380 void SetWindowStyle( long style ) { SetWindowStyleFlag(style); }
381 long GetWindowStyle() const { return GetWindowStyleFlag(); }
382
383 bool HasFlag(int flag) const { return (m_windowStyle & flag) != 0; }
384 virtual bool IsRetained() const { return HasFlag(wxRETAINED); }
385
386 // extra style: the less often used style bits which can't be set with
387 // SetWindowStyleFlag()
388 virtual void SetExtraStyle(long exStyle) { m_exStyle = exStyle; }
389 long GetExtraStyle() const { return m_exStyle; }
390
391 // make the window modal (all other windows unresponsive)
392 virtual void MakeModal(bool modal = TRUE);
393
394 virtual void SetThemeEnabled(bool enableTheme) { m_themeEnabled = enableTheme; }
395 virtual bool GetThemeEnabled() const { return m_themeEnabled; }
396
397 // focus and keyboard handling
398 // ---------------------------
399
400 // set focus to this window
401 virtual void SetFocus() = 0;
402
403 // set focus to this window as the result of a keyboard action
404 virtual void SetFocusFromKbd() { SetFocus(); }
405
406 // return the window which currently has the focus or NULL
407 static wxWindow *FindFocus() /* = 0: implement in derived classes */;
408
409 // can this window have focus?
410 virtual bool AcceptsFocus() const { return IsShown() && IsEnabled(); }
411
412 // can this window be given focus by keyboard navigation? if not, the
413 // only way to give it focus (provided it accepts it at all) is to
414 // click it
415 virtual bool AcceptsFocusFromKeyboard() const { return AcceptsFocus(); }
416
417 // NB: these methods really don't belong here but with the current
418 // class hierarchy there is no other place for them :-(
419
420 // get the default child of this parent, i.e. the one which is
421 // activated by pressing <Enter>
422 virtual wxWindow *GetDefaultItem() const { return NULL; }
423
424 // set this child as default, return the old default
425 virtual wxWindow *SetDefaultItem(wxWindow * WXUNUSED(child))
426 { return NULL; }
427
428 // set this child as temporary default
429 virtual void SetTmpDefaultItem(wxWindow * WXUNUSED(win)) { }
430
431 // parent/children relations
432 // -------------------------
433
434 // get the list of children
435 const wxWindowList& GetChildren() const { return m_children; }
436 wxWindowList& GetChildren() { return m_children; }
437
438 // get the parent or the parent of the parent
439 wxWindow *GetParent() const { return m_parent; }
440 inline wxWindow *GetGrandParent() const;
441
442 // is this window a top level one?
443 virtual bool IsTopLevel() const;
444
445 // it doesn't really change parent, use ReParent() instead
446 void SetParent( wxWindowBase *parent ) { m_parent = (wxWindow *)parent; }
447 // change the real parent of this window, return TRUE if the parent
448 // was changed, FALSE otherwise (error or newParent == oldParent)
449 virtual bool Reparent( wxWindowBase *newParent );
450
451 // implementation mostly
452 virtual void AddChild( wxWindowBase *child );
453 virtual void RemoveChild( wxWindowBase *child );
454
455 // looking for windows
456 // -------------------
457
458 // find window among the descendants of this one either by id or by
459 // name (return NULL if not found)
460 wxWindow *FindWindow( long id );
461 wxWindow *FindWindow( const wxString& name );
462
463 // Find a window among any window (all return NULL if not found)
464 static wxWindow *FindWindowById( long id, const wxWindow *parent = NULL );
465 static wxWindow *FindWindowByName( const wxString& name,
466 const wxWindow *parent = NULL );
467 static wxWindow *FindWindowByLabel( const wxString& label,
468 const wxWindow *parent = NULL );
469
470 // event handler stuff
471 // -------------------
472
473 // get the current event handler
474 wxEvtHandler *GetEventHandler() const { return m_eventHandler; }
475
476 // replace the event handler (allows to completely subclass the
477 // window)
478 void SetEventHandler( wxEvtHandler *handler ) { m_eventHandler = handler; }
479
480 // push/pop event handler: allows to chain a custom event handler to
481 // alreasy existing ones
482 void PushEventHandler( wxEvtHandler *handler );
483 wxEvtHandler *PopEventHandler( bool deleteHandler = FALSE );
484
485 // find the given handler in the event handler chain and remove (but
486 // not delete) it from the event handler chain, return TRUE if it was
487 // found and FALSE otherwise (this also results in an assert failure so
488 // this function should only be called when the handler is supposed to
489 // be there)
490 bool RemoveEventHandler(wxEvtHandler *handler);
491
492 // validators
493 // ----------
494
495 #if wxUSE_VALIDATORS
496 // a window may have an associated validator which is used to control
497 // user input
498 virtual void SetValidator( const wxValidator &validator );
499 virtual wxValidator *GetValidator() { return m_windowValidator; }
500 #endif // wxUSE_VALIDATORS
501
502
503 // dialog oriented functions
504 // -------------------------
505
506 // validate the correctness of input, return TRUE if ok
507 virtual bool Validate();
508
509 // transfer data between internal and GUI representations
510 virtual bool TransferDataToWindow();
511 virtual bool TransferDataFromWindow();
512
513 virtual void InitDialog();
514
515 #if wxUSE_ACCEL
516 // accelerators
517 // ------------
518 virtual void SetAcceleratorTable( const wxAcceleratorTable& accel )
519 { m_acceleratorTable = accel; }
520 wxAcceleratorTable *GetAcceleratorTable()
521 { return &m_acceleratorTable; }
522 #endif // wxUSE_ACCEL
523
524 // dialog units translations
525 // -------------------------
526
527 wxPoint ConvertPixelsToDialog( const wxPoint& pt );
528 wxPoint ConvertDialogToPixels( const wxPoint& pt );
529 wxSize ConvertPixelsToDialog( const wxSize& sz )
530 {
531 wxPoint pt(ConvertPixelsToDialog(wxPoint(sz.x, sz.y)));
532
533 return wxSize(pt.x, pt.y);
534 }
535
536 wxSize ConvertDialogToPixels( const wxSize& sz )
537 {
538 wxPoint pt(ConvertDialogToPixels(wxPoint(sz.x, sz.y)));
539
540 return wxSize(pt.x, pt.y);
541 }
542
543 // mouse functions
544 // ---------------
545
546 // move the mouse to the specified position
547 virtual void WarpPointer(int x, int y) = 0;
548
549 // start or end mouse capture, these functions maintain the stack of
550 // windows having captured the mouse and after calling ReleaseMouse()
551 // the mouse is not released but returns to the window which had had
552 // captured it previously (if any)
553 void CaptureMouse();
554 void ReleaseMouse();
555
556 // get the window which currently captures the mouse or NULL
557 static wxWindow *GetCapture();
558
559 // does this window have the capture?
560 virtual bool HasCapture() const
561 { return (wxWindow *)this == GetCapture(); }
562
563 // painting the window
564 // -------------------
565
566 // mark the specified rectangle (or the whole window) as "dirty" so it
567 // will be repainted
568 virtual void Refresh( bool eraseBackground = TRUE,
569 const wxRect *rect = (const wxRect *) NULL ) = 0;
570
571 // a less awkward wrapper for Refresh
572 void RefreshRect(const wxRect& rect) { Refresh(TRUE, &rect); }
573
574 // repaint all invalid areas of the window immediately
575 virtual void Update() { }
576
577 // clear the window entirely
578 virtual void Clear() = 0;
579
580 // freeze the window: don't redraw it until it is thawed
581 virtual void Freeze() { }
582
583 // thaw the window: redraw it after it had been frozen
584 virtual void Thaw() { }
585
586 // adjust DC for drawing on this window
587 virtual void PrepareDC( wxDC & WXUNUSED(dc) ) { }
588
589 // the update region of the window contains the areas which must be
590 // repainted by the program
591 const wxRegion& GetUpdateRegion() const { return m_updateRegion; }
592 wxRegion& GetUpdateRegion() { return m_updateRegion; }
593
594 // get the update rectangleregion bounding box in client coords
595 wxRect GetUpdateClientRect() const;
596
597 // these functions verify whether the given point/rectangle belongs to
598 // (or at least intersects with) the update region
599 bool IsExposed( int x, int y ) const;
600 bool IsExposed( int x, int y, int w, int h ) const;
601
602 bool IsExposed( const wxPoint& pt ) const
603 { return IsExposed(pt.x, pt.y); }
604 bool IsExposed( const wxRect& rect ) const
605 { return IsExposed(rect.x, rect.y, rect.width, rect.height); }
606
607 // colours, fonts and cursors
608 // --------------------------
609
610 // set/retrieve the window colours (system defaults are used by
611 // default): Set functions return TRUE if colour was changed
612 virtual bool SetBackgroundColour( const wxColour &colour );
613 virtual bool SetForegroundColour( const wxColour &colour );
614
615 wxColour GetBackgroundColour() const { return m_backgroundColour; }
616 wxColour GetForegroundColour() const { return m_foregroundColour; }
617
618 // set/retrieve the cursor for this window (SetCursor() returns TRUE
619 // if the cursor was really changed)
620 virtual bool SetCursor( const wxCursor &cursor );
621 const wxCursor& GetCursor() const { return m_cursor; }
622 wxCursor& GetCursor() { return m_cursor; }
623
624 // set/retrieve the font for the window (SetFont() returns TRUE if the
625 // font really changed)
626 virtual bool SetFont( const wxFont &font ) = 0;
627 const wxFont& GetFont() const { return m_font; }
628 wxFont& GetFont() { return m_font; }
629
630 #if wxUSE_CARET
631 // associate a caret with the window
632 void SetCaret(wxCaret *caret);
633 // get the current caret (may be NULL)
634 wxCaret *GetCaret() const { return m_caret; }
635 #endif // wxUSE_CARET
636
637 // get the (average) character size for the current font
638 virtual int GetCharHeight() const = 0;
639 virtual int GetCharWidth() const = 0;
640
641 // get the width/height/... of the text using current or specified
642 // font
643 virtual void GetTextExtent(const wxString& string,
644 int *x, int *y,
645 int *descent = (int *) NULL,
646 int *externalLeading = (int *) NULL,
647 const wxFont *theFont = (const wxFont *) NULL)
648 const = 0;
649
650 // client <-> screen coords
651 // ------------------------
652
653 // translate to/from screen/client coordinates (pointers may be NULL)
654 void ClientToScreen( int *x, int *y ) const
655 { DoClientToScreen(x, y); }
656 void ScreenToClient( int *x, int *y ) const
657 { DoScreenToClient(x, y); }
658
659 // wxPoint interface to do the same thing
660 wxPoint ClientToScreen(const wxPoint& pt) const
661 {
662 int x = pt.x, y = pt.y;
663 DoClientToScreen(&x, &y);
664
665 return wxPoint(x, y);
666 }
667
668 wxPoint ScreenToClient(const wxPoint& pt) const
669 {
670 int x = pt.x, y = pt.y;
671 DoScreenToClient(&x, &y);
672
673 return wxPoint(x, y);
674 }
675
676 // test where the given (in client coords) point lies
677 wxHitTest HitTest(wxCoord x, wxCoord y) const
678 { return DoHitTest(x, y); }
679
680 wxHitTest HitTest(const wxPoint& pt) const
681 { return DoHitTest(pt.x, pt.y); }
682
683 // misc
684 // ----
685
686 // get the window border style: uses the current style and falls back to
687 // the default style for this class otherwise (see GetDefaultBorder())
688 wxBorder GetBorder() const;
689
690 void UpdateWindowUI();
691
692 #if wxUSE_MENUS
693 bool PopupMenu( wxMenu *menu, const wxPoint& pos )
694 { return DoPopupMenu(menu, pos.x, pos.y); }
695 bool PopupMenu( wxMenu *menu, int x, int y )
696 { return DoPopupMenu(menu, x, y); }
697 #endif // wxUSE_MENUS
698
699 // scrollbars
700 // ----------
701
702 // does the window have the scrollbar for this orientation?
703 bool HasScrollbar(int orient) const
704 {
705 return (m_windowStyle &
706 (orient == wxHORIZONTAL ? wxHSCROLL : wxVSCROLL)) != 0;
707 }
708
709 // configure the window scrollbars
710 virtual void SetScrollbar( int orient,
711 int pos,
712 int thumbvisible,
713 int range,
714 bool refresh = TRUE ) = 0;
715 virtual void SetScrollPos( int orient, int pos, bool refresh = TRUE ) = 0;
716 virtual int GetScrollPos( int orient ) const = 0;
717 virtual int GetScrollThumb( int orient ) const = 0;
718 virtual int GetScrollRange( int orient ) const = 0;
719
720 // scroll window to the specified position
721 virtual void ScrollWindow( int dx, int dy,
722 const wxRect* rect = (wxRect *) NULL ) = 0;
723
724 // scrolls window by line/page: note that not all controls support this
725 //
726 // return TRUE if the position changed, FALSE otherwise
727 virtual bool ScrollLines(int WXUNUSED(lines)) { return FALSE; }
728 virtual bool ScrollPages(int WXUNUSED(pages)) { return FALSE; }
729
730 // convenient wrappers for ScrollLines/Pages
731 bool LineUp() { return ScrollLines(-1); }
732 bool LineDown() { return ScrollLines(1); }
733 bool PageUp() { return ScrollPages(-1); }
734 bool PageDown() { return ScrollPages(1); }
735
736 // context-sensitive help
737 // ----------------------
738
739 // these are the convenience functions wrapping wxHelpProvider methods
740
741 #if wxUSE_HELP
742 // associate this help text with this window
743 void SetHelpText(const wxString& text);
744 // associate this help text with all windows with the same id as this
745 // one
746 void SetHelpTextForId(const wxString& text);
747 // get the help string associated with this window (may be empty)
748 wxString GetHelpText() const;
749 #endif // wxUSE_HELP
750
751 // tooltips
752 // --------
753
754 #if wxUSE_TOOLTIPS
755 // the easiest way to set a tooltip for a window is to use this method
756 void SetToolTip( const wxString &tip );
757 // attach a tooltip to the window
758 void SetToolTip( wxToolTip *tip ) { DoSetToolTip(tip); }
759 // get the associated tooltip or NULL if none
760 wxToolTip* GetToolTip() const { return m_tooltip; }
761 #endif // wxUSE_TOOLTIPS
762
763 // drag and drop
764 // -------------
765 #if wxUSE_DRAG_AND_DROP
766 // set/retrieve the drop target associated with this window (may be
767 // NULL; it's owned by the window and will be deleted by it)
768 virtual void SetDropTarget( wxDropTarget *dropTarget ) = 0;
769 virtual wxDropTarget *GetDropTarget() const { return m_dropTarget; }
770 #endif // wxUSE_DRAG_AND_DROP
771
772 // constraints and sizers
773 // ----------------------
774 #if wxUSE_CONSTRAINTS
775 // set the constraints for this window or retrieve them (may be NULL)
776 void SetConstraints( wxLayoutConstraints *constraints );
777 wxLayoutConstraints *GetConstraints() const { return m_constraints; }
778
779 // implementation only
780 void UnsetConstraints(wxLayoutConstraints *c);
781 wxWindowList *GetConstraintsInvolvedIn() const
782 { return m_constraintsInvolvedIn; }
783 void AddConstraintReference(wxWindowBase *otherWin);
784 void RemoveConstraintReference(wxWindowBase *otherWin);
785 void DeleteRelatedConstraints();
786 void ResetConstraints();
787
788 // these methods may be overriden for special layout algorithms
789 virtual void SetConstraintSizes(bool recurse = TRUE);
790 virtual bool LayoutPhase1(int *noChanges);
791 virtual bool LayoutPhase2(int *noChanges);
792 virtual bool DoPhase(int phase);
793
794 // these methods are virtual but normally won't be overridden
795 virtual void SetSizeConstraint(int x, int y, int w, int h);
796 virtual void MoveConstraint(int x, int y);
797 virtual void GetSizeConstraint(int *w, int *h) const ;
798 virtual void GetClientSizeConstraint(int *w, int *h) const ;
799 virtual void GetPositionConstraint(int *x, int *y) const ;
800
801 #endif // wxUSE_CONSTRAINTS
802
803 // when using constraints or sizers, it makes sense to update
804 // children positions automatically whenever the window is resized
805 // - this is done if autoLayout is on
806 void SetAutoLayout( bool autoLayout ) { m_autoLayout = autoLayout; }
807 bool GetAutoLayout() const { return m_autoLayout; }
808
809 // lay out the window and its children
810 virtual bool Layout();
811
812 // sizers
813 void SetSizer(wxSizer *sizer, bool deleteOld = TRUE );
814 void SetSizerAndFit( wxSizer *sizer, bool deleteOld = TRUE );
815
816 wxSizer *GetSizer() const { return m_windowSizer; }
817
818 // Track if this window is a member of a sizer
819 void SetContainingSizer(wxSizer* sizer) { m_containingSizer = sizer; }
820 wxSizer *GetContainingSizer() const { return m_containingSizer; }
821
822 // backward compatibility
823 // ----------------------
824 #if WXWIN_COMPATIBILITY
825 bool Enabled() const { return IsEnabled(); }
826
827 void SetButtonFont(const wxFont& font) { SetFont(font); }
828 void SetLabelFont(const wxFont& font) { SetFont(font); }
829 wxFont& GetLabelFont() { return GetFont(); };
830 wxFont& GetButtonFont() { return GetFont(); };
831 #endif // WXWIN_COMPATIBILITY
832
833 // implementation
834 // --------------
835
836 // event handlers
837 void OnSysColourChanged( wxSysColourChangedEvent& event );
838 void OnInitDialog( wxInitDialogEvent &event );
839 void OnMiddleClick( wxMouseEvent& event );
840 #if wxUSE_HELP
841 void OnHelp(wxHelpEvent& event);
842 #endif // wxUSE_HELP
843
844 // get the haqndle of the window for the underlying window system: this
845 // is only used for wxWin itself or for user code which wants to call
846 // platform-specific APIs
847 virtual WXWidget GetHandle() const = 0;
848
849 #if wxUSE_PALETTE
850 // Store the palette used by DCs in wxWindow so that the dcs can share
851 // a palette. And we can respond to palette messages.
852 wxPalette GetPalette() const { return m_palette; }
853
854 // When palette is changed tell the DC to set the system palette to the
855 // new one.
856 void SetPalette(const wxPalette& pal);
857
858 // return true if we have a specific palette
859 bool HasCustomPalette() const { return m_hasCustomPalette; }
860
861 // return the first parent window with a custom palette or NULL
862 wxWindow *GetAncestorWithCustomPalette() const;
863 #endif // wxUSE_PALETTE
864
865 protected:
866 #if wxUSE_CONSTRAINTS
867 // satisfy the constraints for the windows but don't set the window sizes
868 void SatisfyConstraints();
869 #endif // wxUSE_CONSTRAINTS
870
871 // the window id - a number which uniquely identifies a window among
872 // its siblings unless it is -1
873 wxWindowID m_windowId;
874
875 // the parent window of this window (or NULL) and the list of the children
876 // of this window
877 wxWindow *m_parent;
878 wxWindowList m_children;
879
880 // the minimal allowed size for the window (no minimal size if variable(s)
881 // contain(s) -1)
882 int m_minWidth,
883 m_minHeight,
884 m_maxWidth,
885 m_maxHeight;
886
887 // event handler for this window: usually is just 'this' but may be
888 // changed with SetEventHandler()
889 wxEvtHandler *m_eventHandler;
890
891 #if wxUSE_VALIDATORS
892 // associated validator or NULL if none
893 wxValidator *m_windowValidator;
894 #endif // wxUSE_VALIDATORS
895
896 #if wxUSE_DRAG_AND_DROP
897 wxDropTarget *m_dropTarget;
898 #endif // wxUSE_DRAG_AND_DROP
899
900 // visual window attributes
901 wxCursor m_cursor;
902 wxFont m_font;
903 wxColour m_backgroundColour, m_foregroundColour;
904
905 #if wxUSE_CARET
906 wxCaret *m_caret;
907 #endif // wxUSE_CARET
908
909 // the region which should be repainted in response to paint event
910 wxRegion m_updateRegion;
911
912 #if wxUSE_ACCEL
913 // the accelerator table for the window which translates key strokes into
914 // command events
915 wxAcceleratorTable m_acceleratorTable;
916 #endif // wxUSE_ACCEL
917
918 // the tooltip for this window (may be NULL)
919 #if wxUSE_TOOLTIPS
920 wxToolTip *m_tooltip;
921 #endif // wxUSE_TOOLTIPS
922
923 // constraints and sizers
924 #if wxUSE_CONSTRAINTS
925 // the constraints for this window or NULL
926 wxLayoutConstraints *m_constraints;
927
928 // constraints this window is involved in
929 wxWindowList *m_constraintsInvolvedIn;
930 #endif // wxUSE_CONSTRAINTS
931
932 // this window's sizer
933 wxSizer *m_windowSizer;
934
935 // The sizer this window is a member of, if any
936 wxSizer *m_containingSizer;
937
938 // Layout() window automatically when its size changes?
939 bool m_autoLayout:1;
940
941 // window state
942 bool m_isShown:1;
943 bool m_isEnabled:1;
944 bool m_isBeingDeleted:1;
945
946 // was the window colours/font explicitly changed by user?
947 bool m_hasBgCol:1;
948 bool m_hasFgCol:1;
949 bool m_hasFont:1;
950
951 // window attributes
952 long m_windowStyle,
953 m_exStyle;
954 wxString m_windowName;
955 bool m_themeEnabled;
956
957 #if wxUSE_PALETTE
958 wxPalette m_palette;
959 bool m_hasCustomPalette;
960 #endif // wxUSE_PALETTE
961
962 // Virtual size (scrolling)
963 wxSize m_virtualSize;
964
965 int m_minVirtualWidth; // VirtualSizeHints
966 int m_minVirtualHeight;
967 int m_maxVirtualWidth;
968 int m_maxVirtualHeight;
969
970 // common part of all ctors: it is not virtual because it is called from
971 // ctor
972 void InitBase();
973
974 // override this to change the default (i.e. used when no style is
975 // specified) border for the window class
976 virtual wxBorder GetDefaultBorder() const;
977
978 // get the default size for the new window if no explicit size given
979 // FIXME why 20 and not 30, 10 or ...?
980 static int WidthDefault(int w) { return w == -1 ? 20 : w; }
981 static int HeightDefault(int h) { return h == -1 ? 20 : h; }
982
983 // set the best size for the control if the default size was given:
984 // replaces the fields of size == -1 with the best values for them and
985 // calls SetSize() if needed
986 //
987 // This function is rather unfortunately named.. it's really just a
988 // smarter SetSize / convenience function for expanding wxDefaultSize.
989 // Note that it does not influence the value returned by GetBestSize
990 // at all.
991 void SetBestSize(const wxSize& size)
992 {
993 // the size only needs to be changed if the current size is incomplete,
994 // i.e. one of the components was specified as default -- so if both
995 // were given, simply don't do anything
996 if ( size.x == -1 || size.y == -1 )
997 {
998 wxSize sizeBest = DoGetBestSize();
999 if ( size.x != -1 )
1000 sizeBest.x = size.x;
1001 if ( size.y != -1 )
1002 sizeBest.y = size.y;
1003
1004 SetSize(sizeBest);
1005 }
1006 }
1007
1008 // more pure virtual functions
1009 // ---------------------------
1010
1011 // NB: we must have DoSomething() function when Something() is an overloaded
1012 // method: indeed, we can't just have "virtual Something()" in case when
1013 // the function is overloaded because then we'd have to make virtual all
1014 // the variants (otherwise only the virtual function may be called on a
1015 // pointer to derived class according to C++ rules) which is, in
1016 // general, absolutely not needed. So instead we implement all
1017 // overloaded Something()s in terms of DoSomething() which will be the
1018 // only one to be virtual.
1019
1020 // coordinates translation
1021 virtual void DoClientToScreen( int *x, int *y ) const = 0;
1022 virtual void DoScreenToClient( int *x, int *y ) const = 0;
1023
1024 virtual wxHitTest DoHitTest(wxCoord x, wxCoord y) const;
1025
1026 // capture/release the mouse, used by Capture/ReleaseMouse()
1027 virtual void DoCaptureMouse() = 0;
1028 virtual void DoReleaseMouse() = 0;
1029
1030 // retrieve the position/size of the window
1031 virtual void DoGetPosition( int *x, int *y ) const = 0;
1032 virtual void DoGetSize( int *width, int *height ) const = 0;
1033 virtual void DoGetClientSize( int *width, int *height ) const = 0;
1034
1035 // get the size which best suits the window: for a control, it would be
1036 // the minimal size which doesn't truncate the control, for a panel - the
1037 // same size as it would have after a call to Fit()
1038 virtual wxSize DoGetBestSize() const;
1039
1040 // this is the virtual function to be overriden in any derived class which
1041 // wants to change how SetSize() or Move() works - it is called by all
1042 // versions of these functions in the base class
1043 virtual void DoSetSize(int x, int y,
1044 int width, int height,
1045 int sizeFlags = wxSIZE_AUTO) = 0;
1046
1047 // same as DoSetSize() for the client size
1048 virtual void DoSetClientSize(int width, int height) = 0;
1049
1050 // move the window to the specified location and resize it: this is called
1051 // from both DoSetSize() and DoSetClientSize() and would usually just
1052 // reposition this window except for composite controls which will want to
1053 // arrange themselves inside the given rectangle
1054 virtual void DoMoveWindow(int x, int y, int width, int height) = 0;
1055
1056 #if wxUSE_TOOLTIPS
1057 virtual void DoSetToolTip( wxToolTip *tip );
1058 #endif // wxUSE_TOOLTIPS
1059
1060 #if wxUSE_MENUS
1061 virtual bool DoPopupMenu( wxMenu *menu, int x, int y ) = 0;
1062 #endif // wxUSE_MENUS
1063
1064 // Makes an adjustment to the window position (for example, a frame that has
1065 // a toolbar that it manages itself).
1066 virtual void AdjustForParentClientOrigin(int& x, int& y, int sizeFlags) const;
1067
1068
1069 private:
1070
1071 // contains the last id generated by NewControlId
1072 static int ms_lastControlId;
1073
1074 // the stack of windows which have captured the mouse
1075 static struct WXDLLEXPORT wxWindowNext *ms_winCaptureNext;
1076
1077 DECLARE_ABSTRACT_CLASS(wxWindowBase)
1078 DECLARE_NO_COPY_CLASS(wxWindowBase)
1079 DECLARE_EVENT_TABLE()
1080 };
1081
1082 // ----------------------------------------------------------------------------
1083 // now include the declaration of wxWindow class
1084 // ----------------------------------------------------------------------------
1085
1086 // include the declaration of the platform-specific class
1087 #if defined(__WXMSW__)
1088 #ifdef __WXUNIVERSAL__
1089 #define wxWindowNative wxWindowMSW
1090 #else // !wxUniv
1091 #define wxWindowMSW wxWindow
1092 #define sm_classwxWindowMSW sm_classwxWindow
1093 #endif // wxUniv/!wxUniv
1094 #include "wx/msw/window.h"
1095 #elif defined(__WXMOTIF__)
1096 #include "wx/motif/window.h"
1097 #elif defined(__WXGTK__)
1098 #ifdef __WXUNIVERSAL__
1099 #define wxWindowNative wxWindowGTK
1100 #else // !wxUniv
1101 #define wxWindowGTK wxWindow
1102 #define sm_classwxWindowGTK sm_classwxWindow
1103 #endif // wxUniv
1104 #include "wx/gtk/window.h"
1105 #elif defined(__WXX11__)
1106 #ifdef __WXUNIVERSAL__
1107 #define wxWindowNative wxWindowX11
1108 #else // !wxUniv
1109 #define wxWindowX11 wxWindow
1110 #define sm_classwxWindowX11 sm_classwxWindow
1111 #endif // wxUniv
1112 #include "wx/x11/window.h"
1113 #elif defined(__WXMGL__)
1114 #ifdef __WXUNIVERSAL__
1115 #define wxWindowNative wxWindowMGL
1116 #else // !wxUniv
1117 #define wxWindowMGL wxWindow
1118 #define sm_classwxWindowMGL sm_classwxWindow
1119 #endif // wxUniv
1120 #include "wx/mgl/window.h"
1121 #elif defined(__WXMAC__)
1122 #ifdef __WXUNIVERSAL__
1123 #define wxWindowNative wxWindowMac
1124 #else // !wxUniv
1125 #define wxWindowMac wxWindow
1126 #define sm_classwxWindowMac sm_classwxWindow
1127 #endif // wxUniv
1128 #include "wx/mac/window.h"
1129 #elif defined(__WXPM__)
1130 #ifdef __WXUNIVERSAL__
1131 #define wxWindowNative wxWindowOS2
1132 #else // !wxUniv
1133 #define wxWindowOS2 wxWindow
1134 #define sm_classwxWindowOS2 sm_classwxWindow
1135 #endif // wxUniv/!wxUniv
1136 #include "wx/os2/window.h"
1137 #endif
1138
1139 // for wxUniversal, we now derive the real wxWindow from wxWindow<platform>,
1140 // for the native ports we already have defined it above
1141 #if defined(__WXUNIVERSAL__)
1142 #ifndef wxWindowNative
1143 #error "wxWindowNative must be defined above!"
1144 #endif
1145
1146 #include "wx/univ/window.h"
1147 #endif // wxUniv
1148
1149 // ----------------------------------------------------------------------------
1150 // inline functions which couldn't be declared in the class body because of
1151 // forward dependencies
1152 // ----------------------------------------------------------------------------
1153
1154 inline wxWindow *wxWindowBase::GetGrandParent() const
1155 {
1156 return m_parent ? m_parent->GetParent() : (wxWindow *)NULL;
1157 }
1158
1159 // ----------------------------------------------------------------------------
1160 // global functions
1161 // ----------------------------------------------------------------------------
1162
1163 // Find the wxWindow at the current mouse position, also returning the mouse
1164 // position.
1165 WXDLLEXPORT extern wxWindow* wxFindWindowAtPointer(wxPoint& pt);
1166
1167 // Get the current mouse position.
1168 WXDLLEXPORT extern wxPoint wxGetMousePosition();
1169
1170 // get the currently active window of this application or NULL
1171 WXDLLEXPORT extern wxWindow *wxGetActiveWindow();
1172
1173 // get the (first) top level parent window
1174 WXDLLEXPORT wxWindow* wxGetTopLevelParent(wxWindow *win);
1175
1176 // deprecated (doesn't start with 'wx' prefix), use wxWindow::NewControlId()
1177 inline int NewControlId() { return wxWindowBase::NewControlId(); }
1178
1179 #endif
1180 // _WX_WINDOW_H_BASE_
1181