Implemented (for GTK+) and tested dataview_context_menu event

[wxWidgets.git] / src / common / sizer.cpp

diff --git a/src/common/sizer.cpp b/src/common/sizer.cpp
index bb2ca4fe1635e5ed8bd421a6322593103d454de2..a35871787601b52b85b7f13e35bbd80d8be80dc9 100644 (file)
--- a/src/common/sizer.cpp
+++ b/src/common/sizer.cpp
@@ -274,68 +274,68 @@ wxSize wxSizerItem::GetSize() const
 
 bool wxSizerItem::InformFirstDirection(int direction, int size, int availableOtherDir)
 {
 
 bool wxSizerItem::InformFirstDirection(int direction, int size, int availableOtherDir)
 {

-       // The size that come here will be including borders. Child items should get it 
-       // without borders. 
-       if( size>0 )
-       {
-               if( direction==wxHORIZONTAL )
-               {
-                   if (m_flag & wxWEST)
-                       size -= m_border;
-                   if (m_flag & wxEAST)
-                       size -= m_border;
-               }
-               else if( direction==wxVERTICAL )
-               {
-                   if (m_flag & wxNORTH)
-                       size -= m_border;
-                   if (m_flag & wxSOUTH)
-                       size -= m_border;
-               }
-       }
-       
+    // The size that come here will be including borders. Child items should get it
+    // without borders.
+    if( size>0 )
+    {
+        if( direction==wxHORIZONTAL )
+        {
+            if (m_flag & wxWEST)
+                size -= m_border;
+            if (m_flag & wxEAST)
+                size -= m_border;
+        }
+        else if( direction==wxVERTICAL )
+        {
+            if (m_flag & wxNORTH)
+                size -= m_border;
+            if (m_flag & wxSOUTH)
+                size -= m_border;
+        }
+    }
+

     bool didUse = false;
     // Pass the information along to the held object
     if (IsSizer())
     {
         didUse = GetSizer()->InformFirstDirection(direction,size,availableOtherDir);
         if (didUse)
     bool didUse = false;
     // Pass the information along to the held object
     if (IsSizer())
     {
         didUse = GetSizer()->InformFirstDirection(direction,size,availableOtherDir);
         if (didUse)

-               m_minSize = GetSizer()->CalcMin();
+            m_minSize = GetSizer()->CalcMin();

     }
     else if (IsWindow())
     {
         didUse =  GetWindow()->InformFirstDirection(direction,size,availableOtherDir);
         if (didUse)
             m_minSize = m_window->GetEffectiveMinSize();
     }
     else if (IsWindow())
     {
         didUse =  GetWindow()->InformFirstDirection(direction,size,availableOtherDir);
         if (didUse)
             m_minSize = m_window->GetEffectiveMinSize();

-    
-           // This information is useful for items with wxSHAPED flag, since 
-           // we can request an optimal min size for such an item. Even if 
-           // we overwrite the m_minSize member here, we can read it back from 
-           // the owned window (happens automatically).
-           if( (m_flag & wxSHAPED) && (m_flag & wxEXPAND) && direction )
-           {
-               if( !wxIsNullDouble(m_ratio) )
-               {
-                   wxCHECK_MSG( (m_proportion==0), false, _T("Shaped item, non-zero proportion in wxSizerItem::InformFirstDirection()") );
-                   if( direction==wxHORIZONTAL && !wxIsNullDouble(m_ratio) )
-                   {
-                       // Clip size so that we don't take too much
-                       if( availableOtherDir>=0 && int(size/m_ratio)-m_minSize.y>availableOtherDir )
-                           size = int((availableOtherDir+m_minSize.y)*m_ratio);
-                       m_minSize = wxSize(size,int(size/m_ratio));
-                   }
-                   else if( direction==wxVERTICAL )
-                   {
-                       // Clip size so that we don't take too much
-                       if( availableOtherDir>=0 && int(size*m_ratio)-m_minSize.x>availableOtherDir )
-                           size = int((availableOtherDir+m_minSize.x)/m_ratio);
-                       m_minSize = wxSize(int(size*m_ratio),size);
-                   }
-                   didUse = true;
-               }
-           }
-    }
-        
+
+        // This information is useful for items with wxSHAPED flag, since
+        // we can request an optimal min size for such an item. Even if
+        // we overwrite the m_minSize member here, we can read it back from
+        // the owned window (happens automatically).
+        if( (m_flag & wxSHAPED) && (m_flag & wxEXPAND) && direction )
+        {
+            if( !wxIsNullDouble(m_ratio) )
+            {
+                wxCHECK_MSG( (m_proportion==0), false, _T("Shaped item, non-zero proportion in wxSizerItem::InformFirstDirection()") );
+                if( direction==wxHORIZONTAL && !wxIsNullDouble(m_ratio) )
+                {
+                    // Clip size so that we don't take too much
+                    if( availableOtherDir>=0 && int(size/m_ratio)-m_minSize.y>availableOtherDir )
+                        size = int((availableOtherDir+m_minSize.y)*m_ratio);
+                    m_minSize = wxSize(size,int(size/m_ratio));
+                }
+                else if( direction==wxVERTICAL )
+                {
+                    // Clip size so that we don't take too much
+                    if( availableOtherDir>=0 && int(size*m_ratio)-m_minSize.x>availableOtherDir )
+                        size = int((availableOtherDir+m_minSize.x)/m_ratio);
+                    m_minSize = wxSize(int(size*m_ratio),size);
+                }
+                didUse = true;
+            }
+        }
+    }
+

     return didUse;
 }
 
     return didUse;
 }
 


