[wxWidgets.git] / wxPython / src / my_typemaps.i

/////////////////////////////////////////////////////////////////////////////
// Name:        my_typemaps.i
// Purpose:     Special typemaps specifically for wxPython.
//
// Author:      Robin Dunn
//
// Created:     7/3/97
// RCS-ID:      $Id$
// Copyright:   (c) 1998 by Total Control Software
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////


//---------------------------------------------------------------------------
// Tell SWIG to wrap all the wrappers with our thread protection

%except(python) {
    PyThreadState* __tstate = wxPyBeginAllowThreads();
$function
    wxPyEndAllowThreads(__tstate);
    if (PyErr_Occurred()) return NULL;
}

//----------------------------------------------------------------------
// LCOUNT and choices go together.  They allow a single Python list to be
// converted to an integer count and an array count items long.

%typemap(python,build) int LCOUNT {
    if (_in_choices) {
        $target = PyList_Size(_in_choices);
    }
    else {
        $target = 0;
    }
}


%typemap(python,in) byte* choices  {
    $target = byte_LIST_helper($source);
    if ($target == NULL) {
        return NULL;
    }
}
%typemap(python,freearg) byte* choices {
    delete [] $source;
}

// wxDash is a signed char
%typemap(python,in) wxDash* choices  {
    $target = (wxDash*)byte_LIST_helper($source);
    if ($target == NULL) {
        return NULL;
    }
}
%typemap(python,freearg) wxDash* choices {
    delete [] $source;
}


%typemap(python,in) int* choices  {
    $target = int_LIST_helper($source);
    if ($target == NULL) {
        return NULL;
    }
}
%typemap(python,freearg) int* choices {
    delete [] $source;
}


%typemap(python,in) long* choices {
    $target = long_LIST_helper($source);
    if ($target == NULL) {
        return NULL;
    }
}
%typemap(python,freearg) long* choices {
    delete [] $source;
}


%typemap(python,in) unsigned long* choices {
    $target = (unsigned long*)long_LIST_helper($source);
    if ($target == NULL) {
        return NULL;
    }
}
%typemap(python,freearg) unsigned long* choices {
    delete [] $source;
}


%typemap(python,in) char** choices {
    $target = string_LIST_helper($source);
    if ($target == NULL) {
        return NULL;
    }
}
%typemap(python,freearg) char** choices {
    delete [] $source;
}


%typemap(python,in) wxBitmap** choices  {
    $target = wxBitmap_LIST_helper($source);
    if ($target == NULL) {
        return NULL;
    }
}
%typemap(python,freearg) wxBitmap** choices {
    delete [] $source;
}

%typemap(python,in) wxString* choices  {
    $target = wxString_LIST_helper($source);
    if ($target == NULL) {
        return NULL;
    }
}
%typemap(python,freearg) wxString* choices {
    delete [] $source;
}

%typemap(python,in) wxAcceleratorEntry* choices  {
    $target = wxAcceleratorEntry_LIST_helper($source);
    if ($target == NULL) {
        return NULL;
    }
}
%typemap(python,freearg) wxAcceleratorEntry* choices {
    delete [] $source;
}

%typemap(python,build) int PCOUNT {
	$target = NPOINTS;
}

%typemap(python,in) wxPoint* points (int NPOINTS) {
    $target = wxPoint_LIST_helper($source, &NPOINTS);
	if ($target == NULL) {
		return NULL;
	}
}
%typemap(python,freearg) wxPoint* points {
    delete [] $source;
}


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


%typemap(python, in) wxString& {
    $target = wxString_in_helper($source);
    if ($target == NULL)
        return NULL;
}


%typemap(python, freearg) wxString& {
    if ($target)
        delete $source;
}


%typemap(python, out) wxString {
#if wxUSE_UNICODE
    $target = PyUnicode_FromUnicode($source->c_str(), $source->Len());
#else
    $target = PyString_FromStringAndSize($source->c_str(), $source->Len());
#endif
}
%typemap(python, ret) wxString {
    delete $source;
}


