src/xrc/xh_sizer.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/xrc/xh_sizer.cpp
// Purpose:     XRC resource for wxBoxSizer
// Author:      Vaclav Slavik
// Created:     2000/03/21
// RCS-ID:      $Id$
// Copyright:   (c) 2000 Vaclav Slavik
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

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

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#if wxUSE_XRC

#include "wx/xrc/xh_sizer.h"

#ifndef WX_PRECOMP
    #include "wx/log.h"
    #include "wx/panel.h"
    #include "wx/statbox.h"
    #include "wx/sizer.h"
    #include "wx/frame.h"
    #include "wx/dialog.h"
    #include "wx/button.h"
    #include "wx/scrolwin.h"
#endif

#include "wx/gbsizer.h"
#include "wx/wrapsizer.h"
#include "wx/notebook.h"
#include "wx/tokenzr.h"


//-----------------------------------------------------------------------------
// wxSizerXmlHandler
//-----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxSizerXmlHandler, wxXmlResourceHandler)

wxSizerXmlHandler::wxSizerXmlHandler()
                  :wxXmlResourceHandler(),
                   m_isInside(false),
                   m_isGBS(false),
                   m_parentSizer(NULL)
{
    XRC_ADD_STYLE(wxHORIZONTAL);
    XRC_ADD_STYLE(wxVERTICAL);

    // and flags
    XRC_ADD_STYLE(wxLEFT);
    XRC_ADD_STYLE(wxRIGHT);
    XRC_ADD_STYLE(wxTOP);
    XRC_ADD_STYLE(wxBOTTOM);
    XRC_ADD_STYLE(wxNORTH);
    XRC_ADD_STYLE(wxSOUTH);
    XRC_ADD_STYLE(wxEAST);
    XRC_ADD_STYLE(wxWEST);
    XRC_ADD_STYLE(wxALL);

    XRC_ADD_STYLE(wxGROW);
    XRC_ADD_STYLE(wxEXPAND);
    XRC_ADD_STYLE(wxSHAPED);
    XRC_ADD_STYLE(wxSTRETCH_NOT);

    XRC_ADD_STYLE(wxALIGN_CENTER);
    XRC_ADD_STYLE(wxALIGN_CENTRE);
    XRC_ADD_STYLE(wxALIGN_LEFT);
    XRC_ADD_STYLE(wxALIGN_TOP);
    XRC_ADD_STYLE(wxALIGN_RIGHT);
    XRC_ADD_STYLE(wxALIGN_BOTTOM);
    XRC_ADD_STYLE(wxALIGN_CENTER_HORIZONTAL);
    XRC_ADD_STYLE(wxALIGN_CENTRE_HORIZONTAL);
    XRC_ADD_STYLE(wxALIGN_CENTER_VERTICAL);
    XRC_ADD_STYLE(wxALIGN_CENTRE_VERTICAL);

    XRC_ADD_STYLE(wxFIXED_MINSIZE);
    XRC_ADD_STYLE(wxRESERVE_SPACE_EVEN_IF_HIDDEN);

    // this flag doesn't do anything any more but we can just ignore its
    // occurrences in the old resource files instead of raising a fuss because
    // of it
    AddStyle("wxADJUST_MINSIZE", 0);

    // wxWrapSizer-specific flags
    XRC_ADD_STYLE(wxEXTEND_LAST_ON_EACH_LINE);
    XRC_ADD_STYLE(wxREMOVE_LEADING_SPACES);
}


bool wxSizerXmlHandler::CanHandle(wxXmlNode *node)
{
    return ( (!m_isInside && IsSizerNode(node)) ||
             (m_isInside && IsOfClass(node, wxT("sizeritem"))) ||
             (m_isInside && IsOfClass(node, wxT("spacer")))
        );
}


wxObject* wxSizerXmlHandler::DoCreateResource()
{
    if (m_class == wxT("sizeritem"))
        return Handle_sizeritem();

    else if (m_class == wxT("spacer"))
        return Handle_spacer();

    else
        return Handle_sizer();
}


bool wxSizerXmlHandler::IsSizerNode(wxXmlNode *node)
{
    return (IsOfClass(node, wxT("wxBoxSizer"))) ||
           (IsOfClass(node, wxT("wxStaticBoxSizer"))) ||
           (IsOfClass(node, wxT("wxGridSizer"))) ||
           (IsOfClass(node, wxT("wxFlexGridSizer"))) ||
           (IsOfClass(node, wxT("wxGridBagSizer"))) ||
           (IsOfClass(node, wxT("wxWrapSizer")));
}


