wxPython/src/sizers.i

/////////////////////////////////////////////////////////////////////////////
// Name:        sizers.i
// Purpose:     SWIG definitions of the wxSizer family of classes
//
// Author:      Robin Dunn
//
// Created:     18-Sept-1999
// RCS-ID:      $Id$
// Copyright:   (c) 1999 by Total Control Software
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////

%module sizers

%{
#include "helpers.h"

#include <wx/notebook.h>
%}

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

%include typemaps.i
%include my_typemaps.i

// Import some definitions of other classes, etc.
%import _defs.i
%import misc.i
%import windows.i
%import controls.i

%pragma(python) code = "import wx"
%pragma(python) code = "import string"

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


class wxSizerItem : public wxObject {
public:
    // No need to ever create one directly in Python...

    //wxSizerItem( int width, int height, int option, int flag, int border, wxObject* userData);
    //wxSizerItem( wxWindow *window, int option, int flag, int border, wxObject* userData );
    //wxSizerItem( wxSizer *sizer, int option, int flag, int border, wxObject* userData );

    void DeleteWindows();

    wxPoint GetPosition();
    wxSize GetSize();
    wxSize CalcMin();
    void SetDimension( wxPoint pos, wxSize size );
    %name(SetRatioWH) void SetRatio( int width, int height );
    %name(SetRatioSize) void SetRatio( wxSize size );
    void SetRatio( float ratio );
    float GetRatio();

    bool IsWindow();
    bool IsSizer();
    bool IsSpacer();

    wxWindow *GetWindow();
    void SetWindow( wxWindow *window );
    wxSizer *GetSizer();
    void SetSizer( wxSizer *sizer );
    int GetOption();
    int GetFlag();
    int GetBorder();

    void SetInitSize( int x, int y );
    void SetOption( int option );
    void SetFlag( int flag );
    void SetBorder( int border );

    // wxObject* GetUserData();
    %addmethods {
        // Assume that the user data is a wxPyUserData object and return the contents
        PyObject* GetUserData() {
            wxPyUserData* data = (wxPyUserData*)self->GetUserData();
            if (data) {
                Py_INCREF(data->m_obj);
                return data->m_obj;
            } else {
                Py_INCREF(Py_None);
                return Py_None;
            }
        }
    }
};


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

class wxSizer : public wxObject {
public:
    // wxSizer();      ****  abstract, can't instantiate
    // ~wxSizer();

    %addmethods {
        void _setOORInfo(PyObject* _self) {
            self->SetClientObject(new wxPyOORClientData(_self));
        }
    }

    %addmethods {
        void Destroy() { delete self; }

        void AddWindow(wxWindow *window, int option=0, int flag=0, int border=0,
                       PyObject* userData=NULL) {
            wxPyUserData* data = NULL;
            if (userData) data = new wxPyUserData(userData);
            self->Add(window, option, flag, border, data);
        }
        void AddSizer(wxSizer *sizer, int option=0, int flag=0, int border=0,
                      PyObject* userData=NULL) {
            wxPyUserData* data = NULL;
            if (userData) data = new wxPyUserData(userData);
            self->Add(sizer, option, flag, border, data);
        }
        void AddSpacer(int width, int height, int option=0, int flag=0,
                       int border=0, PyObject* userData=NULL) {
            wxPyUserData* data = NULL;
            if (userData) data = new wxPyUserData(userData);
            self->Add(width, height, option, flag, border, data);
        }


        void InsertWindow(int before, wxWindow *window, int option=0, int flag=0,
                          int border=0, PyObject* userData=NULL) {
            wxPyUserData* data = NULL;
            if (userData) data = new wxPyUserData(userData);
            self->Insert(before, window, option, flag, border, data);
        }
        void InsertSizer(int before, wxSizer *sizer, int option=0, int flag=0,
                         int border=0, PyObject* userData=NULL) {
            wxPyUserData* data = NULL;
            if (userData) data = new wxPyUserData(userData);
            self->Insert(before, sizer, option, flag, border, data);
        }
        void InsertSpacer(int before, int width, int height, int option=0, int flag=0,
                          int border=0, PyObject* userData=NULL) {
            wxPyUserData* data = NULL;
            if (userData) data = new wxPyUserData(userData);
            self->Insert(before, width, height, option, flag, border, data);
        }


        void PrependWindow(wxWindow *window, int option=0, int flag=0, int border=0,
                           PyObject* userData=NULL) {
            wxPyUserData* data = NULL;
            if (userData) data = new wxPyUserData(userData);
            self->Prepend(window, option, flag, border, data);
        }
        void PrependSizer(wxSizer *sizer, int option=0, int flag=0, int border=0,
                          PyObject* userData=NULL) {
            wxPyUserData* data = NULL;
            if (userData) data = new wxPyUserData(userData);
            self->Prepend(sizer, option, flag, border, data);
        }
        void PrependSpacer(int width, int height, int option=0, int flag=0,
                           int border=0, PyObject* userData=NULL) {
            wxPyUserData* data = NULL;
            if (userData) data = new wxPyUserData(userData);
            self->Prepend(width, height, option, flag, border, data);
        }
    }

