[wxWidgets.git] / tests / sizers / boxsizer.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        tests/sizers/boxsizer.cpp
// Purpose:     Unit tests for wxBoxSizer
// Author:      Vadim Zeitlin
// Created:     2010-03-06
// RCS-ID:      $Id$
// Copyright:   (c) 2010 Vadim Zeitlin <vadim@wxwidgets.org>
///////////////////////////////////////////////////////////////////////////////

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

#include "testprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include "wx/app.h"
    #include "wx/sizer.h"
    #include "wx/listbox.h"
#endif // WX_PRECOMP

#include "asserthelper.h"

// ----------------------------------------------------------------------------
// test class
// ----------------------------------------------------------------------------

class BoxSizerTestCase : public CppUnit::TestCase
{
public:
    BoxSizerTestCase() { }

    virtual void setUp();
    virtual void tearDown();

private:
    CPPUNIT_TEST_SUITE( BoxSizerTestCase );
        CPPUNIT_TEST( Size1 );
        CPPUNIT_TEST( Size3 );
        CPPUNIT_TEST( CalcMin );
        CPPUNIT_TEST( BestSizeRespectsMaxSize );
        CPPUNIT_TEST( RecalcSizesRespectsMaxSize1 );
        CPPUNIT_TEST( RecalcSizesRespectsMaxSize2 );
    CPPUNIT_TEST_SUITE_END();

    void Size1();
    void Size3();
    void CalcMin();
    void BestSizeRespectsMaxSize();
    void RecalcSizesRespectsMaxSize1();
    void RecalcSizesRespectsMaxSize2();

    wxWindow *m_win;
    wxSizer *m_sizer;

    DECLARE_NO_COPY_CLASS(BoxSizerTestCase)
};

// register in the unnamed registry so that these tests are run by default
CPPUNIT_TEST_SUITE_REGISTRATION( BoxSizerTestCase );

// also include in its own registry so that these tests can be run alone
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( BoxSizerTestCase, "BoxSizerTestCase" );

// ----------------------------------------------------------------------------
// test initialization
// ----------------------------------------------------------------------------

void BoxSizerTestCase::setUp()
{
    m_win = new wxWindow(wxTheApp->GetTopWindow(), wxID_ANY);
    m_win->SetClientSize(127, 35);

    m_sizer = new wxBoxSizer(wxHORIZONTAL);
    m_win->SetSizer(m_sizer);
}

void BoxSizerTestCase::tearDown()
{
    delete m_win;
    m_win = NULL;

    m_sizer = NULL;
}

// ----------------------------------------------------------------------------
// tests themselves
// ----------------------------------------------------------------------------

void BoxSizerTestCase::Size1()
{
    const wxSize sizeTotal = m_win->GetClientSize();
    const wxSize sizeChild = sizeTotal / 2;

    wxWindow * const
        child = new wxWindow(m_win, wxID_ANY, wxDefaultPosition, sizeChild);
    m_sizer->Add(child);
    m_win->Layout();
    CPPUNIT_ASSERT_EQUAL( sizeChild, child->GetSize() );

    m_sizer->Clear();
    m_sizer->Add(child, wxSizerFlags(1));
    m_win->Layout();
    CPPUNIT_ASSERT_EQUAL( wxSize(sizeTotal.x, sizeChild.y), child->GetSize() );

    m_sizer->Clear();
    m_sizer->Add(child, wxSizerFlags(1).Expand());
    m_win->Layout();
    CPPUNIT_ASSERT_EQUAL( sizeTotal, child->GetSize() );

    m_sizer->Clear();
    m_sizer->Add(child, wxSizerFlags());
    m_sizer->SetItemMinSize(child, sizeTotal*2);
    m_win->Layout();
    CPPUNIT_ASSERT_EQUAL( sizeTotal, child->GetSize() );

    m_sizer->Clear();
    m_sizer->Add(child, wxSizerFlags().Expand());
    m_sizer->SetItemMinSize(child, sizeTotal*2);
    m_win->Layout();
    CPPUNIT_ASSERT_EQUAL( sizeTotal, child->GetSize() );
}

