fix undefined structs under 10.2 (tinderbox)

[wxWidgets.git] / src / common / wincmn.cpp

diff --git a/src/common/wincmn.cpp b/src/common/wincmn.cpp
index 031974f07248211e8d0cf4b40894f988385c2f86..7a1e6e85774ce0cc5cae664560bb279b1ac936e1 100644 (file)
--- a/src/common/wincmn.cpp
+++ b/src/common/wincmn.cpp
@@ -5,7 +5,7 @@
 // Modified by:
 // Created:     13/07/98
 // RCS-ID:      $Id$
 // Modified by:
 // Created:     13/07/98
 // RCS-ID:      $Id$

-// Copyright:   (c) wxWindows team
+// Copyright:   (c) wxWidgets team

 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 


@@ -17,10 +17,6 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-    #pragma implementation "windowbase.h"
-#endif
-

 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 


@@ -44,9 +40,14 @@
     #include "wx/dialog.h"
     #include "wx/msgdlg.h"
     #include "wx/statusbr.h"
     #include "wx/dialog.h"
     #include "wx/msgdlg.h"
     #include "wx/statusbr.h"

+    #include "wx/toolbar.h"

     #include "wx/dcclient.h"
 #endif //WX_PRECOMP
 
     #include "wx/dcclient.h"
 #endif //WX_PRECOMP
 

+#if defined(__WXMAC__) && wxUSE_SCROLLBAR
+    #include "wx/scrolbar.h"
+#endif
+

 #if wxUSE_CONSTRAINTS
     #include "wx/layout.h"
 #endif // wxUSE_CONSTRAINTS
 #if wxUSE_CONSTRAINTS
     #include "wx/layout.h"
 #endif // wxUSE_CONSTRAINTS


@@ -73,11 +74,21 @@
     #include "wx/caret.h"
 #endif // wxUSE_CARET
 
     #include "wx/caret.h"
 #endif // wxUSE_CARET
 

+#if wxUSE_DISPLAY
+    #include "wx/display.h"
+#endif
+
+#if wxUSE_SYSTEM_OPTIONS
+    #include "wx/sysopt.h"
+#endif
+

 // ----------------------------------------------------------------------------
 // static data
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // static data
 // ----------------------------------------------------------------------------
 

-#if defined(__WXPM__)
+#if defined(__WXPALMOS__)
+int wxWindowBase::ms_lastControlId = 32767;
+#elif defined(__WXPM__)

 int wxWindowBase::ms_lastControlId = 2000;
 #else
 int wxWindowBase::ms_lastControlId = -200;
 int wxWindowBase::ms_lastControlId = 2000;
 #else
 int wxWindowBase::ms_lastControlId = -200;


@@ -110,7 +121,6 @@ END_EVENT_TABLE()
 
 // the default initialization
 wxWindowBase::wxWindowBase()
 
 // the default initialization
 wxWindowBase::wxWindowBase()

-:   m_bestSize(wxDefaultSize)

 {
     // no window yet, no parent nor children
     m_parent = (wxWindow *)NULL;
 {
     // no window yet, no parent nor children
     m_parent = (wxWindow *)NULL;


@@ -118,9 +128,12 @@ wxWindowBase::wxWindowBase()
 
     // no constraints on the minimal window size
     m_minWidth =
 
     // no constraints on the minimal window size
     m_minWidth =

+    m_maxWidth = wxDefaultCoord;

     m_minHeight =
     m_minHeight =

-    m_maxWidth =
-    m_maxHeight = -1;
+    m_maxHeight = wxDefaultCoord;
+
+    // invalidiated cache value
+    m_bestSizeCache = wxDefaultSize;

 
     // window are created enabled and visible by default
     m_isShown =
 
     // window are created enabled and visible by default
     m_isShown =


@@ -139,11 +152,16 @@ wxWindowBase::wxWindowBase()
     m_hasBgCol =
     m_hasFgCol =
     m_hasFont = false;
     m_hasBgCol =
     m_hasFgCol =
     m_hasFont = false;

+    m_inheritBgCol =
+    m_inheritFgCol =
+    m_inheritFont = false;

 
     // no style bits
     m_exStyle =
     m_windowStyle = 0;
 
 
     // no style bits
     m_exStyle =
     m_windowStyle = 0;
 

+    m_backgroundStyle = wxBG_STYLE_SYSTEM;
+

 #if wxUSE_CONSTRAINTS
     // no constraints whatsoever
     m_constraints = (wxLayoutConstraints *) NULL;
 #if wxUSE_CONSTRAINTS
     // no constraints whatsoever
     m_constraints = (wxLayoutConstraints *) NULL;


@@ -177,24 +195,33 @@ wxWindowBase::wxWindowBase()
     m_virtualSize = wxDefaultSize;
 
     m_minVirtualWidth =
     m_virtualSize = wxDefaultSize;
 
     m_minVirtualWidth =

+    m_maxVirtualWidth = wxDefaultCoord;

     m_minVirtualHeight =
     m_minVirtualHeight =

-    m_maxVirtualWidth =
-    m_maxVirtualHeight = -1;
+    m_maxVirtualHeight = wxDefaultCoord;

 
     m_windowVariant = wxWINDOW_VARIANT_NORMAL;
 
     m_windowVariant = wxWINDOW_VARIANT_NORMAL;

+#if wxUSE_SYSTEM_OPTIONS
+    if ( wxSystemOptions::HasOption(wxWINDOW_DEFAULT_VARIANT) )
+    {
+       m_windowVariant = (wxWindowVariant) wxSystemOptions::GetOptionInt( wxWINDOW_DEFAULT_VARIANT ) ;
+    }
+#endif

 
     // Whether we're using the current theme for this window (wxGTK only for now)
     m_themeEnabled = false;
 
     // VZ: this one shouldn't exist...
     m_isBeingDeleted = false;
 
     // Whether we're using the current theme for this window (wxGTK only for now)
     m_themeEnabled = false;
 
     // VZ: this one shouldn't exist...
     m_isBeingDeleted = false;

+
+    // Reserved for future use
+    m_windowReserved = NULL;

 }
 
 // common part of window creation process
 bool wxWindowBase::CreateBase(wxWindowBase *parent,
                               wxWindowID id,
                               const wxPoint& WXUNUSED(pos),
 }
 
 // common part of window creation process
 bool wxWindowBase::CreateBase(wxWindowBase *parent,
                               wxWindowID id,
                               const wxPoint& WXUNUSED(pos),

-                              const wxSize& size,
+                              const wxSize& WXUNUSED(size),

                               long style,
                               const wxValidator& wxVALIDATOR_PARAM(validator),
                               const wxString& name)
                               long style,
                               const wxValidator& wxVALIDATOR_PARAM(validator),
                               const wxString& name)


