changing to wxDC, so that wxGCDC can be used as well

[wxWidgets.git] / include / wx / sizer.h

diff --git a/include/wx/sizer.h b/include/wx/sizer.h
index 8aa759e376e2661663c537395395b58420731ba1..8ae125062dac6c539ab553cb8234d53b711ea0bd 100644 (file)
--- a/include/wx/sizer.h
+++ b/include/wx/sizer.h
@@ -20,10 +20,10 @@
 // classes
 //---------------------------------------------------------------------------
 
 // classes
 //---------------------------------------------------------------------------
 

-class WXDLLEXPORT wxButton;
-class WXDLLEXPORT wxBoxSizer;
-class WXDLLEXPORT wxSizerItem;
-class WXDLLEXPORT wxSizer;
+class WXDLLIMPEXP_FWD_CORE wxButton;
+class WXDLLIMPEXP_FWD_CORE wxBoxSizer;
+class WXDLLIMPEXP_FWD_CORE wxSizerItem;
+class WXDLLIMPEXP_FWD_CORE wxSizer;

 
 #ifndef wxUSE_BORDER_BY_DEFAULT
     #ifdef __SMARTPHONE__
 
 #ifndef wxUSE_BORDER_BY_DEFAULT
     #ifdef __SMARTPHONE__


@@ -73,7 +73,7 @@ public:
     }
 
     // some shortcuts for Align()
     }
 
     // some shortcuts for Align()

-    wxSizerFlags& Centre() { return Align(wxCENTRE); }
+    wxSizerFlags& Centre() { return Align(wxALIGN_CENTRE); }

     wxSizerFlags& Center() { return Centre(); }
     wxSizerFlags& Top() { return Align(wxALIGN_TOP); }
     wxSizerFlags& Left() { return Align(wxALIGN_LEFT); }
     wxSizerFlags& Center() { return Centre(); }
     wxSizerFlags& Top() { return Align(wxALIGN_TOP); }
     wxSizerFlags& Left() { return Align(wxALIGN_LEFT); }


@@ -298,6 +298,11 @@ public:
 
     virtual wxRect GetRect() { return m_rect; }
 
 
     virtual wxRect GetRect() { return m_rect; }
 

+    // set a sizer item id (different from a window id, all sizer items,
+    // including spacers, can have an associated id)
+    void SetId(int id) { m_id = id; }
+    int GetId() const { return m_id; }
+

     bool IsWindow() const { return m_kind == Item_Window; }
     bool IsSizer() const { return m_kind == Item_Sizer; }
     bool IsSpacer() const { return m_kind == Item_Spacer; }
     bool IsWindow() const { return m_kind == Item_Window; }
     bool IsSizer() const { return m_kind == Item_Sizer; }
     bool IsSpacer() const { return m_kind == Item_Spacer; }


@@ -340,6 +345,12 @@ public:
     wxPoint GetPosition() const
         { return m_pos; }
 
     wxPoint GetPosition() const
         { return m_pos; }
 

+    // Called once the first component of an item has been decided. This is 
+    // used in algorithms that depend on knowing the size in one direction 
+    // before the min size in the other direction can be known. 
+    // Returns true if it made use of the information (and min size was changed).
+    bool InformFirstDirection( int direction, int size, int availableOtherDir=-1 );
+

     // these functions delete the current contents of the item if it's a sizer
     // or a spacer but not if it is a window
     void AssignWindow(wxWindow *window)
     // these functions delete the current contents of the item if it's a sizer
     // or a spacer but not if it is a window
     void AssignWindow(wxWindow *window)


@@ -407,6 +418,7 @@ protected:
     int          m_proportion;
     int          m_border;
     int          m_flag;
     int          m_proportion;
     int          m_border;
     int          m_flag;

+    int          m_id;

 
     // on screen rectangle of this item (not including borders)
     wxRect       m_rect;
 
     // on screen rectangle of this item (not including borders)
     wxRect       m_rect;


@@ -456,6 +468,7 @@ public:
                      wxObject* userData = NULL);
     wxSizerItem* Add( wxWindow *window, const wxSizerFlags& flags);
     wxSizerItem* Add( wxSizer *sizer, const wxSizerFlags& flags);
                      wxObject* userData = NULL);
     wxSizerItem* Add( wxWindow *window, const wxSizerFlags& flags);
     wxSizerItem* Add( wxSizer *sizer, const wxSizerFlags& flags);

