Added wxNewSizer and wxBorderNewSizer with sample

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3319 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

include/wx/sizer.h

@@ -1,6 +1,6 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        sizer.h
-// Purpose:     provide wxSizer class for layounting
+// Purpose:     provide wxNewSizer class for layounting
 // Author:      Robert Roebling and Robin Dunn
 // Modified by:
 // Created:     
@@ -26,62 +26,63 @@
 // classes
 //---------------------------------------------------------------------------
 
-class wxSizerItem;
+class wxNewSizerItem;
-class wxSizer;
+class wxNewSizer;
-class wxBoxSizer;
+class wxBoxNewSizer;
 
 //---------------------------------------------------------------------------
-// wxSizerItem
+// wxNewSizerItem
 //---------------------------------------------------------------------------
 
-class WXDLLEXPORT wxSizerItem: wxObject
+class WXDLLEXPORT wxNewSizerItem: public wxObject
 {
 public:
   // spacer
-  wxSizerItem( int width, int height, int option )
+  wxNewSizerItem( int width, int height, int option );
 
   // window
-  wxSizerItem( wxWindow *window, int option );
+  wxNewSizerItem( wxWindow *window, int option );
 
   // subsizer
-  wxSizerItem( wxSizer *sizer, int option );
+  wxNewSizerItem( wxNewSizer *sizer, int option );
 
-  virtual wxSize GetMinSize();
+  virtual wxSize GetSize();
+  virtual wxSize CalcMin();
+  virtual void SetDimension( wxPoint pos, wxSize size );
   
   bool IsWindow();
-  bool IsSizer();
+  bool IsNewSizer();
   bool IsSpacer();
   
   wxWindow *GetWindow() const  
     { return m_window; }
-  wxSizer *GetSizer() const    
+  wxNewSizer *GetNewSizer() const    
     { return m_sizer; }
   int GetOption() const
     { return m_option; }
   
-private:
+protected:
   wxWindow    *m_window;
-  wxSizer     *m_sizer;
+  wxNewSizer     *m_sizer;
   wxSize       m_minSize;
   int          m_option;
-}
+};
 
 //---------------------------------------------------------------------------
-// wxSizer
+// wxNewSizer
 //---------------------------------------------------------------------------
 
-class WXDLLEXPORT wxSizer: wxObject
+class WXDLLEXPORT wxNewSizer: public wxObject
 {
 public:
-   wxSizer()
+   wxNewSizer();
-   ~wxSizer()
+   ~wxNewSizer();
    
    virtual void Add( wxWindow *window, int option = 0 );
-   virtual void Add( wxSizer *sizer, int option = 0  );
+   virtual void Add( wxNewSizer *sizer, int option = 0  );
    virtual void Add( int width, int height, int option = 0  );
   
-   void SetDimension( int x, int y, int width, int height )
+   void SetDimension( int x, int y, int width, int height );
-     { DoSetDimension( x, y, width, height ); }
   
    wxSize GetSize()
      { return m_size; }
@@ -89,21 +90,52 @@ public:
      { return m_position; }
    wxSize GetMinSize()
      { return CalcMin(); }
-     
+
    virtual void RecalcSizes() = 0;
    virtual wxSize CalcMin() = 0;
+   
+   virtual void Layout();
 
    void Fit( wxWindow *window );
    void SetSizeHints( wxWindow *window );
    
-private:
+protected:
    wxSize  m_size;
    wxPoint m_position;
    wxList  m_children;
    
    wxSize GetMinWindowSize( wxWindow *window );
-   virtual void DoSetDimension( int x, int y, int width, int height );
+};
-}
+
+//---------------------------------------------------------------------------
+// wxBorderNewSizer
+//---------------------------------------------------------------------------
+
+#define wxWEST  wxLEFT
+#define wxEAST  wxRIGHT
+#define wxNORTH wxUP
+#define wxSOUTH wxDOWN
+#define wxALL_DIRECTIONS (wxNORTH | wxSOUTH | wxEAST | wxWEST)
+
+class WXDLLEXPORT wxBorderNewSizer: public wxNewSizer
+{
+public:
+   wxBorderNewSizer( int sides = wxALL_DIRECTIONS );
+   
+   virtual void Add( wxWindow *window, int option = 10 );
+   virtual void Add( wxNewSizer *sizer, int option = 10 );
+   virtual void Add( int width, int height, int option = 10 );
+   
+   void RecalcSizes();
+   wxSize CalcMin();
+   
+   int GetSides()
+     { return m_sides; }
+   
+protected:
+   int    m_sides;
+};
+  
 
 #endif
   // __WXSIZER_H__