void BoxSizerTestCase::Size3()
{
    // check that various combinations of minimal sizes and proportions work as
    // expected for different window sizes
    static const struct LayoutTestData
    {
        // proportions of the elements
        int prop[3];

        // minimal sizes of the elements in the sizer direction
        int minsize[3];

        // total size and the expected sizes of the elements
        int x,
            sizes[3];

        // if true, don't try the permutations of our test data
        bool dontPermute;


        // Add the given window to the sizer with the corresponding parameters
        void AddToSizer(wxSizer *sizer, wxWindow *win, int n) const
        {
            sizer->Add(win, wxSizerFlags(prop[n]));
            sizer->SetItemMinSize(win, wxSize(minsize[n], -1));
        }

    } layoutTestData[] =
    {
        // some really simple cases (no need to permute those, they're
        // symmetrical anyhow)
        { { 1, 1, 1, }, {  50,  50,  50, }, 150, {  50,  50,  50, }, true },
        { { 2, 2, 2, }, {  50,  50,  50, }, 600, { 200, 200, 200, }, true },

        // items with different proportions and min sizes when there is enough
        // space to lay them out
        { { 1, 2, 3, }, {   0,   0,   0, }, 600, { 100, 200, 300, } },
        { { 1, 2, 3, }, { 100, 100, 100, }, 600, { 100, 200, 300, } },
        { { 1, 2, 3, }, { 100,  50,  50, }, 600, { 100, 200, 300, } },
        { { 0, 1, 1, }, { 200, 100, 100, }, 600, { 200, 200, 200, } },
        { { 0, 1, 2, }, { 300, 100, 100, }, 600, { 300, 100, 200, } },
        { { 0, 1, 1, }, { 100,  50,  50, }, 300, { 100, 100, 100, } },
        { { 0, 1, 2, }, { 100,  50,  50, }, 400, { 100, 100, 200, } },

        // cases when there is not enough space to lay out the items correctly
        // while still respecting their min sizes
        { { 0, 1, 1, }, { 100, 150,  50, }, 300, { 100, 150,  50, } },
        { { 1, 2, 3, }, { 100, 100, 100, }, 300, { 100, 100, 100, } },
        { { 1, 2, 3, }, { 100,  50,  50, }, 300, { 100,  80, 120, } },
        { { 1, 2, 3, }, { 100,  10,  10, }, 150, { 100,  20,  30, } },

        // cases when there is not enough space even for the min sizes (don't
        // permute in these cases as the layout does depend on the item order
        // because the first ones have priority)
        { { 1, 2, 3, }, { 100,  50,  50, }, 150, { 100,  50,   0, }, true },
        { { 1, 2, 3, }, { 100, 100, 100, }, 200, { 100, 100,   0, }, true },
        { { 1, 2, 3, }, { 100, 100, 100, }, 150, { 100,  50,   0, }, true },
        { { 1, 2, 3, }, { 100, 100, 100, },  50, {  50,   0,   0, }, true },
        { { 1, 2, 3, }, { 100, 100, 100, },   0, {   0,   0,   0, }, true },
    };

    wxWindow *child[3];
    child[0] = new wxWindow(m_win, wxID_ANY);
    child[1] = new wxWindow(m_win, wxID_ANY);
    child[2] = new wxWindow(m_win, wxID_ANY);

    for ( unsigned i = 0; i < WXSIZEOF(layoutTestData); i++ )
    {
        LayoutTestData ltd = layoutTestData[i];

        // the results shouldn't depend on the order of items except in the
        // case when there is not enough space for even the fixed width items
        // (in which case the first ones might get enough of it but not the
        // last ones) so test a couple of permutations of test data unless
        // specifically disabled for this test case
        for ( unsigned p = 0; p < 3; p++)
        {
            switch ( p )
            {
                case 0:
                    // nothing to do, use original data
                    break;

                case 1:
                    // exchange first and last elements
                    wxSwap(ltd.prop[0], ltd.prop[2]);
                    wxSwap(ltd.minsize[0], ltd.minsize[2]);
                    wxSwap(ltd.sizes[0], ltd.sizes[2]);
                    break;

                case 2:
                    // exchange the original third and second elements
                    wxSwap(ltd.prop[0], ltd.prop[1]);
                    wxSwap(ltd.minsize[0], ltd.minsize[1]);
                    wxSwap(ltd.sizes[0], ltd.sizes[1]);
                    break;
            }

            m_sizer->Clear();

            unsigned j;
            for ( j = 0; j < WXSIZEOF(child); j++ )
                ltd.AddToSizer(m_sizer, child[j], j);

            m_win->SetClientSize(ltd.x, -1);
            m_win->Layout();

            for ( j = 0; j < WXSIZEOF(child); j++ )
            {
                WX_ASSERT_EQUAL_MESSAGE
                (
                    (
                        "test %lu, permutation #%lu: wrong size for child #%d "
                        "for total size %d",
                        static_cast<unsigned long>(i),
                        static_cast<unsigned long>(p),
                        j,
                        ltd.x
                    ),
                    ltd.sizes[j], child[j]->GetSize().x
                );
            }

            // don't try other permutations if explicitly disabled
            if ( ltd.dontPermute )
                break;
        }
    }
}

