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

/////////////////////////////////////////////////////////////////////////////
// Name:        gbsizer.cpp
// Purpose:     wxGridBagSizer:  A sizer that can lay out items in a grid,
//              with items at specified cells, and with the option of row
//              and/or column spanning
//
// Author:      Robin Dunn
// Created:     03-Nov-2003
// RCS-ID:      $Id$
// Copyright:   (c) Robin Dunn
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////


#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma implementation "gbsizer.h"
#endif

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#include "wx/gbsizer.h"

//---------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxGBSizerItem, wxSizerItem)
IMPLEMENT_CLASS(wxGridBagSizer, wxFlexGridSizer)

const wxGBSpan wxDefaultSpan;

//---------------------------------------------------------------------------
// wxGBSizerItem
//---------------------------------------------------------------------------

wxGBSizerItem::wxGBSizerItem( int width,
                              int height,
                              const wxGBPosition& pos,
                              const wxGBSpan& span,
                              int flag,
                              int border,
                              wxObject* userData)
    : wxSizerItem(width, height, 0, flag, border, userData),
      m_pos(pos),
      m_span(span),
      m_gbsizer(NULL)
{
}


wxGBSizerItem::wxGBSizerItem( wxWindow *window,
                              const wxGBPosition& pos,
                              const wxGBSpan& span,
                              int flag,
                              int border,
                              wxObject* userData )
    : wxSizerItem(window, 0, flag, border, userData),
      m_pos(pos),
      m_span(span),
      m_gbsizer(NULL)
{
}


wxGBSizerItem::wxGBSizerItem( wxSizer *sizer,
                              const wxGBPosition& pos,
                              const wxGBSpan& span,
                              int flag,
                              int border,
                              wxObject* userData )
    : wxSizerItem(sizer, 0, flag, border, userData),
      m_pos(pos),
      m_span(span),
      m_gbsizer(NULL)
{
}

wxGBSizerItem::wxGBSizerItem()
    : wxSizerItem(),
      m_pos(-1,-1),
      m_span(-1,-1),
      m_gbsizer(NULL)
{
}

//---------------------------------------------------------------------------


void wxGBSizerItem::GetPos(int& row, int& col) const
{
    row = m_pos.GetRow();
    col = m_pos.GetCol();
}

void wxGBSizerItem::GetSpan(int& rowspan, int& colspan) const
{
    rowspan = m_span.GetRowspan();
    colspan = m_span.GetColspan();
}


bool wxGBSizerItem::SetPos( const wxGBPosition& pos )
{
    if (m_gbsizer)
    {
        wxCHECK_MSG( !m_gbsizer->CheckForIntersection(pos, m_span, this), false,
                 wxT("An item is already at that position") );
    }
    m_pos = pos;
    return true;
}

bool wxGBSizerItem::SetSpan( const wxGBSpan& span )
{
    if (m_gbsizer)
    {
        wxCHECK_MSG( !m_gbsizer->CheckForIntersection(m_pos, span, this), false,
                 wxT("An item is already at that position") );
    }
    m_span = span;
    return true;
}


inline bool InRange(int val, int min, int max)
{
    return (val >= min && val <= max);
}

bool wxGBSizerItem::Intersects(const wxGBSizerItem& other)
{
    return Intersects(other.GetPos(), other.GetSpan());
}

bool wxGBSizerItem::Intersects(const wxGBPosition& pos, const wxGBSpan& span)
{

    int row, col, endrow, endcol;
    int otherrow, othercol, otherendrow, otherendcol;

    GetPos(row, col);
    GetEndPos(endrow, endcol);

    otherrow = pos.GetRow();
    othercol = pos.GetCol();
    otherendrow = otherrow + span.GetRowspan() - 1;
    otherendcol = othercol + span.GetColspan() - 1;

    // is the other item's start or end in the range of this one?
    if (( InRange(otherrow, row, endrow) && InRange(othercol, col, endcol) ) ||
        ( InRange(otherendrow, row, endrow) && InRange(otherendcol, col, endcol) ))
        return true;

    // is this item's start or end in the range of the other one?
    if (( InRange(row, otherrow, otherendrow) && InRange(col, othercol, otherendcol) ) ||
        ( InRange(endrow, otherrow, otherendrow) && InRange(endcol, othercol, otherendcol) ))
        return true;

    return false;
}


void wxGBSizerItem::GetEndPos(int& row, int& col)
{
    row = m_pos.GetRow() + m_span.GetRowspan() - 1;
    col = m_pos.GetCol() + m_span.GetColspan() - 1;
}


//---------------------------------------------------------------------------
// wxGridBagSizer
//---------------------------------------------------------------------------

wxGridBagSizer::wxGridBagSizer(int vgap, int hgap )
    : wxFlexGridSizer(1, vgap, hgap),
      m_emptyCellSize(10,20)
    
{
}


bool wxGridBagSizer::Add( wxWindow *window,
                          const wxGBPosition& pos, const wxGBSpan& span,
                          int flag, int border,  wxObject* userData )
{
    wxGBSizerItem* item = new wxGBSizerItem(window, pos, span, flag, border, userData);
    if ( Add(item) )
        return true;
    else
    {
        delete item;
        return false;
    }
}