%typemap(python, out) wxString* {
#if wxUSE_UNICODE
    $target = PyUnicode_FromUnicode($source->c_str(), $source->Len());
#else
    $target = PyString_FromStringAndSize($source->c_str(), $source->Len());
#endif
}


//---------------------------------------------------------------------------
// Typemaps to convert Python sequence objects (tuples, etc.) to
// wxSize, wxPoint, wxRealPoint, and wxRect.

%typemap(python,in) wxSize& (wxSize temp) {
    $target = &temp;
    if (! wxSize_helper($source, &$target))
        return NULL;
}

%typemap(python,in) wxPoint& (wxPoint temp) {
    $target = &temp;
    if (! wxPoint_helper($source, &$target))
        return NULL;
}

%typemap(python,in) wxRealPoint& (wxRealPoint temp) {
    $target = &temp;
    if (! wxRealPoint_helper($source, &$target))
        return NULL;
}

%typemap(python,in) wxRect& (wxRect temp) {
    $target = &temp;
    if (! wxRect_helper($source, &$target))
        return NULL;
}

//---------------------------------------------------------------------------
// Typemap to convert strings to wxColour.  Two string formats are accepted,
// either a colour name, or a hex colour spec like "#RRGGBB"

%typemap(python,in) wxColour& (wxColour temp) {
    $target = &temp;
    if (! wxColour_helper($source, &$target))
        return NULL;
}

//---------------------------------------------------------------------------
// Typemap for wxArrayString from Python sequence objects

%typemap(python,in) wxArrayString& {
    if (! PySequence_Check($source)) {
        PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
        return NULL;
    }
    $target = new wxArrayString;
    int i, len=PySequence_Length($source);
    for (i=0; i<len; i++) {
        PyObject* item = PySequence_GetItem($source, i);
#if wxUSE_UNICODE
        PyObject* str  = PyObject_Unicode(item);
        $target->Add(PyUnicode_AsUnicode(str));
#else
        PyObject* str  = PyObject_Str(item);
        $target->Add(PyString_AsString(str));
#endif
        Py_DECREF(item);
        Py_DECREF(str);
    }
}

%typemap(python, freearg) wxArrayString& {
    if ($target)
        delete $source;
}

//---------------------------------------------------------------------------
// Typemap for wxArrayInt from Python sequence objects

%typemap(python,in) wxArrayInt& {
    if (! PySequence_Check($source)) {
        PyErr_SetString(PyExc_TypeError, "Sequence of integers expected.");
        return NULL;
    }
    $target = new wxArrayInt;
    int i, len=PySequence_Length($source);
    for (i=0; i<len; i++) {
        PyObject* item = PySequence_GetItem($source, i);
        PyObject* number  = PyNumber_Int(item);
        $target->Add(PyInt_AS_LONG(number));
        Py_DECREF(item);
        Py_DECREF(number);
    }
}

%typemap(python, freearg) wxArrayInt& {
    if ($target)
        delete $source;
}


//---------------------------------------------------------------------------
// Map T_OUTPUTs for floats to return ints.


%typemap(python,ignore) float          *T_OUTPUT_TOINT(float temp),
                        double         *T_OUTPUT_TOINT(double temp)
{
  $target = &temp;
}


%typemap(python,argout) float          *T_OUTPUT_TOINT,
                        double         *T_OUTPUT_TOINT
{
    PyObject *o;
    o = PyInt_FromLong((long) (*$source));
    $target = t_output_helper($target, o);
}


%typemap(python,ignore) bool *T_OUTPUT(int temp)
{
  $target = (bool*)&temp;
}

%typemap(python,argout) bool *T_OUTPUT
{
    PyObject *o;
    o = PyInt_FromLong((long) (*$source));
    $target = t_output_helper($target, o);
}

%typemap(python,ignore) bool  *OUTPUT = bool *T_OUTPUT;
%typemap(python,argout) bool  *OUTPUT = bool *T_OUTPUT;


%typemap(python,ignore) byte *T_OUTPUT(int temp)
{
  $target = (byte*)&temp;
}

%typemap(python,argout) byte *T_OUTPUT
{
    PyObject *o;
    o = PyInt_FromLong((long) (*$source));
    $target = t_output_helper($target, o);
}

