]> git.saurik.com Git - wxWidgets.git/blobdiff - src/common/layout.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Added missing wxGetFullHostName() and wxNO_DEFAULT for generic msgdialog
[wxWidgets.git] / src / common / layout.cpp
diff --git a/src/common/layout.cpp b/src/common/layout.cpp
index 38750aceadaf33ca439cc0b01f292db829ee3a03..441a1217c007e815e8e2136c129803581fcadccb 100644 (file)
--- a/src/common/layout.cpp
+++ b/src/common/layout.cpp
@@ -6,40 +6,45 @@
 // Created:     04/01/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart and Markus Holzem
 // Created:     04/01/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart and Markus Holzem
-// Licence:    wxWindows license
+// Licence:       wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 
 /////////////////////////////////////////////////////////////////////////////
 
+// =============================================================================
+// declarations
+// =============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
 #ifdef __GNUG__
 #ifdef __GNUG__
-#pragma implementation "layout.h"
+    #pragma implementation "layout.h"
 #endif
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
 #endif
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
-#pragma hdrstop
+    #pragma hdrstop
 #endif
 
 #include "wx/defs.h"
 
 #endif
 
 #include "wx/defs.h"
 
-#if wxUSE_CONSTRAINTS
-
 #ifndef WX_PRECOMP
 #ifndef WX_PRECOMP
-#include "wx/window.h"
-#include "wx/utils.h"
-#include "wx/dialog.h"
-#include "wx/msgdlg.h"
-#include <wx/intl.h>
+    #include "wx/window.h"
+    #include "wx/utils.h"
+    #include "wx/dialog.h"
+    #include "wx/msgdlg.h"
+    #include "wx/intl.h"
 #endif
 
 #include "wx/layout.h"
 
 #if !USE_SHARED_LIBRARY
 #endif
 
 #include "wx/layout.h"
 
 #if !USE_SHARED_LIBRARY
-IMPLEMENT_DYNAMIC_CLASS(wxIndividualLayoutConstraint, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxLayoutConstraints, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxSizer, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxRowColSizer, wxSizer)
-IMPLEMENT_DYNAMIC_CLASS(wxSpacingSizer, wxSizer)
+    IMPLEMENT_DYNAMIC_CLASS(wxIndividualLayoutConstraint, wxObject)
+    IMPLEMENT_DYNAMIC_CLASS(wxLayoutConstraints, wxObject)
+    IMPLEMENT_DYNAMIC_CLASS(wxSizer, wxObject)
+    IMPLEMENT_DYNAMIC_CLASS(wxRowColSizer, wxSizer)
+    IMPLEMENT_DYNAMIC_CLASS(wxSpacingSizer, wxSizer)
 #endif
 
 /*
 #endif
 
 /*
@@ -66,948 +71,979 @@ TODO:
 */
 
 // Find margin sizes if a sizer, or zero otherwise
 */
 
 // Find margin sizes if a sizer, or zero otherwise
-int wxSizerMarginX(wxWindow *win)
+int wxSizerMarginX(wxWindowBase *win)
 {
 {
-       if ( win->IsKindOf(CLASSINFO(wxSizer)) )
-       {
-               wxSizer *sizer = (wxSizer *)win;
-               return sizer->GetBorderX();
-       }
-       else
-               return 0;
+    if ( win->IsKindOf(CLASSINFO(wxSizer)) )
+    {
+        wxSizer *sizer = (wxSizer *)win;
+        return sizer->GetBorderX();
+    }
+    else
+        return 0;
 }
 
 }
 
-int wxSizerMarginY(wxWindow *win)
+int wxSizerMarginY(wxWindowBase *win)
 {
 {
-       if ( win->IsKindOf(CLASSINFO(wxSizer)) )
-       {
-               wxSizer *sizer = (wxSizer *)win;
-               return sizer->GetBorderY();
-       }
-       else
-               return 0;
+    if ( win->IsKindOf(CLASSINFO(wxSizer)) )
+    {
+        wxSizer *sizer = (wxSizer *)win;
+        return sizer->GetBorderY();
+    }
+    else
+        return 0;
 }
 
 
 wxIndividualLayoutConstraint::wxIndividualLayoutConstraint()
 {
 }
 
 
 wxIndividualLayoutConstraint::wxIndividualLayoutConstraint()
 {
-  myEdge = wxTop; relationship = wxUnconstrained; margin = 0; value = 0; percent = 0; otherEdge = wxTop;
-  done = FALSE; otherWin = (wxWindow *) NULL;
+    myEdge = wxTop;
+    relationship = wxUnconstrained;
+    margin = 0;
+    value = 0;
+    percent = 0;
+    otherEdge = wxTop;
+    done = FALSE;
+    otherWin = (wxWindowBase *) NULL;
 }
 
 wxIndividualLayoutConstraint::~wxIndividualLayoutConstraint()
 {
 }
 
 }
 
 wxIndividualLayoutConstraint::~wxIndividualLayoutConstraint()
 {
 }
 
-void wxIndividualLayoutConstraint::Set(wxRelationship rel, wxWindow *otherW, wxEdge otherE, int val, int marg)
+void wxIndividualLayoutConstraint::Set(wxRelationship rel, wxWindowBase *otherW, wxEdge otherE, int val, int marg)
 {
 {
-  relationship = rel; otherWin = otherW; otherEdge = otherE; value = val; margin = marg;
+  relationship = rel;
+  otherWin = otherW;
+  otherEdge = otherE;
+  value = val;
+  margin = marg;
 }
 
 }
 
-void wxIndividualLayoutConstraint::LeftOf(wxWindow *sibling, int marg)
-{ Set(wxLeftOf, sibling, wxLeft, 0, marg); }
+void wxIndividualLayoutConstraint::LeftOf(wxWindowBase *sibling, int marg)
+{
+    Set(wxLeftOf, sibling, wxLeft, 0, marg);
+}
 
 
-void wxIndividualLayoutConstraint::RightOf(wxWindow *sibling, int marg)
-{ Set(wxRightOf, sibling, wxRight, 0, marg); }
+void wxIndividualLayoutConstraint::RightOf(wxWindowBase *sibling, int marg)
+{
+    Set(wxRightOf, sibling, wxRight, 0, marg);
+}
 
 
-void wxIndividualLayoutConstraint::Above(wxWindow *sibling, int marg)
-{ Set(wxAbove, sibling, wxTop, 0, marg); }
+void wxIndividualLayoutConstraint::Above(wxWindowBase *sibling, int marg)
+{
+    Set(wxAbove, sibling, wxTop, 0, marg);
+}
 
 
-void wxIndividualLayoutConstraint::Below(wxWindow *sibling, int marg)
-{ Set(wxBelow, sibling, wxBottom, 0, marg); }
+void wxIndividualLayoutConstraint::Below(wxWindowBase *sibling, int marg)
+{
+    Set(wxBelow, sibling, wxBottom, 0, marg);
+}
 
 //
 // 'Same edge' alignment
 //
 
 //
 // 'Same edge' alignment
 //
-void wxIndividualLayoutConstraint::SameAs(wxWindow *otherW, wxEdge edge, int marg)
-{ Set(wxPercentOf, otherW, edge, 0, marg); percent = 100; }
+void wxIndividualLayoutConstraint::SameAs(wxWindowBase *otherW, wxEdge edge, int marg)
+{ 
+    Set(wxPercentOf, otherW, edge, 0, marg);
+    percent = 100;
+}
 
 // The edge is a percentage of the other window's edge
 
 // The edge is a percentage of the other window's edge
-void wxIndividualLayoutConstraint::PercentOf(wxWindow *otherW, wxEdge wh, int per)
-{ otherWin = otherW; relationship = wxPercentOf; percent = per;
-  otherEdge = wh;
+void wxIndividualLayoutConstraint::PercentOf(wxWindowBase *otherW, wxEdge wh, int per)
+{ 
+    otherWin = otherW;
+    relationship = wxPercentOf;
+    percent = per;
+
+    otherEdge = wh;
 }
 
 //
 // Edge has absolute value
 //
 void wxIndividualLayoutConstraint::Absolute(int val)
 }
 
 //
 // Edge has absolute value
 //
 void wxIndividualLayoutConstraint::Absolute(int val)
-{ value = val; relationship = wxAbsolute; }
+{
+    value = val; relationship = wxAbsolute;
+}
 
 // Reset constraint if it mentions otherWin
 
 // Reset constraint if it mentions otherWin
-bool wxIndividualLayoutConstraint::ResetIfWin(wxWindow *otherW)
+bool wxIndividualLayoutConstraint::ResetIfWin(wxWindowBase *otherW)
 {
 {
-  if (otherW == otherWin)
-  {
-    myEdge = wxTop; relationship = wxAsIs; margin = 0; value = 0; percent = 0; otherEdge = wxTop;
-    otherWin = (wxWindow *) NULL;
-    return TRUE;
-  }
-  else
-    return FALSE;
+    if (otherW == otherWin)
+    {
+        myEdge = wxTop;
+        relationship = wxAsIs;
+        margin = 0;
+        value = 0;
+        percent = 0;
+        otherEdge = wxTop;
+        otherWin = (wxWindowBase *) NULL;
+        return TRUE;
+    }
+    else
+        return FALSE;
 }
 
 // Try to satisfy constraint
 }
 
 // Try to satisfy constraint