@@ -907,18 +907,12 @@ void wxSizer::SetSizeHints( wxWindow *window )
                           window->GetMaxHeight() );
 }
 
                           window->GetMaxHeight() );
 }
 

+#if WXWIN_COMPATIBILITY_2_8

 void wxSizer::SetVirtualSizeHints( wxWindow *window )
 {
 void wxSizer::SetVirtualSizeHints( wxWindow *window )
 {

-    // Preserve the window's max size hints, but set the
-    // lower bound according to the sizer calculations.
-

     FitInside( window );
     FitInside( window );

-    wxSize size( window->GetVirtualSize() );
-    window->SetVirtualSizeHints( size.x,
-                                 size.y,
-                                 window->GetMaxWidth(),
-                                 window->GetMaxHeight() );

 }
 }

+#endif // WXWIN_COMPATIBILITY_2_8

 
 wxSize wxSizer::GetMaxWindowSize( wxWindow *window ) const
 {
 
 wxSize wxSizer::GetMaxWindowSize( wxWindow *window ) const
 {


@@ -1381,7 +1375,7 @@ wxSize wxGridSizer::CalcMin()
         node = node->GetNext();
     }
 
         node = node->GetNext();
     }
 

-    // In case we have a nested sizer with a two step algo , give it 
+    // In case we have a nested sizer with a two step algo , give it

     // a chance to adjust to that (we give it width component)
     node = m_children.GetFirst();
     bool didChangeMinSize = false;
     // a chance to adjust to that (we give it width component)
     node = m_children.GetFirst();
     bool didChangeMinSize = false;


@@ -1389,10 +1383,10 @@ wxSize wxGridSizer::CalcMin()
     {
         wxSizerItem     *item = node->GetData();
         didChangeMinSize |= item->InformFirstDirection( wxHORIZONTAL, w, -1 );
     {
         wxSizerItem     *item = node->GetData();
         didChangeMinSize |= item->InformFirstDirection( wxHORIZONTAL, w, -1 );

-        
+

         node = node->GetNext();
     }
         node = node->GetNext();
     }

-    
+

     // And redo iteration in case min size changed
     if( didChangeMinSize )
     {
     // And redo iteration in case min size changed
     if( didChangeMinSize )
     {


@@ -1407,9 +1401,9 @@ wxSize wxGridSizer::CalcMin()
             h = wxMax( h, sz.y );
 
             node = node->GetNext();
             h = wxMax( h, sz.y );
 
             node = node->GetNext();

-        }    
+        }

     }
     }

-    
+

     return wxSize( ncols * w + (ncols-1) * m_hgap,
                    nrows * h + (nrows-1) * m_vgap );
 }
     return wxSize( ncols * w + (ncols-1) * m_hgap,
                    nrows * h + (nrows-1) * m_vgap );
 }


@@ -1571,7 +1565,7 @@ void wxFlexGridSizer::FindWidthsAndHeights(int nrows, int ncols)
         wxSizerItem * const item = *i;
         if ( item->IsShown() )
         {
         wxSizerItem * const item = *i;
         if ( item->IsShown() )
         {

-            // NOTE: Not doing the calculation here, this is just 
+            // NOTE: Not doing the calculation here, this is just

             // for finding max values.
             const wxSize sz(item->GetMinSizeWithBorder());
 
             // for finding max values.
             const wxSize sz(item->GetMinSizeWithBorder());
 


@@ -1622,7 +1616,7 @@ wxSize wxFlexGridSizer::CalcMin()
         }
     }
 
         }
     }
 

