]>
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 | ||
d14a1e28 RD |
14 | //---------------------------------------------------------------------- |
15 | // Typemaps to convert a list of items to an int (size) and an array | |
16 | ||
9f8a9f54 RD |
17 | %define MAKE_INT_ARRAY_TYPEMAPS(NAME, ARR_NAME) |
18 | %typemap(in) (int NAME, int* ARR_NAME) { | |
19 | $1 = PyList_Size($input); | |
20 | $2 = int_LIST_helper($input); | |
21 | if ($2 == NULL) SWIG_fail; | |
22 | } | |
23 | ||
24 | %typemap(freearg) (int NAME, int* ARR_NAME) { | |
25 | if ($2) delete [] $2; | |
26 | } | |
27 | %enddef | |
28 | ||
29 | MAKE_INT_ARRAY_TYPEMAPS(widths, widths_field) | |
30 | MAKE_INT_ARRAY_TYPEMAPS(styles, styles_field) | |
31 | ||
32 | ||
33 | ||
34 | // Same things for a wxString | |
d14a1e28 RD |
35 | %typemap(in) (int choices, wxString* choices_array ) { |
36 | $1 = PyList_Size($input); | |
37 | $2 = wxString_LIST_helper($input); | |
38 | if ($2 == NULL) SWIG_fail; | |
39 | } | |
40 | %typemap(freearg) (int choices, wxString* choices_array ) { | |
41 | if ($2) delete [] $2; | |
42 | } | |
43 | ||
44 | ||
9f8a9f54 | 45 | |
d14a1e28 | 46 | //--------------------------------------------------------------------------- |
dd9f7fea | 47 | // wxString typemaps |
7bf85405 RD |
48 | |
49 | ||
a72f4631 | 50 | %typemap(in) wxString& (bool temp=false) { |
d14a1e28 RD |
51 | $1 = wxString_in_helper($input); |
52 | if ($1 == NULL) SWIG_fail; | |
a72f4631 | 53 | temp = true; |
7bf85405 | 54 | } |
d14a1e28 RD |
55 | %typemap(freearg) wxString& { |
56 | if (temp$argnum) | |
57 | delete $1; | |
7bf85405 RD |
58 | } |
59 | ||
54b29c1f | 60 | %typemap(out) wxString& { |
d14a1e28 RD |
61 | %#if wxUSE_UNICODE |
62 | $result = PyUnicode_FromWideChar($1->c_str(), $1->Len()); | |
63 | %#else | |
64 | $result = PyString_FromStringAndSize($1->c_str(), $1->Len()); | |
65 | %#endif | |
7bf85405 RD |
66 | } |
67 | ||
87c2245b | 68 | |
54b29c1f RD |
69 | %apply wxString& { wxString* } |
70 | ||
71 | ||
72 | ||
73 | %typemap(out) wxString { | |
87c2245b | 74 | %#if wxUSE_UNICODE |
54b29c1f | 75 | $result = PyUnicode_FromWideChar($1.c_str(), $1.Len()); |
87c2245b | 76 | %#else |
54b29c1f | 77 | $result = PyString_FromStringAndSize($1.c_str(), $1.Len()); |
87c2245b RD |
78 | %#endif |
79 | } | |
80 | ||
dd9f7fea | 81 | %typemap(varout) wxString { |
d14a1e28 RD |
82 | %#if wxUSE_UNICODE |
83 | $result = PyUnicode_FromWideChar($1.c_str(), $1.Len()); | |
84 | %#else | |
85 | $result = PyString_FromStringAndSize($1.c_str(), $1.Len()); | |
86 | %#endif | |
7bf85405 RD |
87 | } |
88 | ||
eec92d76 | 89 | |
dd9f7fea RD |
90 | %typemap(in) wxString { |
91 | wxString* sptr = wxString_in_helper($input); | |
92 | if (sptr == NULL) SWIG_fail; | |
93 | $1 = *sptr; | |
94 | delete sptr; | |
95 | } | |
ba933fa5 RD |
96 | |
97 | %typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) wxString& { | |
98 | $1 = PyString_Check($input) || PyUnicode_Check($input); | |
99 | } | |
100 | ||
6fa9e461 RD |
101 | //--------------------------------------------------------------------------- |
102 | // wxMemoryBuffer (needed for wxSTC) | |
103 | ||
a72f4631 | 104 | %typemap(in) wxMemoryBuffer& (bool temp=false) { |
6fa9e461 RD |
105 | if (!PyString_Check($input)) { |
106 | PyErr_SetString(PyExc_TypeError, "String buffer expected"); | |
107 | SWIG_fail; | |
108 | } | |
109 | char* str = PyString_AS_STRING($input); | |
110 | int len = PyString_GET_SIZE($input); | |
111 | $1 = new wxMemoryBuffer(len); | |
a72f4631 | 112 | temp = true; |
6fa9e461 | 113 | memcpy($1->GetData(), str, len); |
97d6a30b | 114 | $1->SetDataLen(len); |
6fa9e461 RD |
115 | } |
116 | ||
117 | %typemap(freearg) wxMemoryBuffer& { | |
118 | if (temp$argnum) delete $1; | |
119 | } | |
120 | ||
121 | %typemap(out) wxMemoryBuffer { | |
122 | $result = PyString_FromStringAndSize((char*)$1.GetData(), $1.GetDataLen()); | |
123 | } | |
124 | ||
125 | ||
7bf85405 | 126 | |
1110f5ce RD |
127 | %typemap(out) wxCharBuffer { |
128 | $result = PyString_FromString((char*)$1.data()); | |
129 | } | |
130 | ||
131 | ||
d14a1e28 RD |
132 | //--------------------------------------------------------------------------- |
133 | // Typemaps to convert Python sequence objects (tuples, etc.) to | |
134 | // wxSize, wxPoint, wxRealPoint, and wxRect. | |
7bf85405 RD |
135 | |
136 | ||
d14a1e28 RD |
137 | %typemap(in) wxSize& (wxSize temp) { |
138 | $1 = &temp; | |
139 | if ( ! wxSize_helper($input, &$1)) SWIG_fail; | |
7bf85405 | 140 | } |
d14a1e28 RD |
141 | %typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) wxSize& { |
142 | $1 = wxPySimple_typecheck($input, wxT("wxSize"), 2); | |
7bf85405 RD |
143 | } |
144 | ||
145 | ||
d14a1e28 RD |
146 | %typemap(in) wxPoint& (wxPoint temp) { |
147 | $1 = &temp; | |
148 | if ( ! wxPoint_helper($input, &$1)) SWIG_fail; | |
7bf85405 | 149 | } |
d14a1e28 RD |
150 | %typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) wxPoint& { |
151 | $1 = wxPySimple_typecheck($input, wxT("wxPoint"), 2); | |
10ef30eb RD |
152 | } |
153 | ||
10ef30eb | 154 | |
d14a1e28 RD |
155 | %typemap(in) wxRealPoint& (wxRealPoint temp) { |
156 | $1 = &temp; | |
157 | if ( ! wxRealPoint_helper($input, &$1)) SWIG_fail; | |
10ef30eb | 158 | } |
d14a1e28 RD |
159 | %typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) wxRealPoint& { |
160 | $1 = wxPySimple_typecheck($input, wxT("wxRealPoint"), 2); | |
10ef30eb | 161 | } |
2f90df85 RD |
162 | |
163 | ||
d14a1e28 RD |
164 | %typemap(in) wxRect& (wxRect temp) { |
165 | $1 = &temp; | |
166 | if ( ! wxRect_helper($input, &$1)) SWIG_fail; | |
2f90df85 | 167 | } |
d14a1e28 RD |
168 | %typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) wxRect& { |
169 | $1 = wxPySimple_typecheck($input, wxT("wxRect"), 4); | |
2f90df85 RD |
170 | } |
171 | ||
7bf85405 | 172 | |
d14a1e28 RD |
173 | %typemap(in) wxPoint2D& (wxPoint2D temp) { |
174 | $1 = &temp; | |
175 | if ( ! wxPoint2D_helper($input, &$1)) SWIG_fail; | |
2f90df85 | 176 | } |
d14a1e28 RD |
177 | %typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) wxPoint2D& { |
178 | $1 = wxPySimple_typecheck($input, wxT("wxPoint2D"), 2); | |
1e4a197e RD |
179 | } |
180 | ||
d14a1e28 | 181 | |
f6bcfd97 BP |
182 | //--------------------------------------------------------------------------- |
183 | // Typemap to convert strings to wxColour. Two string formats are accepted, | |
de20db99 | 184 | // either a colour name, or a hex colour spec like "#RRGGBB" |
f6bcfd97 | 185 | |
d14a1e28 RD |
186 | %typemap(in) wxColour& (wxColour temp) { |
187 | $1 = &temp; | |
188 | if ( ! wxColour_helper($input, &$1)) SWIG_fail; | |
f6bcfd97 | 189 | } |
d14a1e28 RD |
190 | %typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) wxColour& { |
191 | $1 = wxColour_typecheck($input); | |
192 | } | |
193 | ||
b37c7e1d RD |
194 | //--------------------------------------------------------------------------- |
195 | // Typemap for wxArrayString from Python sequence objects | |
196 | ||
a72f4631 | 197 | %typemap(in) wxArrayString& (bool temp=false) { |
d14a1e28 | 198 | if (! PySequence_Check($input)) { |
b37c7e1d | 199 | PyErr_SetString(PyExc_TypeError, "Sequence of strings expected."); |
d14a1e28 | 200 | SWIG_fail; |
b37c7e1d | 201 | } |
d14a1e28 | 202 | $1 = new wxArrayString; |
a72f4631 | 203 | temp = true; |
d14a1e28 | 204 | int i, len=PySequence_Length($input); |
b37c7e1d | 205 | for (i=0; i<len; i++) { |
d14a1e28 | 206 | PyObject* item = PySequence_GetItem($input, i); |
9899bd5b | 207 | wxString* s = wxString_in_helper(item); |
3eb1aad7 | 208 | if (PyErr_Occurred()) SWIG_fail; |
9899bd5b RD |
209 | $1->Add(*s); |
210 | delete s; | |
b37c7e1d | 211 | Py_DECREF(item); |
b37c7e1d RD |
212 | } |
213 | } | |
214 | ||
d14a1e28 | 215 | %typemap(freearg) wxArrayString& { |
c2e6d970 | 216 | if (temp$argnum) delete $1; |
b37c7e1d | 217 | } |
7bf85405 | 218 | |
293a0a86 RD |
219 | //--------------------------------------------------------------------------- |
220 | // Typemap for wxArrayInt from Python sequence objects | |
221 | ||
a72f4631 | 222 | %typemap(in) wxArrayInt& (bool temp=false) { |
d14a1e28 | 223 | if (! PySequence_Check($input)) { |
293a0a86 | 224 | PyErr_SetString(PyExc_TypeError, "Sequence of integers expected."); |
d14a1e28 | 225 | SWIG_fail; |
293a0a86 | 226 | } |
d14a1e28 | 227 | $1 = new wxArrayInt; |
a72f4631 | 228 | temp = true; |
d14a1e28 | 229 | int i, len=PySequence_Length($input); |
293a0a86 | 230 | for (i=0; i<len; i++) { |
d14a1e28 | 231 | PyObject* item = PySequence_GetItem($input, i); |
293a0a86 | 232 | PyObject* number = PyNumber_Int(item); |
d14a1e28 | 233 | $1->Add(PyInt_AS_LONG(number)); |
293a0a86 RD |
234 | Py_DECREF(item); |
235 | Py_DECREF(number); | |
236 | } | |
237 | } | |
238 | ||
d14a1e28 | 239 | %typemap(freearg) wxArrayInt& { |
c2e6d970 | 240 | if (temp$argnum) delete $1; |
293a0a86 RD |
241 | } |
242 | ||
243 | ||
d14a1e28 RD |
244 | //--------------------------------------------------------------------------- |
245 | // Typemaps to convert an array of ints to a list for return values | |
281c54cc RD |
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 | ||
d14a1e28 | 266 | %typemap(out) wxArrayInt& { |
281c54cc | 267 | $result = wxArrayInt2PyList_helper(*$1); |
1e4a197e RD |
268 | } |
269 | ||
d14a1e28 | 270 | %typemap(out) wxArrayInt { |
281c54cc RD |
271 | $result = wxArrayInt2PyList_helper($1); |
272 | } | |
273 | ||
274 | ||
275 | // convert array of doubles to a Python list | |
276 | %typemap(out) wxArrayDouble& { | |
277 | $result = wxArrayDouble2PyList_helper(*$1); | |
278 | } | |
279 | ||
280 | %typemap(out) wxArrayDouble { | |
281 | $result = wxArrayDouble2PyList_helper($1); | |
1e4a197e RD |
282 | } |
283 | ||
284 | ||
7bf85405 | 285 | |
6d450e1a | 286 | // Typemaps to convert an array of strings to a list for return values |
d14a1e28 RD |
287 | %typemap(out) wxArrayString& { |
288 | $result = wxArrayString2PyList_helper(*$1); | |
289 | } | |
7bf85405 | 290 | |
d14a1e28 RD |
291 | %typemap(out) wxArrayString { |
292 | $result = wxArrayString2PyList_helper($1); | |
7bf85405 RD |
293 | } |
294 | ||
295 | ||
e07fb96d RD |
296 | //--------------------------------------------------------------------------- |
297 | ||
da32eb53 RD |
298 | %typemap(out) bool { |
299 | $result = $1 ? Py_True : Py_False; Py_INCREF($result); | |
300 | } | |
1e4a197e | 301 | |
d19a83a5 | 302 | |
56a52e90 RD |
303 | //--------------------------------------------------------------------------- |
304 | // wxFileOffset, can be a 32-bit or a 64-bit integer | |
305 | ||
306 | %typemap(in) wxFileOffset { | |
307 | if (sizeof(wxFileOffset) > sizeof(long)) | |
308 | $1 = PyLong_AsLongLong($input); | |
309 | else | |
310 | $1 = PyInt_AsLong($input); | |
311 | } | |
312 | ||
313 | %typemap(out) wxFileOffset { | |
314 | if (sizeof(wxFileOffset) > sizeof(long)) | |
315 | $result = PyLong_FromLongLong($1); | |
316 | else | |
317 | $result = PyInt_FromLong($1); | |
318 | } | |
319 | ||
320 | ||
d19a83a5 RD |
321 | //--------------------------------------------------------------------------- |
322 | // Typemap for when GDI objects are returned by reference. This will cause a | |
323 | // copy to be made instead of returning a reference to the same instance. The | |
324 | // GDI object's internal refcounting scheme will do a copy-on-write of the | |
325 | // internal data as needed. | |
326 | ||
327 | // These too? | |
328 | //, wxRegion&, wxPalette& | |
329 | ||
330 | %typemap(out) wxBrush&, wxPen&, wxFont&, wxBitmap&, wxIcon&, wxCursor& { | |
331 | $*1_ltype* resultptr = new $*1_ltype(*$1); | |
332 | $result = SWIG_NewPointerObj((void*)(resultptr), $1_descriptor, 1); | |
333 | } | |
334 | ||
335 | ||
238ba802 RD |
336 | //--------------------------------------------------------------------------- |
337 | // Typemaps for loading a image or bitmap from an object that implements the | |
338 | // buffer interface | |
339 | ||
8c9c423b | 340 | %typemap(in) (buffer data, int DATASIZE) (Py_ssize_t temp) |
074d2e04 | 341 | { |
8c9c423b RD |
342 | if (PyObject_AsReadBuffer($input, (const void**)(&$1), &temp) == -1) SWIG_fail; |
343 | $2 = (int)temp; | |
074d2e04 | 344 | } |
238ba802 | 345 | |
8c9c423b | 346 | %typemap(in) (buffer alpha, int ALPHASIZE) (Py_ssize_t temp) |
074d2e04 RD |
347 | { |
348 | if ($input != Py_None) { | |
8c9c423b RD |
349 | if (PyObject_AsReadBuffer($input, (const void**)(&$1), &temp) == -1) SWIG_fail; |
350 | $2 = (int)temp; | |
074d2e04 RD |
351 | } |
352 | } | |
353 | ||
354 | ||
238ba802 | 355 | |
9416aa89 RD |
356 | //--------------------------------------------------------------------------- |
357 | // Typemaps to convert return values that are base class pointers | |
358 | // to the real derived type, if possible. See wxPyMake_wxObject in | |
359 | // helpers.cpp | |
360 | ||
b39c3fa0 RD |
361 | // NOTE: For those classes that also call _setOORInfo these typemaps should be |
362 | // disabled for the constructor. | |
363 | ||
214c4fbe RD |
364 | %typemap(out) wxEvtHandler* { $result = wxPyMake_wxObject($1, (bool)$owner); } |
365 | %typemap(out) wxMenu* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
366 | %typemap(out) wxValidator* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
367 | ||
368 | %typemap(out) wxApp* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
369 | %typemap(out) wxPyApp* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
370 | %typemap(out) wxDC* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
371 | %typemap(out) wxFSFile* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
372 | %typemap(out) wxFileSystem* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
bbc3761e | 373 | //%typemap(out) wxImageList* { $result = wxPyMake_wxObject($1, (bool)$owner); } |
214c4fbe RD |
374 | %typemap(out) wxImage* { $result = wxPyMake_wxObject($1, (bool)$owner); } |
375 | %typemap(out) wxListItem* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
376 | %typemap(out) wxMenuItem* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
377 | %typemap(out) wxMouseEvent* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
378 | %typemap(out) wxObject* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
379 | %typemap(out) wxPyPrintout* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
380 | %typemap(out) wxToolBarToolBase* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
381 | %typemap(out) wxToolTip* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
382 | ||
383 | ||
384 | %typemap(out) wxBitmapButton* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
385 | %typemap(out) wxButton* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
386 | %typemap(out) wxControl* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
387 | %typemap(out) wxFrame* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
388 | %typemap(out) wxGrid* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
389 | //%typemap(out) wxListCtrl* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
390 | %typemap(out) wxMDIChildFrame* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
391 | %typemap(out) wxMDIClientWindow* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
392 | %typemap(out) wxMenuBar* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
393 | %typemap(out) wxNotebook* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
394 | %typemap(out) wxStaticBox* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
395 | %typemap(out) wxStatusBar* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
396 | %typemap(out) wxTextCtrl* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
397 | %typemap(out) wxToolBar* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
398 | %typemap(out) wxToolBarBase* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
399 | //%typemap(out) wxTreeCtrl* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
400 | %typemap(out) wxPyTreeCtrl* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
401 | %typemap(out) wxWindow* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
402 | %typemap(out) wxPyHtmlWindow* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
403 | %typemap(out) wxWizardPage* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
404 | %typemap(out) wxPyWizardPage* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
405 | %typemap(out) wxPanel* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
406 | %typemap(out) wxDialog* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
407 | %typemap(out) wxScrolledWindow* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
408 | ||
409 | %typemap(out) wxSizer* { $result = wxPyMake_wxObject($1, (bool)$owner); } | |
6d450e1a | 410 | |
9416aa89 | 411 | |
7bf85405 | 412 | //--------------------------------------------------------------------------- |
2f90df85 | 413 | //--------------------------------------------------------------------------- |
7bf85405 | 414 | |
9416aa89 RD |
415 | |
416 | ||
417 | ||
418 | ||
419 |