@@ -212,7 +239,7 @@ bool wxWindowBase::CreateBase(wxWindowBase *parent,
 
     // ids are limited to 16 bits under MSW so if you care about portability,
     // it's not a good idea to use ids out of this range (and negative ids are
 
     // ids are limited to 16 bits under MSW so if you care about portability,
     // it's not a good idea to use ids out of this range (and negative ids are

-    // reserved for wxWindows own usage)
+    // reserved for wxWidgets own usage)

     wxASSERT_MSG( id == wxID_ANY || (id >= 0 && id < 32767),
                   _T("invalid id value") );
 
     wxASSERT_MSG( id == wxID_ANY || (id >= 0 && id < 32767),
                   _T("invalid id value") );
 


@@ -223,14 +250,6 @@ bool wxWindowBase::CreateBase(wxWindowBase *parent,
     SetWindowStyleFlag(style);
     SetParent(parent);
 
     SetWindowStyleFlag(style);
     SetParent(parent);
 

-    // Set the minsize to be the size passed to the ctor (if any) for
-    // non-TLWs.  This is so items used in a sizer will use this explicitly
-    // set size for layout, instead of falling back the (probably smaller)
-    // bestsize.
-    if (! IsTopLevel())
-        SetSizeHints(size);
-
-    

 #if wxUSE_VALIDATORS
     SetValidator(validator);
 #endif // wxUSE_VALIDATORS
 #if wxUSE_VALIDATORS
     SetValidator(validator);
 #endif // wxUSE_VALIDATORS


@@ -375,6 +394,7 @@ void wxWindowBase::Centre(int direction)
     int widthParent, heightParent;
 
     wxWindow *parent = NULL;
     int widthParent, heightParent;
 
     wxWindow *parent = NULL;

+    wxTopLevelWindow *winTop = NULL;

 
     if ( !(direction & wxCENTRE_ON_SCREEN) )
     {
 
     if ( !(direction & wxCENTRE_ON_SCREEN) )
     {


@@ -396,9 +416,10 @@ void wxWindowBase::Centre(int direction)
         // Windows, for example, this places it completely off the screen
         if ( parent )
         {
         // Windows, for example, this places it completely off the screen
         if ( parent )
         {

-            wxTopLevelWindow *winTop = wxDynamicCast(parent, wxTopLevelWindow);
+            winTop = wxDynamicCast(parent, wxTopLevelWindow);

             if ( winTop && winTop->IsIconized() )
             {
             if ( winTop && winTop->IsIconized() )
             {

+                winTop = NULL;

                 parent = NULL;
             }
         }
                 parent = NULL;
             }
         }


@@ -414,6 +435,21 @@ void wxWindowBase::Centre(int direction)
 
     if ( direction & wxCENTRE_ON_SCREEN )
     {
 
     if ( direction & wxCENTRE_ON_SCREEN )
     {

+        //RN:  If we are using wxDisplay we get
+        //the dimensions of the monitor the window is on,
+        //otherwise we get the dimensions of the primary monitor
+        //FIXME:  wxDisplay::GetFromWindow only implemented on MSW
+#if wxUSE_DISPLAY && defined(__WXMSW__)
+        int nDisplay = wxDisplay::GetFromWindow((wxWindow*)this);
+        if(nDisplay != wxNOT_FOUND)
+        {
+            wxDisplay windowDisplay(nDisplay);
+            wxRect displayRect = windowDisplay.GetGeometry();
+            widthParent = displayRect.width;
+            heightParent = displayRect.height;
+        }
+        else
+#endif

         // centre with respect to the whole screen
         wxDisplaySize(&widthParent, &heightParent);
     }
         // centre with respect to the whole screen
         wxDisplaySize(&widthParent, &heightParent);
     }


@@ -421,11 +457,16 @@ void wxWindowBase::Centre(int direction)
     {
         if ( IsTopLevel() )
         {
     {
         if ( IsTopLevel() )
         {

-            // centre on the parent
-            parent->GetSize(&widthParent, &heightParent);
+            if(winTop)
+                winTop->GetRectForTopLevelChildren(&posParent.x, &posParent.y, &widthParent, &heightParent);
+            else
+            {
+                // centre on the parent
+                parent->GetSize(&widthParent, &heightParent);

 
 

-            // adjust to the parents position
-            posParent = parent->GetPosition();
+                // adjust to the parents position
+                posParent = parent->GetPosition();
+            }

         }
         else
         {
         }
         else
         {


@@ -437,8 +478,8 @@ void wxWindowBase::Centre(int direction)
     int width, height;
     GetSize(&width, &height);
 
     int width, height;
     GetSize(&width, &height);
 

-    int xNew = -1,
-        yNew = -1;
+    int xNew = wxDefaultCoord,
+        yNew = wxDefaultCoord;

 
     if ( direction & wxHORIZONTAL )
         xNew = (widthParent - width)/2;
 
     if ( direction & wxHORIZONTAL )
         xNew = (widthParent - width)/2;


@@ -449,45 +490,47 @@ void wxWindowBase::Centre(int direction)
     xNew += posParent.x;
     yNew += posParent.y;
 
     xNew += posParent.x;
     yNew += posParent.y;
 

+    // FIXME:  This needs to get the client display rect of the display
+    // the window is (via wxDisplay::GetFromWindow).
+

     // Base size of the visible dimensions of the display
     // Base size of the visible dimensions of the display

-    // to take into account the taskbar
-    wxRect rect = wxGetClientDisplayRect();
-    wxSize size (rect.width,rect.height);
+    // to take into account the taskbar. And the Mac menu bar at top.
+    wxRect clientrect = wxGetClientDisplayRect();

 
 

-    // NB: in wxMSW, negative position may not neccessary mean "out of screen",
+    // NB: in wxMSW, negative position may not necessarily mean "out of screen",

     //     but it may mean that the window is placed on other than the main
     //     display. Therefore we only make sure centered window is on the main display
     //     if the parent is at least partially present here.
     if (posParent.x + widthParent >= 0)  // if parent is (partially) on the main display
     {
     //     but it may mean that the window is placed on other than the main
     //     display. Therefore we only make sure centered window is on the main display
     //     if the parent is at least partially present here.
     if (posParent.x + widthParent >= 0)  // if parent is (partially) on the main display
     {

-        if (xNew < 0)
-            xNew = 0;
-        else if (xNew+width > size.x)
-            xNew = size.x-width-1;
+        if (xNew < clientrect.GetLeft())
+            xNew = clientrect.GetLeft();
+        else if (xNew + width > clientrect.GetRight())
+            xNew = clientrect.GetRight() - width;

     }
     if (posParent.y + heightParent >= 0)  // if parent is (partially) on the main display
     {
     }
     if (posParent.y + heightParent >= 0)  // if parent is (partially) on the main display
     {

-        if (yNew+height > size.y)
-            yNew = size.y-height-1;
+        if (yNew + height > clientrect.GetBottom())
+            yNew = clientrect.GetBottom() - height;

 
         // Make certain that the title bar is initially visible
         // always, even if this would push the bottom of the
 
         // Make certain that the title bar is initially visible
         // always, even if this would push the bottom of the

-        // dialog of the visible area of the display
-        if (yNew < 0)
-            yNew = 0;
+        // dialog off the visible area of the display
+        if (yNew < clientrect.GetTop())
+            yNew = clientrect.GetTop();

     }
 
     // move the window to this position (keeping the old size but using
     }
 
     // move the window to this position (keeping the old size but using

-    // SetSize() and not Move() to allow xNew and/or yNew to be -1)
+    // SetSize() and not Move() to allow xNew and/or yNew to be wxDefaultCoord)

     SetSize(xNew, yNew, width, height, wxSIZE_ALLOW_MINUS_ONE);
 }
 
 // fits the window around the children
 void wxWindowBase::Fit()
 {
     SetSize(xNew, yNew, width, height, wxSIZE_ALLOW_MINUS_ONE);
 }
 
 // fits the window around the children
 void wxWindowBase::Fit()
 {

-    if ( GetChildren().GetCount() > 0 )
+    if ( !GetChildren().empty() )

     {
     {

-        SetClientSize(DoGetBestSize());
+        SetClientSize(GetBestSize());

     }
     //else: do nothing if we have no children
 }
     }
     //else: do nothing if we have no children
 }


@@ -501,12 +544,42 @@ void wxWindowBase::FitInside()
     }
 }
 
     }
 }
 

+// On Mac, scrollbars are explicitly children.
+#ifdef __WXMAC__
+static bool wxHasRealChildren(const wxWindowBase* win)
+{
+    int realChildCount = 0;
+
+    for ( wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
+          node;
+          node = node->GetNext() )
+    {
+        wxWindow *win = node->GetData();
+        if ( !win->IsTopLevel() && win->IsShown() && !win->IsKindOf(CLASSINFO(wxScrollBar)))
+            realChildCount ++;
+    }
+    return (realChildCount > 0);
+}
+#endif
+
+void wxWindowBase::InvalidateBestSize()
+{
+    m_bestSizeCache = wxDefaultSize;
+
+    // parent's best size calculation may depend on its children's
+    // best sizes, so let's invalidate it as well to be safe:
+    if (m_parent)
+        m_parent->InvalidateBestSize();
+}
+

 // return the size best suited for the current window
 wxSize wxWindowBase::DoGetBestSize() const
 {
 // return the size best suited for the current window
 wxSize wxWindowBase::DoGetBestSize() const
 {

+    wxSize best;
+

     if ( m_windowSizer )
     {
     if ( m_windowSizer )
     {

-        return m_windowSizer->GetMinSize();
+        best = GetWindowSizeForVirtualSize(m_windowSizer->GetMinSize());

     }
 #if wxUSE_CONSTRAINTS
     else if ( m_constraints )
     }
 #if wxUSE_CONSTRAINTS
     else if ( m_constraints )


@@ -542,12 +615,16 @@ wxSize wxWindowBase::DoGetBestSize() const
             //       will never return a size bigger than the current one :-(
         }
 
             //       will never return a size bigger than the current one :-(
         }
 

-        return wxSize(maxX, maxY);
+        best = wxSize(maxX, maxY);

     }
 #endif // wxUSE_CONSTRAINTS
     }
 #endif // wxUSE_CONSTRAINTS