bool wxGridBagSizer::Add( wxSizer *sizer,
                          const wxGBPosition& pos, const wxGBSpan& span,
                          int flag, int border,  wxObject* userData )
{
    wxGBSizerItem* item = new wxGBSizerItem(sizer, pos, span, flag, border, userData);
    if ( Add(item) )
        return true;
    else
    {
        delete item;
        return false;
    }
}

bool wxGridBagSizer::Add( int width, int height,
                          const wxGBPosition& pos, const wxGBSpan& span,
                          int flag, int border,  wxObject* userData )
{
    wxGBSizerItem* item = new wxGBSizerItem(width, height, pos, span, flag, border, userData);
    if ( Add(item) )
        return true;
    else
    {
        delete item;
        return false;
    }
}

bool wxGridBagSizer::Add( wxGBSizerItem *item )
{
    wxCHECK_MSG( !CheckForIntersection(item), false,
                 wxT("An item is already at that position") );
    m_children.Append(item);
    item->SetGBSizer(this);
    if ( item->GetWindow() )
        item->GetWindow()->SetContainingSizer( this );

    return true;
}


//---------------------------------------------------------------------------

wxSize wxGridBagSizer::GetCellSize(int row, int col) const
{
    wxCHECK_MSG( (row < m_rows) && (col < m_cols),
                 wxDefaultSize,
                 wxT("Invalid cell."));
    return wxSize( m_colWidths[col], m_rowHeights[row] );
}


wxGBPosition wxGridBagSizer::GetItemPosition(wxWindow *window)
{
    wxGBPosition badpos(-1,-1);
    wxGBSizerItem* item = FindItem(window);
    wxCHECK_MSG(item, badpos, wxT("Failed to find item."));
    return item->GetPos();
}


wxGBPosition wxGridBagSizer::GetItemPosition(wxSizer *sizer)
{
    wxGBPosition badpos(-1,-1);
    wxGBSizerItem* item = FindItem(sizer);
    wxCHECK_MSG(item, badpos, wxT("Failed to find item."));
    return item->GetPos();
}


wxGBPosition wxGridBagSizer::GetItemPosition(size_t index)
{
    wxGBPosition badpos(-1,-1);
    wxSizerItemList::compatibility_iterator node = m_children.Item( index );
    wxCHECK_MSG( node, badpos, _T("Failed to find item.") );
    wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();    
    return item->GetPos();
}


bool wxGridBagSizer::SetItemPosition(wxWindow *window, const wxGBPosition& pos)
{
    wxGBSizerItem* item = FindItem(window);
    wxCHECK_MSG(item, false, wxT("Failed to find item."));
    return item->SetPos(pos);
}


bool wxGridBagSizer::SetItemPosition(wxSizer *sizer, const wxGBPosition& pos)
{
    wxGBSizerItem* item = FindItem(sizer);
    wxCHECK_MSG(item, false, wxT("Failed to find item."));
    return item->SetPos(pos);
}


bool wxGridBagSizer::SetItemPosition(size_t index, const wxGBPosition& pos)
{
    wxSizerItemList::compatibility_iterator node = m_children.Item( index );
    wxCHECK_MSG( node, false, _T("Failed to find item.") );
    wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();    
    return item->SetPos(pos);
}


wxGBSpan wxGridBagSizer::GetItemSpan(wxWindow *window)
{
    wxGBSpan badspan(-1,-1);
    wxGBSizerItem* item = FindItem(window);
    wxCHECK_MSG( item, badspan, _T("Failed to find item.") );
    return item->GetSpan();
}


wxGBSpan wxGridBagSizer::GetItemSpan(wxSizer *sizer)
{
    wxGBSpan badspan(-1,-1);
    wxGBSizerItem* item = FindItem(sizer);
    wxCHECK_MSG( item, badspan, _T("Failed to find item.") );
    return item->GetSpan();
}


wxGBSpan wxGridBagSizer::GetItemSpan(size_t index)
{
    wxGBSpan badspan(-1,-1);
    wxSizerItemList::compatibility_iterator node = m_children.Item( index );
    wxCHECK_MSG( node, badspan, _T("Failed to find item.") );
    wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();    
    return item->GetSpan();
}


bool wxGridBagSizer::SetItemSpan(wxWindow *window, const wxGBSpan& span)
{
    wxGBSizerItem* item = FindItem(window);
    wxCHECK_MSG(item, false, wxT("Failed to find item."));
    return item->SetSpan(span);
}


bool wxGridBagSizer::SetItemSpan(wxSizer *sizer, const wxGBSpan& span)
{
    wxGBSizerItem* item = FindItem(sizer);
    wxCHECK_MSG(item, false, wxT("Failed to find item."));
    return item->SetSpan(span);
}


bool wxGridBagSizer::SetItemSpan(size_t index, const wxGBSpan& span)
{
    wxSizerItemList::compatibility_iterator node = m_children.Item( index );
    wxCHECK_MSG( node, false, _T("Failed to find item.") );
    wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();    
    return item->SetSpan(span);
}


wxGBSizerItem* wxGridBagSizer::FindItem(wxWindow* window)
{
    wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
    while (node)
    {
        wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
        if ( item->GetWindow() == window )
            return item;
        node = node->GetNext();
    }
    return NULL;
}


wxGBSizerItem* wxGridBagSizer::FindItem(wxSizer* sizer)
{
    wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
    while (node)
    {
        wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
        if ( item->GetSizer() == sizer )
            return item;
        node = node->GetNext();
    }
    return NULL;
}


