]>
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 | %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 | // wxString typemaps | |
40 | ||
41 | ||
42 | %typemap(in) wxString& (bool temp=False) { | |
43 | $1 = wxString_in_helper($input); | |
44 | if ($1 == NULL) SWIG_fail; | |
45 | temp = True; | |
46 | } | |
47 | %typemap(freearg) wxString& { | |
48 | if (temp$argnum) | |
49 | delete $1; | |
50 | } | |
51 | ||
52 | %typemap(out) wxString& { | |
53 | %#if wxUSE_UNICODE | |
54 | $result = PyUnicode_FromWideChar($1->c_str(), $1->Len()); | |
55 | %#else | |
56 | $result = PyString_FromStringAndSize($1->c_str(), $1->Len()); | |
57 | %#endif | |
58 | } | |
59 | ||
60 | ||
61 | %apply wxString& { wxString* } | |
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 | %typemap(varout) wxString { | |
74 | %#if wxUSE_UNICODE | |
75 | $result = PyUnicode_FromWideChar($1.c_str(), $1.Len()); | |
76 | %#else | |
77 | $result = PyString_FromStringAndSize($1.c_str(), $1.Len()); | |
78 | %#endif | |
79 | } | |
80 | ||
81 | ||
82 | %typemap(in) wxString { | |
83 | wxString* sptr = wxString_in_helper($input); | |
84 | if (sptr == NULL) SWIG_fail; | |
85 | $1 = *sptr; | |
86 | delete sptr; | |
87 | } | |
88 | ||
89 | ||
90 | ||
91 | //--------------------------------------------------------------------------- | |
92 | // Typemaps to convert Python sequence objects (tuples, etc.) to | |
93 | // wxSize, wxPoint, wxRealPoint, and wxRect. | |
94 | ||
95 | ||
96 | %typemap(in) wxSize& (wxSize temp) { | |
97 | $1 = &temp; | |
98 | if ( ! wxSize_helper($input, &$1)) SWIG_fail; | |
99 | } | |
100 | %typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) wxSize& { | |
101 | $1 = wxPySimple_typecheck($input, wxT("wxSize"), 2); | |
102 | } | |
103 | ||
104 | ||
105 | %typemap(in) wxPoint& (wxPoint temp) { | |
106 | $1 = &temp; | |
107 | if ( ! wxPoint_helper($input, &$1)) SWIG_fail; | |
108 | } | |
109 | %typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) wxPoint& { | |
110 | $1 = wxPySimple_typecheck($input, wxT("wxPoint"), 2); | |
111 | } | |
112 | ||
113 | ||
114 | %typemap(in) wxRealPoint& (wxRealPoint temp) { | |
115 | $1 = &temp; | |
116 | if ( ! wxRealPoint_helper($input, &$1)) SWIG_fail; | |
117 | } | |
118 | %typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) wxRealPoint& { | |
119 | $1 = wxPySimple_typecheck($input, wxT("wxRealPoint"), 2); | |
120 | } | |
121 | ||
122 | ||
123 | %typemap(in) wxRect& (wxRect temp) { | |
124 | $1 = &temp; | |
125 | if ( ! wxRect_helper($input, &$1)) SWIG_fail; | |
126 | } | |
127 | %typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) wxRect& { | |
128 | $1 = wxPySimple_typecheck($input, wxT("wxRect"), 4); | |
129 | } | |
130 | ||
131 | ||
132 | %typemap(in) wxPoint2D& (wxPoint2D temp) { | |
133 | $1 = &temp; | |
134 | if ( ! wxPoint2D_helper($input, &$1)) SWIG_fail; | |
135 | } | |
136 | %typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) wxPoint2D& { | |
137 | $1 = wxPySimple_typecheck($input, wxT("wxPoint2D"), 2); | |
138 | } | |
139 | ||
140 | ||
141 | //--------------------------------------------------------------------------- | |
142 | // Typemap to convert strings to wxColour. Two string formats are accepted, | |
143 | // either a colour name, or a hex colour spec like "#RRGGBB" | |
144 | ||
145 | %typemap(in) wxColour& (wxColour temp) { | |
146 | $1 = &temp; | |
147 | if ( ! wxColour_helper($input, &$1)) SWIG_fail; | |
148 | } | |
149 | %typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) wxColour& { | |
150 | $1 = wxColour_typecheck($input); | |
151 | } | |
152 | ||
153 | ||
154 | ||
155 | //--------------------------------------------------------------------------- | |
156 | // Typemap for wxArrayString from Python sequence objects | |
157 | ||
158 | %typemap(in) wxArrayString& { | |
159 | if (! PySequence_Check($input)) { | |
160 | PyErr_SetString(PyExc_TypeError, "Sequence of strings expected."); | |
161 | SWIG_fail; | |
162 | } | |
163 | $1 = new wxArrayString; | |
164 | int i, len=PySequence_Length($input); | |
165 | for (i=0; i<len; i++) { | |
166 | PyObject* item = PySequence_GetItem($input, i); | |
167 | %#if wxUSE_UNICODE | |
168 | PyObject* str = PyObject_Unicode(item); | |
169 | %#else | |
170 | PyObject* str = PyObject_Str(item); | |
171 | %#endif | |
172 | $1->Add(Py2wxString(str)); | |
173 | Py_DECREF(item); | |
174 | Py_DECREF(str); | |
175 | } | |
176 | } | |
177 | ||
178 | %typemap(freearg) wxArrayString& { | |
179 | if ($1) delete $1; | |
180 | } | |
181 | ||
182 | //--------------------------------------------------------------------------- | |
183 | // Typemap for wxArrayInt from Python sequence objects | |
184 | ||
185 | %typemap(in) wxArrayInt& { | |
186 | if (! PySequence_Check($input)) { | |
187 | PyErr_SetString(PyExc_TypeError, "Sequence of integers expected."); | |
188 | SWIG_fail; | |
189 | } | |
190 | $1 = new wxArrayInt; | |
191 | int i, len=PySequence_Length($input); | |
192 | for (i=0; i<len; i++) { | |
193 | PyObject* item = PySequence_GetItem($input, i); | |
194 | PyObject* number = PyNumber_Int(item); | |
195 | $1->Add(PyInt_AS_LONG(number)); | |
196 | Py_DECREF(item); | |
197 | Py_DECREF(number); | |
198 | } | |
199 | } | |
200 | ||
201 | %typemap(freearg) wxArrayInt& { | |
202 | if ($1) delete $1; | |
203 | } | |
204 | ||
205 | ||
206 | //--------------------------------------------------------------------------- | |
207 | // Typemaps to convert an array of ints to a list for return values | |
208 | %typemap(out) wxArrayInt& { | |
209 | $result = PyList_New(0); | |
210 | size_t idx; | |
211 | for (idx = 0; idx < $1->GetCount(); idx += 1) { | |
212 | PyObject* val = PyInt_FromLong( $1->Item(idx) ); | |
213 | PyList_Append($result, val); | |
214 | Py_DECREF(val); | |
215 | } | |
216 | } | |
217 | ||
218 | %typemap(out) wxArrayInt { | |
219 | $result = PyList_New(0); | |
220 | size_t idx; | |
221 | for (idx = 0; idx < $1.GetCount(); idx += 1) { | |
222 | PyObject* val = PyInt_FromLong( $1.Item(idx) ); | |
223 | PyList_Append($result, val); | |
224 | Py_DECREF(val); | |
225 | } | |
226 | } | |
227 | ||
228 | ||
229 | ||
230 | // Typemaps to convert an array of ints to a list for return values | |
231 | %typemap(out) wxArrayString& { | |
232 | $result = wxArrayString2PyList_helper(*$1); | |
233 | } | |
234 | ||
235 | %typemap(out) wxArrayString { | |
236 | $result = wxArrayString2PyList_helper($1); | |
237 | } | |
238 | ||
239 | ||
240 | ||
241 | //--------------------------------------------------------------------------- | |
242 | // Typemaps to convert return values that are base class pointers | |
243 | // to the real derived type, if possible. See wxPyMake_wxObject in | |
244 | // helpers.cpp | |
245 | ||
246 | %typemap(out) wxEvtHandler* { $result = wxPyMake_wxObject($1); } | |
247 | %typemap(out) wxMenu* { $result = wxPyMake_wxObject($1); } | |
248 | %typemap(out) wxValidator* { $result = wxPyMake_wxObject($1); } | |
249 | ||
250 | %typemap(out) wxApp* { $result = wxPyMake_wxObject($1); } | |
251 | %typemap(out) wxPyApp* { $result = wxPyMake_wxObject($1); } | |
252 | %typemap(out) wxDC* { $result = wxPyMake_wxObject($1); } | |
253 | %typemap(out) wxFSFile* { $result = wxPyMake_wxObject($1); } | |
254 | %typemap(out) wxFileSystem* { $result = wxPyMake_wxObject($1); } | |
255 | %typemap(out) wxGridTableBase* { $result = wxPyMake_wxObject($1); } | |
256 | %typemap(out) wxImageList* { $result = wxPyMake_wxObject($1); } | |
257 | %typemap(out) wxListItem* { $result = wxPyMake_wxObject($1); } | |
258 | %typemap(out) wxMenuItem* { $result = wxPyMake_wxObject($1); } | |
259 | %typemap(out) wxMouseEvent* { $result = wxPyMake_wxObject($1); } | |
260 | %typemap(out) wxObject* { $result = wxPyMake_wxObject($1); } | |
261 | %typemap(out) wxPyPrintout* { $result = wxPyMake_wxObject($1); } | |
262 | %typemap(out) wxToolBarToolBase* { $result = wxPyMake_wxObject($1); } | |
263 | %typemap(out) wxToolTip* { $result = wxPyMake_wxObject($1); } | |
264 | ||
265 | ||
266 | %typemap(out) wxBitmapButton* { $result = wxPyMake_wxObject($1); } | |
267 | %typemap(out) wxButton* { $result = wxPyMake_wxObject($1); } | |
268 | %typemap(out) wxControl* { $result = wxPyMake_wxObject($1); } | |
269 | %typemap(out) wxFrame* { $result = wxPyMake_wxObject($1); } | |
270 | %typemap(out) wxGrid* { $result = wxPyMake_wxObject($1); } | |
271 | %typemap(out) wxListCtrl* { $result = wxPyMake_wxObject($1); } | |
272 | %typemap(out) wxMDIChildFrame* { $result = wxPyMake_wxObject($1); } | |
273 | %typemap(out) wxMDIClientWindow* { $result = wxPyMake_wxObject($1); } | |
274 | %typemap(out) wxMenuBar* { $result = wxPyMake_wxObject($1); } | |
275 | %typemap(out) wxNotebook* { $result = wxPyMake_wxObject($1); } | |
276 | %typemap(out) wxStaticBox* { $result = wxPyMake_wxObject($1); } | |
277 | %typemap(out) wxStatusBar* { $result = wxPyMake_wxObject($1); } | |
278 | %typemap(out) wxTextCtrl* { $result = wxPyMake_wxObject($1); } | |
279 | %typemap(out) wxToolBar* { $result = wxPyMake_wxObject($1); } | |
280 | %typemap(out) wxToolBarBase* { $result = wxPyMake_wxObject($1); } | |
281 | %typemap(out) wxTreeCtrl* { $result = wxPyMake_wxObject($1); } | |
282 | %typemap(out) wxPyTreeCtrl* { $result = wxPyMake_wxObject($1); } | |
283 | %typemap(out) wxWindow* { $result = wxPyMake_wxObject($1); } | |
284 | %typemap(out) wxHtmlWindow* { $result = wxPyMake_wxObject($1); } | |
285 | %typemap(out) wxPyHtmlWindow* { $result = wxPyMake_wxObject($1); } | |
286 | %typemap(out) wxWizardPage* { $result = wxPyMake_wxObject($1); } | |
287 | ||
288 | %typemap(out) wxSizer* { $result = wxPyMake_wxSizer($1); } | |
289 | ||
290 | ||
291 | //%typemap(python, out) wxHtmlCell* { $target = wxPyMake_wxObject($source); } | |
292 | //%typemap(python, out) wxHtmlContainerCell* { $target = wxPyMake_wxObject($source); } | |
293 | //%typemap(python, out) wxHtmlParser* { $target = wxPyMake_wxObject($source); } | |
294 | //%typemap(python, out) wxHtmlWinParser* { $target = wxPyMake_wxObject($source); } | |
295 | ||
296 | //--------------------------------------------------------------------------- | |
297 | //--------------------------------------------------------------------------- | |
298 | ||
299 | ||
300 | ||
301 | ||
302 | ||
303 |