void BoxSizerTestCase::CalcMin()
{
    static const unsigned NUM_TEST_ITEM = 3;

    static const struct CalcMinTestData
    {
        // proportions of the elements, if one of them is -1 it means to not
        // use this window at all in this test
        int prop[NUM_TEST_ITEM];

        // minimal sizes of the elements in the sizer direction
        int minsize[NUM_TEST_ITEM];

        // the expected minimal sizer size
        int total;
    } calcMinTestData[] =
    {
        { {  1,  1, -1 }, {  30,  50,   0 },  100 },
        { {  1,  1,  0 }, {  30,  50,  20 },  120 },
        { { 10, 10, -1 }, {  30,  50,   0 },  100 },
        { {  1,  2,  2 }, {  50,  50,  80 },  250 },
        { {  1,  2,  2 }, { 100,  50,  80 },  500 },
    };

    unsigned n;
    wxWindow *child[NUM_TEST_ITEM];
    for ( n = 0; n < NUM_TEST_ITEM; n++ )
        child[n] = new wxWindow(m_win, wxID_ANY);

    for ( unsigned i = 0; i < WXSIZEOF(calcMinTestData); i++ )
    {
        m_sizer->Clear();

        const CalcMinTestData& cmtd = calcMinTestData[i];
        for ( n = 0; n < NUM_TEST_ITEM; n++ )
        {
            if ( cmtd.prop[n] != -1 )
            {
                child[n]->SetInitialSize(wxSize(cmtd.minsize[n], -1));
                m_sizer->Add(child[n], wxSizerFlags(cmtd.prop[n]));
            }
        }

        WX_ASSERT_EQUAL_MESSAGE
        (
            ("In test #%u", i),
            cmtd.total, m_sizer->CalcMin().x
        );
    }
}

void BoxSizerTestCase::BestSizeRespectsMaxSize()
{
    m_sizer->Clear();

    const int maxWidth = 100;

    wxSizer* sizer = new wxBoxSizer(wxVERTICAL);
    wxListBox* listbox = new wxListBox(m_win, wxID_ANY);
    listbox->Append("some very very very very very very very very very very very long string");
    listbox->SetMaxSize(wxSize(maxWidth, -1));
    sizer->Add(listbox);

    m_sizer->Add(sizer);
    m_win->Layout();

    CPPUNIT_ASSERT_EQUAL(maxWidth, listbox->GetSize().GetWidth());
}

void BoxSizerTestCase::RecalcSizesRespectsMaxSize1()
{
    m_sizer->Clear();

    const int maxWidth = 100;

    m_win->SetClientSize(300, 300);

    wxSizer* sizer1 = new wxBoxSizer(wxVERTICAL);
    m_sizer->Add(sizer1);

    wxListBox* listbox1 = new wxListBox(m_win, wxID_ANY);
    listbox1->Append("some very very very very very very very very very very very long string");
    sizer1->Add(listbox1);

    wxSizer* sizer2 = new wxBoxSizer(wxHORIZONTAL);
    sizer1->Add(sizer2, wxSizerFlags().Expand());

    wxListBox* listbox2 = new wxListBox(m_win, wxID_ANY);
    listbox2->Append("some string");
    listbox2->SetMaxSize(wxSize(100, -1));
    sizer2->Add(listbox2, wxSizerFlags().Proportion(1));

    m_win->Layout();

    CPPUNIT_ASSERT_EQUAL(maxWidth, listbox2->GetSize().GetWidth());
}