-    // The stage of looking for max values in each row/column has been 
+    // The stage of looking for max values in each row/column has been

     // made a separate function, since it's reused in AdjustForGrowables.
     FindWidthsAndHeights(nrows,ncols);
 
     // made a separate function, since it's reused in AdjustForGrowables.
     FindWidthsAndHeights(nrows,ncols);
 


@@ -1752,13 +1746,13 @@ void wxFlexGridSizer::AdjustForGrowables(const wxSize& sz)
             m_growMode == wxFLEX_GROWMODE_SPECIFIED ? &m_growableColsProportions
                                                     : NULL
         );
             m_growMode == wxFLEX_GROWMODE_SPECIFIED ? &m_growableColsProportions
                                                     : NULL
         );

-        
-        // This gives nested objects that benefit from knowing one size 
-        // component in advance the chance to use that. 
+
+        // This gives nested objects that benefit from knowing one size
+        // component in advance the chance to use that.

         bool didAdjustMinSize = false;
         int nrows, ncols;
         CalcRowsCols(nrows, ncols);
         bool didAdjustMinSize = false;
         int nrows, ncols;
         CalcRowsCols(nrows, ncols);

-         
+

         // Iterate over all items and inform about column width
         size_t n = 0;
         for ( wxSizerItemList::iterator i = m_children.begin();
         // Iterate over all items and inform about column width
         size_t n = 0;
         for ( wxSizerItemList::iterator i = m_children.begin();


@@ -1769,7 +1763,7 @@ void wxFlexGridSizer::AdjustForGrowables(const wxSize& sz)
             didAdjustMinSize |= (*i)->InformFirstDirection(wxHORIZONTAL, m_colWidths[col], sz.y - m_calculatedMinSize.y);
     }
 
             didAdjustMinSize |= (*i)->InformFirstDirection(wxHORIZONTAL, m_colWidths[col], sz.y - m_calculatedMinSize.y);
     }
 

-        // Only redo if info was actually used 
+        // Only redo if info was actually used

         if( didAdjustMinSize )
     {
         DoAdjustForGrowables
         if( didAdjustMinSize )
     {
         DoAdjustForGrowables


@@ -1848,13 +1842,13 @@ void wxBoxSizer::RecalcSizes()
     if ( m_children.empty() )
         return;
 
     if ( m_children.empty() )
         return;
 

-    const wxCoord totalMinorSize = SizeInMinorDir(m_size);
+    const wxCoord totalMinorSize = GetSizeInMinorDir(m_size);

 
     // the amount of free space which we should redistribute among the
     // stretchable items (i.e. those with non zero proportion)
 
     // the amount of free space which we should redistribute among the
     // stretchable items (i.e. those with non zero proportion)

-    int delta = SizeInMajorDir(m_size) - SizeInMajorDir(m_minSize);
+    int delta = GetSizeInMajorDir(m_size) - GetSizeInMajorDir(m_minSize);
+

 
 

-    

     // Inform child items about the size in minor direction, that can
     // change how much free space we have in major dir and how to distribute it.
     int majorMinSum = 0;
     // Inform child items about the size in minor direction, that can
     // change how much free space we have in major dir and how to distribute it.
     int majorMinSum = 0;


@@ -1871,22 +1865,22 @@ void wxBoxSizer::RecalcSizes()
         wxSize szMinPrev = item->GetMinSizeWithBorder();
         item->InformFirstDirection(m_orient^wxBOTH,totalMinorSize,delta);
         wxSize szMin = item->GetMinSizeWithBorder();
         wxSize szMinPrev = item->GetMinSizeWithBorder();
         item->InformFirstDirection(m_orient^wxBOTH,totalMinorSize,delta);
         wxSize szMin = item->GetMinSizeWithBorder();

-        int deltaChange = SizeInMajorDir(szMin-szMinPrev); 
+        int deltaChange = GetSizeInMajorDir(szMin-szMinPrev);

         if( deltaChange )
         {
         if( deltaChange )
         {

-               // Since we passed available space along to the item, it should not 
-               // take too much ,so delat should not become negative. 
-               delta -= deltaChange;
+            // Since we passed available space along to the item, it should not
+            // take too much, so delta should not become negative.
+            delta -= deltaChange;

         }
         }

-        majorMinSum += SizeInMajorDir(item->GetMinSizeWithBorder());
+        majorMinSum += GetSizeInMajorDir(item->GetMinSizeWithBorder());

     }
     // And update our min size
     SizeInMajorDir(m_minSize) = majorMinSum;
 
 
     // might have a new delta now
     }
     // And update our min size
     SizeInMajorDir(m_minSize) = majorMinSum;
 
 
     // might have a new delta now