samples/layout/layout.cpp

@@ -25,6 +25,8 @@
 #endif
 
 #include <ctype.h>
+#include "wx/sizer.h"
+
 #include "layout.h"
 
 // Declare two frames
@@ -52,6 +54,7 @@ bool MyApp::OnInit(void)
 
   file_menu->Append(LAYOUT_LOAD_FILE, "&Load file",      "Load a text file");
   file_menu->Append(LAYOUT_TEST, "&Test sizers",      "Test sizer code");
+  file_menu->Append(LAYOUT_TEST_NEW, "&Test new sizers",      "Test new sizer code");
 
   file_menu->AppendSeparator();
   file_menu->Append(LAYOUT_QUIT, "E&xit",                "Quit program");
@@ -152,6 +155,10 @@ bool MyApp::OnInit(void)
   return TRUE;
 }
 
+//-----------------------------------------------------------------
+//  MyFrame
+//-----------------------------------------------------------------
+
 // Define my frame constructor
 MyFrame::MyFrame(wxFrame *frame, char *title, int x, int y, int w, int h):
   wxFrame(frame, -1, title, wxPoint(x, y), wxSize(w, h))
@@ -165,6 +172,7 @@ BEGIN_EVENT_TABLE(MyFrame, wxFrame)
   EVT_MENU(LAYOUT_LOAD_FILE, MyFrame::LoadFile)
   EVT_MENU(LAYOUT_QUIT, MyFrame::Quit)
   EVT_MENU(LAYOUT_TEST, MyFrame::TestSizers)
+  EVT_MENU(LAYOUT_TEST_NEW, MyFrame::TestNewSizers)
   EVT_MENU(LAYOUT_ABOUT, MyFrame::About)
   EVT_SIZE(MyFrame::OnSize)
 END_EVENT_TABLE()
@@ -188,7 +196,13 @@ void MyFrame::Quit(wxCommandEvent& WXUNUSED(event) )
 
 void MyFrame::TestSizers(wxCommandEvent& WXUNUSED(event) )
 {
-  SizerFrame *newFrame = new SizerFrame((MyFrame *) NULL, (char *) "Sizer Test Frame", 50, 50, 500, 500);
+  SizerFrame *newFrame = new SizerFrame((MyFrame *) NULL, "Sizer Test Frame", 50, 50, 500, 500);
+  newFrame->Show(TRUE);
+}
+
+void MyFrame::TestNewSizers(wxCommandEvent& WXUNUSED(event) )
+{
+  NewSizerFrame *newFrame = new NewSizerFrame((MyFrame *) NULL, "Sizer Test Frame", 50, 50 );
   newFrame->Show(TRUE);
 }
 
@@ -224,6 +238,10 @@ void MyFrame::Draw(wxDC& dc, bool WXUNUSED(draw_bitmaps) )
   dc.DrawArc(50, 300, 100, 250, 100, 300 );
 }
 
+//-----------------------------------------------------------------
+//  MyWindow
+//-----------------------------------------------------------------
+
 BEGIN_EVENT_TABLE(MyWindow, wxWindow)
     EVT_PAINT(MyWindow::OnPaint)
 END_EVENT_TABLE()
@@ -245,6 +263,9 @@ void MyWindow::OnPaint(wxPaintEvent& WXUNUSED(event) )
   frame->Draw(dc,TRUE);
 }
 
