]> git.saurik.com Git - wxWidgets.git/blobdiff - src/common/layout.cpp
reverted the fix for Unicode compilation with VC++ as it breaks other ports (and...
[wxWidgets.git] / src / common / layout.cpp
index e8f22391a6d5b5f4a64f3cf229ece5d7c19551cd..8dbb8ea8dc5e93601ff196e31f90c85df0b784d5 100644 (file)
 // 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
 
 #endif
 
-#include "wx/defs.h"
-
 #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/defs.h"
 #endif
 
 #endif
 
-#include "wx/layout.h"
+#if wxUSE_CONSTRAINTS
 
 
-#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)
+#ifndef WX_PRECOMP
+  #include "wx/window.h"
+  #include "wx/utils.h"
+  #include "wx/dialog.h"
+  #include "wx/msgdlg.h"
+  #include "wx/intl.h"
 #endif
 
 #endif
 
-/*
-TODO:
- - Non shrink-to-fit row-col behaviour.
- - Give justification styles, so can e.g. centre
- the rows & cols, distribute the available space...
- - Shrink-to-fit: should resize outer window (e.g. dialog box)
- if directly associated with this kind of window.
- - How to deal with a rowcol that stretches in one direction
- but shrinks-to-fit in other. E.g. a horizontal toolbar: the width
- stretches to fit the frame, but the height is constant
- or wraps around contents. The algorithm currently assumes
- both dimensions have the same behaviour. Could assume a constant
- height (absolute value).
- - rowcol where each row or column is aligned (length of
-   largest element determines spacing)
- - Groupbox sizer
- - Analyze aesthetic dialog boxes and implement using sizers.
- - What reuseable components can we provide? E.g. Ok/Cancel/Help
-   group of buttons.
- - use wxStaticItems for aesthetic dialogs.
+#include "wx/layout.h"
 
 
-*/
+    IMPLEMENT_DYNAMIC_CLASS(wxIndividualLayoutConstraint, wxObject)
+    IMPLEMENT_DYNAMIC_CLASS(wxLayoutConstraints, wxObject)
 
 
-// Find margin sizes if a sizer, or zero otherwise
-int wxSizerMarginX(wxWindow *win)
+
+wxIndividualLayoutConstraint::wxIndividualLayoutConstraint()
 {
 {
-       if ( win->IsKindOf(CLASSINFO(wxSizer)) )
-       {
-               wxSizer *sizer = (wxSizer *)win;
-               return sizer->GetBorderX();
-       }
-       else
-               return 0;
+    myEdge = wxTop;
+    relationship = wxUnconstrained;
+    margin = 0;
+    value = 0;
+    percent = 0;
+    otherEdge = wxTop;
+    done = FALSE;
+    otherWin = (wxWindowBase *) NULL;
 }
 
 }
 
-int wxSizerMarginY(wxWindow *win)
+wxIndividualLayoutConstraint::~wxIndividualLayoutConstraint()
 {
 {
-       if ( win->IsKindOf(CLASSINFO(wxSizer)) )
-       {
-               wxSizer *sizer = (wxSizer *)win;
-               return sizer->GetBorderY();
-       }
-       else
-               return 0;
 }
 
 }
 
-
-wxIndividualLayoutConstraint::wxIndividualLayoutConstraint()
+void wxIndividualLayoutConstraint::Set(wxRelationship rel, wxWindowBase *otherW, wxEdge otherE, int val, int marg)
 {
 {
-  myEdge = wxTop; relationship = wxUnconstrained; margin = 0; value = 0; percent = 0; otherEdge = wxTop;
-  done = FALSE; otherWin = (wxWindow *) NULL;
+    relationship = rel;
+    otherWin = otherW;
+    otherEdge = otherE;
+
+    if ( rel == wxPercentOf )
+    {
+        percent = val;
+    }
+    else
+    {
+        value = val;
+    }
+
+    margin = marg;
 }
 
 }
 
-wxIndividualLayoutConstraint::~wxIndividualLayoutConstraint()
+void wxIndividualLayoutConstraint::LeftOf(wxWindowBase *sibling, int marg)
 {
 {
+    Set(wxLeftOf, sibling, wxLeft, 0, marg);
 }
 
 }
 
-void wxIndividualLayoutConstraint::Set(wxRelationship rel, wxWindow *otherW, wxEdge otherE, int val, int marg)
+void wxIndividualLayoutConstraint::RightOf(wxWindowBase *sibling, int marg)
 {
 {
-  relationship = rel; otherWin = otherW; otherEdge = otherE; value = val; margin = marg;
+    Set(wxRightOf, sibling, wxRight, 0, marg);
 }
 
 }
 
-void wxIndividualLayoutConstraint::LeftOf(wxWindow *sibling, int marg)
-{ Set(wxLeftOf, sibling, wxLeft, 0, marg); }
-
-void wxIndividualLayoutConstraint::RightOf(wxWindow *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, 100, marg);
+}
 
 // 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)