    %name(RemoveWindow)bool Remove( wxWindow *window );
    %name(RemoveSizer)bool Remove( wxSizer *sizer );
    %name(RemovePos)bool Remove( int pos );


    %pragma(python) addtoclass = "
    def Add(self, *args, **kw):
        if type(args[0]) == type(1):
            apply(self.AddSpacer, args, kw)
        elif string.find(args[0].this, 'Sizer') != -1:
            apply(self.AddSizer, args, kw)
        else:
            apply(self.AddWindow, args, kw)

    def Insert(self, *args, **kw):
        if type(args[1]) == type(1):
            apply(self.InsertSpacer, args, kw)
        elif string.find(args[1].this, 'Sizer') != -1:
            apply(self.InsertSizer, args, kw)
        else:
            apply(self.InsertWindow, args, kw)

    def Prepend(self, *args, **kw):
        if type(args[0]) == type(1):
            apply(self.PrependSpacer, args, kw)
        elif string.find(args[0].this, 'Sizer') != -1:
            apply(self.PrependSizer, args, kw)
        else:
            apply(self.PrependWindow, args, kw)

    def Remove(self, *args, **kw):
        if type(args[0]) == type(1):
            apply(self.RemovePos, args, kw)
        elif string.find(args[0].this, 'Sizer') != -1:
            apply(self.RemoveSizer, args, kw)
        else:
            apply(self.RemoveWindow, args, kw)

    def AddMany(self, widgets):
        for childinfo in widgets:
            if type(childinfo) != type(()):
                childinfo = (childinfo, )
            apply(self.Add, childinfo)
"


    void SetDimension( int x, int y, int width, int height );
    void SetMinSize(wxSize size);

    %name(SetItemMinSizeWindow) void SetItemMinSize(wxWindow* window, int width, int height);
    %name(SetItemMinSizeSizer) void SetItemMinSize(wxSizer* sizer, int width, int height);
    %name(SetItemMinSizePos) void SetItemMinSize(int pos, int width, int height);

    %pragma(python) addtoclass = "
    def SetItemMinSize(self, *args):
        if type(args[0]) == type(1):
            apply(self.SetItemMinSizePos, args)
        elif string.find(args[0].this, 'Sizer') != -1:
            apply(self.SetItemMinSizeSizer, args)
        else:
            apply(self.SetItemMinSizeWindow, args)
     "

    wxSize GetSize();
    wxPoint GetPosition();
    wxSize GetMinSize();

    %pragma(python) addtoclass = "
    def GetSizeTuple(self):
        return self.GetSize().asTuple()
    def GetPositionTuple(self):
        return self.GetPosition().asTuple()
    def GetMinSizeTuple(self):
        return self.GetMinSize().asTuple()
    "

    // void RecalcSizes() = 0;
    // wxSize CalcMin() = 0;