+//-----------------------------------------------------------------
+//  SizerFrame
+//-----------------------------------------------------------------
 
 SizerFrame::SizerFrame(wxFrame *frame, char *title, int x, int y, int w, int h):
   wxFrame(frame, -1, title, wxPoint(x, y), wxSize(w, h))
@@ -339,3 +360,43 @@ void SizerFrame::OnSize(wxSizeEvent& event)
   panel->Layout();
 }
 
+//-----------------------------------------------------------------
+//  NewSizerFrame
+//-----------------------------------------------------------------
+
+NewSizerFrame::NewSizerFrame(wxFrame *frame, char *title, int x, int y ):
+  wxFrame(frame, -1, title, wxPoint(x, y) )
+{
+  // no extra options means border all around  
+  topsizer = new wxBorderNewSizer();
+  
+  // make border 20 pixels wide
+  topsizer->Add( new wxButton( this, -1, "Hello" ), 20 );
+  
+  // set frame to minimum size
+  topsizer->Fit( this );  
+  
+  // don't allow frame to get smaller than what the sizers tell ye
+  topsizer->SetSizeHints( this );  
+  
+  // layout widgets
+  topsizer->Layout();
+}
+
+// This can later be removed if we integrate wxNewSizers
+// into wxWindows
+
+BEGIN_EVENT_TABLE(NewSizerFrame, wxFrame)
+  EVT_SIZE(NewSizerFrame::OnSize)
+END_EVENT_TABLE()
+
+void NewSizerFrame::OnSize(wxSizeEvent& event)
+{
+  wxFrame::OnSize(event);
+
+  wxSize client_size( GetClientSize() );
+   
+  topsizer->SetDimension( 0, 0, client_size.x, client_size.y );
+}
+
+

samples/layout/layout.h

@@ -34,6 +34,7 @@ class MyFrame: public wxFrame
     void LoadFile(wxCommandEvent& event);
     void Quit(wxCommandEvent& event);
     void TestSizers(wxCommandEvent& event);
+    void TestNewSizers(wxCommandEvent& event);
     void About(wxCommandEvent& event);
 
   DECLARE_EVENT_TABLE()
@@ -71,7 +72,19 @@ class SizerFrame: public wxFrame
    DECLARE_EVENT_TABLE()
 };
 
+class NewSizerFrame: public wxFrame
+{
+  public:
+    wxPanel *panel;
+    wxNewSizer *topsizer;
+    NewSizerFrame(wxFrame *frame, char *title, int x, int y );
+    void OnSize(wxSizeEvent& event);
+
+   DECLARE_EVENT_TABLE()
+};
+
 #define LAYOUT_QUIT       100
 #define LAYOUT_TEST       101
 #define LAYOUT_ABOUT      102
 #define LAYOUT_LOAD_FILE  103
+#define LAYOUT_TEST_NEW   104

src/common/sizer.cpp

@@ -1,6 +1,6 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        sizer.cpp
-// Purpose:     provide wxSizer class for layounting
+// Purpose:     provide wxNewSizer class for layounting
 // Author:      Robert Roebling and Robin Dunn
 // Modified by:
 // Created:     
@@ -13,105 +13,135 @@
 #define __WXSIZERS_H__
 
 #ifdef __GNUG__
-#pragma interface "sizers.h"
+#pragma implementation "sizer.h"
 #endif
 
 #include "wx/sizer.h"
 
 
 //---------------------------------------------------------------------------
-// wxSizerItem
+// wxNewSizerItem
 //---------------------------------------------------------------------------
 
-wxSizerItem::wxSizerItem( int width, int height, int option )
+wxNewSizerItem::wxNewSizerItem( int width, int height, int option )
 {
     m_window = (wxWindow *) NULL;
-    m_sizer = (wxSizer *) NULL;
+    m_sizer = (wxNewSizer *) NULL;
     m_minSize.x = width;
-    m_minSize.h = height;
+    m_minSize.y = height;
     m_option = option;
 }
 