wxGBSizerItem* wxGridBagSizer::FindItemAtPosition(const wxGBPosition& pos)
{
    wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
    while (node)
    {
        wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
        if ( item->Intersects(pos, wxDefaultSpan) )
            return item;
        node = node->GetNext();
    }
    return NULL;
}


wxGBSizerItem* wxGridBagSizer::FindItemAtPoint(const wxPoint& pt)
{
    wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
    while (node)
    {
        wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
        wxRect rect(item->GetPosition(), item->GetSize());
        rect.Inflate(m_hgap, m_vgap);
        if ( rect.Inside(pt) )
            return item;
        node = node->GetNext();
    }
    return NULL;
}


wxGBSizerItem* wxGridBagSizer::FindItemWithData(const wxObject* userData)
{
    wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
    while (node)
    {
        wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
        if ( item->GetUserData() == userData )
            return item;
        node = node->GetNext();
    }
    return NULL;
}


//---------------------------------------------------------------------------

// Figure out what all the min row heights and col widths are, and calculate
// min size from that.
wxSize wxGridBagSizer::CalcMin()
{
    int idx;
    
    if (m_children.GetCount() == 0)
        return m_emptyCellSize;

    m_rowHeights.Empty();
    m_colWidths.Empty();

    wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
    while (node)
    {
        wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
        if ( item->IsShown() )
        {
            int row, col, endrow, endcol;
        
            item->GetPos(row, col);
            item->GetEndPos(endrow, endcol);

            // fill heights and widths upto this item if needed
            while ( m_rowHeights.GetCount() <= (size_t)endrow )
                m_rowHeights.Add(m_emptyCellSize.GetHeight());
            while ( m_colWidths.GetCount() <= (size_t)endcol )
                m_colWidths.Add(m_emptyCellSize.GetWidth());

            // See if this item increases the size of its row(s) or col(s)
            wxSize size(item->CalcMin());
            for (idx=row; idx <= endrow; idx++)
                m_rowHeights[idx] = wxMax(m_rowHeights[idx], size.GetHeight() / (endrow-row+1));
            for (idx=col; idx <= endcol; idx++)
                m_colWidths[idx] = wxMax(m_colWidths[idx], size.GetWidth() / (endcol-col+1));
        }
        node = node->GetNext();
    }

    AdjustForFlexDirection();

    // Now traverse the heights and widths arrays calcing the totals, including gaps
    int width = 0;
    m_cols = m_colWidths.GetCount();
    for (idx=0; idx < m_cols; idx++)
        width += m_colWidths[idx] + ( idx == m_cols-1 ? 0 : m_hgap );

    int height = 0;
    m_rows = m_rowHeights.GetCount();
    for (idx=0; idx < m_rows; idx++)
        height += m_rowHeights[idx] + ( idx == m_rows-1 ? 0 : m_vgap );

    return wxSize(width, height);   
}


void wxGridBagSizer::RecalcSizes()
{
    if (m_children.GetCount() == 0)
        return;

    // Calculates minsize and populates m_rowHeights and m_colWidths
    wxSize  minsz( CalcMin() ); 

    wxPoint pt( GetPosition() );
    wxSize  sz( GetSize() );
   
    m_rows = m_rowHeights.GetCount();
    m_cols = m_colWidths.GetCount();
    int idx, width, height;

    AdjustForGrowables(sz, minsz, m_rows, m_cols);

    // Find the start positions on the window of the rows and columns
    wxArrayInt rowpos;
    rowpos.Add(0, m_rows);
    int y = pt.y;
    for (idx=0; idx < m_rows; idx++)
    {
        height = m_rowHeights[idx] + m_vgap;
        rowpos[idx] = y;
        y += height;
    }

    wxArrayInt colpos;
    colpos.Add(0, m_cols);
    int x = pt.x;
    for (idx=0; idx < m_cols; idx++)
    {
        width = m_colWidths[idx] + m_hgap;
        colpos[idx] = x;
        x += width;
    }


    // Now iterate the children, setting each child's dimensions
    wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
    while (node)
    {
        int row, col, endrow, endcol;
        wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
        item->GetPos(row, col);
        item->GetEndPos(endrow, endcol);

        height = 0;
        for(idx=row; idx <= endrow; idx++)
            height += m_rowHeights[idx] + m_vgap;
        
        width = 0;
        for (idx=col; idx <= endcol; idx++)
            width += m_colWidths[idx] + m_hgap;
    
        SetItemBounds(item, colpos[col], rowpos[row], width, height);

        node = node->GetNext();
    }        
}


//---------------------------------------------------------------------------

bool wxGridBagSizer::CheckForIntersection(wxGBSizerItem* item, wxGBSizerItem* excludeItem)
{
    return CheckForIntersection(item->GetPos(), item->GetSpan(), excludeItem);
}

bool wxGridBagSizer::CheckForIntersection(const wxGBPosition& pos, const wxGBSpan& span, wxGBSizerItem* excludeItem)
{
    wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
    while (node)
    {
        wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
        node = node->GetNext();

        if ( excludeItem && item == excludeItem )
            continue;
        
        if ( item->Intersects(pos, span) )
            return true;

    }
    return false;
}


