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 %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
 354 %typemap(python,ignore) bool  *OUTPUT = bool *T_OUTPUT;
 355 %typemap(python,argout) bool  *OUTPUT = bool *T_OUTPUT;
 356
 357 //---------------------------------------------------------------------------
 358 // Typemaps to convert return values that are base class pointers
 359 // to the real derived type, if possible.  See wxPyMake_wxObject in
 360 // helpers.cpp
 361
 362 %typemap(python, out) wxEvtHandler*             { $target = wxPyMake_wxObject($source); }
 363 %typemap(python, out) wxMenu*                   { $target = wxPyMake_wxObject($source); }
 364 %typemap(python, out) wxValidator*              { $target = wxPyMake_wxObject($source); }
 365
 366 %typemap(python, out) wxDC*                     { $target = wxPyMake_wxObject($source); }
 367 %typemap(python, out) wxFSFile*                 { $target = wxPyMake_wxObject($source); }
 368 %typemap(python, out) wxFileSystem*             { $target = wxPyMake_wxObject($source); }
 369 %typemap(python, out) wxGridTableBase*          { $target = wxPyMake_wxObject($source); }
 370 %typemap(python, out) wxImageList*              { $target = wxPyMake_wxObject($source); }
 371 %typemap(python, out) wxListItem*               { $target = wxPyMake_wxObject($source); }
 372 %typemap(python, out) wxMenuItem*               { $target = wxPyMake_wxObject($source); }
 373 %typemap(python, out) wxMouseEvent*             { $target = wxPyMake_wxObject($source); }
 374 %typemap(python, out) wxObject*                 { $target = wxPyMake_wxObject($source); }
 375 %typemap(python, out) wxPyPrintout*             { $target = wxPyMake_wxObject($source); }
 376 %typemap(python, out) wxToolBarToolBase*        { $target = wxPyMake_wxObject($source); }
 377 %typemap(python, out) wxToolTip*                { $target = wxPyMake_wxObject($source); }
 378
 379
 380 %typemap(python, out) wxButton*                 { $target = wxPyMake_wxObject($source); }
 381 %typemap(python, out) wxControl*                { $target = wxPyMake_wxObject($source); }
 382 %typemap(python, out) wxFrame*                  { $target = wxPyMake_wxObject($source); }
 383 %typemap(python, out) wxGrid*                   { $target = wxPyMake_wxObject($source); }
 384 %typemap(python, out) wxMDIChildFrame*          { $target = wxPyMake_wxObject($source); }
 385 %typemap(python, out) wxMDIClientWindow*        { $target = wxPyMake_wxObject($source); }
 386 %typemap(python, out) wxMenuBar*                { $target = wxPyMake_wxObject($source); }
 387 %typemap(python, out) wxNotebook*               { $target = wxPyMake_wxObject($source); }
 388 %typemap(python, out) wxStaticBox*              { $target = wxPyMake_wxObject($source); }
 389 %typemap(python, out) wxStatusBar*              { $target = wxPyMake_wxObject($source); }
 390 %typemap(python, out) wxTextCtrl*               { $target = wxPyMake_wxObject($source); }
 391 %typemap(python, out) wxToolBar*                { $target = wxPyMake_wxObject($source); }
 392 %typemap(python, out) wxToolBarBase*            { $target = wxPyMake_wxObject($source); }
 393 %typemap(python, out) wxWindow*                 { $target = wxPyMake_wxObject($source); }
 394
 395 %typemap(python, out) wxSizer*                  { $target = wxPyMake_wxSizer($source); }
 396
 397
 398 //%typemap(python, out) wxHtmlCell*               { $target = wxPyMake_wxObject($source); }
 399 //%typemap(python, out) wxHtmlContainerCell*      { $target = wxPyMake_wxObject($source); }
 400 //%typemap(python, out) wxHtmlParser*             { $target = wxPyMake_wxObject($source); }
 401 //%typemap(python, out) wxHtmlWinParser*          { $target = wxPyMake_wxObject($source); }
 402
 403 //---------------------------------------------------------------------------
 404 //---------------------------------------------------------------------------
 405
 406
 407
 408
 409
 410