-    delta = SizeInMajorDir(m_size) - SizeInMajorDir(m_minSize);
-    
+    delta = GetSizeInMajorDir(m_size) - GetSizeInMajorDir(m_minSize);
+

     // the position at which we put the next child
     wxPoint pt(m_position);
 
     // the position at which we put the next child
     wxPoint pt(m_position);
 


@@ -1899,17 +1893,11 @@ void wxBoxSizer::RecalcSizes()
 
         if ( !item->IsShown() )
             continue;
 
         if ( !item->IsShown() )
             continue;

-            
-#ifndef __DMC__
-        // DMC doesn't distinguish between 
-        //     int  SizeInMajorDir(const wxSize& sz) const
-        // and int& SizeInMajorDir(wxSize& sz)
-        const         
-#endif 
-        wxSize sizeThis(item->GetMinSizeWithBorder());
+
+        const wxSize sizeThis(item->GetMinSizeWithBorder());

 
         // adjust the size in the major direction using the proportion
 
         // adjust the size in the major direction using the proportion

-        wxCoord majorSize = SizeInMajorDir(sizeThis);
+        wxCoord majorSize = GetSizeInMajorDir(sizeThis);

         const int propItem = item->GetProportion();
         if ( propItem )
         {
         const int propItem = item->GetProportion();
         if ( propItem )
         {


@@ -1925,7 +1913,7 @@ void wxBoxSizer::RecalcSizes()
         // apply the alignment in the minor direction
         wxPoint posChild(pt);
 
         // apply the alignment in the minor direction
         wxPoint posChild(pt);
 

-        wxCoord minorSize = SizeInMinorDir(sizeThis);
+        wxCoord minorSize = GetSizeInMinorDir(sizeThis);

         const int flag = item->GetFlag();
         if ( flag & (wxEXPAND | wxSHAPED) )
         {
         const int flag = item->GetFlag();
         if ( flag & (wxEXPAND | wxSHAPED) )
         {


@@ -1975,14 +1963,11 @@ wxSize wxBoxSizer::CalcMin()
 
         if ( !item->IsShown() )
             continue;
 
         if ( !item->IsShown() )
             continue;

-#ifndef __DMC__
-        const // see __DMC__ above
-#endif        
-        wxSize sizeMinThis = item->CalcMin();

 
 

-        SizeInMajorDir(m_minSize) += SizeInMajorDir(sizeMinThis);
-        if ( SizeInMinorDir(sizeMinThis) > SizeInMinorDir(m_minSize) )
-            SizeInMinorDir(m_minSize) = SizeInMinorDir(sizeMinThis);
+        const wxSize sizeMinThis = item->CalcMin();
+        SizeInMajorDir(m_minSize) += GetSizeInMajorDir(sizeMinThis);
+        if ( GetSizeInMinorDir(sizeMinThis) > GetSizeInMinorDir(m_minSize) )
+            SizeInMinorDir(m_minSize) = GetSizeInMinorDir(sizeMinThis);

 
         m_totalProportion += item->GetProportion();
     }
 
         m_totalProportion += item->GetProportion();
     }


@@ -1994,15 +1979,15 @@ wxSize wxBoxSizer::CalcMin()
 // wxWrapSizer
 //---------------------------------------------------------------------------
 
 // wxWrapSizer
 //---------------------------------------------------------------------------
 

-#define wxDEFAULT_PROPORTION_LAST    1000000            
-       
-// User data to hold old proportion for last item on line 
+#define wxDEFAULT_PROPORTION_LAST    1000000
+
+// User data to hold old proportion for last item on line

 // (which might be extended)
 struct wxPropHolder : public wxObject
 {
     wxPropHolder( ) : m_item(0), m_propOld(0)   { }
     void Init( wxSizerItem *item, int propOld ) { m_item=item; m_propOld=propOld; }
 // (which might be extended)
 struct wxPropHolder : public wxObject
 {
     wxPropHolder( ) : m_item(0), m_propOld(0)   { }
     void Init( wxSizerItem *item, int propOld ) { m_item=item; m_propOld=propOld; }

-    
+

     wxSizerItem *m_item;
     int          m_propOld;
 };
     wxSizerItem *m_item;
     int          m_propOld;
 };


@@ -2010,8 +1995,8 @@ struct wxPropHolder : public wxObject
 IMPLEMENT_DYNAMIC_CLASS(wxWrapSizer, wxBoxSizer);
 
 wxWrapSizer::wxWrapSizer( int orient, int flags )
 IMPLEMENT_DYNAMIC_CLASS(wxWrapSizer, wxBoxSizer);
 
 wxWrapSizer::wxWrapSizer( int orient, int flags )

-    : wxBoxSizer(orient), 
-      m_prim_size_last( -1 ), 
+    : wxBoxSizer(orient),
+      m_prim_size_last( -1 ),

       m_rows(orient^wxBOTH),
       m_flags(flags)
 {
       m_rows(orient^wxBOTH),
       m_flags(flags)
 {


@@ -2034,17 +2019,17 @@ bool wxWrapSizer::InformFirstDirection( int direction, int size, int WXUNUSED(av
 {
     if( !direction )
     {
 {
     if( !direction )
     {

-       // Better to keep value, then CalcMin will work better
-        //m_prim_size_last = -1; 
+        // Better to keep value, then CalcMin will work better
+        //m_prim_size_last = -1;

         return false;
     }
     if( direction==m_orient )
     {
         // The direction is same as our primary, so we can make use of it
         return false;
     }
     if( direction==m_orient )
     {
         // The direction is same as our primary, so we can make use of it

-        m_prim_size_last = size; 
+        m_prim_size_last = size;

         return true;
     }
         return true;
     }

-    else 
+    else

         return false;
 }
 
         return false;
 }
 


@@ -2054,9 +2039,9 @@ void wxWrapSizer::AdjustPropLastItem(wxSizer *psz, wxSizerItem *itemLast)
     wxSizerItem *psi = m_rows.GetItem(psz);
     wxASSERT(psi);
     wxPropHolder *pph = (wxPropHolder*)psi->GetUserData();
     wxSizerItem *psi = m_rows.GetItem(psz);
     wxASSERT(psi);
     wxPropHolder *pph = (wxPropHolder*)psi->GetUserData();

-    if ( !pph ) 
+    if ( !pph )

         psi->SetUserData( pph=new wxPropHolder );
         psi->SetUserData( pph=new wxPropHolder );

-        
+

     pph->Init( itemLast, itemLast->GetProportion() );
     itemLast->SetProportion( wxDEFAULT_PROPORTION_LAST );
 }
     pph->Init( itemLast, itemLast->GetProportion() );
     itemLast->SetProportion( wxDEFAULT_PROPORTION_LAST );
 }


@@ -2067,39 +2052,39 @@ void wxWrapSizer::RecalcSizes()
     if (m_children.GetCount() == 0)
         return;
 
     if (m_children.GetCount() == 0)
         return;
 

-    // What we do here is to put our items into child box sizers, 
-    // as many of them as we have lines. 
+    // What we do here is to put our items into child box sizers,
+    // as many of them as we have lines.

 
     // Empty all items in all rows in owned sizer.
 
     // Empty all items in all rows in owned sizer.

-    // We have to access the list directly, since we don't want to 
+    // We have to access the list directly, since we don't want to

     // destroy the wxSizerItems.
     for( int ix=m_rows.GetChildren().GetCount()-1; ix>=0; ix-- ){
     // destroy the wxSizerItems.
     for( int ix=m_rows.GetChildren().GetCount()-1; ix>=0; ix-- ){

-       wxSizerItem *psi = m_rows.GetItem( (size_t)ix );
-       
-       // Restore proportion for last item on line (if item has not been deleted) 
-       wxPropHolder *pph = (wxPropHolder*)psi->GetUserData();
-       if( pph && GetChildren().Find(pph->m_item) )
-               pph->m_item->SetProportion(pph->m_propOld);
-       
+        wxSizerItem *psi = m_rows.GetItem( (size_t)ix );
+
+        // Restore proportion for last item on line (if item has not been deleted)
+        wxPropHolder *pph = (wxPropHolder*)psi->GetUserData();
+        if( pph && GetChildren().Find(pph->m_item) )
+            pph->m_item->SetProportion(pph->m_propOld);
+

         wxSizer *psz = psi->GetSizer();
         wxASSERT( psz );
         wxSizerItemList &sl = psz->GetChildren();
         while( sl.GetLast() )
             sl.Erase( sl.GetLast() );
     }
         wxSizer *psz = psi->GetSizer();
         wxASSERT( psz );
         wxSizerItemList &sl = psz->GetChildren();
         while( sl.GetLast() )
             sl.Erase( sl.GetLast() );
     }

-    
+

     int lineSumMajor = 0;
     int lineSumMajor = 0;

-    int majorSize = SizeInMajorDir(m_size);
-    
+    int majorSize = GetSizeInMajorDir(m_size);
+

     // Make sure we have at least one child sizer
     m_n_line = 1;
     // Make sure we have at least one child sizer
     m_n_line = 1;

-    if( !m_rows.GetChildren().GetCount() ) 
+    if( !m_rows.GetChildren().GetCount() )

         m_rows.Add( new wxBoxSizer(GetOrientation()), 1, wxEXPAND );
         m_rows.Add( new wxBoxSizer(GetOrientation()), 1, wxEXPAND );

-    
+

     // The sizer where to insert items in
     wxSizer *psz = m_rows.GetItem((size_t)0)->GetSizer();
     wxASSERT( psz );
     // The sizer where to insert items in
     wxSizer *psz = m_rows.GetItem((size_t)0)->GetSizer();
     wxASSERT( psz );

-    
+

     // Now put our child items into child sizers instead
     wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
     wxSizerItem *item = NULL, *itemLast=NULL;
     // Now put our child items into child sizers instead
     wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
     wxSizerItem *item = NULL, *itemLast=NULL;


@@ -2108,11 +2093,11 @@ void wxWrapSizer::RecalcSizes()
         item = node->GetData();
         if ( item->IsShown() )
         {
         item = node->GetData();
         if ( item->IsShown() )
         {

-            wxSize minSz = item->GetMinSize();  
-            int minSzMajor = SizeInMajorDir(minSz);
-            
+            wxSize minSz = item->GetMinSize();
+            int minSzMajor = GetSizeInMajorDir(minSz);
+

             // More space on this line?
             // More space on this line?

-            if( !lineSumMajor || lineSumMajor+minSzMajor<=majorSize )    
+            if( !lineSumMajor || lineSumMajor+minSzMajor<=majorSize )

             {
                 lineSumMajor += minSzMajor;
             }
             {
                 lineSumMajor += minSzMajor;
             }


@@ -2122,38 +2107,38 @@ void wxWrapSizer::RecalcSizes()
                 // Get a new empty sizer to insert into
                 if( (int)m_rows.GetChildren().GetCount()<=m_n_line )
                     m_rows.Add( new wxBoxSizer(GetOrientation()), 1, wxEXPAND );
                 // Get a new empty sizer to insert into
                 if( (int)m_rows.GetChildren().GetCount()<=m_n_line )
                     m_rows.Add( new wxBoxSizer(GetOrientation()), 1, wxEXPAND );

-                
-                // If we have extend-last-on-each-line mode, then do so now 
+
+                // If we have extend-last-on-each-line mode, then do so now

                 // Note: We must store old proportion value then.
                 if( m_flags&wxEXTEND_LAST_ON_EACH_LINE )
                 // Note: We must store old proportion value then.
                 if( m_flags&wxEXTEND_LAST_ON_EACH_LINE )

-                       AdjustPropLastItem(psz,itemLast);
-                       
+                    AdjustPropLastItem(psz,itemLast);
+

                 // The sizer where to insert items in
                 psz = m_rows.GetItem(m_n_line++)->GetSizer();
             }
                 // The sizer where to insert items in
                 psz = m_rows.GetItem(m_n_line++)->GetSizer();
             }

-               itemLast = item;
+            itemLast = item;

             psz->Add( item );
             psz->Add( item );

-            // If item is a window, it now has a pointer to the child sizer, 
-            // which is wrong. Set it to point to us. 
+            // If item is a window, it now has a pointer to the child sizer,
+            // which is wrong. Set it to point to us.

             if( item->GetWindow() )
             if( item->GetWindow() )

-               item->GetWindow()->SetContainingSizer( this );
+                item->GetWindow()->SetContainingSizer( this );

         }
         node = node->GetNext();
     }
 
         }
         node = node->GetNext();
     }
 