wxObject* wxSizerXmlHandler::Handle_sizeritem()
{
    // find the item to be managed by this sizeritem
    wxXmlNode *n = GetParamNode(wxT("object"));
    if ( !n )
        n = GetParamNode(wxT("object_ref"));

    // did we find one?
    if (n)
    {
        // create a sizer item for it
        wxSizerItem* sitem = MakeSizerItem();

        // now fetch the item to be managed
        bool old_gbs = m_isGBS;
        bool old_ins = m_isInside;
        wxSizer *old_par = m_parentSizer;
        m_isInside = false;
        if (!IsSizerNode(n)) m_parentSizer = NULL;
        wxObject *item = CreateResFromNode(n, m_parent, NULL);
        m_isInside = old_ins;
        m_parentSizer = old_par;
        m_isGBS = old_gbs;

        // and figure out what type it is
        wxSizer *sizer = wxDynamicCast(item, wxSizer);
        wxWindow *wnd = wxDynamicCast(item, wxWindow);

        if (sizer)
            sitem->AssignSizer(sizer);
        else if (wnd)
            sitem->AssignWindow(wnd);
        else
            wxLogError(wxT("Error in resource."));

        // finally, set other wxSizerItem attributes
        SetSizerItemAttributes(sitem);

        AddSizerItem(sitem);
        return item;
    }
    else /*n == NULL*/
    {
        wxLogError(wxT("Error in resource: no window/sizer/spacer within sizeritem object."));
        return NULL;
    }
}


wxObject* wxSizerXmlHandler::Handle_spacer()
{
    wxCHECK_MSG(m_parentSizer, NULL, wxT("Incorrect syntax of XRC resource: spacer not within sizer!"));

    wxSizerItem* sitem = MakeSizerItem();
    SetSizerItemAttributes(sitem);
    sitem->AssignSpacer(GetSize());
    AddSizerItem(sitem);
    return NULL;
}


wxObject* wxSizerXmlHandler::Handle_sizer()
{
    wxSizer *sizer = NULL;

    wxXmlNode *parentNode = m_node->GetParent();

    wxCHECK_MSG(m_parentSizer != NULL ||
                (parentNode && parentNode->GetType() == wxXML_ELEMENT_NODE &&
                 m_parentAsWindow), NULL,
                wxT("Sizer must have a window parent node"));

    if (m_class == wxT("wxBoxSizer"))
        sizer = Handle_wxBoxSizer();

#if wxUSE_STATBOX
    else if (m_class == wxT("wxStaticBoxSizer"))
        sizer = Handle_wxStaticBoxSizer();
#endif

    else if (m_class == wxT("wxGridSizer"))
        sizer = Handle_wxGridSizer();

    else if (m_class == wxT("wxFlexGridSizer"))
        sizer = Handle_wxFlexGridSizer();

    else if (m_class == wxT("wxGridBagSizer"))
        sizer = Handle_wxGridBagSizer();

    else if (m_class == wxT("wxWrapSizer"))
        sizer = Handle_wxWrapSizer();

    if ( !sizer )
    {
        wxLogError(_T("Failed to create size of class \"%s\""), m_class.c_str());
        return NULL;
    }

    wxSize minsize = GetSize(wxT("minsize"));
    if (!(minsize == wxDefaultSize))
        sizer->SetMinSize(minsize);

    // save state
    wxSizer *old_par = m_parentSizer;
    bool old_ins = m_isInside;

    // set new state
    m_parentSizer = sizer;
    m_isInside = true;
    m_isGBS = (m_class == wxT("wxGridBagSizer"));

    CreateChildren(m_parent, true/*only this handler*/);

    // restore state
    m_isInside = old_ins;
    m_parentSizer = old_par;

    if (m_parentSizer == NULL) // setup window:
    {
        m_parentAsWindow->SetSizer(sizer);

        wxXmlNode *nd = m_node;
        m_node = parentNode;
        if (GetSize() == wxDefaultSize)
        {
            if ( wxDynamicCast(m_parentAsWindow, wxScrolledWindow) != NULL )
            {
                sizer->FitInside(m_parentAsWindow);
            }
            else
            {
                sizer->Fit(m_parentAsWindow);
            }
        }
        m_node = nd;

        if (m_parentAsWindow->IsTopLevel())
        {
            sizer->SetSizeHints(m_parentAsWindow);
        }
    }

    return sizer;
}