+    wxSizerItem* Add( int width, int height, const wxSizerFlags& flags);

     wxSizerItem* Add( wxSizerItem *item);
 
     wxSizerItem* AddSpacer(int size);
     wxSizerItem* Add( wxSizerItem *item);
 
     wxSizerItem* AddSpacer(int size);


@@ -486,6 +499,10 @@ public:
     wxSizerItem* Insert(size_t index,
                         wxSizer *sizer,
                         const wxSizerFlags& flags);
     wxSizerItem* Insert(size_t index,
                         wxSizer *sizer,
                         const wxSizerFlags& flags);

+    wxSizerItem* Insert(size_t index,
+                        int width,
+                        int height,
+                        const wxSizerFlags& flags);                        

     virtual wxSizerItem* Insert( size_t index, wxSizerItem *item);
 
     wxSizerItem* InsertSpacer(size_t index, int size);
     virtual wxSizerItem* Insert( size_t index, wxSizerItem *item);
 
     wxSizerItem* InsertSpacer(size_t index, int size);


@@ -509,6 +526,7 @@ public:
                          wxObject* userData = NULL);
     wxSizerItem* Prepend(wxWindow *window, const wxSizerFlags& flags);
     wxSizerItem* Prepend(wxSizer *sizer, const wxSizerFlags& flags);
                          wxObject* userData = NULL);
     wxSizerItem* Prepend(wxWindow *window, const wxSizerFlags& flags);
     wxSizerItem* Prepend(wxSizer *sizer, const wxSizerFlags& flags);

+    wxSizerItem* Prepend(int width, int height, const wxSizerFlags& flags);

     wxSizerItem* Prepend(wxSizerItem *item);
 
     wxSizerItem* PrependSpacer(int size);
     wxSizerItem* Prepend(wxSizerItem *item);
 
     wxSizerItem* PrependSpacer(int size);


@@ -539,6 +557,11 @@ public:
     virtual void Clear( bool delete_windows = false );
     virtual void DeleteWindows();
 
     virtual void Clear( bool delete_windows = false );
     virtual void DeleteWindows();
 

+    // Inform sizer about the first direction that has been decided (by parent item)
+    // Returns true if it made use of the informtion (and recalculated min size)
+    virtual bool InformFirstDirection( int WXUNUSED(direction), int WXUNUSED(size), int WXUNUSED(availableOtherDir) )
+        { return false; }
+    

     void SetMinSize( int width, int height )
         { DoSetMinSize( width, height ); }
     void SetMinSize( const wxSize& size )
     void SetMinSize( int width, int height )
         { DoSetMinSize( width, height ); }
     void SetMinSize( const wxSize& size )


@@ -569,15 +592,22 @@ public:
     // Calculate the minimal size or return m_minSize if bigger.
     wxSize GetMinSize();
 
     // Calculate the minimal size or return m_minSize if bigger.
     wxSize GetMinSize();
 

-    virtual void RecalcSizes() = 0;
+    // These virtual functions are used by the layout algorithm: first
+    // CalcMin() is called to calculate the minimal size of the sizer and
+    // prepare for laying it out and then RecalcSizes() is called to really
+    // update all the sizer items

     virtual wxSize CalcMin() = 0;
     virtual wxSize CalcMin() = 0;

+    virtual void RecalcSizes() = 0;

 
     virtual void Layout();
 
     wxSize Fit( wxWindow *window );
     void FitInside( wxWindow *window );
     void SetSizeHints( wxWindow *window );
 
     virtual void Layout();
 
     wxSize Fit( wxWindow *window );
     void FitInside( wxWindow *window );
     void SetSizeHints( wxWindow *window );

-    void SetVirtualSizeHints( wxWindow *window );
+#if WXWIN_COMPATIBILITY_2_8
+    // This only calls FitInside() since 2.9
+    wxDEPRECATED( void SetVirtualSizeHints( wxWindow *window ) );
+#endif

 
     wxSizerItemList& GetChildren()
         { return m_children; }
 
     wxSizerItemList& GetChildren()
         { return m_children; }


@@ -589,6 +619,7 @@ public:
     wxSizerItem* GetItem( wxWindow *window, bool recursive = false );
     wxSizerItem* GetItem( wxSizer *sizer, bool recursive = false );
     wxSizerItem* GetItem( size_t index );
     wxSizerItem* GetItem( wxWindow *window, bool recursive = false );
     wxSizerItem* GetItem( wxSizer *sizer, bool recursive = false );
     wxSizerItem* GetItem( size_t index );