// Assumes a 10x10 grid, and returns the first empty cell found.  This is
// really stupid but it is only used by the Add methods that match the base
// class virtuals, which should normally not be used anyway...
wxGBPosition wxGridBagSizer::FindEmptyCell()
{
    int row, col;

    for (row=0; row<10; row++)
        for (col=0; col<10; col++)
        {
            wxGBPosition pos(row, col);
            if ( !CheckForIntersection(pos, wxDefaultSpan) )
                return pos;
        }
    return wxGBPosition(-1, -1);
}


//---------------------------------------------------------------------------

// The Add base class virtuals should not be used with this class, but
// we'll try to make them automatically select a location for the item
// anyway.

void wxGridBagSizer::Add( wxWindow *window, int, int flag, int border, wxObject* userData )
{
    Add(window, FindEmptyCell(), wxDefaultSpan, flag, border, userData);
}

void wxGridBagSizer::Add( wxSizer *sizer, int, int flag, int border, wxObject* userData )
{
    Add(sizer, FindEmptyCell(), wxDefaultSpan, flag, border, userData);
}

void wxGridBagSizer::Add( int width, int height, int, int flag, int border, wxObject* userData )
{
    Add(width, height, FindEmptyCell(), wxDefaultSpan, flag, border, userData);
}


// The Insert nad Prepend base class virtuals that are not appropriate for
// this class and should not be used.  Their implementation in this class
// simply fails.

void wxGridBagSizer::Add( wxSizerItem * )
{ wxFAIL_MSG(wxT("Invalid Add form called.")); }

void wxGridBagSizer::Prepend( wxWindow *, int, int, int, wxObject*  )
{ wxFAIL_MSG(wxT("Prepend should not be used with wxGridBagSizer.")); }

void wxGridBagSizer::Prepend( wxSizer *, int, int, int, wxObject*  )
{ wxFAIL_MSG(wxT("Prepend should not be used with wxGridBagSizer.")); }

void wxGridBagSizer::Prepend( int, int, int, int, int, wxObject*  )
{ wxFAIL_MSG(wxT("Prepend should not be used with wxGridBagSizer.")); }

void wxGridBagSizer::Prepend( wxSizerItem * )
{ wxFAIL_MSG(wxT("Prepend should not be used with wxGridBagSizer.")); }


void wxGridBagSizer::Insert( size_t, wxWindow *, int, int, int, wxObject*  )
{ wxFAIL_MSG(wxT("Insert should not be used with wxGridBagSizer.")); }

void wxGridBagSizer::Insert( size_t, wxSizer *, int, int, int, wxObject*  )
{ wxFAIL_MSG(wxT("Insert should not be used with wxGridBagSizer.")); }

void wxGridBagSizer::Insert( size_t, int, int, int, int, int, wxObject*  )
{ wxFAIL_MSG(wxT("Insert should not be used with wxGridBagSizer.")); }

void wxGridBagSizer::Insert( size_t, wxSizerItem * )
{ wxFAIL_MSG(wxT("Insert should not be used with wxGridBagSizer.")); }


//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
Commit	Line	Data
20b35a69 RD	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: gbsizer.cpp
	3	// Purpose: wxGridBagSizer: A sizer that can lay out items in a grid,
	4	// with items at specified cells, and with the option of row
	5	// and/or column spanning
	6	//
	7	// Author: Robin Dunn
	8	// Created: 03-Nov-2003
	9	// RCS-ID: $Id$
	10	// Copyright: (c) Robin Dunn
65571936	11	// Licence: wxWindows licence
20b35a69 RD	12	/////////////////////////////////////////////////////////////////////////////
	13
	14
	15	#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
	16	#pragma implementation "gbsizer.h"
	17	#endif
	18
	19	// For compilers that support precompilation, includes "wx.h".
	20	#include "wx/wxprec.h"
	21
	22	#ifdef __BORLANDC__
	23	#pragma hdrstop
	24	#endif
	25
	26	#include "wx/gbsizer.h"
	27
	28	//---------------------------------------------------------------------------
	29
1b52f7ab	30	IMPLEMENT_DYNAMIC_CLASS(wxGBSizerItem, wxSizerItem)
20b35a69 RD	31	IMPLEMENT_CLASS(wxGridBagSizer, wxFlexGridSizer)
	32
	33	const wxGBSpan wxDefaultSpan;
	34
	35	//---------------------------------------------------------------------------
	36	// wxGBSizerItem
	37	//---------------------------------------------------------------------------
	38
	39	wxGBSizerItem::wxGBSizerItem( int width,
	40	int height,
	41	const wxGBPosition& pos,
	42	const wxGBSpan& span,
	43	int flag,
	44	int border,
	45	wxObject* userData)
	46	: wxSizerItem(width, height, 0, flag, border, userData),
	47	m_pos(pos),
	48	m_span(span),
3ff632ce	49	m_gbsizer(NULL)
20b35a69 RD	50	{
	51	}
	52
	53
	54	wxGBSizerItem::wxGBSizerItem( wxWindow *window,
	55	const wxGBPosition& pos,
	56	const wxGBSpan& span,
	57	int flag,
	58	int border,
	59	wxObject* userData )
	60	: wxSizerItem(window, 0, flag, border, userData),
	61	m_pos(pos),
	62	m_span(span),
