Added wxNewSizer and wxBorderNewSizer with sample

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3319 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
1999-08-08 16:45:57 +00:00
parent 29672bf006
commit c62ac5b6e4
6 changed files with 290 additions and 59 deletions
--- a/include/wx/sizer.h
+++ b/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 wxSizer;
-class wxBoxSizer;
+class wxNewSizerItem;
+class wxNewSizer;
+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()
-   ~wxSizer()
+   wxNewSizer();
+   ~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 )
-     { DoSetDimension( x, y, width, height ); }
+   void SetDimension( int x, int y, int width, int 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__
--- a/samples/layout/layout.cpp
+++ b/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 );
+}
+
+
--- a/samples/layout/layout.h
+++ b/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
--- a/src/common/sizer.cpp
+++ b/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.h = -1;
+    m_minSize = sizer->GetSize();
    m_option = option;
 }

-wxSize wxSizerItem::GetMinSize()
+wxSize wxNewSizerItem::GetSize()
 {
-    if (IsSizer())
-        return m_sizer->GetMinSize();
-    else
-        return m_minSize;
+    if (IsNewSizer())
+        return m_sizer->GetSize();
+	
+    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__
--- a/src/gtk/Makefile.am
+++ b/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 \
--- a/src/gtk1/Makefile.am
+++ b/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 \