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