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;
}


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

%{
#if PYTHON_API_VERSION >= 1009
    static char* wxStringErrorMsg = "String or Unicode type required";
#else
    static char* wxStringErrorMsg = "String type required";
#endif
%}

// TODO:  Which works best???

// Implementation #1
//  %typemap(python, in) wxString& (PyObject* temp, int tmpDoDecRef) {
//      temp = $source;
//      tmpDoDecRef = 0;
//  #if PYTHON_API_VERSION >= 1009
//      if (PyUnicode_Check(temp) {
//          temp = PyUnicode_AsUTF8String(temp);
//          if (! temp) {
//              PyErr_SetString(PyExc_TypeError, "Unicode encoding to UTF8 failed.");
//              return NULL;
//          }
//          tmpDoDecRef = 1;
//  #endif
//      if (!PyString_Check(temp)) {
//          PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
//          return NULL;
//      }
//      $target = new wxString(PyString_AsString(temp), PyString_Size(temp));
//  #if PYTHON_API_VERESION >= 1009
//      if (tmpDoDecRef) Py_DECREF(temp);
//  #endif
//  }


// Implementation #2
%typemap(python, in) wxString& {
#if PYTHON_API_VERSION >= 1009
    char* tmpPtr; int tmpSize;
    if (!PyString_Check($source) && !PyUnicode_Check($source)) {
        PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
        return NULL;
    }
    if (PyString_AsStringAndSize($source, &tmpPtr, &tmpSize) == -1)
        return NULL;
    $target = new wxString(tmpPtr, tmpSize);
#else
    if (!PyString_Check($source)) {
        PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
        return NULL;
    }
    $target = new wxString(PyString_AS_STRING($source), PyString_GET_SIZE($source));
#endif
}


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


%typemap(python, out) wxString {
    $target = PyString_FromStringAndSize($source->c_str(), $source->Len());
}
%typemap(python, ret) wxString {
    delete $source;
}


%typemap(python, out) wxString* {
    $target = PyString_FromStringAndSize($source->c_str(), $source->Len());
}