-    else if ( GetChildren().GetCount() > 0 )
+    else if ( !GetChildren().empty()
+#ifdef __WXMAC__
+              && wxHasRealChildren(this)
+#endif
+              )

     {
     {

-        // our minimal acceptable size is such that all our windows fit inside
+        // our minimal acceptable size is such that all our visible child windows fit inside

         int maxX = 0,
             maxY = 0;
 
         int maxX = 0,
             maxY = 0;
 


@@ -556,7 +633,7 @@ wxSize wxWindowBase::DoGetBestSize() const
               node = node->GetNext() )
         {
             wxWindow *win = node->GetData();
               node = node->GetNext() )
         {
             wxWindow *win = node->GetData();

-            if ( win->IsTopLevel()
+            if ( win->IsTopLevel()  || ( ! win->IsShown() )

 #if wxUSE_STATUSBAR
                     || wxDynamicCast(win, wxStatusBar)
 #endif // wxUSE_STATUSBAR
 #if wxUSE_STATUSBAR
                     || wxDynamicCast(win, wxStatusBar)
 #endif // wxUSE_STATUSBAR


@@ -573,9 +650,9 @@ wxSize wxWindowBase::DoGetBestSize() const
 
             // if the window hadn't been positioned yet, assume that it is in
             // the origin
 
             // if the window hadn't been positioned yet, assume that it is in
             // the origin

-            if ( wx == -1 )
+            if ( wx == wxDefaultCoord )

                 wx = 0;
                 wx = 0;

-            if ( wy == -1 )
+            if ( wy == wxDefaultCoord )

                 wy = 0;
 
             win->GetSize(&ww, &wh);
                 wy = 0;
 
             win->GetSize(&ww, &wh);


@@ -590,40 +667,82 @@ wxSize wxWindowBase::DoGetBestSize() const
         maxX += 7;
         maxY += 14;
 
         maxX += 7;
         maxY += 14;
 

-        return wxSize(maxX, maxY);
+        best = wxSize(maxX, maxY);

     }
     }

-    else
+    else // ! has children

     {
     {

-        // Windows which don't implement DoGetBestSize and aren't parents.
-        // This emulates the behavior of a wxSizer without wxADJUST_MINSIZE
-
-        // If you get the following message you should do one of two things
-        // 1. Do what it says (best)
-        // 2. m_bestSize = GetSize() at end of Create() (hack)
-        if(m_bestSize == wxDefaultSize)
+        // for a generic window there is no natural best size so, if the
+        // minimal size is not set, use the current size but take care to
+        // remember it as minimal size for the next time because our best size
+        // should be constant: otherwise we could get into a situation when the
+        // window is initially at some size, then expanded to a larger size and
+        // then, when the containing window is shrunk back (because our initial
+        // best size had been used for computing the parent min size), we can't
+        // be shrunk back any more because our best size is now bigger
+        wxSize size = GetMinSize();
+        if ( !size.IsFullySpecified() )

         {
         {

-            wxLogDebug(wxT("Class %s (or superclass) should implement DoGetBestSize()"),GetClassInfo()->GetClassName());
-            wxConstCast(this,wxWindowBase)->m_bestSize = GetSize();
+            size.SetDefaults(GetSize());
+            wxConstCast(this, wxWindowBase)->SetMinSize(size);

         }
         }

-        return m_bestSize;
+
+        // return as-is, unadjusted by the client size difference.
+        return size;
+    }
+
+    // Add any difference between size and client size
+    wxSize diff = GetSize() - GetClientSize();
+    best.x += wxMax(0, diff.x);
+    best.y += wxMax(0, diff.y);
+
+    return best;
+}
+
+
+wxSize wxWindowBase::GetBestFittingSize() const
+{
+    // merge the best size with the min size, giving priority to the min size
+    wxSize min = GetMinSize();
+    if (min.x == wxDefaultCoord || min.y == wxDefaultCoord)
+    {
+        wxSize best = GetBestSize();
+        if (min.x == wxDefaultCoord) min.x =  best.x;
+        if (min.y == wxDefaultCoord) min.y =  best.y;

     }
     }

+    return min;
+}
+
+
+void wxWindowBase::SetBestFittingSize(const wxSize& size)
+{
+    // Set the min size to the size passed in.  This will usually either be
+    // wxDefaultSize or the size passed to this window's ctor/Create function.
+    SetMinSize(size);
+
+    // Merge the size with the best size if needed
+    wxSize best = GetBestFittingSize();
+
+    // If the current size doesn't match then change it
+    if (GetSize() != best)
+        SetSize(best);

 }
 
 }
 