-    // If we have extend-last-on-each-line mode, then do so now 
+    // If we have extend-last-on-each-line mode, then do so now

     if( m_flags&wxEXTEND_LAST_ON_EACH_LINE )
         AdjustPropLastItem(psz,itemLast);
     if( m_flags&wxEXTEND_LAST_ON_EACH_LINE )
         AdjustPropLastItem(psz,itemLast);

-    
-    // If we have more sizers than lines, remove them 
+
+    // If we have more sizers than lines, remove them

     while( (int)m_rows.GetChildren().GetCount()>m_n_line )
         m_rows.Remove( m_n_line );
 
     // Now do layout on row sizer
     m_rows.SetDimension( m_position.x, m_position.y, m_size.x, m_size.y );
     while( (int)m_rows.GetChildren().GetCount()>m_n_line )
         m_rows.Remove( m_n_line );
 
     // Now do layout on row sizer
     m_rows.SetDimension( m_position.x, m_position.y, m_size.x, m_size.y );

-    
+

     // Remember this to next time (will be overridden by InformFirstDirection if used)
     // Remember this to next time (will be overridden by InformFirstDirection if used)

-    m_prim_size_last = SizeInMajorDir(m_size);
+    m_prim_size_last = GetSizeInMajorDir(m_size);

 }
 
 
 }
 
 