wxSizer*  wxSizerXmlHandler::Handle_wxBoxSizer()
{
    return new wxBoxSizer(GetStyle(wxT("orient"), wxHORIZONTAL));
}

#if wxUSE_STATBOX
wxSizer*  wxSizerXmlHandler::Handle_wxStaticBoxSizer()
{
    return new wxStaticBoxSizer(
            new wxStaticBox(m_parentAsWindow,
                            GetID(),
                            GetText(wxT("label")),
                            wxDefaultPosition, wxDefaultSize,
                            0/*style*/,
                            GetName()),
            GetStyle(wxT("orient"), wxHORIZONTAL));
}
#endif // wxUSE_STATBOX

wxSizer*  wxSizerXmlHandler::Handle_wxGridSizer()
{
    return new wxGridSizer(GetLong(wxT("rows")), GetLong(wxT("cols")),
                           GetDimension(wxT("vgap")), GetDimension(wxT("hgap")));
}


wxSizer*  wxSizerXmlHandler::Handle_wxFlexGridSizer()
{
    wxFlexGridSizer *sizer =
        new wxFlexGridSizer(GetLong(wxT("rows")), GetLong(wxT("cols")),
                            GetDimension(wxT("vgap")), GetDimension(wxT("hgap")));
    SetGrowables(sizer, wxT("growablerows"), true);
    SetGrowables(sizer, wxT("growablecols"), false);
    return sizer;
}


wxSizer*  wxSizerXmlHandler::Handle_wxGridBagSizer()
{
    wxGridBagSizer *sizer =
        new wxGridBagSizer(GetDimension(wxT("vgap")), GetDimension(wxT("hgap")));
    SetGrowables(sizer, wxT("growablerows"), true);
    SetGrowables(sizer, wxT("growablecols"), false);
    return sizer;
}

wxSizer*  wxSizerXmlHandler::Handle_wxWrapSizer()
{
    wxWrapSizer *sizer = new wxWrapSizer(GetStyle("orient"), GetStyle("flag"));
    return sizer;
}


void wxSizerXmlHandler::SetGrowables(wxFlexGridSizer* sizer,
                                     const wxChar* param,
                                     bool rows)
{
    wxStringTokenizer tkn;
    unsigned long l;
    tkn.SetString(GetParamValue(param), wxT(","));
    while (tkn.HasMoreTokens())
    {
        if (!tkn.GetNextToken().ToULong(&l))
            wxLogError(wxT("growable[rows|cols] must be comma-separated list of row numbers"));
        else {
            if (rows)
                sizer->AddGrowableRow(l);
            else
                sizer->AddGrowableCol(l);
        }
    }
}


wxGBPosition wxSizerXmlHandler::GetGBPos(const wxString& param)
{
    wxSize sz = GetSize(param);
    if (sz.x < 0) sz.x = 0;
    if (sz.y < 0) sz.y = 0;
    return wxGBPosition(sz.x, sz.y);
}

wxGBSpan wxSizerXmlHandler::GetGBSpan(const wxString& param)
{
    wxSize sz = GetSize(param);
    if (sz.x < 1) sz.x = 1;
    if (sz.y < 1) sz.y = 1;
    return wxGBSpan(sz.x, sz.y);
}


wxSizerItem* wxSizerXmlHandler::MakeSizerItem()
{
    if (m_isGBS)
        return new wxGBSizerItem();
    else
        return new wxSizerItem();
}

void wxSizerXmlHandler::SetSizerItemAttributes(wxSizerItem* sitem)
{
    sitem->SetProportion(GetLong(wxT("option")));  // Should this check for "proportion" too?
    sitem->SetFlag(GetStyle(wxT("flag")));
    sitem->SetBorder(GetDimension(wxT("border")));
    wxSize sz = GetSize(wxT("minsize"));
    if (!(sz == wxDefaultSize))
        sitem->SetMinSize(sz);
    sz = GetSize(wxT("ratio"));
    if (!(sz == wxDefaultSize))
        sitem->SetRatio(sz);

    if (m_isGBS)
    {
        wxGBSizerItem* gbsitem = (wxGBSizerItem*)sitem;
        gbsitem->SetPos(GetGBPos(wxT("cellpos")));
        gbsitem->SetSpan(GetGBSpan(wxT("cellspan")));
    }

    // record the id of the item, if any, for use by XRCSIZERITEM()
    sitem->SetId(GetID());
}