+

 // by default the origin is not shifted
 wxPoint wxWindowBase::GetClientAreaOrigin() const
 {
 // by default the origin is not shifted
 wxPoint wxWindowBase::GetClientAreaOrigin() const
 {

-    return wxPoint(0, 0);
+    return wxPoint(0,0);

 }
 
 // set the min/max size of the window
 }
 
 // set the min/max size of the window

-void wxWindowBase::SetSizeHints(int minW, int minH,
-                                int maxW, int maxH,
-                                int WXUNUSED(incW), int WXUNUSED(incH))
+void wxWindowBase::DoSetSizeHints(int minW, int minH,
+                                  int maxW, int maxH,
+                                  int WXUNUSED(incW), int WXUNUSED(incH))

 {
     // setting min width greater than max width leads to infinite loops under
     // X11 and generally doesn't make any sense, so don't allow it
 {
     // setting min width greater than max width leads to infinite loops under
     // X11 and generally doesn't make any sense, so don't allow it

-    wxCHECK_RET( (minW == -1 || maxW == -1 || minW <= maxW) &&
-                    (minH == -1 || maxH == -1 || minH <= maxH),
+    wxCHECK_RET( (minW == wxDefaultCoord || maxW == wxDefaultCoord || minW <= maxW) &&
+                    (minH == wxDefaultCoord || maxH == wxDefaultCoord || minH <= maxH),

                  _T("min width/height must be less than max width/height!") );
 
     m_minWidth = minW;
                  _T("min width/height must be less than max width/height!") );
 
     m_minWidth = minW;


@@ -688,13 +807,13 @@ void wxWindowBase::SetVirtualSizeHints( int minW, int minH,
 
 void wxWindowBase::DoSetVirtualSize( int x, int y )
 {
 
 void wxWindowBase::DoSetVirtualSize( int x, int y )
 {

-    if ( m_minVirtualWidth != -1 && m_minVirtualWidth > x )
+    if ( m_minVirtualWidth != wxDefaultCoord && m_minVirtualWidth > x )

         x = m_minVirtualWidth;
         x = m_minVirtualWidth;

-    if ( m_maxVirtualWidth != -1 && m_maxVirtualWidth < x )
+    if ( m_maxVirtualWidth != wxDefaultCoord && m_maxVirtualWidth < x )

         x = m_maxVirtualWidth;
         x = m_maxVirtualWidth;

-    if ( m_minVirtualHeight != -1 && m_minVirtualHeight > y )
+    if ( m_minVirtualHeight != wxDefaultCoord && m_minVirtualHeight > y )

         y = m_minVirtualHeight;
         y = m_minVirtualHeight;

-    if ( m_maxVirtualHeight != -1 && m_maxVirtualHeight < y )
+    if ( m_maxVirtualHeight != wxDefaultCoord && m_maxVirtualHeight < y )

         y = m_maxVirtualHeight;
 
     m_virtualSize = wxSize(x, y);
         y = m_maxVirtualHeight;
 
     m_virtualSize = wxSize(x, y);


@@ -702,10 +821,17 @@ void wxWindowBase::DoSetVirtualSize( int x, int y )
 
 wxSize wxWindowBase::DoGetVirtualSize() const
 {
 
 wxSize wxWindowBase::DoGetVirtualSize() const
 {

-    wxSize  s( GetClientSize() );
+    if ( m_virtualSize.IsFullySpecified() )
+        return m_virtualSize;
+
+    wxSize size = GetClientSize();
+    if ( m_virtualSize.x != wxDefaultCoord )
+        size.x = m_virtualSize.x;
+
+    if ( m_virtualSize.y != wxDefaultCoord )
+        size.y = m_virtualSize.y;

 
 

-    return wxSize( wxMax( m_virtualSize.GetWidth(), s.GetWidth() ),
-                   wxMax( m_virtualSize.GetHeight(), s.GetHeight() ) );
+    return size;

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -890,7 +1016,7 @@ bool wxWindowBase::RemoveEventHandler(wxEvtHandler *handler)
 
 void wxWindowBase::InheritAttributes()
 {
 
 void wxWindowBase::InheritAttributes()
 {

-    const wxWindow * const parent = GetParent();
+    const wxWindowBase * const parent = GetParent();

     if ( !parent )
         return;
 
     if ( !parent )
         return;
 


@@ -898,18 +1024,25 @@ void wxWindowBase::InheritAttributes()
     // which ensures that this only happens if the user really wants it and
     // not by default which wouldn't make any sense in modern GUIs where the
     // controls don't all use the same fonts (nor colours)
     // which ensures that this only happens if the user really wants it and
     // not by default which wouldn't make any sense in modern GUIs where the
     // controls don't all use the same fonts (nor colours)

-    if ( parent->m_hasFont && !m_hasFont )
+    if ( parent->m_inheritFont && !m_hasFont )

         SetFont(parent->GetFont());
 
     // in addition, there is a possibility to explicitly forbid inheriting
     // colours at each class level by overriding ShouldInheritColours()
     if ( ShouldInheritColours() )
     {
         SetFont(parent->GetFont());
 
     // in addition, there is a possibility to explicitly forbid inheriting
     // colours at each class level by overriding ShouldInheritColours()
     if ( ShouldInheritColours() )
     {

-        if ( parent->m_hasFgCol && !m_hasFgCol )
+        if ( parent->m_inheritFgCol && !m_hasFgCol )

             SetForegroundColour(parent->GetForegroundColour());
 
             SetForegroundColour(parent->GetForegroundColour());
 

-        if ( parent->m_hasBgCol && !m_hasBgCol )
+        // inheriting (solid) background colour is wrong as it totally breaks
+        // any kind of themed backgrounds
+        //
+        // instead, the controls should use the same background as their parent
+        // (ideally by not drawing it at all)
+#if 0
+        if ( parent->m_inheritBgCol && !m_hasBgCol )

             SetBackgroundColour(parent->GetBackgroundColour());
             SetBackgroundColour(parent->GetBackgroundColour());

+#endif // 0

     }
 }
 
     }
 }
 


@@ -921,8 +1054,17 @@ wxWindowBase::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
     wxVisualAttributes attrs;
     attrs.font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
     attrs.colFg = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
     wxVisualAttributes attrs;
     attrs.font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
     attrs.colFg = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);

-    attrs.colBg = wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE);

 
 

+    // On Smartphone/PocketPC, wxSYS_COLOUR_WINDOW is a better reflection of
+    // the usual background colour than wxSYS_COLOUR_BTNFACE.
+    // It's a pity that wxSYS_COLOUR_WINDOW isn't always a suitable background
+    // colour on other platforms.
+
+#if defined(__WXWINCE__) && (defined(__SMARTPHONE__) || defined(__POCKETPC__))
+    attrs.colBg = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW);
+#else
+    attrs.colBg = wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE);
+#endif

     return attrs;
 }
 
     return attrs;
 }
 


@@ -937,17 +1079,16 @@ wxColour wxWindowBase::GetBackgroundColour() const
 
         // we must return some valid colour to avoid redoing this every time
         // and also to avoid surprizing the applications written for older
 
         // we must return some valid colour to avoid redoing this every time
         // and also to avoid surprizing the applications written for older

-        // wxWindows versions where GetBackgroundColour() always returned
+        // wxWidgets versions where GetBackgroundColour() always returned

         // something -- so give them something even if it doesn't make sense
         // for this window (e.g. it has a themed background)
         if ( !colBg.Ok() )
             colBg = GetClassDefaultAttributes().colBg;
 
         // something -- so give them something even if it doesn't make sense
         // for this window (e.g. it has a themed background)
         if ( !colBg.Ok() )
             colBg = GetClassDefaultAttributes().colBg;
 

-        // cache it for the next call
-        wxConstCast(this, wxWindowBase)->m_backgroundColour = colBg;
+        return colBg;

     }
     }