3ff632ce	63	m_gbsizer(NULL)
20b35a69 RD	64	{
	65	}
	66
	67
	68	wxGBSizerItem::wxGBSizerItem( wxSizer *sizer,
	69	const wxGBPosition& pos,
	70	const wxGBSpan& span,
	71	int flag,
	72	int border,
	73	wxObject* userData )
	74	: wxSizerItem(sizer, 0, flag, border, userData),
	75	m_pos(pos),
	76	m_span(span),
3ff632ce	77	m_gbsizer(NULL)
20b35a69 RD	78	{
	79	}
	80
1b52f7ab RD	81	wxGBSizerItem::wxGBSizerItem()
	82	: wxSizerItem(),
	83	m_pos(-1,-1),
	84	m_span(-1,-1),
3ff632ce	85	m_gbsizer(NULL)
1b52f7ab RD	86	{
1b52f7ab RD	87	}
20b35a69 RD	88
	89	//---------------------------------------------------------------------------
	90
	91
	92	void wxGBSizerItem::GetPos(int& row, int& col) const
	93	{
	94	row = m_pos.GetRow();
	95	col = m_pos.GetCol();
	96	}
	97
	98	void wxGBSizerItem::GetSpan(int& rowspan, int& colspan) const
	99	{
	100	rowspan = m_span.GetRowspan();
	101	colspan = m_span.GetColspan();
	102	}
	103
	104
	105	bool wxGBSizerItem::SetPos( const wxGBPosition& pos )
	106	{
3ff632ce	107	if (m_gbsizer)
20b35a69	108	{
3ff632ce	109	wxCHECK_MSG( !m_gbsizer->CheckForIntersection(pos, m_span, this), false,
20b35a69 RD	110	wxT("An item is already at that position") );
	111	}
	112	m_pos = pos;
	113	return true;
	114	}
	115
	116	bool wxGBSizerItem::SetSpan( const wxGBSpan& span )
	117	{
3ff632ce	118	if (m_gbsizer)
20b35a69	119	{
3ff632ce	120	wxCHECK_MSG( !m_gbsizer->CheckForIntersection(m_pos, span, this), false,
20b35a69 RD	121	wxT("An item is already at that position") );
	122	}
	123	m_span = span;
	124	return true;
	125	}
	126
	127
	128	inline bool InRange(int val, int min, int max)
	129	{
	130	return (val >= min && val <= max);
	131	}
	132
	133	bool wxGBSizerItem::Intersects(const wxGBSizerItem& other)
	134	{
	135	return Intersects(other.GetPos(), other.GetSpan());
	136	}
	137
	138	bool wxGBSizerItem::Intersects(const wxGBPosition& pos, const wxGBSpan& span)
	139	{
	140
	141	int row, col, endrow, endcol;
	142	int otherrow, othercol, otherendrow, otherendcol;
	143
	144	GetPos(row, col);
	145	GetEndPos(endrow, endcol);
	146
	147	otherrow = pos.GetRow();
	148	othercol = pos.GetCol();
	149	otherendrow = otherrow + span.GetRowspan() - 1;
	150	otherendcol = othercol + span.GetColspan() - 1;
	151
	152	// is the other item's start or end in the range of this one?
	153	if (( InRange(otherrow, row, endrow) && InRange(othercol, col, endcol) ) \|\|
	154	( InRange(otherendrow, row, endrow) && InRange(otherendcol, col, endcol) ))
	155	return true;
	156
	157	// is this item's start or end in the range of the other one?
	158	if (( InRange(row, otherrow, otherendrow) && InRange(col, othercol, otherendcol) ) \|\|
	159	( InRange(endrow, otherrow, otherendrow) && InRange(endcol, othercol, otherendcol) ))
	160	return true;
	161
	162	return false;
	163	}
	164
	165
	166	void wxGBSizerItem::GetEndPos(int& row, int& col)
	167	{
	168	row = m_pos.GetRow() + m_span.GetRowspan() - 1;
	169	col = m_pos.GetCol() + m_span.GetColspan() - 1;
	170	}
	171
	172
	173	//---------------------------------------------------------------------------
	174	// wxGridBagSizer
	175	//---------------------------------------------------------------------------
	176
	177	wxGridBagSizer::wxGridBagSizer(int vgap, int hgap )
	178	: wxFlexGridSizer(1, vgap, hgap),
	179	m_emptyCellSize(10,20)
	180
	181	{
	182	}
	183
	184
185	bool wxGridBagSizer::Add( wxWindow *window,
186	const wxGBPosition& pos, const wxGBSpan& span,
187	int flag, int border, wxObject* userData )
188	{
189	wxGBSizerItem* item = new wxGBSizerItem(window, pos, span, flag, border, userData);
190	if ( Add(item) )
191	return true;
192	else
193	{
194	delete item;
195	return false;
196	}
197	}
198
199	bool wxGridBagSizer::Add( wxSizer *sizer,
200	const wxGBPosition& pos, const wxGBSpan& span,
201	int flag, int border, wxObject* userData )
202	{
203	wxGBSizerItem* item = new wxGBSizerItem(sizer, pos, span, flag, border, userData);
204	if ( Add(item) )
205	return true;
206	else
207	{
208	delete item;
209	return false;
210	}
211	}
212
213	bool wxGridBagSizer::Add( int width, int height,
214	const wxGBPosition& pos, const wxGBSpan& span,
215	int flag, int border, wxObject* userData )
216	{
217	wxGBSizerItem* item = new wxGBSizerItem(width, height, pos, span, flag, border, userData);
218	if ( Add(item) )
219	return true;
220	else
221	{
222	delete item;
223	return false;
224	}
225	}
226
227	bool wxGridBagSizer::Add( wxGBSizerItem *item )
228	{
3ff632ce RD	229	wxCHECK_MSG( !CheckForIntersection(item), false,
	230	wxT("An item is already at that position") );
	231	m_children.Append(item);
	232	item->SetGBSizer(this);
20b35a69 RD	233	if ( item->GetWindow() )
	234	item->GetWindow()->SetContainingSizer( this );
	235
	236	return true;
	237	}
	238
	239
	240
	241	//---------------------------------------------------------------------------
	242