void wxSizerXmlHandler::AddSizerItem(wxSizerItem* sitem)
{
    if (m_isGBS)
        ((wxGridBagSizer*)m_parentSizer)->Add((wxGBSizerItem*)sitem);
    else
        m_parentSizer->Add(sitem);
}


//-----------------------------------------------------------------------------
// wxStdDialogButtonSizerXmlHandler
//-----------------------------------------------------------------------------
#if wxUSE_BUTTON

IMPLEMENT_DYNAMIC_CLASS(wxStdDialogButtonSizerXmlHandler, wxXmlResourceHandler)

wxStdDialogButtonSizerXmlHandler::wxStdDialogButtonSizerXmlHandler()
    : m_isInside(false), m_parentSizer(NULL)
{
}

wxObject *wxStdDialogButtonSizerXmlHandler::DoCreateResource()
{
    if (m_class == wxT("wxStdDialogButtonSizer"))
    {
        wxASSERT( !m_parentSizer );

        wxSizer *s = m_parentSizer = new wxStdDialogButtonSizer;
        m_isInside = true;

        CreateChildren(m_parent, true/*only this handler*/);

        m_parentSizer->Realize();

        m_isInside = false;
        m_parentSizer = NULL;

        return s;
    }
    else // m_class == "button"
    {
        wxASSERT( m_parentSizer );

        // find the item to be managed by this sizeritem
        wxXmlNode *n = GetParamNode(wxT("object"));
        if ( !n )
            n = GetParamNode(wxT("object_ref"));

        // did we find one?
        if (n)
        {
            wxObject *item = CreateResFromNode(n, m_parent, NULL);
            wxButton *button = wxDynamicCast(item, wxButton);

            if (button)
                m_parentSizer->AddButton(button);
            else
                wxLogError(wxT("Error in resource - expected button."));

            return item;
        }
        else /*n == NULL*/
        {
            wxLogError(wxT("Error in resource: no button within wxStdDialogButtonSizer."));
            return NULL;
        }
    }
}

bool wxStdDialogButtonSizerXmlHandler::CanHandle(wxXmlNode *node)
{
    return (!m_isInside && IsOfClass(node, wxT("wxStdDialogButtonSizer"))) ||
           (m_isInside && IsOfClass(node, wxT("button")));
}
#endif // wxUSE_BUTTON