    void Layout();

    void Fit( wxWindow *window );
    void FitInside( wxWindow *window );

    void SetSizeHints( wxWindow *window );
    void SetVirtualSizeHints( wxWindow *window );

    void Clear( bool delete_windows=FALSE );
    void DeleteWindows();


    // wxList& GetChildren();
    %addmethods {
        PyObject* GetChildren() {
            wxList& list = self->GetChildren();
            return wxPy_ConvertList(&list, "wxSizerItem");
        }
    }
};


//---------------------------------------------------------------------------
// Use this one for deriving Python classes from
%{
class wxPySizer : public wxSizer {
    DECLARE_DYNAMIC_CLASS(wxPySizer);
public:
    wxPySizer() : wxSizer() {};

    DEC_PYCALLBACK___pure(RecalcSizes);
    DEC_PYCALLBACK_wxSize__pure(CalcMin);
    PYPRIVATE;
};


IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);

IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
%}


class wxPySizer : public wxSizer {
public:
    wxPySizer();
    void _setCallbackInfo(PyObject* self, PyObject* _class);
    %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxPySizer)"
    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
};


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

class  wxBoxSizer : public wxSizer {
public:
    wxBoxSizer(int orient = wxHORIZONTAL);
    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
    int GetOrientation();
    void RecalcSizes();
    wxSize CalcMin();
};

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

class  wxStaticBoxSizer : public wxBoxSizer {
public:
    wxStaticBoxSizer(wxStaticBox *box, int orient = wxHORIZONTAL);
    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
    wxStaticBox *GetStaticBox();
    void RecalcSizes();
    wxSize CalcMin();
};

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

class wxNotebookSizer: public wxSizer {
public:
    wxNotebookSizer( wxNotebook *nb );
    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
    void RecalcSizes();
    wxSize CalcMin();
    wxNotebook *GetNotebook();
};

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

class wxGridSizer: public wxSizer
{
public:
    wxGridSizer( int rows=1, int cols=0, int vgap=0, int hgap=0 );
    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"

    void RecalcSizes();
    wxSize CalcMin();

    void SetCols( int cols );
    void SetRows( int rows );
    void SetVGap( int gap );
    void SetHGap( int gap );
    int GetCols();
    int GetRows();
    int GetVGap();
    int GetHGap();
};

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

class wxFlexGridSizer: public wxGridSizer
{
public:
    wxFlexGridSizer( int rows=1, int cols=0, int vgap=0, int hgap=0 );
    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"

    void RecalcSizes();
    wxSize CalcMin();

    void AddGrowableRow( size_t idx );
    void RemoveGrowableRow( size_t idx );
    void AddGrowableCol( size_t idx );
    void RemoveGrowableCol( size_t idx );

};