6217b9aa RD	243	wxSize wxGridBagSizer::GetCellSize(int row, int col) const
	244	{
	245	wxCHECK_MSG( (row < m_rows) && (col < m_cols),
	246	wxDefaultSize,
	247	wxT("Invalid cell."));
	248	return wxSize( m_colWidths[col], m_rowHeights[row] );
	249	}
	250
	251
20b35a69 RD	252	wxGBPosition wxGridBagSizer::GetItemPosition(wxWindow *window)
	253	{
	254	wxGBPosition badpos(-1,-1);
	255	wxGBSizerItem* item = FindItem(window);
	256	wxCHECK_MSG(item, badpos, wxT("Failed to find item."));
	257	return item->GetPos();
	258	}
	259
	260
	261	wxGBPosition wxGridBagSizer::GetItemPosition(wxSizer *sizer)
	262	{
	263	wxGBPosition badpos(-1,-1);
	264	wxGBSizerItem* item = FindItem(sizer);
	265	wxCHECK_MSG(item, badpos, wxT("Failed to find item."));
	266	return item->GetPos();
	267	}
	268
	269
	270	wxGBPosition wxGridBagSizer::GetItemPosition(size_t index)
	271	{
	272	wxGBPosition badpos(-1,-1);
	273	wxSizerItemList::compatibility_iterator node = m_children.Item( index );
	274	wxCHECK_MSG( node, badpos, _T("Failed to find item.") );
	275	wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
	276	return item->GetPos();
	277	}
	278
	279
	280
	281	bool wxGridBagSizer::SetItemPosition(wxWindow *window, const wxGBPosition& pos)
	282	{
	283	wxGBSizerItem* item = FindItem(window);
	284	wxCHECK_MSG(item, false, wxT("Failed to find item."));
	285	return item->SetPos(pos);
	286	}
	287
	288
	289	bool wxGridBagSizer::SetItemPosition(wxSizer *sizer, const wxGBPosition& pos)
	290	{
	291	wxGBSizerItem* item = FindItem(sizer);
	292	wxCHECK_MSG(item, false, wxT("Failed to find item."));
	293	return item->SetPos(pos);
	294	}
	295
	296
	297	bool wxGridBagSizer::SetItemPosition(size_t index, const wxGBPosition& pos)
	298	{
	299	wxSizerItemList::compatibility_iterator node = m_children.Item( index );
	300	wxCHECK_MSG( node, false, _T("Failed to find item.") );
	301	wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
	302	return item->SetPos(pos);
	303	}
	304
	305
	306
	307	wxGBSpan wxGridBagSizer::GetItemSpan(wxWindow *window)
	308	{
	309	wxGBSpan badspan(-1,-1);
	310	wxGBSizerItem* item = FindItem(window);
	311	wxCHECK_MSG( item, badspan, _T("Failed to find item.") );
	312	return item->GetSpan();
	313	}
	314
	315
316	wxGBSpan wxGridBagSizer::GetItemSpan(wxSizer *sizer)
317	{
318	wxGBSpan badspan(-1,-1);
319	wxGBSizerItem* item = FindItem(sizer);
320	wxCHECK_MSG( item, badspan, _T("Failed to find item.") );
321	return item->GetSpan();
322	}
323
324
325	wxGBSpan wxGridBagSizer::GetItemSpan(size_t index)
326	{
327	wxGBSpan badspan(-1,-1);
328	wxSizerItemList::compatibility_iterator node = m_children.Item( index );
329	wxCHECK_MSG( node, badspan, _T("Failed to find item.") );
330	wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
331	return item->GetSpan();
332	}
333
334
335
336	bool wxGridBagSizer::SetItemSpan(wxWindow *window, const wxGBSpan& span)
337	{
338	wxGBSizerItem* item = FindItem(window);
339	wxCHECK_MSG(item, false, wxT("Failed to find item."));
340	return item->SetSpan(span);
341	}
342
343
344	bool wxGridBagSizer::SetItemSpan(wxSizer *sizer, const wxGBSpan& span)
345	{
346	wxGBSizerItem* item = FindItem(sizer);
347	wxCHECK_MSG(item, false, wxT("Failed to find item."));
348	return item->SetSpan(span);
349	}
350
351
352	bool wxGridBagSizer::SetItemSpan(size_t index, const wxGBSpan& span)
353	{
354	wxSizerItemList::compatibility_iterator node = m_children.Item( index );
355	wxCHECK_MSG( node, false, _T("Failed to find item.") );
356	wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
357	return item->SetSpan(span);
358	}
359
360
361
362
363	wxGBSizerItem* wxGridBagSizer::FindItem(wxWindow* window)
364	{
365	wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
366	while (node)
367	{
368	wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
369	if ( item->GetWindow() == window )
370	return item;
371	node = node->GetNext();
372	}
373	return NULL;
374	}
375
376
377	wxGBSizerItem* wxGridBagSizer::FindItem(wxSizer* sizer)
378	{
379	wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
380	while (node)
381	{
382	wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
383	if ( item->GetSizer() == sizer )
384	return item;
385	node = node->GetNext();
386	}
387	return NULL;
388	}
389
390
391
392
393	wxGBSizerItem* wxGridBagSizer::FindItemAtPosition(const wxGBPosition& pos)
394	{
395	wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
396	while (node)
397	{
398	wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
399	if ( item->Intersects(pos, wxDefaultSpan) )
400	return item;
401	node = node->GetNext();
402	}
403	return NULL;
404	}
405
406
407
408
3ac7b44c RD	409	wxGBSizerItem* wxGridBagSizer::FindItemAtPoint(const wxPoint& pt)
	410	{
	411	wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
	412	while (node)
	413	{
	414	wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
	415	wxRect rect(item->GetPosition(), item->GetSize());
	416	rect.Inflate(m_hgap, m_vgap);
	417	if ( rect.Inside(pt) )
	418	return item;
	419	node = node->GetNext();
	420	}
	421	return NULL;
	422	}
	423
	424
	425
	426