%typemap(python,ignore) byte  *OUTPUT = byte *T_OUTPUT;
%typemap(python,argout) byte  *OUTPUT = byte *T_OUTPUT;

//---------------------------------------------------------------------------
// Typemaps to convert return values that are base class pointers
// to the real derived type, if possible.  See wxPyMake_wxObject in
// helpers.cpp

%typemap(python, out) wxEvtHandler*             { $target = wxPyMake_wxObject($source); }
%typemap(python, out) wxMenu*                   { $target = wxPyMake_wxObject($source); }
%typemap(python, out) wxValidator*              { $target = wxPyMake_wxObject($source); }

%typemap(python, out) wxDC*                     { $target = wxPyMake_wxObject($source); }
%typemap(python, out) wxFSFile*                 { $target = wxPyMake_wxObject($source); }
%typemap(python, out) wxFileSystem*             { $target = wxPyMake_wxObject($source); }
%typemap(python, out) wxGridTableBase*          { $target = wxPyMake_wxObject($source); }
%typemap(python, out) wxImageList*              { $target = wxPyMake_wxObject($source); }
%typemap(python, out) wxListItem*               { $target = wxPyMake_wxObject($source); }
%typemap(python, out) wxMenuItem*               { $target = wxPyMake_wxObject($source); }
%typemap(python, out) wxMouseEvent*             { $target = wxPyMake_wxObject($source); }
%typemap(python, out) wxObject*                 { $target = wxPyMake_wxObject($source); }
%typemap(python, out) wxPyPrintout*             { $target = wxPyMake_wxObject($source); }
%typemap(python, out) wxToolBarToolBase*        { $target = wxPyMake_wxObject($source); }
%typemap(python, out) wxToolTip*                { $target = wxPyMake_wxObject($source); }


%typemap(python, out) wxButton*                 { $target = wxPyMake_wxObject($source); }
%typemap(python, out) wxControl*                { $target = wxPyMake_wxObject($source); }
%typemap(python, out) wxFrame*                  { $target = wxPyMake_wxObject($source); }
%typemap(python, out) wxGrid*                   { $target = wxPyMake_wxObject($source); }
%typemap(python, out) wxMDIChildFrame*          { $target = wxPyMake_wxObject($source); }
%typemap(python, out) wxMDIClientWindow*        { $target = wxPyMake_wxObject($source); }
%typemap(python, out) wxMenuBar*                { $target = wxPyMake_wxObject($source); }
%typemap(python, out) wxNotebook*               { $target = wxPyMake_wxObject($source); }
%typemap(python, out) wxStaticBox*              { $target = wxPyMake_wxObject($source); }
%typemap(python, out) wxStatusBar*              { $target = wxPyMake_wxObject($source); }
%typemap(python, out) wxTextCtrl*               { $target = wxPyMake_wxObject($source); }
%typemap(python, out) wxToolBar*                { $target = wxPyMake_wxObject($source); }
%typemap(python, out) wxToolBarBase*            { $target = wxPyMake_wxObject($source); }
%typemap(python, out) wxWindow*                 { $target = wxPyMake_wxObject($source); }
%typemap(python, out) wxHtmlWindow*             { $target = wxPyMake_wxObject($source); }

%typemap(python, out) wxSizer*                  { $target = wxPyMake_wxSizer($source); }


//%typemap(python, out) wxHtmlCell*               { $target = wxPyMake_wxObject($source); }
//%typemap(python, out) wxHtmlContainerCell*      { $target = wxPyMake_wxObject($source); }
//%typemap(python, out) wxHtmlParser*             { $target = wxPyMake_wxObject($source); }
//%typemap(python, out) wxHtmlWinParser*          { $target = wxPyMake_wxObject($source); }

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
Commit	Line	Data
7bf85405 RD	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: my_typemaps.i
	3	// Purpose: Special typemaps specifically for wxPython.
	4	//
	5	// Author: Robin Dunn
	6	//
	7	// Created: 7/3/97
	8	// RCS-ID: $Id$
	9	// Copyright: (c) 1998 by Total Control Software
	10	// Licence: wxWindows license
	11	/////////////////////////////////////////////////////////////////////////////
	12
	13