void BoxSizerTestCase::RecalcSizesRespectsMaxSize2()
{
    m_sizer->Clear();

    m_win->SetClientSize(300, 300);

    wxSizer* sizer1 = new wxBoxSizer(wxVERTICAL);
    m_sizer->Add(sizer1, wxSizerFlags().Expand());

    wxWindow* child1 = new wxWindow(m_win, wxID_ANY);
    sizer1->Add(child1, wxSizerFlags().Proportion(1));

    wxWindow* child2 = new wxWindow(m_win, wxID_ANY);
    child2->SetMaxSize(wxSize(-1, 50));
    sizer1->Add(child2, wxSizerFlags().Proportion(1));

    wxWindow* child3 = new wxWindow(m_win, wxID_ANY);
    sizer1->Add(child3, wxSizerFlags().Proportion(1));

    m_win->Layout();

    CPPUNIT_ASSERT_EQUAL(125, child1->GetSize().GetHeight());
    CPPUNIT_ASSERT_EQUAL(50, child2->GetSize().GetHeight());
    CPPUNIT_ASSERT_EQUAL(125, child3->GetSize().GetHeight());
}
Commit	Line	Data
869c7a94 VZ	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: tests/sizers/boxsizer.cpp
	3	// Purpose: Unit tests for wxBoxSizer
	4	// Author: Vadim Zeitlin
	5	// Created: 2010-03-06
	6	// RCS-ID: $Id$
	7	// Copyright: (c) 2010 Vadim Zeitlin <vadim@wxwidgets.org>
	8	///////////////////////////////////////////////////////////////////////////////
	9
	10	// ----------------------------------------------------------------------------
	11	// headers
	12	// ----------------------------------------------------------------------------
	13
	14	#include "testprec.h"
	15
	16	#ifdef __BORLANDC__
	17	#pragma hdrstop
	18	#endif
	19
	20	#ifndef WX_PRECOMP
	21	#include "wx/app.h"
	22	#include "wx/sizer.h"
93b87dd9	23	#include "wx/listbox.h"
869c7a94 VZ	24	#endif // WX_PRECOMP
869c7a94 VZ	25
232fdc63	26	#include "asserthelper.h"
869c7a94 VZ	27
	28	// ----------------------------------------------------------------------------
	29	// test class
	30	// ----------------------------------------------------------------------------
	31
	32	class BoxSizerTestCase : public CppUnit::TestCase
	33	{
	34	public:
	35	BoxSizerTestCase() { }
	36
	37	virtual void setUp();
	38	virtual void tearDown();
	39
	40	private:
	41	CPPUNIT_TEST_SUITE( BoxSizerTestCase );
	42	CPPUNIT_TEST( Size1 );
729f53d4	43	CPPUNIT_TEST( Size3 );
f27d62bf	44	CPPUNIT_TEST( CalcMin );
93b87dd9 VZ	45	CPPUNIT_TEST( BestSizeRespectsMaxSize );
	46	CPPUNIT_TEST( RecalcSizesRespectsMaxSize1 );
	47	CPPUNIT_TEST( RecalcSizesRespectsMaxSize2 );
869c7a94 VZ	48	CPPUNIT_TEST_SUITE_END();
	49
	50	void Size1();
729f53d4	51	void Size3();
f27d62bf	52	void CalcMin();
93b87dd9 VZ	53	void BestSizeRespectsMaxSize();
	54	void RecalcSizesRespectsMaxSize1();
	55	void RecalcSizesRespectsMaxSize2();
869c7a94 VZ	56
	57	wxWindow *m_win;
	58	wxSizer *m_sizer;
	59
	60	DECLARE_NO_COPY_CLASS(BoxSizerTestCase)
	61	};
	62
	63	// register in the unnamed registry so that these tests are run by default
	64	CPPUNIT_TEST_SUITE_REGISTRATION( BoxSizerTestCase );
	65