#endif // wxUSE_XRC
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/xrc/xh_sizer.cpp
	3	// Purpose: XRC resource for wxBoxSizer
	4	// Author: Vaclav Slavik
	5	// Created: 2000/03/21
	6	// RCS-ID: $Id$
	7	// Copyright: (c) 2000 Vaclav Slavik
	8	// Licence: wxWindows licence
	9	/////////////////////////////////////////////////////////////////////////////
	10
	11	// For compilers that support precompilation, includes "wx.h".
	12	#include "wx/wxprec.h"
	13
	14	#ifdef __BORLANDC__
	15	#pragma hdrstop
	16	#endif
	17
	18	#if wxUSE_XRC
	19
	20	#include "wx/xrc/xh_sizer.h"
	21
	22	#ifndef WX_PRECOMP
	23	#include "wx/log.h"
	24	#include "wx/panel.h"
	25	#include "wx/statbox.h"
	26	#include "wx/sizer.h"
	27	#include "wx/frame.h"
	28	#include "wx/dialog.h"
	29	#include "wx/button.h"
	30	#include "wx/scrolwin.h"
	31	#endif
	32
	33	#include "wx/gbsizer.h"
	34	#include "wx/wrapsizer.h"
	35	#include "wx/notebook.h"
	36	#include "wx/tokenzr.h"
	37
	38
	39	//-----------------------------------------------------------------------------
	40	// wxSizerXmlHandler
	41	//-----------------------------------------------------------------------------
	42
	43	IMPLEMENT_DYNAMIC_CLASS(wxSizerXmlHandler, wxXmlResourceHandler)
	44
	45	wxSizerXmlHandler::wxSizerXmlHandler()
	46	:wxXmlResourceHandler(),
	47	m_isInside(false),
	48	m_isGBS(false),
	49	m_parentSizer(NULL)
	50	{
	51	XRC_ADD_STYLE(wxHORIZONTAL);
	52	XRC_ADD_STYLE(wxVERTICAL);
	53
	54	// and flags
	55	XRC_ADD_STYLE(wxLEFT);
	56	XRC_ADD_STYLE(wxRIGHT);
	57	XRC_ADD_STYLE(wxTOP);
	58	XRC_ADD_STYLE(wxBOTTOM);
	59	XRC_ADD_STYLE(wxNORTH);
	60	XRC_ADD_STYLE(wxSOUTH);
	61	XRC_ADD_STYLE(wxEAST);
	62	XRC_ADD_STYLE(wxWEST);
	63	XRC_ADD_STYLE(wxALL);
	64
	65	XRC_ADD_STYLE(wxGROW);
	66	XRC_ADD_STYLE(wxEXPAND);
	67	XRC_ADD_STYLE(wxSHAPED);
	68	XRC_ADD_STYLE(wxSTRETCH_NOT);
	69
	70	XRC_ADD_STYLE(wxALIGN_CENTER);
	71	XRC_ADD_STYLE(wxALIGN_CENTRE);
	72	XRC_ADD_STYLE(wxALIGN_LEFT);
	73	XRC_ADD_STYLE(wxALIGN_TOP);
	74	XRC_ADD_STYLE(wxALIGN_RIGHT);
	75	XRC_ADD_STYLE(wxALIGN_BOTTOM);
	76	XRC_ADD_STYLE(wxALIGN_CENTER_HORIZONTAL);
	77	XRC_ADD_STYLE(wxALIGN_CENTRE_HORIZONTAL);
	78	XRC_ADD_STYLE(wxALIGN_CENTER_VERTICAL);
	79	XRC_ADD_STYLE(wxALIGN_CENTRE_VERTICAL);
	80
	81	XRC_ADD_STYLE(wxFIXED_MINSIZE);
	82	XRC_ADD_STYLE(wxRESERVE_SPACE_EVEN_IF_HIDDEN);
	83
	84	// this flag doesn't do anything any more but we can just ignore its
	85	// occurrences in the old resource files instead of raising a fuss because
	86	// of it
	87	AddStyle("wxADJUST_MINSIZE", 0);
	88
	89	// wxWrapSizer-specific flags
	90	XRC_ADD_STYLE(wxEXTEND_LAST_ON_EACH_LINE);
	91	XRC_ADD_STYLE(wxREMOVE_LEADING_SPACES);
	92	}
	93
	94
	95
	96	bool wxSizerXmlHandler::CanHandle(wxXmlNode *node)
	97	{
	98	return ( (!m_isInside && IsSizerNode(node)) \|\|
	99	(m_isInside && IsOfClass(node, wxT("sizeritem"))) \|\|
	100	(m_isInside && IsOfClass(node, wxT("spacer")))
	101	);
	102	}
	103
	104
	105	wxObject* wxSizerXmlHandler::DoCreateResource()
	106	{
	107	if (m_class == wxT("sizeritem"))
	108	return Handle_sizeritem();
	109
	110	else if (m_class == wxT("spacer"))
	111	return Handle_spacer();
	112
	113	else
	114	return Handle_sizer();
	115	}
	116
	117
	118
	119
	120	bool wxSizerXmlHandler::IsSizerNode(wxXmlNode *node)
	121	{
	122	return (IsOfClass(node, wxT("wxBoxSizer"))) \|\|
	123	(IsOfClass(node, wxT("wxStaticBoxSizer"))) \|\|
	124	(IsOfClass(node, wxT("wxGridSizer"))) \|\|
	125	(IsOfClass(node, wxT("wxFlexGridSizer"))) \|\|
	126	(IsOfClass(node, wxT("wxGridBagSizer"))) \|\|
	127	(IsOfClass(node, wxT("wxWrapSizer")));
	128	}
	129
	130
	131	wxObject* wxSizerXmlHandler::Handle_sizeritem()
	132	{
	133	// find the item to be managed by this sizeritem
	134	wxXmlNode *n = GetParamNode(wxT("object"));
	135	if ( !n )
	136	n = GetParamNode(wxT("object_ref"));
	137
	138	// did we find one?
	139	if (n)
	140	{
	141	// create a sizer item for it
	142	wxSizerItem* sitem = MakeSizerItem();
	143
	144	// now fetch the item to be managed
	145	bool old_gbs = m_isGBS;
	146	bool old_ins = m_isInside;
	147	wxSizer *old_par = m_parentSizer;
	148	m_isInside = false;
	149	if (!IsSizerNode(n)) m_parentSizer = NULL;
	150	wxObject *item = CreateResFromNode(n, m_parent, NULL);
	151	m_isInside = old_ins;
	152	m_parentSizer = old_par;
	153	m_isGBS = old_gbs;
	154
	155	// and figure out what type it is
	156	wxSizer *sizer = wxDynamicCast(item, wxSizer);
	157	wxWindow *wnd = wxDynamicCast(item, wxWindow);
	158
	159	if (sizer)
	160	sitem->AssignSizer(sizer);
	161	else if (wnd)
	162	sitem->AssignWindow(wnd);
	163	else
	164	wxLogError(wxT("Error in resource."));
	165
	166	// finally, set other wxSizerItem attributes
	167	SetSizerItemAttributes(sitem);
	168
	169	AddSizerItem(sitem);
	170	return item;
	171	}
	172	else /n == NULL/
	173	{
	174	wxLogError(wxT("Error in resource: no window/sizer/spacer within sizeritem object."));
	175	return NULL;
	176	}
	177	}
	178
	179
	180	wxObject* wxSizerXmlHandler::Handle_spacer()
	181	{
	182	wxCHECK_MSG(m_parentSizer, NULL, wxT("Incorrect syntax of XRC resource: spacer not within sizer!"));
	183
	184	wxSizerItem* sitem = MakeSizerItem();
	185	SetSizerItemAttributes(sitem);
	186	sitem->AssignSpacer(GetSize());
	187	AddSizerItem(sitem);
	188	return NULL;
	189	}
	190
	191
	192	wxObject* wxSizerXmlHandler::Handle_sizer()
	193	{
	194	wxSizer *sizer = NULL;
	195
	196	wxXmlNode *parentNode = m_node->GetParent();
	197
	198	wxCHECK_MSG(m_parentSizer != NULL \|\|
	199	(parentNode && parentNode->GetType() == wxXML_ELEMENT_NODE &&
	200	m_parentAsWindow), NULL,
	201	wxT("Sizer must have a window parent node"));
	202
	203	if (m_class == wxT("wxBoxSizer"))
	204	sizer = Handle_wxBoxSizer();
	205
	206	#if wxUSE_STATBOX
	207	else if (m_class == wxT("wxStaticBoxSizer"))
	208	sizer = Handle_wxStaticBoxSizer();
	209	#endif
	210
	211	else if (m_class == wxT("wxGridSizer"))
	212	sizer = Handle_wxGridSizer();
	213
	214	else if (m_class == wxT("wxFlexGridSizer"))
	215	sizer = Handle_wxFlexGridSizer();
	216
	217	else if (m_class == wxT("wxGridBagSizer"))
	218	sizer = Handle_wxGridBagSizer();
	219
	220	else if (m_class == wxT("wxWrapSizer"))
	221	sizer = Handle_wxWrapSizer();
	222
	223	if ( !sizer )
	224	{
	225	wxLogError(_T("Failed to create size of class \"%s\""), m_class.c_str());
	226	return NULL;
	227	}
	228
	229	wxSize minsize = GetSize(wxT("minsize"));
	230	if (!(minsize == wxDefaultSize))
	231	sizer->SetMinSize(minsize);
	232
	233	// save state
	234	wxSizer *old_par = m_parentSizer;
	235	bool old_ins = m_isInside;
	236
	237	// set new state
	238	m_parentSizer = sizer;
	239	m_isInside = true;
	240	m_isGBS = (m_class == wxT("wxGridBagSizer"));
	241
	242	CreateChildren(m_parent, true/only this handler/);
	243
	244	// restore state
	245	m_isInside = old_ins;
	246	m_parentSizer = old_par;
	247
	248	if (m_parentSizer == NULL) // setup window:
	249	{
	250	m_parentAsWindow->SetSizer(sizer);
	251
	252	wxXmlNode *nd = m_node;
	253	m_node = parentNode;
	254	if (GetSize() == wxDefaultSize)
	255	{
	256	if ( wxDynamicCast(m_parentAsWindow, wxScrolledWindow) != NULL )
	257	{
	258	sizer->FitInside(m_parentAsWindow);
	259	}
	260	else
	261	{
	262	sizer->Fit(m_parentAsWindow);
	263	}
	264	}
	265	m_node = nd;
	266
	267	if (m_parentAsWindow->IsTopLevel())
	268	{
	269	sizer->SetSizeHints(m_parentAsWindow);
	270	}
	271	}
	272
	273	return sizer;
	274	}
	275
	276
	277	wxSizer* wxSizerXmlHandler::Handle_wxBoxSizer()
	278	{
	279	return new wxBoxSizer(GetStyle(wxT("orient"), wxHORIZONTAL));
	280	}
	281
	282	#if wxUSE_STATBOX
	283	wxSizer* wxSizerXmlHandler::Handle_wxStaticBoxSizer()
	284	{
	285	return new wxStaticBoxSizer(
	286	new wxStaticBox(m_parentAsWindow,
	287	GetID(),
	288	GetText(wxT("label")),
	289	wxDefaultPosition, wxDefaultSize,
	290	0/style/,
	291	GetName()),
	292	GetStyle(wxT("orient"), wxHORIZONTAL));
	293	}
	294	#endif // wxUSE_STATBOX
	295
	296	wxSizer* wxSizerXmlHandler::Handle_wxGridSizer()
	297	{
	298	return new wxGridSizer(GetLong(wxT("rows")), GetLong(wxT("cols")),
	299	GetDimension(wxT("vgap")), GetDimension(wxT("hgap")));
	300	}
	301
	302
	303	wxSizer* wxSizerXmlHandler::Handle_wxFlexGridSizer()
	304	{
	305	wxFlexGridSizer *sizer =
	306	new wxFlexGridSizer(GetLong(wxT("rows")), GetLong(wxT("cols")),
	307	GetDimension(wxT("vgap")), GetDimension(wxT("hgap")));
	308	SetGrowables(sizer, wxT("growablerows"), true);
	309	SetGrowables(sizer, wxT("growablecols"), false);
	310	return sizer;
	311	}
	312
	313
	314	wxSizer* wxSizerXmlHandler::Handle_wxGridBagSizer()
	315	{
	316	wxGridBagSizer *sizer =
	317	new wxGridBagSizer(GetDimension(wxT("vgap")), GetDimension(wxT("hgap")));
	318	SetGrowables(sizer, wxT("growablerows"), true);
	319	SetGrowables(sizer, wxT("growablecols"), false);
	320	return sizer;
	321	}
	322
	323	wxSizer* wxSizerXmlHandler::Handle_wxWrapSizer()
	324	{
	325	wxWrapSizer *sizer = new wxWrapSizer(GetStyle("orient"), GetStyle("flag"));
	326	return sizer;
	327	}
	328
	329
	330
	331	void wxSizerXmlHandler::SetGrowables(wxFlexGridSizer* sizer,
	332	const wxChar* param,
	333	bool rows)
	334	{
	335	wxStringTokenizer tkn;
	336	unsigned long l;
	337	tkn.SetString(GetParamValue(param), wxT(","));
	338	while (tkn.HasMoreTokens())
	339	{
	340	if (!tkn.GetNextToken().ToULong(&l))
	341	wxLogError(wxT("growable[rows\|cols] must be comma-separated list of row numbers"));
	342	else {
	343	if (rows)
	344	sizer->AddGrowableRow(l);
	345	else
	346	sizer->AddGrowableCol(l);
	347	}
	348	}
	349	}
	350
	351
	352	wxGBPosition wxSizerXmlHandler::GetGBPos(const wxString& param)
	353	{
	354	wxSize sz = GetSize(param);
	355	if (sz.x < 0) sz.x = 0;
	356	if (sz.y < 0) sz.y = 0;
	357	return wxGBPosition(sz.x, sz.y);
	358	}
	359
	360	wxGBSpan wxSizerXmlHandler::GetGBSpan(const wxString& param)
	361	{
	362	wxSize sz = GetSize(param);
	363	if (sz.x < 1) sz.x = 1;
	364	if (sz.y < 1) sz.y = 1;
	365	return wxGBSpan(sz.x, sz.y);
	366	}
	367
	368
	369
	370	wxSizerItem* wxSizerXmlHandler::MakeSizerItem()
	371	{
	372	if (m_isGBS)
	373	return new wxGBSizerItem();
	374	else
	375	return new wxSizerItem();
	376	}
	377
	378	void wxSizerXmlHandler::SetSizerItemAttributes(wxSizerItem* sitem)
	379	{
	380	sitem->SetProportion(GetLong(wxT("option"))); // Should this check for "proportion" too?
	381	sitem->SetFlag(GetStyle(wxT("flag")));
	382	sitem->SetBorder(GetDimension(wxT("border")));
	383	wxSize sz = GetSize(wxT("minsize"));
	384	if (!(sz == wxDefaultSize))
	385	sitem->SetMinSize(sz);
	386	sz = GetSize(wxT("ratio"));
	387	if (!(sz == wxDefaultSize))
	388	sitem->SetRatio(sz);
	389
	390	if (m_isGBS)
	391	{
	392	wxGBSizerItem* gbsitem = (wxGBSizerItem*)sitem;
	393	gbsitem->SetPos(GetGBPos(wxT("cellpos")));
	394	gbsitem->SetSpan(GetGBSpan(wxT("cellspan")));
	395	}
	396
	397	// record the id of the item, if any, for use by XRCSIZERITEM()
	398	sitem->SetId(GetID());
	399	}
	400
	401	void wxSizerXmlHandler::AddSizerItem(wxSizerItem* sitem)
	402	{
	403	if (m_isGBS)
	404	((wxGridBagSizer)m_parentSizer)->Add((wxGBSizerItem)sitem);
	405	else
	406	m_parentSizer->Add(sitem);
	407	}
	408
	409
	410
	411	//-----------------------------------------------------------------------------
	412	// wxStdDialogButtonSizerXmlHandler
	413	//-----------------------------------------------------------------------------
	414	#if wxUSE_BUTTON
	415
	416	IMPLEMENT_DYNAMIC_CLASS(wxStdDialogButtonSizerXmlHandler, wxXmlResourceHandler)
	417
	418	wxStdDialogButtonSizerXmlHandler::wxStdDialogButtonSizerXmlHandler()
	419	: m_isInside(false), m_parentSizer(NULL)
	420	{
	421	}
	422
	423	wxObject *wxStdDialogButtonSizerXmlHandler::DoCreateResource()
	424	{
	425	if (m_class == wxT("wxStdDialogButtonSizer"))
	426	{
	427	wxASSERT( !m_parentSizer );
	428
	429	wxSizer *s = m_parentSizer = new wxStdDialogButtonSizer;
	430	m_isInside = true;
	431
	432	CreateChildren(m_parent, true/only this handler/);
	433
	434	m_parentSizer->Realize();
	435
	436	m_isInside = false;
	437	m_parentSizer = NULL;
	438
	439	return s;
	440	}
	441	else // m_class == "button"
	442	{
	443	wxASSERT( m_parentSizer );
	444
	445	// find the item to be managed by this sizeritem
	446	wxXmlNode *n = GetParamNode(wxT("object"));
	447	if ( !n )
	448	n = GetParamNode(wxT("object_ref"));
	449
	450	// did we find one?
	451	if (n)
	452	{
	453	wxObject *item = CreateResFromNode(n, m_parent, NULL);
	454	wxButton *button = wxDynamicCast(item, wxButton);
	455
	456	if (button)
	457	m_parentSizer->AddButton(button);
	458	else
	459	wxLogError(wxT("Error in resource - expected button."));
	460
	461	return item;
	462	}
	463	else /n == NULL/
	464	{
	465	wxLogError(wxT("Error in resource: no button within wxStdDialogButtonSizer."));
	466	return NULL;
	467	}
	468	}
	469	}
	470
	471	bool wxStdDialogButtonSizerXmlHandler::CanHandle(wxXmlNode *node)
	472	{
	473	return (!m_isInside && IsOfClass(node, wxT("wxStdDialogButtonSizer"))) \|\|
	474	(m_isInside && IsOfClass(node, wxT("button")));
	475	}
	476	#endif // wxUSE_BUTTON
	477
	478	#endif // wxUSE_XRC