]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/common/wincmn.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
int warning
[wxWidgets.git] / src / common / wincmn.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/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) wxWidgets team
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12// ============================================================================
13// declarations
14// ============================================================================
15
16// ----------------------------------------------------------------------------
17// headers
18// ----------------------------------------------------------------------------
19
20// For compilers that support precompilation, includes "wx.h".
21#include "wx/wxprec.h"
22
23#ifdef __BORLANDC__
24 #pragma hdrstop
25#endif
26
27#ifndef WX_PRECOMP
28 #include "wx/string.h"
29 #include "wx/log.h"
30 #include "wx/intl.h"
31 #include "wx/frame.h"
32 #include "wx/window.h"
33 #include "wx/control.h"
34 #include "wx/checkbox.h"
35 #include "wx/radiobut.h"
36 #include "wx/statbox.h"
37 #include "wx/textctrl.h"
38 #include "wx/settings.h"
39 #include "wx/dialog.h"
40 #include "wx/msgdlg.h"
41 #include "wx/statusbr.h"
42 #include "wx/toolbar.h"
43 #include "wx/dcclient.h"
44 #include "wx/scrolbar.h"
45 #include "wx/layout.h"
46 #include "wx/sizer.h"
47#endif //WX_PRECOMP
48
49#if wxUSE_DRAG_AND_DROP
50 #include "wx/dnd.h"
51#endif // wxUSE_DRAG_AND_DROP
52
53#if wxUSE_ACCESSIBILITY
54 #include "wx/access.h"
55#endif
56
57#if wxUSE_HELP
58 #include "wx/cshelp.h"
59#endif // wxUSE_HELP
60
61#if wxUSE_TOOLTIPS
62 #include "wx/tooltip.h"
63#endif // wxUSE_TOOLTIPS
64
65#if wxUSE_CARET
66 #include "wx/caret.h"
67#endif // wxUSE_CARET
68
69#if wxUSE_SYSTEM_OPTIONS
70 #include "wx/sysopt.h"
71#endif
72
73// For reporting compile- and runtime version of GTK+ in the ctrl+alt+mclick dialog.
74// The gtk includes don't pull any other headers in, at least not on my system - MR
75#ifdef __WXGTK__
76 #ifdef __WXGTK20__
77 #include <gtk/gtkversion.h>
78 #else
79 #include <gtk/gtkfeatures.h>
80 #endif
81 extern const unsigned int gtk_major_version;
82 extern const unsigned int gtk_minor_version;
83 extern const unsigned int gtk_micro_version;
84#endif
85
86// Windows List
87WXDLLIMPEXP_DATA_CORE(wxWindowList) wxTopLevelWindows;
88
89// ----------------------------------------------------------------------------
90// static data
91// ----------------------------------------------------------------------------
92
93#if defined(__WXPALMOS__)
94int wxWindowBase::ms_lastControlId = 32767;
95#elif defined(__WXPM__)
96int wxWindowBase::ms_lastControlId = 2000;
97#else
98int wxWindowBase::ms_lastControlId = -200;
99#endif
100
101IMPLEMENT_ABSTRACT_CLASS(wxWindowBase, wxEvtHandler)
102
103// ----------------------------------------------------------------------------
104// event table
105// ----------------------------------------------------------------------------
106
107BEGIN_EVENT_TABLE(wxWindowBase, wxEvtHandler)
108 EVT_SYS_COLOUR_CHANGED(wxWindowBase::OnSysColourChanged)
109 EVT_INIT_DIALOG(wxWindowBase::OnInitDialog)
110 EVT_MIDDLE_DOWN(wxWindowBase::OnMiddleClick)
111
112#if wxUSE_HELP
113 EVT_HELP(wxID_ANY, wxWindowBase::OnHelp)
114#endif // wxUSE_HELP
115
116END_EVENT_TABLE()
117
118// ============================================================================
119// implementation of the common functionality of the wxWindow class
120// ============================================================================
121
122// ----------------------------------------------------------------------------
123// initialization
124// ----------------------------------------------------------------------------
125
126// the default initialization
127wxWindowBase::wxWindowBase()
128{
129 // no window yet, no parent nor children
130 m_parent = (wxWindow *)NULL;
131 m_windowId = wxID_ANY;
132
133 // no constraints on the minimal window size
134 m_minWidth =
135 m_maxWidth = wxDefaultCoord;
136 m_minHeight =
137 m_maxHeight = wxDefaultCoord;
138
139 // invalidiated cache value
140 m_bestSizeCache = wxDefaultSize;
141
142 // window are created enabled and visible by default
143 m_isShown =
144 m_isEnabled = true;
145
146 // the default event handler is just this window
147 m_eventHandler = this;
148
149#if wxUSE_VALIDATORS
150 // no validator
151 m_windowValidator = (wxValidator *) NULL;
152#endif // wxUSE_VALIDATORS
153
154 // the colours/fonts are default for now, so leave m_font,
155 // m_backgroundColour and m_foregroundColour uninitialized and set those
156 m_hasBgCol =
157 m_hasFgCol =
158 m_hasFont = false;
159 m_inheritBgCol =
160 m_inheritFgCol =
161 m_inheritFont = false;
162
163 // no style bits
164 m_exStyle =
165 m_windowStyle = 0;
166
167 m_backgroundStyle = wxBG_STYLE_SYSTEM;
168
169#if wxUSE_CONSTRAINTS
170 // no constraints whatsoever
171 m_constraints = (wxLayoutConstraints *) NULL;
172 m_constraintsInvolvedIn = (wxWindowList *) NULL;
173#endif // wxUSE_CONSTRAINTS
174
175 m_windowSizer = (wxSizer *) NULL;
176 m_containingSizer = (wxSizer *) NULL;
177 m_autoLayout = false;
178
179#if wxUSE_DRAG_AND_DROP
180 m_dropTarget = (wxDropTarget *)NULL;
181#endif // wxUSE_DRAG_AND_DROP
182
183#if wxUSE_TOOLTIPS
184 m_tooltip = (wxToolTip *)NULL;
185#endif // wxUSE_TOOLTIPS
186
187#if wxUSE_CARET
188 m_caret = (wxCaret *)NULL;
189#endif // wxUSE_CARET
190
191#if wxUSE_PALETTE
192 m_hasCustomPalette = false;
193#endif // wxUSE_PALETTE
194
195#if wxUSE_ACCESSIBILITY
196 m_accessible = NULL;
197#endif
198
199 m_virtualSize = wxDefaultSize;
200
201 m_minVirtualWidth =
202 m_maxVirtualWidth = wxDefaultCoord;
203 m_minVirtualHeight =
204 m_maxVirtualHeight = wxDefaultCoord;
205
206 m_windowVariant = wxWINDOW_VARIANT_NORMAL;
207#if wxUSE_SYSTEM_OPTIONS
208 if ( wxSystemOptions::HasOption(wxWINDOW_DEFAULT_VARIANT) )
209 {
210 m_windowVariant = (wxWindowVariant) wxSystemOptions::GetOptionInt( wxWINDOW_DEFAULT_VARIANT ) ;
211 }
212#endif
213
214 // Whether we're using the current theme for this window (wxGTK only for now)
215 m_themeEnabled = false;
216
217 // VZ: this one shouldn't exist...
218 m_isBeingDeleted = false;
219}
220
221// common part of window creation process
222bool wxWindowBase::CreateBase(wxWindowBase *parent,
223 wxWindowID id,
224 const wxPoint& WXUNUSED(pos),
225 const wxSize& WXUNUSED(size),
226 long style,
227 const wxValidator& wxVALIDATOR_PARAM(validator),
228 const wxString& name)
229{
230#if wxUSE_STATBOX
231 // wxGTK doesn't allow to create controls with static box as the parent so
232 // this will result in a crash when the program is ported to wxGTK so warn
233 // the user about it
234
235 // if you get this assert, the correct solution is to create the controls
236 // as siblings of the static box
237 wxASSERT_MSG( !parent || !wxDynamicCast(parent, wxStaticBox),
238 _T("wxStaticBox can't be used as a window parent!") );
239#endif // wxUSE_STATBOX
240
241 // ids are limited to 16 bits under MSW so if you care about portability,
242 // it's not a good idea to use ids out of this range (and negative ids are
243 // reserved for wxWidgets own usage)
244 wxASSERT_MSG( id == wxID_ANY || (id >= 0 && id < 32767),
245 _T("invalid id value") );
246
247 // generate a new id if the user doesn't care about it
248 m_windowId = id == wxID_ANY ? NewControlId() : id;
249
250 SetName(name);
251 SetWindowStyleFlag(style);
252 SetParent(parent);
253
254#if wxUSE_VALIDATORS
255 SetValidator(validator);
256#endif // wxUSE_VALIDATORS
257
258 // if the parent window has wxWS_EX_VALIDATE_RECURSIVELY set, we want to
259 // have it too - like this it's possible to set it only in the top level
260 // dialog/frame and all children will inherit it by defult
261 if ( parent && (parent->GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) )
262 {
263 SetExtraStyle(GetExtraStyle() | wxWS_EX_VALIDATE_RECURSIVELY);
264 }
265
266 return true;
267}
268
269// ----------------------------------------------------------------------------
270// destruction
271// ----------------------------------------------------------------------------
272
273// common clean up
274wxWindowBase::~wxWindowBase()
275{
276 wxASSERT_MSG( GetCapture() != this, wxT("attempt to destroy window with mouse capture") );
277
278 // FIXME if these 2 cases result from programming errors in the user code
279 // we should probably assert here instead of silently fixing them
280
281 // Just in case the window has been Closed, but we're then deleting
282 // immediately: don't leave dangling pointers.
283 wxPendingDelete.DeleteObject(this);
284
285 // Just in case we've loaded a top-level window via LoadNativeDialog but
286 // we weren't a dialog class
287 wxTopLevelWindows.DeleteObject((wxWindow*)this);
288
289 wxASSERT_MSG( GetChildren().GetCount() == 0, wxT("children not destroyed") );
290
291 // reset the dangling pointer our parent window may keep to us
292 if ( m_parent )
293 {
294 if ( m_parent->GetDefaultItem() == this )
295 {
296 m_parent->SetDefaultItem(NULL);
297 }
298
299 m_parent->RemoveChild(this);
300 }
301
302#if wxUSE_CARET
303 delete m_caret;
304#endif // wxUSE_CARET
305
306#if wxUSE_VALIDATORS
307 delete m_windowValidator;
308#endif // wxUSE_VALIDATORS
309
310#if wxUSE_CONSTRAINTS
311 // Have to delete constraints/sizer FIRST otherwise sizers may try to look
312 // at deleted windows as they delete themselves.
313 DeleteRelatedConstraints();
314
315 if ( m_constraints )
316 {
317 // This removes any dangling pointers to this window in other windows'
318 // constraintsInvolvedIn lists.
319 UnsetConstraints(m_constraints);
320 delete m_constraints;
321 m_constraints = NULL;
322 }
323#endif // wxUSE_CONSTRAINTS
324
325 if ( m_containingSizer )
326 m_containingSizer->Detach( (wxWindow*)this );
327
328 delete m_windowSizer;
329
330#if wxUSE_DRAG_AND_DROP
331 delete m_dropTarget;
332#endif // wxUSE_DRAG_AND_DROP
333
334#if wxUSE_TOOLTIPS
335 delete m_tooltip;
336#endif // wxUSE_TOOLTIPS
337
338#if wxUSE_ACCESSIBILITY
339 delete m_accessible;
340#endif
341}
342
343bool wxWindowBase::Destroy()
344{
345 delete this;
346
347 return true;
348}
349
350bool wxWindowBase::Close(bool force)
351{
352 wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
353 event.SetEventObject(this);
354 event.SetCanVeto(!force);
355
356 // return false if window wasn't closed because the application vetoed the
357 // close event
358 return GetEventHandler()->ProcessEvent(event) && !event.GetVeto();
359}
360
361bool wxWindowBase::DestroyChildren()
362{
363 wxWindowList::compatibility_iterator node;
364 for ( ;; )
365 {
366 // we iterate until the list becomes empty
367 node = GetChildren().GetFirst();
368 if ( !node )
369 break;
370
371 wxWindow *child = node->GetData();
372
373 // note that we really want to call delete and not ->Destroy() here
374 // because we want to delete the child immediately, before we are
375 // deleted, and delayed deletion would result in problems as our (top
376 // level) child could outlive its parent
377 delete child;
378
379 wxASSERT_MSG( !GetChildren().Find(child),
380 wxT("child didn't remove itself using RemoveChild()") );
381 }
382
383 return true;
384}
385
386// ----------------------------------------------------------------------------
387// size/position related methods
388// ----------------------------------------------------------------------------
389
390// centre the window with respect to its parent in either (or both) directions
391void wxWindowBase::DoCentre(int dir)
392{
393 wxCHECK_RET( !(dir & wxCENTRE_ON_SCREEN) && GetParent(),
394 _T("this method only implements centering child windows") );
395
396 SetSize(GetRect().CentreIn(GetParent()->GetClientSize(), dir));
397}
398
399// fits the window around the children
400void wxWindowBase::Fit()
401{
402 if ( !GetChildren().empty() )
403 {
404 SetClientSize(GetBestSize());
405 }
406 //else: do nothing if we have no children
407}
408
409// fits virtual size (ie. scrolled area etc.) around children
410void wxWindowBase::FitInside()
411{
412 if ( GetChildren().GetCount() > 0 )
413 {
414 SetVirtualSize( GetBestVirtualSize() );
415 }
416}
417
418// On Mac, scrollbars are explicitly children.
419#ifdef __WXMAC__
420static bool wxHasRealChildren(const wxWindowBase* win)
421{
422 int realChildCount = 0;
423
424 for ( wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
425 node;
426 node = node->GetNext() )
427 {
428 wxWindow *win = node->GetData();
429 if ( !win->IsTopLevel() && win->IsShown() && !win->IsKindOf(CLASSINFO(wxScrollBar)))
430 realChildCount ++;
431 }
432 return (realChildCount > 0);
433}
434#endif
435
436void wxWindowBase::InvalidateBestSize()
437{
438 m_bestSizeCache = wxDefaultSize;
439
440 // parent's best size calculation may depend on its children's
441 // as long as child window we are in is not top level window itself
442 // (because the TLW size is never resized automatically)
443 // so let's invalidate it as well to be safe:
444 if (m_parent && !IsTopLevel())
445 m_parent->InvalidateBestSize();
446}
447
448// return the size best suited for the current window
449wxSize wxWindowBase::DoGetBestSize() const
450{
451 wxSize best;
452
453 if ( m_windowSizer )
454 {
455 best = GetWindowSizeForVirtualSize(m_windowSizer->GetMinSize());
456 }
457#if wxUSE_CONSTRAINTS
458 else if ( m_constraints )
459 {
460 wxConstCast(this, wxWindowBase)->SatisfyConstraints();
461
462 // our minimal acceptable size is such that all our windows fit inside
463 int maxX = 0,
464 maxY = 0;
465
466 for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
467 node;
468 node = node->GetNext() )
469 {
470 wxLayoutConstraints *c = node->GetData()->GetConstraints();
471 if ( !c )
472 {
473 // it's not normal that we have an unconstrained child, but
474 // what can we do about it?
475 continue;
476 }
477
478 int x = c->right.GetValue(),
479 y = c->bottom.GetValue();
480
481 if ( x > maxX )
482 maxX = x;
483
484 if ( y > maxY )
485 maxY = y;
486
487 // TODO: we must calculate the overlaps somehow, otherwise we
488 // will never return a size bigger than the current one :-(
489 }
490
491 best = wxSize(maxX, maxY);
492 }
493#endif // wxUSE_CONSTRAINTS
494 else if ( !GetChildren().empty()
495#ifdef __WXMAC__
496 && wxHasRealChildren(this)
497#endif
498 )
499 {
500 // our minimal acceptable size is such that all our visible child windows fit inside
501 int maxX = 0,
502 maxY = 0;
503
504 for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
505 node;
506 node = node->GetNext() )
507 {
508 wxWindow *win = node->GetData();
509 if ( win->IsTopLevel() || ( ! win->IsShown() )
510#if wxUSE_STATUSBAR
511 || wxDynamicCast(win, wxStatusBar)
512#endif // wxUSE_STATUSBAR
513 )
514 {
515 // dialogs and frames lie in different top level windows -
516 // don't deal with them here; as for the status bars, they
517 // don't lie in the client area at all
518 continue;
519 }
520
521 int wx, wy, ww, wh;
522 win->GetPosition(&wx, &wy);
523
524 // if the window hadn't been positioned yet, assume that it is in
525 // the origin
526 if ( wx == wxDefaultCoord )
527 wx = 0;
528 if ( wy == wxDefaultCoord )
529 wy = 0;
530
531 win->GetSize(&ww, &wh);
532 if ( wx + ww > maxX )
533 maxX = wx + ww;
534 if ( wy + wh > maxY )
535 maxY = wy + wh;
536 }
537
538 // for compatibility with the old versions and because it really looks
539 // slightly more pretty like this, add a pad
540 maxX += 7;
541 maxY += 14;
542
543 best = wxSize(maxX, maxY);
544 }
545 else // ! has children
546 {
547 // for a generic window there is no natural best size so, if the
548 // minimal size is not set, use the current size but take care to
549 // remember it as minimal size for the next time because our best size
550 // should be constant: otherwise we could get into a situation when the
551 // window is initially at some size, then expanded to a larger size and
552 // then, when the containing window is shrunk back (because our initial
553 // best size had been used for computing the parent min size), we can't
554 // be shrunk back any more because our best size is now bigger
555 wxSize size = GetMinSize();
556 if ( !size.IsFullySpecified() )
557 {
558 size.SetDefaults(GetSize());
559 wxConstCast(this, wxWindowBase)->SetMinSize(size);
560 }
561
562 // return as-is, unadjusted by the client size difference.
563 return size;
564 }
565
566 // Add any difference between size and client size
567 wxSize diff = GetSize() - GetClientSize();
568 best.x += wxMax(0, diff.x);
569 best.y += wxMax(0, diff.y);
570
571 return best;
572}
573
574
575wxSize wxWindowBase::GetBestFittingSize() const
576{
577 // merge the best size with the min size, giving priority to the min size
578 wxSize min = GetMinSize();
579 if (min.x == wxDefaultCoord || min.y == wxDefaultCoord)
580 {
581 wxSize best = GetBestSize();
582 if (min.x == wxDefaultCoord) min.x = best.x;
583 if (min.y == wxDefaultCoord) min.y = best.y;
584 }
585 return min;
586}
587
588
589void wxWindowBase::SetBestFittingSize(const wxSize& size)
590{
591 // Set the min size to the size passed in. This will usually either be
592 // wxDefaultSize or the size passed to this window's ctor/Create function.
593 SetMinSize(size);
594
595 // Merge the size with the best size if needed
596 wxSize best = GetBestFittingSize();
597
598 // If the current size doesn't match then change it
599 if (GetSize() != best)
600 SetSize(best);
601}
602
603
604// by default the origin is not shifted
605wxPoint wxWindowBase::GetClientAreaOrigin() const
606{
607 return wxPoint(0,0);
608}
609
610// set the min/max size of the window
611void wxWindowBase::DoSetSizeHints(int minW, int minH,
612 int maxW, int maxH,
613 int WXUNUSED(incW), int WXUNUSED(incH))
614{
615 // setting min width greater than max width leads to infinite loops under
616 // X11 and generally doesn't make any sense, so don't allow it
617 wxCHECK_RET( (minW == wxDefaultCoord || maxW == wxDefaultCoord || minW <= maxW) &&
618 (minH == wxDefaultCoord || maxH == wxDefaultCoord || minH <= maxH),
619 _T("min width/height must be less than max width/height!") );
620
621 m_minWidth = minW;
622 m_maxWidth = maxW;
623 m_minHeight = minH;
624 m_maxHeight = maxH;
625}
626
627void wxWindowBase::SetWindowVariant( wxWindowVariant variant )
628{
629 if ( m_windowVariant != variant )
630 {
631 m_windowVariant = variant;
632
633 DoSetWindowVariant(variant);
634 }
635}
636
637void wxWindowBase::DoSetWindowVariant( wxWindowVariant variant )
638{
639 // adjust the font height to correspond to our new variant (notice that
640 // we're only called if something really changed)
641 wxFont font = GetFont();
642 int size = font.GetPointSize();
643 switch ( variant )
644 {
645 case wxWINDOW_VARIANT_NORMAL:
646 break;
647
648 case wxWINDOW_VARIANT_SMALL:
649 size *= 3;
650 size /= 4;
651 break;
652
653 case wxWINDOW_VARIANT_MINI:
654 size *= 2;
655 size /= 3;
656 break;
657
658 case wxWINDOW_VARIANT_LARGE:
659 size *= 5;
660 size /= 4;
661 break;
662
663 default:
664 wxFAIL_MSG(_T("unexpected window variant"));
665 break;
666 }
667
668 font.SetPointSize(size);
669 SetFont(font);
670}
671
672void wxWindowBase::SetVirtualSizeHints( int minW, int minH,
673 int maxW, int maxH )
674{
675 m_minVirtualWidth = minW;
676 m_maxVirtualWidth = maxW;
677 m_minVirtualHeight = minH;
678 m_maxVirtualHeight = maxH;
679}
680
681void wxWindowBase::DoSetVirtualSize( int x, int y )
682{
683 if ( m_minVirtualWidth != wxDefaultCoord && m_minVirtualWidth > x )
684 x = m_minVirtualWidth;
685 if ( m_maxVirtualWidth != wxDefaultCoord && m_maxVirtualWidth < x )
686 x = m_maxVirtualWidth;
687 if ( m_minVirtualHeight != wxDefaultCoord && m_minVirtualHeight > y )
688 y = m_minVirtualHeight;
689 if ( m_maxVirtualHeight != wxDefaultCoord && m_maxVirtualHeight < y )
690 y = m_maxVirtualHeight;
691
692 m_virtualSize = wxSize(x, y);
693}
694
695wxSize wxWindowBase::DoGetVirtualSize() const
696{
697 // we should use the entire client area so if it is greater than our
698 // virtual size, expand it to fit (otherwise if the window is big enough we
699 // wouldn't be using parts of it)
700 wxSize size = GetClientSize();
701 if ( m_virtualSize.x > size.x )
702 size.x = m_virtualSize.x;
703
704 if ( m_virtualSize.y >= size.y )
705 size.y = m_virtualSize.y;
706
707 return size;
708}
709
710void wxWindowBase::DoGetScreenPosition(int *x, int *y) const
711{
712 // screen position is the same as (0, 0) in client coords for non TLWs (and
713 // TLWs override this method)
714 if ( x )
715 *x = 0;
716 if ( y )
717 *y = 0;
718
719 ClientToScreen(x, y);
720}
721
722// ----------------------------------------------------------------------------
723// show/hide/enable/disable the window
724// ----------------------------------------------------------------------------
725
726bool wxWindowBase::Show(bool show)
727{
728 if ( show != m_isShown )
729 {
730 m_isShown = show;
731
732 return true;
733 }
734 else
735 {
736 return false;
737 }
738}
739
740bool wxWindowBase::Enable(bool enable)
741{
742 if ( enable != m_isEnabled )
743 {
744 m_isEnabled = enable;
745
746 return true;
747 }
748 else
749 {
750 return false;
751 }
752}
753// ----------------------------------------------------------------------------
754// RTTI
755// ----------------------------------------------------------------------------
756
757bool wxWindowBase::IsTopLevel() const
758{
759 return false;
760}
761
762// ----------------------------------------------------------------------------
763// reparenting the window
764// ----------------------------------------------------------------------------
765
766void wxWindowBase::AddChild(wxWindowBase *child)
767{
768 wxCHECK_RET( child, wxT("can't add a NULL child") );
769
770 // this should never happen and it will lead to a crash later if it does
771 // because RemoveChild() will remove only one node from the children list
772 // and the other(s) one(s) will be left with dangling pointers in them
773 wxASSERT_MSG( !GetChildren().Find((wxWindow*)child), _T("AddChild() called twice") );
774
775 GetChildren().Append((wxWindow*)child);
776 child->SetParent(this);
777}
778
779void wxWindowBase::RemoveChild(wxWindowBase *child)
780{
781 wxCHECK_RET( child, wxT("can't remove a NULL child") );
782
783 GetChildren().DeleteObject((wxWindow *)child);
784 child->SetParent(NULL);
785}
786
787bool wxWindowBase::Reparent(wxWindowBase *newParent)
788{
789 wxWindow *oldParent = GetParent();
790 if ( newParent == oldParent )
791 {
792 // nothing done
793 return false;
794 }
795
796 // unlink this window from the existing parent.
797 if ( oldParent )
798 {
799 oldParent->RemoveChild(this);
800 }
801 else
802 {
803 wxTopLevelWindows.DeleteObject((wxWindow *)this);
804 }
805
806 // add it to the new one
807 if ( newParent )
808 {
809 newParent->AddChild(this);
810 }
811 else
812 {
813 wxTopLevelWindows.Append((wxWindow *)this);
814 }
815
816 return true;
817}
818
819// ----------------------------------------------------------------------------
820// event handler stuff
821// ----------------------------------------------------------------------------
822
823void wxWindowBase::PushEventHandler(wxEvtHandler *handler)
824{
825 wxEvtHandler *handlerOld = GetEventHandler();
826
827 handler->SetNextHandler(handlerOld);
828
829 if ( handlerOld )
830 GetEventHandler()->SetPreviousHandler(handler);
831
832 SetEventHandler(handler);
833}
834
835wxEvtHandler *wxWindowBase::PopEventHandler(bool deleteHandler)
836{
837 wxEvtHandler *handlerA = GetEventHandler();
838 if ( handlerA )
839 {
840 wxEvtHandler *handlerB = handlerA->GetNextHandler();
841 handlerA->SetNextHandler((wxEvtHandler *)NULL);
842
843 if ( handlerB )
844 handlerB->SetPreviousHandler((wxEvtHandler *)NULL);
845 SetEventHandler(handlerB);
846
847 if ( deleteHandler )
848 {
849 delete handlerA;
850 handlerA = (wxEvtHandler *)NULL;
851 }
852 }
853
854 return handlerA;
855}
856
857bool wxWindowBase::RemoveEventHandler(wxEvtHandler *handler)
858{
859 wxCHECK_MSG( handler, false, _T("RemoveEventHandler(NULL) called") );
860
861 wxEvtHandler *handlerPrev = NULL,
862 *handlerCur = GetEventHandler();
863 while ( handlerCur )
864 {
865 wxEvtHandler *handlerNext = handlerCur->GetNextHandler();
866
867 if ( handlerCur == handler )
868 {
869 if ( handlerPrev )
870 {
871 handlerPrev->SetNextHandler(handlerNext);
872 }
873 else
874 {
875 SetEventHandler(handlerNext);
876 }
877
878 if ( handlerNext )
879 {
880 handlerNext->SetPreviousHandler ( handlerPrev );
881 }
882
883 handler->SetNextHandler(NULL);
884 handler->SetPreviousHandler(NULL);
885
886 return true;
887 }
888
889 handlerPrev = handlerCur;
890 handlerCur = handlerNext;
891 }
892
893 wxFAIL_MSG( _T("where has the event handler gone?") );
894
895 return false;
896}
897
898// ----------------------------------------------------------------------------
899// colours, fonts &c
900// ----------------------------------------------------------------------------
901
902void wxWindowBase::InheritAttributes()
903{
904 const wxWindowBase * const parent = GetParent();
905 if ( !parent )
906 return;
907
908 // we only inherit attributes which had been explicitly set for the parent
909 // which ensures that this only happens if the user really wants it and
910 // not by default which wouldn't make any sense in modern GUIs where the
911 // controls don't all use the same fonts (nor colours)
912 if ( parent->m_inheritFont && !m_hasFont )
913 SetFont(parent->GetFont());
914
915 // in addition, there is a possibility to explicitly forbid inheriting
916 // colours at each class level by overriding ShouldInheritColours()
917 if ( ShouldInheritColours() )
918 {
919 if ( parent->m_inheritFgCol && !m_hasFgCol )
920 SetForegroundColour(parent->GetForegroundColour());
921
922 // inheriting (solid) background colour is wrong as it totally breaks
923 // any kind of themed backgrounds
924 //
925 // instead, the controls should use the same background as their parent
926 // (ideally by not drawing it at all)
927#if 0
928 if ( parent->m_inheritBgCol && !m_hasBgCol )
929 SetBackgroundColour(parent->GetBackgroundColour());
930#endif // 0
931 }
932}
933
934/* static */ wxVisualAttributes
935wxWindowBase::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
936{
937 // it is important to return valid values for all attributes from here,
938 // GetXXX() below rely on this
939 wxVisualAttributes attrs;
940 attrs.font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
941 attrs.colFg = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
942
943 // On Smartphone/PocketPC, wxSYS_COLOUR_WINDOW is a better reflection of
944 // the usual background colour than wxSYS_COLOUR_BTNFACE.
945 // It's a pity that wxSYS_COLOUR_WINDOW isn't always a suitable background
946 // colour on other platforms.
947
948#if defined(__WXWINCE__) && (defined(__SMARTPHONE__) || defined(__POCKETPC__))
949 attrs.colBg = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW);
950#else
951 attrs.colBg = wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE);
952#endif
953 return attrs;
954}
955
956wxColour wxWindowBase::GetBackgroundColour() const
957{
958 if ( !m_backgroundColour.Ok() )
959 {
960 wxASSERT_MSG( !m_hasBgCol, _T("we have invalid explicit bg colour?") );
961
962 // get our default background colour
963 wxColour colBg = GetDefaultAttributes().colBg;
964
965 // we must return some valid colour to avoid redoing this every time
966 // and also to avoid surprizing the applications written for older
967 // wxWidgets versions where GetBackgroundColour() always returned
968 // something -- so give them something even if it doesn't make sense
969 // for this window (e.g. it has a themed background)
970 if ( !colBg.Ok() )
971 colBg = GetClassDefaultAttributes().colBg;
972
973 return colBg;
974 }
975 else
976 return m_backgroundColour;
977}
978
979wxColour wxWindowBase::GetForegroundColour() const
980{
981 // logic is the same as above
982 if ( !m_hasFgCol && !m_foregroundColour.Ok() )
983 {
984 wxASSERT_MSG( !m_hasFgCol, _T("we have invalid explicit fg colour?") );
985
986 wxColour colFg = GetDefaultAttributes().colFg;
987
988 if ( !colFg.Ok() )
989 colFg = GetClassDefaultAttributes().colFg;
990
991 return colFg;
992 }
993 else
994 return m_foregroundColour;
995}
996
997bool wxWindowBase::SetBackgroundColour( const wxColour &colour )
998{
999 if ( colour == m_backgroundColour )
1000 return false;
1001
1002 m_hasBgCol = colour.Ok();
1003 if ( m_backgroundStyle != wxBG_STYLE_CUSTOM )
1004 m_backgroundStyle = m_hasBgCol ? wxBG_STYLE_COLOUR : wxBG_STYLE_SYSTEM;
1005
1006 m_inheritBgCol = m_hasBgCol;
1007 m_backgroundColour = colour;
1008 SetThemeEnabled( !m_hasBgCol && !m_foregroundColour.Ok() );
1009 return true;
1010}
1011
1012bool wxWindowBase::SetForegroundColour( const wxColour &colour )
1013{
1014 if (colour == m_foregroundColour )
1015 return false;
1016
1017 m_hasFgCol = colour.Ok();
1018 m_inheritFgCol = m_hasFgCol;
1019 m_foregroundColour = colour;
1020 SetThemeEnabled( !m_hasFgCol && !m_backgroundColour.Ok() );
1021 return true;
1022}
1023
1024bool wxWindowBase::SetCursor(const wxCursor& cursor)
1025{
1026 // setting an invalid cursor is ok, it means that we don't have any special
1027 // cursor
1028 if ( m_cursor == cursor )
1029 {
1030 // no change
1031 return false;
1032 }
1033
1034 m_cursor = cursor;
1035
1036 return true;
1037}
1038
1039wxFont wxWindowBase::GetFont() const
1040{
1041 // logic is the same as in GetBackgroundColour()
1042 if ( !m_font.Ok() )
1043 {
1044 wxASSERT_MSG( !m_hasFont, _T("we have invalid explicit font?") );
1045
1046 wxFont font = GetDefaultAttributes().font;
1047 if ( !font.Ok() )
1048 font = GetClassDefaultAttributes().font;
1049
1050 return font;
1051 }
1052 else
1053 return m_font;
1054}
1055
1056bool wxWindowBase::SetFont(const wxFont& font)
1057{
1058 if ( font == m_font )
1059 {
1060 // no change
1061 return false;
1062 }
1063
1064 m_font = font;
1065 m_hasFont = font.Ok();
1066 m_inheritFont = m_hasFont;
1067
1068 InvalidateBestSize();
1069
1070 return true;
1071}
1072
1073#if wxUSE_PALETTE
1074
1075void wxWindowBase::SetPalette(const wxPalette& pal)
1076{
1077 m_hasCustomPalette = true;
1078 m_palette = pal;
1079
1080 // VZ: can anyone explain me what do we do here?
1081 wxWindowDC d((wxWindow *) this);
1082 d.SetPalette(pal);
1083}
1084
1085wxWindow *wxWindowBase::GetAncestorWithCustomPalette() const
1086{
1087 wxWindow *win = (wxWindow *)this;
1088 while ( win && !win->HasCustomPalette() )
1089 {
1090 win = win->GetParent();
1091 }
1092
1093 return win;
1094}
1095
1096#endif // wxUSE_PALETTE
1097
1098#if wxUSE_CARET
1099void wxWindowBase::SetCaret(wxCaret *caret)
1100{
1101 if ( m_caret )
1102 {
1103 delete m_caret;
1104 }
1105
1106 m_caret = caret;
1107
1108 if ( m_caret )
1109 {
1110 wxASSERT_MSG( m_caret->GetWindow() == this,
1111 wxT("caret should be created associated to this window") );
1112 }
1113}
1114#endif // wxUSE_CARET
1115
1116#if wxUSE_VALIDATORS
1117// ----------------------------------------------------------------------------
1118// validators
1119// ----------------------------------------------------------------------------
1120
1121void wxWindowBase::SetValidator(const wxValidator& validator)
1122{
1123 if ( m_windowValidator )
1124 delete m_windowValidator;
1125
1126 m_windowValidator = (wxValidator *)validator.Clone();
1127
1128 if ( m_windowValidator )
1129 m_windowValidator->SetWindow(this);
1130}
1131#endif // wxUSE_VALIDATORS
1132
1133// ----------------------------------------------------------------------------
1134// update region stuff
1135// ----------------------------------------------------------------------------
1136
1137wxRect wxWindowBase::GetUpdateClientRect() const
1138{
1139 wxRegion rgnUpdate = GetUpdateRegion();
1140 rgnUpdate.Intersect(GetClientRect());
1141 wxRect rectUpdate = rgnUpdate.GetBox();
1142 wxPoint ptOrigin = GetClientAreaOrigin();
1143 rectUpdate.x -= ptOrigin.x;
1144 rectUpdate.y -= ptOrigin.y;
1145
1146 return rectUpdate;
1147}
1148
1149bool wxWindowBase::IsExposed(int x, int y) const
1150{
1151 return m_updateRegion.Contains(x, y) != wxOutRegion;
1152}
1153
1154bool wxWindowBase::IsExposed(int x, int y, int w, int h) const
1155{
1156 return m_updateRegion.Contains(x, y, w, h) != wxOutRegion;
1157}
1158
1159void wxWindowBase::ClearBackground()
1160{
1161 // wxGTK uses its own version, no need to add never used code
1162#ifndef __WXGTK__
1163 wxClientDC dc((wxWindow *)this);
1164 wxBrush brush(GetBackgroundColour(), wxSOLID);
1165 dc.SetBackground(brush);
1166 dc.Clear();
1167#endif // __WXGTK__
1168}
1169
1170// ----------------------------------------------------------------------------
1171// find child window by id or name
1172// ----------------------------------------------------------------------------
1173
1174wxWindow *wxWindowBase::FindWindow(long id) const
1175{
1176 if ( id == m_windowId )
1177 return (wxWindow *)this;
1178
1179 wxWindowBase *res = (wxWindow *)NULL;
1180 wxWindowList::compatibility_iterator node;
1181 for ( node = m_children.GetFirst(); node && !res; node = node->GetNext() )
1182 {
1183 wxWindowBase *child = node->GetData();
1184 res = child->FindWindow( id );
1185 }
1186
1187 return (wxWindow *)res;
1188}
1189
1190wxWindow *wxWindowBase::FindWindow(const wxString& name) const
1191{
1192 if ( name == m_windowName )
1193 return (wxWindow *)this;
1194
1195 wxWindowBase *res = (wxWindow *)NULL;
1196 wxWindowList::compatibility_iterator node;
1197 for ( node = m_children.GetFirst(); node && !res; node = node->GetNext() )
1198 {
1199 wxWindow *child = node->GetData();
1200 res = child->FindWindow(name);
1201 }
1202
1203 return (wxWindow *)res;
1204}
1205
1206
1207// find any window by id or name or label: If parent is non-NULL, look through
1208// children for a label or title matching the specified string. If NULL, look
1209// through all top-level windows.
1210//
1211// to avoid duplicating code we reuse the same helper function but with
1212// different comparators
1213
1214typedef bool (*wxFindWindowCmp)(const wxWindow *win,
1215 const wxString& label, long id);
1216
1217static
1218bool wxFindWindowCmpLabels(const wxWindow *win, const wxString& label,
1219 long WXUNUSED(id))
1220{
1221 return win->GetLabel() == label;
1222}
1223
1224static
1225bool wxFindWindowCmpNames(const wxWindow *win, const wxString& label,
1226 long WXUNUSED(id))
1227{
1228 return win->GetName() == label;
1229}
1230
1231static
1232bool wxFindWindowCmpIds(const wxWindow *win, const wxString& WXUNUSED(label),
1233 long id)
1234{
1235 return win->GetId() == id;
1236}
1237
1238// recursive helper for the FindWindowByXXX() functions
1239static
1240wxWindow *wxFindWindowRecursively(const wxWindow *parent,
1241 const wxString& label,
1242 long id,
1243 wxFindWindowCmp cmp)
1244{
1245 if ( parent )
1246 {
1247 // see if this is the one we're looking for
1248 if ( (*cmp)(parent, label, id) )
1249 return (wxWindow *)parent;
1250
1251 // It wasn't, so check all its children
1252 for ( wxWindowList::compatibility_iterator node = parent->GetChildren().GetFirst();
1253 node;
1254 node = node->GetNext() )
1255 {
1256 // recursively check each child
1257 wxWindow *win = (wxWindow *)node->GetData();
1258 wxWindow *retwin = wxFindWindowRecursively(win, label, id, cmp);
1259 if (retwin)
1260 return retwin;
1261 }
1262 }
1263
1264 // Not found
1265 return NULL;
1266}
1267
1268// helper for FindWindowByXXX()
1269static
1270wxWindow *wxFindWindowHelper(const wxWindow *parent,
1271 const wxString& label,
1272 long id,
1273 wxFindWindowCmp cmp)
1274{
1275 if ( parent )
1276 {
1277 // just check parent and all its children
1278 return wxFindWindowRecursively(parent, label, id, cmp);
1279 }
1280
1281 // start at very top of wx's windows
1282 for ( wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetFirst();
1283 node;
1284 node = node->GetNext() )
1285 {
1286 // recursively check each window & its children
1287 wxWindow *win = node->GetData();
1288 wxWindow *retwin = wxFindWindowRecursively(win, label, id, cmp);
1289 if (retwin)
1290 return retwin;
1291 }
1292
1293 return NULL;
1294}
1295
1296/* static */
1297wxWindow *
1298wxWindowBase::FindWindowByLabel(const wxString& title, const wxWindow *parent)
1299{
1300 return wxFindWindowHelper(parent, title, 0, wxFindWindowCmpLabels);
1301}
1302
1303/* static */
1304wxWindow *
1305wxWindowBase::FindWindowByName(const wxString& title, const wxWindow *parent)
1306{
1307 wxWindow *win = wxFindWindowHelper(parent, title, 0, wxFindWindowCmpNames);
1308
1309 if ( !win )
1310 {
1311 // fall back to the label
1312 win = FindWindowByLabel(title, parent);
1313 }
1314
1315 return win;
1316}
1317
1318/* static */
1319wxWindow *
1320wxWindowBase::FindWindowById( long id, const wxWindow* parent )
1321{
1322 return wxFindWindowHelper(parent, wxEmptyString, id, wxFindWindowCmpIds);
1323}
1324
1325// ----------------------------------------------------------------------------
1326// dialog oriented functions
1327// ----------------------------------------------------------------------------
1328
1329void wxWindowBase::MakeModal(bool modal)
1330{
1331 // Disable all other windows
1332 if ( IsTopLevel() )
1333 {
1334 wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetFirst();
1335 while (node)
1336 {
1337 wxWindow *win = node->GetData();
1338 if (win != this)
1339 win->Enable(!modal);
1340
1341 node = node->GetNext();
1342 }
1343 }
1344}
1345
1346bool wxWindowBase::Validate()
1347{
1348#if wxUSE_VALIDATORS
1349 bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0;
1350
1351 wxWindowList::compatibility_iterator node;
1352 for ( node = m_children.GetFirst(); node; node = node->GetNext() )
1353 {
1354 wxWindowBase *child = node->GetData();
1355 wxValidator *validator = child->GetValidator();
1356 if ( validator && !validator->Validate((wxWindow *)this) )
1357 {
1358 return false;
1359 }
1360
1361 if ( recurse && !child->Validate() )
1362 {
1363 return false;
1364 }
1365 }
1366#endif // wxUSE_VALIDATORS
1367
1368 return true;
1369}
1370
1371bool wxWindowBase::TransferDataToWindow()
1372{
1373#if wxUSE_VALIDATORS
1374 bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0;
1375
1376 wxWindowList::compatibility_iterator node;
1377 for ( node = m_children.GetFirst(); node; node = node->GetNext() )
1378 {
1379 wxWindowBase *child = node->GetData();
1380 wxValidator *validator = child->GetValidator();
1381 if ( validator && !validator->TransferToWindow() )
1382 {
1383 wxLogWarning(_("Could not transfer data to window"));
1384#if wxUSE_LOG
1385 wxLog::FlushActive();
1386#endif // wxUSE_LOG
1387
1388 return false;
1389 }
1390
1391 if ( recurse )
1392 {
1393 if ( !child->TransferDataToWindow() )
1394 {
1395 // warning already given
1396 return false;
1397 }
1398 }
1399 }
1400#endif // wxUSE_VALIDATORS
1401
1402 return true;
1403}
1404
1405bool wxWindowBase::TransferDataFromWindow()
1406{
1407#if wxUSE_VALIDATORS
1408 bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0;
1409
1410 wxWindowList::compatibility_iterator node;
1411 for ( node = m_children.GetFirst(); node; node = node->GetNext() )
1412 {
1413 wxWindow *child = node->GetData();
1414 wxValidator *validator = child->GetValidator();
1415 if ( validator && !validator->TransferFromWindow() )
1416 {
1417 // nop warning here because the application is supposed to give
1418 // one itself - we don't know here what might have gone wrongly
1419
1420 return false;
1421 }
1422
1423 if ( recurse )
1424 {
1425 if ( !child->TransferDataFromWindow() )
1426 {
1427 // warning already given
1428 return false;
1429 }
1430 }
1431 }
1432#endif // wxUSE_VALIDATORS
1433
1434 return true;
1435}
1436
1437void wxWindowBase::InitDialog()
1438{
1439 wxInitDialogEvent event(GetId());
1440 event.SetEventObject( this );
1441 GetEventHandler()->ProcessEvent(event);
1442}
1443
1444// ----------------------------------------------------------------------------
1445// context-sensitive help support
1446// ----------------------------------------------------------------------------
1447
1448#if wxUSE_HELP
1449
1450// associate this help text with this window
1451void wxWindowBase::SetHelpText(const wxString& text)
1452{
1453 wxHelpProvider *helpProvider = wxHelpProvider::Get();
1454 if ( helpProvider )
1455 {
1456 helpProvider->AddHelp(this, text);
1457 }
1458}
1459
1460// associate this help text with all windows with the same id as this
1461// one
1462void wxWindowBase::SetHelpTextForId(const wxString& text)
1463{
1464 wxHelpProvider *helpProvider = wxHelpProvider::Get();
1465 if ( helpProvider )
1466 {
1467 helpProvider->AddHelp(GetId(), text);
1468 }
1469}
1470
1471// get the help string associated with this window (may be empty)
1472// default implementation forwards calls to the help provider
1473wxString
1474wxWindowBase::GetHelpTextAtPoint(const wxPoint & WXUNUSED(pt),
1475 wxHelpEvent::Origin WXUNUSED(origin)) const
1476{
1477 wxString text;
1478 wxHelpProvider *helpProvider = wxHelpProvider::Get();
1479 if ( helpProvider )
1480 {
1481 text = helpProvider->GetHelp(this);
1482 }
1483
1484 return text;
1485}
1486
1487// show help for this window
1488void wxWindowBase::OnHelp(wxHelpEvent& event)
1489{
1490 wxHelpProvider *helpProvider = wxHelpProvider::Get();
1491 if ( helpProvider )
1492 {
1493 if ( helpProvider->ShowHelpAtPoint(this, event.GetPosition(), event.GetOrigin()) )
1494 {
1495 // skip the event.Skip() below
1496 return;
1497 }
1498 }
1499
1500 event.Skip();
1501}
1502
1503#endif // wxUSE_HELP
1504
1505// ----------------------------------------------------------------------------
1506// tooltipsroot.Replace("\\", "/");
1507// ----------------------------------------------------------------------------
1508
1509#if wxUSE_TOOLTIPS
1510
1511void wxWindowBase::SetToolTip( const wxString &tip )
1512{
1513 // don't create the new tooltip if we already have one
1514 if ( m_tooltip )
1515 {
1516 m_tooltip->SetTip( tip );
1517 }
1518 else
1519 {
1520 SetToolTip( new wxToolTip( tip ) );
1521 }
1522
1523 // setting empty tooltip text does not remove the tooltip any more - use
1524 // SetToolTip((wxToolTip *)NULL) for this
1525}
1526
1527void wxWindowBase::DoSetToolTip(wxToolTip *tooltip)
1528{
1529 if ( m_tooltip != tooltip )
1530 {
1531 if ( m_tooltip )
1532 delete m_tooltip;
1533
1534 m_tooltip = tooltip;
1535 }
1536}
1537
1538#endif // wxUSE_TOOLTIPS
1539
1540// ----------------------------------------------------------------------------
1541// constraints and sizers
1542// ----------------------------------------------------------------------------
1543
1544#if wxUSE_CONSTRAINTS
1545
1546void wxWindowBase::SetConstraints( wxLayoutConstraints *constraints )
1547{
1548 if ( m_constraints )
1549 {
1550 UnsetConstraints(m_constraints);
1551 delete m_constraints;
1552 }
1553 m_constraints = constraints;
1554 if ( m_constraints )
1555 {
1556 // Make sure other windows know they're part of a 'meaningful relationship'
1557 if ( m_constraints->left.GetOtherWindow() && (m_constraints->left.GetOtherWindow() != this) )
1558 m_constraints->left.GetOtherWindow()->AddConstraintReference(this);
1559 if ( m_constraints->top.GetOtherWindow() && (m_constraints->top.GetOtherWindow() != this) )
1560 m_constraints->top.GetOtherWindow()->AddConstraintReference(this);
1561 if ( m_constraints->right.GetOtherWindow() && (m_constraints->right.GetOtherWindow() != this) )
1562 m_constraints->right.GetOtherWindow()->AddConstraintReference(this);
1563 if ( m_constraints->bottom.GetOtherWindow() && (m_constraints->bottom.GetOtherWindow() != this) )
1564 m_constraints->bottom.GetOtherWindow()->AddConstraintReference(this);
1565 if ( m_constraints->width.GetOtherWindow() && (m_constraints->width.GetOtherWindow() != this) )
1566 m_constraints->width.GetOtherWindow()->AddConstraintReference(this);
1567 if ( m_constraints->height.GetOtherWindow() && (m_constraints->height.GetOtherWindow() != this) )
1568 m_constraints->height.GetOtherWindow()->AddConstraintReference(this);
1569 if ( m_constraints->centreX.GetOtherWindow() && (m_constraints->centreX.GetOtherWindow() != this) )
1570 m_constraints->centreX.GetOtherWindow()->AddConstraintReference(this);
1571 if ( m_constraints->centreY.GetOtherWindow() && (m_constraints->centreY.GetOtherWindow() != this) )
1572 m_constraints->centreY.GetOtherWindow()->AddConstraintReference(this);
1573 }
1574}
1575
1576// This removes any dangling pointers to this window in other windows'
1577// constraintsInvolvedIn lists.
1578void wxWindowBase::UnsetConstraints(wxLayoutConstraints *c)
1579{
1580 if ( c )
1581 {
1582 if ( c->left.GetOtherWindow() && (c->top.GetOtherWindow() != this) )
1583 c->left.GetOtherWindow()->RemoveConstraintReference(this);
1584 if ( c->top.GetOtherWindow() && (c->top.GetOtherWindow() != this) )
1585 c->top.GetOtherWindow()->RemoveConstraintReference(this);
1586 if ( c->right.GetOtherWindow() && (c->right.GetOtherWindow() != this) )
1587 c->right.GetOtherWindow()->RemoveConstraintReference(this);
1588 if ( c->bottom.GetOtherWindow() && (c->bottom.GetOtherWindow() != this) )
1589 c->bottom.GetOtherWindow()->RemoveConstraintReference(this);
1590 if ( c->width.GetOtherWindow() && (c->width.GetOtherWindow() != this) )
1591 c->width.GetOtherWindow()->RemoveConstraintReference(this);
1592 if ( c->height.GetOtherWindow() && (c->height.GetOtherWindow() != this) )
1593 c->height.GetOtherWindow()->RemoveConstraintReference(this);
1594 if ( c->centreX.GetOtherWindow() && (c->centreX.GetOtherWindow() != this) )
1595 c->centreX.GetOtherWindow()->RemoveConstraintReference(this);
1596 if ( c->centreY.GetOtherWindow() && (c->centreY.GetOtherWindow() != this) )
1597 c->centreY.GetOtherWindow()->RemoveConstraintReference(this);
1598 }
1599}
1600
1601// Back-pointer to other windows we're involved with, so if we delete this
1602// window, we must delete any constraints we're involved with.
1603void wxWindowBase::AddConstraintReference(wxWindowBase *otherWin)
1604{
1605 if ( !m_constraintsInvolvedIn )
1606 m_constraintsInvolvedIn = new wxWindowList;
1607 if ( !m_constraintsInvolvedIn->Find((wxWindow *)otherWin) )
1608 m_constraintsInvolvedIn->Append((wxWindow *)otherWin);
1609}
1610
1611// REMOVE back-pointer to other windows we're involved with.
1612void wxWindowBase::RemoveConstraintReference(wxWindowBase *otherWin)
1613{
1614 if ( m_constraintsInvolvedIn )
1615 m_constraintsInvolvedIn->DeleteObject((wxWindow *)otherWin);
1616}
1617
1618// Reset any constraints that mention this window
1619void wxWindowBase::DeleteRelatedConstraints()
1620{
1621 if ( m_constraintsInvolvedIn )
1622 {
1623 wxWindowList::compatibility_iterator node = m_constraintsInvolvedIn->GetFirst();
1624 while (node)
1625 {
1626 wxWindow *win = node->GetData();
1627 wxLayoutConstraints *constr = win->GetConstraints();
1628
1629 // Reset any constraints involving this window
1630 if ( constr )
1631 {
1632 constr->left.ResetIfWin(this);
1633 constr->top.ResetIfWin(this);
1634 constr->right.ResetIfWin(this);
1635 constr->bottom.ResetIfWin(this);
1636 constr->width.ResetIfWin(this);
1637 constr->height.ResetIfWin(this);
1638 constr->centreX.ResetIfWin(this);
1639 constr->centreY.ResetIfWin(this);
1640 }
1641
1642 wxWindowList::compatibility_iterator next = node->GetNext();
1643 m_constraintsInvolvedIn->Erase(node);
1644 node = next;
1645 }
1646
1647 delete m_constraintsInvolvedIn;
1648 m_constraintsInvolvedIn = (wxWindowList *) NULL;
1649 }
1650}
1651
1652#endif // wxUSE_CONSTRAINTS
1653
1654void wxWindowBase::SetSizer(wxSizer *sizer, bool deleteOld)
1655{
1656 if ( sizer == m_windowSizer)
1657 return;
1658
1659 if ( deleteOld )
1660 delete m_windowSizer;
1661
1662 m_windowSizer = sizer;
1663
1664 SetAutoLayout( sizer != NULL );
1665}
1666
1667void wxWindowBase::SetSizerAndFit(wxSizer *sizer, bool deleteOld)
1668{
1669 SetSizer( sizer, deleteOld );
1670 sizer->SetSizeHints( (wxWindow*) this );
1671}
1672
1673
1674void wxWindowBase::SetContainingSizer(wxSizer* sizer)
1675{
1676 // adding a window to a sizer twice is going to result in fatal and
1677 // hard to debug problems later because when deleting the second
1678 // associated wxSizerItem we're going to dereference a dangling
1679 // pointer; so try to detect this as early as possible
1680 wxASSERT_MSG( !sizer || m_containingSizer != sizer,
1681 _T("Adding a window to the same sizer twice?") );
1682
1683 m_containingSizer = sizer;
1684}
1685
1686#if wxUSE_CONSTRAINTS
1687
1688void wxWindowBase::SatisfyConstraints()
1689{
1690 wxLayoutConstraints *constr = GetConstraints();
1691 bool wasOk = constr && constr->AreSatisfied();
1692
1693 ResetConstraints(); // Mark all constraints as unevaluated
1694
1695 int noChanges = 1;
1696
1697 // if we're a top level panel (i.e. our parent is frame/dialog), our
1698 // own constraints will never be satisfied any more unless we do it
1699 // here
1700 if ( wasOk )
1701 {
1702 while ( noChanges > 0 )
1703 {
1704 LayoutPhase1(&noChanges);
1705 }
1706 }
1707
1708 LayoutPhase2(&noChanges);
1709}
1710
1711#endif // wxUSE_CONSTRAINTS
1712
1713bool wxWindowBase::Layout()
1714{
1715 // If there is a sizer, use it instead of the constraints
1716 if ( GetSizer() )
1717 {
1718 int w = 0, h = 0;
1719 GetVirtualSize(&w, &h);
1720 GetSizer()->SetDimension( 0, 0, w, h );
1721 }
1722#if wxUSE_CONSTRAINTS
1723 else
1724 {
1725 SatisfyConstraints(); // Find the right constraints values
1726 SetConstraintSizes(); // Recursively set the real window sizes
1727 }
1728#endif
1729
1730 return true;
1731}
1732
1733#if wxUSE_CONSTRAINTS
1734
1735// first phase of the constraints evaluation: set our own constraints
1736bool wxWindowBase::LayoutPhase1(int *noChanges)
1737{
1738 wxLayoutConstraints *constr = GetConstraints();
1739
1740 return !constr || constr->SatisfyConstraints(this, noChanges);
1741}
1742
1743// second phase: set the constraints for our children
1744bool wxWindowBase::LayoutPhase2(int *noChanges)
1745{
1746 *noChanges = 0;
1747
1748 // Layout children
1749 DoPhase(1);
1750
1751 // Layout grand children
1752 DoPhase(2);
1753
1754 return true;
1755}
1756
1757// Do a phase of evaluating child constraints
1758bool wxWindowBase::DoPhase(int phase)
1759{
1760 // the list containing the children for which the constraints are already
1761 // set correctly
1762 wxWindowList succeeded;
1763
1764 // the max number of iterations we loop before concluding that we can't set
1765 // the constraints
1766 static const int maxIterations = 500;
1767
1768 for ( int noIterations = 0; noIterations < maxIterations; noIterations++ )
1769 {
1770 int noChanges = 0;
1771
1772 // loop over all children setting their constraints
1773 for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
1774 node;
1775 node = node->GetNext() )
1776 {
1777 wxWindow *child = node->GetData();
1778 if ( child->IsTopLevel() )
1779 {
1780 // top level children are not inside our client area
1781 continue;
1782 }
1783
1784 if ( !child->GetConstraints() || succeeded.Find(child) )
1785 {
1786 // this one is either already ok or nothing we can do about it
1787 continue;
1788 }
1789
1790 int tempNoChanges = 0;
1791 bool success = phase == 1 ? child->LayoutPhase1(&tempNoChanges)
1792 : child->LayoutPhase2(&tempNoChanges);
1793 noChanges += tempNoChanges;
1794
1795 if ( success )
1796 {
1797 succeeded.Append(child);
1798 }
1799 }
1800
1801 if ( !noChanges )
1802 {
1803 // constraints are set
1804 break;
1805 }
1806 }
1807
1808 return true;
1809}
1810
1811void wxWindowBase::ResetConstraints()
1812{
1813 wxLayoutConstraints *constr = GetConstraints();
1814 if ( constr )
1815 {
1816 constr->left.SetDone(false);
1817 constr->top.SetDone(false);
1818 constr->right.SetDone(false);
1819 constr->bottom.SetDone(false);
1820 constr->width.SetDone(false);
1821 constr->height.SetDone(false);
1822 constr->centreX.SetDone(false);
1823 constr->centreY.SetDone(false);
1824 }
1825
1826 wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
1827 while (node)
1828 {
1829 wxWindow *win = node->GetData();
1830 if ( !win->IsTopLevel() )
1831 win->ResetConstraints();
1832 node = node->GetNext();
1833 }
1834}
1835
1836// Need to distinguish between setting the 'fake' size for windows and sizers,
1837// and setting the real values.
1838void wxWindowBase::SetConstraintSizes(bool recurse)
1839{
1840 wxLayoutConstraints *constr = GetConstraints();
1841 if ( constr && constr->AreSatisfied() )
1842 {
1843 int x = constr->left.GetValue();
1844 int y = constr->top.GetValue();
1845 int w = constr->width.GetValue();
1846 int h = constr->height.GetValue();
1847
1848 if ( (constr->width.GetRelationship() != wxAsIs ) ||
1849 (constr->height.GetRelationship() != wxAsIs) )
1850 {
1851 SetSize(x, y, w, h);
1852 }
1853 else
1854 {
1855 // If we don't want to resize this window, just move it...
1856 Move(x, y);
1857 }
1858 }
1859 else if ( constr )
1860 {
1861 wxLogDebug(wxT("Constraints not satisfied for %s named '%s'."),
1862 GetClassInfo()->GetClassName(),
1863 GetName().c_str());
1864 }
1865
1866 if ( recurse )
1867 {
1868 wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
1869 while (node)
1870 {
1871 wxWindow *win = node->GetData();
1872 if ( !win->IsTopLevel() && win->GetConstraints() )
1873 win->SetConstraintSizes();
1874 node = node->GetNext();
1875 }
1876 }
1877}
1878
1879// Only set the size/position of the constraint (if any)
1880void wxWindowBase::SetSizeConstraint(int x, int y, int w, int h)
1881{
1882 wxLayoutConstraints *constr = GetConstraints();
1883 if ( constr )
1884 {
1885 if ( x != wxDefaultCoord )
1886 {
1887 constr->left.SetValue(x);
1888 constr->left.SetDone(true);
1889 }
1890 if ( y != wxDefaultCoord )
1891 {
1892 constr->top.SetValue(y);
1893 constr->top.SetDone(true);
1894 }
1895 if ( w != wxDefaultCoord )
1896 {
1897 constr->width.SetValue(w);
1898 constr->width.SetDone(true);
1899 }
1900 if ( h != wxDefaultCoord )
1901 {
1902 constr->height.SetValue(h);
1903 constr->height.SetDone(true);
1904 }
1905 }
1906}
1907
1908void wxWindowBase::MoveConstraint(int x, int y)
1909{
1910 wxLayoutConstraints *constr = GetConstraints();
1911 if ( constr )
1912 {
1913 if ( x != wxDefaultCoord )
1914 {
1915 constr->left.SetValue(x);
1916 constr->left.SetDone(true);
1917 }
1918 if ( y != wxDefaultCoord )
1919 {
1920 constr->top.SetValue(y);
1921 constr->top.SetDone(true);
1922 }
1923 }
1924}
1925
1926void wxWindowBase::GetSizeConstraint(int *w, int *h) const
1927{
1928 wxLayoutConstraints *constr = GetConstraints();
1929 if ( constr )
1930 {
1931 *w = constr->width.GetValue();
1932 *h = constr->height.GetValue();
1933 }
1934 else
1935 GetSize(w, h);
1936}
1937
1938void wxWindowBase::GetClientSizeConstraint(int *w, int *h) const
1939{
1940 wxLayoutConstraints *constr = GetConstraints();
1941 if ( constr )
1942 {
1943 *w = constr->width.GetValue();
1944 *h = constr->height.GetValue();
1945 }
1946 else
1947 GetClientSize(w, h);
1948}
1949
1950void wxWindowBase::GetPositionConstraint(int *x, int *y) const
1951{
1952 wxLayoutConstraints *constr = GetConstraints();
1953 if ( constr )
1954 {
1955 *x = constr->left.GetValue();
1956 *y = constr->top.GetValue();
1957 }
1958 else
1959 GetPosition(x, y);
1960}
1961
1962#endif // wxUSE_CONSTRAINTS
1963
1964void wxWindowBase::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags) const
1965{
1966 // don't do it for the dialogs/frames - they float independently of their
1967 // parent
1968 if ( !IsTopLevel() )
1969 {
1970 wxWindow *parent = GetParent();
1971 if ( !(sizeFlags & wxSIZE_NO_ADJUSTMENTS) && parent )
1972 {
1973 wxPoint pt(parent->GetClientAreaOrigin());
1974 x += pt.x;
1975 y += pt.y;
1976 }
1977 }
1978}
1979
1980// ----------------------------------------------------------------------------
1981// do Update UI processing for child controls
1982// ----------------------------------------------------------------------------
1983
1984void wxWindowBase::UpdateWindowUI(long flags)
1985{
1986 wxUpdateUIEvent event(GetId());
1987 event.SetEventObject(this);
1988
1989 if ( GetEventHandler()->ProcessEvent(event) )
1990 {
1991 DoUpdateWindowUI(event);
1992 }
1993
1994 if (flags & wxUPDATE_UI_RECURSE)
1995 {
1996 wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
1997 while (node)
1998 {
1999 wxWindow* child = (wxWindow*) node->GetData();
2000 child->UpdateWindowUI(flags);
2001 node = node->GetNext();
2002 }
2003 }
2004}
2005
2006// do the window-specific processing after processing the update event
2007void wxWindowBase::DoUpdateWindowUI(wxUpdateUIEvent& event)
2008{
2009 if ( event.GetSetEnabled() )
2010 Enable(event.GetEnabled());
2011
2012 if ( event.GetSetShown() )
2013 Show(event.GetShown());
2014}
2015
2016#if 0
2017// call internal idle recursively
2018// may be obsolete (wait until OnIdle scheme stabilises)
2019void wxWindowBase::ProcessInternalIdle()
2020{
2021 OnInternalIdle();
2022
2023 wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
2024 while (node)
2025 {
2026 wxWindow *child = node->GetData();
2027 child->ProcessInternalIdle();
2028 node = node->GetNext();
2029 }
2030}
2031#endif
2032
2033// ----------------------------------------------------------------------------
2034// dialog units translations
2035// ----------------------------------------------------------------------------
2036
2037wxPoint wxWindowBase::ConvertPixelsToDialog(const wxPoint& pt)
2038{
2039 int charWidth = GetCharWidth();
2040 int charHeight = GetCharHeight();
2041 wxPoint pt2 = wxDefaultPosition;
2042 if (pt.x != wxDefaultCoord)
2043 pt2.x = (int) ((pt.x * 4) / charWidth);
2044 if (pt.y != wxDefaultCoord)
2045 pt2.y = (int) ((pt.y * 8) / charHeight);
2046
2047 return pt2;
2048}
2049
2050wxPoint wxWindowBase::ConvertDialogToPixels(const wxPoint& pt)
2051{
2052 int charWidth = GetCharWidth();
2053 int charHeight = GetCharHeight();
2054 wxPoint pt2 = wxDefaultPosition;
2055 if (pt.x != wxDefaultCoord)
2056 pt2.x = (int) ((pt.x * charWidth) / 4);
2057 if (pt.y != wxDefaultCoord)
2058 pt2.y = (int) ((pt.y * charHeight) / 8);
2059
2060 return pt2;
2061}
2062
2063// ----------------------------------------------------------------------------
2064// event handlers
2065// ----------------------------------------------------------------------------
2066
2067// propagate the colour change event to the subwindows
2068void wxWindowBase::OnSysColourChanged(wxSysColourChangedEvent& event)
2069{
2070 wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
2071 while ( node )
2072 {
2073 // Only propagate to non-top-level windows
2074 wxWindow *win = node->GetData();
2075 if ( !win->IsTopLevel() )
2076 {
2077 wxSysColourChangedEvent event2;
2078 event.SetEventObject(win);
2079 win->GetEventHandler()->ProcessEvent(event2);
2080 }
2081
2082 node = node->GetNext();
2083 }
2084
2085 Refresh();
2086}
2087
2088// the default action is to populate dialog with data when it's created,
2089// and nudge the UI into displaying itself correctly in case
2090// we've turned the wxUpdateUIEvents frequency down low.
2091void wxWindowBase::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) )
2092{
2093 TransferDataToWindow();
2094
2095 // Update the UI at this point
2096 UpdateWindowUI(wxUPDATE_UI_RECURSE);
2097}
2098
2099// methods for drawing the sizers in a visible way
2100#ifdef __WXDEBUG__
2101
2102static void DrawSizers(wxWindowBase *win);
2103
2104static void DrawBorder(wxWindowBase *win, const wxRect& rect, bool fill = false)
2105{
2106 wxClientDC dc((wxWindow *)win);
2107 dc.SetPen(*wxRED_PEN);
2108 dc.SetBrush(fill ? wxBrush(*wxRED, wxCROSSDIAG_HATCH): *wxTRANSPARENT_BRUSH);
2109 dc.DrawRectangle(rect.Deflate(1, 1));
2110}
2111
2112static void DrawSizer(wxWindowBase *win, wxSizer *sizer)
2113{
2114 const wxSizerItemList& items = sizer->GetChildren();
2115 for ( wxSizerItemList::const_iterator i = items.begin(),
2116 end = items.end();
2117 i != end;
2118 ++i )
2119 {
2120 wxSizerItem *item = *i;
2121 if ( item->IsSizer() )
2122 {
2123 DrawBorder(win, item->GetRect().Deflate(2));
2124 DrawSizer(win, item->GetSizer());
2125 }
2126 else if ( item->IsSpacer() )
2127 {
2128 DrawBorder(win, item->GetRect().Deflate(2), true);
2129 }
2130 else if ( item->IsWindow() )
2131 {
2132 DrawSizers(item->GetWindow());
2133 }
2134 }
2135}
2136
2137static void DrawSizers(wxWindowBase *win)
2138{
2139 wxSizer *sizer = win->GetSizer();
2140 if ( sizer )
2141 {
2142 DrawBorder(win, win->GetClientSize());
2143 DrawSizer(win, sizer);
2144 }
2145 else // no sizer, still recurse into the children
2146 {
2147 const wxWindowList& children = win->GetChildren();
2148 for ( wxWindowList::const_iterator i = children.begin(),
2149 end = children.end();
2150 i != end;
2151 ++i )
2152 {
2153 DrawSizers(*i);
2154 }
2155 }
2156}
2157
2158#endif // __WXDEBUG__
2159
2160// process special middle clicks
2161void wxWindowBase::OnMiddleClick( wxMouseEvent& event )
2162{
2163 if ( event.ControlDown() && event.AltDown() )
2164 {
2165#ifdef __WXDEBUG__
2166 // Ctrl-Alt-Shift-mclick makes the sizers visible in debug builds
2167 if ( event.ShiftDown() )
2168 {
2169 DrawSizers(this);
2170 return;
2171 }
2172#endif // __WXDEBUG__
2173
2174#if wxUSE_MSGDLG
2175 // don't translate these strings
2176 wxString port;
2177
2178#ifdef __WXUNIVERSAL__
2179 port = _T("Univ/");
2180#endif // __WXUNIVERSAL__
2181
2182 switch ( wxGetOsVersion() )
2183 {
2184 case wxMOTIF_X: port += _T("Motif"); break;
2185 case wxMAC:
2186 case wxMAC_DARWIN: port += _T("Mac"); break;
2187 case wxBEOS: port += _T("BeOS"); break;
2188 case wxGTK:
2189 case wxGTK_WIN32:
2190 case wxGTK_OS2:
2191 case wxGTK_BEOS: port += _T("GTK"); break;
2192 case wxWINDOWS:
2193 case wxPENWINDOWS:
2194 case wxWINDOWS_NT:
2195 case wxWIN32S:
2196 case wxWIN95:
2197 case wxWIN386: port += _T("MS Windows"); break;
2198 case wxMGL_UNIX:
2199 case wxMGL_X:
2200 case wxMGL_WIN32:
2201 case wxMGL_OS2: port += _T("MGL"); break;
2202 case wxWINDOWS_OS2:
2203 case wxOS2_PM: port += _T("OS/2"); break;
2204 case wxPALMOS: port += _T("Palm OS"); break;
2205 case wxWINDOWS_CE: port += _T("Windows CE (generic)"); break;
2206 case wxWINDOWS_POCKETPC: port += _T("Windows CE PocketPC"); break;
2207 case wxWINDOWS_SMARTPHONE: port += _T("Windows CE Smartphone"); break;
2208 default: port += _T("unknown"); break;
2209 }
2210
2211 wxMessageBox(wxString::Format(
2212 _T(
2213 " wxWidgets Library (%s port)\nVersion %d.%d.%d%s%s, compiled at %s %s%s\n Copyright (c) 1995-2006 wxWidgets team"
2214 ),
2215 port.c_str(),
2216 wxMAJOR_VERSION,
2217 wxMINOR_VERSION,
2218 wxRELEASE_NUMBER,
2219#if wxUSE_UNICODE
2220 L" (Unicode)",
2221#else
2222 "",
2223#endif
2224#ifdef __WXDEBUG__
2225 _T(" Debug build"),
2226#else
2227 wxEmptyString,
2228#endif
2229 __TDATE__,
2230 __TTIME__,
2231#ifdef __WXGTK__
2232 wxString::Format(_T("\nagainst GTK+ %d.%d.%d. Runtime GTK+ version: %d.%d.%d"), GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION, gtk_major_version, gtk_minor_version, gtk_micro_version).c_str()
2233#else
2234 ""
2235#endif
2236 ),
2237 _T("wxWidgets information"),
2238 wxICON_INFORMATION | wxOK,
2239 (wxWindow *)this);
2240 }
2241 else
2242#endif // wxUSE_MSGDLG
2243 {
2244 event.Skip();
2245 }
2246}
2247
2248// ----------------------------------------------------------------------------
2249// accessibility
2250// ----------------------------------------------------------------------------
2251
2252#if wxUSE_ACCESSIBILITY
2253void wxWindowBase::SetAccessible(wxAccessible* accessible)
2254{
2255 if (m_accessible && (accessible != m_accessible))
2256 delete m_accessible;
2257 m_accessible = accessible;
2258 if (m_accessible)
2259 m_accessible->SetWindow((wxWindow*) this);
2260}
2261
2262// Returns the accessible object, creating if necessary.
2263wxAccessible* wxWindowBase::GetOrCreateAccessible()
2264{
2265 if (!m_accessible)
2266 m_accessible = CreateAccessible();
2267 return m_accessible;
2268}
2269
2270// Override to create a specific accessible object.
2271wxAccessible* wxWindowBase::CreateAccessible()
2272{
2273 return new wxWindowAccessible((wxWindow*) this);
2274}
2275
2276#endif
2277
2278// ----------------------------------------------------------------------------
2279// list classes implementation
2280// ----------------------------------------------------------------------------
2281
2282#if wxUSE_STL
2283
2284#include "wx/listimpl.cpp"
2285WX_DEFINE_LIST(wxWindowList)
2286
2287#else
2288
2289void wxWindowListNode::DeleteData()
2290{
2291 delete (wxWindow *)GetData();
2292}
2293
2294#endif
2295
2296// ----------------------------------------------------------------------------
2297// borders
2298// ----------------------------------------------------------------------------
2299
2300wxBorder wxWindowBase::GetBorder(long flags) const
2301{
2302 wxBorder border = (wxBorder)(flags & wxBORDER_MASK);
2303 if ( border == wxBORDER_DEFAULT )
2304 {
2305 border = GetDefaultBorder();
2306 }
2307
2308 return border;
2309}
2310
2311wxBorder wxWindowBase::GetDefaultBorder() const
2312{
2313 return wxBORDER_NONE;
2314}
2315
2316// ----------------------------------------------------------------------------
2317// hit testing
2318// ----------------------------------------------------------------------------
2319
2320wxHitTest wxWindowBase::DoHitTest(wxCoord x, wxCoord y) const
2321{
2322 // here we just check if the point is inside the window or not
2323
2324 // check the top and left border first
2325 bool outside = x < 0 || y < 0;
2326 if ( !outside )
2327 {
2328 // check the right and bottom borders too
2329 wxSize size = GetSize();
2330 outside = x >= size.x || y >= size.y;
2331 }
2332
2333 return outside ? wxHT_WINDOW_OUTSIDE : wxHT_WINDOW_INSIDE;
2334}
2335
2336// ----------------------------------------------------------------------------
2337// mouse capture
2338// ----------------------------------------------------------------------------
2339
2340struct WXDLLEXPORT wxWindowNext
2341{
2342 wxWindow *win;
2343 wxWindowNext *next;
2344} *wxWindowBase::ms_winCaptureNext = NULL;
2345
2346void wxWindowBase::CaptureMouse()
2347{
2348 wxLogTrace(_T("mousecapture"), _T("CaptureMouse(%p)"), this);
2349
2350 wxWindow *winOld = GetCapture();
2351 if ( winOld )
2352 {
2353 ((wxWindowBase*) winOld)->DoReleaseMouse();
2354
2355 // save it on stack
2356 wxWindowNext *item = new wxWindowNext;
2357 item->win = winOld;
2358 item->next = ms_winCaptureNext;
2359 ms_winCaptureNext = item;
2360 }
2361 //else: no mouse capture to save
2362
2363 DoCaptureMouse();
2364}
2365
2366void wxWindowBase::ReleaseMouse()
2367{
2368 wxLogTrace(_T("mousecapture"), _T("ReleaseMouse(%p)"), this);
2369
2370 wxASSERT_MSG( GetCapture() == this, wxT("attempt to release mouse, but this window hasn't captured it") );
2371
2372 DoReleaseMouse();
2373
2374 if ( ms_winCaptureNext )
2375 {
2376 ((wxWindowBase*)ms_winCaptureNext->win)->DoCaptureMouse();
2377
2378 wxWindowNext *item = ms_winCaptureNext;
2379 ms_winCaptureNext = item->next;
2380 delete item;
2381 }
2382 //else: stack is empty, no previous capture
2383
2384 wxLogTrace(_T("mousecapture"),
2385 (const wxChar *) _T("After ReleaseMouse() mouse is captured by %p"),
2386 GetCapture());
2387}
2388
2389#if wxUSE_HOTKEY
2390
2391bool
2392wxWindowBase::RegisterHotKey(int WXUNUSED(hotkeyId),
2393 int WXUNUSED(modifiers),
2394 int WXUNUSED(keycode))
2395{
2396 // not implemented
2397 return false;
2398}
2399
2400bool wxWindowBase::UnregisterHotKey(int WXUNUSED(hotkeyId))
2401{
2402 // not implemented
2403 return false;
2404}
2405
2406#endif // wxUSE_HOTKEY
2407
2408void wxWindowBase::SendDestroyEvent()
2409{
2410 wxWindowDestroyEvent event;
2411 event.SetEventObject(this);
2412 event.SetId(GetId());
2413 GetEventHandler()->ProcessEvent(event);
2414}
2415
2416// ----------------------------------------------------------------------------
2417// event processing
2418// ----------------------------------------------------------------------------
2419
2420bool wxWindowBase::TryValidator(wxEvent& wxVALIDATOR_PARAM(event))
2421{
2422#if wxUSE_VALIDATORS
2423 // Can only use the validator of the window which
2424 // is receiving the event
2425 if ( event.GetEventObject() == this )
2426 {
2427 wxValidator *validator = GetValidator();
2428 if ( validator && validator->ProcessEvent(event) )
2429 {
2430 return true;
2431 }
2432 }
2433#endif // wxUSE_VALIDATORS
2434
2435 return false;
2436}
2437
2438bool wxWindowBase::TryParent(wxEvent& event)
2439{
2440 // carry on up the parent-child hierarchy if the propagation count hasn't
2441 // reached zero yet
2442 if ( event.ShouldPropagate() )
2443 {
2444 // honour the requests to stop propagation at this window: this is
2445 // used by the dialogs, for example, to prevent processing the events
2446 // from the dialog controls in the parent frame which rarely, if ever,
2447 // makes sense
2448 if ( !(GetExtraStyle() & wxWS_EX_BLOCK_EVENTS) )
2449 {
2450 wxWindow *parent = GetParent();
2451 if ( parent && !parent->IsBeingDeleted() )
2452 {
2453 wxPropagateOnce propagateOnce(event);
2454
2455 return parent->GetEventHandler()->ProcessEvent(event);
2456 }
2457 }
2458 }
2459
2460 return wxEvtHandler::TryParent(event);
2461}
2462
2463// ----------------------------------------------------------------------------
2464// keyboard navigation
2465// ----------------------------------------------------------------------------
2466
2467// Navigates in the specified direction.
2468bool wxWindowBase::Navigate(int flags)
2469{
2470 wxNavigationKeyEvent eventNav;
2471 eventNav.SetFlags(flags);
2472 eventNav.SetEventObject(this);
2473 if ( GetParent()->GetEventHandler()->ProcessEvent(eventNav) )
2474 {
2475 return true;
2476 }
2477 return false;
2478}
2479
2480void wxWindowBase::DoMoveInTabOrder(wxWindow *win, MoveKind move)
2481{
2482 // check that we're not a top level window
2483 wxCHECK_RET( GetParent(),
2484 _T("MoveBefore/AfterInTabOrder() don't work for TLWs!") );
2485
2486 // detect the special case when we have nothing to do anyhow and when the
2487 // code below wouldn't work
2488 if ( win == this )
2489 return;
2490
2491 // find the target window in the siblings list
2492 wxWindowList& siblings = GetParent()->GetChildren();
2493 wxWindowList::compatibility_iterator i = siblings.Find(win);
2494 wxCHECK_RET( i, _T("MoveBefore/AfterInTabOrder(): win is not a sibling") );
2495
2496 // unfortunately, when wxUSE_STL == 1 DetachNode() is not implemented so we
2497 // can't just move the node around
2498 wxWindow *self = (wxWindow *)this;
2499 siblings.DeleteObject(self);
2500 if ( move == MoveAfter )
2501 {
2502 i = i->GetNext();
2503 }
2504
2505 if ( i )
2506 {
2507 siblings.Insert(i, self);
2508 }
2509 else // MoveAfter and win was the last sibling
2510 {
2511 siblings.Append(self);
2512 }
2513}
2514
2515// ----------------------------------------------------------------------------
2516// focus handling
2517// ----------------------------------------------------------------------------
2518
2519/*static*/ wxWindow* wxWindowBase::FindFocus()
2520{
2521 wxWindowBase *win = DoFindFocus();
2522 return win ? win->GetMainWindowOfCompositeControl() : NULL;
2523}
2524
2525// ----------------------------------------------------------------------------
2526// global functions
2527// ----------------------------------------------------------------------------
2528
2529wxWindow* wxGetTopLevelParent(wxWindow *win)
2530{
2531 while ( win && !win->IsTopLevel() )
2532 win = win->GetParent();
2533
2534 return win;
2535}
2536
2537#if wxUSE_ACCESSIBILITY
2538// ----------------------------------------------------------------------------
2539// accessible object for windows
2540// ----------------------------------------------------------------------------
2541
2542// Can return either a child object, or an integer
2543// representing the child element, starting from 1.
2544wxAccStatus wxWindowAccessible::HitTest(const wxPoint& WXUNUSED(pt), int* WXUNUSED(childId), wxAccessible** WXUNUSED(childObject))
2545{
2546 wxASSERT( GetWindow() != NULL );
2547 if (!GetWindow())
2548 return wxACC_FAIL;
2549
2550 return wxACC_NOT_IMPLEMENTED;
2551}
2552
2553// Returns the rectangle for this object (id = 0) or a child element (id > 0).
2554wxAccStatus wxWindowAccessible::GetLocation(wxRect& rect, int elementId)
2555{
2556 wxASSERT( GetWindow() != NULL );
2557 if (!GetWindow())
2558 return wxACC_FAIL;
2559
2560 wxWindow* win = NULL;
2561 if (elementId == 0)
2562 {
2563 win = GetWindow();
2564 }
2565 else
2566 {
2567 if (elementId <= (int) GetWindow()->GetChildren().GetCount())
2568 {
2569 win = GetWindow()->GetChildren().Item(elementId-1)->GetData();
2570 }
2571 else
2572 return wxACC_FAIL;
2573 }
2574 if (win)
2575 {
2576 rect = win->GetRect();
2577 if (win->GetParent() && !win->IsKindOf(CLASSINFO(wxTopLevelWindow)))
2578 rect.SetPosition(win->GetParent()->ClientToScreen(rect.GetPosition()));
2579 return wxACC_OK;
2580 }
2581
2582 return wxACC_NOT_IMPLEMENTED;
2583}
2584
2585// Navigates from fromId to toId/toObject.
2586wxAccStatus wxWindowAccessible::Navigate(wxNavDir navDir, int fromId,
2587 int* WXUNUSED(toId), wxAccessible** toObject)
2588{
2589 wxASSERT( GetWindow() != NULL );
2590 if (!GetWindow())
2591 return wxACC_FAIL;
2592
2593 switch (navDir)
2594 {
2595 case wxNAVDIR_FIRSTCHILD:
2596 {
2597 if (GetWindow()->GetChildren().GetCount() == 0)
2598 return wxACC_FALSE;
2599 wxWindow* childWindow = (wxWindow*) GetWindow()->GetChildren().GetFirst()->GetData();
2600 *toObject = childWindow->GetOrCreateAccessible();
2601
2602 return wxACC_OK;
2603 }
2604 case wxNAVDIR_LASTCHILD:
2605 {
2606 if (GetWindow()->GetChildren().GetCount() == 0)
2607 return wxACC_FALSE;
2608 wxWindow* childWindow = (wxWindow*) GetWindow()->GetChildren().GetLast()->GetData();
2609 *toObject = childWindow->GetOrCreateAccessible();
2610
2611 return wxACC_OK;
2612 }
2613 case wxNAVDIR_RIGHT:
2614 case wxNAVDIR_DOWN:
2615 case wxNAVDIR_NEXT:
2616 {
2617 wxWindowList::compatibility_iterator node =
2618 wxWindowList::compatibility_iterator();
2619 if (fromId == 0)
2620 {
2621 // Can't navigate to sibling of this window
2622 // if we're a top-level window.
2623 if (!GetWindow()->GetParent())
2624 return wxACC_NOT_IMPLEMENTED;
2625
2626 node = GetWindow()->GetParent()->GetChildren().Find(GetWindow());
2627 }
2628 else
2629 {
2630 if (fromId <= (int) GetWindow()->GetChildren().GetCount())
2631 node = GetWindow()->GetChildren().Item(fromId-1);
2632 }
2633
2634 if (node && node->GetNext())
2635 {
2636 wxWindow* nextWindow = node->GetNext()->GetData();
2637 *toObject = nextWindow->GetOrCreateAccessible();
2638 return wxACC_OK;
2639 }
2640 else
2641 return wxACC_FALSE;
2642 }
2643 case wxNAVDIR_LEFT:
2644 case wxNAVDIR_UP:
2645 case wxNAVDIR_PREVIOUS:
2646 {
2647 wxWindowList::compatibility_iterator node =
2648 wxWindowList::compatibility_iterator();
2649 if (fromId == 0)
2650 {
2651 // Can't navigate to sibling of this window
2652 // if we're a top-level window.
2653 if (!GetWindow()->GetParent())
2654 return wxACC_NOT_IMPLEMENTED;
2655
2656 node = GetWindow()->GetParent()->GetChildren().Find(GetWindow());
2657 }
2658 else
2659 {
2660 if (fromId <= (int) GetWindow()->GetChildren().GetCount())
2661 node = GetWindow()->GetChildren().Item(fromId-1);
2662 }
2663
2664 if (node && node->GetPrevious())
2665 {
2666 wxWindow* previousWindow = node->GetPrevious()->GetData();
2667 *toObject = previousWindow->GetOrCreateAccessible();
2668 return wxACC_OK;
2669 }
2670 else
2671 return wxACC_FALSE;
2672 }
2673 }
2674
2675 return wxACC_NOT_IMPLEMENTED;
2676}
2677
2678// Gets the name of the specified object.
2679wxAccStatus wxWindowAccessible::GetName(int childId, wxString* name)
2680{
2681 wxASSERT( GetWindow() != NULL );
2682 if (!GetWindow())
2683 return wxACC_FAIL;
2684
2685 wxString title;
2686
2687 // If a child, leave wxWidgets to call the function on the actual
2688 // child object.
2689 if (childId > 0)
2690 return wxACC_NOT_IMPLEMENTED;
2691
2692 // This will eventually be replaced by specialised
2693 // accessible classes, one for each kind of wxWidgets
2694 // control or window.
2695#if wxUSE_BUTTON
2696 if (GetWindow()->IsKindOf(CLASSINFO(wxButton)))
2697 title = ((wxButton*) GetWindow())->GetLabel();
2698 else
2699#endif
2700 title = GetWindow()->GetName();
2701
2702 if (!title.empty())
2703 {
2704 *name = title;
2705 return wxACC_OK;
2706 }
2707 else
2708 return wxACC_NOT_IMPLEMENTED;
2709}
2710
2711// Gets the number of children.
2712wxAccStatus wxWindowAccessible::GetChildCount(int* childId)
2713{
2714 wxASSERT( GetWindow() != NULL );
2715 if (!GetWindow())
2716 return wxACC_FAIL;
2717
2718 *childId = (int) GetWindow()->GetChildren().GetCount();
2719 return wxACC_OK;
2720}
2721
2722// Gets the specified child (starting from 1).
2723// If *child is NULL and return value is wxACC_OK,
2724// this means that the child is a simple element and
2725// not an accessible object.
2726wxAccStatus wxWindowAccessible::GetChild(int childId, wxAccessible** child)
2727{
2728 wxASSERT( GetWindow() != NULL );
2729 if (!GetWindow())
2730 return wxACC_FAIL;
2731
2732 if (childId == 0)
2733 {
2734 *child = this;
2735 return wxACC_OK;
2736 }
2737
2738 if (childId > (int) GetWindow()->GetChildren().GetCount())
2739 return wxACC_FAIL;
2740
2741 wxWindow* childWindow = GetWindow()->GetChildren().Item(childId-1)->GetData();
2742 *child = childWindow->GetOrCreateAccessible();
2743 if (*child)
2744 return wxACC_OK;
2745 else
2746 return wxACC_FAIL;
2747}
2748
2749// Gets the parent, or NULL.
2750wxAccStatus wxWindowAccessible::GetParent(wxAccessible** parent)
2751{
2752 wxASSERT( GetWindow() != NULL );
2753 if (!GetWindow())
2754 return wxACC_FAIL;
2755
2756 wxWindow* parentWindow = GetWindow()->GetParent();
2757 if (!parentWindow)
2758 {
2759 *parent = NULL;
2760 return wxACC_OK;
2761 }
2762 else
2763 {
2764 *parent = parentWindow->GetOrCreateAccessible();
2765 if (*parent)
2766 return wxACC_OK;
2767 else
2768 return wxACC_FAIL;
2769 }
2770}
2771
2772// Performs the default action. childId is 0 (the action for this object)
2773// or > 0 (the action for a child).
2774// Return wxACC_NOT_SUPPORTED if there is no default action for this
2775// window (e.g. an edit control).
2776wxAccStatus wxWindowAccessible::DoDefaultAction(int WXUNUSED(childId))
2777{
2778 wxASSERT( GetWindow() != NULL );
2779 if (!GetWindow())
2780 return wxACC_FAIL;
2781
2782 return wxACC_NOT_IMPLEMENTED;
2783}
2784
2785// Gets the default action for this object (0) or > 0 (the action for a child).
2786// Return wxACC_OK even if there is no action. actionName is the action, or the empty
2787// string if there is no action.
2788// The retrieved string describes the action that is performed on an object,
2789// not what the object does as a result. For example, a toolbar button that prints
2790// a document has a default action of "Press" rather than "Prints the current document."
2791wxAccStatus wxWindowAccessible::GetDefaultAction(int WXUNUSED(childId), wxString* WXUNUSED(actionName))
2792{
2793 wxASSERT( GetWindow() != NULL );
2794 if (!GetWindow())
2795 return wxACC_FAIL;
2796
2797 return wxACC_NOT_IMPLEMENTED;
2798}
2799
2800// Returns the description for this object or a child.
2801wxAccStatus wxWindowAccessible::GetDescription(int WXUNUSED(childId), wxString* description)
2802{
2803 wxASSERT( GetWindow() != NULL );
2804 if (!GetWindow())
2805 return wxACC_FAIL;
2806
2807 wxString ht(GetWindow()->GetHelpTextAtPoint(wxDefaultPosition, wxHelpEvent::Origin_Keyboard));
2808 if (!ht.empty())
2809 {
2810 *description = ht;
2811 return wxACC_OK;
2812 }
2813 return wxACC_NOT_IMPLEMENTED;
2814}
2815
2816// Returns help text for this object or a child, similar to tooltip text.
2817wxAccStatus wxWindowAccessible::GetHelpText(int WXUNUSED(childId), wxString* helpText)
2818{
2819 wxASSERT( GetWindow() != NULL );
2820 if (!GetWindow())
2821 return wxACC_FAIL;
2822
2823 wxString ht(GetWindow()->GetHelpTextAtPoint(wxDefaultPosition, wxHelpEvent::Origin_Keyboard));
2824 if (!ht.empty())
2825 {
2826 *helpText = ht;
2827 return wxACC_OK;
2828 }
2829 return wxACC_NOT_IMPLEMENTED;
2830}
2831
2832// Returns the keyboard shortcut for this object or child.
2833// Return e.g. ALT+K
2834wxAccStatus wxWindowAccessible::GetKeyboardShortcut(int WXUNUSED(childId), wxString* WXUNUSED(shortcut))
2835{
2836 wxASSERT( GetWindow() != NULL );
2837 if (!GetWindow())
2838 return wxACC_FAIL;
2839
2840 return wxACC_NOT_IMPLEMENTED;
2841}
2842
2843// Returns a role constant.
2844wxAccStatus wxWindowAccessible::GetRole(int childId, wxAccRole* role)
2845{
2846 wxASSERT( GetWindow() != NULL );
2847 if (!GetWindow())
2848 return wxACC_FAIL;
2849
2850 // If a child, leave wxWidgets to call the function on the actual
2851 // child object.
2852 if (childId > 0)
2853 return wxACC_NOT_IMPLEMENTED;
2854
2855 if (GetWindow()->IsKindOf(CLASSINFO(wxControl)))
2856 return wxACC_NOT_IMPLEMENTED;
2857#if wxUSE_STATUSBAR
2858 if (GetWindow()->IsKindOf(CLASSINFO(wxStatusBar)))
2859 return wxACC_NOT_IMPLEMENTED;
2860#endif
2861#if wxUSE_TOOLBAR
2862 if (GetWindow()->IsKindOf(CLASSINFO(wxToolBar)))
2863 return wxACC_NOT_IMPLEMENTED;
2864#endif
2865
2866 //*role = wxROLE_SYSTEM_CLIENT;
2867 *role = wxROLE_SYSTEM_CLIENT;
2868 return wxACC_OK;
2869
2870 #if 0
2871 return wxACC_NOT_IMPLEMENTED;
2872 #endif
2873}
2874
2875// Returns a state constant.
2876wxAccStatus wxWindowAccessible::GetState(int childId, long* state)
2877{
2878 wxASSERT( GetWindow() != NULL );
2879 if (!GetWindow())
2880 return wxACC_FAIL;
2881
2882 // If a child, leave wxWidgets to call the function on the actual
2883 // child object.
2884 if (childId > 0)
2885 return wxACC_NOT_IMPLEMENTED;
2886
2887 if (GetWindow()->IsKindOf(CLASSINFO(wxControl)))
2888 return wxACC_NOT_IMPLEMENTED;
2889
2890#if wxUSE_STATUSBAR
2891 if (GetWindow()->IsKindOf(CLASSINFO(wxStatusBar)))
2892 return wxACC_NOT_IMPLEMENTED;
2893#endif
2894#if wxUSE_TOOLBAR
2895 if (GetWindow()->IsKindOf(CLASSINFO(wxToolBar)))
2896 return wxACC_NOT_IMPLEMENTED;
2897#endif
2898
2899 *state = 0;
2900 return wxACC_OK;
2901
2902 #if 0
2903 return wxACC_NOT_IMPLEMENTED;
2904 #endif
2905}
2906
2907// Returns a localized string representing the value for the object
2908// or child.
2909wxAccStatus wxWindowAccessible::GetValue(int WXUNUSED(childId), wxString* WXUNUSED(strValue))
2910{
2911 wxASSERT( GetWindow() != NULL );
2912 if (!GetWindow())
2913 return wxACC_FAIL;
2914
2915 return wxACC_NOT_IMPLEMENTED;
2916}
2917
2918// Selects the object or child.
2919wxAccStatus wxWindowAccessible::Select(int WXUNUSED(childId), wxAccSelectionFlags WXUNUSED(selectFlags))
2920{
2921 wxASSERT( GetWindow() != NULL );
2922 if (!GetWindow())
2923 return wxACC_FAIL;
2924
2925 return wxACC_NOT_IMPLEMENTED;
2926}
2927
2928// Gets the window with the keyboard focus.
2929// If childId is 0 and child is NULL, no object in
2930// this subhierarchy has the focus.
2931// If this object has the focus, child should be 'this'.
2932wxAccStatus wxWindowAccessible::GetFocus(int* WXUNUSED(childId), wxAccessible** WXUNUSED(child))
2933{
2934 wxASSERT( GetWindow() != NULL );
2935 if (!GetWindow())
2936 return wxACC_FAIL;
2937
2938 return wxACC_NOT_IMPLEMENTED;
2939}
2940
2941// Gets a variant representing the selected children
2942// of this object.
2943// Acceptable values:
2944// - a null variant (IsNull() returns true)
2945// - a list variant (GetType() == wxT("list")
2946// - an integer representing the selected child element,
2947// or 0 if this object is selected (GetType() == wxT("long")
2948// - a "void*" pointer to a wxAccessible child object
2949wxAccStatus wxWindowAccessible::GetSelections(wxVariant* WXUNUSED(selections))
2950{
2951 wxASSERT( GetWindow() != NULL );
2952 if (!GetWindow())
2953 return wxACC_FAIL;
2954
2955 return wxACC_NOT_IMPLEMENTED;
2956}
2957
2958#endif // wxUSE_ACCESSIBILITY
wxWidgets (Impactor)