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