]> git.saurik.com Git - wxWidgets.git/blob - src/common/wincmn.cpp
TRUE, not true; FALSE, not false....
[wxWidgets.git] / src / common / wincmn.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: common/window.cpp
3 // Purpose: common (to all ports) wxWindow functions
4 // Author: Julian Smart, Vadim Zeitlin
5 // Modified by:
6 // Created: 13/07/98
7 // RCS-ID: $Id$
8 // Copyright: (c) wxWindows team
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 #ifdef __GNUG__
21 #pragma implementation "windowbase.h"
22 #endif
23
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
26
27 #ifdef __BORLANDC__
28 #pragma hdrstop
29 #endif
30
31 #ifndef WX_PRECOMP
32 #include "wx/string.h"
33 #include "wx/log.h"
34 #include "wx/intl.h"
35 #include "wx/frame.h"
36 #include "wx/defs.h"
37 #include "wx/window.h"
38 #include "wx/control.h"
39 #include "wx/checkbox.h"
40 #include "wx/radiobut.h"
41 #include "wx/textctrl.h"
42 #include "wx/settings.h"
43 #include "wx/dialog.h"
44 #include "wx/msgdlg.h"
45 #include "wx/statusbr.h"
46 #endif //WX_PRECOMP
47
48 #if wxUSE_CONSTRAINTS
49 #include "wx/layout.h"
50 #include "wx/sizer.h"
51 #endif // wxUSE_CONSTRAINTS
52
53 #if wxUSE_DRAG_AND_DROP
54 #include "wx/dnd.h"
55 #endif // wxUSE_DRAG_AND_DROP
56
57 #if wxUSE_HELP
58 #include "wx/cshelp.h"
59 #endif // wxUSE_HELP
60
61 #if wxUSE_TOOLTIPS
62 #include "wx/tooltip.h"
63 #endif // wxUSE_TOOLTIPS
64
65 #if wxUSE_CARET
66 #include "wx/caret.h"
67 #endif // wxUSE_CARET
68
69 // ----------------------------------------------------------------------------
70 // static data
71 // ----------------------------------------------------------------------------
72
73 int wxWindowBase::ms_lastControlId = -200;
74
75 IMPLEMENT_ABSTRACT_CLASS(wxWindowBase, wxEvtHandler)
76
77 // ----------------------------------------------------------------------------
78 // event table
79 // ----------------------------------------------------------------------------
80
81 BEGIN_EVENT_TABLE(wxWindowBase, wxEvtHandler)
82 EVT_SYS_COLOUR_CHANGED(wxWindowBase::OnSysColourChanged)
83 EVT_INIT_DIALOG(wxWindowBase::OnInitDialog)
84 EVT_MIDDLE_DOWN(wxWindowBase::OnMiddleClick)
85
86 #if wxUSE_HELP
87 EVT_HELP(-1, wxWindowBase::OnHelp)
88 #endif // wxUSE_HELP
89
90 END_EVENT_TABLE()
91
92 // ============================================================================
93 // implementation of the common functionality of the wxWindow class
94 // ============================================================================
95
96 // ----------------------------------------------------------------------------
97 // initialization
98 // ----------------------------------------------------------------------------
99
100 // the default initialization
101 void wxWindowBase::InitBase()
102 {
103 // no window yet, no parent nor children
104 m_parent = (wxWindow *)NULL;
105 m_windowId = -1;
106 m_children.DeleteContents( FALSE ); // don't auto delete node data
107
108 // no constraints on the minimal window size
109 m_minWidth =
110 m_minHeight =
111 m_maxWidth =
112 m_maxHeight = -1;
113
114 // window is created enabled but it's not visible yet
115 m_isShown = FALSE;
116 m_isEnabled = TRUE;
117
118 // the default event handler is just this window
119 m_eventHandler = this;
120
121 #if wxUSE_VALIDATORS
122 // no validator
123 m_windowValidator = (wxValidator *) NULL;
124 #endif // wxUSE_VALIDATORS
125
126 // use the system default colours
127 m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE);
128 m_foregroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
129
130 // don't set the font here for wxMSW as we don't call WM_SETFONT here and
131 // so the font is *not* really set - but calls to SetFont() later won't do
132 // anything because m_font appears to be already set!
133 #ifndef __WXMSW__
134 m_font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
135 #endif // __WXMSW__
136
137 // the colours/fonts are default for now
138 m_hasBgCol =
139 m_hasFgCol =
140 m_hasFont = FALSE;
141
142 // no style bits
143 m_exStyle =
144 m_windowStyle = 0;
145
146 // an optimization for the event processing: checking this flag is much
147 // faster than using IsKindOf(CLASSINFO(wxWindow))
148 m_isWindow = TRUE;
149
150 #if wxUSE_CONSTRAINTS
151 // no constraints whatsoever
152 m_constraints = (wxLayoutConstraints *) NULL;
153 m_constraintsInvolvedIn = (wxWindowList *) NULL;
154 m_windowSizer = (wxSizer *) NULL;
155 m_autoLayout = FALSE;
156 #endif // wxUSE_CONSTRAINTS
157
158 #if wxUSE_DRAG_AND_DROP
159 m_dropTarget = (wxDropTarget *)NULL;
160 #endif // wxUSE_DRAG_AND_DROP
161
162 #if wxUSE_TOOLTIPS
163 m_tooltip = (wxToolTip *)NULL;
164 #endif // wxUSE_TOOLTIPS
165
166 #if wxUSE_CARET
167 m_caret = (wxCaret *)NULL;
168 #endif // wxUSE_CARET
169
170 // Whether we're using the current theme for this window (wxGTK only for now)
171 m_themeEnabled = FALSE;
172 }
173
174 // common part of window creation process
175 bool wxWindowBase::CreateBase(wxWindowBase *parent,
176 wxWindowID id,
177 const wxPoint& WXUNUSED(pos),
178 const wxSize& WXUNUSED(size),
179 long style,
180 const wxValidator& validator,
181 const wxString& name)
182 {
183 // m_isWindow is set to TRUE in wxWindowBase::Init() as well as many other
184 // member variables - check that it has been called (will catch the case
185 // when a new ctor is added which doesn't call InitWindow)
186 wxASSERT_MSG( m_isWindow, wxT("Init() must have been called before!") );
187
188 // generate a new id if the user doesn't care about it
189 m_windowId = id == -1 ? NewControlId() : id;
190
191 SetName(name);
192 SetWindowStyleFlag(style);
193 SetParent(parent);
194
195 #if wxUSE_VALIDATORS
196 SetValidator(validator);
197 #endif // wxUSE_VALIDATORS
198
199 // if the parent window has wxWS_EX_VALIDATE_RECURSIVELY set, we want to
200 // have it too - like this it's possible to set it only in the top level
201 // dialog/frame and all children will inherit it by defult
202 if ( parent && (parent->GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) )
203 {
204 SetExtraStyle(wxWS_EX_VALIDATE_RECURSIVELY);
205 }
206
207 return TRUE;
208 }
209
210 // ----------------------------------------------------------------------------
211 // destruction
212 // ----------------------------------------------------------------------------
213
214 // common clean up
215 wxWindowBase::~wxWindowBase()
216 {
217 // FIXME if these 2 cases result from programming errors in the user code
218 // we should probably assert here instead of silently fixing them
219
220 // Just in case the window has been Closed, but we're then deleting
221 // immediately: don't leave dangling pointers.
222 wxPendingDelete.DeleteObject(this);
223
224 // Just in case we've loaded a top-level window via LoadNativeDialog but
225 // we weren't a dialog class
226 wxTopLevelWindows.DeleteObject(this);
227
228 wxASSERT_MSG( GetChildren().GetCount() == 0, wxT("children not destroyed") );
229
230 #if wxUSE_CARET
231 if ( m_caret )
232 delete m_caret;
233 #endif // wxUSE_CARET
234
235 #if wxUSE_VALIDATORS
236 if ( m_windowValidator )
237 delete m_windowValidator;
238 #endif // wxUSE_VALIDATORS
239
240 #if wxUSE_CONSTRAINTS
241 // Have to delete constraints/sizer FIRST otherwise sizers may try to look
242 // at deleted windows as they delete themselves.
243 DeleteRelatedConstraints();
244
245 if ( m_constraints )
246 {
247 // This removes any dangling pointers to this window in other windows'
248 // constraintsInvolvedIn lists.
249 UnsetConstraints(m_constraints);
250 delete m_constraints;
251 m_constraints = NULL;
252 }
253
254 if ( m_windowSizer )
255 delete m_windowSizer;
256
257 #endif // wxUSE_CONSTRAINTS
258
259 #if wxUSE_DRAG_AND_DROP
260 if ( m_dropTarget )
261 delete m_dropTarget;
262 #endif // wxUSE_DRAG_AND_DROP
263
264 #if wxUSE_TOOLTIPS
265 if ( m_tooltip )
266 delete m_tooltip;
267 #endif // wxUSE_TOOLTIPS
268
269 // reset the dangling pointer our parent window may keep to us
270 if ( m_parent && m_parent->GetDefaultItem() == this )
271 {
272 m_parent->SetDefaultItem(NULL);
273 }
274 }
275
276 bool wxWindowBase::Destroy()
277 {
278 delete this;
279
280 return TRUE;
281 }
282
283 bool wxWindowBase::Close(bool force)
284 {
285 wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
286 event.SetEventObject(this);
287 #if WXWIN_COMPATIBILITY
288 event.SetForce(force);
289 #endif // WXWIN_COMPATIBILITY
290 event.SetCanVeto(!force);
291
292 // return FALSE if window wasn't closed because the application vetoed the
293 // close event
294 return GetEventHandler()->ProcessEvent(event) && !event.GetVeto();
295 }
296
297 bool wxWindowBase::DestroyChildren()
298 {
299 wxWindowList::Node *node;
300 for ( ;; )
301 {
302 // we iterate until the list becomes empty
303 node = GetChildren().GetFirst();
304 if ( !node )
305 break;
306
307 wxWindow *child = node->GetData();
308
309 wxASSERT_MSG( child, wxT("children list contains empty nodes") );
310
311 child->Show(FALSE);
312 delete child;
313
314 wxASSERT_MSG( !GetChildren().Find(child),
315 wxT("child didn't remove itself using RemoveChild()") );
316 }
317
318 return TRUE;
319 }
320
321 // ----------------------------------------------------------------------------
322 // size/position related methods
323 // ----------------------------------------------------------------------------
324
325 // centre the window with respect to its parent in either (or both) directions
326 void wxWindowBase::Centre(int direction)
327 {
328 // the position/size of the parent window or of the entire screen
329 wxPoint posParent;
330 int widthParent, heightParent;
331
332 wxWindow *parent = NULL;
333
334 if ( !(direction & wxCENTRE_ON_SCREEN) )
335 {
336 // find the parent to centre this window on: it should be the
337 // immediate parent for the controls but the top level parent for the
338 // top level windows (like dialogs)
339 parent = GetParent();
340 if ( IsTopLevel() )
341 {
342 while ( parent && !parent->IsTopLevel() )
343 {
344 parent = parent->GetParent();
345 }
346 }
347
348 // did we find the parent?
349 if ( !parent )
350 {
351 // no other choice
352 direction |= wxCENTRE_ON_SCREEN;
353 }
354 }
355
356 if ( direction & wxCENTRE_ON_SCREEN )
357 {
358 // centre with respect to the whole screen
359 wxDisplaySize(&widthParent, &heightParent);
360 }
361 else
362 {
363 if ( IsTopLevel() )
364 {
365 // centre on the parent
366 parent->GetSize(&widthParent, &heightParent);
367
368 // adjust to the parents position
369 posParent = parent->GetPosition();
370 }
371 else
372 {
373 // centre inside the parents client rectangle
374 parent->GetClientSize(&widthParent, &heightParent);
375 }
376 }
377
378 int width, height;
379 GetSize(&width, &height);
380
381 int xNew = -1,
382 yNew = -1;
383
384 if ( direction & wxHORIZONTAL )
385 xNew = (widthParent - width)/2;
386
387 if ( direction & wxVERTICAL )
388 yNew = (heightParent - height)/2;
389
390 xNew += posParent.x;
391 yNew += posParent.y;
392
393 // Base size of the visible dimensions of the display
394 // to take into account the taskbar
395 wxRect rect = wxGetClientDisplayRect();
396 wxSize size (rect.width,rect.height);
397
398 if (posParent.x >= 0) // if parent is on the main display
399 {
400 if (xNew < 0)
401 xNew = 0;
402 else if (xNew+width > size.x)
403 xNew = size.x-width-1;
404 }
405 if (posParent.y >= 0) // if parent is on the main display
406 {
407 if (yNew+height > size.y)
408 yNew = size.y-height-1;
409
410 // Make certain that the title bar is initially visible
411 // always, even if this would push the bottom of the
412 // dialog of the visible area of the display
413 if (yNew < 0)
414 yNew = 0;
415 }
416
417 // move the window to this position (keeping the old size but using
418 // SetSize() and not Move() to allow xNew and/or yNew to be -1)
419 SetSize(xNew, yNew, width, height, wxSIZE_ALLOW_MINUS_ONE);
420 }
421
422 // fits the window around the children
423 void wxWindowBase::Fit()
424 {
425 if ( GetChildren().GetCount() > 0 )
426 {
427 wxSize size = DoGetBestSize();
428
429 // for compatibility with the old versions and because it really looks
430 // slightly more pretty like this, add a pad
431 size.x += 7;
432 size.y += 14;
433
434 SetClientSize(size);
435 }
436 //else: do nothing if we have no children
437 }
438
439 // return the size best suited for the current window
440 wxSize wxWindowBase::DoGetBestSize() const
441 {
442 if ( GetChildren().GetCount() > 0 )
443 {
444 // our minimal acceptable size is such that all our windows fit inside
445 int maxX = 0,
446 maxY = 0;
447
448 for ( wxWindowList::Node *node = GetChildren().GetFirst();
449 node;
450 node = node->GetNext() )
451 {
452 wxWindow *win = node->GetData();
453 if ( win->IsTopLevel()
454 #if wxUSE_STATUSBAR
455 || wxDynamicCast(win, wxStatusBar)
456 #endif // wxUSE_STATUSBAR
457 )
458 {
459 // dialogs and frames lie in different top level windows -
460 // don't deal with them here; as for the status bars, they
461 // don't lie in the client area at all
462 continue;
463 }
464
465 int wx, wy, ww, wh;
466 win->GetPosition(&wx, &wy);
467
468 // if the window hadn't been positioned yet, assume that it is in
469 // the origin
470 if ( wx == -1 )
471 wx = 0;
472 if ( wy == -1 )
473 wy = 0;
474
475 win->GetSize(&ww, &wh);
476 if ( wx + ww > maxX )
477 maxX = wx + ww;
478 if ( wy + wh > maxY )
479 maxY = wy + wh;
480 }
481
482 return wxSize(maxX, maxY);
483 }
484 else
485 {
486 // for a generic window there is no natural best size - just use the
487 // current one
488 return GetSize();
489 }
490 }
491
492 // by default the origin is not shifted
493 wxPoint wxWindowBase::GetClientAreaOrigin() const
494 {
495 return wxPoint(0, 0);
496 }
497
498 // set the min/max size of the window
499 void wxWindowBase::SetSizeHints(int minW, int minH,
500 int maxW, int maxH,
501 int WXUNUSED(incW), int WXUNUSED(incH))
502 {
503 m_minWidth = minW;
504 m_maxWidth = maxW;
505 m_minHeight = minH;
506 m_maxHeight = maxH;
507 }
508
509 // ----------------------------------------------------------------------------
510 // show/hide/enable/disable the window
511 // ----------------------------------------------------------------------------
512
513 bool wxWindowBase::Show(bool show)
514 {
515 if ( show != m_isShown )
516 {
517 m_isShown = show;
518
519 return TRUE;
520 }
521 else
522 {
523 return FALSE;
524 }
525 }
526
527 bool wxWindowBase::Enable(bool enable)
528 {
529 if ( enable != m_isEnabled )
530 {
531 m_isEnabled = enable;
532
533 return TRUE;
534 }
535 else
536 {
537 return FALSE;
538 }
539 }
540 // ----------------------------------------------------------------------------
541 // RTTI
542 // ----------------------------------------------------------------------------
543
544 bool wxWindowBase::IsTopLevel() const
545 {
546 return FALSE;
547 }
548
549 // ----------------------------------------------------------------------------
550 // reparenting the window
551 // ----------------------------------------------------------------------------
552
553 void wxWindowBase::AddChild(wxWindowBase *child)
554 {
555 wxCHECK_RET( child, wxT("can't add a NULL child") );
556
557 // this should never happen and it will lead to a crash later if it does
558 // because RemoveChild() will remove only one node from the children list
559 // and the other(s) one(s) will be left with dangling pointers in them
560 wxASSERT_MSG( !GetChildren().Find(child), _T("AddChild() called twice") );
561
562 GetChildren().Append(child);
563 child->SetParent(this);
564 }
565
566 void wxWindowBase::RemoveChild(wxWindowBase *child)
567 {
568 wxCHECK_RET( child, wxT("can't remove a NULL child") );
569
570 GetChildren().DeleteObject(child);
571 child->SetParent((wxWindow *)NULL);
572 }
573
574 bool wxWindowBase::Reparent(wxWindowBase *newParent)
575 {
576 wxWindow *oldParent = GetParent();
577 if ( newParent == oldParent )
578 {
579 // nothing done
580 return FALSE;
581 }
582
583 // unlink this window from the existing parent.
584 if ( oldParent )
585 {
586 oldParent->RemoveChild(this);
587 }
588 else
589 {
590 wxTopLevelWindows.DeleteObject(this);
591 }
592
593 // add it to the new one
594 if ( newParent )
595 {
596 newParent->AddChild(this);
597 }
598 else
599 {
600 wxTopLevelWindows.Append(this);
601 }
602
603 return TRUE;
604 }
605
606 // ----------------------------------------------------------------------------
607 // event handler stuff
608 // ----------------------------------------------------------------------------
609
610 void wxWindowBase::PushEventHandler(wxEvtHandler *handler)
611 {
612 handler->SetNextHandler(GetEventHandler());
613 SetEventHandler(handler);
614 }
615
616 wxEvtHandler *wxWindowBase::PopEventHandler(bool deleteHandler)
617 {
618 wxEvtHandler *handlerA = GetEventHandler();
619 if ( handlerA )
620 {
621 wxEvtHandler *handlerB = handlerA->GetNextHandler();
622 handlerA->SetNextHandler((wxEvtHandler *)NULL);
623 SetEventHandler(handlerB);
624 if ( deleteHandler )
625 {
626 delete handlerA;
627 handlerA = (wxEvtHandler *)NULL;
628 }
629 }
630
631 return handlerA;
632 }
633
634 // ----------------------------------------------------------------------------
635 // cursors, fonts &c
636 // ----------------------------------------------------------------------------
637
638 bool wxWindowBase::SetBackgroundColour( const wxColour &colour )
639 {
640 if ( !colour.Ok() || (colour == m_backgroundColour) )
641 return FALSE;
642
643 m_backgroundColour = colour;
644
645 m_hasBgCol = TRUE;
646
647 return TRUE;
648 }
649
650 bool wxWindowBase::SetForegroundColour( const wxColour &colour )
651 {
652 if ( !colour.Ok() || (colour == m_foregroundColour) )
653 return FALSE;
654
655 m_foregroundColour = colour;
656
657 m_hasFgCol = TRUE;
658
659 return TRUE;
660 }
661
662 bool wxWindowBase::SetCursor(const wxCursor& cursor)
663 {
664 // setting an invalid cursor is ok, it means that we don't have any special
665 // cursor
666 if ( m_cursor == cursor )
667 {
668 // no change
669 return FALSE;
670 }
671
672 m_cursor = cursor;
673
674 return TRUE;
675 }
676
677 bool wxWindowBase::SetFont(const wxFont& font)
678 {
679 // don't try to set invalid font, always fall back to the default
680 const wxFont& fontOk = font.Ok() ? font : *wxSWISS_FONT;
681
682 if ( fontOk == m_font )
683 {
684 // no change
685 return FALSE;
686 }
687
688 m_font = fontOk;
689
690 m_hasFont = TRUE;
691
692 return TRUE;
693 }
694
695 #if wxUSE_CARET
696 void wxWindowBase::SetCaret(wxCaret *caret)
697 {
698 if ( m_caret )
699 {
700 delete m_caret;
701 }
702
703 m_caret = caret;
704
705 if ( m_caret )
706 {
707 wxASSERT_MSG( m_caret->GetWindow() == this,
708 wxT("caret should be created associated to this window") );
709 }
710 }
711 #endif // wxUSE_CARET
712
713 #if wxUSE_VALIDATORS
714 // ----------------------------------------------------------------------------
715 // validators
716 // ----------------------------------------------------------------------------
717
718 void wxWindowBase::SetValidator(const wxValidator& validator)
719 {
720 if ( m_windowValidator )
721 delete m_windowValidator;
722
723 m_windowValidator = (wxValidator *)validator.Clone();
724
725 if ( m_windowValidator )
726 m_windowValidator->SetWindow(this) ;
727 }
728 #endif // wxUSE_VALIDATORS
729
730 // ----------------------------------------------------------------------------
731 // update region stuff
732 // ----------------------------------------------------------------------------
733
734 wxRect wxWindowBase::GetUpdateClientRect() const
735 {
736 wxRegion rgnUpdate = GetUpdateRegion();
737 rgnUpdate.Intersect(GetClientRect());
738 wxRect rectUpdate = rgnUpdate.GetBox();
739 wxPoint ptOrigin = GetClientAreaOrigin();
740 rectUpdate.x -= ptOrigin.x;
741 rectUpdate.y -= ptOrigin.y;
742
743 return rectUpdate;
744 }
745
746 bool wxWindowBase::IsExposed(int x, int y) const
747 {
748 return m_updateRegion.Contains(x, y) != wxOutRegion;
749 }
750
751 bool wxWindowBase::IsExposed(int x, int y, int w, int h) const
752 {
753 return m_updateRegion.Contains(x, y, w, h) != wxOutRegion;
754 }
755
756 // ----------------------------------------------------------------------------
757 // find window by id or name
758 // ----------------------------------------------------------------------------
759
760 wxWindow *wxWindowBase::FindWindow( long id )
761 {
762 if ( id == m_windowId )
763 return (wxWindow *)this;
764
765 wxWindowBase *res = (wxWindow *)NULL;
766 wxWindowList::Node *node;
767 for ( node = m_children.GetFirst(); node && !res; node = node->GetNext() )
768 {
769 wxWindowBase *child = node->GetData();
770 res = child->FindWindow( id );
771 }
772
773 return (wxWindow *)res;
774 }
775
776 wxWindow *wxWindowBase::FindWindow( const wxString& name )
777 {
778 if ( name == m_windowName )
779 return (wxWindow *)this;
780
781 wxWindowBase *res = (wxWindow *)NULL;
782 wxWindowList::Node *node;
783 for ( node = m_children.GetFirst(); node && !res; node = node->GetNext() )
784 {
785 wxWindow *child = node->GetData();
786 res = child->FindWindow(name);
787 }
788
789 return (wxWindow *)res;
790 }
791
792 // ----------------------------------------------------------------------------
793 // dialog oriented functions
794 // ----------------------------------------------------------------------------
795
796 void wxWindowBase::MakeModal(bool modal)
797 {
798 // Disable all other windows
799 if ( IsTopLevel() )
800 {
801 wxWindowList::Node *node = wxTopLevelWindows.GetFirst();
802 while (node)
803 {
804 wxWindow *win = node->GetData();
805 if (win != this)
806 win->Enable(!modal);
807
808 node = node->GetNext();
809 }
810 }
811 }
812
813 bool wxWindowBase::Validate()
814 {
815 #if wxUSE_VALIDATORS
816 bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0;
817
818 wxWindowList::Node *node;
819 for ( node = m_children.GetFirst(); node; node = node->GetNext() )
820 {
821 wxWindowBase *child = node->GetData();
822 wxValidator *validator = child->GetValidator();
823 if ( validator && !validator->Validate((wxWindow *)this) )
824 {
825 return FALSE;
826 }
827
828 if ( recurse && !child->Validate() )
829 {
830 return FALSE;
831 }
832 }
833 #endif // wxUSE_VALIDATORS
834
835 return TRUE;
836 }
837
838 bool wxWindowBase::TransferDataToWindow()
839 {
840 #if wxUSE_VALIDATORS
841 bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0;
842
843 wxWindowList::Node *node;
844 for ( node = m_children.GetFirst(); node; node = node->GetNext() )
845 {
846 wxWindowBase *child = node->GetData();
847 wxValidator *validator = child->GetValidator();
848 if ( validator && !validator->TransferToWindow() )
849 {
850 wxLogWarning(_("Could not transfer data to window"));
851 wxLog::FlushActive();
852
853 return FALSE;
854 }
855
856 if ( recurse )
857 {
858 if ( !child->TransferDataToWindow() )
859 {
860 // warning already given
861 return FALSE;
862 }
863 }
864 }
865 #endif // wxUSE_VALIDATORS
866
867 return TRUE;
868 }
869
870 bool wxWindowBase::TransferDataFromWindow()
871 {
872 #if wxUSE_VALIDATORS
873 bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0;
874
875 wxWindowList::Node *node;
876 for ( node = m_children.GetFirst(); node; node = node->GetNext() )
877 {
878 wxWindow *child = node->GetData();
879 wxValidator *validator = child->GetValidator();
880 if ( validator && !validator->TransferFromWindow() )
881 {
882 // nop warning here because the application is supposed to give
883 // one itself - we don't know here what might have gone wrongly
884
885 return FALSE;
886 }
887
888 if ( recurse )
889 {
890 if ( !child->TransferDataFromWindow() )
891 {
892 // warning already given
893 return FALSE;
894 }
895 }
896 }
897 #endif // wxUSE_VALIDATORS
898
899 return TRUE;
900 }
901
902 void wxWindowBase::InitDialog()
903 {
904 wxInitDialogEvent event(GetId());
905 event.SetEventObject( this );
906 GetEventHandler()->ProcessEvent(event);
907 }
908
909 // ----------------------------------------------------------------------------
910 // context-sensitive help support
911 // ----------------------------------------------------------------------------
912
913 #if wxUSE_HELP
914
915 // associate this help text with this window
916 void wxWindowBase::SetHelpText(const wxString& text)
917 {
918 wxHelpProvider *helpProvider = wxHelpProvider::Get();
919 if ( helpProvider )
920 {
921 helpProvider->AddHelp(this, text);
922 }
923 }
924
925 // associate this help text with all windows with the same id as this
926 // one
927 void wxWindowBase::SetHelpTextForId(const wxString& text)
928 {
929 wxHelpProvider *helpProvider = wxHelpProvider::Get();
930 if ( helpProvider )
931 {
932 helpProvider->AddHelp(GetId(), text);
933 }
934 }
935
936 // get the help string associated with this window (may be empty)
937 wxString wxWindowBase::GetHelpText() const
938 {
939 wxString text;
940 wxHelpProvider *helpProvider = wxHelpProvider::Get();
941 if ( helpProvider )
942 {
943 text = helpProvider->GetHelp(this);
944 }
945
946 return text;
947 }
948
949 // show help for this window
950 void wxWindowBase::OnHelp(wxHelpEvent& event)
951 {
952 wxHelpProvider *helpProvider = wxHelpProvider::Get();
953 if ( helpProvider )
954 {
955 if ( helpProvider->ShowHelp(this) )
956 {
957 // skip the event.Skip() below
958 return;
959 }
960 }
961
962 event.Skip();
963 }
964
965 #endif // wxUSE_HELP
966
967 // ----------------------------------------------------------------------------
968 // tooltips
969 // ----------------------------------------------------------------------------
970
971 #if wxUSE_TOOLTIPS
972
973 void wxWindowBase::SetToolTip( const wxString &tip )
974 {
975 // don't create the new tooltip if we already have one
976 if ( m_tooltip )
977 {
978 m_tooltip->SetTip( tip );
979 }
980 else
981 {
982 SetToolTip( new wxToolTip( tip ) );
983 }
984
985 // setting empty tooltip text does not remove the tooltip any more - use
986 // SetToolTip((wxToolTip *)NULL) for this
987 }
988
989 void wxWindowBase::DoSetToolTip(wxToolTip *tooltip)
990 {
991 if ( m_tooltip )
992 delete m_tooltip;
993
994 m_tooltip = tooltip;
995 }
996
997 #endif // wxUSE_TOOLTIPS
998
999 // ----------------------------------------------------------------------------
1000 // constraints and sizers
1001 // ----------------------------------------------------------------------------
1002
1003 #if wxUSE_CONSTRAINTS
1004
1005 void wxWindowBase::SetConstraints( wxLayoutConstraints *constraints )
1006 {
1007 if ( m_constraints )
1008 {
1009 UnsetConstraints(m_constraints);
1010 delete m_constraints;
1011 }
1012 m_constraints = constraints;
1013 if ( m_constraints )
1014 {
1015 // Make sure other windows know they're part of a 'meaningful relationship'
1016 if ( m_constraints->left.GetOtherWindow() && (m_constraints->left.GetOtherWindow() != this) )
1017 m_constraints->left.GetOtherWindow()->AddConstraintReference(this);
1018 if ( m_constraints->top.GetOtherWindow() && (m_constraints->top.GetOtherWindow() != this) )
1019 m_constraints->top.GetOtherWindow()->AddConstraintReference(this);
1020 if ( m_constraints->right.GetOtherWindow() && (m_constraints->right.GetOtherWindow() != this) )
1021 m_constraints->right.GetOtherWindow()->AddConstraintReference(this);
1022 if ( m_constraints->bottom.GetOtherWindow() && (m_constraints->bottom.GetOtherWindow() != this) )
1023 m_constraints->bottom.GetOtherWindow()->AddConstraintReference(this);
1024 if ( m_constraints->width.GetOtherWindow() && (m_constraints->width.GetOtherWindow() != this) )
1025 m_constraints->width.GetOtherWindow()->AddConstraintReference(this);
1026 if ( m_constraints->height.GetOtherWindow() && (m_constraints->height.GetOtherWindow() != this) )
1027 m_constraints->height.GetOtherWindow()->AddConstraintReference(this);
1028 if ( m_constraints->centreX.GetOtherWindow() && (m_constraints->centreX.GetOtherWindow() != this) )
1029 m_constraints->centreX.GetOtherWindow()->AddConstraintReference(this);
1030 if ( m_constraints->centreY.GetOtherWindow() && (m_constraints->centreY.GetOtherWindow() != this) )
1031 m_constraints->centreY.GetOtherWindow()->AddConstraintReference(this);
1032 }
1033 }
1034
1035 // This removes any dangling pointers to this window in other windows'
1036 // constraintsInvolvedIn lists.
1037 void wxWindowBase::UnsetConstraints(wxLayoutConstraints *c)
1038 {
1039 if ( c )
1040 {
1041 if ( c->left.GetOtherWindow() && (c->top.GetOtherWindow() != this) )
1042 c->left.GetOtherWindow()->RemoveConstraintReference(this);
1043 if ( c->top.GetOtherWindow() && (c->top.GetOtherWindow() != this) )
1044 c->top.GetOtherWindow()->RemoveConstraintReference(this);
1045 if ( c->right.GetOtherWindow() && (c->right.GetOtherWindow() != this) )
1046 c->right.GetOtherWindow()->RemoveConstraintReference(this);
1047 if ( c->bottom.GetOtherWindow() && (c->bottom.GetOtherWindow() != this) )
1048 c->bottom.GetOtherWindow()->RemoveConstraintReference(this);
1049 if ( c->width.GetOtherWindow() && (c->width.GetOtherWindow() != this) )
1050 c->width.GetOtherWindow()->RemoveConstraintReference(this);
1051 if ( c->height.GetOtherWindow() && (c->height.GetOtherWindow() != this) )
1052 c->height.GetOtherWindow()->RemoveConstraintReference(this);
1053 if ( c->centreX.GetOtherWindow() && (c->centreX.GetOtherWindow() != this) )
1054 c->centreX.GetOtherWindow()->RemoveConstraintReference(this);
1055 if ( c->centreY.GetOtherWindow() && (c->centreY.GetOtherWindow() != this) )
1056 c->centreY.GetOtherWindow()->RemoveConstraintReference(this);
1057 }
1058 }
1059
1060 // Back-pointer to other windows we're involved with, so if we delete this
1061 // window, we must delete any constraints we're involved with.
1062 void wxWindowBase::AddConstraintReference(wxWindowBase *otherWin)
1063 {
1064 if ( !m_constraintsInvolvedIn )
1065 m_constraintsInvolvedIn = new wxWindowList;
1066 if ( !m_constraintsInvolvedIn->Find(otherWin) )
1067 m_constraintsInvolvedIn->Append(otherWin);
1068 }
1069
1070 // REMOVE back-pointer to other windows we're involved with.
1071 void wxWindowBase::RemoveConstraintReference(wxWindowBase *otherWin)
1072 {
1073 if ( m_constraintsInvolvedIn )
1074 m_constraintsInvolvedIn->DeleteObject(otherWin);
1075 }
1076
1077 // Reset any constraints that mention this window
1078 void wxWindowBase::DeleteRelatedConstraints()
1079 {
1080 if ( m_constraintsInvolvedIn )
1081 {
1082 wxWindowList::Node *node = m_constraintsInvolvedIn->GetFirst();
1083 while (node)
1084 {
1085 wxWindow *win = node->GetData();
1086 wxLayoutConstraints *constr = win->GetConstraints();
1087
1088 // Reset any constraints involving this window
1089 if ( constr )
1090 {
1091 constr->left.ResetIfWin(this);
1092 constr->top.ResetIfWin(this);
1093 constr->right.ResetIfWin(this);
1094 constr->bottom.ResetIfWin(this);
1095 constr->width.ResetIfWin(this);
1096 constr->height.ResetIfWin(this);
1097 constr->centreX.ResetIfWin(this);
1098 constr->centreY.ResetIfWin(this);
1099 }
1100
1101 wxWindowList::Node *next = node->GetNext();
1102 delete node;
1103 node = next;
1104 }
1105
1106 delete m_constraintsInvolvedIn;
1107 m_constraintsInvolvedIn = (wxWindowList *) NULL;
1108 }
1109 }
1110
1111 void wxWindowBase::SetSizer(wxSizer *sizer)
1112 {
1113 if (m_windowSizer) delete m_windowSizer;
1114
1115 m_windowSizer = sizer;
1116 }
1117
1118 bool wxWindowBase::Layout()
1119 {
1120 // If there is a sizer, use it instead of the constraints
1121 if ( GetSizer() )
1122 {
1123 int w, h;
1124 GetClientSize(&w, &h);
1125
1126 GetSizer()->SetDimension( 0, 0, w, h );
1127 }
1128 else
1129 {
1130 wxLayoutConstraints *constr = GetConstraints();
1131 bool wasOk = constr && constr->AreSatisfied();
1132
1133 ResetConstraints(); // Mark all constraints as unevaluated
1134
1135 // if we're a top level panel (i.e. our parent is frame/dialog), our
1136 // own constraints will never be satisfied any more unless we do it
1137 // here
1138 if ( wasOk )
1139 {
1140 int noChanges = 1;
1141 while ( noChanges > 0 )
1142 {
1143 constr->SatisfyConstraints(this, &noChanges);
1144 }
1145 }
1146
1147 DoPhase(1); // Layout children
1148 DoPhase(2); // Layout grand children
1149 SetConstraintSizes(); // Recursively set the real window sizes
1150 }
1151
1152 return TRUE;
1153 }
1154
1155
1156 // Do a phase of evaluating constraints: the default behaviour. wxSizers may
1157 // do a similar thing, but also impose their own 'constraints' and order the
1158 // evaluation differently.
1159 bool wxWindowBase::LayoutPhase1(int *noChanges)
1160 {
1161 wxLayoutConstraints *constr = GetConstraints();
1162 if ( constr )
1163 {
1164 return constr->SatisfyConstraints(this, noChanges);
1165 }
1166 else
1167 return TRUE;
1168 }
1169
1170 bool wxWindowBase::LayoutPhase2(int *noChanges)
1171 {
1172 *noChanges = 0;
1173
1174 // Layout children
1175 DoPhase(1);
1176 DoPhase(2);
1177 return TRUE;
1178 }
1179
1180 // Do a phase of evaluating child constraints
1181 bool wxWindowBase::DoPhase(int phase)
1182 {
1183 int noIterations = 0;
1184 int maxIterations = 500;
1185 int noChanges = 1;
1186 int noFailures = 0;
1187 wxWindowList succeeded;
1188 while ((noChanges > 0) && (noIterations < maxIterations))
1189 {
1190 noChanges = 0;
1191 noFailures = 0;
1192 wxWindowList::Node *node = GetChildren().GetFirst();
1193 while (node)
1194 {
1195 wxWindow *child = node->GetData();
1196 if ( !child->IsTopLevel() )
1197 {
1198 wxLayoutConstraints *constr = child->GetConstraints();
1199 if ( constr )
1200 {
1201 if ( !succeeded.Find(child) )
1202 {
1203 int tempNoChanges = 0;
1204 bool success = ( (phase == 1) ? child->LayoutPhase1(&tempNoChanges) : child->LayoutPhase2(&tempNoChanges) ) ;
1205 noChanges += tempNoChanges;
1206 if ( success )
1207 {
1208 succeeded.Append(child);
1209 }
1210 }
1211 }
1212 }
1213 node = node->GetNext();
1214 }
1215
1216 noIterations++;
1217 }
1218
1219 return TRUE;
1220 }
1221
1222 void wxWindowBase::ResetConstraints()
1223 {
1224 wxLayoutConstraints *constr = GetConstraints();
1225 if ( constr )
1226 {
1227 constr->left.SetDone(FALSE);
1228 constr->top.SetDone(FALSE);
1229 constr->right.SetDone(FALSE);
1230 constr->bottom.SetDone(FALSE);
1231 constr->width.SetDone(FALSE);
1232 constr->height.SetDone(FALSE);
1233 constr->centreX.SetDone(FALSE);
1234 constr->centreY.SetDone(FALSE);
1235 }
1236
1237 wxWindowList::Node *node = GetChildren().GetFirst();
1238 while (node)
1239 {
1240 wxWindow *win = node->GetData();
1241 if ( !win->IsTopLevel() )
1242 win->ResetConstraints();
1243 node = node->GetNext();
1244 }
1245 }
1246
1247 // Need to distinguish between setting the 'fake' size for windows and sizers,
1248 // and setting the real values.
1249 void wxWindowBase::SetConstraintSizes(bool recurse)
1250 {
1251 wxLayoutConstraints *constr = GetConstraints();
1252 if ( constr && constr->AreSatisfied() )
1253 {
1254 int x = constr->left.GetValue();
1255 int y = constr->top.GetValue();
1256 int w = constr->width.GetValue();
1257 int h = constr->height.GetValue();
1258
1259 if ( (constr->width.GetRelationship() != wxAsIs ) ||
1260 (constr->height.GetRelationship() != wxAsIs) )
1261 {
1262 SetSize(x, y, w, h);
1263 }
1264 else
1265 {
1266 // If we don't want to resize this window, just move it...
1267 Move(x, y);
1268 }
1269 }
1270 else if ( constr )
1271 {
1272 wxLogDebug(wxT("Constraints not satisfied for %s named '%s'."),
1273 GetClassInfo()->GetClassName(),
1274 GetName().c_str());
1275 }
1276
1277 if ( recurse )
1278 {
1279 wxWindowList::Node *node = GetChildren().GetFirst();
1280 while (node)
1281 {
1282 wxWindow *win = node->GetData();
1283 if ( !win->IsTopLevel() && win->GetConstraints() )
1284 win->SetConstraintSizes();
1285 node = node->GetNext();
1286 }
1287 }
1288 }
1289
1290 // Only set the size/position of the constraint (if any)
1291 void wxWindowBase::SetSizeConstraint(int x, int y, int w, int h)
1292 {
1293 wxLayoutConstraints *constr = GetConstraints();
1294 if ( constr )
1295 {
1296 if ( x != -1 )
1297 {
1298 constr->left.SetValue(x);
1299 constr->left.SetDone(TRUE);
1300 }
1301 if ( y != -1 )
1302 {
1303 constr->top.SetValue(y);
1304 constr->top.SetDone(TRUE);
1305 }
1306 if ( w != -1 )
1307 {
1308 constr->width.SetValue(w);
1309 constr->width.SetDone(TRUE);
1310 }
1311 if ( h != -1 )
1312 {
1313 constr->height.SetValue(h);
1314 constr->height.SetDone(TRUE);
1315 }
1316 }
1317 }
1318
1319 void wxWindowBase::MoveConstraint(int x, int y)
1320 {
1321 wxLayoutConstraints *constr = GetConstraints();
1322 if ( constr )
1323 {
1324 if ( x != -1 )
1325 {
1326 constr->left.SetValue(x);
1327 constr->left.SetDone(TRUE);
1328 }
1329 if ( y != -1 )
1330 {
1331 constr->top.SetValue(y);
1332 constr->top.SetDone(TRUE);
1333 }
1334 }
1335 }
1336
1337 void wxWindowBase::GetSizeConstraint(int *w, int *h) const
1338 {
1339 wxLayoutConstraints *constr = GetConstraints();
1340 if ( constr )
1341 {
1342 *w = constr->width.GetValue();
1343 *h = constr->height.GetValue();
1344 }
1345 else
1346 GetSize(w, h);
1347 }
1348
1349 void wxWindowBase::GetClientSizeConstraint(int *w, int *h) const
1350 {
1351 wxLayoutConstraints *constr = GetConstraints();
1352 if ( constr )
1353 {
1354 *w = constr->width.GetValue();
1355 *h = constr->height.GetValue();
1356 }
1357 else
1358 GetClientSize(w, h);
1359 }
1360
1361 void wxWindowBase::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags)
1362 {
1363 // don't do it for the dialogs/frames - they float independently of their
1364 // parent
1365 if ( !IsTopLevel() )
1366 {
1367 wxWindow *parent = GetParent();
1368 if ( !(sizeFlags & wxSIZE_NO_ADJUSTMENTS) && parent )
1369 {
1370 wxPoint pt(parent->GetClientAreaOrigin());
1371 x += pt.x;
1372 y += pt.y;
1373 }
1374 }
1375 }
1376
1377
1378 void wxWindowBase::GetPositionConstraint(int *x, int *y) const
1379 {
1380 wxLayoutConstraints *constr = GetConstraints();
1381 if ( constr )
1382 {
1383 *x = constr->left.GetValue();
1384 *y = constr->top.GetValue();
1385 }
1386 else
1387 GetPosition(x, y);
1388 }
1389
1390 #endif // wxUSE_CONSTRAINTS
1391
1392 // ----------------------------------------------------------------------------
1393 // do Update UI processing for child controls
1394 // ----------------------------------------------------------------------------
1395
1396 // TODO: should this be implemented for the child window rather
1397 // than the parent? Then you can override it e.g. for wxCheckBox
1398 // to do the Right Thing rather than having to assume a fixed number
1399 // of control classes.
1400 void wxWindowBase::UpdateWindowUI()
1401 {
1402 #if wxUSE_CONTROLS
1403 wxUpdateUIEvent event(GetId());
1404 event.m_eventObject = this;
1405
1406 if ( GetEventHandler()->ProcessEvent(event) )
1407 {
1408 if ( event.GetSetEnabled() )
1409 Enable(event.GetEnabled());
1410
1411 if ( event.GetSetText() )
1412 {
1413 wxControl *control = wxDynamicCastThis(wxControl);
1414 if ( control )
1415 {
1416 #if wxUSE_TEXTCTRL
1417 wxTextCtrl *text = wxDynamicCast(control, wxTextCtrl);
1418 if ( text )
1419 text->SetValue(event.GetText());
1420 else
1421 #endif // wxUSE_TEXTCTRL
1422 control->SetLabel(event.GetText());
1423 }
1424 }
1425
1426 #if wxUSE_CHECKBOX
1427 wxCheckBox *checkbox = wxDynamicCastThis(wxCheckBox);
1428 if ( checkbox )
1429 {
1430 if ( event.GetSetChecked() )
1431 checkbox->SetValue(event.GetChecked());
1432 }
1433 #endif // wxUSE_CHECKBOX
1434
1435 #if wxUSE_RADIOBTN
1436 wxRadioButton *radiobtn = wxDynamicCastThis(wxRadioButton);
1437 if ( radiobtn )
1438 {
1439 if ( event.GetSetChecked() )
1440 radiobtn->SetValue(event.GetChecked());
1441 }
1442 #endif // wxUSE_RADIOBTN
1443 }
1444 #endif // wxUSE_CONTROLS
1445 }
1446
1447 // ----------------------------------------------------------------------------
1448 // dialog units translations
1449 // ----------------------------------------------------------------------------
1450
1451 wxPoint wxWindowBase::ConvertPixelsToDialog(const wxPoint& pt)
1452 {
1453 int charWidth = GetCharWidth();
1454 int charHeight = GetCharHeight();
1455 wxPoint pt2(-1, -1);
1456 if (pt.x != -1)
1457 pt2.x = (int) ((pt.x * 4) / charWidth) ;
1458 if (pt.y != -1)
1459 pt2.y = (int) ((pt.y * 8) / charHeight) ;
1460
1461 return pt2;
1462 }
1463
1464 wxPoint wxWindowBase::ConvertDialogToPixels(const wxPoint& pt)
1465 {
1466 int charWidth = GetCharWidth();
1467 int charHeight = GetCharHeight();
1468 wxPoint pt2(-1, -1);
1469 if (pt.x != -1)
1470 pt2.x = (int) ((pt.x * charWidth) / 4) ;
1471 if (pt.y != -1)
1472 pt2.y = (int) ((pt.y * charHeight) / 8) ;
1473
1474 return pt2;
1475 }
1476
1477 // ----------------------------------------------------------------------------
1478 // event handlers
1479 // ----------------------------------------------------------------------------
1480
1481 // propagate the colour change event to the subwindows
1482 void wxWindowBase::OnSysColourChanged(wxSysColourChangedEvent& event)
1483 {
1484 wxWindowList::Node *node = GetChildren().GetFirst();
1485 while ( node )
1486 {
1487 // Only propagate to non-top-level windows
1488 wxWindow *win = node->GetData();
1489 if ( !win->IsTopLevel() )
1490 {
1491 wxSysColourChangedEvent event2;
1492 event.m_eventObject = win;
1493 win->GetEventHandler()->ProcessEvent(event2);
1494 }
1495
1496 node = node->GetNext();
1497 }
1498 }
1499
1500 // the default action is to populate dialog with data when it's created
1501 void wxWindowBase::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) )
1502 {
1503 TransferDataToWindow();
1504 }
1505
1506 // process Ctrl-Alt-mclick
1507 void wxWindowBase::OnMiddleClick( wxMouseEvent& event )
1508 {
1509 #if wxUSE_MSGDLG
1510 if ( event.ControlDown() && event.AltDown() )
1511 {
1512 // don't translate these strings
1513 wxString port;
1514 switch ( wxGetOsVersion() )
1515 {
1516 case wxMOTIF_X: port = _T("Motif"); break;
1517 case wxMAC:
1518 case wxMAC_DARWIN: port = _T("Mac"); break;
1519 case wxBEOS: port = _T("BeOS"); break;
1520 case wxGTK:
1521 case wxGTK_WIN32:
1522 case wxGTK_OS2:
1523 case wxGTK_BEOS: port = _T("GTK"); break;
1524 case wxWINDOWS:
1525 case wxPENWINDOWS:
1526 case wxWINDOWS_NT:
1527 case wxWIN32S:
1528 case wxWIN95:
1529 case wxWIN386: port = _T("MS Windows"); break;
1530 case wxMGL_UNIX:
1531 case wxMGL_X:
1532 case wxMGL_WIN32:
1533 case wxMGL_OS2: port = _T("MGL"); break;
1534 case wxWINDOWS_OS2:
1535 case wxOS2_PM: port = _T("OS/2"); break;
1536 default: port = _T("unknown"); break;
1537 }
1538
1539 wxMessageBox(wxString::Format(
1540 _T(
1541 " wxWindows Library (%s port)\nVersion %u.%u.%u%s, compiled at %s %s\n Copyright (c) 1995-2001 wxWindows team"
1542 ),
1543 port.c_str(),
1544 wxMAJOR_VERSION,
1545 wxMINOR_VERSION,
1546 wxRELEASE_NUMBER,
1547 #if wxUSE_UNICODE
1548 L" (Unicode)",
1549 #else
1550 "",
1551 #endif
1552 __TDATE__,
1553 __TTIME__
1554 ),
1555 _T("wxWindows information"),
1556 wxICON_INFORMATION | wxOK,
1557 (wxWindow *)this);
1558 }
1559 else
1560 #endif // wxUSE_MSGDLG
1561 {
1562 event.Skip();
1563 }
1564 }
1565
1566 // ----------------------------------------------------------------------------
1567 // list classes implementation
1568 // ----------------------------------------------------------------------------
1569
1570 void wxWindowListNode::DeleteData()
1571 {
1572 delete (wxWindow *)GetData();
1573 }
1574
1575 // ----------------------------------------------------------------------------
1576 // borders
1577 // ----------------------------------------------------------------------------
1578
1579 wxBorder wxWindowBase::GetBorder() const
1580 {
1581 wxBorder border = (wxBorder)(m_windowStyle & wxBORDER_MASK);
1582 if ( border == wxBORDER_DEFAULT )
1583 {
1584 border = GetDefaultBorder();
1585 }
1586
1587 return border;
1588 }
1589
1590 wxBorder wxWindowBase::GetDefaultBorder() const
1591 {
1592 return wxBORDER_NONE;
1593 }
1594
1595 // ----------------------------------------------------------------------------
1596 // hit testing
1597 // ----------------------------------------------------------------------------
1598
1599 wxHitTest wxWindowBase::DoHitTest(wxCoord x, wxCoord y) const
1600 {
1601 // here we just check if the point is inside the window or not
1602
1603 // check the top and left border first
1604 bool outside = x < 0 || y < 0;
1605 if ( !outside )
1606 {
1607 // check the right and bottom borders too
1608 wxSize size = GetSize();
1609 outside = x >= size.x || y >= size.y;
1610 }
1611
1612 return outside ? wxHT_WINDOW_OUTSIDE : wxHT_WINDOW_INSIDE;
1613 }
1614