cf694132	14	//---------------------------------------------------------------------------
4268f798	15	// Tell SWIG to wrap all the wrappers with our thread protection
cf694132 RD	16
cf694132 RD	17	%except(python) {
4268f798	18	PyThreadState* __tstate = wxPyBeginAllowThreads();
c8bc7bb8	19	$function
4268f798	20	wxPyEndAllowThreads(__tstate);
493f1553	21	if (PyErr_Occurred()) return NULL;
cf694132 RD	22	}
cf694132 RD	23
7bf85405	24	//----------------------------------------------------------------------
eec92d76	25	// LCOUNT and choices go together. They allow a single Python list to be
2f90df85	26	// converted to an integer count and an array count items long.
7bf85405 RD	27
7bf85405 RD	28	%typemap(python,build) int LCOUNT {
eec92d76 RD	29	if (_in_choices) {
eec92d76 RD	30	$target = PyList_Size(_in_choices);
cf694132 RD	31	}
	32	else {
	33	$target = 0;
	34	}
7bf85405 RD	35	}
	36
	37
	38
eec92d76	39	%typemap(python,in) byte* choices {
b639c3c5 RD	40	$target = byte_LIST_helper($source);
	41	if ($target == NULL) {
	42	return NULL;
	43	}
	44	}
eec92d76	45	%typemap(python,freearg) byte* choices {
b639c3c5 RD	46	delete [] $source;
	47	}
	48
de9d9ed2 RD	49	// wxDash is a signed char
	50	%typemap(python,in) wxDash* choices {
	51	$target = (wxDash*)byte_LIST_helper($source);
	52	if ($target == NULL) {
	53	return NULL;
	54	}
	55	}
	56	%typemap(python,freearg) wxDash* choices {
	57	delete [] $source;
	58	}
	59
b639c3c5	60
eec92d76	61	%typemap(python,in) int* choices {
7bf85405 RD	62	$target = int_LIST_helper($source);
	63	if ($target == NULL) {
	64	return NULL;
	65	}
	66	}
eec92d76	67	%typemap(python,freearg) int* choices {
7bf85405 RD	68	delete [] $source;
	69	}
	70
	71
eec92d76	72	%typemap(python,in) long* choices {
7bf85405 RD	73	$target = long_LIST_helper($source);
	74	if ($target == NULL) {
	75	return NULL;
	76	}
	77	}
eec92d76	78	%typemap(python,freearg) long* choices {
7bf85405 RD	79	delete [] $source;
	80	}
	81
	82
eec92d76	83	%typemap(python,in) unsigned long* choices {
7bf85405 RD	84	$target = (unsigned long*)long_LIST_helper($source);
	85	if ($target == NULL) {
	86	return NULL;
	87	}
	88	}
eec92d76	89	%typemap(python,freearg) unsigned long* choices {
7bf85405 RD	90	delete [] $source;
	91	}
	92
	93
eec92d76	94	%typemap(python,in) char** choices {
7bf85405 RD	95	$target = string_LIST_helper($source);
	96	if ($target == NULL) {
	97	return NULL;
	98	}
	99	}
eec92d76	100	%typemap(python,freearg) char** choices {
7bf85405 RD	101	delete [] $source;
	102	}
	103
	104
eec92d76 RD	105	%typemap(python,in) wxBitmap** choices {
eec92d76 RD	106	$target = wxBitmap_LIST_helper($source);
7bf85405 RD	107	if ($target == NULL) {
	108	return NULL;
	109	}
	110	}
eec92d76	111	%typemap(python,freearg) wxBitmap** choices {
7bf85405 RD	112	delete [] $source;
	113	}
	114
eec92d76 RD	115	%typemap(python,in) wxString* choices {
eec92d76 RD	116	$target = wxString_LIST_helper($source);
7bf85405 RD	117	if ($target == NULL) {
	118	return NULL;
	119	}
	120	}
eec92d76	121	%typemap(python,freearg) wxString* choices {
7bf85405 RD	122	delete [] $source;
	123	}
	124
