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