wxPython/src/my_typemaps.i

   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 %exception {
  18     PyThreadState* __tstate = wxPyBeginAllowThreads();
  19     $action
  20     wxPyEndAllowThreads(__tstate);
  21     if (PyErr_Occurred()) SWIG_fail;
  22 }
  23
  24
  25 //----------------------------------------------------------------------
  26 // Typemaps to convert a list of items to an int (size) and an array
  27
  28 %typemap(in) (int choices, wxString* choices_array ) {
  29     $1 = PyList_Size($input);
  30     $2 = wxString_LIST_helper($input);
  31     if ($2 == NULL) SWIG_fail;
  32 }
  33 %typemap(freearg) (int choices, wxString* choices_array ) {
  34     if ($2) delete [] $2;
  35 }
  36
  37
  38
  39
  40 //---------------------------------------------------------------------------
  41 // wxString typemaps
  42
  43
  44 %typemap(in) wxString& (bool temp=False) {
  45     $1 = wxString_in_helper($input);
  46     if ($1 == NULL) SWIG_fail;
  47     temp = True;
  48 }
  49 %typemap(freearg) wxString& {
  50     if (temp$argnum)
  51         delete $1;
  52 }
  53
  54
  55
  56 %typemap(out) wxString {
  57 %#if wxUSE_UNICODE
  58     $result = PyUnicode_FromWideChar($1.c_str(), $1.Len());
  59 %#else
  60     $result = PyString_FromStringAndSize($1.c_str(), $1.Len());
  61 %#endif
  62 }
  63
  64
  65 %typemap(out) wxString* {
  66 %#if wxUSE_UNICODE
  67     $result = PyUnicode_FromWideChar($1->c_str(), $1->Len());
  68 %#else
  69     $result = PyString_FromStringAndSize($1->c_str(), $1->Len());
  70 %#endif
  71 }
  72
  73
  74 %typemap(out) wxString& {
  75 %#if wxUSE_UNICODE
  76     $result = PyUnicode_FromWideChar($1->c_str(), $1->Len());
  77 %#else
  78     $result = PyString_FromStringAndSize($1->c_str(), $1->Len());
  79 %#endif
  80 }
  81
  82
  83 %typemap(varout) wxString {
  84 %#if wxUSE_UNICODE
  85     $result = PyUnicode_FromWideChar($1.c_str(), $1.Len());
  86 %#else
  87     $result = PyString_FromStringAndSize($1.c_str(), $1.Len());
  88 %#endif
  89 }
  90
  91
  92 %typemap(in) wxString {
  93     wxString* sptr = wxString_in_helper($input);
  94     if (sptr == NULL) SWIG_fail;
  95     $1 = *sptr;
  96     delete sptr;
  97 }
  98
  99
 100
 101 // //---------------------------------------------------------------------------
 102
 103
 104 // %typemap(python, in) wxMemoryBuffer& {
 105 //     if (!PyString_Check($source)) {
 106 //         PyErr_SetString(PyExc_TypeError, "String buffer expected");
 107 //         return NULL;
 108 //     }
 109 //     char* str = PyString_AS_STRING($source);
 110 //     int   len = PyString_GET_SIZE($source);
 111 //     $target = new wxMemoryBuffer(len);
 112 //     memcpy($target->GetData(), str, len);
 113 // }
 114
 115 // %typemap(python, freearg) wxMemoryBuffer& {
 116 //     if ($target)
 117 //         delete $source;
 118 // }
 119
 120 // %typemap(python, out) wxMemoryBuffer {
 121 //     $target = PyString_FromStringAndSize((char*)$source->GetData(), $source->GetDataLen());
 122 // }
 123
 124 // %typemap(python, ret) wxMemoryBuffer {
 125 //     delete $source;
 126 // }
 127
 128
 129 //---------------------------------------------------------------------------
 130 // Typemaps to convert Python sequence objects (tuples, etc.) to
 131 // wxSize, wxPoint, wxRealPoint, and wxRect.
 132
 133
 134 %typemap(in) wxSize& (wxSize temp) {
 135     $1 = &temp;
 136     if ( ! wxSize_helper($input, &$1)) SWIG_fail;
 137 }
 138 %typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) wxSize& {
 139     $1 = wxPySimple_typecheck($input, wxT("wxSize"), 2);
 140 }
 141
 142
 143 %typemap(in) wxPoint& (wxPoint temp) {
 144     $1 = &temp;
 145     if ( ! wxPoint_helper($input, &$1)) SWIG_fail;
 146 }
 147 %typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) wxPoint& {
 148     $1 = wxPySimple_typecheck($input, wxT("wxPoint"), 2);
 149 }
 150
 151
 152 %typemap(in) wxRealPoint& (wxRealPoint temp) {
 153     $1 = &temp;
 154     if ( ! wxRealPoint_helper($input, &$1)) SWIG_fail;
 155 }
 156 %typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) wxRealPoint& {
 157     $1 = wxPySimple_typecheck($input, wxT("wxRealPoint"), 2);
 158 }
 159
 160
 161 %typemap(in) wxRect& (wxRect temp) {
 162     $1 = &temp;
 163     if ( ! wxRect_helper($input, &$1)) SWIG_fail;
 164 }
 165 %typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) wxRect& {
 166     $1 = wxPySimple_typecheck($input, wxT("wxRect"), 4);
 167 }
 168
 169
 170 %typemap(in) wxPoint2D& (wxPoint2D temp) {
 171     $1 = &temp;
 172     if ( ! wxPoint2D_helper($input, &$1)) SWIG_fail;
 173 }
 174 %typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) wxPoint2D& {
 175     $1 = wxPySimple_typecheck($input, wxT("wxPoint2D"), 2);
 176 }
 177
 178
 179 //---------------------------------------------------------------------------
 180 // Typemap to convert strings to wxColour.  Two string formats are accepted,
 181 // either a colour name, or a hex colour spec like "#RRGGBB"
 182
 183 %typemap(in) wxColour& (wxColour temp) {
 184     $1 = &temp;
 185     if ( ! wxColour_helper($input, &$1)) SWIG_fail;
 186 }
 187 %typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) wxColour& {
 188     $1 = wxColour_typecheck($input);
 189 }
 190
 191
 192
 193 //---------------------------------------------------------------------------
 194 // Typemap for wxArrayString from Python sequence objects
 195
 196 %typemap(in) wxArrayString& {
 197     if (! PySequence_Check($input)) {
 198         PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
 199         SWIG_fail;
 200     }
 201     $1 = new wxArrayString;
 202     int i, len=PySequence_Length($input);
 203     for (i=0; i<len; i++) {
 204         PyObject* item = PySequence_GetItem($input, i);
 205 %#if wxUSE_UNICODE
 206         PyObject* str  = PyObject_Unicode(item);
 207 %#else
 208         PyObject* str  = PyObject_Str(item);
 209 %#endif
 210         $1->Add(Py2wxString(str));
 211         Py_DECREF(item);
 212         Py_DECREF(str);
 213     }
 214 }
 215
 216 %typemap(freearg) wxArrayString& {
 217     if ($1) delete $1;
 218 }
 219
 220 //---------------------------------------------------------------------------
 221 // Typemap for wxArrayInt from Python sequence objects
 222
 223 %typemap(in) wxArrayInt& {
 224     if (! PySequence_Check($input)) {
 225         PyErr_SetString(PyExc_TypeError, "Sequence of integers expected.");
 226         SWIG_fail;
 227     }
 228     $1 = new wxArrayInt;
 229     int i, len=PySequence_Length($input);
 230     for (i=0; i<len; i++) {
 231         PyObject* item = PySequence_GetItem($input, i);
 232         PyObject* number  = PyNumber_Int(item);
 233         $1->Add(PyInt_AS_LONG(number));
 234         Py_DECREF(item);
 235         Py_DECREF(number);
 236     }
 237 }
 238
 239 %typemap(freearg) wxArrayInt& {
 240     if ($1) delete $1;
 241 }
 242
 243
 244 //---------------------------------------------------------------------------
 245 // Typemaps to convert an array of ints to a list for return values
 246 %typemap(out) wxArrayInt& {
 247     $result = PyList_New(0);
 248     size_t idx;
 249     for (idx = 0; idx < $1->GetCount(); idx += 1) {
 250         PyObject* val = PyInt_FromLong( $1->Item(idx) );
 251         PyList_Append($result, val);
 252         Py_DECREF(val);
 253     }
 254 }
 255
 256 %typemap(out) wxArrayInt {
 257     $result = PyList_New(0);
 258     size_t idx;
 259     for (idx = 0; idx < $1.GetCount(); idx += 1) {
 260         PyObject* val = PyInt_FromLong( $1.Item(idx) );
 261         PyList_Append($result, val);
 262         Py_DECREF(val);
 263     }
 264 }
 265
 266
 267
 268 // Typemaps to convert an array of ints to a list for return values
 269 %typemap(out) wxArrayString& {
 270     $result = wxArrayString2PyList_helper(*$1);
 271 }
 272
 273 %typemap(out) wxArrayString {
 274     $result = wxArrayString2PyList_helper($1);
 275 }
 276
 277
 278 // //---------------------------------------------------------------------------
 279 // // Map T_OUTPUTs for floats to return ints.
 280
 281
 282 // %typemap(python,ignore) float          *T_OUTPUT_TOINT(float temp),
 283 //                         double         *T_OUTPUT_TOINT(double temp)
 284 // {
 285 //   $target = &temp;
 286 // }
 287
 288
 289 // %typemap(python,argout) float          *T_OUTPUT_TOINT,
 290 //                         double         *T_OUTPUT_TOINT
 291 // {
 292 //     PyObject *o;
 293 //     o = PyInt_FromLong((long) (*$source));
 294 //     $target = t_output_helper($target, o);
 295 // }
 296
 297
 298 // %typemap(python,ignore) bool *T_OUTPUT(int temp)
 299 // {
 300 //   $target = (bool*)&temp;
 301 // }
 302
 303 // %typemap(python,argout) bool *T_OUTPUT
 304 // {
 305 //     PyObject *o;
 306 //     o = PyInt_FromLong((long) (*$source));
 307 //     $target = t_output_helper($target, o);
 308 // }
 309
 310 // %typemap(python,ignore) bool  *OUTPUT = bool *T_OUTPUT;
 311 // %typemap(python,argout) bool  *OUTPUT = bool *T_OUTPUT;
 312
 313
 314
 315 // %typemap(python,ignore) byte *T_OUTPUT(int temp)
 316 // {
 317 //   $target = (byte*)&temp;
 318 // }
 319
 320 // %typemap(python,argout) byte *T_OUTPUT
 321 // {
 322 //     PyObject *o;
 323 //     o = PyInt_FromLong((long) (*$source));
 324 //     $target = t_output_helper($target, o);
 325 // }
 326
 327 // %typemap(python,ignore) byte  *OUTPUT = byte *T_OUTPUT;
 328 // %typemap(python,argout) byte  *OUTPUT = byte *T_OUTPUT;
 329
 330
 331 // %typemap(python,ignore) wxCoord *OUTPUT = int *OUTPUT;
 332 // %typemap(python,argout) wxCoord *OUTPUT = int *OUTPUT;
 333
 334
 335 //---------------------------------------------------------------------------
 336 // Typemaps to convert return values that are base class pointers
 337 // to the real derived type, if possible.  See wxPyMake_wxObject in
 338 // helpers.cpp
 339
 340 %typemap(out) wxEvtHandler*             { $result = wxPyMake_wxObject($1); }
 341 %typemap(out) wxMenu*                   { $result = wxPyMake_wxObject($1); }
 342 %typemap(out) wxValidator*              { $result = wxPyMake_wxObject($1); }
 343
 344 %typemap(out) wxApp*                    { $result = wxPyMake_wxObject($1); }
 345 %typemap(out) wxPyApp*                  { $result = wxPyMake_wxObject($1); }
 346 %typemap(out) wxDC*                     { $result = wxPyMake_wxObject($1); }
 347 %typemap(out) wxFSFile*                 { $result = wxPyMake_wxObject($1); }
 348 %typemap(out) wxFileSystem*             { $result = wxPyMake_wxObject($1); }
 349 %typemap(out) wxGridTableBase*          { $result = wxPyMake_wxObject($1); }
 350 %typemap(out) wxImageList*              { $result = wxPyMake_wxObject($1); }
 351 %typemap(out) wxListItem*               { $result = wxPyMake_wxObject($1); }
 352 %typemap(out) wxMenuItem*               { $result = wxPyMake_wxObject($1); }
 353 %typemap(out) wxMouseEvent*             { $result = wxPyMake_wxObject($1); }
 354 %typemap(out) wxObject*                 { $result = wxPyMake_wxObject($1); }
 355 %typemap(out) wxPyPrintout*             { $result = wxPyMake_wxObject($1); }
 356 %typemap(out) wxToolBarToolBase*        { $result = wxPyMake_wxObject($1); }
 357 %typemap(out) wxToolTip*                { $result = wxPyMake_wxObject($1); }
 358
 359
 360 %typemap(out) wxBitmapButton*           { $result = wxPyMake_wxObject($1); }
 361 %typemap(out) wxButton*                 { $result = wxPyMake_wxObject($1); }
 362 %typemap(out) wxControl*                { $result = wxPyMake_wxObject($1); }
 363 %typemap(out) wxFrame*                  { $result = wxPyMake_wxObject($1); }
 364 %typemap(out) wxGrid*                   { $result = wxPyMake_wxObject($1); }
 365 %typemap(out) wxListCtrl*               { $result = wxPyMake_wxObject($1); }
 366 %typemap(out) wxMDIChildFrame*          { $result = wxPyMake_wxObject($1); }
 367 %typemap(out) wxMDIClientWindow*        { $result = wxPyMake_wxObject($1); }
 368 %typemap(out) wxMenuBar*                { $result = wxPyMake_wxObject($1); }
 369 %typemap(out) wxNotebook*               { $result = wxPyMake_wxObject($1); }
 370 %typemap(out) wxStaticBox*              { $result = wxPyMake_wxObject($1); }
 371 %typemap(out) wxStatusBar*              { $result = wxPyMake_wxObject($1); }
 372 %typemap(out) wxTextCtrl*               { $result = wxPyMake_wxObject($1); }
 373 %typemap(out) wxToolBar*                { $result = wxPyMake_wxObject($1); }
 374 %typemap(out) wxToolBarBase*            { $result = wxPyMake_wxObject($1); }
 375 %typemap(out) wxTreeCtrl*               { $result = wxPyMake_wxObject($1); }
 376 %typemap(out) wxPyTreeCtrl*             { $result = wxPyMake_wxObject($1); }
 377 %typemap(out) wxWindow*                 { $result = wxPyMake_wxObject($1); }
 378 %typemap(out) wxHtmlWindow*             { $result = wxPyMake_wxObject($1); }
 379 %typemap(out) wxPyHtmlWindow*           { $result = wxPyMake_wxObject($1); }
 380 %typemap(out) wxWizardPage*             { $result = wxPyMake_wxObject($1); }
 381
 382 %typemap(out) wxSizer*                  { $result = wxPyMake_wxSizer($1); }
 383
 384
 385 //%typemap(python, out) wxHtmlCell*               { $target = wxPyMake_wxObject($source); }
 386 //%typemap(python, out) wxHtmlContainerCell*      { $target = wxPyMake_wxObject($source); }
 387 //%typemap(python, out) wxHtmlParser*             { $target = wxPyMake_wxObject($source); }
 388 //%typemap(python, out) wxHtmlWinParser*          { $target = wxPyMake_wxObject($source); }
 389
 390 //---------------------------------------------------------------------------
 391 //---------------------------------------------------------------------------
 392
 393
 394
 395
 396
 397