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