@@ -2164,15 +2149,15 @@ wxSize wxWrapSizer::CalcMin()
 
     // Algorithm for calculating min size: (assuming horizontal orientation)
     // X: Max width of all members
 
     // Algorithm for calculating min size: (assuming horizontal orientation)
     // X: Max width of all members

-    // Y: Based on last X, calculate how many lines needed 
+    // Y: Based on last X, calculate how many lines needed

     //    First time around, assume all items fits on one line
     //    First time around, assume all items fits on one line

-    
+

     int maxMajor = 0;
     int minorSum = 0;
     int lineMaxMinor = 0;
     int lineSumMajor = 0;
     m_n_line = 0;
     int maxMajor = 0;
     int minorSum = 0;
     int lineMaxMinor = 0;
     int lineSumMajor = 0;
     m_n_line = 0;

-    
+

     // precalc item minsizes and fit on lines (preliminary)
     wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
     while (node)
     // precalc item minsizes and fit on lines (preliminary)
     wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
     while (node)


@@ -2181,15 +2166,15 @@ wxSize wxWrapSizer::CalcMin()
         if ( item->IsShown() )
         {
             wxSize minSz = item->CalcMin();
         if ( item->IsShown() )
         {
             wxSize minSz = item->CalcMin();

-            int szMajor = SizeInMajorDir(minSz);
-            int szMinor = SizeInMinorDir(minSz);
+            int szMajor = GetSizeInMajorDir(minSz);
+            int szMinor = GetSizeInMinorDir(minSz);

             if( szMajor>maxMajor ) maxMajor = szMajor;
             // More space on this line?
             if( szMajor>maxMajor ) maxMajor = szMajor;
             // More space on this line?

-            if( m_prim_size_last<0 || !lineSumMajor || 
-               lineSumMajor+szMajor<=m_prim_size_last )    
+            if( m_prim_size_last<0 || !lineSumMajor ||
+                lineSumMajor+szMajor<=m_prim_size_last )

             {
                 lineSumMajor += szMajor;
             {
                 lineSumMajor += szMajor;

-                if( szMinor>lineMaxMinor ) 
+                if( szMinor>lineMaxMinor )

                     lineMaxMinor = szMinor;
             }
             else
                     lineMaxMinor = szMinor;
             }
             else


@@ -2204,8 +2189,8 @@ wxSize wxWrapSizer::CalcMin()
     }
     minorSum += lineMaxMinor;            // Add height of highest item on last line
 
     }
     minorSum += lineMaxMinor;            // Add height of highest item on last line
 

-    m_minSize = SizeFromMajorMinor(maxMajor, minorSum); 
-    return m_minSize;  
+    m_minSize = SizeFromMajorMinor(maxMajor, minorSum);
+    return m_minSize;

 }
 
 //---------------------------------------------------------------------------
 }
 
 //---------------------------------------------------------------------------