+    wxSizerItem* GetItemById( int id, bool recursive = false );

 
     // Manage whether individual scene items are considered
     // in the layout calculations or not.
 
     // Manage whether individual scene items are considered
     // in the layout calculations or not.


@@ -730,8 +761,8 @@ public:
 
 protected:
     void AdjustForFlexDirection();
 
 protected:
     void AdjustForFlexDirection();

-    void AdjustForGrowables(const wxSize& sz, const wxSize& minsz,
-                            int nrows, int ncols);
+    void AdjustForGrowables(const wxSize& sz);
+    void FindWidthsAndHeights(int nrows, int ncols);

 
     // the heights/widths of all rows/columns
     wxArrayInt  m_rowHeights,
 
     // the heights/widths of all rows/columns
     wxArrayInt  m_rowHeights,


@@ -765,36 +796,122 @@ private:
 class WXDLLEXPORT wxBoxSizer: public wxSizer
 {
 public:
 class WXDLLEXPORT wxBoxSizer: public wxSizer
 {
 public:

-    wxBoxSizer( int orient );
+    wxBoxSizer(int orient)
+    {
+        m_orient = orient;

 
 

-    void RecalcSizes();
-    wxSize CalcMin();
+        wxASSERT_MSG( m_orient == wxHORIZONTAL || m_orient == wxVERTICAL,
+                      _T("invalid value for wxBoxSizer orientation") );
+    }

 
 

-    int GetOrientation() const
-        { return m_orient; }
+    int GetOrientation() const { return m_orient; }

 
 

-    void SetOrientation(int orient)
-        { m_orient = orient; }
+    bool IsVertical() const { return m_orient == wxVERTICAL; }
+
+    void SetOrientation(int orient) { m_orient = orient; }
+
+    // implementation of our resizing logic
+    virtual wxSize CalcMin();
+    virtual void RecalcSizes();

 
 protected:
 
 protected:

+    // helpers for our code: this returns the component of the given wxSize in
+    // the direction of the sizer and in the other direction, respectively
+    int GetSizeInMajorDir(const wxSize& sz) const
+    {
+        return m_orient == wxHORIZONTAL ? sz.x : sz.y;
+    }
+
+    int& SizeInMajorDir(wxSize& sz)
+    {
+        return m_orient == wxHORIZONTAL ? sz.x : sz.y;
+    }
+
+    int& PosInMajorDir(wxPoint& pt)
+    {
+        return m_orient == wxHORIZONTAL ? pt.x : pt.y;
+    }
+
+    int GetSizeInMinorDir(const wxSize& sz) const
+    {
+        return m_orient == wxHORIZONTAL ? sz.y : sz.x;
+    }
+
+    int& SizeInMinorDir(wxSize& sz)
+    {
+        return m_orient == wxHORIZONTAL ? sz.y : sz.x;
+    }
+
+    int& PosInMinorDir(wxPoint& pt)
+    {
+        return m_orient == wxHORIZONTAL ? pt.y : pt.x;
+    }
+
+    // another helper: creates wxSize from major and minor components
+    wxSize SizeFromMajorMinor(int major, int minor) const
+    {
+        if ( m_orient == wxHORIZONTAL )
+        {
+            return wxSize(major, minor);
+        }
+        else // wxVERTICAL
+        {
+            return wxSize(minor, major);
+        }
+    }
+
+
+    // either wxHORIZONTAL or wxVERTICAL

     int m_orient;
     int m_orient;

-    int m_stretchable;
-    int m_minWidth;
-    int m_minHeight;
-    int m_fixedWidth;
-    int m_fixedHeight;
+
+    // the sum of proportion of all of our elements
+    int m_totalProportion;
+
+    // the minimal size needed for this sizer as calculated by the last call to
+    // our CalcMin()
+    wxSize m_minSize;

 
 private:
     DECLARE_CLASS(wxBoxSizer)
 };
 
 
 private:
     DECLARE_CLASS(wxBoxSizer)
 };
 