e3778b4d	66	// also include in its own registry so that these tests can be run alone
869c7a94 VZ	67	CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( BoxSizerTestCase, "BoxSizerTestCase" );
	68
	69	// ----------------------------------------------------------------------------
	70	// test initialization
	71	// ----------------------------------------------------------------------------
	72
	73	void BoxSizerTestCase::setUp()
	74	{
	75	m_win = new wxWindow(wxTheApp->GetTopWindow(), wxID_ANY);
	76	m_win->SetClientSize(127, 35);
	77
	78	m_sizer = new wxBoxSizer(wxHORIZONTAL);
	79	m_win->SetSizer(m_sizer);
	80	}
	81
	82	void BoxSizerTestCase::tearDown()
	83	{
	84	delete m_win;
	85	m_win = NULL;
	86
	87	m_sizer = NULL;
	88	}
	89
	90	// ----------------------------------------------------------------------------
	91	// tests themselves
	92	// ----------------------------------------------------------------------------
	93
	94	void BoxSizerTestCase::Size1()
	95	{
	96	const wxSize sizeTotal = m_win->GetClientSize();
	97	const wxSize sizeChild = sizeTotal / 2;
	98
	99	wxWindow * const
	100	child = new wxWindow(m_win, wxID_ANY, wxDefaultPosition, sizeChild);
	101	m_sizer->Add(child);
	102	m_win->Layout();
	103	CPPUNIT_ASSERT_EQUAL( sizeChild, child->GetSize() );
729f53d4	104
869c7a94 VZ	105	m_sizer->Clear();
	106	m_sizer->Add(child, wxSizerFlags(1));
	107	m_win->Layout();
	108	CPPUNIT_ASSERT_EQUAL( wxSize(sizeTotal.x, sizeChild.y), child->GetSize() );
	109
	110	m_sizer->Clear();
	111	m_sizer->Add(child, wxSizerFlags(1).Expand());
	112	m_win->Layout();
	113	CPPUNIT_ASSERT_EQUAL( sizeTotal, child->GetSize() );
26022721	114
a71aeb24 VZ	115	m_sizer->Clear();
	116	m_sizer->Add(child, wxSizerFlags());
	117	m_sizer->SetItemMinSize(child, sizeTotal*2);
	118	m_win->Layout();
	119	CPPUNIT_ASSERT_EQUAL( sizeTotal, child->GetSize() );
	120
26022721 VZ	121	m_sizer->Clear();
	122	m_sizer->Add(child, wxSizerFlags().Expand());
	123	m_sizer->SetItemMinSize(child, sizeTotal*2);
	124	m_win->Layout();
	125	CPPUNIT_ASSERT_EQUAL( sizeTotal, child->GetSize() );
869c7a94 VZ	126	}
869c7a94 VZ	127
729f53d4 VZ	128	void BoxSizerTestCase::Size3()
	129	{
	130	// check that various combinations of minimal sizes and proportions work as
	131	// expected for different window sizes
	132	static const struct LayoutTestData
	133	{
	134	// proportions of the elements
	135	int prop[3];
	136
	137	// minimal sizes of the elements in the sizer direction
	138	int minsize[3];
	139
	140	// total size and the expected sizes of the elements
	141	int x,
	142	sizes[3];
	143
	144	// if true, don't try the permutations of our test data
	145	bool dontPermute;
	146
	147
	148	// Add the given window to the sizer with the corresponding parameters
	149	void AddToSizer(wxSizer sizer, wxWindow win, int n) const
	150	{
	151	sizer->Add(win, wxSizerFlags(prop[n]));
	152	sizer->SetItemMinSize(win, wxSize(minsize[n], -1));
	153	}
	154
	155	} layoutTestData[] =
	156	{
	157	// some really simple cases (no need to permute those, they're
	158	// symmetrical anyhow)
	159	{ { 1, 1, 1, }, { 50, 50, 50, }, 150, { 50, 50, 50, }, true },
	160	{ { 2, 2, 2, }, { 50, 50, 50, }, 600, { 200, 200, 200, }, true },
	161
	162	// items with different proportions and min sizes when there is enough
	163	// space to lay them out
	164	{ { 1, 2, 3, }, { 0, 0, 0, }, 600, { 100, 200, 300, } },
	165	{ { 1, 2, 3, }, { 100, 100, 100, }, 600, { 100, 200, 300, } },
	166	{ { 1, 2, 3, }, { 100, 50, 50, }, 600, { 100, 200, 300, } },
	167	{ { 0, 1, 1, }, { 200, 100, 100, }, 600, { 200, 200, 200, } },
	168	{ { 0, 1, 2, }, { 300, 100, 100, }, 600, { 300, 100, 200, } },
	169	{ { 0, 1, 1, }, { 100, 50, 50, }, 300, { 100, 100, 100, } },
	170	{ { 0, 1, 2, }, { 100, 50, 50, }, 400, { 100, 100, 200, } },
	171
	172	// cases when there is not enough space to lay out the items correctly
	173	// while still respecting their min sizes
	174	{ { 0, 1, 1, }, { 100, 150, 50, }, 300, { 100, 150, 50, } },
	175	{ { 1, 2, 3, }, { 100, 100, 100, }, 300, { 100, 100, 100, } },
	176	{ { 1, 2, 3, }, { 100, 50, 50, }, 300, { 100, 80, 120, } },
	177	{ { 1, 2, 3, }, { 100, 10, 10, }, 150, { 100, 20, 30, } },
	178
	179	// cases when there is not enough space even for the min sizes (don't
	180	// permute in these cases as the layout does depend on the item order
	181	// because the first ones have priority)
	182	{ { 1, 2, 3, }, { 100, 50, 50, }, 150, { 100, 50, 0, }, true },
	183	{ { 1, 2, 3, }, { 100, 100, 100, }, 200, { 100, 100, 0, }, true },
	184	{ { 1, 2, 3, }, { 100, 100, 100, }, 150, { 100, 50, 0, }, true },
	185	{ { 1, 2, 3, }, { 100, 100, 100, }, 50, { 50, 0, 0, }, true },
	186	{ { 1, 2, 3, }, { 100, 100, 100, }, 0, { 0, 0, 0, }, true },
	187	};
	188
	189	wxWindow *child[3];
	190	child[0] = new wxWindow(m_win, wxID_ANY);
	191	child[1] = new wxWindow(m_win, wxID_ANY);
192	child[2] = new wxWindow(m_win, wxID_ANY);
193
729f53d4 VZ	194	for ( unsigned i = 0; i < WXSIZEOF(layoutTestData); i++ )
	195	{
	196	LayoutTestData ltd = layoutTestData[i];
	197
	198	// the results shouldn't depend on the order of items except in the
	199	// case when there is not enough space for even the fixed width items
	200	// (in which case the first ones might get enough of it but not the
	201	// last ones) so test a couple of permutations of test data unless
	202	// specifically disabled for this test case
	203	for ( unsigned p = 0; p < 3; p++)
	204	{
	205	switch ( p )
	206	{
	207	case 0:
	208	// nothing to do, use original data
	209	break;
	210
	211	case 1:
	212	// exchange first and last elements
	213	wxSwap(ltd.prop[0], ltd.prop[2]);
	214	wxSwap(ltd.minsize[0], ltd.minsize[2]);
	215	wxSwap(ltd.sizes[0], ltd.sizes[2]);
	216	break;
	217
	218	case 2:
	219	// exchange the original third and second elements
	220	wxSwap(ltd.prop[0], ltd.prop[1]);
	221	wxSwap(ltd.minsize[0], ltd.minsize[1]);
	222	wxSwap(ltd.sizes[0], ltd.sizes[1]);
	223	break;
	224	}
	225
	226	m_sizer->Clear();
be8332eb VZ	227
be8332eb VZ	228	unsigned j;
729f53d4 VZ	229	for ( j = 0; j < WXSIZEOF(child); j++ )
	230	ltd.AddToSizer(m_sizer, child[j], j);
	231
	232	m_win->SetClientSize(ltd.x, -1);
	233	m_win->Layout();
	234
	235	for ( j = 0; j < WXSIZEOF(child); j++ )
	236	{
	237	WX_ASSERT_EQUAL_MESSAGE
	238	(
	239	(
df67b58b	240	"test %lu, permutation #%lu: wrong size for child #%d "
729f53d4 VZ	241	"for total size %d",
	242	static_cast<unsigned long>(i),
	243	static_cast<unsigned long>(p),
	244	j,
	245	ltd.x
	246	),
	247	ltd.sizes[j], child[j]->GetSize().x
	248	);
	249	}
	250
	251	// don't try other permutations if explicitly disabled
	252	if ( ltd.dontPermute )
	253	break;
	254	}
	255	}
	256	}