eec92d76 RD	125	%typemap(python,in) wxAcceleratorEntry* choices {
eec92d76 RD	126	$target = wxAcceleratorEntry_LIST_helper($source);
7bf85405 RD	127	if ($target == NULL) {
	128	return NULL;
	129	}
	130	}
eec92d76	131	%typemap(python,freearg) wxAcceleratorEntry* choices {
7bf85405 RD	132	delete [] $source;
	133	}
	134
eec92d76	135	%typemap(python,build) int PCOUNT {
e0672e2f	136	$target = NPOINTS;
eec92d76 RD	137	}
eec92d76 RD	138
e0672e2f RD	139	%typemap(python,in) wxPoint* points (int NPOINTS) {
	140	$target = wxPoint_LIST_helper($source, &NPOINTS);
	141	if ($target == NULL) {
	142	return NULL;
	143	}
7bf85405	144	}
eec92d76	145	%typemap(python,freearg) wxPoint* points {
7bf85405 RD	146	delete [] $source;
	147	}
	148
	149
eec92d76	150
e0672e2f	151
7bf85405 RD	152	//---------------------------------------------------------------------------
7bf85405 RD	153
c8bc7bb8	154
7bf85405	155	%typemap(python, in) wxString& {
c8bc7bb8 RD	156	$target = wxString_in_helper($source);
c8bc7bb8 RD	157	if ($target == NULL)
185d7c3e	158	return NULL;
7bf85405	159	}
185d7c3e RD	160
185d7c3e RD	161
7bf85405 RD	162	%typemap(python, freearg) wxString& {
	163	if ($target)
	164	delete $source;
	165	}
	166
	167
	168
	169	%typemap(python, out) wxString {
c8bc7bb8 RD	170	#if wxUSE_UNICODE
	171	$target = PyUnicode_FromUnicode($source->c_str(), $source->Len());
	172	#else
eec92d76	173	$target = PyString_FromStringAndSize($source->c_str(), $source->Len());
c8bc7bb8	174	#endif
7bf85405 RD	175	}
	176	%typemap(python, ret) wxString {
	177	delete $source;
	178	}
	179
	180
	181	%typemap(python, out) wxString* {
c8bc7bb8 RD	182	#if wxUSE_UNICODE
	183	$target = PyUnicode_FromUnicode($source->c_str(), $source->Len());
	184	#else
eec92d76	185	$target = PyString_FromStringAndSize($source->c_str(), $source->Len());
c8bc7bb8	186	#endif
7bf85405 RD	187	}
	188
	189
2f90df85 RD	190
	191
	192
7bf85405	193	//---------------------------------------------------------------------------
0122b7e3	194	// Typemaps to convert Python sequence objects (tuples, etc.) to
2f90df85 RD	195	// wxSize, wxPoint, wxRealPoint, and wxRect.
	196
	197	%typemap(python,in) wxSize& (wxSize temp) {
	198	$target = &temp;
	199	if (! wxSize_helper($source, &$target))
	200	return NULL;
	201	}
	202
	203	%typemap(python,in) wxPoint& (wxPoint temp) {
	204	$target = &temp;
	205	if (! wxPoint_helper($source, &$target))
	206	return NULL;
	207	}
	208
	209	%typemap(python,in) wxRealPoint& (wxRealPoint temp) {
	210	$target = &temp;
	211	if (! wxRealPoint_helper($source, &$target))
	212	return NULL;
	213	}
7bf85405	214
2f90df85 RD	215	%typemap(python,in) wxRect& (wxRect temp) {
	216	$target = &temp;
	217	if (! wxRect_helper($source, &$target))
	218	return NULL;
	219	}
7bf85405	220
f6bcfd97 BP	221	//---------------------------------------------------------------------------
f6bcfd97 BP	222	// Typemap to convert strings to wxColour. Two string formats are accepted,
de20db99	223	// either a colour name, or a hex colour spec like "#RRGGBB"
f6bcfd97 BP	224
	225	%typemap(python,in) wxColour& (wxColour temp) {
	226	$target = &temp;
	227	if (! wxColour_helper($source, &$target))
	228	return NULL;
	229	}
	230