+//---------------------------------------------------------------------------
+// wxWrapSizer - A box sizer that can wrap items on several lines when 
+// widths exceed available width.
+//---------------------------------------------------------------------------
+
+// Borrow unused flag value
+#define wxEXTEND_LAST_ON_EACH_LINE     wxFULL_REPAINT_ON_RESIZE
+
+class WXDLLEXPORT wxWrapSizer: public wxBoxSizer
+{
+public:
+    wxWrapSizer( int orient=wxHORIZONTAL, int flags=wxEXTEND_LAST_ON_EACH_LINE );
+    virtual ~wxWrapSizer();
+
+    virtual void RecalcSizes();
+    virtual wxSize CalcMin();
+    
+    virtual bool InformFirstDirection( int direction, int size, int availableOtherDir );
+    
+protected:
+    int m_prim_size_last;    // Size in primary direction last time
+    int m_n_line;            // Number of lines
+    wxBoxSizer m_rows;       // Rows of items
+    int m_flags;
+
+    void AdjustPropLastItem(wxSizer *psz, wxSizerItem *itemLast);    
+    
+    DECLARE_DYNAMIC_CLASS(wxWrapSizer)
+};
+

 //---------------------------------------------------------------------------
 // wxStaticBoxSizer
 //---------------------------------------------------------------------------
 
 #if wxUSE_STATBOX
 
 //---------------------------------------------------------------------------
 // wxStaticBoxSizer
 //---------------------------------------------------------------------------
 
 #if wxUSE_STATBOX
 

-class WXDLLEXPORT wxStaticBox;
+class WXDLLIMPEXP_FWD_CORE wxStaticBox;

 
 class WXDLLEXPORT wxStaticBoxSizer: public wxBoxSizer
 {
 
 class WXDLLEXPORT wxStaticBoxSizer: public wxBoxSizer
 {


@@ -862,10 +979,10 @@ public:
 
 protected:
     wxButton *m_buttonAffirmative;  // wxID_OK, wxID_YES, wxID_SAVE go here
 
 protected:
     wxButton *m_buttonAffirmative;  // wxID_OK, wxID_YES, wxID_SAVE go here

-    wxButton *m_buttonApply;
+    wxButton *m_buttonApply;        // wxID_APPLY

     wxButton *m_buttonNegative;     // wxID_NO
     wxButton *m_buttonNegative;     // wxID_NO

-    wxButton *m_buttonCancel;
-    wxButton *m_buttonHelp;
+    wxButton *m_buttonCancel;       // wxID_CANCEL, wxID_CLOSE
+    wxButton *m_buttonHelp;         // wxID_HELP, wxID_CONTEXT_HELP

 
 private:
     DECLARE_CLASS(wxStdDialogButtonSizer)
 
 private:
     DECLARE_CLASS(wxStdDialogButtonSizer)


@@ -940,6 +1057,12 @@ wxSizer::Add( wxSizer *sizer, const wxSizerFlags& flags )
     return Add( new wxSizerItem(sizer, flags) );
 }
 
     return Add( new wxSizerItem(sizer, flags) );
 }
 

+inline wxSizerItem*
+wxSizer::Add( int width, int height, const wxSizerFlags& flags )
+{
+    return Add( new wxSizerItem(width, height, flags) );
+}
+

 inline wxSizerItem*
 wxSizer::AddSpacer(int size)
 {
 inline wxSizerItem*
 wxSizer::AddSpacer(int size)
 {


@@ -1000,6 +1123,12 @@ wxSizer::Prepend( wxSizer *sizer, const wxSizerFlags& flags )
     return Prepend( new wxSizerItem(sizer, flags) );
 }
 
     return Prepend( new wxSizerItem(sizer, flags) );
 }
 

+inline wxSizerItem*
+wxSizer::Prepend( int width, int height, const wxSizerFlags& flags )
+{
+    return Prepend( new wxSizerItem(width, height, flags) );
+}
+

 inline wxSizerItem*
 wxSizer::Insert( size_t index,
                  wxWindow *window,
 inline wxSizerItem*
 wxSizer::Insert( size_t index,
                  wxWindow *window,


@@ -1046,6 +1175,12 @@ wxSizer::Insert( size_t index, wxSizer *sizer, const wxSizerFlags& flags )
     return Insert( index, new wxSizerItem(sizer, flags) );
 }
 
     return Insert( index, new wxSizerItem(sizer, flags) );
 }
 

+inline wxSizerItem*
+wxSizer::Insert( size_t index, int width, int height, const wxSizerFlags& flags )
+{
+    return Insert( index, new wxSizerItem(width, height, flags) );
+}
+

 inline wxSizerItem*
 wxSizer::InsertSpacer(size_t index, int size)
 {
 inline wxSizerItem*
 wxSizer::InsertSpacer(size_t index, int size)
 {