f27d62bf VZ	257
	258	void BoxSizerTestCase::CalcMin()
	259	{
	260	static const unsigned NUM_TEST_ITEM = 3;
	261
	262	static const struct CalcMinTestData
	263	{
	264	// proportions of the elements, if one of them is -1 it means to not
	265	// use this window at all in this test
	266	int prop[NUM_TEST_ITEM];
	267
	268	// minimal sizes of the elements in the sizer direction
	269	int minsize[NUM_TEST_ITEM];
	270
	271	// the expected minimal sizer size
	272	int total;
	273	} calcMinTestData[] =
	274	{
	275	{ { 1, 1, -1 }, { 30, 50, 0 }, 100 },
	276	{ { 1, 1, 0 }, { 30, 50, 20 }, 120 },
	277	{ { 10, 10, -1 }, { 30, 50, 0 }, 100 },
	278	{ { 1, 2, 2 }, { 50, 50, 80 }, 250 },
	279	{ { 1, 2, 2 }, { 100, 50, 80 }, 500 },
	280	};
	281
	282	unsigned n;
	283	wxWindow *child[NUM_TEST_ITEM];
	284	for ( n = 0; n < NUM_TEST_ITEM; n++ )
	285	child[n] = new wxWindow(m_win, wxID_ANY);
	286
	287	for ( unsigned i = 0; i < WXSIZEOF(calcMinTestData); i++ )
	288	{
	289	m_sizer->Clear();
	290
	291	const CalcMinTestData& cmtd = calcMinTestData[i];
	292	for ( n = 0; n < NUM_TEST_ITEM; n++ )
	293	{
	294	if ( cmtd.prop[n] != -1 )
	295	{
	296	child[n]->SetInitialSize(wxSize(cmtd.minsize[n], -1));
	297	m_sizer->Add(child[n], wxSizerFlags(cmtd.prop[n]));
	298	}
	299	}
	300
	301	WX_ASSERT_EQUAL_MESSAGE
	302	(
	303	("In test #%u", i),
	304	cmtd.total, m_sizer->CalcMin().x
	305	);
	306	}
	307	}