+{ 
+    Set(wxPercentOf, otherW, wh, per);
 }
 
 //
 // 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
+    if (otherW == otherWin)
+    {
+        myEdge = wxTop;
+        relationship = wxAsIs;
+        margin = 0;
+        value = 0;
+        percent = 0;
+        otherEdge = wxTop;
+        otherWin = (wxWindowBase *) NULL;
+        return TRUE;
+    }
+
     return FALSE;
 }
 
 // Try to satisfy constraint
     return FALSE;
 }
 
 // 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:
-    {
-      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:
+    if (relationship == wxAbsolute)
     {
     {
-      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;
+        done = TRUE;
+        return TRUE;
     }
     }
-    case wxCentreX:
+
+    switch (myEdge)
     {
     {
-      switch (relationship)
-      {
-        case wxLeftOf:
+        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 wxRightOf:
+        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 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;
+            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 wxCentreY:
-    {
-      switch (relationship)
-      {
-        case wxAbove:
+        case wxCentreX:
         {
         {
-          // 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 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 wxBelow:
+        case wxCentreY:
         {
         {
-          int edgePos = GetEdge(otherEdge, win, otherWin);
-          if (edgePos != -1)
-          {
-            value = edgePos + 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 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 wxPercentOf:
+        case wxWidth:
         {
         {
-          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 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 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 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;
     }
     }
-    case wxWidth:
-    {
-      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 wxHeight:
-    {
-      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:
-      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)
+    // 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))
     {
     {
-      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:
-    {
-      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 0;
+                }
+            case wxTop:
+                {
+                    return 0;
+                }
+            case wxRight:
+                {
+                    int w, h;
+                    other->GetClientSizeConstraint(&w, &h);
+                    return w;
+                }
+            case wxBottom:
+                {
+                    int w, h;
+                    other->GetClientSizeConstraint(&w, &h);
+                    return h;
+                }
+            case wxWidth:
+                {
+                    int w, h;
+                    other->GetClientSizeConstraint(&w, &h);
+                    return w;
+                }
+            case wxHeight:
+                {
+                    int w, h;
+                    other->GetClientSizeConstraint(&w, &h);
+                    return h;
+                }
+            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();
 }
 
 /*
 }
 
 /*
@@ -1042,7 +1039,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;
@@ -1055,7 +1053,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)
     {
@@ -1080,7 +1078,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)
       {
@@ -1097,7 +1095,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
@@ -1105,7 +1103,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())
@@ -1135,588 +1133,6 @@ bool wxOldDoLayout(wxWindow *win)
 
   return TRUE;
 }
 
   return TRUE;
 }
+#endif // WXWIN_COMPATIBILITY
 
 
-wxSizer::wxSizer()
-{
-  sizerBehaviour = wxSizerNone;
-  borderX = 2;
-  borderY = 2;
-  sizerX = 0;
-  sizerY = 0;
-  sizerWidth = 0;
-  sizerHeight = 0;
-}
-
-wxSizer::wxSizer(wxWindow *parent, wxSizerBehaviour behav)
-{
-  Create(parent, behav);
-}
-
-bool wxSizer::Create(wxWindow *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:
-    {
-      // 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;
-}
-
-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
-    {
-      RemoveSizerChild(win);
-      delete win;
-    }
-    node = next;
-  }
-
-  if (m_sizerParent) // && !m_sizerParent->IsKindOf(CLASSINFO(wxSizer)))
-  {
-    m_sizerParent->SetSizer((wxSizer *) NULL);
-       m_sizerParent = (wxWindow *) NULL;
-  }
-
-}
-
-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);
-       }
-*/
-
-}
-
-void wxSizer::AddSizerChild(wxWindow *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);
-  }
-}
-
-void wxSizer::RemoveSizerChild(wxWindow *child)
-{
-  GetChildren().DeleteObject(child);
-}
-
-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);
-  }
-  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
-{
-  *w = sizerWidth;
-  *h = sizerHeight;
-}
-
-void wxSizer::GetPosition(int *x, int *y) const
-{
-  *x = sizerX;
-  *y = sizerY;
-}
-
-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:
-    {
-      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;
-
-}
-
-bool wxSizer::LayoutPhase2(int *noChanges)
-{
-  *noChanges = 0;
-
-  switch (sizerBehaviour)
-  {
-    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;
-}
-
-/*
- * wxRowColSizer
- */
-wxRowColSizer::wxRowColSizer()
-{
-  rowOrCol = TRUE;
-  rowOrColSize = 20;
-  xSpacing = 2;
-  ySpacing = 2;
-}
-
-wxRowColSizer::wxRowColSizer(wxWindow *parent, bool rc, int n, wxSizerBehaviour behav)
-{
-  Create(parent, rc, n, behav);
-}
-
-bool wxRowColSizer::Create(wxWindow *parent, bool rc, int n, wxSizerBehaviour behav)
-{
-  wxSizer::Create(parent, behav);
-  
-  rowOrCol = rc;
-  rowOrColSize = n;
-  xSpacing = 2;
-  ySpacing = 2;
-
-  return TRUE;
-}
-
-wxRowColSizer::~wxRowColSizer()
-{
-}
-
-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();
-    }
-
-    // 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)
-    {
-      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)
-        {
-          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();
-    }
-    maxX += borderX;
-    maxY += borderY;
-
-    SetSize(-1, -1, maxX, maxY);
-  }
-  return TRUE;
-}
-
-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)
-    {
-      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
-  {
-    // Lay out the children: breadth-first strategy.
-    DoPhase(1);
-    DoPhase(2);
-
-    // Space them
-  }
-  return TRUE;
-}
-
-
-/*
- * wxSpacingSizer
- */
-wxSpacingSizer::wxSpacingSizer()
-{
-}
-
-wxSpacingSizer::wxSpacingSizer(wxWindow *parent)
-{
-  Create(parent);
-}
-
-wxSpacingSizer::wxSpacingSizer(wxWindow *parent, wxRelationship rel, wxWindow *other, int spacing)
-{
-  Create(parent, rel, other, spacing);
-}
-
-bool wxSpacingSizer::Create(wxWindow *parent)
-{
-  wxSizer::Create(parent);
-  return TRUE;
-}
-
-bool wxSpacingSizer::Create(wxWindow *parent, wxRelationship rel, wxWindow *other, int spacing)
-{
-  wxLayoutConstraints *c = new wxLayoutConstraints;
-
-  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);
-
-  return TRUE;
-}
-
-wxSpacingSizer::~wxSpacingSizer()
-{
-}
-
+#endif // wxUSE_CONSTRAINTS