//---------------------------------------------------------------------------
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: sizers.i
	3	// Purpose: SWIG definitions of the wxSizer family of classes
	4	//
	5	// Author: Robin Dunn
	6	//
	7	// Created: 18-Sept-1999
	8	// RCS-ID: $Id$
	9	// Copyright: (c) 1999 by Total Control Software
	10	// Licence: wxWindows license
	11	/////////////////////////////////////////////////////////////////////////////
	12
	13	%module sizers
	14
	15	%{
	16	#include "helpers.h"
	17
	18	#include <wx/notebook.h>
	19	%}
	20
	21	//----------------------------------------------------------------------
	22
	23	%include typemaps.i
	24	%include my_typemaps.i
	25
	26	// Import some definitions of other classes, etc.
	27	%import _defs.i
	28	%import misc.i
	29	%import windows.i
	30	%import controls.i
	31
	32	%pragma(python) code = "import wx"
	33	%pragma(python) code = "import string"
	34
	35	//---------------------------------------------------------------------------
	36
	37
	38	class wxSizerItem : public wxObject {
	39	public:
	40	// No need to ever create one directly in Python...
	41
	42	//wxSizerItem( int width, int height, int option, int flag, int border, wxObject* userData);
	43	//wxSizerItem( wxWindow window, int option, int flag, int border, wxObject userData );
	44	//wxSizerItem( wxSizer sizer, int option, int flag, int border, wxObject userData );
	45
	46	void DeleteWindows();
	47
	48	wxPoint GetPosition();
	49	wxSize GetSize();
	50	wxSize CalcMin();
	51	void SetDimension( wxPoint pos, wxSize size );
	52	%name(SetRatioWH) void SetRatio( int width, int height );
	53	%name(SetRatioSize) void SetRatio( wxSize size );
	54	void SetRatio( float ratio );
	55	float GetRatio();
	56
	57	bool IsWindow();
	58	bool IsSizer();
	59	bool IsSpacer();
	60
	61	wxWindow *GetWindow();
	62	void SetWindow( wxWindow *window );
	63	wxSizer *GetSizer();
	64	void SetSizer( wxSizer *sizer );
	65	int GetOption();
	66	int GetFlag();
	67	int GetBorder();
	68
	69	void SetInitSize( int x, int y );
	70	void SetOption( int option );
	71	void SetFlag( int flag );
	72	void SetBorder( int border );
	73
	74	// wxObject* GetUserData();
	75	%addmethods {
	76	// Assume that the user data is a wxPyUserData object and return the contents
	77	PyObject* GetUserData() {
	78	wxPyUserData* data = (wxPyUserData*)self->GetUserData();
	79	if (data) {
	80	Py_INCREF(data->m_obj);
	81	return data->m_obj;
	82	} else {
	83	Py_INCREF(Py_None);
	84	return Py_None;
	85	}
	86	}
	87	}
	88	};
	89
	90
	91	//---------------------------------------------------------------------------
	92
	93	class wxSizer : public wxObject {
	94	public:
	95	// wxSizer(); **** abstract, can't instantiate
	96	// ~wxSizer();
	97
	98	%addmethods {
	99	void _setOORInfo(PyObject* _self) {
	100	self->SetClientObject(new wxPyOORClientData(_self));
	101	}
	102	}
	103
	104	%addmethods {
	105	void Destroy() { delete self; }
	106
	107	void AddWindow(wxWindow *window, int option=0, int flag=0, int border=0,
	108	PyObject* userData=NULL) {
	109	wxPyUserData* data = NULL;
	110	if (userData) data = new wxPyUserData(userData);
	111	self->Add(window, option, flag, border, data);
	112	}
	113	void AddSizer(wxSizer *sizer, int option=0, int flag=0, int border=0,
	114	PyObject* userData=NULL) {
	115	wxPyUserData* data = NULL;
	116	if (userData) data = new wxPyUserData(userData);
	117	self->Add(sizer, option, flag, border, data);
	118	}
	119	void AddSpacer(int width, int height, int option=0, int flag=0,
	120	int border=0, PyObject* userData=NULL) {
	121	wxPyUserData* data = NULL;
	122	if (userData) data = new wxPyUserData(userData);
	123	self->Add(width, height, option, flag, border, data);
	124	}
	125
	126
	127	void InsertWindow(int before, wxWindow *window, int option=0, int flag=0,
	128	int border=0, PyObject* userData=NULL) {
	129	wxPyUserData* data = NULL;
	130	if (userData) data = new wxPyUserData(userData);
	131	self->Insert(before, window, option, flag, border, data);
	132	}
	133	void InsertSizer(int before, wxSizer *sizer, int option=0, int flag=0,
	134	int border=0, PyObject* userData=NULL) {
	135	wxPyUserData* data = NULL;
	136	if (userData) data = new wxPyUserData(userData);
	137	self->Insert(before, sizer, option, flag, border, data);
	138	}
	139	void InsertSpacer(int before, int width, int height, int option=0, int flag=0,
	140	int border=0, PyObject* userData=NULL) {
	141	wxPyUserData* data = NULL;
	142	if (userData) data = new wxPyUserData(userData);
	143	self->Insert(before, width, height, option, flag, border, data);
	144	}
	145
	146
	147	void PrependWindow(wxWindow *window, int option=0, int flag=0, int border=0,
	148	PyObject* userData=NULL) {
	149	wxPyUserData* data = NULL;
	150	if (userData) data = new wxPyUserData(userData);
	151	self->Prepend(window, option, flag, border, data);
	152	}
	153	void PrependSizer(wxSizer *sizer, int option=0, int flag=0, int border=0,
	154	PyObject* userData=NULL) {
	155	wxPyUserData* data = NULL;
	156	if (userData) data = new wxPyUserData(userData);
	157	self->Prepend(sizer, option, flag, border, data);
	158	}
	159	void PrependSpacer(int width, int height, int option=0, int flag=0,
	160	int border=0, PyObject* userData=NULL) {
	161	wxPyUserData* data = NULL;
	162	if (userData) data = new wxPyUserData(userData);
	163	self->Prepend(width, height, option, flag, border, data);
	164	}
	165	}
	166
	167	%name(RemoveWindow)bool Remove( wxWindow *window );
	168	%name(RemoveSizer)bool Remove( wxSizer *sizer );
	169	%name(RemovePos)bool Remove( int pos );
	170
	171
	172	%pragma(python) addtoclass = "
	173	def Add(self, args, *kw):
	174	if type(args[0]) == type(1):
	175	apply(self.AddSpacer, args, kw)
	176	elif string.find(args[0].this, 'Sizer') != -1:
	177	apply(self.AddSizer, args, kw)
	178	else:
	179	apply(self.AddWindow, args, kw)
	180
	181	def Insert(self, args, *kw):
	182	if type(args[1]) == type(1):
	183	apply(self.InsertSpacer, args, kw)
	184	elif string.find(args[1].this, 'Sizer') != -1:
	185	apply(self.InsertSizer, args, kw)
	186	else:
	187	apply(self.InsertWindow, args, kw)
	188
	189	def Prepend(self, args, *kw):
	190	if type(args[0]) == type(1):
	191	apply(self.PrependSpacer, args, kw)
	192	elif string.find(args[0].this, 'Sizer') != -1:
	193	apply(self.PrependSizer, args, kw)
	194	else:
	195	apply(self.PrependWindow, args, kw)
	196
	197	def Remove(self, args, *kw):
	198	if type(args[0]) == type(1):
	199	apply(self.RemovePos, args, kw)
	200	elif string.find(args[0].this, 'Sizer') != -1:
	201	apply(self.RemoveSizer, args, kw)
	202	else:
	203	apply(self.RemoveWindow, args, kw)
	204
	205	def AddMany(self, widgets):
	206	for childinfo in widgets:
	207	if type(childinfo) != type(()):
	208	childinfo = (childinfo, )
	209	apply(self.Add, childinfo)
	210	"
	211
	212
	213	void SetDimension( int x, int y, int width, int height );
	214	void SetMinSize(wxSize size);
	215
	216	%name(SetItemMinSizeWindow) void SetItemMinSize(wxWindow* window, int width, int height);
	217	%name(SetItemMinSizeSizer) void SetItemMinSize(wxSizer* sizer, int width, int height);
	218	%name(SetItemMinSizePos) void SetItemMinSize(int pos, int width, int height);
	219
	220	%pragma(python) addtoclass = "
	221	def SetItemMinSize(self, *args):
	222	if type(args[0]) == type(1):
	223	apply(self.SetItemMinSizePos, args)
	224	elif string.find(args[0].this, 'Sizer') != -1:
	225	apply(self.SetItemMinSizeSizer, args)
	226	else:
	227	apply(self.SetItemMinSizeWindow, args)
	228	"
	229
	230	wxSize GetSize();
	231	wxPoint GetPosition();
	232	wxSize GetMinSize();
	233
	234	%pragma(python) addtoclass = "
	235	def GetSizeTuple(self):
	236	return self.GetSize().asTuple()
	237	def GetPositionTuple(self):
	238	return self.GetPosition().asTuple()
	239	def GetMinSizeTuple(self):
	240	return self.GetMinSize().asTuple()
	241	"
	242
	243	// void RecalcSizes() = 0;
	244	// wxSize CalcMin() = 0;
	245
	246	void Layout();
	247
	248	void Fit( wxWindow *window );
	249	void FitInside( wxWindow *window );
	250
	251	void SetSizeHints( wxWindow *window );
	252	void SetVirtualSizeHints( wxWindow *window );
	253
	254	void Clear( bool delete_windows=FALSE );
	255	void DeleteWindows();
	256
	257
	258	// wxList& GetChildren();
	259	%addmethods {
	260	PyObject* GetChildren() {
	261	wxList& list = self->GetChildren();
	262	return wxPy_ConvertList(&list, "wxSizerItem");
	263	}
	264	}
	265	};
	266
	267
	268	//---------------------------------------------------------------------------
	269	// Use this one for deriving Python classes from
	270	%{
	271	class wxPySizer : public wxSizer {
	272	DECLARE_DYNAMIC_CLASS(wxPySizer);
	273	public:
	274	wxPySizer() : wxSizer() {};
	275
	276	DEC_PYCALLBACK___pure(RecalcSizes);
	277	DEC_PYCALLBACK_wxSize__pure(CalcMin);
	278	PYPRIVATE;
	279	};
	280
	281
	282	IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
	283	IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
	284
	285	IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
	286	%}
	287
	288
	289
	290	class wxPySizer : public wxSizer {
	291	public:
	292	wxPySizer();
	293	void _setCallbackInfo(PyObject* self, PyObject* _class);
	294	%pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxPySizer)"
	295	%pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
	296	};
	297
	298
	299	//---------------------------------------------------------------------------
	300
	301	class wxBoxSizer : public wxSizer {
	302	public:
	303	wxBoxSizer(int orient = wxHORIZONTAL);
	304	%pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
	305	int GetOrientation();
	306	void RecalcSizes();
	307	wxSize CalcMin();
	308	};
	309
	310	//---------------------------------------------------------------------------
	311
	312	class wxStaticBoxSizer : public wxBoxSizer {
	313	public:
	314	wxStaticBoxSizer(wxStaticBox *box, int orient = wxHORIZONTAL);
	315	%pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
	316	wxStaticBox *GetStaticBox();
	317	void RecalcSizes();
	318	wxSize CalcMin();
	319	};
	320
	321	//---------------------------------------------------------------------------
	322
	323	class wxNotebookSizer: public wxSizer {
	324	public:
	325	wxNotebookSizer( wxNotebook *nb );
	326	%pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
	327	void RecalcSizes();
	328	wxSize CalcMin();
	329	wxNotebook *GetNotebook();
	330	};
	331
	332	//---------------------------------------------------------------------------
	333
	334	class wxGridSizer: public wxSizer
	335	{
	336	public:
	337	wxGridSizer( int rows=1, int cols=0, int vgap=0, int hgap=0 );
	338	%pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
	339
	340	void RecalcSizes();
	341	wxSize CalcMin();
	342
	343	void SetCols( int cols );
	344	void SetRows( int rows );
	345	void SetVGap( int gap );
	346	void SetHGap( int gap );
	347	int GetCols();
	348	int GetRows();
	349	int GetVGap();
	350	int GetHGap();
	351	};
	352
	353	//---------------------------------------------------------------------------
	354
	355	class wxFlexGridSizer: public wxGridSizer
	356	{
	357	public:
	358	wxFlexGridSizer( int rows=1, int cols=0, int vgap=0, int hgap=0 );
	359	%pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
	360
	361	void RecalcSizes();
	362	wxSize CalcMin();
	363
	364	void AddGrowableRow( size_t idx );
	365	void RemoveGrowableRow( size_t idx );
	366	void AddGrowableCol( size_t idx );
	367	void RemoveGrowableCol( size_t idx );
	368
	369	};
	370
	371	//---------------------------------------------------------------------------