93b87dd9 VZ	308
	309	void BoxSizerTestCase::BestSizeRespectsMaxSize()
	310	{
	311	m_sizer->Clear();
	312
	313	const int maxWidth = 100;
	314
	315	wxSizer* sizer = new wxBoxSizer(wxVERTICAL);
	316	wxListBox* listbox = new wxListBox(m_win, wxID_ANY);
	317	listbox->Append("some very very very very very very very very very very very long string");
	318	listbox->SetMaxSize(wxSize(maxWidth, -1));
	319	sizer->Add(listbox);
	320
	321	m_sizer->Add(sizer);
	322	m_win->Layout();
	323
	324	CPPUNIT_ASSERT_EQUAL(maxWidth, listbox->GetSize().GetWidth());
	325	}
	326
	327	void BoxSizerTestCase::RecalcSizesRespectsMaxSize1()
	328	{
	329	m_sizer->Clear();
	330
	331	const int maxWidth = 100;
	332
	333	m_win->SetClientSize(300, 300);
	334
	335	wxSizer* sizer1 = new wxBoxSizer(wxVERTICAL);
	336	m_sizer->Add(sizer1);
	337
	338	wxListBox* listbox1 = new wxListBox(m_win, wxID_ANY);
	339	listbox1->Append("some very very very very very very very very very very very long string");
	340	sizer1->Add(listbox1);
	341
	342	wxSizer* sizer2 = new wxBoxSizer(wxHORIZONTAL);
	343	sizer1->Add(sizer2, wxSizerFlags().Expand());
	344
	345	wxListBox* listbox2 = new wxListBox(m_win, wxID_ANY);
	346	listbox2->Append("some string");
	347	listbox2->SetMaxSize(wxSize(100, -1));
	348	sizer2->Add(listbox2, wxSizerFlags().Proportion(1));
	349
	350	m_win->Layout();
	351
	352	CPPUNIT_ASSERT_EQUAL(maxWidth, listbox2->GetSize().GetWidth());
	353	}
	354
	355	void BoxSizerTestCase::RecalcSizesRespectsMaxSize2()
	356	{
	357	m_sizer->Clear();
	358
	359	m_win->SetClientSize(300, 300);
	360
	361	wxSizer* sizer1 = new wxBoxSizer(wxVERTICAL);
	362	m_sizer->Add(sizer1, wxSizerFlags().Expand());
	363
	364	wxWindow* child1 = new wxWindow(m_win, wxID_ANY);
	365	sizer1->Add(child1, wxSizerFlags().Proportion(1));
	366
	367	wxWindow* child2 = new wxWindow(m_win, wxID_ANY);
	368	child2->SetMaxSize(wxSize(-1, 50));
	369	sizer1->Add(child2, wxSizerFlags().Proportion(1));
	370
	371	wxWindow* child3 = new wxWindow(m_win, wxID_ANY);
372	sizer1->Add(child3, wxSizerFlags().Proportion(1));
373
374	m_win->Layout();
375
376	CPPUNIT_ASSERT_EQUAL(125, child1->GetSize().GetHeight());
377	CPPUNIT_ASSERT_EQUAL(50, child2->GetSize().GetHeight());
378	CPPUNIT_ASSERT_EQUAL(125, child3->GetSize().GetHeight());
379	}