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