b37c7e1d RD	231	//---------------------------------------------------------------------------
	232	// Typemap for wxArrayString from Python sequence objects
	233
	234	%typemap(python,in) wxArrayString& {
	235	if (! PySequence_Check($source)) {
	236	PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
	237	return NULL;
	238	}
	239	$target = new wxArrayString;
	240	int i, len=PySequence_Length($source);
	241	for (i=0; i<len; i++) {
	242	PyObject* item = PySequence_GetItem($source, i);
c8bc7bb8 RD	243	#if wxUSE_UNICODE
	244	PyObject* str = PyObject_Unicode(item);
	245	$target->Add(PyUnicode_AsUnicode(str));
	246	#else
b37c7e1d	247	PyObject* str = PyObject_Str(item);
293a0a86	248	$target->Add(PyString_AsString(str));
c8bc7bb8	249	#endif
b37c7e1d RD	250	Py_DECREF(item);
	251	Py_DECREF(str);
	252	}
	253	}
	254
	255	%typemap(python, freearg) wxArrayString& {
	256	if ($target)
	257	delete $source;
	258	}
7bf85405	259
293a0a86 RD	260	//---------------------------------------------------------------------------
	261	// Typemap for wxArrayInt from Python sequence objects
	262
	263	%typemap(python,in) wxArrayInt& {
	264	if (! PySequence_Check($source)) {
	265	PyErr_SetString(PyExc_TypeError, "Sequence of integers expected.");
	266	return NULL;
	267	}
	268	$target = new wxArrayInt;
	269	int i, len=PySequence_Length($source);
	270	for (i=0; i<len; i++) {
	271	PyObject* item = PySequence_GetItem($source, i);
	272	PyObject* number = PyNumber_Int(item);
	273	$target->Add(PyInt_AS_LONG(number));
	274	Py_DECREF(item);
	275	Py_DECREF(number);
	276	}
	277	}
	278
	279	%typemap(python, freearg) wxArrayInt& {
	280	if ($target)
	281	delete $source;
	282	}
	283
	284
2f90df85	285	//---------------------------------------------------------------------------
7bf85405 RD	286	// Map T_OUTPUTs for floats to return ints.
	287
	288
	289	%typemap(python,ignore) float *T_OUTPUT_TOINT(float temp),
	290	double *T_OUTPUT_TOINT(double temp)
	291	{
	292	$target = &temp;
	293	}
	294
	295
	296	%typemap(python,argout) float *T_OUTPUT_TOINT,
	297	double *T_OUTPUT_TOINT
	298	{
	299	PyObject *o;
	300	o = PyInt_FromLong((long) (*$source));
	301	$target = t_output_helper($target, o);
	302	}
	303
68320e40 RD	304
	305	%typemap(python,ignore) bool *T_OUTPUT(int temp)
	306	{
	307	$target = (bool*)&temp;
	308	}
	309
	310	%typemap(python,argout) bool *T_OUTPUT
	311	{
	312	PyObject *o;
	313	o = PyInt_FromLong((long) (*$source));
	314	$target = t_output_helper($target, o);
	315	}
	316
68320e40 RD	317	%typemap(python,ignore) bool OUTPUT = bool T_OUTPUT;
	318	%typemap(python,argout) bool OUTPUT = bool T_OUTPUT;
	319
154747f5 RD	320
	321
	322	%typemap(python,ignore) byte *T_OUTPUT(int temp)
	323	{
	324	$target = (byte*)&temp;
	325	}
	326
	327	%typemap(python,argout) byte *T_OUTPUT
	328	{
	329	PyObject *o;
	330	o = PyInt_FromLong((long) (*$source));
	331	$target = t_output_helper($target, o);
	332	}
	333
	334	%typemap(python,ignore) byte OUTPUT = byte T_OUTPUT;
	335	%typemap(python,argout) byte OUTPUT = byte T_OUTPUT;
	336
9416aa89 RD	337	//---------------------------------------------------------------------------
	338	// Typemaps to convert return values that are base class pointers
	339	// to the real derived type, if possible. See wxPyMake_wxObject in
	340	// helpers.cpp
	341