-
-    return m_backgroundColour;
+    else
+        return m_backgroundColour;

 }
 
 wxColour wxWindowBase::GetForegroundColour() const
 }
 
 wxColour wxWindowBase::GetForegroundColour() const


@@ -962,33 +1103,36 @@ wxColour wxWindowBase::GetForegroundColour() const
         if ( !colFg.Ok() )
             colFg = GetClassDefaultAttributes().colFg;
 
         if ( !colFg.Ok() )
             colFg = GetClassDefaultAttributes().colFg;
 

-        wxConstCast(this, wxWindowBase)->m_foregroundColour = colFg;
+        return colFg;

     }
     }

-
-    return m_foregroundColour;
+    else
+        return m_foregroundColour;

 }
 
 bool wxWindowBase::SetBackgroundColour( const wxColour &colour )
 {
 }
 
 bool wxWindowBase::SetBackgroundColour( const wxColour &colour )
 {

-    if ( !colour.Ok() || (colour == m_backgroundColour) )
+    if ( colour == m_backgroundColour )

         return false;
 
         return false;
 

-    m_backgroundColour = colour;
-
-    m_hasBgCol = true;
+    m_hasBgCol = colour.Ok();
+    if ( m_backgroundStyle != wxBG_STYLE_CUSTOM )
+        m_backgroundStyle = m_hasBgCol ? wxBG_STYLE_COLOUR : wxBG_STYLE_SYSTEM;

 
 

+    m_inheritBgCol = m_hasBgCol;
+    m_backgroundColour = colour;
+    SetThemeEnabled( !m_hasBgCol && !m_foregroundColour.Ok() );

     return true;
 }
 
 bool wxWindowBase::SetForegroundColour( const wxColour &colour )
 {
     return true;
 }
 
 bool wxWindowBase::SetForegroundColour( const wxColour &colour )
 {

-    if ( !colour.Ok() || (colour == m_foregroundColour) )
+    if (colour == m_foregroundColour )

         return false;
 
         return false;
 

+    m_hasFgCol = colour.Ok();
+    m_inheritFgCol = m_hasFgCol;

     m_foregroundColour = colour;
     m_foregroundColour = colour;

-
-    m_hasFgCol = true;
-
+    SetThemeEnabled( !m_hasFgCol && !m_backgroundColour.Ok() );

     return true;
 }
 
     return true;
 }
 


@@ -1007,7 +1151,7 @@ bool wxWindowBase::SetCursor(const wxCursor& cursor)
     return true;
 }
 
     return true;
 }
 

-wxFont& wxWindowBase::DoGetFont() const
+wxFont wxWindowBase::GetFont() const

 {
     // logic is the same as in GetBackgroundColour()
     if ( !m_font.Ok() )
 {
     // logic is the same as in GetBackgroundColour()
     if ( !m_font.Ok() )


@@ -1018,18 +1162,14 @@ wxFont& wxWindowBase::DoGetFont() const
         if ( !font.Ok() )
             font = GetClassDefaultAttributes().font;
 
         if ( !font.Ok() )
             font = GetClassDefaultAttributes().font;
 

-        wxConstCast(this, wxWindowBase)->m_font = font;
+        return font;

     }
     }

-
-    // cast is here for non-const GetFont() convenience
-    return wxConstCast(this, wxWindowBase)->m_font;
+    else
+        return m_font;

 }
 
 bool wxWindowBase::SetFont(const wxFont& font)
 {
 }
 
 bool wxWindowBase::SetFont(const wxFont& font)
 {

-    if ( !font.Ok() )
-        return false;
-

     if ( font == m_font )
     {
         // no change
     if ( font == m_font )
     {
         // no change


@@ -1037,8 +1177,10 @@ bool wxWindowBase::SetFont(const wxFont& font)
     }
 
     m_font = font;
     }
 
     m_font = font;

+    m_hasFont = font.Ok();
+    m_inheritFont = m_hasFont;

 
 

-    m_hasFont = true;
+    InvalidateBestSize();

 
     return true;
 }
 
     return true;
 }


@@ -1144,7 +1286,7 @@ void wxWindowBase::ClearBackground()
 // find child window by id or name
 // ----------------------------------------------------------------------------
 
 // find child window by id or name
 // ----------------------------------------------------------------------------
 