-wxSizerItem::wxSizerItem( wxWindow *window, int option )
+wxNewSizerItem::wxNewSizerItem( wxWindow *window, int option )
 {
     m_window = window;
-    m_sizer = (wxSizer *) NULL;
+    m_sizer = (wxNewSizer *) NULL;
     m_minSize = window->GetSize();
     m_option = option;
 }
 
-wxSizerItem::wxSizerItem( wxSizer *sizer, int option )
+wxNewSizerItem::wxNewSizerItem( wxNewSizer *sizer, int option )
 {
     m_window = (wxWindow *) NULL;
     m_sizer = sizer;
-    m_minSize.x = -1;
+    m_minSize = sizer->GetSize();
-    m_minSize.h = -1;
     m_option = option;
 }
 
-wxSize wxSizerItem::GetMinSize()
+wxSize wxNewSizerItem::GetSize()
 {
-    if (IsSizer())
+    if (IsNewSizer())
-        return m_sizer->GetMinSize();
+        return m_sizer->GetSize();
-    else
+	
-        return m_minSize;
+    if (IsWindow())
+        return m_window->GetSize();
+	
+    return m_minSize;
 }
 
-bool wxSizerItem::IsWindow()
+wxSize wxNewSizerItem::CalcMin()
+{
+    if (IsNewSizer())
+        return m_sizer->CalcMin();
+	
+    if (IsWindow())
+        return m_window->GetSize();
+	
+    return m_minSize;
+}
+
+void wxNewSizerItem::SetDimension( wxPoint pos, wxSize size )
+{
+    if (IsNewSizer())
+        m_sizer->SetDimension( pos.x, pos.y, size.x, size.y );
+	
+    if (IsWindow())
+        m_window->SetSize( pos.x, pos.y, size.x, size.y );
+	
+    m_minSize = size;
+}
+
+bool wxNewSizerItem::IsWindow()
 {
     return (m_window != NULL);
 }
 
-bool wxSizerItem::IsSizer()
+bool wxNewSizerItem::IsNewSizer()
 {
     return (m_sizer != NULL);
 }
 
-bool wxSizerItem::IsSpacer()
+bool wxNewSizerItem::IsSpacer()
 {
     return (m_window == NULL) && (m_sizer == NULL);
 }
 
 //---------------------------------------------------------------------------
-// wxSizer
+// wxNewSizer
 //---------------------------------------------------------------------------
 
-wxSizer::wxSizer()
+wxNewSizer::wxNewSizer()
 {
     m_children.DeleteContents( TRUE );
 }
 
-wxSizer::~wxSizer()
+wxNewSizer::~wxNewSizer()
 {
 }
    
-void wxSizer::Add( wxWindow *window, int option )
+void wxNewSizer::Add( wxWindow *window, int option )
 {
-    m_children.Append( new wxSizerItem( window, option ) );
+    m_children.Append( new wxNewSizerItem( window, option ) );
 }
 
-void wxSizer::Add( wxSizer *sizer, int option )
+void wxNewSizer::Add( wxNewSizer *sizer, int option )
 {
-    m_children.Append( new wxSizerItem( sizer, option ) );
+    m_children.Append( new wxNewSizerItem( sizer, option ) );
 }
 
-void wxSizer::Add( int width, int height, int option )
+void wxNewSizer::Add( int width, int height, int option )
 {
-    m_children.Append( new wxSizerItem( width, height, option ) );
+    m_children.Append( new wxNewSizerItem( width, height, option ) );
 }
 
-void wxSizer::Fit( wxWindow *window );
+void wxNewSizer::Fit( wxWindow *window )
 {
     window->SetSize( GetMinWindowSize( window ) );
 }
 
-void wxSizer::SetSizeHints( wxWindow *window );
+void wxNewSizer::Layout()
+{
+    m_size = CalcMin();
+    RecalcSizes();
+}
+
+void wxNewSizer::SetSizeHints( wxWindow *window )
 {
     wxSize size( GetMinWindowSize( window ) );
     window->SetSizeHints( size.x, size.y );
 }
 
