]> git.saurik.com Git - wxWidgets.git/blob - src/common/wincmn.cpp
projects / wxWidgets.git / blob
? search:


d54ce77bdfb25226d542d23cf3bdee019c93ee37
[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/statbox.h"
42 #include "wx/textctrl.h"
43 #include "wx/settings.h"
44 #include "wx/dialog.h"
45 #include "wx/msgdlg.h"
46 #include "wx/statusbr.h"
47 #include "wx/dcclient.h"
48 #endif //WX_PRECOMP
49
50 #if wxUSE_CONSTRAINTS
51 #include "wx/layout.h"
52 #endif // wxUSE_CONSTRAINTS
53
54 #include "wx/sizer.h"
55
56 #if wxUSE_DRAG_AND_DROP
57 #include "wx/dnd.h"
58 #endif // wxUSE_DRAG_AND_DROP
59
60 #if wxUSE_HELP
61 #include "wx/cshelp.h"
62 #endif // wxUSE_HELP
63
64 #if wxUSE_TOOLTIPS
65 #include "wx/tooltip.h"
66 #endif // wxUSE_TOOLTIPS
67
68 #if wxUSE_CARET
69 #include "wx/caret.h"
70 #endif // wxUSE_CARET
71
72 // ----------------------------------------------------------------------------
73 // static data
74 // ----------------------------------------------------------------------------
75
76 #if defined(__WXPM__)
77 int wxWindowBase::ms_lastControlId = 2000;
78 #else
79 int wxWindowBase::ms_lastControlId = -200;
80 #endif
81
82 IMPLEMENT_ABSTRACT_CLASS(wxWindowBase, wxEvtHandler)
83
84 // ----------------------------------------------------------------------------
85 // event table
86 // ----------------------------------------------------------------------------
87
88 BEGIN_EVENT_TABLE(wxWindowBase, wxEvtHandler)
89 EVT_SYS_COLOUR_CHANGED(wxWindowBase::OnSysColourChanged)
90 EVT_INIT_DIALOG(wxWindowBase::OnInitDialog)
91 EVT_MIDDLE_DOWN(wxWindowBase::OnMiddleClick)
92
93 #if wxUSE_HELP
94 EVT_HELP(-1, wxWindowBase::OnHelp)
95 #endif // wxUSE_HELP
96
97 END_EVENT_TABLE()
98
99 // ============================================================================
100 // implementation of the common functionality of the wxWindow class
101 // ============================================================================
102
103 // ----------------------------------------------------------------------------
104 // initialization
105 // ----------------------------------------------------------------------------
106
107 // the default initialization
108 void wxWindowBase::InitBase()
109 {
110 // no window yet, no parent nor children
111 m_parent = (wxWindow *)NULL;
112 m_windowId = -1;
113 m_children.DeleteContents( FALSE ); // don't auto delete node data
114
115 // no constraints on the minimal window size
116 m_minWidth =
117 m_minHeight =
118 m_maxWidth =
119 m_maxHeight = -1;
120
121 // window is created enabled but it's not visible yet
122 m_isShown = FALSE;
123 m_isEnabled = TRUE;
124
125 // the default event handler is just this window
126 m_eventHandler = this;
127
128 #if wxUSE_VALIDATORS
129 // no validator
130 m_windowValidator = (wxValidator *) NULL;
131 #endif // wxUSE_VALIDATORS
132
133 // use the system default colours
134 m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE);
135 m_foregroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
136
137 // don't set the font here for wxMSW as we don't call WM_SETFONT here and
138 // so the font is *not* really set - but calls to SetFont() later won't do
139 // anything because m_font appears to be already set!
140 #ifndef __WXMSW__
141 m_font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
142 #endif // __WXMSW__
143
144 // the colours/fonts are default for now
145 m_hasBgCol =
146 m_hasFgCol =
147 m_hasFont = FALSE;
148
149 // no style bits
150 m_exStyle =
151 m_windowStyle = 0;
152
153 // an optimization for the event processing: checking this flag is much
154 // faster than using IsKindOf(CLASSINFO(wxWindow))
155 m_isWindow = TRUE;
156
157 #if wxUSE_CONSTRAINTS
158 // no constraints whatsoever
159 m_constraints = (wxLayoutConstraints *) NULL;
160 m_constraintsInvolvedIn = (wxWindowList *) NULL;
161 #endif // wxUSE_CONSTRAINTS
162
163 m_windowSizer = (wxSizer *) NULL;
164 m_containingSizer = (wxSizer *) NULL;
165 m_autoLayout = FALSE;
166
167 #if wxUSE_DRAG_AND_DROP
168 m_dropTarget = (wxDropTarget *)NULL;
169 #endif // wxUSE_DRAG_AND_DROP
170
171 #if wxUSE_TOOLTIPS
172 m_tooltip = (wxToolTip *)NULL;
173 #endif // wxUSE_TOOLTIPS
174
175 #if wxUSE_CARET
176 m_caret = (wxCaret *)NULL;
177 #endif // wxUSE_CARET
178
179 #if wxUSE_PALETTE
180 m_hasCustomPalette = FALSE;
181 #endif // wxUSE_PALETTE
182
183 m_virtualSize = wxDefaultSize;
184
185 m_minVirtualWidth =
186 m_minVirtualHeight =
187 m_maxVirtualWidth =
188 m_maxVirtualHeight = -1;
189
190 // Whether we're using the current theme for this window (wxGTK only for now)
191 m_themeEnabled = FALSE;
192 }
193
194 // common part of window creation process
195 bool wxWindowBase::CreateBase(wxWindowBase *parent,
196 wxWindowID id,
197 const wxPoint& WXUNUSED(pos),
198 const wxSize& WXUNUSED(size),
199 long style,
200 const wxValidator& validator,
201 const wxString& name)
202 {
203 // m_isWindow is set to TRUE in wxWindowBase::Init() as well as many other
204 // member variables - check that it has been called (will catch the case
205 // when a new ctor is added which doesn't call InitWindow)
206 wxASSERT_MSG( m_isWindow, wxT("Init() must have been called before!") );
207
208 #if wxUSE_STATBOX
209 // wxGTK doesn't allow to create controls with static box as the parent so
210 // this will result in a crash when the program is ported to wxGTK so warn
211 // the user about it
212
213 // if you get this assert, the correct solution is to create the controls
214 // as siblings of the static box
215 wxASSERT_MSG( !parent || !wxDynamicCast(parent, wxStaticBox),
216 _T("wxStaticBox can't be used as a window parent!") );
217 #endif // wxUSE_STATBOX
218
219 // generate a new id if the user doesn't care about it
220 m_windowId = id == -1 ? NewControlId() : id;
221
222 SetName(name);
223 SetWindowStyleFlag(style);
224 SetParent(parent);
225
226 #if wxUSE_VALIDATORS
227 SetValidator(validator);
228 #endif // wxUSE_VALIDATORS
229
230 // if the parent window has wxWS_EX_VALIDATE_RECURSIVELY set, we want to
231 // have it too - like this it's possible to set it only in the top level
232 // dialog/frame and all children will inherit it by defult
233 if ( parent && (parent->GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) )
234 {
235 SetExtraStyle(GetExtraStyle() | wxWS_EX_VALIDATE_RECURSIVELY);
236 }
237
238 return TRUE;
239 }
240
241 // ----------------------------------------------------------------------------
242 // destruction
243 // ----------------------------------------------------------------------------
244
245 // common clean up
246 wxWindowBase::~wxWindowBase()
247 {
248 wxASSERT_MSG( GetCapture() != this, wxT("attempt to destroy window with mouse capture") );
249
250 // FIXME if these 2 cases result from programming errors in the user code
251 // we should probably assert here instead of silently fixing them
252
253 // Just in case the window has been Closed, but we're then deleting
254 // immediately: don't leave dangling pointers.
255 wxPendingDelete.DeleteObject(this);
256
257 // Just in case we've loaded a top-level window via LoadNativeDialog but
258 // we weren't a dialog class
259 wxTopLevelWindows.DeleteObject(this);
260
261 wxASSERT_MSG( GetChildren().GetCount() == 0, wxT("children not destroyed") );
262
263 #if wxUSE_CARET
264 if ( m_caret )
265 delete m_caret;
266 #endif // wxUSE_CARET
267
268 #if wxUSE_VALIDATORS
269 if ( m_windowValidator )
270 delete m_windowValidator;
271 #endif // wxUSE_VALIDATORS
272
273 #if wxUSE_CONSTRAINTS
274 // Have to delete constraints/sizer FIRST otherwise sizers may try to look
275 // at deleted windows as they delete themselves.
276 DeleteRelatedConstraints();
277
278 if ( m_constraints )
279 {
280 // This removes any dangling pointers to this window in other windows'
281 // constraintsInvolvedIn lists.
282 UnsetConstraints(m_constraints);
283 delete m_constraints;
284 m_constraints = NULL;
285 }
286
287 #endif // wxUSE_CONSTRAINTS
288
289 if ( m_containingSizer )
290 m_containingSizer->Detach( (wxWindow*)this );
291
292 if ( m_windowSizer )
293 delete m_windowSizer;
294
295 #if wxUSE_DRAG_AND_DROP
296 if ( m_dropTarget )
297 delete m_dropTarget;
298 #endif // wxUSE_DRAG_AND_DROP
299
300 #if wxUSE_TOOLTIPS
301 if ( m_tooltip )
302 delete m_tooltip;
303 #endif // wxUSE_TOOLTIPS
304
305 // reset the dangling pointer our parent window may keep to us
306 if ( m_parent && m_parent->GetDefaultItem() == this )
307 {
308 m_parent->SetDefaultItem(NULL);
309 }
310 }
311
312 bool wxWindowBase::Destroy()
313 {
314 delete this;
315
316 return TRUE;
317 }
318
319 bool wxWindowBase::Close(bool force)
320 {
321 wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
322 event.SetEventObject(this);
323 #if WXWIN_COMPATIBILITY
324 event.SetForce(force);
325 #endif // WXWIN_COMPATIBILITY
326 event.SetCanVeto(!force);
327
328 // return FALSE if window wasn't closed because the application vetoed the
329 // close event
330 return GetEventHandler()->ProcessEvent(event) && !event.GetVeto();
331 }
332
333 bool wxWindowBase::DestroyChildren()
334 {
335 wxWindowList::Node *node;
336 for ( ;; )
337 {
338 // we iterate until the list becomes empty
339 node = GetChildren().GetFirst();
340 if ( !node )
341 break;
342
343 wxWindow *child = node->GetData();
344
345 wxASSERT_MSG( child, wxT("children list contains empty nodes") );
346
347 child->Show(FALSE);
348 delete child;
349
350 wxASSERT_MSG( !GetChildren().Find(child),
351 wxT("child didn't remove itself using RemoveChild()") );
352 }
353
354 return TRUE;
355 }
356
357 // ----------------------------------------------------------------------------
358 // size/position related methods
359 // ----------------------------------------------------------------------------
360
361 // centre the window with respect to its parent in either (or both) directions
362 void wxWindowBase::Centre(int direction)
363 {
364 // the position/size of the parent window or of the entire screen
365 wxPoint posParent;
366 int widthParent, heightParent;
367
368 wxWindow *parent = NULL;
369
370 if ( !(direction & wxCENTRE_ON_SCREEN) )
371 {
372 // find the parent to centre this window on: it should be the
373 // immediate parent for the controls but the top level parent for the
374 // top level windows (like dialogs)
375 parent = GetParent();
376 if ( IsTopLevel() )
377 {
378 while ( parent && !parent->IsTopLevel() )
379 {
380 parent = parent->GetParent();
381 }
382 }
383
384 // there is no wxTopLevelWindow under wxMotif yet
385 #ifndef __WXMOTIF__
386 // we shouldn't center the dialog on the iconized window: under
387 // Windows, for example, this places it completely off the screen
388 if ( parent )
389 {
390 wxTopLevelWindow *winTop = wxDynamicCast(parent, wxTopLevelWindow);
391 if ( winTop && winTop->IsIconized() )
392 {
393 parent = NULL;
394 }
395 }
396 #endif // __WXMOTIF__
397
398 // did we find the parent?
399 if ( !parent )
400 {
401 // no other choice
402 direction |= wxCENTRE_ON_SCREEN;
403 }
404 }
405
406 if ( direction & wxCENTRE_ON_SCREEN )
407 {
408 // centre with respect to the whole screen
409 wxDisplaySize(&widthParent, &heightParent);
410 }
411 else
412 {
413 if ( IsTopLevel() )
414 {
415 // centre on the parent
416 parent->GetSize(&widthParent, &heightParent);
417
418 // adjust to the parents position
419 posParent = parent->GetPosition();
420 }
421 else
422 {
423 // centre inside the parents client rectangle
424 parent->GetClientSize(&widthParent, &heightParent);
425 }
426 }
427
428 int width, height;
429 GetSize(&width, &height);
430
431 int xNew = -1,
432 yNew = -1;
433
434 if ( direction & wxHORIZONTAL )
435 xNew = (widthParent - width)/2;
436
437 if ( direction & wxVERTICAL )
438 yNew = (heightParent - height)/2;
439
440 xNew += posParent.x;
441 yNew += posParent.y;
442
443 // Base size of the visible dimensions of the display
444 // to take into account the taskbar
445 wxRect rect = wxGetClientDisplayRect();
446 wxSize size (rect.width,rect.height);
447
448 // NB: in wxMSW, negative position may not neccessary mean "out of screen",
449 // but it may mean that the window is placed on other than the main
450 // display. Therefore we only make sure centered window is on the main display
451 // if the parent is at least partially present here.
452 if (posParent.x + widthParent >= 0) // if parent is (partially) on the main display
453 {
454 if (xNew < 0)
455 xNew = 0;
456 else if (xNew+width > size.x)
457 xNew = size.x-width-1;
458 }
459 if (posParent.y + heightParent >= 0) // if parent is (partially) on the main display
460 {
461 if (yNew+height > size.y)
462 yNew = size.y-height-1;
463
464 // Make certain that the title bar is initially visible
465 // always, even if this would push the bottom of the
466 // dialog of the visible area of the display
467 if (yNew < 0)
468 yNew = 0;
469 }
470
471 // move the window to this position (keeping the old size but using
472 // SetSize() and not Move() to allow xNew and/or yNew to be -1)
473 SetSize(xNew, yNew, width, height, wxSIZE_ALLOW_MINUS_ONE);
474 }
475
476 // fits the window around the children
477 void wxWindowBase::Fit()
478 {
479 if ( GetChildren().GetCount() > 0 )
480 {
481 SetClientSize(DoGetBestSize());
482 }
483 //else: do nothing if we have no children
484 }
485
486 // fits virtual size (ie. scrolled area etc.) around children
487 void wxWindowBase::FitInside()
488 {
489 if ( GetChildren().GetCount() > 0 )
490 {
491 SetVirtualSize( GetBestVirtualSize() );
492 }
493 }
494
495 // return the size best suited for the current window
496 wxSize wxWindowBase::DoGetBestSize() const
497 {
498 if ( m_windowSizer )
499 {
500 return m_windowSizer->GetMinSize();
501 }
502 #if wxUSE_CONSTRAINTS
503 else if ( m_constraints )
504 {
505 wxConstCast(this, wxWindowBase)->SatisfyConstraints();
506
507 // our minimal acceptable size is such that all our windows fit inside
508 int maxX = 0,
509 maxY = 0;
510
511 for ( wxWindowList::Node *node = GetChildren().GetFirst();
512 node;
513 node = node->GetNext() )
514 {
515 wxLayoutConstraints *c = node->GetData()->GetConstraints();
516 if ( !c )
517 {
518 // it's not normal that we have an unconstrained child, but
519 // what can we do about it?
520 continue;
521 }
522
523 int x = c->right.GetValue(),
524 y = c->bottom.GetValue();
525
526 if ( x > maxX )
527 maxX = x;
528
529 if ( y > maxY )
530 maxY = y;
531
532 // TODO: we must calculate the overlaps somehow, otherwise we
533 // will never return a size bigger than the current one :-(
534 }
535
536 return wxSize(maxX, maxY);
537 }
538 #endif // wxUSE_CONSTRAINTS
539 else if ( GetChildren().GetCount() > 0 )
540 {
541 // our minimal acceptable size is such that all our windows fit inside
542 int maxX = 0,
543 maxY = 0;
544
545 for ( wxWindowList::Node *node = GetChildren().GetFirst();
546 node;
547 node = node->GetNext() )
548 {
549 wxWindow *win = node->GetData();
550 if ( win->IsTopLevel()
551 #if wxUSE_STATUSBAR
552 || wxDynamicCast(win, wxStatusBar)
553 #endif // wxUSE_STATUSBAR
554 )
555 {
556 // dialogs and frames lie in different top level windows -
557 // don't deal with them here; as for the status bars, they
558 // don't lie in the client area at all
559 continue;
560 }
561
562 int wx, wy, ww, wh;
563 win->GetPosition(&wx, &wy);
564
565 // if the window hadn't been positioned yet, assume that it is in
566 // the origin
567 if ( wx == -1 )
568 wx = 0;
569 if ( wy == -1 )
570 wy = 0;
571
572 win->GetSize(&ww, &wh);
573 if ( wx + ww > maxX )
574 maxX = wx + ww;
575 if ( wy + wh > maxY )
576 maxY = wy + wh;
577 }
578
579 // for compatibility with the old versions and because it really looks
580 // slightly more pretty like this, add a pad
581 maxX += 7;
582 maxY += 14;
583
584 return wxSize(maxX, maxY);
585 }
586 else
587 {
588 // for a generic window there is no natural best size - just use the
589 // current one
590 return GetSize();
591 }
592 }
593
594 // by default the origin is not shifted
595 wxPoint wxWindowBase::GetClientAreaOrigin() const
596 {
597 return wxPoint(0, 0);
598 }
599
600 // set the min/max size of the window
601 void wxWindowBase::SetSizeHints(int minW, int minH,
602 int maxW, int maxH,
603 int WXUNUSED(incW), int WXUNUSED(incH))
604 {
605 m_minWidth = minW;
606 m_maxWidth = maxW;
607 m_minHeight = minH;
608 m_maxHeight = maxH;
609 }
610
611 void wxWindowBase::SetVirtualSizeHints( int minW, int minH,
612 int maxW, int maxH )
613 {
614 m_minVirtualWidth = minW;
615 m_maxVirtualWidth = maxW;
616 m_minVirtualHeight = minH;
617 m_maxVirtualHeight = maxH;
618 }
619
620 void wxWindowBase::DoSetVirtualSize( int x, int y )
621 {
622 if ( m_minVirtualWidth != -1 && m_minVirtualWidth > x )
623 x = m_minVirtualWidth;
624 if ( m_maxVirtualWidth != -1 && m_maxVirtualWidth < x )
625 x = m_maxVirtualWidth;
626 if ( m_minVirtualHeight != -1 && m_minVirtualHeight > y )
627 y = m_minVirtualHeight;
628 if ( m_maxVirtualHeight != -1 && m_maxVirtualHeight < y )
629 y = m_maxVirtualHeight;
630
631 m_virtualSize = wxSize(x, y);
632 }
633
634 wxSize wxWindowBase::DoGetVirtualSize() const
635 {
636 wxSize s( GetClientSize() );
637
638 return wxSize( wxMax( m_virtualSize.GetWidth(), s.GetWidth() ),
639 wxMax( m_virtualSize.GetHeight(), s.GetHeight() ) );
640 }
641
642 // ----------------------------------------------------------------------------
643 // show/hide/enable/disable the window
644 // ----------------------------------------------------------------------------
645
646 bool wxWindowBase::Show(bool show)
647 {
648 if ( show != m_isShown )
649 {
650 m_isShown = show;
651
652 return TRUE;
653 }
654 else
655 {
656 return FALSE;
657 }
658 }
659
660 bool wxWindowBase::Enable(bool enable)
661 {
662 if ( enable != m_isEnabled )
663 {
664 m_isEnabled = enable;
665
666 return TRUE;
667 }
668 else
669 {
670 return FALSE;
671 }
672 }
673 // ----------------------------------------------------------------------------
674 // RTTI
675 // ----------------------------------------------------------------------------
676
677 bool wxWindowBase::IsTopLevel() const
678 {
679 return FALSE;
680 }
681
682 // ----------------------------------------------------------------------------
683 // reparenting the window
684 // ----------------------------------------------------------------------------
685
686 void wxWindowBase::AddChild(wxWindowBase *child)
687 {
688 wxCHECK_RET( child, wxT("can't add a NULL child") );
689
690 // this should never happen and it will lead to a crash later if it does
691 // because RemoveChild() will remove only one node from the children list
692 // and the other(s) one(s) will be left with dangling pointers in them
693 wxASSERT_MSG( !GetChildren().Find(child), _T("AddChild() called twice") );
694
695 GetChildren().Append(child);
696 child->SetParent(this);
697 }
698
699 void wxWindowBase::RemoveChild(wxWindowBase *child)
700 {
701 wxCHECK_RET( child, wxT("can't remove a NULL child") );
702
703 GetChildren().DeleteObject(child);
704 child->SetParent((wxWindow *)NULL);
705 }
706
707 bool wxWindowBase::Reparent(wxWindowBase *newParent)
708 {
709 wxWindow *oldParent = GetParent();
710 if ( newParent == oldParent )
711 {
712 // nothing done
713 return FALSE;
714 }
715
716 // unlink this window from the existing parent.
717 if ( oldParent )
718 {
719 oldParent->RemoveChild(this);
720 }
721 else
722 {
723 wxTopLevelWindows.DeleteObject(this);
724 }
725
726 // add it to the new one
727 if ( newParent )
728 {
729 newParent->AddChild(this);
730 }
731 else
732 {
733 wxTopLevelWindows.Append(this);
734 }
735
736 return TRUE;
737 }
738
739 // ----------------------------------------------------------------------------
740 // event handler stuff
741 // ----------------------------------------------------------------------------
742
743 void wxWindowBase::PushEventHandler(wxEvtHandler *handler)
744 {
745 wxEvtHandler *handlerOld = GetEventHandler();
746
747 handler->SetNextHandler(handlerOld);
748
749 if ( handlerOld )
750 GetEventHandler()->SetPreviousHandler(handler);
751
752 SetEventHandler(handler);
753 }
754
755 wxEvtHandler *wxWindowBase::PopEventHandler(bool deleteHandler)
756 {
757 wxEvtHandler *handlerA = GetEventHandler();
758 if ( handlerA )
759 {
760 wxEvtHandler *handlerB = handlerA->GetNextHandler();
761 handlerA->SetNextHandler((wxEvtHandler *)NULL);
762
763 if ( handlerB )
764 handlerB->SetPreviousHandler((wxEvtHandler *)NULL);
765 SetEventHandler(handlerB);
766
767 if ( deleteHandler )
768 {
769 delete handlerA;
770 handlerA = (wxEvtHandler *)NULL;
771 }
772 }
773
774 return handlerA;
775 }
776
777 bool wxWindowBase::RemoveEventHandler(wxEvtHandler *handler)
778 {
779 wxCHECK_MSG( handler, FALSE, _T("RemoveEventHandler(NULL) called") );
780
781 wxEvtHandler *handlerPrev = NULL,
782 *handlerCur = GetEventHandler();
783 while ( handlerCur )
784 {
785 wxEvtHandler *handlerNext = handlerCur->GetNextHandler();
786
787 if ( handlerCur == handler )
788 {
789 if ( handlerPrev )
790 {
791 handlerPrev->SetNextHandler(handlerNext);
792 }
793 else
794 {
795 SetEventHandler(handlerNext);
796 }
797
798 if ( handlerNext )
799 {
800 handlerNext->SetPreviousHandler ( handlerPrev );
801 }
802 handler->SetNextHandler(NULL);
803
804 return TRUE;
805 }
806
807 handlerPrev = handlerCur;
808 handlerCur = handlerNext;
809 }
810
811 wxFAIL_MSG( _T("where has the event handler gone?") );
812
813 return FALSE;
814 }
815
816 // ----------------------------------------------------------------------------
817 // cursors, fonts &c
818 // ----------------------------------------------------------------------------
819
820 bool wxWindowBase::SetBackgroundColour( const wxColour &colour )
821 {
822 if ( !colour.Ok() || (colour == m_backgroundColour) )
823 return FALSE;
824
825 m_backgroundColour = colour;
826
827 m_hasBgCol = TRUE;
828
829 return TRUE;
830 }
831
832 bool wxWindowBase::SetForegroundColour( const wxColour &colour )
833 {
834 if ( !colour.Ok() || (colour == m_foregroundColour) )
835 return FALSE;
836
837 m_foregroundColour = colour;
838
839 m_hasFgCol = TRUE;
840
841 return TRUE;
842 }
843
844 bool wxWindowBase::SetCursor(const wxCursor& cursor)
845 {
846 // setting an invalid cursor is ok, it means that we don't have any special
847 // cursor
848 if ( m_cursor == cursor )
849 {
850 // no change
851 return FALSE;
852 }
853
854 m_cursor = cursor;
855
856 return TRUE;
857 }
858
859 bool wxWindowBase::SetFont(const wxFont& font)
860 {
861 // don't try to set invalid font, always fall back to the default
862 const wxFont& fontOk = font.Ok() ? font : *wxSWISS_FONT;
863
864 if ( fontOk == m_font )
865 {
866 // no change
867 return FALSE;
868 }
869
870 m_font = fontOk;
871
872 m_hasFont = TRUE;
873
874 return TRUE;
875 }
876
877 #if wxUSE_PALETTE
878
879 void wxWindowBase::SetPalette(const wxPalette& pal)
880 {
881 m_hasCustomPalette = TRUE;
882 m_palette = pal;
883
884 // VZ: can anyone explain me what do we do here?
885 wxWindowDC d((wxWindow *) this);
886 d.SetPalette(pal);
887 }
888
889 wxWindow *wxWindowBase::GetAncestorWithCustomPalette() const
890 {
891 wxWindow *win = (wxWindow *)this;
892 while ( win && !win->HasCustomPalette() )
893 {
894 win = win->GetParent();
895 }
896
897 return win;
898 }
899
900 #endif // wxUSE_PALETTE
901
902 #if wxUSE_CARET
903 void wxWindowBase::SetCaret(wxCaret *caret)
904 {
905 if ( m_caret )
906 {
907 delete m_caret;
908 }
909
910 m_caret = caret;
911
912 if ( m_caret )
913 {
914 wxASSERT_MSG( m_caret->GetWindow() == this,
915 wxT("caret should be created associated to this window") );
916 }
917 }
918 #endif // wxUSE_CARET
919
920 #if wxUSE_VALIDATORS
921 // ----------------------------------------------------------------------------
922 // validators
923 // ----------------------------------------------------------------------------
924
925 void wxWindowBase::SetValidator(const wxValidator& validator)
926 {
927 if ( m_windowValidator )
928 delete m_windowValidator;
929
930 m_windowValidator = (wxValidator *)validator.Clone();
931
932 if ( m_windowValidator )
933 m_windowValidator->SetWindow(this) ;
934 }
935 #endif // wxUSE_VALIDATORS
936
937 // ----------------------------------------------------------------------------
938 // update region stuff
939 // ----------------------------------------------------------------------------
940
941 wxRect wxWindowBase::GetUpdateClientRect() const
942 {
943 wxRegion rgnUpdate = GetUpdateRegion();
944 rgnUpdate.Intersect(GetClientRect());
945 wxRect rectUpdate = rgnUpdate.GetBox();
946 wxPoint ptOrigin = GetClientAreaOrigin();
947 rectUpdate.x -= ptOrigin.x;
948 rectUpdate.y -= ptOrigin.y;
949
950 return rectUpdate;
951 }
952
953 bool wxWindowBase::IsExposed(int x, int y) const
954 {
955 return m_updateRegion.Contains(x, y) != wxOutRegion;
956 }
957
958 bool wxWindowBase::IsExposed(int x, int y, int w, int h) const
959 {
960 return m_updateRegion.Contains(x, y, w, h) != wxOutRegion;
961 }
962
963 // ----------------------------------------------------------------------------
964 // find child window by id or name
965 // ----------------------------------------------------------------------------
966
967 wxWindow *wxWindowBase::FindWindow( long id )
968 {
969 if ( id == m_windowId )
970 return (wxWindow *)this;
971
972 wxWindowBase *res = (wxWindow *)NULL;
973 wxWindowList::Node *node;
974 for ( node = m_children.GetFirst(); node && !res; node = node->GetNext() )
975 {
976 wxWindowBase *child = node->GetData();
977 res = child->FindWindow( id );
978 }
979
980 return (wxWindow *)res;
981 }
982
983 wxWindow *wxWindowBase::FindWindow( const wxString& name )
984 {
985 if ( name == m_windowName )
986 return (wxWindow *)this;
987
988 wxWindowBase *res = (wxWindow *)NULL;
989 wxWindowList::Node *node;
990 for ( node = m_children.GetFirst(); node && !res; node = node->GetNext() )
991 {
992 wxWindow *child = node->GetData();
993 res = child->FindWindow(name);
994 }
995
996 return (wxWindow *)res;
997 }
998
999
1000 // find any window by id or name or label: If parent is non-NULL, look through
1001 // children for a label or title matching the specified string. If NULL, look
1002 // through all top-level windows.
1003 //
1004 // to avoid duplicating code we reuse the same helper function but with
1005 // different comparators
1006
1007 typedef bool (*wxFindWindowCmp)(const wxWindow *win,
1008 const wxString& label, long id);
1009
1010 static
1011 bool wxFindWindowCmpLabels(const wxWindow *win, const wxString& label,
1012 long WXUNUSED(id))
1013 {
1014 return win->GetLabel() == label;
1015 }
1016
1017 static
1018 bool wxFindWindowCmpNames(const wxWindow *win, const wxString& label,
1019 long WXUNUSED(id))
1020 {
1021 return win->GetName() == label;
1022 }
1023
1024 static
1025 bool wxFindWindowCmpIds(const wxWindow *win, const wxString& WXUNUSED(label),
1026 long id)
1027 {
1028 return win->GetId() == id;
1029 }
1030
1031 // recursive helper for the FindWindowByXXX() functions
1032 static
1033 wxWindow *wxFindWindowRecursively(const wxWindow *parent,
1034 const wxString& label,
1035 long id,
1036 wxFindWindowCmp cmp)
1037 {
1038 if ( parent )
1039 {
1040 // see if this is the one we're looking for
1041 if ( (*cmp)(parent, label, id) )
1042 return (wxWindow *)parent;
1043
1044 // It wasn't, so check all its children
1045 for ( wxWindowList::Node * node = parent->GetChildren().GetFirst();
1046 node;
1047 node = node->GetNext() )
1048 {
1049 // recursively check each child
1050 wxWindow *win = (wxWindow *)node->GetData();
1051 wxWindow *retwin = wxFindWindowRecursively(win, label, id, cmp);
1052 if (retwin)
1053 return retwin;
1054 }
1055 }
1056
1057 // Not found
1058 return NULL;
1059 }
1060
1061 // helper for FindWindowByXXX()
1062 static
1063 wxWindow *wxFindWindowHelper(const wxWindow *parent,
1064 const wxString& label,
1065 long id,
1066 wxFindWindowCmp cmp)
1067 {
1068 if ( parent )
1069 {
1070 // just check parent and all its children
1071 return wxFindWindowRecursively(parent, label, id, cmp);
1072 }
1073
1074 // start at very top of wx's windows
1075 for ( wxWindowList::Node * node = wxTopLevelWindows.GetFirst();
1076 node;
1077 node = node->GetNext() )
1078 {
1079 // recursively check each window & its children
1080 wxWindow *win = node->GetData();
1081 wxWindow *retwin = wxFindWindowRecursively(win, label, id, cmp);
1082 if (retwin)
1083 return retwin;
1084 }
1085
1086 return NULL;
1087 }
1088
1089 /* static */
1090 wxWindow *
1091 wxWindowBase::FindWindowByLabel(const wxString& title, const wxWindow *parent)
1092 {
1093 return wxFindWindowHelper(parent, title, 0, wxFindWindowCmpLabels);
1094 }
1095
1096 /* static */
1097 wxWindow *
1098 wxWindowBase::FindWindowByName(const wxString& title, const wxWindow *parent)
1099 {
1100 wxWindow *win = wxFindWindowHelper(parent, title, 0, wxFindWindowCmpNames);
1101
1102 if ( !win )
1103 {
1104 // fall back to the label
1105 win = FindWindowByLabel(title, parent);
1106 }
1107
1108 return win;
1109 }
1110
1111 /* static */
1112 wxWindow *
1113 wxWindowBase::FindWindowById( long id, const wxWindow* parent )
1114 {
1115 return wxFindWindowHelper(parent, _T(""), id, wxFindWindowCmpIds);
1116 }
1117
1118 // ----------------------------------------------------------------------------
1119 // dialog oriented functions
1120 // ----------------------------------------------------------------------------
1121
1122 void wxWindowBase::MakeModal(bool modal)
1123 {
1124 // Disable all other windows
1125 if ( IsTopLevel() )
1126 {
1127 wxWindowList::Node *node = wxTopLevelWindows.GetFirst();
1128 while (node)
1129 {
1130 wxWindow *win = node->GetData();
1131 if (win != this)
1132 win->Enable(!modal);
1133
1134 node = node->GetNext();
1135 }
1136 }
1137 }
1138
1139 bool wxWindowBase::Validate()
1140 {
1141 #if wxUSE_VALIDATORS
1142 bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0;
1143
1144 wxWindowList::Node *node;
1145 for ( node = m_children.GetFirst(); node; node = node->GetNext() )
1146 {
1147 wxWindowBase *child = node->GetData();
1148 wxValidator *validator = child->GetValidator();
1149 if ( validator && !validator->Validate((wxWindow *)this) )
1150 {
1151 return FALSE;
1152 }
1153
1154 if ( recurse && !child->Validate() )
1155 {
1156 return FALSE;
1157 }
1158 }
1159 #endif // wxUSE_VALIDATORS
1160
1161 return TRUE;
1162 }
1163
1164 bool wxWindowBase::TransferDataToWindow()
1165 {
1166 #if wxUSE_VALIDATORS
1167 bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0;
1168
1169 wxWindowList::Node *node;
1170 for ( node = m_children.GetFirst(); node; node = node->GetNext() )
1171 {
1172 wxWindowBase *child = node->GetData();
1173 wxValidator *validator = child->GetValidator();
1174 if ( validator && !validator->TransferToWindow() )
1175 {
1176 wxLogWarning(_("Could not transfer data to window"));
1177 #if wxUSE_LOG
1178 wxLog::FlushActive();
1179 #endif // wxUSE_LOG
1180
1181 return FALSE;
1182 }
1183
1184 if ( recurse )
1185 {
1186 if ( !child->TransferDataToWindow() )
1187 {
1188 // warning already given
1189 return FALSE;
1190 }
1191 }
1192 }
1193 #endif // wxUSE_VALIDATORS
1194
1195 return TRUE;
1196 }
1197
1198 bool wxWindowBase::TransferDataFromWindow()
1199 {
1200 #if wxUSE_VALIDATORS
1201 bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0;
1202
1203 wxWindowList::Node *node;
1204 for ( node = m_children.GetFirst(); node; node = node->GetNext() )
1205 {
1206 wxWindow *child = node->GetData();
1207 wxValidator *validator = child->GetValidator();
1208 if ( validator && !validator->TransferFromWindow() )
1209 {
1210 // nop warning here because the application is supposed to give
1211 // one itself - we don't know here what might have gone wrongly
1212
1213 return FALSE;
1214 }
1215
1216 if ( recurse )
1217 {
1218 if ( !child->TransferDataFromWindow() )
1219 {
1220 // warning already given
1221 return FALSE;
1222 }
1223 }
1224 }
1225 #endif // wxUSE_VALIDATORS
1226
1227 return TRUE;
1228 }
1229
1230 void wxWindowBase::InitDialog()
1231 {
1232 wxInitDialogEvent event(GetId());
1233 event.SetEventObject( this );
1234 GetEventHandler()->ProcessEvent(event);
1235 }
1236
1237 // ----------------------------------------------------------------------------
1238 // context-sensitive help support
1239 // ----------------------------------------------------------------------------
1240
1241 #if wxUSE_HELP
1242
1243 // associate this help text with this window
1244 void wxWindowBase::SetHelpText(const wxString& text)
1245 {
1246 wxHelpProvider *helpProvider = wxHelpProvider::Get();
1247 if ( helpProvider )
1248 {
1249 helpProvider->AddHelp(this, text);
1250 }
1251 }
1252
1253 // associate this help text with all windows with the same id as this
1254 // one
1255 void wxWindowBase::SetHelpTextForId(const wxString& text)
1256 {
1257 wxHelpProvider *helpProvider = wxHelpProvider::Get();
1258 if ( helpProvider )
1259 {
1260 helpProvider->AddHelp(GetId(), text);
1261 }
1262 }
1263
1264 // get the help string associated with this window (may be empty)
1265 wxString wxWindowBase::GetHelpText() const
1266 {
1267 wxString text;
1268 wxHelpProvider *helpProvider = wxHelpProvider::Get();
1269 if ( helpProvider )
1270 {
1271 text = helpProvider->GetHelp(this);
1272 }
1273
1274 return text;
1275 }
1276
1277 // show help for this window
1278 void wxWindowBase::OnHelp(wxHelpEvent& event)
1279 {
1280 wxHelpProvider *helpProvider = wxHelpProvider::Get();
1281 if ( helpProvider )
1282 {
1283 if ( helpProvider->ShowHelp(this) )
1284 {
1285 // skip the event.Skip() below
1286 return;
1287 }
1288 }
1289
1290 event.Skip();
1291 }
1292
1293 #endif // wxUSE_HELP
1294
1295 // ----------------------------------------------------------------------------
1296 // tooltipsroot.Replace("\\", "/");
1297 // ----------------------------------------------------------------------------
1298
1299 #if wxUSE_TOOLTIPS
1300
1301 void wxWindowBase::SetToolTip( const wxString &tip )
1302 {
1303 // don't create the new tooltip if we already have one
1304 if ( m_tooltip )
1305 {
1306 m_tooltip->SetTip( tip );
1307 }
1308 else
1309 {
1310 SetToolTip( new wxToolTip( tip ) );
1311 }
1312
1313 // setting empty tooltip text does not remove the tooltip any more - use
1314 // SetToolTip((wxToolTip *)NULL) for this
1315 }
1316
1317 void wxWindowBase::DoSetToolTip(wxToolTip *tooltip)
1318 {
1319 if ( m_tooltip )
1320 delete m_tooltip;
1321
1322 m_tooltip = tooltip;
1323 }
1324
1325 #endif // wxUSE_TOOLTIPS
1326
1327 // ----------------------------------------------------------------------------
1328 // constraints and sizers
1329 // ----------------------------------------------------------------------------
1330
1331 #if wxUSE_CONSTRAINTS
1332
1333 void wxWindowBase::SetConstraints( wxLayoutConstraints *constraints )
1334 {
1335 if ( m_constraints )
1336 {
1337 UnsetConstraints(m_constraints);
1338 delete m_constraints;
1339 }
1340 m_constraints = constraints;
1341 if ( m_constraints )
1342 {
1343 // Make sure other windows know they're part of a 'meaningful relationship'
1344 if ( m_constraints->left.GetOtherWindow() && (m_constraints->left.GetOtherWindow() != this) )
1345 m_constraints->left.GetOtherWindow()->AddConstraintReference(this);
1346 if ( m_constraints->top.GetOtherWindow() && (m_constraints->top.GetOtherWindow() != this) )
1347 m_constraints->top.GetOtherWindow()->AddConstraintReference(this);
1348 if ( m_constraints->right.GetOtherWindow() && (m_constraints->right.GetOtherWindow() != this) )
1349 m_constraints->right.GetOtherWindow()->AddConstraintReference(this);
1350 if ( m_constraints->bottom.GetOtherWindow() && (m_constraints->bottom.GetOtherWindow() != this) )
1351 m_constraints->bottom.GetOtherWindow()->AddConstraintReference(this);
1352 if ( m_constraints->width.GetOtherWindow() && (m_constraints->width.GetOtherWindow() != this) )
1353 m_constraints->width.GetOtherWindow()->AddConstraintReference(this);
1354 if ( m_constraints->height.GetOtherWindow() && (m_constraints->height.GetOtherWindow() != this) )
1355 m_constraints->height.GetOtherWindow()->AddConstraintReference(this);
1356 if ( m_constraints->centreX.GetOtherWindow() && (m_constraints->centreX.GetOtherWindow() != this) )
1357 m_constraints->centreX.GetOtherWindow()->AddConstraintReference(this);
1358 if ( m_constraints->centreY.GetOtherWindow() && (m_constraints->centreY.GetOtherWindow() != this) )
1359 m_constraints->centreY.GetOtherWindow()->AddConstraintReference(this);
1360 }
1361 }
1362
1363 // This removes any dangling pointers to this window in other windows'
1364 // constraintsInvolvedIn lists.
1365 void wxWindowBase::UnsetConstraints(wxLayoutConstraints *c)
1366 {
1367 if ( c )
1368 {
1369 if ( c->left.GetOtherWindow() && (c->top.GetOtherWindow() != this) )
1370 c->left.GetOtherWindow()->RemoveConstraintReference(this);
1371 if ( c->top.GetOtherWindow() && (c->top.GetOtherWindow() != this) )
1372 c->top.GetOtherWindow()->RemoveConstraintReference(this);
1373 if ( c->right.GetOtherWindow() && (c->right.GetOtherWindow() != this) )
1374 c->right.GetOtherWindow()->RemoveConstraintReference(this);
1375 if ( c->bottom.GetOtherWindow() && (c->bottom.GetOtherWindow() != this) )
1376 c->bottom.GetOtherWindow()->RemoveConstraintReference(this);
1377 if ( c->width.GetOtherWindow() && (c->width.GetOtherWindow() != this) )
1378 c->width.GetOtherWindow()->RemoveConstraintReference(this);
1379 if ( c->height.GetOtherWindow() && (c->height.GetOtherWindow() != this) )
1380 c->height.GetOtherWindow()->RemoveConstraintReference(this);
1381 if ( c->centreX.GetOtherWindow() && (c->centreX.GetOtherWindow() != this) )
1382 c->centreX.GetOtherWindow()->RemoveConstraintReference(this);
1383 if ( c->centreY.GetOtherWindow() && (c->centreY.GetOtherWindow() != this) )
1384 c->centreY.GetOtherWindow()->RemoveConstraintReference(this);
1385 }
1386 }
1387
1388 // Back-pointer to other windows we're involved with, so if we delete this
1389 // window, we must delete any constraints we're involved with.
1390 void wxWindowBase::AddConstraintReference(wxWindowBase *otherWin)
1391 {
1392 if ( !m_constraintsInvolvedIn )
1393 m_constraintsInvolvedIn = new wxWindowList;
1394 if ( !m_constraintsInvolvedIn->Find(otherWin) )
1395 m_constraintsInvolvedIn->Append(otherWin);
1396 }
1397
1398 // REMOVE back-pointer to other windows we're involved with.
1399 void wxWindowBase::RemoveConstraintReference(wxWindowBase *otherWin)
1400 {
1401 if ( m_constraintsInvolvedIn )
1402 m_constraintsInvolvedIn->DeleteObject(otherWin);
1403 }
1404
1405 // Reset any constraints that mention this window
1406 void wxWindowBase::DeleteRelatedConstraints()
1407 {
1408 if ( m_constraintsInvolvedIn )
1409 {
1410 wxWindowList::Node *node = m_constraintsInvolvedIn->GetFirst();
1411 while (node)
1412 {
1413 wxWindow *win = node->GetData();
1414 wxLayoutConstraints *constr = win->GetConstraints();
1415
1416 // Reset any constraints involving this window
1417 if ( constr )
1418 {
1419 constr->left.ResetIfWin(this);
1420 constr->top.ResetIfWin(this);
1421 constr->right.ResetIfWin(this);
1422 constr->bottom.ResetIfWin(this);
1423 constr->width.ResetIfWin(this);
1424 constr->height.ResetIfWin(this);
1425 constr->centreX.ResetIfWin(this);
1426 constr->centreY.ResetIfWin(this);
1427 }
1428
1429 wxWindowList::Node *next = node->GetNext();
1430 delete node;
1431 node = next;
1432 }
1433
1434 delete m_constraintsInvolvedIn;
1435 m_constraintsInvolvedIn = (wxWindowList *) NULL;
1436 }
1437 }
1438
1439 #endif // wxUSE_CONSTRAINTS
1440
1441 void wxWindowBase::SetSizer(wxSizer *sizer, bool deleteOld)
1442 {
1443 if ( deleteOld )
1444 delete m_windowSizer;
1445
1446 m_windowSizer = sizer;
1447
1448 SetAutoLayout( sizer != NULL );
1449 }
1450
1451 void wxWindowBase::SetSizerAndFit(wxSizer *sizer, bool deleteOld)
1452 {
1453 SetSizer( sizer, deleteOld );
1454 sizer->SetSizeHints( (wxWindow*) this );
1455 }
1456
1457 #if wxUSE_CONSTRAINTS
1458
1459 void wxWindowBase::SatisfyConstraints()
1460 {
1461 wxLayoutConstraints *constr = GetConstraints();
1462 bool wasOk = constr && constr->AreSatisfied();
1463
1464 ResetConstraints(); // Mark all constraints as unevaluated
1465
1466 int noChanges = 1;
1467
1468 // if we're a top level panel (i.e. our parent is frame/dialog), our
1469 // own constraints will never be satisfied any more unless we do it
1470 // here
1471 if ( wasOk )
1472 {
1473 while ( noChanges > 0 )
1474 {
1475 LayoutPhase1(&noChanges);
1476 }
1477 }
1478
1479 LayoutPhase2(&noChanges);
1480 }
1481
1482 #endif // wxUSE_CONSTRAINTS
1483
1484 bool wxWindowBase::Layout()
1485 {
1486 // If there is a sizer, use it instead of the constraints
1487 if ( GetSizer() )
1488 {
1489 int w, h;
1490 GetVirtualSize(&w, &h);
1491 GetSizer()->SetDimension( 0, 0, w, h );
1492 }
1493 #if wxUSE_CONSTRAINTS
1494 else
1495 {
1496 SatisfyConstraints(); // Find the right constraints values
1497 SetConstraintSizes(); // Recursively set the real window sizes
1498 }
1499 #endif
1500
1501 return TRUE;
1502 }
1503
1504 #if wxUSE_CONSTRAINTS
1505
1506 // first phase of the constraints evaluation: set our own constraints
1507 bool wxWindowBase::LayoutPhase1(int *noChanges)
1508 {
1509 wxLayoutConstraints *constr = GetConstraints();
1510
1511 return !constr || constr->SatisfyConstraints(this, noChanges);
1512 }
1513
1514 // second phase: set the constraints for our children
1515 bool wxWindowBase::LayoutPhase2(int *noChanges)
1516 {
1517 *noChanges = 0;
1518
1519 // Layout children
1520 DoPhase(1);
1521
1522 // Layout grand children
1523 DoPhase(2);
1524
1525 return TRUE;
1526 }
1527
1528 // Do a phase of evaluating child constraints
1529 bool wxWindowBase::DoPhase(int phase)
1530 {
1531 // the list containing the children for which the constraints are already
1532 // set correctly
1533 wxWindowList succeeded;
1534
1535 // the max number of iterations we loop before concluding that we can't set
1536 // the constraints
1537 static const int maxIterations = 500;
1538
1539 for ( int noIterations = 0; noIterations < maxIterations; noIterations++ )
1540 {
1541 int noChanges = 0;
1542
1543 // loop over all children setting their constraints
1544 for ( wxWindowList::Node *node = GetChildren().GetFirst();
1545 node;
1546 node = node->GetNext() )
1547 {
1548 wxWindow *child = node->GetData();
1549 if ( child->IsTopLevel() )
1550 {
1551 // top level children are not inside our client area
1552 continue;
1553 }
1554
1555 if ( !child->GetConstraints() || succeeded.Find(child) )
1556 {
1557 // this one is either already ok or nothing we can do about it
1558 continue;
1559 }
1560
1561 int tempNoChanges = 0;
1562 bool success = phase == 1 ? child->LayoutPhase1(&tempNoChanges)
1563 : child->LayoutPhase2(&tempNoChanges);
1564 noChanges += tempNoChanges;
1565
1566 if ( success )
1567 {
1568 succeeded.Append(child);
1569 }
1570 }
1571
1572 if ( !noChanges )
1573 {
1574 // constraints are set
1575 break;
1576 }
1577 }
1578
1579 return TRUE;
1580 }
1581
1582 void wxWindowBase::ResetConstraints()
1583 {
1584 wxLayoutConstraints *constr = GetConstraints();
1585 if ( constr )
1586 {
1587 constr->left.SetDone(FALSE);
1588 constr->top.SetDone(FALSE);
1589 constr->right.SetDone(FALSE);
1590 constr->bottom.SetDone(FALSE);
1591 constr->width.SetDone(FALSE);
1592 constr->height.SetDone(FALSE);
1593 constr->centreX.SetDone(FALSE);
1594 constr->centreY.SetDone(FALSE);
1595 }
1596
1597 wxWindowList::Node *node = GetChildren().GetFirst();
1598 while (node)
1599 {
1600 wxWindow *win = node->GetData();
1601 if ( !win->IsTopLevel() )
1602 win->ResetConstraints();
1603 node = node->GetNext();
1604 }
1605 }
1606
1607 // Need to distinguish between setting the 'fake' size for windows and sizers,
1608 // and setting the real values.
1609 void wxWindowBase::SetConstraintSizes(bool recurse)
1610 {
1611 wxLayoutConstraints *constr = GetConstraints();
1612 if ( constr && constr->AreSatisfied() )
1613 {
1614 int x = constr->left.GetValue();
1615 int y = constr->top.GetValue();
1616 int w = constr->width.GetValue();
1617 int h = constr->height.GetValue();
1618
1619 if ( (constr->width.GetRelationship() != wxAsIs ) ||
1620 (constr->height.GetRelationship() != wxAsIs) )
1621 {
1622 SetSize(x, y, w, h);
1623 }
1624 else
1625 {
1626 // If we don't want to resize this window, just move it...
1627 Move(x, y);
1628 }
1629 }
1630 else if ( constr )
1631 {
1632 wxLogDebug(wxT("Constraints not satisfied for %s named '%s'."),
1633 GetClassInfo()->GetClassName(),
1634 GetName().c_str());
1635 }
1636
1637 if ( recurse )
1638 {
1639 wxWindowList::Node *node = GetChildren().GetFirst();
1640 while (node)
1641 {
1642 wxWindow *win = node->GetData();
1643 if ( !win->IsTopLevel() && win->GetConstraints() )
1644 win->SetConstraintSizes();
1645 node = node->GetNext();
1646 }
1647 }
1648 }
1649
1650 // Only set the size/position of the constraint (if any)
1651 void wxWindowBase::SetSizeConstraint(int x, int y, int w, int h)
1652 {
1653 wxLayoutConstraints *constr = GetConstraints();
1654 if ( constr )
1655 {
1656 if ( x != -1 )
1657 {
1658 constr->left.SetValue(x);
1659 constr->left.SetDone(TRUE);
1660 }
1661 if ( y != -1 )
1662 {
1663 constr->top.SetValue(y);
1664 constr->top.SetDone(TRUE);
1665 }
1666 if ( w != -1 )
1667 {
1668 constr->width.SetValue(w);
1669 constr->width.SetDone(TRUE);
1670 }
1671 if ( h != -1 )
1672 {
1673 constr->height.SetValue(h);
1674 constr->height.SetDone(TRUE);
1675 }
1676 }
1677 }
1678
1679 void wxWindowBase::MoveConstraint(int x, int y)
1680 {
1681 wxLayoutConstraints *constr = GetConstraints();
1682 if ( constr )
1683 {
1684 if ( x != -1 )
1685 {
1686 constr->left.SetValue(x);
1687 constr->left.SetDone(TRUE);
1688 }
1689 if ( y != -1 )
1690 {
1691 constr->top.SetValue(y);
1692 constr->top.SetDone(TRUE);
1693 }
1694 }
1695 }
1696
1697 void wxWindowBase::GetSizeConstraint(int *w, int *h) const
1698 {
1699 wxLayoutConstraints *constr = GetConstraints();
1700 if ( constr )
1701 {
1702 *w = constr->width.GetValue();
1703 *h = constr->height.GetValue();
1704 }
1705 else
1706 GetSize(w, h);
1707 }
1708
1709 void wxWindowBase::GetClientSizeConstraint(int *w, int *h) const
1710 {
1711 wxLayoutConstraints *constr = GetConstraints();
1712 if ( constr )
1713 {
1714 *w = constr->width.GetValue();
1715 *h = constr->height.GetValue();
1716 }
1717 else
1718 GetClientSize(w, h);
1719 }
1720
1721 void wxWindowBase::GetPositionConstraint(int *x, int *y) const
1722 {
1723 wxLayoutConstraints *constr = GetConstraints();
1724 if ( constr )
1725 {
1726 *x = constr->left.GetValue();
1727 *y = constr->top.GetValue();
1728 }
1729 else
1730 GetPosition(x, y);
1731 }
1732
1733 #endif // wxUSE_CONSTRAINTS
1734
1735 void wxWindowBase::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags) const
1736 {
1737 // don't do it for the dialogs/frames - they float independently of their
1738 // parent
1739 if ( !IsTopLevel() )
1740 {
1741 wxWindow *parent = GetParent();
1742 if ( !(sizeFlags & wxSIZE_NO_ADJUSTMENTS) && parent )
1743 {
1744 wxPoint pt(parent->GetClientAreaOrigin());
1745 x += pt.x;
1746 y += pt.y;
1747 }
1748 }
1749 }
1750
1751 // ----------------------------------------------------------------------------
1752 // do Update UI processing for child controls
1753 // ----------------------------------------------------------------------------
1754
1755 // TODO: should this be implemented for the child window rather
1756 // than the parent? Then you can override it e.g. for wxCheckBox
1757 // to do the Right Thing rather than having to assume a fixed number
1758 // of control classes.
1759 void wxWindowBase::UpdateWindowUI()
1760 {
1761 #if wxUSE_CONTROLS
1762 wxUpdateUIEvent event(GetId());
1763 event.m_eventObject = this;
1764
1765 if ( GetEventHandler()->ProcessEvent(event) )
1766 {
1767 if ( event.GetSetEnabled() )
1768 Enable(event.GetEnabled());
1769
1770 if ( event.GetSetText() )
1771 {
1772 wxControl *control = wxDynamicCastThis(wxControl);
1773 if ( control )
1774 {
1775 #if wxUSE_TEXTCTRL
1776 wxTextCtrl *text = wxDynamicCast(control, wxTextCtrl);
1777 if ( text )
1778 {
1779 if ( event.GetText() != text->GetValue() )
1780 text->SetValue(event.GetText());
1781 }
1782 else
1783 #endif // wxUSE_TEXTCTRL
1784 {
1785 if ( event.GetText() != control->GetLabel() )
1786 control->SetLabel(event.GetText());
1787 }
1788 }
1789 }
1790
1791 #if wxUSE_CHECKBOX
1792 wxCheckBox *checkbox = wxDynamicCastThis(wxCheckBox);
1793 if ( checkbox )
1794 {
1795 if ( event.GetSetChecked() )
1796 checkbox->SetValue(event.GetChecked());
1797 }
1798 #endif // wxUSE_CHECKBOX
1799
1800 #if wxUSE_RADIOBTN
1801 wxRadioButton *radiobtn = wxDynamicCastThis(wxRadioButton);
1802 if ( radiobtn )
1803 {
1804 if ( event.GetSetChecked() )
1805 radiobtn->SetValue(event.GetChecked());
1806 }
1807 #endif // wxUSE_RADIOBTN
1808 }
1809 #endif // wxUSE_CONTROLS
1810 }
1811
1812 // ----------------------------------------------------------------------------
1813 // dialog units translations
1814 // ----------------------------------------------------------------------------
1815
1816 wxPoint wxWindowBase::ConvertPixelsToDialog(const wxPoint& pt)
1817 {
1818 int charWidth = GetCharWidth();
1819 int charHeight = GetCharHeight();
1820 wxPoint pt2(-1, -1);
1821 if (pt.x != -1)
1822 pt2.x = (int) ((pt.x * 4) / charWidth) ;
1823 if (pt.y != -1)
1824 pt2.y = (int) ((pt.y * 8) / charHeight) ;
1825
1826 return pt2;
1827 }
1828
1829 wxPoint wxWindowBase::ConvertDialogToPixels(const wxPoint& pt)
1830 {
1831 int charWidth = GetCharWidth();
1832 int charHeight = GetCharHeight();
1833 wxPoint pt2(-1, -1);
1834 if (pt.x != -1)
1835 pt2.x = (int) ((pt.x * charWidth) / 4) ;
1836 if (pt.y != -1)
1837 pt2.y = (int) ((pt.y * charHeight) / 8) ;
1838
1839 return pt2;
1840 }
1841
1842 // ----------------------------------------------------------------------------
1843 // event handlers
1844 // ----------------------------------------------------------------------------
1845
1846 // propagate the colour change event to the subwindows
1847 void wxWindowBase::OnSysColourChanged(wxSysColourChangedEvent& event)
1848 {
1849 wxWindowList::Node *node = GetChildren().GetFirst();
1850 while ( node )
1851 {
1852 // Only propagate to non-top-level windows
1853 wxWindow *win = node->GetData();
1854 if ( !win->IsTopLevel() )
1855 {
1856 wxSysColourChangedEvent event2;
1857 event.m_eventObject = win;
1858 win->GetEventHandler()->ProcessEvent(event2);
1859 }
1860
1861 node = node->GetNext();
1862 }
1863 }
1864
1865 // the default action is to populate dialog with data when it's created
1866 void wxWindowBase::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) )
1867 {
1868 TransferDataToWindow();
1869 }
1870
1871 // process Ctrl-Alt-mclick
1872 void wxWindowBase::OnMiddleClick( wxMouseEvent& event )
1873 {
1874 #if wxUSE_MSGDLG
1875 if ( event.ControlDown() && event.AltDown() )
1876 {
1877 // don't translate these strings
1878 wxString port;
1879
1880 #ifdef __WXUNIVERSAL__
1881 port = _T("Univ/");
1882 #endif // __WXUNIVERSAL__
1883
1884 switch ( wxGetOsVersion() )
1885 {
1886 case wxMOTIF_X: port += _T("Motif"); break;
1887 case wxMAC:
1888 case wxMAC_DARWIN: port += _T("Mac"); break;
1889 case wxBEOS: port += _T("BeOS"); break;
1890 case wxGTK:
1891 case wxGTK_WIN32:
1892 case wxGTK_OS2:
1893 case wxGTK_BEOS: port += _T("GTK"); break;
1894 case wxWINDOWS:
1895 case wxPENWINDOWS:
1896 case wxWINDOWS_NT:
1897 case wxWIN32S:
1898 case wxWIN95:
1899 case wxWIN386: port += _T("MS Windows"); break;
1900 case wxMGL_UNIX:
1901 case wxMGL_X:
1902 case wxMGL_WIN32:
1903 case wxMGL_OS2: port += _T("MGL"); break;
1904 case wxWINDOWS_OS2:
1905 case wxOS2_PM: port += _T("OS/2"); break;
1906 default: port += _T("unknown"); break;
1907 }
1908
1909 wxMessageBox(wxString::Format(
1910 _T(
1911 " wxWindows Library (%s port)\nVersion %u.%u.%u%s, compiled at %s %s\n Copyright (c) 1995-2002 wxWindows team"
1912 ),
1913 port.c_str(),
1914 wxMAJOR_VERSION,
1915 wxMINOR_VERSION,
1916 wxRELEASE_NUMBER,
1917 #if wxUSE_UNICODE
1918 L" (Unicode)",
1919 #else
1920 "",
1921 #endif
1922 __TDATE__,
1923 __TTIME__
1924 ),
1925 _T("wxWindows information"),
1926 wxICON_INFORMATION | wxOK,
1927 (wxWindow *)this);
1928 }
1929 else
1930 #endif // wxUSE_MSGDLG
1931 {
1932 event.Skip();
1933 }
1934 }
1935
1936 // ----------------------------------------------------------------------------
1937 // list classes implementation
1938 // ----------------------------------------------------------------------------
1939
1940 void wxWindowListNode::DeleteData()
1941 {
1942 delete (wxWindow *)GetData();
1943 }
1944
1945 // ----------------------------------------------------------------------------
1946 // borders
1947 // ----------------------------------------------------------------------------
1948
1949 wxBorder wxWindowBase::GetBorder() const
1950 {
1951 wxBorder border = (wxBorder)(m_windowStyle & wxBORDER_MASK);
1952 if ( border == wxBORDER_DEFAULT )
1953 {
1954 border = GetDefaultBorder();
1955 }
1956
1957 return border;
1958 }
1959
1960 wxBorder wxWindowBase::GetDefaultBorder() const
1961 {
1962 return wxBORDER_NONE;
1963 }
1964
1965 // ----------------------------------------------------------------------------
1966 // hit testing
1967 // ----------------------------------------------------------------------------
1968
1969 wxHitTest wxWindowBase::DoHitTest(wxCoord x, wxCoord y) const
1970 {
1971 // here we just check if the point is inside the window or not
1972
1973 // check the top and left border first
1974 bool outside = x < 0 || y < 0;
1975 if ( !outside )
1976 {
1977 // check the right and bottom borders too
1978 wxSize size = GetSize();
1979 outside = x >= size.x || y >= size.y;
1980 }
1981
1982 return outside ? wxHT_WINDOW_OUTSIDE : wxHT_WINDOW_INSIDE;
1983 }
1984
1985 // ----------------------------------------------------------------------------
1986 // mouse capture
1987 // ----------------------------------------------------------------------------
1988
1989 struct WXDLLEXPORT wxWindowNext
1990 {
1991 wxWindow *win;
1992 wxWindowNext *next;
1993 } *wxWindowBase::ms_winCaptureNext = NULL;
1994
1995 void wxWindowBase::CaptureMouse()
1996 {
1997 wxLogTrace(_T("mousecapture"), _T("CaptureMouse(%p)"), this);
1998
1999 wxWindow *winOld = GetCapture();
2000 if ( winOld )
2001 {
2002 ((wxWindowBase*) winOld)->DoReleaseMouse();
2003
2004 // save it on stack
2005 wxWindowNext *item = new wxWindowNext;
2006 item->win = winOld;
2007 item->next = ms_winCaptureNext;
2008 ms_winCaptureNext = item;
2009 }
2010 //else: no mouse capture to save
2011
2012 DoCaptureMouse();
2013 }
2014
2015 void wxWindowBase::ReleaseMouse()
2016 {
2017 wxLogTrace(_T("mousecapture"), _T("ReleaseMouse(%p)"), this);
2018
2019 wxASSERT_MSG( GetCapture() == this, wxT("attempt to release mouse, but this window hasn't captured it") );
2020
2021 DoReleaseMouse();
2022
2023 if ( ms_winCaptureNext )
2024 {
2025 ((wxWindowBase*)ms_winCaptureNext->win)->DoCaptureMouse();
2026
2027 wxWindowNext *item = ms_winCaptureNext;
2028 ms_winCaptureNext = item->next;
2029 delete item;
2030 }
2031 //else: stack is empty, no previous capture
2032
2033 wxLogTrace(_T("mousecapture"),
2034 _T("After ReleaseMouse() mouse is captured by %p"),
2035 GetCapture());
2036 }
2037
2038 // ----------------------------------------------------------------------------
2039 // global functions
2040 // ----------------------------------------------------------------------------
2041
2042 wxWindow* wxGetTopLevelParent(wxWindow *win)
2043 {
2044 while ( win && !win->IsTopLevel() )
2045 win = win->GetParent();
2046
2047 return win;
2048 }
2049
2050 // vi:sts=4:sw=4:et
wxWidgets (Impactor)