-bool wxIndividualLayoutConstraint::SatisfyConstraint(wxLayoutConstraints *constraints, wxWindow *win)
+bool wxIndividualLayoutConstraint::SatisfyConstraint(wxLayoutConstraints *constraints, wxWindowBase *win)
 {
 {
-  if (relationship == wxAbsolute)
-  {
-    done = TRUE;
-    return TRUE;
-  }
-  
-  switch (myEdge)
-  {
-    case wxLeft:
-    {
-      switch (relationship)
-      {
-        case wxLeftOf:
-        {
-          // We can know this edge if: otherWin is win's parent,
-          // or otherWin has a satisfied constraint, or
-          // otherWin has no constraint.
-          int edgePos = GetEdge(otherEdge, win, otherWin);
-          if (edgePos != -1)
-          {
-            value = edgePos - margin;
-            done = TRUE;
-            return TRUE;
-          }
-          else
-            return FALSE;
-        }
-        case wxRightOf:
-        {
-          int edgePos = GetEdge(otherEdge, win, otherWin);
-          if (edgePos != -1)
-          {
-            value = edgePos + margin;
-            done = TRUE;
-            return TRUE;
-          }
-          else
-            return FALSE;
-        }
-        case wxPercentOf:
-        {
-          int edgePos = GetEdge(otherEdge, win, otherWin);
-          if (edgePos != -1)
-          {
-            value = (int)(edgePos*(((float)percent)*0.01) + margin);
-            done = TRUE;
-            return TRUE;
-          }
-          else
-            return FALSE;
-        }
-        case wxUnconstrained:
-        {
-          // We know the left-hand edge position if we know
-          // the right-hand edge and we know the width; OR if we know the centre and the width.
-          if (constraints->right.GetDone() && constraints->width.GetDone())
-          {
-            value = (constraints->right.GetValue() - constraints->width.GetValue() + margin);
-            done = TRUE;
-            return TRUE;
-          }
-          else if (constraints->centreX.GetDone() && constraints->width.GetDone())
-          {
-            value = (int)(constraints->centreX.GetValue() - (constraints->width.GetValue()/2) + margin);
-            done = TRUE;
-            return TRUE;
-          }
-          else
-            return FALSE;
-        }
-        case wxAsIs:
-        {
-          int y;
-          win->GetPosition(&value, &y);
-          done = TRUE;
-          return TRUE;
-        }
-        default:
-          break;
-      }
-      break;
-    }
-    case wxRight:
+    if (relationship == wxAbsolute)
     {
     {
-      switch (relationship)
-      {
-        case wxLeftOf:
-        {
-          // We can know this edge if: otherWin is win's parent,
-          // or otherWin has a satisfied constraint, or
-          // otherWin has no constraint.
-          int edgePos = GetEdge(otherEdge, win, otherWin);
-          if (edgePos != -1)
-          {
-            value = edgePos - margin;
-            done = TRUE;
-            return TRUE;
-          }
-          else
-            return FALSE;
-        }
-        case wxRightOf:
-        {
-          int edgePos = GetEdge(otherEdge, win, otherWin);
-          if (edgePos != -1)
-          {
-            value = edgePos + margin;
-            done = TRUE;
-            return TRUE;
-          }
-          else
-            return FALSE;
-        }
-        case wxPercentOf:
-        {
-          int edgePos = GetEdge(otherEdge, win, otherWin);
-          if (edgePos != -1)
-          {
-            value = (int)(edgePos*(((float)percent)*0.01) - margin);
-            done = TRUE;
-            return TRUE;
-          }
-          else
-            return FALSE;
-        }
-        case wxUnconstrained:
-        {
-          // We know the right-hand edge position if we know
-          // the left-hand edge and we know the width, OR if we know the
-          // centre edge and the width.
-          if (constraints->left.GetDone() && constraints->width.GetDone())
-          {
-            value = (constraints->left.GetValue() + constraints->width.GetValue() - margin);
-            done = TRUE;
-            return TRUE;
-          }
-          else if (constraints->centreX.GetDone() && constraints->width.GetDone())
-          {
-            value = (int)(constraints->centreX.GetValue() + (constraints->width.GetValue()/2) - margin);
-            done = TRUE;
-            return TRUE;
-          }
-          else
-            return FALSE;
-        }
-        case wxAsIs:
-        {
-          int x, y;
-          int w, h;
-          win->GetSize(&w, &h);
-          win->GetPosition(&x, &y);
-          value = x + w;
-          done = TRUE;
-          return TRUE;
-        }
-        default:
-          break;
-      }
-      break;
-    }
-    case wxTop:
-    {
-      switch (relationship)
-      {
-        case wxAbove:
-        {
-          // We can know this edge if: otherWin is win's parent,
-          // or otherWin has a satisfied constraint, or
-          // otherWin has no constraint.
-          int edgePos = GetEdge(otherEdge, win, otherWin);
-          if (edgePos != -1)
-          {
-            value = edgePos - margin;
-            done = TRUE;
-            return TRUE;
-          }
-          else
-            return FALSE;
-        }
-        case wxBelow:
-        {
-          int edgePos = GetEdge(otherEdge, win, otherWin);
-          if (edgePos != -1)
-          {
-            value = edgePos + margin;
-            done = TRUE;
-            return TRUE;
-          }
-          else
-            return FALSE;
-        }
-        case wxPercentOf:
-        {
-          int edgePos = GetEdge(otherEdge, win, otherWin);
-          if (edgePos != -1)
-          {
-            value = (int)(edgePos*(((float)percent)*0.01) + margin);
-            done = TRUE;
-            return TRUE;
-          }
-          else
-            return FALSE;
-        }
-        case wxUnconstrained:
-        {
-          // We know the top edge position if we know
-          // the bottom edge and we know the height; OR if we know the centre
-          // edge and the height.
-          if (constraints->bottom.GetDone() && constraints->height.GetDone())
-          {
-            value = (constraints->bottom.GetValue() - constraints->height.GetValue() + margin);
-            done = TRUE;
-            return TRUE;
-          }
-          else if (constraints->centreY.GetDone() && constraints->height.GetDone())
-          {
-            value = (constraints->centreY.GetValue() - (constraints->height.GetValue()/2) + margin);
-            done = TRUE;
-            return TRUE;
-          }
-          else
-            return FALSE;
-        }
-        case wxAsIs:
-        {
-          int x;
-          win->GetPosition(&x, &value);
-          done = TRUE;
-          return TRUE;
-        }
-        default:
-          break;
-      }
-      break;
-    }
-    case wxBottom:
-    {
-      switch (relationship)
-      {
-        case wxAbove:
-        {
-          // We can know this edge if: otherWin is win's parent,
-          // or otherWin has a satisfied constraint, or
-          // otherWin has no constraint.
-          int edgePos = GetEdge(otherEdge, win, otherWin);
-          if (edgePos != -1)
-          {
-            value = edgePos + margin;
-            done = TRUE;
-            return TRUE;
-          }
-          else
-            return FALSE;
-        }
-        case wxBelow:
-        {
-          int edgePos = GetEdge(otherEdge, win, otherWin);
-          if (edgePos != -1)
-          {
-            value = edgePos - margin;
-            done = TRUE;
-            return TRUE;
-          }
-          else
-            return FALSE;
-        }
-        case wxPercentOf:
-        {
-          int edgePos = GetEdge(otherEdge, win, otherWin);
-          if (edgePos != -1)
-          {
-            value = (int)(edgePos*(((float)percent)*0.01) - margin);
-            done = TRUE;
-            return TRUE;
-          }
-          else
-            return FALSE;
-        }
-        case wxUnconstrained:
-        {
-          // We know the bottom edge position if we know
-          // the top edge and we know the height; OR if we know the
-          // centre edge and the height.
-          if (constraints->top.GetDone() && constraints->height.GetDone())
-          {
-            value = (constraints->top.GetValue() + constraints->height.GetValue() - margin);
-            done = TRUE;
-            return TRUE;
-          }
-          else if (constraints->centreY.GetDone() && constraints->height.GetDone())
-          {
-            value = (constraints->centreY.GetValue() + (constraints->height.GetValue()/2) - margin);
-            done = TRUE;
-            return TRUE;
-          }
-          else
-            return FALSE;
-        }
-        case wxAsIs:
-        {
-          int x, y;
-          int w, h;
-          win->GetSize(&w, &h);
-          win->GetPosition(&x, &y);
-          value = h + y;
-          done = TRUE;
-          return TRUE;
-        }
-        default:
-          break;
-      }
-      break;
-    }
-    case wxCentreX:
-    {
-      switch (relationship)
-      {
-        case wxLeftOf:
-        {
-          // We can know this edge if: otherWin is win's parent,
-          // or otherWin has a satisfied constraint, or
-          // otherWin has no constraint.
-          int edgePos = GetEdge(otherEdge, win, otherWin);
-          if (edgePos != -1)
-          {
-            value = edgePos - margin;
-            done = TRUE;
-            return TRUE;
-          }
-          else
-            return FALSE;
-        }
-        case wxRightOf:
-        {
-          int edgePos = GetEdge(otherEdge, win, otherWin);
-          if (edgePos != -1)
-          {
-            value = edgePos + margin;
-            done = TRUE;
-            return TRUE;
-          }
-          else
-            return FALSE;
-        }
-        case wxPercentOf:
-        {
-          int edgePos = GetEdge(otherEdge, win, otherWin);
-          if (edgePos != -1)
-          {
-            value = (int)(edgePos*(((float)percent)*0.01) + margin);
-            done = TRUE;
-            return TRUE;
-          }
-          else
-            return FALSE;
-        }
-        case wxUnconstrained:
-        {
-          // We know the centre position if we know
-          // the left-hand edge and we know the width, OR
-          // the right-hand edge and the width
-          if (constraints->left.GetDone() && constraints->width.GetDone())
-          {
-            value = (int)(constraints->left.GetValue() + (constraints->width.GetValue()/2) + margin);
-            done = TRUE;
-            return TRUE;
-          }
-          else if (constraints->right.GetDone() && constraints->width.GetDone())
-          {
-            value = (int)(constraints->left.GetValue() - (constraints->width.GetValue()/2) + margin);
-            done = TRUE;
-            return TRUE;
-          }
-          else
-            return FALSE;
-        }
-        default:
-          break;
-      }
-      break;
+        done = TRUE;
+        return TRUE;
     }
     }
-    case wxCentreY:
+
+    switch (myEdge)
     {
     {
-      switch (relationship)
-      {
-        case wxAbove:
+        case wxLeft:
         {
         {
-          // We can know this edge if: otherWin is win's parent,
-          // or otherWin has a satisfied constraint, or
-          // otherWin has no constraint.
-          int edgePos = GetEdge(otherEdge, win, otherWin);
-          if (edgePos != -1)
-          {
-            value = edgePos - margin;
-            done = TRUE;
-            return TRUE;
-          }
-          else
-            return FALSE;
+            switch (relationship)
+            {
+                case wxLeftOf:
+                {
+                    // We can know this edge if: otherWin is win's
+                    // parent, or otherWin has a satisfied constraint,
+                    // or otherWin has no constraint.
+                    int edgePos = GetEdge(otherEdge, win, otherWin);
+                    if (edgePos != -1)
+                    {
+                        value = edgePos - margin;
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else
+                        return FALSE;
+                }
+                case wxRightOf:
+                {
+                    int edgePos = GetEdge(otherEdge, win, otherWin);
+                    if (edgePos != -1)
+                    {
+                        value = edgePos + margin;
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else
+                        return FALSE;
+                }
+                case wxPercentOf:
+                {
+                    int edgePos = GetEdge(otherEdge, win, otherWin);
+                    if (edgePos != -1)
+                    {
+                        value = (int)(edgePos*(((float)percent)*0.01) + margin);
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else
+                        return FALSE;
+                }
+                case wxUnconstrained:
+                {
+                    // We know the left-hand edge position if we know
+                    // the right-hand edge and we know the width; OR if
+                    // we know the centre and the width.
+                    if (constraints->right.GetDone() && constraints->width.GetDone())
+                    {
+                        value = (constraints->right.GetValue() - constraints->width.GetValue() + margin);
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else if (constraints->centreX.GetDone() && constraints->width.GetDone())
+                    {
+                        value = (int)(constraints->centreX.GetValue() - (constraints->width.GetValue()/2) + margin);
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else
+                        return FALSE;
+                }
+                case wxAsIs:
+                {
+                    int y;
+                    win->GetPosition(&value, &y);
+                    done = TRUE;
+                    return TRUE;
+                }
+                default:
+                    break;
+            }
+            break;
         }
         }
-        case wxBelow:
+        case wxRight:
         {
         {
-          int edgePos = GetEdge(otherEdge, win, otherWin);
-          if (edgePos != -1)
-          {
-            value = edgePos + margin;
-            done = TRUE;
-            return TRUE;
-          }
-          else
-            return FALSE;
+            switch (relationship)
+            {
+                case wxLeftOf:
+                {
+                    // We can know this edge if: otherWin is win's
+                    // parent, or otherWin has a satisfied constraint,
+                    // or otherWin has no constraint.
+                    int edgePos = GetEdge(otherEdge, win, otherWin);
+                    if (edgePos != -1)
+                    {
+                        value = edgePos - margin;
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else
+                        return FALSE;
+                }
+                case wxRightOf:
+                {
+                    int edgePos = GetEdge(otherEdge, win, otherWin);
+                    if (edgePos != -1)
+                    {
+                        value = edgePos + margin;
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else
+                        return FALSE;
+                }
+                case wxPercentOf:
+                {
+                    int edgePos = GetEdge(otherEdge, win, otherWin);
+                    if (edgePos != -1)
+                    {
+                        value = (int)(edgePos*(((float)percent)*0.01) - margin);
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else
+                        return FALSE;
+                }
+                case wxUnconstrained:
+                {
+                    // We know the right-hand edge position if we know the
+                    // left-hand edge and we know the width, OR if we know the
+                    // centre edge and the width.
+                    if (constraints->left.GetDone() && constraints->width.GetDone())
+                    {
+                        value = (constraints->left.GetValue() + constraints->width.GetValue() - margin);
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else if (constraints->centreX.GetDone() && constraints->width.GetDone())
+                    {
+                        value = (int)(constraints->centreX.GetValue() + (constraints->width.GetValue()/2) - margin);
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else
+                        return FALSE;
+                }
+                case wxAsIs:
+                {
+                    int x, y;
+                    int w, h;
+                    win->GetSize(&w, &h);
+                    win->GetPosition(&x, &y);
+                    value = x + w;
+                    done = TRUE;
+                    return TRUE;
+                }
+                default:
+                    break;
+            }
+            break;
         }
         }
-        case wxPercentOf:
+        case wxTop:
         {
         {
-          int edgePos = GetEdge(otherEdge, win, otherWin);
-          if (edgePos != -1)
-          {
-            value = (int)(edgePos*(((float)percent)*0.01) + margin);
-            done = TRUE;
-            return TRUE;
-          }
-          else
-            return FALSE;
+            switch (relationship)
+            {
+                case wxAbove:
+                {
+                    // We can know this edge if: otherWin is win's
+                    // parent, or otherWin has a satisfied constraint,
+                    // or otherWin has no constraint.
+                    int edgePos = GetEdge(otherEdge, win, otherWin);
+                    if (edgePos != -1)
+                    {
+                        value = edgePos - margin;
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else
+                        return FALSE;
+                }
+                case wxBelow:
+                {
+                    int edgePos = GetEdge(otherEdge, win, otherWin);
+                    if (edgePos != -1)
+                    {
+                        value = edgePos + margin;
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else
+                        return FALSE;
+                }
+                case wxPercentOf:
+                {
+                    int edgePos = GetEdge(otherEdge, win, otherWin);
+                    if (edgePos != -1)
+                    {
+                        value = (int)(edgePos*(((float)percent)*0.01) + margin);
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else
+                        return FALSE;
+                }
+                case wxUnconstrained:
+                {
+                    // We know the top edge position if we know the bottom edge
+                    // and we know the height; OR if we know the centre edge and
+                    // the height.
+                    if (constraints->bottom.GetDone() && constraints->height.GetDone())
+                    {
+                        value = (constraints->bottom.GetValue() - constraints->height.GetValue() + margin);
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else if (constraints->centreY.GetDone() && constraints->height.GetDone())
+                    {
+                        value = (constraints->centreY.GetValue() - (constraints->height.GetValue()/2) + margin);
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else
+                        return FALSE;
+                }
+                case wxAsIs:
+                {
+                    int x;
+                    win->GetPosition(&x, &value);
+                    done = TRUE;
+                    return TRUE;
+                }
+                default:
+                    break;
+            }
+            break;
         }
         }
-        case wxUnconstrained:
+        case wxBottom:
         {
         {
-          // We know the centre position if we know
-          // the top edge and we know the height, OR
-          // the bottom edge and the height.
-          if (constraints->bottom.GetDone() && constraints->height.GetDone())
-          {
-            value = (int)(constraints->bottom.GetValue() - (constraints->height.GetValue()/2) + margin);
-            done = TRUE;
-            return TRUE;
-          }
-          else if (constraints->top.GetDone() && constraints->height.GetDone())
-          {
-            value = (int)(constraints->top.GetValue() + (constraints->height.GetValue()/2) + margin);
-            done = TRUE;
-            return TRUE;
-          }
-          else
-            return FALSE;
+            switch (relationship)
+            {
+                case wxAbove:
+                {
+                    // We can know this edge if: otherWin is win's parent,
+                    // or otherWin has a satisfied constraint, or
+                    // otherWin has no constraint.
+                    int edgePos = GetEdge(otherEdge, win, otherWin);
+                    if (edgePos != -1)
+                    {
+                        value = edgePos + margin;
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else
+                        return FALSE;
+                }
+                case wxBelow:
+                {
+                    int edgePos = GetEdge(otherEdge, win, otherWin);
+                    if (edgePos != -1)
+                    {
+                        value = edgePos - margin;
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else
+                        return FALSE;
+                }
+                case wxPercentOf:
+                {
+                    int edgePos = GetEdge(otherEdge, win, otherWin);
+                    if (edgePos != -1)
+                    {
+                        value = (int)(edgePos*(((float)percent)*0.01) - margin);
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else
+                        return FALSE;
+                }
+                case wxUnconstrained:
+                {
+                    // We know the bottom edge position if we know the top edge
+                    // and we know the height; OR if we know the centre edge and
+                    // the height.
+                    if (constraints->top.GetDone() && constraints->height.GetDone())
+                    {
+                        value = (constraints->top.GetValue() + constraints->height.GetValue() - margin);
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else if (constraints->centreY.GetDone() && constraints->height.GetDone())
+                    {
+                        value = (constraints->centreY.GetValue() + (constraints->height.GetValue()/2) - margin);
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else
+                        return FALSE;
+                }
+                case wxAsIs:
+                {
+                    int x, y;
+                    int w, h;
+                    win->GetSize(&w, &h);
+                    win->GetPosition(&x, &y);
+                    value = h + y;
+                    done = TRUE;
+                    return TRUE;
+                }
+                default:
+                    break;
+            }
+            break;
         }
         }
-        default:
-          break;
-      }
-      break;
-    }
-    case wxWidth:
-    {
-      switch (relationship)
-      {
-        case wxPercentOf:
+        case wxCentreX:
         {
         {
-          int edgePos = GetEdge(otherEdge, win, otherWin);
-          if (edgePos != -1)
-          {
-            value = (int)(edgePos*(((float)percent)*0.01));
-            done = TRUE;
-            return TRUE;
-          }
-          else
-            return FALSE;
+            switch (relationship)
+            {
+                case wxLeftOf:
+                {
+                    // We can know this edge if: otherWin is win's parent, or
+                    // otherWin has a satisfied constraint, or otherWin has no
+                    // constraint.
+                    int edgePos = GetEdge(otherEdge, win, otherWin);
+                    if (edgePos != -1)
+                    {
+                        value = edgePos - margin;
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else
+                        return FALSE;
+                }
+                case wxRightOf:
+                {
+                    int edgePos = GetEdge(otherEdge, win, otherWin);
+                    if (edgePos != -1)
+                    {
+                        value = edgePos + margin;
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else
+                        return FALSE;
+                }
+                case wxPercentOf:
+                {
+                    int edgePos = GetEdge(otherEdge, win, otherWin);
+                    if (edgePos != -1)
+                    {
+                        value = (int)(edgePos*(((float)percent)*0.01) + margin);
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else
+                        return FALSE;
+                }
+                case wxUnconstrained:
+                {
+                    // We know the centre position if we know
+                    // the left-hand edge and we know the width, OR
+                    // the right-hand edge and the width
+                    if (constraints->left.GetDone() && constraints->width.GetDone())
+                    {
+                        value = (int)(constraints->left.GetValue() + (constraints->width.GetValue()/2) + margin);
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else if (constraints->right.GetDone() && constraints->width.GetDone())
+                    {
+                        value = (int)(constraints->left.GetValue() - (constraints->width.GetValue()/2) + margin);
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else
+                        return FALSE;
+                }
+                default:
+                    break;
+            }
+            break;
         }
         }
-        case wxAsIs:
-        {
-          if (win)
-          {
-            int h;
-            win->GetSize(&value, &h);
-            done = TRUE;
-            return TRUE;
-          }
-          else return FALSE;
-        }
-        case wxUnconstrained:
-        {
-          // We know the width if we know the left edge and the right edge, OR
-          // if we know the left edge and the centre, OR
-          // if we know the right edge and the centre
-          if (constraints->left.GetDone() && constraints->right.GetDone())
-          {
-            value = constraints->right.GetValue() - constraints->left.GetValue();
-            done = TRUE;
-            return TRUE;
-          }
-          else if (constraints->centreX.GetDone() && constraints->left.GetDone())
-          {
-            value = (int)(2*(constraints->centreX.GetValue() - constraints->left.GetValue()));
-            done = TRUE;
-            return TRUE;
-          }
-          else if (constraints->centreX.GetDone() && constraints->right.GetDone())
-          {
-            value = (int)(2*(constraints->right.GetValue() - constraints->centreX.GetValue()));
-            done = TRUE;
-            return TRUE;
-          }
-          else
-            return FALSE;
-        }
-        default:
-          break;
-      }
-      break;
-    }
-    case wxHeight:
-    {
-      switch (relationship)
-      {
-        case wxPercentOf:
+        case wxCentreY:
         {
         {
-          int edgePos = GetEdge(otherEdge, win, otherWin);
-          if (edgePos != -1)
-          {
-            value = (int)(edgePos*(((float)percent)*0.01));
-            done = TRUE;
-            return TRUE;
-          }
-          else
-            return FALSE;
+            switch (relationship)
+            {
+                case wxAbove:
+                {
+                    // We can know this edge if: otherWin is win's parent,
+                    // or otherWin has a satisfied constraint, or otherWin
+                    // has no constraint.
+                    int edgePos = GetEdge(otherEdge, win, otherWin);
+                    if (edgePos != -1)
+                    {
+                        value = edgePos - margin;
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else
+                        return FALSE;
+                }
+                case wxBelow:
+                {
+                    int edgePos = GetEdge(otherEdge, win, otherWin);
+                    if (edgePos != -1)
+                    {
+                        value = edgePos + margin;
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else
+                        return FALSE;
+                }
+                case wxPercentOf:
+                {
+                    int edgePos = GetEdge(otherEdge, win, otherWin);
+                    if (edgePos != -1)
+                    {
+                        value = (int)(edgePos*(((float)percent)*0.01) + margin);
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else
+                        return FALSE;
+                }
+                case wxUnconstrained:
+                {
+                    // We know the centre position if we know
+                    // the top edge and we know the height, OR
+                    // the bottom edge and the height.
+                    if (constraints->bottom.GetDone() && constraints->height.GetDone())
+                    {
+                        value = (int)(constraints->bottom.GetValue() - (constraints->height.GetValue()/2) + margin);
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else if (constraints->top.GetDone() && constraints->height.GetDone())
+                    {
+                        value = (int)(constraints->top.GetValue() + (constraints->height.GetValue()/2) + margin);
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else
+                        return FALSE;
+                }
+                default:
+                    break;
+            }
+            break;
         }
         }
-        case wxAsIs:
+        case wxWidth:
         {
         {
-          if (win)
-          {
-            int w;
-            win->GetSize(&w, &value);
-            done = TRUE;
-            return TRUE;
-          }
-          else return FALSE;
+            switch (relationship)
+            {
+                case wxPercentOf:
+                {
+                    int edgePos = GetEdge(otherEdge, win, otherWin);
+                    if (edgePos != -1)
+                    {
+                        value = (int)(edgePos*(((float)percent)*0.01));
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else
+                        return FALSE;
+                }
+                case wxAsIs:
+                {
+                    if (win)
+                    {
+                        int h;
+                        win->GetSize(&value, &h);
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else return FALSE;
+                }
+                case wxUnconstrained:
+                {
+                    // We know the width if we know the left edge and the right edge, OR
+                    // if we know the left edge and the centre, OR
+                    // if we know the right edge and the centre
+                    if (constraints->left.GetDone() && constraints->right.GetDone())
+                    {
+                        value = constraints->right.GetValue() - constraints->left.GetValue();
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else if (constraints->centreX.GetDone() && constraints->left.GetDone())
+                    {
+                        value = (int)(2*(constraints->centreX.GetValue() - constraints->left.GetValue()));
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else if (constraints->centreX.GetDone() && constraints->right.GetDone())
+                    {
+                        value = (int)(2*(constraints->right.GetValue() - constraints->centreX.GetValue()));
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else
+                        return FALSE;
+                }
+                default:
+                    break;
+            }
+            break;
         }
         }
-        case wxUnconstrained:
+        case wxHeight:
         {
         {
-          // We know the height if we know the top edge and the bottom edge, OR
-          // if we know the top edge and the centre, OR
-          // if we know the bottom edge and the centre
-          if (constraints->top.GetDone() && constraints->bottom.GetDone())
-          {
-            value = constraints->bottom.GetValue() - constraints->top.GetValue();
-            done = TRUE;
-            return TRUE;
-          }
-          else if (constraints->top.GetDone() && constraints->centreY.GetDone())
-          {
-            value = (int)(2*(constraints->centreY.GetValue() - constraints->top.GetValue()));
-            done = TRUE;
-            return TRUE;
-          }
-          else if (constraints->bottom.GetDone() && constraints->centreY.GetDone())
-          {
-            value = (int)(2*(constraints->bottom.GetValue() - constraints->centreY.GetValue()));
-            done = TRUE;
-            return TRUE;
-          }
-          else
-            return FALSE;
+            switch (relationship)
+            {
+                case wxPercentOf:
+                {
+                    int edgePos = GetEdge(otherEdge, win, otherWin);
+                    if (edgePos != -1)
+                    {
+                        value = (int)(edgePos*(((float)percent)*0.01));
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else
+                        return FALSE;
+                }
+                case wxAsIs:
+                {
+                    if (win)
+                    {
+                        int w;
+                        win->GetSize(&w, &value);
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else return FALSE;
+                }
+                case wxUnconstrained:
+                {
+                    // We know the height if we know the top edge and the bottom edge, OR
+                    // if we know the top edge and the centre, OR
+                    // if we know the bottom edge and the centre
+                    if (constraints->top.GetDone() && constraints->bottom.GetDone())
+                    {
+                        value = constraints->bottom.GetValue() - constraints->top.GetValue();
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else if (constraints->top.GetDone() && constraints->centreY.GetDone())
+                    {
+                        value = (int)(2*(constraints->centreY.GetValue() - constraints->top.GetValue()));
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else if (constraints->bottom.GetDone() && constraints->centreY.GetDone())
+                    {
+                        value = (int)(2*(constraints->bottom.GetValue() - constraints->centreY.GetValue()));
+                        done = TRUE;
+                        return TRUE;
+                    }
+                    else
+                        return FALSE;
+                }
+                default:
+                    break;
+            }
+            break;
         }
         default:
         }
         default:
-          break;
-      }
-      break;
+            break;
     }
     }
-    default:
-      break;
-  }
-  return FALSE;
+    return FALSE;
 }
 
 }
 
-// Get the value of this edge or dimension, or if this
-// is not determinable, -1.
+// Get the value of this edge or dimension, or if this is not determinable, -1.
 int wxIndividualLayoutConstraint::GetEdge(wxEdge which,
 int wxIndividualLayoutConstraint::GetEdge(wxEdge which,
-                                          wxWindow *thisWin,
-                                          wxWindow *other) const
+                                          wxWindowBase *thisWin,
+                                          wxWindowBase *other) const
 {
 {
-  // If the edge or dimension belongs to the parent, then we
-  // know the dimension is obtainable immediately.
-  // E.g. a wxExpandSizer may contain a button (but the button's
-  // true parent is a panel, not the sizer)
-  if (other->GetChildren().Member(thisWin))
-  {
-    switch (which)
-    {
-      case wxLeft:
-         {
-               return wxSizerMarginX(other);
-         }
-      case wxTop:
-      {
-        return wxSizerMarginY(other);
-      }
-      case wxRight:
-         {
-        int w, h;
-        other->GetClientSizeConstraint(&w, &h);
-        return w - wxSizerMarginX(other);
-         }
-      case wxBottom:
-         {
-        int w, h;
-        other->GetClientSizeConstraint(&w, &h);
-        return h - wxSizerMarginY(other);
-         }
-      case wxWidth:
-         {
-        int w, h;
-        other->GetClientSizeConstraint(&w, &h);
-        return w - 2*wxSizerMarginX(other);
-         }
-      case wxHeight:
-      {
-        int w, h;
-        other->GetClientSizeConstraint(&w, &h);
-        return h - 2*wxSizerMarginY(other);
-      }
-      case wxCentreX:
-      case wxCentreY:
-      {
-        int w, h;
-        other->GetClientSizeConstraint(&w, &h);
-        if (which == wxCentreX)
-          return (int)(w/2);
-        else
-          return (int)(h/2);
-      }
-      default:
-        return -1;
-    }
-  }
-  switch (which)
-  {
-    case wxLeft:
-    {
-      wxLayoutConstraints *constr = other->GetConstraints();
-      // If no constraints, it means the window is not dependent
-      // on anything, and therefore we know its value immediately
-      if (constr)
-      {
-        if (constr->left.GetDone())
-          return constr->left.GetValue();
-        else
-          return -1;
-      }
-      else
-      {
-        int x, y;
-        other->GetPosition(&x, &y);
-        return x;
-      }
-    }
-    case wxTop:
-    {
-      wxLayoutConstraints *constr = other->GetConstraints();
-      // If no constraints, it means the window is not dependent
-      // on anything, and therefore we know its value immediately
-      if (constr)
-      {
-        if (constr->top.GetDone())
-          return constr->top.GetValue();
-        else
-          return -1;
-      }
-      else
-      {
-        int x, y;
-        other->GetPosition(&x, &y);
-        return y;
-      }
-    }
-    case wxRight:
-    {
-      wxLayoutConstraints *constr = other->GetConstraints();
-      // If no constraints, it means the window is not dependent
-      // on anything, and therefore we know its value immediately
-      if (constr)
-      {
-        if (constr->right.GetDone())
-          return constr->right.GetValue();
-        else
-          return -1;
-      }
-      else
-      {
-        int x, y, w, h;
-        other->GetPosition(&x, &y);
-        other->GetSize(&w, &h);
-        return (int)(x + w);
-      }
-    }
-    case wxBottom:
-    {
-      wxLayoutConstraints *constr = other->GetConstraints();
-      // If no constraints, it means the window is not dependent
-      // on anything, and therefore we know its value immediately
-      if (constr)
-      {
-        if (constr->bottom.GetDone())
-          return constr->bottom.GetValue();
-        else
-          return -1;
-      }
-      else
-      {
-        int x, y, w, h;
-        other->GetPosition(&x, &y);
-        other->GetSize(&w, &h);
-        return (int)(y + h);
-      }
-    }
-    case wxWidth:
-    {
-      wxLayoutConstraints *constr = other->GetConstraints();
-      // If no constraints, it means the window is not dependent
-      // on anything, and therefore we know its value immediately
-      if (constr)
-      {
-        if (constr->width.GetDone())
-          return constr->width.GetValue();
-        else
-          return -1;
-      }
-      else
-      {
-        int w, h;
-        other->GetSize(&w, &h);
-        return w;
-      }
-    }
-    case wxHeight:
-    {
-      wxLayoutConstraints *constr = other->GetConstraints();
-      // If no constraints, it means the window is not dependent
-      // on anything, and therefore we know its value immediately
-      if (constr)
-      {
-        if (constr->height.GetDone())
-          return constr->height.GetValue();
-        else
-          return -1;
-      }
-      else
-      {
-        int w, h;
-        other->GetSize(&w, &h);
-        return h;
-      }
-    }
-    case wxCentreX:
+    // If the edge or dimension belongs to the parent, then we know the
+    // dimension is obtainable immediately. E.g. a wxExpandSizer may contain a
+    // button (but the button's true parent is a panel, not the sizer)
+    if (other->GetChildren().Find(thisWin))
     {
     {
-      wxLayoutConstraints *constr = other->GetConstraints();
-      // If no constraints, it means the window is not dependent
-      // on anything, and therefore we know its value immediately
-      if (constr)
-      {
-        if (constr->centreX.GetDone())
-          return constr->centreX.GetValue();
-        else
-          return -1;
-      }
-      else
-      {
-        int x, y, w, h;
-        other->GetPosition(&x, &y);
-        other->GetSize(&w, &h);
-        return (int)(x + (w/2));
-      }
+        switch (which)
+        {
+            case wxLeft:
+                {
+                    return wxSizerMarginX(other);
+                }
+            case wxTop:
+                {
+                    return wxSizerMarginY(other);
+                }
+            case wxRight:
+                {
+                    int w, h;
+                    other->GetClientSizeConstraint(&w, &h);
+                    return w - wxSizerMarginX(other);
+                }
+            case wxBottom:
+                {
+                    int w, h;
+                    other->GetClientSizeConstraint(&w, &h);
+                    return h - wxSizerMarginY(other);
+                }
+            case wxWidth:
+                {
+                    int w, h;
+                    other->GetClientSizeConstraint(&w, &h);
+                    return w - 2*wxSizerMarginX(other);
+                }
+            case wxHeight:
+                {
+                    int w, h;
+                    other->GetClientSizeConstraint(&w, &h);
+                    return h - 2*wxSizerMarginY(other);
+                }
+            case wxCentreX:
+            case wxCentreY:
+                {
+                    int w, h;
+                    other->GetClientSizeConstraint(&w, &h);
+                    if (which == wxCentreX)
+                        return (int)(w/2);
+                    else
+                        return (int)(h/2);
+                }
+            default:
+                return -1;
+        }
     }
     }
-    case wxCentreY:
+    switch (which)
     {
     {
-      wxLayoutConstraints *constr = other->GetConstraints();
-      // If no constraints, it means the window is not dependent
-      // on anything, and therefore we know its value immediately
-      if (constr)
-      {
-        if (constr->centreY.GetDone())
-          return constr->centreY.GetValue();
-        else
-          return -1;
-      }
-      else
-      {
-        int x, y, w, h;
-        other->GetPosition(&x, &y);
-        other->GetSize(&w, &h);
-        return (int)(y + (h/2));
-      }
+        case wxLeft:
+            {
+                wxLayoutConstraints *constr = other->GetConstraints();
+                // If no constraints, it means the window is not dependent
+                // on anything, and therefore we know its value immediately
+                if (constr)
+                {
+                    if (constr->left.GetDone())
+                        return constr->left.GetValue();
+                    else
+                        return -1;
+                }
+                else
+                {
+                    int x, y;
+                    other->GetPosition(&x, &y);
+                    return x;
+                }
+            }
+        case wxTop:
+            {
+                wxLayoutConstraints *constr = other->GetConstraints();
+                // If no constraints, it means the window is not dependent
+                // on anything, and therefore we know its value immediately
+                if (constr)
+                {
+                    if (constr->top.GetDone())
+                        return constr->top.GetValue();
+                    else
+                        return -1;
+                }
+                else
+                {
+                    int x, y;
+                    other->GetPosition(&x, &y);
+                    return y;
+                }
+            }
+        case wxRight:
+            {
+                wxLayoutConstraints *constr = other->GetConstraints();
+                // If no constraints, it means the window is not dependent
+                // on anything, and therefore we know its value immediately
+                if (constr)
+                {
+                    if (constr->right.GetDone())
+                        return constr->right.GetValue();
+                    else
+                        return -1;
+                }
+                else
+                {
+                    int x, y, w, h;
+                    other->GetPosition(&x, &y);
+                    other->GetSize(&w, &h);
+                    return (int)(x + w);
+                }
+            }
+        case wxBottom:
+            {
+                wxLayoutConstraints *constr = other->GetConstraints();
+                // If no constraints, it means the window is not dependent
+                // on anything, and therefore we know its value immediately
+                if (constr)
+                {
+                    if (constr->bottom.GetDone())
+                        return constr->bottom.GetValue();
+                    else
+                        return -1;
+                }
+                else
+                {
+                    int x, y, w, h;
+                    other->GetPosition(&x, &y);
+                    other->GetSize(&w, &h);
+                    return (int)(y + h);
+                }
+            }
+        case wxWidth:
+            {
+                wxLayoutConstraints *constr = other->GetConstraints();
+                // If no constraints, it means the window is not dependent
+                // on anything, and therefore we know its value immediately
+                if (constr)
+                {
+                    if (constr->width.GetDone())
+                        return constr->width.GetValue();
+                    else
+                        return -1;
+                }
+                else
+                {
+                    int w, h;
+                    other->GetSize(&w, &h);
+                    return w;
+                }
+            }
+        case wxHeight:
+            {
+                wxLayoutConstraints *constr = other->GetConstraints();
+                // If no constraints, it means the window is not dependent
+                // on anything, and therefore we know its value immediately
+                if (constr)
+                {
+                    if (constr->height.GetDone())
+                        return constr->height.GetValue();
+                    else
+                        return -1;
+                }
+                else
+                {
+                    int w, h;
+                    other->GetSize(&w, &h);
+                    return h;
+                }
+            }
+        case wxCentreX:
+            {
+                wxLayoutConstraints *constr = other->GetConstraints();
+                // If no constraints, it means the window is not dependent
+                // on anything, and therefore we know its value immediately
+                if (constr)
+                {
+                    if (constr->centreX.GetDone())
+                        return constr->centreX.GetValue();
+                    else
+                        return -1;
+                }
+                else
+                {
+                    int x, y, w, h;
+                    other->GetPosition(&x, &y);
+                    other->GetSize(&w, &h);
+                    return (int)(x + (w/2));
+                }
+            }
+        case wxCentreY:
+            {
+                wxLayoutConstraints *constr = other->GetConstraints();
+                // If no constraints, it means the window is not dependent
+                // on anything, and therefore we know its value immediately
+                if (constr)
+                {
+                    if (constr->centreY.GetDone())
+                        return constr->centreY.GetValue();
+                    else
+                        return -1;
+                }
+                else
+                {
+                    int x, y, w, h;
+                    other->GetPosition(&x, &y);
+                    other->GetSize(&w, &h);
+                    return (int)(y + (h/2));
+                }
+            }
+        default:
+            break;
     }
     }
-    default:
-      break;
-  }
-  return -1;
+    return -1;
 }
 
 wxLayoutConstraints::wxLayoutConstraints()
 {
 }
 
 wxLayoutConstraints::wxLayoutConstraints()
 {
-  left.SetEdge(wxLeft);
-  top.SetEdge(wxTop);
-  right.SetEdge(wxRight);
-  bottom.SetEdge(wxBottom);
-  centreX.SetEdge(wxCentreX);
-  centreY.SetEdge(wxCentreY);
-  width.SetEdge(wxWidth);
-  height.SetEdge(wxHeight);
+    left.SetEdge(wxLeft);
+    top.SetEdge(wxTop);
+    right.SetEdge(wxRight);
+    bottom.SetEdge(wxBottom);
+    centreX.SetEdge(wxCentreX);
+    centreY.SetEdge(wxCentreY);
+    width.SetEdge(wxWidth);
+    height.SetEdge(wxHeight);
 }
 
 wxLayoutConstraints::~wxLayoutConstraints()
 {
 }
 
 }
 
 wxLayoutConstraints::~wxLayoutConstraints()
 {
 }
 
-bool wxLayoutConstraints::SatisfyConstraints(wxWindow *win, int *nChanges)
+bool wxLayoutConstraints::SatisfyConstraints(wxWindowBase *win, int *nChanges)
 {
 {
-  int noChanges = 0;
-  
-  bool done = width.GetDone();
-  bool newDone = (done ? TRUE : width.SatisfyConstraint(this, win));
-  if (newDone != done)
-    noChanges ++;
-
-  done = height.GetDone();
-  newDone = (done ? TRUE : height.SatisfyConstraint(this, win));
-  if (newDone != done)
-    noChanges ++;
-
-  done = left.GetDone();
-  newDone = (done ? TRUE : left.SatisfyConstraint(this, win));
-  if (newDone != done)
-    noChanges ++;
-
-  done = top.GetDone();
-  newDone = (done ? TRUE : top.SatisfyConstraint(this, win));
-  if (newDone != done)
-    noChanges ++;
-
-  done = right.GetDone();
-  newDone = (done ? TRUE : right.SatisfyConstraint(this, win));
-  if (newDone != done)
-    noChanges ++;
-          
-  done = bottom.GetDone();
-  newDone = (done ? TRUE : bottom.SatisfyConstraint(this, win));
-  if (newDone != done)
-    noChanges ++;
-
-  done = centreX.GetDone();
-  newDone = (done ? TRUE : centreX.SatisfyConstraint(this, win));
-  if (newDone != done)
-    noChanges ++;
-
-  done = centreY.GetDone();
-  newDone = (done ? TRUE : centreY.SatisfyConstraint(this, win));
-  if (newDone != done)
-    noChanges ++;
-
-  *nChanges = noChanges;
-
-  return AreSatisfied();
+    int noChanges = 0;
+
+    bool done = width.GetDone();
+    bool newDone = (done ? TRUE : width.SatisfyConstraint(this, win));
+    if (newDone != done)
+        noChanges ++;
+
+    done = height.GetDone();
+    newDone = (done ? TRUE : height.SatisfyConstraint(this, win));
+    if (newDone != done)
+        noChanges ++;
+
+    done = left.GetDone();
+    newDone = (done ? TRUE : left.SatisfyConstraint(this, win));
+    if (newDone != done)
+        noChanges ++;
+
+    done = top.GetDone();
+    newDone = (done ? TRUE : top.SatisfyConstraint(this, win));
+    if (newDone != done)
+        noChanges ++;
+
+    done = right.GetDone();
+    newDone = (done ? TRUE : right.SatisfyConstraint(this, win));
+    if (newDone != done)
+        noChanges ++;
+
+    done = bottom.GetDone();
+    newDone = (done ? TRUE : bottom.SatisfyConstraint(this, win));
+    if (newDone != done)
+        noChanges ++;
+
+    done = centreX.GetDone();
+    newDone = (done ? TRUE : centreX.SatisfyConstraint(this, win));
+    if (newDone != done)
+        noChanges ++;
+
+    done = centreY.GetDone();
+    newDone = (done ? TRUE : centreY.SatisfyConstraint(this, win));
+    if (newDone != done)
+        noChanges ++;
+
+    *nChanges = noChanges;
+
+    return AreSatisfied();
 }
 
 /*
 }
 
 /*
@@ -1044,7 +1080,8 @@ bool wxLayoutConstraints::SatisfyConstraints(wxWindow *win, int *nChanges)
 
  */
  
 
  */
  
-bool wxOldDoLayout(wxWindow *win)
+#if WXWIN_COMPATIBILITY
+bool wxOldDoLayout(wxWindowBase *win)
 {
   // Make sure this isn't called recursively from below
   static wxList doneSoFar;
 {
   // Make sure this isn't called recursively from below
   static wxList doneSoFar;
@@ -1057,7 +1094,7 @@ bool wxOldDoLayout(wxWindow *win)
   wxNode *node = win->GetChildren().First();
   while (node)
   {
   wxNode *node = win->GetChildren().First();
   while (node)
   {
-    wxWindow *child = (wxWindow *)node->Data();
+    wxWindowBase *child = (wxWindowBase *)node->Data();
     wxLayoutConstraints *constr = child->GetConstraints();
     if (constr)
     {
     wxLayoutConstraints *constr = child->GetConstraints();
     if (constr)
     {
@@ -1082,7 +1119,7 @@ bool wxOldDoLayout(wxWindow *win)
     wxNode *node = win->GetChildren().First();
     while (node)
     {
     wxNode *node = win->GetChildren().First();
     while (node)
     {
-      wxWindow *child = (wxWindow *)node->Data();
+      wxWindowBase *child = (wxWindowBase *)node->Data();
       wxLayoutConstraints *constr = child->GetConstraints();
       if (constr)
       {
       wxLayoutConstraints *constr = child->GetConstraints();
       if (constr)
       {
@@ -1099,7 +1136,7 @@ bool wxOldDoLayout(wxWindow *win)
   // failed, so we can print a specific diagnostic message.
   if (noFailures > 0)
   {
   // failed, so we can print a specific diagnostic message.
   if (noFailures > 0)
   {
-    wxDebugMsg(_("wxWindow::Layout() failed.\n"));
+    wxDebugMsg(_("wxWindowBase::Layout() failed.\n"));
   }
 */
   // Now set the sizes and positions of the children, and
   }
 */
   // Now set the sizes and positions of the children, and
@@ -1107,7 +1144,7 @@ bool wxOldDoLayout(wxWindow *win)
   node = win->GetChildren().First();
   while (node)
   {
   node = win->GetChildren().First();
   while (node)
   {
-    wxWindow *child = (wxWindow *)node->Data();
+    wxWindowBase *child = (wxWindowBase *)node->Data();
     wxLayoutConstraints *constr = child->GetConstraints();
     if (constr && constr->left.GetDone() && constr->right.GetDone() &&
                   constr->width.GetDone() && constr->height.GetDone())
     wxLayoutConstraints *constr = child->GetConstraints();
     if (constr && constr->left.GetDone() && constr->right.GetDone() &&
                   constr->width.GetDone() && constr->height.GetDone())
@@ -1137,613 +1174,591 @@ bool wxOldDoLayout(wxWindow *win)
 
   return TRUE;
 }
 
   return TRUE;
 }
+#endif // WXWIN_COMPATIBILITY
 
 wxSizer::wxSizer()
 {
 
 wxSizer::wxSizer()
 {
-  sizerBehaviour = wxSizerNone;
-  borderX = 2;
-  borderY = 2;
-  sizerX = 0;
-  sizerY = 0;
-  sizerWidth = 0;
-  sizerHeight = 0;
+    sizerBehaviour = wxSizerNone;
+    borderX = 2;
+    borderY = 2;
+    sizerX = 0;
+    sizerY = 0;
+    sizerWidth = 0;
+    sizerHeight = 0;
 }
 
 }
 
-wxSizer::wxSizer(wxWindow *parent, wxSizerBehaviour behav)
+wxSizer::wxSizer(wxWindowBase *parent, wxSizerBehaviour behav)
 {
 {
-  Create(parent, behav);
+    Create(parent, behav);
 }
 
 }
 
-bool wxSizer::Create(wxWindow *parent, wxSizerBehaviour behav)
+bool wxSizer::Create(wxWindowBase *parent, wxSizerBehaviour behav)
 {
 {
-  sizerBehaviour = behav;
-  borderX = 2;
-  borderY = 2;
-  m_sizerParent = parent;
-  sizerX = 0;
-  sizerY = 0;
-  sizerWidth = 0;
-  sizerHeight = 0;
-
-  // A normal window can have just one top-level sizer
-  // associated with it.
-  if (!parent->IsKindOf(CLASSINFO(wxSizer)))
-  {
-    parent->SetSizer(this);
-  }
-  else
-    ((wxSizer *)parent)->AddSizerChild(this);
-
-  switch (sizerBehaviour)
-  {
-    case wxSizerExpand:
+    sizerBehaviour = behav;
+    borderX = 2;
+    borderY = 2;
+    m_sizerParent = parent;
+    sizerX = 0;
+    sizerY = 0;
+    sizerWidth = 0;
+    sizerHeight = 0;
+
+    // A normal window can have just one top-level sizer
+    // associated with it.
+    if (!parent->IsKindOf(CLASSINFO(wxSizer)))
     {
     {
-      // Defines a set of constraints
-      // to expand the sizer to fit the parent window
-      wxLayoutConstraints *c = new wxLayoutConstraints;
-
-      c->left.SameAs(parent, wxLeft, 0);
-      c->top.SameAs(parent, wxTop, 0);
-      c->right.SameAs(parent, wxRight, 0);
-      c->bottom.SameAs(parent, wxBottom, 0);
-
-      SetConstraints(c);
-      break;
+        parent->SetSizer(this);
     }
     }
-    case wxSizerShrink:
-    case wxSizerNone:
-    default:
+    else
+        ((wxSizer *)parent)->AddSizerChild(this);
+
+    switch (sizerBehaviour)
     {
     {
+        case wxSizerExpand:
+            {
+                // Defines a set of constraints
+                // to expand the sizer to fit the parent window
+                wxLayoutConstraints *c = new wxLayoutConstraints;
+
+                c->left.SameAs(parent, wxLeft, 0);
+                c->top.SameAs(parent, wxTop, 0);
+                c->right.SameAs(parent, wxRight, 0);
+                c->bottom.SameAs(parent, wxBottom, 0);
+
+                SetConstraints(c);
+                break;
+            }
+        case wxSizerShrink:
+        case wxSizerNone:
+        default:
+            {
+            }
     }
     }
-  }
-  return TRUE;
+    return TRUE;
 }
 
 wxSizer::~wxSizer()
 {
 }
 
 wxSizer::~wxSizer()
 {
-  // Remove all children without deleting them,
-  // or ~wxbWindow will delete proper windows _twice_
-  wxNode *node = GetChildren().First();
-  while (node)
-  {
-    wxNode *next = node->Next();
-    wxWindow *win = (wxWindow *)node->Data();
-    if (!win->IsKindOf(CLASSINFO(wxSizer)))
-       {
-       delete node;
-               win->SetSizerParent((wxWindow *) NULL);
-       }
-    else
+    // Remove all children without deleting them,
+    // or ~wxbWindow will delete proper windows _twice_
+    wxNode *node = GetChildren().First();
+    while (node)
     {
     {
-      RemoveSizerChild(win);
-      delete win;
+        wxNode *next = node->Next();
+        wxWindowBase *win = (wxWindowBase *)node->Data();
+        if (!win->IsKindOf(CLASSINFO(wxSizer)))
+        {
+            delete node;
+            win->SetSizerParent((wxWindowBase *) NULL);
+        }
+        else
+        {
+            RemoveSizerChild(win);
+            delete win;
+        }
+        node = next;
     }
     }
-    node = next;
-  }
 
 
-  if (m_sizerParent) // && !m_sizerParent->IsKindOf(CLASSINFO(wxSizer)))
-  {
-    m_sizerParent->SetSizer((wxSizer *) NULL);
-       m_sizerParent = (wxWindow *) NULL;
-  }
+    if (m_sizerParent) // && !m_sizerParent->IsKindOf(CLASSINFO(wxSizer)))
+    {
+        m_sizerParent->SetSizer((wxSizer *) NULL);
+        m_sizerParent = (wxWindowBase *) NULL;
+    }
 
 }
 
 void wxSizer::SetBorder(int x, int y)
 {
 
 }
 
 void wxSizer::SetBorder(int x, int y)
 {
-       borderX = x;
-       borderY = y;
-/* No: the margin is for inside, not outside (expansion)
-
-       if ( GetConstraints() )
-       {
-               GetConstraints()->left.SetMargin(x);
-               GetConstraints()->right.SetMargin(x);
-               GetConstraints()->top.SetMargin(y);
-               GetConstraints()->bottom.SetMargin(y);
-       }
-*/
+    borderX = x;
+    borderY = y;
+    /* No: the margin is for inside, not outside (expansion)
+
+       if ( GetConstraints() )
+       {
+       GetConstraints()->left.SetMargin(x);
+       GetConstraints()->right.SetMargin(x);
+       GetConstraints()->top.SetMargin(y);
+       GetConstraints()->bottom.SetMargin(y);
+       }
+     */
 
 }
 
 
 }
 
-void wxSizer::AddSizerChild(wxWindow *child)
+void wxSizer::AddSizerChild(wxWindowBase *child)
 {
 {
-  child->SetSizerParent(this);
-  GetChildren().Append(child);
+    child->SetSizerParent(this);
+    GetChildren().Append(child);
 
 
-  // Add some constraints for the purpose of storing
-  // the relative position of the window/sizer
-  // during layout calculations.
-  if (!child->GetConstraints())
-  {
-    wxLayoutConstraints *c = new wxLayoutConstraints;
-    c->left.AsIs();
-    c->top.AsIs();
-    c->width.AsIs();
-    c->height.AsIs();
-    int w, h;
-    child->GetSize(&w, &h);
-    c->width.SetValue(w);
-    c->height.SetValue(h);
-    
-    child->SetConstraints(c);
-  }
-}
+    // Add some constraints for the purpose of storing
+    // the relative position of the window/sizer
+    // during layout calculations.
+    if (!child->GetConstraints())
+    {
+        wxLayoutConstraints *c = new wxLayoutConstraints;
+        c->left.AsIs();
+        c->top.AsIs();
+        c->width.AsIs();
+        c->height.AsIs();
+        int w, h;
+        child->GetSize(&w, &h);
+        c->width.SetValue(w);
+        c->height.SetValue(h);
 
 
-void wxSizer::RemoveSizerChild(wxWindow *child)
-{
-  GetChildren().DeleteObject(child);
+        child->SetConstraints(c);
+    }
 }
 
 }
 
-void wxSizer::SetSize(int x, int y, int w, int h, int WXUNUSED(flags))
+void wxSizer::RemoveSizerChild(wxWindowBase *child)
 {
 {
-  wxLayoutConstraints *constr = GetConstraints();
-  if (x != -1)
-  {
-    sizerX = x;
-    if (constr)
-      constr->left.SetValue(x);
-  }
-  if (y != -1)
-  {
-    sizerY = y;
-    if (constr)
-      constr->top.SetValue(y);
-  }
-  if (w != -1)
-  {
-    sizerWidth = w;
-    if (constr)
-      constr->width.SetValue(w);
-  }
-  if (h != -1)
-  {
-    sizerHeight = h;
-    if (constr)
-      constr->height.SetValue(h);
-  }
+    GetChildren().DeleteObject(child);
 }
 
 }
 
-void wxSizer::Move(int x, int y)
+void wxSizer::DoSetSize(int x, int y, int w, int h, int WXUNUSED(flags))
 {
 {
-  wxLayoutConstraints *constr = GetConstraints();
-  if (x != -1)
-  {
-    sizerX = x;
-    if (constr)
-      constr->left.SetValue(x);
-  }
-  if (y != -1)
-  {
-    sizerY = y;
-    if (constr)
-      constr->top.SetValue(y);
-  }
+    wxLayoutConstraints *constr = GetConstraints();
+    if (x != -1)
+    {
+        sizerX = x;
+        if (constr)
+            constr->left.SetValue(x);
+    }
+    if (y != -1)
+    {
+        sizerY = y;
+        if (constr)
+            constr->top.SetValue(y);
+    }
+    if (w != -1)
+    {
+        sizerWidth = w;
+        if (constr)
+            constr->width.SetValue(w);
+    }
+    if (h != -1)
+    {
+        sizerHeight = h;
+        if (constr)
+            constr->height.SetValue(h);
+    }
 }
 
 }
 
-void wxSizer::GetSize(int *w, int *h) const
+void wxSizer::DoGetSize(int *w, int *h) const
 {
 {
-  *w = sizerWidth;
-  *h = sizerHeight;
+    *w = sizerWidth;
+    *h = sizerHeight;
 }
 
 }
 
-void wxSizer::GetPosition(int *x, int *y) const
+void wxSizer::DoGetPosition(int *x, int *y) const
 {
 {
-  *x = sizerX;
-  *y = sizerY;
+    *x = sizerX;
+    *y = sizerY;
 }
 
 bool wxSizer::LayoutPhase1(int *noChanges)
 {
 }
 
 bool wxSizer::LayoutPhase1(int *noChanges)
 {
-  *noChanges = 0;
-  switch (sizerBehaviour)
-  {
-    case wxSizerExpand:
-    {
-      if (!m_sizerParent)
-      {
-        wxMessageBox(_("wxExpandSizer has no parent!"), _("Sizer error"), wxOK);
-        return TRUE;
-      }
-
-      // Set the size to fill the parent client area
-      int pw, ph;
-      m_sizerParent->GetClientSize(&pw, &ph);
-      SetSize(GetBorderX(), GetBorderY(), pw - 2*GetBorderX(), ph - 2*GetBorderY());
-      wxLayoutConstraints *constr = GetConstraints();
-
-      // Fill in the constraints
-      if (constr)
-      {
-        constr->left.SetValue(0); constr->left.SetDone(TRUE);
-        constr->top.SetValue(0); constr->right.SetDone(TRUE);
-        constr->width.SetValue(pw); constr->width.SetDone(TRUE);
-        constr->height.SetValue(ph); constr->height.SetDone(TRUE);
-      }
-  
-      return TRUE;
-      break;
-    }
-    case wxSizerShrink:
-    {
-      wxLayoutConstraints *constr = GetConstraints();
-
-      if (constr)
-      {
-        // Force the constraint to have as-is width and height
-        // if we're in shrink-to-fit mode, because if left unconstrained,
-        // SatisfyConstraints will fail. The shrink-to-fit option
-        // essentially specifies the width and height as 'whatever I calculate'.
-        constr->width.AsIs();
-        constr->height.AsIs();
-      }
-      DoPhase(1);
-      DoPhase(2);
-      // Find the bounding box and set own size
-      int maxX = 0;
-      int maxY = 0;
-      wxNode *node = GetChildren().First();
-      while (node)
-      {
-        int x, y, width, height;
-        wxWindow *win = (wxWindow *)node->Data();
-        win->GetSizeConstraint(&width, &height);
-        win->GetPositionConstraint(&x, &y);
-        if ((x+width) > maxX)
-          maxX = (x + width);
-        if ((y+height) > maxY)
-          maxY = (y + height);
-        node = node->Next();
-      }
-      SetSize(GetBorderX(), GetBorderY(), maxX, maxY);
-
-         // If this is the only sizer for the parent, size the parent to this sizer.
-         if ( m_sizerParent && (m_sizerParent->GetSizer() == this) )
-               m_sizerParent->SetClientSize(maxX + 2*GetBorderX(), maxY + 2*GetBorderY());
-
-      return TRUE;
-      break;
-    }
-    case wxSizerNone:
+    *noChanges = 0;
+    switch (sizerBehaviour)
     {
     {
-      wxLayoutConstraints *constr = GetConstraints();
-      if (constr)
-      {
-        bool success = constr->SatisfyConstraints(this, noChanges);
-        if (success)
-        {
-          int x = constr->left.GetValue();
-          int y = constr->top.GetValue();
-          int w = constr->width.GetValue();
-          int h = constr->height.GetValue();
-          SetSize(x, y, w, h);
-        }
-        return success;
-      }
-      else
-        return TRUE;
-      break;
+        case wxSizerExpand:
+            {
+                if (!m_sizerParent)
+                {
+                    wxMessageBox(_("wxExpandSizer has no parent!"), _("Sizer error"), wxOK);
+                    return TRUE;
+                }
+
+                // Set the size to fill the parent client area
+                int pw, ph;
+                m_sizerParent->GetClientSize(&pw, &ph);
+                SetSize(GetBorderX(), GetBorderY(), pw - 2*GetBorderX(), ph - 2*GetBorderY());
+                wxLayoutConstraints *constr = GetConstraints();
+
+                // Fill in the constraints
+                if (constr)
+                {
+                    constr->left.SetValue(0); constr->left.SetDone(TRUE);
+                    constr->top.SetValue(0); constr->right.SetDone(TRUE);
+                    constr->width.SetValue(pw); constr->width.SetDone(TRUE);
+                    constr->height.SetValue(ph); constr->height.SetDone(TRUE);
+                }
+
+                return TRUE;
+                break;
+            }
+        case wxSizerShrink:
+            {
+                wxLayoutConstraints *constr = GetConstraints();
+
+                if (constr)
+                {
+                    // Force the constraint to have as-is width and height
+                    // if we're in shrink-to-fit mode, because if left unconstrained,
+                    // SatisfyConstraints will fail. The shrink-to-fit option
+                    // essentially specifies the width and height as 'whatever I calculate'.
+                    constr->width.AsIs();
+                    constr->height.AsIs();
+                }
+                DoPhase(1);
+                DoPhase(2);
+                // Find the bounding box and set own size
+                int maxX = 0;
+                int maxY = 0;
+
+                wxNode *node = GetChildren().First();
+                while (node)
+                {
+                    int x, y, width, height;
+                    wxWindowBase *win = (wxWindowBase *)node->Data();
+                    win->GetSizeConstraint(&width, &height);
+                    win->GetPositionConstraint(&x, &y);
+                    if ((x+width) > maxX)
+                        maxX = (x + width);
+                    if ((y+height) > maxY)
+                        maxY = (y + height);
+
+                    node = node->Next();
+                }
+                SetSize(GetBorderX(), GetBorderY(), maxX, maxY);
+
+                // If this is the only sizer for the parent, size the parent to this sizer.
+                if ( m_sizerParent && (m_sizerParent->GetSizer() == this) )
+                    m_sizerParent->SetClientSize(maxX + 2*GetBorderX(), maxY + 2*GetBorderY());
+
+                return TRUE;
+                break;
+            }
+        case wxSizerNone:
+            {
+                wxLayoutConstraints *constr = GetConstraints();
+                if (constr)
+                {
+                    bool success = constr->SatisfyConstraints(this, noChanges);
+                    if (success)
+                    {
+                        int x = constr->left.GetValue();
+                        int y = constr->top.GetValue();
+                        int w = constr->width.GetValue();
+                        int h = constr->height.GetValue();
+                        SetSize(x, y, w, h);
+                    }
+                    return success;
+                }
+                else
+                    return TRUE;
+                break;
+            }
     }
     }
-  }
-  return TRUE;
+    return TRUE;
 
 }
 
 bool wxSizer::LayoutPhase2(int *noChanges)
 {
 
 }
 
 bool wxSizer::LayoutPhase2(int *noChanges)
 {
-  *noChanges = 0;
+    *noChanges = 0;
 
 
-  switch (sizerBehaviour)
-  {
-    case wxSizerExpand:
-    {
-      // Layout children
-      DoPhase(1);
-      DoPhase(2);
-      return TRUE;
-    }
-    case wxSizerShrink:
+    switch (sizerBehaviour)
     {
     {
-      wxLayoutConstraints *constr = GetConstraints();
-      if (constr)
-      {
-        bool success = constr->SatisfyConstraints(this, noChanges);
-        if (success)
-        {
-          int x = constr->left.GetValue();
-          int y = constr->top.GetValue();
-          Move(x, y);
-        }
-        return success;
-      }
-      break;
-    }
-    case wxSizerNone:
-    {
-      // Layout children
-      DoPhase(1);
-      DoPhase(2);
-
-         // Is this a dumb fix for lack of constraint evaluation?
-      wxLayoutConstraints *constr = GetConstraints();
-      if (constr)
-      {
-        bool success = constr->SatisfyConstraints(this, noChanges);
-        if (success)
-        {
-          int x = constr->left.GetValue();
-          int y = constr->top.GetValue();
-          int w = constr->width.GetValue();
-          int h = constr->height.GetValue();
-          SetSize(x, y, w, h);
-        }
-        return success;
-      }
-      else
-        return TRUE;
+        case wxSizerExpand:
+            {
+                // Layout children
+                DoPhase(1);
+                DoPhase(2);
+                return TRUE;
+            }
+        case wxSizerShrink:
+            {
+                wxLayoutConstraints *constr = GetConstraints();
+                if (constr)
+                {
+                    bool success = constr->SatisfyConstraints(this, noChanges);
+                    if (success)
+                    {
+                        int x = constr->left.GetValue();
+                        int y = constr->top.GetValue();
+                        Move(x, y);
+                    }
+                    return success;
+                }
+                break;
+            }
+        case wxSizerNone:
+            {
+                // Layout children
+                DoPhase(1);
+                DoPhase(2);
+
+                // Is this a dumb fix for lack of constraint evaluation?
+                wxLayoutConstraints *constr = GetConstraints();
+                if (constr)
+                {
+                    bool success = constr->SatisfyConstraints(this, noChanges);
+                    if (success)
+                    {
+                        int x = constr->left.GetValue();
+                        int y = constr->top.GetValue();
+                        int w = constr->width.GetValue();
+                        int h = constr->height.GetValue();
+                        SetSize(x, y, w, h);
+                    }
+                    return success;
+                }
+                else
+                    return TRUE;
+            }
     }
     }
-  }
-  return TRUE;
+    return TRUE;
 }
 
 /*
  * wxRowColSizer
  */
 }
 
 /*
  * wxRowColSizer
  */
- 
+
 wxRowColSizer::wxRowColSizer()
 {
 wxRowColSizer::wxRowColSizer()
 {
-  rowOrCol = TRUE;
-  rowOrColSize = 20;
-  xSpacing = 2;
-  ySpacing = 2;
+    rowOrCol = TRUE;
+    rowOrColSize = 20;
+    xSpacing = 2;
+    ySpacing = 2;
 }
 
 }
 
-wxRowColSizer::wxRowColSizer(wxWindow *parent, bool rc, int n, wxSizerBehaviour behav)
+wxRowColSizer::wxRowColSizer(wxWindowBase *parent, bool rc, int n, wxSizerBehaviour behav)
 {
 {
-  Create(parent, rc, n, behav);
+    Create(parent, rc, n, behav);
 }
 
 }
 
-bool wxRowColSizer::Create(wxWindow *parent, bool rc, int n, wxSizerBehaviour behav)
+bool wxRowColSizer::Create(wxWindowBase *parent, bool rc, int n, wxSizerBehaviour behav)
 {
 {
-  wxSizer::Create(parent, behav);
-  
-  rowOrCol = rc;
-  rowOrColSize = n;
-  xSpacing = 2;
-  ySpacing = 2;
+    wxSizer::Create(parent, behav);
 
 
-  return TRUE;
-}
+    rowOrCol = rc;
+    rowOrColSize = n;
+    xSpacing = 2;
+    ySpacing = 2;
 
 
-wxRowColSizer::~wxRowColSizer()
-{
+    return TRUE;
 }
 
 }
 
-void wxRowColSizer::SetSize(int x, int y, int w, int h, int flags)
+wxRowColSizer::~wxRowColSizer()
 {
 {
-  wxSizer::SetSize(x, y, w, h, flags);
 }
 
 bool wxRowColSizer::LayoutPhase1(int *noChanges)
 {
 }
 
 bool wxRowColSizer::LayoutPhase1(int *noChanges)
 {
-  *noChanges = 0;
-  wxLayoutConstraints *constr = GetConstraints();
-
-  if (constr)
-  {
-    // Force the constraint to have as-is width and height
-    // if we're in shrink-to-fit mode, because if left unconstrained,
-    // SatisfyConstraints will fail. The shrink-to-fit option
-    // essentially specifies the width and height as 'whatever I calculate'.
-    if (sizerBehaviour == wxSizerShrink)
-    {
-      constr->width.AsIs();
-      constr->height.AsIs();
-    }
+    *noChanges = 0;
+    wxLayoutConstraints *constr = GetConstraints();
 
 
-    // Only evaluate the constraints FIRST if we're NOT
-    // in shrink-to-fit mode, i.e. we want to size the rowcol
-    // first, then lay the children out in the space we've calculated.
-    if (sizerBehaviour != wxSizerShrink)
+    if (constr)
     {
     {
-      bool success = constr->SatisfyConstraints(this, noChanges);
-      if (success)
-      {
-        int x = constr->left.GetValue();
-        int y = constr->top.GetValue();
-        int w = constr->width.GetValue();
-        int h = constr->height.GetValue();
-        SetSize(x, y, w, h);
-      }
-      else
-        return FALSE;
+        // Force the constraint to have as-is width and height
+        // if we're in shrink-to-fit mode, because if left unconstrained,
+        // SatisfyConstraints will fail. The shrink-to-fit option
+        // essentially specifies the width and height as 'whatever I calculate'.
+        if (sizerBehaviour == wxSizerShrink)
+        {
+            constr->width.AsIs();
+            constr->height.AsIs();
+        }
 
 
-      // Continue to do the rest of the phase when the constraints have been
-      // satisfied, i.e. we're on the last iteration of phase 1 and
-      // can now do the actual rowcol laying out.
+        // Only evaluate the constraints FIRST if we're NOT
+        // in shrink-to-fit mode, i.e. we want to size the rowcol
+        // first, then lay the children out in the space we've calculated.
+        if (sizerBehaviour != wxSizerShrink)
+        {
+            bool success = constr->SatisfyConstraints(this, noChanges);
+            if (success)
+            {
+                int x = constr->left.GetValue();
+                int y = constr->top.GetValue();
+                int w = constr->width.GetValue();
+                int h = constr->height.GetValue();
+                SetSize(x, y, w, h);
+            }
+            else
+                return FALSE;
+
+            // Continue to do the rest of the phase when the constraints have been
+            // satisfied, i.e. we're on the last iteration of phase 1 and
+            // can now do the actual rowcol laying out.
+        }
     }
     }
-  }
 
 
-  // If we ARE in shrink-to-fit mode, we must now
-  // calculate the child sizes BEFORE laying out in rows or columns.
-  if (sizerBehaviour == wxSizerShrink)
-  {
-    DoPhase(1);
-    DoPhase(2);
-
-    // WILL THE WINDOW BE SIZED CORRECTLY AT THIS POINT?
-    // CHECK CONSTRAINTS IF ANY...
-    int noRows = 0;
-    int noCols = 0;
-    int currentX = borderX;
-    int currentY = borderY;
-    int maxX = currentX;
-    int maxY = currentY;
-    
-    wxNode *node = GetChildren().First();
-    while (node)
+    // If we ARE in shrink-to-fit mode, we must now
+    // calculate the child sizes BEFORE laying out in rows or columns.
+    if (sizerBehaviour == wxSizerShrink)
     {
     {
-      wxWindow *win = (wxWindow *)node->Data();
-      int childWidth, childHeight;
-      if (win->GetConstraints() &&
-          win->GetConstraints()->width.GetDone() &&
-          win->GetConstraints()->height.GetDone())
-      {
-        childWidth = win->GetConstraints()->width.GetValue();
-        childHeight = win->GetConstraints()->height.GetValue();
-      }
-      else
-        win->GetSize(&childWidth, &childHeight);
-
-      win->MoveConstraint(currentX, currentY);
-
-      if ((currentX + childWidth) > maxX)
-        maxX = (currentX + childWidth);
-      if ((currentY + childHeight) > maxY)
-        maxY = (currentY + childHeight);
-
-      if (rowOrCol)
-      {
-        currentX += childWidth + xSpacing;
-        noCols ++;
-
-        // Reset to start of row
-        if (noCols == rowOrColSize)
+        DoPhase(1);
+        DoPhase(2);
+
+        // WILL THE WINDOW BE SIZED CORRECTLY AT THIS POINT?
+        // CHECK CONSTRAINTS IF ANY...
+        int noRows = 0;
+        int noCols = 0;
+        int currentX = borderX;
+        int currentY = borderY;
+        int maxX = currentX;
+        int maxY = currentY;
+
+        wxNode *node = GetChildren().First();
+        while (node)
         {
         {
-          currentX = borderX;
-          currentY += childHeight + ySpacing;
-          noCols = 0;
+            wxWindowBase *win = (wxWindowBase *)node->Data();
+            int childWidth, childHeight;
+            if (win->GetConstraints() &&
+                    win->GetConstraints()->width.GetDone() &&
+                    win->GetConstraints()->height.GetDone())
+            {
+                childWidth = win->GetConstraints()->width.GetValue();
+                childHeight = win->GetConstraints()->height.GetValue();
+            }
+            else
+                win->GetSize(&childWidth, &childHeight);
+
+            win->MoveConstraint(currentX, currentY);
+
+            if ((currentX + childWidth) > maxX)
+                maxX = (currentX + childWidth);
+            if ((currentY + childHeight) > maxY)
+                maxY = (currentY + childHeight);
+
+            if (rowOrCol)
+            {
+                currentX += childWidth + xSpacing;
+                noCols ++;
+
+                // Reset to start of row
+                if (noCols == rowOrColSize)
+                {
+                    currentX = borderX;
+                    currentY += childHeight + ySpacing;
+                    noCols = 0;
+                }
+            }
+            else
+            {
+                currentY += childHeight + ySpacing;
+                noRows ++;
+
+                // Reset to start of col
+                if (noRows == rowOrColSize)
+                {
+                    currentY = borderY;
+                    currentX += childWidth + xSpacing;
+                    noRows = 0;
+                }
+            }
+
+            node = node->Next();
         }
         }
-      }
-      else
-      {
-        currentY += childHeight + ySpacing;
-        noRows ++;
+        maxX += borderX;
+        maxY += borderY;
 
 
-        // Reset to start of col
-        if (noRows == rowOrColSize)
-        {
-          currentY = borderY;
-          currentX += childWidth + xSpacing;
-          noRows = 0;
-        }
-      }
-      
-      node = node->Next();
+        SetSize(-1, -1, maxX, maxY);
     }
     }
-    maxX += borderX;
-    maxY += borderY;
-
-    SetSize(-1, -1, maxX, maxY);
-  }
-  return TRUE;
+    return TRUE;
 }
 
 bool wxRowColSizer::LayoutPhase2(int *noChanges)
 {
 }
 
 bool wxRowColSizer::LayoutPhase2(int *noChanges)
 {
-  *noChanges = 0;
-  
-  // If shrink-to-fit, it's only at Phase 2 that we know the size of
-  // the wxRowColSizer, and now we can evaluate the
-  // constraints and pass result back up to parent.
-  // This implements a depth-first strategy
-  if (sizerBehaviour == wxSizerShrink)
-  {
-    wxLayoutConstraints *constr = GetConstraints();
-    if (constr)
+    *noChanges = 0;
+
+    // If shrink-to-fit, it's only at Phase 2 that we know the size of
+    // the wxRowColSizer, and now we can evaluate the
+    // constraints and pass result back up to parent.
+    // This implements a depth-first strategy
+    if (sizerBehaviour == wxSizerShrink)
     {
     {
-      bool success = constr->SatisfyConstraints(this, noChanges);
-      if (success)
-      {
-        int x = constr->left.GetValue();
-        int y = constr->top.GetValue();
-        Move(x, y);
-      }
-      return success;
+        wxLayoutConstraints *constr = GetConstraints();
+        if (constr)
+        {
+            bool success = constr->SatisfyConstraints(this, noChanges);
+            if (success)
+            {
+                int x = constr->left.GetValue();
+                int y = constr->top.GetValue();
+                Move(x, y);
+            }
+            return success;
+        }
+        else return TRUE;
     }
     }
-    else return TRUE;
-  }
-  else
-  {
-    // Lay out the children: breadth-first strategy.
-    DoPhase(1);
-    DoPhase(2);
+    else
+    {
+        // Lay out the children: breadth-first strategy.
+        DoPhase(1);
+        DoPhase(2);
 
 
-    // Space them
-  }
-  return TRUE;
+        // Space them
+    }
+    return TRUE;
 }
 
 
 /*
  * wxSpacingSizer
  */
 }
 
 
 /*
  * wxSpacingSizer
  */
- 
+
 wxSpacingSizer::wxSpacingSizer()
 {
 }
 
 wxSpacingSizer::wxSpacingSizer()
 {
 }
 
-wxSpacingSizer::wxSpacingSizer(wxWindow *parent)
+wxSpacingSizer::wxSpacingSizer(wxWindowBase *parent)
 {
 {
-  Create(parent);
+    Create(parent);
 }
 
 }
 
-wxSpacingSizer::wxSpacingSizer(wxWindow *parent, wxRelationship rel, wxWindow *other, int spacing)
+wxSpacingSizer::wxSpacingSizer(wxWindowBase *parent, wxRelationship rel, wxWindowBase *other, int spacing)
 {
 {
-  Create(parent, rel, other, spacing);
+    Create(parent, rel, other, spacing);
 }
 
 }
 
-bool wxSpacingSizer::Create(wxWindow *parent)
+bool wxSpacingSizer::Create(wxWindowBase *parent)
 {
 {
-  wxSizer::Create(parent);
-  return TRUE;
+    wxSizer::Create(parent);
+    return TRUE;
 }
 
 }
 
-bool wxSpacingSizer::Create(wxWindow *parent, wxRelationship rel, wxWindow *other, int spacing)
+bool wxSpacingSizer::Create(wxWindowBase *parent, wxRelationship rel, wxWindowBase *other, int spacing)
 {
 {
-  wxLayoutConstraints *c = new wxLayoutConstraints;
+    wxLayoutConstraints *c = new wxLayoutConstraints;
 
 
-  wxSizer::Create(parent);
+    wxSizer::Create(parent);
 
 
-  switch ( rel )
-  {
-       case wxLeftOf :
-               c->width.Absolute       (spacing);
-               c->top.SameAs           (other, wxTop);
-               c->bottom.SameAs        (other, wxBottom);
-               c->right.LeftOf         (other);
-               break;
-       case wxRightOf :
-               c->width.Absolute       (spacing);
-               c->top.SameAs           (other, wxTop);
-               c->bottom.SameAs        (other, wxBottom);
-               c->left.RightOf         (other);
-               break;
-       case wxBelow :
-               c->height.Absolute      (spacing);
-               c->left.SameAs          (other, wxLeft);
-               c->right.SameAs         (other, wxRight);
-               c->top.Below            (other);
-               break;
-       case wxAbove :
-               c->height.Absolute      (spacing);
-               c->left.SameAs          (other, wxLeft);
-               c->right.SameAs         (other, wxRight);
-               c->bottom.Above         (other);
-               break;
-
-       default :
-               break;
-  }
-  SetConstraints(c);
+    switch ( rel )
+    {
+        case wxLeftOf :
+            c->width.Absolute    (spacing);
+            c->top.SameAs        (other, wxTop);
+            c->bottom.SameAs    (other, wxBottom);
+            c->right.LeftOf        (other);
+            break;
+        case wxRightOf :
+            c->width.Absolute    (spacing);
+            c->top.SameAs        (other, wxTop);
+            c->bottom.SameAs    (other, wxBottom);
+            c->left.RightOf        (other);
+            break;
+        case wxBelow :
+            c->height.Absolute    (spacing);
+            c->left.SameAs        (other, wxLeft);
+            c->right.SameAs        (other, wxRight);
+            c->top.Below        (other);
+            break;
+        case wxAbove :
+            c->height.Absolute    (spacing);
+            c->left.SameAs        (other, wxLeft);
+            c->right.SameAs        (other, wxRight);
+            c->bottom.Above        (other);
+            break;
+
+        default :
+            break;
+    }
+    SetConstraints(c);
 
 
-  return TRUE;
+    return TRUE;
 }
 
 wxSpacingSizer::~wxSpacingSizer()
 {
 }
 
 }
 
 wxSpacingSizer::~wxSpacingSizer()
 {
 }
 
-
-
-#endif
wxWidgets (Impactor)