-wxSize wxSizer::GetMinWindowSize( wxWindow *window )
+wxSize wxNewSizer::GetMinWindowSize( wxWindow *window )
 {
     wxSize min( GetMinSize() );
     wxSize size( window->GetSize() );
@@ -119,7 +149,7 @@ wxSize wxSizer::GetMinWindowSize( wxWindow *window )
     return wxSize( min.x+size.x-client_size.x, min.y+size.y-client_size.y ); 
 }
 
-void wxSizer::DoSetDimension( int x, int y, int width, int height )
+void wxNewSizer::SetDimension( int x, int y, int width, int height )
 {
     m_position.x = x;
     m_position.y = y;
@@ -128,5 +158,98 @@ void wxSizer::DoSetDimension( int x, int y, int width, int height )
     RecalcSizes();
 }
 
+//---------------------------------------------------------------------------
+// wxBorderNewSizer
+//---------------------------------------------------------------------------
+
+wxBorderNewSizer::wxBorderNewSizer( int sides )
+{
+    m_sides = sides;
+}
+
+void wxBorderNewSizer::Add( wxWindow *window, int option )
+{
+   wxCHECK_RET( m_children.GetCount() == 0, _T("border sizer can only hold one child") );
+   
+   wxNewSizer::Add( window, option );
+}
+
+void wxBorderNewSizer::Add( wxNewSizer *sizer, int option )
+{
+   wxCHECK_RET( m_children.GetCount() == 0, _T("border sizer can only hold one child") );
+   
+   wxNewSizer::Add( sizer, option );
+}
+
+void wxBorderNewSizer::Add( int width, int height, int option )
+{
+   wxCHECK_RET( m_children.GetCount() == 0, _T("border sizer can only hold one child") );
+   
+   wxNewSizer::Add( width, height, option );
+}
+
+void wxBorderNewSizer::RecalcSizes()
+{
+    wxNode *node = m_children.GetFirst();
+    
+    if (!node)
+    {
+        SetDimension( m_position.x, m_position.y, 2, 2 );
+        return;
+    }
+    
+    wxNewSizerItem *item = (wxNewSizerItem*) node->Data();
+    
+    wxSize size( m_size );
+    wxPoint pt( m_position );
+    int borderSize = item->GetOption();
+    
+    if (m_sides & wxWEST)
+    {
+        size.x -= borderSize;
+        pt.x += borderSize;
+    }
+    if (m_sides & wxEAST)
+    {
+        size.x -= borderSize;
+    }
+    if (m_sides & wxNORTH)
+    {
+        size.y -= borderSize;
+	pt.y += borderSize;
+    }
+    if (m_sides & wxSOUTH)
+    {
+        size.y -= borderSize;
+    }
+    
+    item->SetDimension( pt, size );
+}
+
+wxSize wxBorderNewSizer::CalcMin()
+{
+    wxNode *node = m_children.GetFirst();
+    
+    if (!node)
+        return wxSize(2,2);
+    
+    wxNewSizerItem *item = (wxNewSizerItem*) node->Data();
+    
+    wxSize size( item->CalcMin() );
+    
+    int borderSize = item->GetOption();
+    
+    if (m_sides & wxWEST)
+        size.x += borderSize;
+    if (m_sides & wxEAST)
+        size.x += borderSize;
+    if (m_sides & wxNORTH)
+        size.y += borderSize;
+    if (m_sides & wxSOUTH)
+        size.y += borderSize;
+	
+    return size;
+}
+
 #endif
   // __SIZERS_H__

src/gtk/Makefile.am

@@ -85,6 +85,7 @@ libwx_gtk_la_SOURCES = \
  sckipc.cpp \
  sckstrm.cpp \
  serbase.cpp \
+ sizer.cpp \
  socket.cpp \
  strconv.cpp \
  stream.cpp \

src/gtk1/Makefile.am

@@ -85,6 +85,7 @@ libwx_gtk_la_SOURCES = \
  sckipc.cpp \
  sckstrm.cpp \
  serbase.cpp \
+ sizer.cpp \
  socket.cpp \
  strconv.cpp \
  stream.cpp \