20b35a69 RD	427	wxGBSizerItem* wxGridBagSizer::FindItemWithData(const wxObject* userData)
	428	{
	429	wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
	430	while (node)
	431	{
	432	wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
	433	if ( item->GetUserData() == userData )
	434	return item;
	435	node = node->GetNext();
	436	}
	437	return NULL;
	438	}
	439
	440
	441
	442
	443	//---------------------------------------------------------------------------
	444
	445	// Figure out what all the min row heights and col widths are, and calculate
	446	// min size from that.
	447	wxSize wxGridBagSizer::CalcMin()
	448	{
	449	int idx;
	450
	451	if (m_children.GetCount() == 0)
	452	return m_emptyCellSize;
	453
	454	m_rowHeights.Empty();
	455	m_colWidths.Empty();
	456
	457	wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
	458	while (node)
	459	{
	460	wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
	461	if ( item->IsShown() )
	462	{
	463	int row, col, endrow, endcol;
	464
	465	item->GetPos(row, col);
	466	item->GetEndPos(endrow, endcol);
	467
	468	// fill heights and widths upto this item if needed
	469	while ( m_rowHeights.GetCount() <= (size_t)endrow )
	470	m_rowHeights.Add(m_emptyCellSize.GetHeight());
	471	while ( m_colWidths.GetCount() <= (size_t)endcol )
	472	m_colWidths.Add(m_emptyCellSize.GetWidth());
	473
	474	// See if this item increases the size of its row(s) or col(s)
	475	wxSize size(item->CalcMin());
	476	for (idx=row; idx <= endrow; idx++)
	477	m_rowHeights[idx] = wxMax(m_rowHeights[idx], size.GetHeight() / (endrow-row+1));
	478	for (idx=col; idx <= endcol; idx++)
	479	m_colWidths[idx] = wxMax(m_colWidths[idx], size.GetWidth() / (endcol-col+1));
	480	}
	481	node = node->GetNext();
	482	}
	483
	484	AdjustForFlexDirection();
	485
	486	// Now traverse the heights and widths arrays calcing the totals, including gaps
	487	int width = 0;
6217b9aa RD	488	m_cols = m_colWidths.GetCount();
	489	for (idx=0; idx < m_cols; idx++)
	490	width += m_colWidths[idx] + ( idx == m_cols-1 ? 0 : m_hgap );
20b35a69 RD	491
20b35a69 RD	492	int height = 0;
6217b9aa RD	493	m_rows = m_rowHeights.GetCount();
	494	for (idx=0; idx < m_rows; idx++)
	495	height += m_rowHeights[idx] + ( idx == m_rows-1 ? 0 : m_vgap );
20b35a69 RD	496
	497	return wxSize(width, height);
	498	}
	499
	500
	501
	502	void wxGridBagSizer::RecalcSizes()
	503	{
	504	if (m_children.GetCount() == 0)
	505	return;
	506
	507	// Calculates minsize and populates m_rowHeights and m_colWidths
	508	wxSize minsz( CalcMin() );
	509
	510	wxPoint pt( GetPosition() );
	511	wxSize sz( GetSize() );
	512
6217b9aa RD	513	m_rows = m_rowHeights.GetCount();
6217b9aa RD	514	m_cols = m_colWidths.GetCount();
20b35a69 RD	515	int idx, width, height;
20b35a69 RD	516
6217b9aa	517	AdjustForGrowables(sz, minsz, m_rows, m_cols);
20b35a69 RD	518
	519	// Find the start positions on the window of the rows and columns
	520	wxArrayInt rowpos;
6217b9aa	521	rowpos.Add(0, m_rows);
20b35a69	522	int y = pt.y;
6217b9aa	523	for (idx=0; idx < m_rows; idx++)
20b35a69 RD	524	{
	525	height = m_rowHeights[idx] + m_vgap;
	526	rowpos[idx] = y;
	527	y += height;
	528	}
	529
	530	wxArrayInt colpos;
6217b9aa	531	colpos.Add(0, m_cols);
20b35a69	532	int x = pt.x;
6217b9aa	533	for (idx=0; idx < m_cols; idx++)
20b35a69 RD	534	{
	535	width = m_colWidths[idx] + m_hgap;
	536	colpos[idx] = x;
	537	x += width;
	538	}
	539
	540
	541	// Now iterate the children, setting each child's dimensions
	542	wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
	543	while (node)
	544	{
	545	int row, col, endrow, endcol;
	546	wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
	547	item->GetPos(row, col);
	548	item->GetEndPos(endrow, endcol);
	549
	550	height = 0;
	551	for(idx=row; idx <= endrow; idx++)
	552	height += m_rowHeights[idx] + m_vgap;
	553
	554	width = 0;
	555	for (idx=col; idx <= endcol; idx++)
	556	width += m_colWidths[idx] + m_hgap;
	557
	558	SetItemBounds(item, colpos[col], rowpos[row], width, height);
	559
	560	node = node->GetNext();
	561	}
	562	}
	563
	564
	565
	566	//---------------------------------------------------------------------------
	567
	568	bool wxGridBagSizer::CheckForIntersection(wxGBSizerItem* item, wxGBSizerItem* excludeItem)
	569	{
	570	return CheckForIntersection(item->GetPos(), item->GetSpan(), excludeItem);
	571	}
	572
	573	bool wxGridBagSizer::CheckForIntersection(const wxGBPosition& pos, const wxGBSpan& span, wxGBSizerItem* excludeItem)
	574	{
	575	wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
	576	while (node)
	577	{
	578	wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
	579	node = node->GetNext();
	580
	581	if ( excludeItem && item == excludeItem )
	582	continue;
	583
	584	if ( item->Intersects(pos, span) )
	585	return true;
	586
	587	}
	588	return false;
	589	}
	590
	591
	592	// Assumes a 10x10 grid, and returns the first empty cell found. This is
	593	// really stupid but it is only used by the Add methods that match the base
	594	// class virtuals, which should normally not be used anyway...
	595	wxGBPosition wxGridBagSizer::FindEmptyCell()
	596	{
	597	int row, col;
598
599	for (row=0; row<10; row++)
600	for (col=0; col<10; col++)
601	{
602	wxGBPosition pos(row, col);
603	if ( !CheckForIntersection(pos, wxDefaultSpan) )
604	return pos;
605	}
606	return wxGBPosition(-1, -1);
607	}
608
609
610	//---------------------------------------------------------------------------
611
612	// The Add base class virtuals should not be used with this class, but
613	// we'll try to make them automatically select a location for the item
614	// anyway.
615
616	void wxGridBagSizer::Add( wxWindow window, int, int flag, int border, wxObject userData )
617	{
618	Add(window, FindEmptyCell(), wxDefaultSpan, flag, border, userData);
619	}
620
621	void wxGridBagSizer::Add( wxSizer sizer, int, int flag, int border, wxObject userData )
622	{
623	Add(sizer, FindEmptyCell(), wxDefaultSpan, flag, border, userData);
624	}
625
626	void wxGridBagSizer::Add( int width, int height, int, int flag, int border, wxObject* userData )
627	{
628	Add(width, height, FindEmptyCell(), wxDefaultSpan, flag, border, userData);
629	}
630
631
632
633	// The Insert nad Prepend base class virtuals that are not appropriate for
634	// this class and should not be used. Their implementation in this class
635	// simply fails.
636
d2eaa86b	637	void wxGridBagSizer::Add( wxSizerItem * )
20b35a69 RD	638	{ wxFAIL_MSG(wxT("Invalid Add form called.")); }
	639
	640	void wxGridBagSizer::Prepend( wxWindow , int, int, int, wxObject )
	641	{ wxFAIL_MSG(wxT("Prepend should not be used with wxGridBagSizer.")); }
	642
	643	void wxGridBagSizer::Prepend( wxSizer , int, int, int, wxObject )
	644	{ wxFAIL_MSG(wxT("Prepend should not be used with wxGridBagSizer.")); }
	645
	646	void wxGridBagSizer::Prepend( int, int, int, int, int, wxObject* )
	647	{ wxFAIL_MSG(wxT("Prepend should not be used with wxGridBagSizer.")); }
	648
	649	void wxGridBagSizer::Prepend( wxSizerItem * )
	650	{ wxFAIL_MSG(wxT("Prepend should not be used with wxGridBagSizer.")); }
	651
	652
	653	void wxGridBagSizer::Insert( size_t, wxWindow , int, int, int, wxObject )
	654	{ wxFAIL_MSG(wxT("Insert should not be used with wxGridBagSizer.")); }
	655
	656	void wxGridBagSizer::Insert( size_t, wxSizer , int, int, int, wxObject )
	657	{ wxFAIL_MSG(wxT("Insert should not be used with wxGridBagSizer.")); }
	658
	659	void wxGridBagSizer::Insert( size_t, int, int, int, int, int, wxObject* )
	660	{ wxFAIL_MSG(wxT("Insert should not be used with wxGridBagSizer.")); }
	661
	662	void wxGridBagSizer::Insert( size_t, wxSizerItem * )
	663	{ wxFAIL_MSG(wxT("Insert should not be used with wxGridBagSizer.")); }
	664
	665
	666	//---------------------------------------------------------------------------
	667	//---------------------------------------------------------------------------