-wxWindow *wxWindowBase::FindWindow( long id )
+wxWindow *wxWindowBase::FindWindow(long id) const

 {
     if ( id == m_windowId )
         return (wxWindow *)this;
 {
     if ( id == m_windowId )
         return (wxWindow *)this;


@@ -1160,7 +1302,7 @@ wxWindow *wxWindowBase::FindWindow( long id )
     return (wxWindow *)res;
 }
 
     return (wxWindow *)res;
 }
 

-wxWindow *wxWindowBase::FindWindow( const wxString& name )
+wxWindow *wxWindowBase::FindWindow(const wxString& name) const

 {
     if ( name == m_windowName )
         return (wxWindow *)this;
 {
     if ( name == m_windowName )
         return (wxWindow *)this;


@@ -1292,7 +1434,7 @@ wxWindowBase::FindWindowByName(const wxString& title, const wxWindow *parent)
 wxWindow *
 wxWindowBase::FindWindowById( long id, const wxWindow* parent )
 {
 wxWindow *
 wxWindowBase::FindWindowById( long id, const wxWindow* parent )
 {

-    return wxFindWindowHelper(parent, _T(""), id, wxFindWindowCmpIds);
+    return wxFindWindowHelper(parent, wxEmptyString, id, wxFindWindowCmpIds);

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -1637,6 +1779,19 @@ void wxWindowBase::SetSizerAndFit(wxSizer *sizer, bool deleteOld)
     sizer->SetSizeHints( (wxWindow*) this );
 }
 
     sizer->SetSizeHints( (wxWindow*) this );
 }
 

+
+void wxWindowBase::SetContainingSizer(wxSizer* sizer)
+{
+    // adding a window to a sizer twice is going to result in fatal and
+    // hard to debug problems later because when deleting the second
+    // associated wxSizerItem we're going to dereference a dangling
+    // pointer; so try to detect this as early as possible
+    wxASSERT_MSG( !sizer || m_containingSizer != sizer,
+                  _T("Adding a window to the same sizer twice?") );
+
+    m_containingSizer = sizer;
+}
+

 #if wxUSE_CONSTRAINTS
 
 void wxWindowBase::SatisfyConstraints()
 #if wxUSE_CONSTRAINTS
 
 void wxWindowBase::SatisfyConstraints()


@@ -1836,22 +1991,22 @@ void wxWindowBase::SetSizeConstraint(int x, int y, int w, int h)
     wxLayoutConstraints *constr = GetConstraints();
     if ( constr )
     {
     wxLayoutConstraints *constr = GetConstraints();
     if ( constr )
     {

-        if ( x != -1 )
+        if ( x != wxDefaultCoord )

         {
             constr->left.SetValue(x);
             constr->left.SetDone(true);
         }
         {
             constr->left.SetValue(x);
             constr->left.SetDone(true);
         }

-        if ( y != -1 )
+        if ( y != wxDefaultCoord )

         {
             constr->top.SetValue(y);
             constr->top.SetDone(true);
         }
         {
             constr->top.SetValue(y);
             constr->top.SetDone(true);
         }

-        if ( w != -1 )
+        if ( w != wxDefaultCoord )

         {
             constr->width.SetValue(w);
             constr->width.SetDone(true);
         }
         {
             constr->width.SetValue(w);
             constr->width.SetDone(true);
         }

-        if ( h != -1 )
+        if ( h != wxDefaultCoord )

         {
             constr->height.SetValue(h);
             constr->height.SetDone(true);
         {
             constr->height.SetValue(h);
             constr->height.SetDone(true);


@@ -1864,12 +2019,12 @@ void wxWindowBase::MoveConstraint(int x, int y)
     wxLayoutConstraints *constr = GetConstraints();
     if ( constr )
     {
     wxLayoutConstraints *constr = GetConstraints();
     if ( constr )
     {

-        if ( x != -1 )
+        if ( x != wxDefaultCoord )

         {
             constr->left.SetValue(x);
             constr->left.SetDone(true);
         }
         {
             constr->left.SetValue(x);
             constr->left.SetDone(true);
         }

-        if ( y != -1 )
+        if ( y != wxDefaultCoord )

         {
             constr->top.SetValue(y);
             constr->top.SetDone(true);
         {
             constr->top.SetValue(y);
             constr->top.SetDone(true);


@@ -1938,7 +2093,7 @@ void wxWindowBase::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags) co
 void wxWindowBase::UpdateWindowUI(long flags)
 {
     wxUpdateUIEvent event(GetId());
 void wxWindowBase::UpdateWindowUI(long flags)
 {
     wxUpdateUIEvent event(GetId());

-    event.m_eventObject = this;
+    event.SetEventObject(this);

 
     if ( GetEventHandler()->ProcessEvent(event) )
     {
 
     if ( GetEventHandler()->ProcessEvent(event) )
     {


@@ -1975,12 +2130,16 @@ void wxWindowBase::DoUpdateWindowUI(wxUpdateUIEvent& event)
             if ( event.GetText() != control->GetLabel() )
                 control->SetLabel(event.GetText());
         }
             if ( event.GetText() != control->GetLabel() )
                 control->SetLabel(event.GetText());
         }

+    }
+#endif // wxUSE_CONTROLS
+
+    if ( event.GetSetChecked() )
+    {

 #if wxUSE_CHECKBOX
         wxCheckBox *checkbox = wxDynamicCastThis(wxCheckBox);
         if ( checkbox )
         {
 #if wxUSE_CHECKBOX
         wxCheckBox *checkbox = wxDynamicCastThis(wxCheckBox);
         if ( checkbox )
         {

-            if ( event.GetSetChecked() )
-                checkbox->SetValue(event.GetChecked());
+            checkbox->SetValue(event.GetChecked());

         }
 #endif // wxUSE_CHECKBOX
 
         }
 #endif // wxUSE_CHECKBOX
 


@@ -1988,12 +2147,10 @@ void wxWindowBase::DoUpdateWindowUI(wxUpdateUIEvent& event)
         wxRadioButton *radiobtn = wxDynamicCastThis(wxRadioButton);
         if ( radiobtn )
         {
         wxRadioButton *radiobtn = wxDynamicCastThis(wxRadioButton);
         if ( radiobtn )
         {

-            if ( event.GetSetChecked() )
-                radiobtn->SetValue(event.GetChecked());
+            radiobtn->SetValue(event.GetChecked());

         }
 #endif // wxUSE_RADIOBTN
     }
         }
 #endif // wxUSE_RADIOBTN
     }

-#endif

 }
 
 #if 0
 }
 
 #if 0


@@ -2021,10 +2178,10 @@ wxPoint wxWindowBase::ConvertPixelsToDialog(const wxPoint& pt)
 {
     int charWidth = GetCharWidth();
     int charHeight = GetCharHeight();
 {
     int charWidth = GetCharWidth();
     int charHeight = GetCharHeight();

-    wxPoint pt2(-1, -1);
-    if (pt.x != -1)
+    wxPoint pt2 = wxDefaultPosition;
+    if (pt.x != wxDefaultCoord)

         pt2.x = (int) ((pt.x * 4) / charWidth);
         pt2.x = (int) ((pt.x * 4) / charWidth);

-    if (pt.y != -1)
+    if (pt.y != wxDefaultCoord)

         pt2.y = (int) ((pt.y * 8) / charHeight);
 
     return pt2;
         pt2.y = (int) ((pt.y * 8) / charHeight);
 
     return pt2;


@@ -2034,10 +2191,10 @@ wxPoint wxWindowBase::ConvertDialogToPixels(const wxPoint& pt)
 {
     int charWidth = GetCharWidth();
     int charHeight = GetCharHeight();
 {
     int charWidth = GetCharWidth();
     int charHeight = GetCharHeight();

-    wxPoint pt2(-1, -1);
-    if (pt.x != -1)
+    wxPoint pt2 = wxDefaultPosition;
+    if (pt.x != wxDefaultCoord)

         pt2.x = (int) ((pt.x * charWidth) / 4);
         pt2.x = (int) ((pt.x * charWidth) / 4);

-    if (pt.y != -1)
+    if (pt.y != wxDefaultCoord)

         pt2.y = (int) ((pt.y * charHeight) / 8);
 
     return pt2;
         pt2.y = (int) ((pt.y * charHeight) / 8);
 
     return pt2;


@@ -2058,12 +2215,14 @@ void wxWindowBase::OnSysColourChanged(wxSysColourChangedEvent& event)
         if ( !win->IsTopLevel() )
         {
             wxSysColourChangedEvent event2;
         if ( !win->IsTopLevel() )
         {
             wxSysColourChangedEvent event2;

-            event.m_eventObject = win;
+            event.SetEventObject(win);

             win->GetEventHandler()->ProcessEvent(event2);
         }
 
         node = node->GetNext();
     }
             win->GetEventHandler()->ProcessEvent(event2);
         }
 
         node = node->GetNext();
     }

+
+    Refresh();

 }
 
 // the default action is to populate dialog with data when it's created,
 }
 
 // the default action is to populate dialog with data when it's created,


@@ -2092,32 +2251,36 @@ void wxWindowBase::OnMiddleClick( wxMouseEvent& event )
 
         switch ( wxGetOsVersion() )
         {
 
         switch ( wxGetOsVersion() )
         {

-            case wxMOTIF_X:     port += _T("Motif"); break;
+            case wxMOTIF_X:            port += _T("Motif"); break;

             case wxMAC:
             case wxMAC:

-            case wxMAC_DARWIN:  port += _T("Mac"); break;
-            case wxBEOS:        port += _T("BeOS"); break;
+            case wxMAC_DARWIN:         port += _T("Mac"); break;
+            case wxBEOS:               port += _T("BeOS"); break;

             case wxGTK:
             case wxGTK_WIN32:
             case wxGTK_OS2:
             case wxGTK:
             case wxGTK_WIN32:
             case wxGTK_OS2:

-            case wxGTK_BEOS:    port += _T("GTK"); break;
+            case wxGTK_BEOS:           port += _T("GTK"); break;

             case wxWINDOWS:
             case wxPENWINDOWS:
             case wxWINDOWS_NT:
             case wxWIN32S:
             case wxWIN95:
             case wxWINDOWS:
             case wxPENWINDOWS:
             case wxWINDOWS_NT:
             case wxWIN32S:
             case wxWIN95:

-            case wxWIN386:      port += _T("MS Windows"); break;
+            case wxWIN386:             port += _T("MS Windows"); break;

             case wxMGL_UNIX:
             case wxMGL_X:
             case wxMGL_WIN32:
             case wxMGL_UNIX:
             case wxMGL_X:
             case wxMGL_WIN32:

-            case wxMGL_OS2:     port += _T("MGL"); break;
+            case wxMGL_OS2:            port += _T("MGL"); break;

             case wxWINDOWS_OS2:
             case wxWINDOWS_OS2:

-            case wxOS2_PM:      port += _T("OS/2"); break;
+            case wxOS2_PM:             port += _T("OS/2"); break;
+            case wxPALMOS:             port += _T("Palm OS"); break;
+            case wxWINDOWS_CE:         port += _T("Windows CE (generic)"); break;
+            case wxWINDOWS_POCKETPC:   port += _T("Windows CE PocketPC"); break;
+            case wxWINDOWS_SMARTPHONE: port += _T("Windows CE Smartphone"); break;

             default:            port += _T("unknown"); break;
         }
 
         wxMessageBox(wxString::Format(
                                       _T(
             default:            port += _T("unknown"); break;
         }
 
         wxMessageBox(wxString::Format(
                                       _T(

-                                        "       wxWindows Library (%s port)\nVersion %u.%u.%u%s, compiled at %s %s\n   Copyright (c) 1995-2002 wxWindows team"
+                                        "       wxWidgets Library (%s port)\nVersion %d.%d.%d%s%s, compiled at %s %s\n   Copyright (c) 1995-2005 wxWidgets team"

                                         ),
                                       port.c_str(),
                                       wxMAJOR_VERSION,
                                         ),
                                       port.c_str(),
                                       wxMAJOR_VERSION,


@@ -2127,11 +2290,16 @@ void wxWindowBase::OnMiddleClick( wxMouseEvent& event )
                                       L" (Unicode)",
 #else
                                       "",
                                       L" (Unicode)",
 #else
                                       "",

+#endif
+#ifdef __WXDEBUG__
+                                      _T(" Debug build"),
+#else
+                                      wxEmptyString,

 #endif
                                       __TDATE__,
                                       __TTIME__
                                      ),
 #endif
                                       __TDATE__,
                                       __TTIME__
                                      ),

-                     _T("wxWindows information"),
+                     _T("wxWidgets information"),

                      wxICON_INFORMATION | wxOK,
                      (wxWindow *)this);
     }
                      wxICON_INFORMATION | wxOK,
                      (wxWindow *)this);
     }


@@ -2172,15 +2340,22 @@ wxAccessible* wxWindowBase::CreateAccessible()
 
 #endif
 
 
 #endif
 

-#if !wxUSE_STL

 // ----------------------------------------------------------------------------
 // list classes implementation
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // list classes implementation
 // ----------------------------------------------------------------------------
 

+#if wxUSE_STL
+
+#include <wx/listimpl.cpp>
+WX_DEFINE_LIST(wxWindowList);
+
+#else
+

 void wxWindowListNode::DeleteData()
 {
     delete (wxWindow *)GetData();
 }
 void wxWindowListNode::DeleteData()
 {
     delete (wxWindow *)GetData();
 }

+

 #endif
 
 // ----------------------------------------------------------------------------
 #endif
 
 // ----------------------------------------------------------------------------


@@ -2350,6 +2525,68 @@ bool wxWindowBase::TryParent(wxEvent& event)
     return wxEvtHandler::TryParent(event);
 }
 
     return wxEvtHandler::TryParent(event);
 }
 

+// ----------------------------------------------------------------------------
+// keyboard navigation
+// ----------------------------------------------------------------------------
+
+// Navigates in the specified direction.
+bool wxWindowBase::Navigate(int flags)
+{
+    wxNavigationKeyEvent eventNav;
+    eventNav.SetFlags(flags);
+    eventNav.SetEventObject(this);
+    if ( GetParent()->GetEventHandler()->ProcessEvent(eventNav) )
+    {
+        return true;
+    }
+    return false;
+}
+
+void wxWindowBase::DoMoveInTabOrder(wxWindow *win, MoveKind move)
+{
+    // check that we're not a top level window
+    wxCHECK_RET( GetParent(),
+                    _T("MoveBefore/AfterInTabOrder() don't work for TLWs!") );
+
+    // detect the special case when we have nothing to do anyhow and when the
+    // code below wouldn't work
+    if ( win == this )
+        return;
+
+    // find the target window in the siblings list
+    wxWindowList& siblings = GetParent()->GetChildren();
+    wxWindowList::compatibility_iterator i = siblings.Find(win);
+    wxCHECK_RET( i, _T("MoveBefore/AfterInTabOrder(): win is not a sibling") );
+
+    // unfortunately, when wxUSE_STL == 1 DetachNode() is not implemented so we
+    // can't just move the node around
+    wxWindow *self = (wxWindow *)this;
+    siblings.DeleteObject(self);
+    if ( move == MoveAfter )
+    {
+        i = i->GetNext();
+    }
+
+    if ( i )
+    {
+        siblings.Insert(i, self);
+    }
+    else // MoveAfter and win was the last sibling
+    {
+        siblings.Append(self);
+    }
+}
+
+// ----------------------------------------------------------------------------
+// focus handling
+// ----------------------------------------------------------------------------
+
+/*static*/ wxWindow* wxWindowBase::FindFocus()
+{
+    wxWindowBase *win = DoFindFocus();
+    return win ? win->GetMainWindowOfCompositeControl() : NULL;
+}
+

 // ----------------------------------------------------------------------------
 // global functions
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // global functions
 // ----------------------------------------------------------------------------


@@ -2512,20 +2749,22 @@ wxAccStatus wxWindowAccessible::GetName(int childId, wxString* name)
 
     wxString title;
 
 
     wxString title;
 

-    // If a child, leave wxWindows to call the function on the actual
+    // If a child, leave wxWidgets to call the function on the actual

     // child object.
     if (childId > 0)
         return wxACC_NOT_IMPLEMENTED;
 
     // This will eventually be replaced by specialised
     // child object.
     if (childId > 0)
         return wxACC_NOT_IMPLEMENTED;
 
     // This will eventually be replaced by specialised

-    // accessible classes, one for each kind of wxWindows
+    // accessible classes, one for each kind of wxWidgets

     // control or window.
     // control or window.

+#if wxUSE_BUTTON

     if (GetWindow()->IsKindOf(CLASSINFO(wxButton)))
         title = ((wxButton*) GetWindow())->GetLabel();
     else
     if (GetWindow()->IsKindOf(CLASSINFO(wxButton)))
         title = ((wxButton*) GetWindow())->GetLabel();
     else

+#endif

         title = GetWindow()->GetName();
 
         title = GetWindow()->GetName();
 

-    if (!title.IsEmpty())
+    if (!title.empty())

     {
         *name = title;
         return wxACC_OK;
     {
         *name = title;
         return wxACC_OK;


@@ -2631,7 +2870,7 @@ wxAccStatus wxWindowAccessible::GetDescription(int WXUNUSED(childId), wxString*
         return wxACC_FAIL;
 
     wxString ht(GetWindow()->GetHelpText());
         return wxACC_FAIL;
 
     wxString ht(GetWindow()->GetHelpText());

-    if (!ht.IsEmpty())
+    if (!ht.empty())

     {
         *description = ht;
         return wxACC_OK;
     {
         *description = ht;
         return wxACC_OK;


@@ -2647,7 +2886,7 @@ wxAccStatus wxWindowAccessible::GetHelpText(int WXUNUSED(childId), wxString* hel
         return wxACC_FAIL;
 
     wxString ht(GetWindow()->GetHelpText());
         return wxACC_FAIL;
 
     wxString ht(GetWindow()->GetHelpText());

-    if (!ht.IsEmpty())
+    if (!ht.empty())

     {
         *helpText = ht;
         return wxACC_OK;
     {
         *helpText = ht;
         return wxACC_OK;


@@ -2673,7 +2912,7 @@ wxAccStatus wxWindowAccessible::GetRole(int childId, wxAccRole* role)
     if (!GetWindow())
         return wxACC_FAIL;
 
     if (!GetWindow())
         return wxACC_FAIL;
 

-    // If a child, leave wxWindows to call the function on the actual
+    // If a child, leave wxWidgets to call the function on the actual

     // child object.
     if (childId > 0)
         return wxACC_NOT_IMPLEMENTED;
     // child object.
     if (childId > 0)
         return wxACC_NOT_IMPLEMENTED;


@@ -2705,7 +2944,7 @@ wxAccStatus wxWindowAccessible::GetState(int childId, long* state)
     if (!GetWindow())
         return wxACC_FAIL;
 
     if (!GetWindow())
         return wxACC_FAIL;
 

-    // If a child, leave wxWindows to call the function on the actual
+    // If a child, leave wxWidgets to call the function on the actual

     // child object.
     if (childId > 0)
         return wxACC_NOT_IMPLEMENTED;
     // child object.
     if (childId > 0)
         return wxACC_NOT_IMPLEMENTED;


@@ -2767,7 +3006,7 @@ wxAccStatus wxWindowAccessible::GetFocus(int* WXUNUSED(childId), wxAccessible**
 // Gets a variant representing the selected children
 // of this object.
 // Acceptable values:
 // Gets a variant representing the selected children
 // of this object.
 // Acceptable values:

-// - a null variant (IsNull() returns TRUE)
+// - a null variant (IsNull() returns true)

 // - a list variant (GetType() == wxT("list")
 // - an integer representing the selected child element,
 //   or 0 if this object is selected (GetType() == wxT("long")
 // - a list variant (GetType() == wxT("list")
 // - an integer representing the selected child element,
 //   or 0 if this object is selected (GetType() == wxT("long")