0122b7e3 RD	342	%typemap(python, out) wxEvtHandler* { $target = wxPyMake_wxObject($source); }
	343	%typemap(python, out) wxMenu* { $target = wxPyMake_wxObject($source); }
	344	%typemap(python, out) wxValidator* { $target = wxPyMake_wxObject($source); }
9416aa89	345
9416aa89	346	%typemap(python, out) wxDC* { $target = wxPyMake_wxObject($source); }
9416aa89 RD	347	%typemap(python, out) wxFSFile* { $target = wxPyMake_wxObject($source); }
9416aa89 RD	348	%typemap(python, out) wxFileSystem* { $target = wxPyMake_wxObject($source); }
9416aa89 RD	349	%typemap(python, out) wxGridTableBase* { $target = wxPyMake_wxObject($source); }
	350	%typemap(python, out) wxImageList* { $target = wxPyMake_wxObject($source); }
	351	%typemap(python, out) wxListItem* { $target = wxPyMake_wxObject($source); }
9416aa89 RD	352	%typemap(python, out) wxMenuItem* { $target = wxPyMake_wxObject($source); }
9416aa89 RD	353	%typemap(python, out) wxMouseEvent* { $target = wxPyMake_wxObject($source); }
9416aa89 RD	354	%typemap(python, out) wxObject* { $target = wxPyMake_wxObject($source); }
9416aa89 RD	355	%typemap(python, out) wxPyPrintout* { $target = wxPyMake_wxObject($source); }
0122b7e3 RD	356	%typemap(python, out) wxToolBarToolBase* { $target = wxPyMake_wxObject($source); }
	357	%typemap(python, out) wxToolTip* { $target = wxPyMake_wxObject($source); }
	358
	359
	360	%typemap(python, out) wxButton* { $target = wxPyMake_wxObject($source); }
	361	%typemap(python, out) wxControl* { $target = wxPyMake_wxObject($source); }
	362	%typemap(python, out) wxFrame* { $target = wxPyMake_wxObject($source); }
	363	%typemap(python, out) wxGrid* { $target = wxPyMake_wxObject($source); }
	364	%typemap(python, out) wxMDIChildFrame* { $target = wxPyMake_wxObject($source); }
	365	%typemap(python, out) wxMDIClientWindow* { $target = wxPyMake_wxObject($source); }
	366	%typemap(python, out) wxMenuBar* { $target = wxPyMake_wxObject($source); }
	367	%typemap(python, out) wxNotebook* { $target = wxPyMake_wxObject($source); }
9416aa89 RD	368	%typemap(python, out) wxStaticBox* { $target = wxPyMake_wxObject($source); }
	369	%typemap(python, out) wxStatusBar* { $target = wxPyMake_wxObject($source); }
	370	%typemap(python, out) wxTextCtrl* { $target = wxPyMake_wxObject($source); }
	371	%typemap(python, out) wxToolBar* { $target = wxPyMake_wxObject($source); }
	372	%typemap(python, out) wxToolBarBase* { $target = wxPyMake_wxObject($source); }
9416aa89	373	%typemap(python, out) wxWindow* { $target = wxPyMake_wxObject($source); }
6c5ae2d2	374	%typemap(python, out) wxHtmlWindow* { $target = wxPyMake_wxObject($source); }
9416aa89	375
2f4e9287 RD	376	%typemap(python, out) wxSizer* { $target = wxPyMake_wxSizer($source); }
2f4e9287 RD	377
9416aa89 RD	378
	379	//%typemap(python, out) wxHtmlCell* { $target = wxPyMake_wxObject($source); }
	380	//%typemap(python, out) wxHtmlContainerCell* { $target = wxPyMake_wxObject($source); }
	381	//%typemap(python, out) wxHtmlParser* { $target = wxPyMake_wxObject($source); }
	382	//%typemap(python, out) wxHtmlWinParser* { $target = wxPyMake_wxObject($source); }
	383
7bf85405	384	//---------------------------------------------------------------------------
2f90df85	385	//---------------------------------------------------------------------------
7bf85405	386
9416aa89 RD	387
	388
	389
	390
	391