//---------------------------------------------------------------------------
// 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);
        PyObject* str  = PyObject_Str(item);
        $target->Add(PyString_AsString(str));
        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
	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
	14	//---------------------------------------------------------------------------
	15	// Tell SWIG to wrap all the wrappers with our thread protection
	16
	17	%except(python) {
	18	PyThreadState* __tstate = wxPyBeginAllowThreads();
	19	$function
	20	wxPyEndAllowThreads(__tstate);
	21	if (PyErr_Occurred()) return NULL;
	22	}
	23
	24	//----------------------------------------------------------------------
	25	// LCOUNT and choices go together. They allow a single Python list to be
	26	// converted to an integer count and an array count items long.
	27
	28	%typemap(python,build) int LCOUNT {
	29	if (_in_choices) {
	30	$target = PyList_Size(_in_choices);
	31	}
	32	else {
	33	$target = 0;
	34	}
	35	}
	36
	37
	38
	39	%typemap(python,in) byte* choices {
	40	$target = byte_LIST_helper($source);
	41	if ($target == NULL) {
	42	return NULL;
	43	}
	44	}
	45	%typemap(python,freearg) byte* choices {
	46	delete [] $source;
	47	}
	48
	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
	60
	61	%typemap(python,in) int* choices {
	62	$target = int_LIST_helper($source);
	63	if ($target == NULL) {
	64	return NULL;
	65	}
	66	}
	67	%typemap(python,freearg) int* choices {
	68	delete [] $source;
	69	}
	70
	71
	72	%typemap(python,in) long* choices {
	73	$target = long_LIST_helper($source);
	74	if ($target == NULL) {
	75	return NULL;
	76	}
	77	}
	78	%typemap(python,freearg) long* choices {
	79	delete [] $source;
	80	}
	81
	82
	83	%typemap(python,in) unsigned long* choices {
	84	$target = (unsigned long*)long_LIST_helper($source);
	85	if ($target == NULL) {
	86	return NULL;
	87	}
	88	}
	89	%typemap(python,freearg) unsigned long* choices {
	90	delete [] $source;
	91	}
	92
	93
	94	%typemap(python,in) char** choices {
	95	$target = string_LIST_helper($source);
	96	if ($target == NULL) {
	97	return NULL;
	98	}
	99	}
	100	%typemap(python,freearg) char** choices {
	101	delete [] $source;
	102	}
	103
	104
	105	%typemap(python,in) wxBitmap** choices {
	106	$target = wxBitmap_LIST_helper($source);
	107	if ($target == NULL) {
	108	return NULL;
	109	}
	110	}
	111	%typemap(python,freearg) wxBitmap** choices {
	112	delete [] $source;
	113	}
	114
	115	%typemap(python,in) wxString* choices {
	116	$target = wxString_LIST_helper($source);
	117	if ($target == NULL) {
	118	return NULL;
	119	}
	120	}
	121	%typemap(python,freearg) wxString* choices {
	122	delete [] $source;
	123	}
	124
	125	%typemap(python,in) wxAcceleratorEntry* choices {
	126	$target = wxAcceleratorEntry_LIST_helper($source);
	127	if ($target == NULL) {
	128	return NULL;
	129	}
	130	}
	131	%typemap(python,freearg) wxAcceleratorEntry* choices {
	132	delete [] $source;
	133	}
	134
	135	%typemap(python,build) int PCOUNT {
	136	$target = NPOINTS;
	137	}
	138
	139	%typemap(python,in) wxPoint* points (int NPOINTS) {
	140	$target = wxPoint_LIST_helper($source, &NPOINTS);
	141	if ($target == NULL) {
	142	return NULL;
	143	}
	144	}
	145	%typemap(python,freearg) wxPoint* points {
	146	delete [] $source;
	147	}
	148
	149
	150
	151
	152	//---------------------------------------------------------------------------
	153
	154	%{
	155	#if PYTHON_API_VERSION >= 1009
	156	static char* wxStringErrorMsg = "String or Unicode type required";
	157	#else
	158	static char* wxStringErrorMsg = "String type required";
	159	#endif
	160	%}
	161
	162	// TODO: Which works best???
	163
	164	// Implementation #1
	165	// %typemap(python, in) wxString& (PyObject* temp, int tmpDoDecRef) {
	166	// temp = $source;
	167	// tmpDoDecRef = 0;
	168	// #if PYTHON_API_VERSION >= 1009
	169	// if (PyUnicode_Check(temp) {
	170	// temp = PyUnicode_AsUTF8String(temp);
	171	// if (! temp) {
	172	// PyErr_SetString(PyExc_TypeError, "Unicode encoding to UTF8 failed.");
	173	// return NULL;
	174	// }
	175	// tmpDoDecRef = 1;
	176	// #endif
	177	// if (!PyString_Check(temp)) {
	178	// PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
	179	// return NULL;
	180	// }
	181	// $target = new wxString(PyString_AsString(temp), PyString_Size(temp));
	182	// #if PYTHON_API_VERESION >= 1009
	183	// if (tmpDoDecRef) Py_DECREF(temp);
	184	// #endif
	185	// }
	186
	187
	188	// Implementation #2
	189	%typemap(python, in) wxString& {
	190	#if PYTHON_API_VERSION >= 1009
	191	char* tmpPtr; int tmpSize;
	192	if (!PyString_Check($source) && !PyUnicode_Check($source)) {
	193	PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
	194	return NULL;
	195	}
	196	if (PyString_AsStringAndSize($source, &tmpPtr, &tmpSize) == -1)
	197	return NULL;
	198	$target = new wxString(tmpPtr, tmpSize);
	199	#else
	200	if (!PyString_Check($source)) {
	201	PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
	202	return NULL;
	203	}
	204	$target = new wxString(PyString_AS_STRING($source), PyString_GET_SIZE($source));
	205	#endif
	206	}
	207
	208
	209
	210
	211	%typemap(python, freearg) wxString& {
	212	if ($target)
	213	delete $source;
	214	}
	215
	216
	217
	218	%typemap(python, out) wxString {
	219	$target = PyString_FromStringAndSize($source->c_str(), $source->Len());
	220	}
	221	%typemap(python, ret) wxString {
	222	delete $source;
	223	}
	224
	225
	226	%typemap(python, out) wxString* {
	227	$target = PyString_FromStringAndSize($source->c_str(), $source->Len());
	228	}
	229
	230
	231
	232
	233
	234	//---------------------------------------------------------------------------
	235	// Typemaps to convert Python sequence objects (tuples, etc.) to
	236	// wxSize, wxPoint, wxRealPoint, and wxRect.
	237
	238	%typemap(python,in) wxSize& (wxSize temp) {
	239	$target = &temp;
	240	if (! wxSize_helper($source, &$target))
	241	return NULL;
	242	}
	243
	244	%typemap(python,in) wxPoint& (wxPoint temp) {
	245	$target = &temp;
	246	if (! wxPoint_helper($source, &$target))
	247	return NULL;
	248	}
	249
	250	%typemap(python,in) wxRealPoint& (wxRealPoint temp) {
	251	$target = &temp;
	252	if (! wxRealPoint_helper($source, &$target))
	253	return NULL;
	254	}
	255
	256	%typemap(python,in) wxRect& (wxRect temp) {
	257	$target = &temp;
	258	if (! wxRect_helper($source, &$target))
	259	return NULL;
	260	}
	261
	262	//---------------------------------------------------------------------------
	263	// Typemap to convert strings to wxColour. Two string formats are accepted,
	264	// either a colour name, or a hex colour spec like "#RRGGBB"
	265
	266	%typemap(python,in) wxColour& (wxColour temp) {
	267	$target = &temp;
	268	if (! wxColour_helper($source, &$target))
	269	return NULL;
	270	}
	271
	272	//---------------------------------------------------------------------------
	273	// Typemap for wxArrayString from Python sequence objects
	274
	275	%typemap(python,in) wxArrayString& {
	276	if (! PySequence_Check($source)) {
	277	PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
	278	return NULL;
	279	}
	280	$target = new wxArrayString;
	281	int i, len=PySequence_Length($source);
	282	for (i=0; i<len; i++) {
	283	PyObject* item = PySequence_GetItem($source, i);
	284	PyObject* str = PyObject_Str(item);
	285	$target->Add(PyString_AsString(str));
	286	Py_DECREF(item);
	287	Py_DECREF(str);
	288	}
	289	}
	290
	291	%typemap(python, freearg) wxArrayString& {
	292	if ($target)
	293	delete $source;
	294	}
	295
	296	//---------------------------------------------------------------------------
	297	// Typemap for wxArrayInt from Python sequence objects
	298
	299	%typemap(python,in) wxArrayInt& {
	300	if (! PySequence_Check($source)) {
	301	PyErr_SetString(PyExc_TypeError, "Sequence of integers expected.");
	302	return NULL;
	303	}
	304	$target = new wxArrayInt;
	305	int i, len=PySequence_Length($source);
	306	for (i=0; i<len; i++) {
	307	PyObject* item = PySequence_GetItem($source, i);
	308	PyObject* number = PyNumber_Int(item);
	309	$target->Add(PyInt_AS_LONG(number));
	310	Py_DECREF(item);
	311	Py_DECREF(number);
	312	}
	313	}
	314
	315	%typemap(python, freearg) wxArrayInt& {
	316	if ($target)
	317	delete $source;
	318	}
	319
	320
	321	//---------------------------------------------------------------------------
	322	// Map T_OUTPUTs for floats to return ints.
	323
	324
	325	%typemap(python,ignore) float *T_OUTPUT_TOINT(float temp),
	326	double *T_OUTPUT_TOINT(double temp)
	327	{
	328	$target = &temp;
	329	}
	330
	331
	332	%typemap(python,argout) float *T_OUTPUT_TOINT,
	333	double *T_OUTPUT_TOINT
	334	{
	335	PyObject *o;
	336	o = PyInt_FromLong((long) (*$source));
	337	$target = t_output_helper($target, o);
	338	}
	339
	340
	341	%typemap(python,ignore) bool *T_OUTPUT(int temp)
	342	{
	343	$target = (bool*)&temp;
	344	}
	345
	346	%typemap(python,argout) bool *T_OUTPUT
	347	{
	348	PyObject *o;
	349	o = PyInt_FromLong((long) (*$source));
	350	$target = t_output_helper($target, o);
	351	}
	352
	353	%typemap(python,ignore) bool OUTPUT = bool T_OUTPUT;
	354	%typemap(python,argout) bool OUTPUT = bool T_OUTPUT;
	355
	356
	357
	358	%typemap(python,ignore) byte *T_OUTPUT(int temp)
	359	{
	360	$target = (byte*)&temp;
	361	}
	362
	363	%typemap(python,argout) byte *T_OUTPUT
	364	{
	365	PyObject *o;
	366	o = PyInt_FromLong((long) (*$source));
	367	$target = t_output_helper($target, o);
	368	}
	369
	370	%typemap(python,ignore) byte OUTPUT = byte T_OUTPUT;
	371	%typemap(python,argout) byte OUTPUT = byte T_OUTPUT;
	372
	373	//---------------------------------------------------------------------------
	374	// Typemaps to convert return values that are base class pointers
	375	// to the real derived type, if possible. See wxPyMake_wxObject in
	376	// helpers.cpp
	377
	378	%typemap(python, out) wxEvtHandler* { $target = wxPyMake_wxObject($source); }
	379	%typemap(python, out) wxMenu* { $target = wxPyMake_wxObject($source); }
	380	%typemap(python, out) wxValidator* { $target = wxPyMake_wxObject($source); }
	381
	382	%typemap(python, out) wxDC* { $target = wxPyMake_wxObject($source); }
	383	%typemap(python, out) wxFSFile* { $target = wxPyMake_wxObject($source); }
	384	%typemap(python, out) wxFileSystem* { $target = wxPyMake_wxObject($source); }
	385	%typemap(python, out) wxGridTableBase* { $target = wxPyMake_wxObject($source); }
	386	%typemap(python, out) wxImageList* { $target = wxPyMake_wxObject($source); }
	387	%typemap(python, out) wxListItem* { $target = wxPyMake_wxObject($source); }
	388	%typemap(python, out) wxMenuItem* { $target = wxPyMake_wxObject($source); }
	389	%typemap(python, out) wxMouseEvent* { $target = wxPyMake_wxObject($source); }
	390	%typemap(python, out) wxObject* { $target = wxPyMake_wxObject($source); }
	391	%typemap(python, out) wxPyPrintout* { $target = wxPyMake_wxObject($source); }
	392	%typemap(python, out) wxToolBarToolBase* { $target = wxPyMake_wxObject($source); }
	393	%typemap(python, out) wxToolTip* { $target = wxPyMake_wxObject($source); }
	394
	395
	396	%typemap(python, out) wxButton* { $target = wxPyMake_wxObject($source); }
	397	%typemap(python, out) wxControl* { $target = wxPyMake_wxObject($source); }
	398	%typemap(python, out) wxFrame* { $target = wxPyMake_wxObject($source); }
	399	%typemap(python, out) wxGrid* { $target = wxPyMake_wxObject($source); }
	400	%typemap(python, out) wxMDIChildFrame* { $target = wxPyMake_wxObject($source); }
	401	%typemap(python, out) wxMDIClientWindow* { $target = wxPyMake_wxObject($source); }
	402	%typemap(python, out) wxMenuBar* { $target = wxPyMake_wxObject($source); }
	403	%typemap(python, out) wxNotebook* { $target = wxPyMake_wxObject($source); }
	404	%typemap(python, out) wxStaticBox* { $target = wxPyMake_wxObject($source); }
	405	%typemap(python, out) wxStatusBar* { $target = wxPyMake_wxObject($source); }
	406	%typemap(python, out) wxTextCtrl* { $target = wxPyMake_wxObject($source); }
	407	%typemap(python, out) wxToolBar* { $target = wxPyMake_wxObject($source); }
	408	%typemap(python, out) wxToolBarBase* { $target = wxPyMake_wxObject($source); }
	409	%typemap(python, out) wxWindow* { $target = wxPyMake_wxObject($source); }
	410	%typemap(python, out) wxHtmlWindow* { $target = wxPyMake_wxObject($source); }
	411
	412	%typemap(python, out) wxSizer* { $target = wxPyMake_wxSizer($source); }
	413
	414
	415	//%typemap(python, out) wxHtmlCell* { $target = wxPyMake_wxObject($source); }
	416	//%typemap(python, out) wxHtmlContainerCell* { $target = wxPyMake_wxObject($source); }
	417	//%typemap(python, out) wxHtmlParser* { $target = wxPyMake_wxObject($source); }
	418	//%typemap(python, out) wxHtmlWinParser* { $target = wxPyMake_wxObject($source); }
	419
	420	//---------------------------------------------------------------------------
	421	//---------------------------------------------------------------------------
	422
	423
	424
	425
	426
	427