]>
Commit | Line | Data |
---|---|---|
1 | /* | |
2 | * FILE : src/gtk/image.cpp | |
3 | * | |
4 | * This file was automatically generated by : | |
5 | * Simplified Wrapper and Interface Generator (SWIG) | |
6 | * Version 1.1 (Build 883) | |
7 | * | |
8 | * Portions Copyright (c) 1995-1998 | |
9 | * The University of Utah and The Regents of the University of California. | |
10 | * Permission is granted to distribute this file in any manner provided | |
11 | * this notice remains intact. | |
12 | * | |
13 | * Do not make changes to this file--changes will be lost! | |
14 | * | |
15 | */ | |
16 | ||
17 | ||
18 | #define SWIGCODE | |
19 | /* Implementation : PYTHON */ | |
20 | ||
21 | #define SWIGPYTHON | |
22 | #include <string.h> | |
23 | #include <stdlib.h> | |
24 | /* Definitions for Windows/Unix exporting */ | |
25 | #if defined(__WIN32__) | |
26 | # if defined(_MSC_VER) | |
27 | # define SWIGEXPORT(a) __declspec(dllexport) a | |
28 | # else | |
29 | # if defined(__BORLANDC__) | |
30 | # define SWIGEXPORT(a) a _export | |
31 | # else | |
32 | # define SWIGEXPORT(a) a | |
33 | # endif | |
34 | # endif | |
35 | #else | |
36 | # define SWIGEXPORT(a) a | |
37 | #endif | |
38 | ||
39 | #include "Python.h" | |
40 | ||
41 | #ifdef __cplusplus | |
42 | extern "C" { | |
43 | #endif | |
44 | ||
45 | extern void SWIG_MakePtr(char *, void *, char *); | |
46 | extern void SWIG_RegisterMapping(char *, char *, void *(*)(void *)); | |
47 | extern char *SWIG_GetPtr(char *, void **, char *); | |
48 | extern char *SWIG_GetPtrObj(PyObject *, void **, char *); | |
49 | extern void SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *)); | |
50 | extern PyObject *SWIG_newvarlink(void); | |
51 | #ifdef __cplusplus | |
52 | } | |
53 | #endif | |
54 | #define SWIG_init initimagec | |
55 | ||
56 | #define SWIG_name "imagec" | |
57 | ||
58 | #include "helpers.h" | |
59 | #include <wx/image.h> | |
60 | ||
61 | ||
62 | static PyObject* t_output_helper(PyObject* target, PyObject* o) { | |
63 | PyObject* o2; | |
64 | PyObject* o3; | |
65 | ||
66 | if (!target) { | |
67 | target = o; | |
68 | } else if (target == Py_None) { | |
69 | Py_DECREF(Py_None); | |
70 | target = o; | |
71 | } else { | |
72 | if (!PyTuple_Check(target)) { | |
73 | o2 = target; | |
74 | target = PyTuple_New(1); | |
75 | PyTuple_SetItem(target, 0, o2); | |
76 | } | |
77 | o3 = PyTuple_New(1); | |
78 | PyTuple_SetItem(o3, 0, o); | |
79 | ||
80 | o2 = target; | |
81 | target = PySequence_Concat(o2, o3); | |
82 | Py_DECREF(o2); | |
83 | Py_DECREF(o3); | |
84 | } | |
85 | return target; | |
86 | } | |
87 | ||
88 | #if PYTHON_API_VERSION >= 1009 | |
89 | static char* wxStringErrorMsg = "String or Unicode type required"; | |
90 | #else | |
91 | static char* wxStringErrorMsg = "String type required"; | |
92 | #endif | |
93 | ||
94 | wxImage* wxEmptyImage(int width=0, int height=0) { | |
95 | if (width == 0 && height == 0) | |
96 | return new wxImage; | |
97 | else | |
98 | return new wxImage(width, height); | |
99 | } | |
100 | ||
101 | ||
102 | wxImage* wxImageFromMime(const wxString& name, const wxString& mimetype, int index) { | |
103 | return new wxImage(name, mimetype, index); | |
104 | } | |
105 | ||
106 | ||
107 | wxImage* wxImageFromBitmap(const wxBitmap &bitmap) { | |
108 | return new wxImage(bitmap); | |
109 | } | |
110 | ||
111 | ||
112 | wxImage* wxImageFromData(int width, int height, unsigned char* data) { | |
113 | // Copy the source data so the wxImage can clean it up later | |
114 | unsigned char* copy = (unsigned char*)malloc(width*height*3); | |
115 | if (copy == NULL) { | |
116 | PyErr_NoMemory(); | |
117 | return NULL; | |
118 | } | |
119 | memcpy(copy, data, width*height*3); | |
120 | return new wxImage(width, height, copy, FALSE); | |
121 | } | |
122 | ||
123 | ||
124 | wxImage* wxImageFromStream(wxInputStream& stream, | |
125 | long type = wxBITMAP_TYPE_ANY, int index = -1) { | |
126 | return new wxImage(stream, type, index); | |
127 | } | |
128 | ||
129 | ||
130 | wxImage* wxImageFromStreamMime(wxInputStream& stream, | |
131 | const wxString& mimetype, int index = -1 ) { | |
132 | return new wxImage(stream, mimetype, index); | |
133 | } | |
134 | ||
135 | #if 0 | |
136 | extern wxImage wxNullImage; | |
137 | ||
138 | #endif | |
139 | ||
140 | wxBitmap* wxBitmapFromImage(const wxImage& img, int depth=-1) { | |
141 | return new wxBitmap(img, depth); | |
142 | } | |
143 | ||
144 | #ifdef __cplusplus | |
145 | extern "C" { | |
146 | #endif | |
147 | static PyObject *_wrap_wxEmptyImage(PyObject *self, PyObject *args, PyObject *kwargs) { | |
148 | PyObject * _resultobj; | |
149 | wxImage * _result; | |
150 | int _arg0 = (int ) 0; | |
151 | int _arg1 = (int ) 0; | |
152 | char *_kwnames[] = { "width","height", NULL }; | |
153 | char _ptemp[128]; | |
154 | ||
155 | self = self; | |
156 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|ii:wxEmptyImage",_kwnames,&_arg0,&_arg1)) | |
157 | return NULL; | |
158 | { | |
159 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
160 | _result = (wxImage *)wxEmptyImage(_arg0,_arg1); | |
161 | ||
162 | wxPyEndAllowThreads(__tstate); | |
163 | if (PyErr_Occurred()) return NULL; | |
164 | } if (_result) { | |
165 | SWIG_MakePtr(_ptemp, (char *) _result,"_wxImage_p"); | |
166 | _resultobj = Py_BuildValue("s",_ptemp); | |
167 | } else { | |
168 | Py_INCREF(Py_None); | |
169 | _resultobj = Py_None; | |
170 | } | |
171 | return _resultobj; | |
172 | } | |
173 | ||
174 | static PyObject *_wrap_wxImageFromMime(PyObject *self, PyObject *args, PyObject *kwargs) { | |
175 | PyObject * _resultobj; | |
176 | wxImage * _result; | |
177 | wxString * _arg0; | |
178 | wxString * _arg1; | |
179 | int _arg2 = (int ) -1; | |
180 | PyObject * _obj0 = 0; | |
181 | PyObject * _obj1 = 0; | |
182 | char *_kwnames[] = { "name","mimetype","index", NULL }; | |
183 | char _ptemp[128]; | |
184 | ||
185 | self = self; | |
186 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|i:wxImageFromMime",_kwnames,&_obj0,&_obj1,&_arg2)) | |
187 | return NULL; | |
188 | { | |
189 | #if PYTHON_API_VERSION >= 1009 | |
190 | char* tmpPtr; int tmpSize; | |
191 | if (!PyString_Check(_obj0) && !PyUnicode_Check(_obj0)) { | |
192 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
193 | return NULL; | |
194 | } | |
195 | if (PyString_AsStringAndSize(_obj0, &tmpPtr, &tmpSize) == -1) | |
196 | return NULL; | |
197 | _arg0 = new wxString(tmpPtr, tmpSize); | |
198 | #else | |
199 | if (!PyString_Check(_obj0)) { | |
200 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
201 | return NULL; | |
202 | } | |
203 | _arg0 = new wxString(PyString_AS_STRING(_obj0), PyString_GET_SIZE(_obj0)); | |
204 | #endif | |
205 | } | |
206 | { | |
207 | #if PYTHON_API_VERSION >= 1009 | |
208 | char* tmpPtr; int tmpSize; | |
209 | if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) { | |
210 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
211 | return NULL; | |
212 | } | |
213 | if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1) | |
214 | return NULL; | |
215 | _arg1 = new wxString(tmpPtr, tmpSize); | |
216 | #else | |
217 | if (!PyString_Check(_obj1)) { | |
218 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
219 | return NULL; | |
220 | } | |
221 | _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1)); | |
222 | #endif | |
223 | } | |
224 | { | |
225 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
226 | _result = (wxImage *)wxImageFromMime(*_arg0,*_arg1,_arg2); | |
227 | ||
228 | wxPyEndAllowThreads(__tstate); | |
229 | if (PyErr_Occurred()) return NULL; | |
230 | } if (_result) { | |
231 | SWIG_MakePtr(_ptemp, (char *) _result,"_wxImage_p"); | |
232 | _resultobj = Py_BuildValue("s",_ptemp); | |
233 | } else { | |
234 | Py_INCREF(Py_None); | |
235 | _resultobj = Py_None; | |
236 | } | |
237 | { | |
238 | if (_obj0) | |
239 | delete _arg0; | |
240 | } | |
241 | { | |
242 | if (_obj1) | |
243 | delete _arg1; | |
244 | } | |
245 | return _resultobj; | |
246 | } | |
247 | ||
248 | static PyObject *_wrap_wxImageFromBitmap(PyObject *self, PyObject *args, PyObject *kwargs) { | |
249 | PyObject * _resultobj; | |
250 | wxImage * _result; | |
251 | wxBitmap * _arg0; | |
252 | PyObject * _argo0 = 0; | |
253 | char *_kwnames[] = { "bitmap", NULL }; | |
254 | char _ptemp[128]; | |
255 | ||
256 | self = self; | |
257 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImageFromBitmap",_kwnames,&_argo0)) | |
258 | return NULL; | |
259 | if (_argo0) { | |
260 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
261 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxBitmap_p")) { | |
262 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImageFromBitmap. Expected _wxBitmap_p."); | |
263 | return NULL; | |
264 | } | |
265 | } | |
266 | { | |
267 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
268 | _result = (wxImage *)wxImageFromBitmap(*_arg0); | |
269 | ||
270 | wxPyEndAllowThreads(__tstate); | |
271 | if (PyErr_Occurred()) return NULL; | |
272 | } if (_result) { | |
273 | SWIG_MakePtr(_ptemp, (char *) _result,"_wxImage_p"); | |
274 | _resultobj = Py_BuildValue("s",_ptemp); | |
275 | } else { | |
276 | Py_INCREF(Py_None); | |
277 | _resultobj = Py_None; | |
278 | } | |
279 | return _resultobj; | |
280 | } | |
281 | ||
282 | static PyObject *_wrap_wxImageFromData(PyObject *self, PyObject *args, PyObject *kwargs) { | |
283 | PyObject * _resultobj; | |
284 | wxImage * _result; | |
285 | int _arg0; | |
286 | int _arg1; | |
287 | unsigned char * _arg2; | |
288 | PyObject * _argo2 = 0; | |
289 | char *_kwnames[] = { "width","height","data", NULL }; | |
290 | char _ptemp[128]; | |
291 | ||
292 | self = self; | |
293 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"iiO:wxImageFromData",_kwnames,&_arg0,&_arg1,&_argo2)) | |
294 | return NULL; | |
295 | if (_argo2) { | |
296 | if (_argo2 == Py_None) { _arg2 = NULL; } | |
297 | else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_unsigned_char_p")) { | |
298 | PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxImageFromData. Expected _unsigned_char_p."); | |
299 | return NULL; | |
300 | } | |
301 | } | |
302 | { | |
303 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
304 | _result = (wxImage *)wxImageFromData(_arg0,_arg1,_arg2); | |
305 | ||
306 | wxPyEndAllowThreads(__tstate); | |
307 | if (PyErr_Occurred()) return NULL; | |
308 | } if (_result) { | |
309 | SWIG_MakePtr(_ptemp, (char *) _result,"_wxImage_p"); | |
310 | _resultobj = Py_BuildValue("s",_ptemp); | |
311 | } else { | |
312 | Py_INCREF(Py_None); | |
313 | _resultobj = Py_None; | |
314 | } | |
315 | return _resultobj; | |
316 | } | |
317 | ||
318 | static PyObject *_wrap_wxImageFromStream(PyObject *self, PyObject *args, PyObject *kwargs) { | |
319 | PyObject * _resultobj; | |
320 | wxImage * _result; | |
321 | wxInputStream * _arg0; | |
322 | long _arg1 = (long ) wxBITMAP_TYPE_ANY; | |
323 | int _arg2 = (int ) -1; | |
324 | wxPyInputStream * temp; | |
325 | bool created; | |
326 | PyObject * _obj0 = 0; | |
327 | char *_kwnames[] = { "stream","type","index", NULL }; | |
328 | char _ptemp[128]; | |
329 | ||
330 | self = self; | |
331 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|li:wxImageFromStream",_kwnames,&_obj0,&_arg1,&_arg2)) | |
332 | return NULL; | |
333 | { | |
334 | if (SWIG_GetPtrObj(_obj0, (void **) &temp, "_wxPyInputStream_p") == 0) { | |
335 | _arg0 = temp->m_wxis; | |
336 | created = FALSE; | |
337 | } else { | |
338 | _arg0 = wxPyCBInputStream::create(_obj0, FALSE); | |
339 | if (_arg0 == NULL) { | |
340 | PyErr_SetString(PyExc_TypeError,"Expected _wxInputStream_p or Python file-like object."); | |
341 | return NULL; | |
342 | } | |
343 | created = TRUE; | |
344 | } | |
345 | } | |
346 | { | |
347 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
348 | _result = (wxImage *)wxImageFromStream(*_arg0,_arg1,_arg2); | |
349 | ||
350 | wxPyEndAllowThreads(__tstate); | |
351 | if (PyErr_Occurred()) return NULL; | |
352 | } if (_result) { | |
353 | SWIG_MakePtr(_ptemp, (char *) _result,"_wxImage_p"); | |
354 | _resultobj = Py_BuildValue("s",_ptemp); | |
355 | } else { | |
356 | Py_INCREF(Py_None); | |
357 | _resultobj = Py_None; | |
358 | } | |
359 | { | |
360 | if (created) | |
361 | delete _arg0; | |
362 | } | |
363 | return _resultobj; | |
364 | } | |
365 | ||
366 | static PyObject *_wrap_wxImageFromStreamMime(PyObject *self, PyObject *args, PyObject *kwargs) { | |
367 | PyObject * _resultobj; | |
368 | wxImage * _result; | |
369 | wxInputStream * _arg0; | |
370 | wxString * _arg1; | |
371 | int _arg2 = (int ) -1; | |
372 | wxPyInputStream * temp; | |
373 | bool created; | |
374 | PyObject * _obj0 = 0; | |
375 | PyObject * _obj1 = 0; | |
376 | char *_kwnames[] = { "stream","mimetype","index", NULL }; | |
377 | char _ptemp[128]; | |
378 | ||
379 | self = self; | |
380 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|i:wxImageFromStreamMime",_kwnames,&_obj0,&_obj1,&_arg2)) | |
381 | return NULL; | |
382 | { | |
383 | if (SWIG_GetPtrObj(_obj0, (void **) &temp, "_wxPyInputStream_p") == 0) { | |
384 | _arg0 = temp->m_wxis; | |
385 | created = FALSE; | |
386 | } else { | |
387 | _arg0 = wxPyCBInputStream::create(_obj0, FALSE); | |
388 | if (_arg0 == NULL) { | |
389 | PyErr_SetString(PyExc_TypeError,"Expected _wxInputStream_p or Python file-like object."); | |
390 | return NULL; | |
391 | } | |
392 | created = TRUE; | |
393 | } | |
394 | } | |
395 | { | |
396 | #if PYTHON_API_VERSION >= 1009 | |
397 | char* tmpPtr; int tmpSize; | |
398 | if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) { | |
399 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
400 | return NULL; | |
401 | } | |
402 | if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1) | |
403 | return NULL; | |
404 | _arg1 = new wxString(tmpPtr, tmpSize); | |
405 | #else | |
406 | if (!PyString_Check(_obj1)) { | |
407 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
408 | return NULL; | |
409 | } | |
410 | _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1)); | |
411 | #endif | |
412 | } | |
413 | { | |
414 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
415 | _result = (wxImage *)wxImageFromStreamMime(*_arg0,*_arg1,_arg2); | |
416 | ||
417 | wxPyEndAllowThreads(__tstate); | |
418 | if (PyErr_Occurred()) return NULL; | |
419 | } if (_result) { | |
420 | SWIG_MakePtr(_ptemp, (char *) _result,"_wxImage_p"); | |
421 | _resultobj = Py_BuildValue("s",_ptemp); | |
422 | } else { | |
423 | Py_INCREF(Py_None); | |
424 | _resultobj = Py_None; | |
425 | } | |
426 | { | |
427 | if (created) | |
428 | delete _arg0; | |
429 | } | |
430 | { | |
431 | if (_obj1) | |
432 | delete _arg1; | |
433 | } | |
434 | return _resultobj; | |
435 | } | |
436 | ||
437 | static PyObject *_wrap_wxInitAllImageHandlers(PyObject *self, PyObject *args, PyObject *kwargs) { | |
438 | PyObject * _resultobj; | |
439 | char *_kwnames[] = { NULL }; | |
440 | ||
441 | self = self; | |
442 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,":wxInitAllImageHandlers",_kwnames)) | |
443 | return NULL; | |
444 | { | |
445 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
446 | wxInitAllImageHandlers(); | |
447 | ||
448 | wxPyEndAllowThreads(__tstate); | |
449 | if (PyErr_Occurred()) return NULL; | |
450 | } Py_INCREF(Py_None); | |
451 | _resultobj = Py_None; | |
452 | return _resultobj; | |
453 | } | |
454 | ||
455 | static int _wrap_wxNullImage_set(PyObject *val) { | |
456 | ||
457 | PyErr_SetString(PyExc_TypeError,"Variable wxNullImage is read-only."); | |
458 | return 1; | |
459 | } | |
460 | ||
461 | static PyObject *_wrap_wxNullImage_get() { | |
462 | PyObject * pyobj; | |
463 | char ptemp[128]; | |
464 | ||
465 | SWIG_MakePtr(ptemp,(char *) &wxNullImage,"_wxImage_p"); | |
466 | pyobj = PyString_FromString(ptemp); | |
467 | return pyobj; | |
468 | } | |
469 | ||
470 | static PyObject *_wrap_wxBitmapFromImage(PyObject *self, PyObject *args, PyObject *kwargs) { | |
471 | PyObject * _resultobj; | |
472 | wxBitmap * _result; | |
473 | wxImage * _arg0; | |
474 | int _arg1 = (int ) -1; | |
475 | PyObject * _argo0 = 0; | |
476 | char *_kwnames[] = { "img","depth", NULL }; | |
477 | char _ptemp[128]; | |
478 | ||
479 | self = self; | |
480 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxBitmapFromImage",_kwnames,&_argo0,&_arg1)) | |
481 | return NULL; | |
482 | if (_argo0) { | |
483 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
484 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
485 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxBitmapFromImage. Expected _wxImage_p."); | |
486 | return NULL; | |
487 | } | |
488 | } | |
489 | { | |
490 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
491 | _result = (wxBitmap *)wxBitmapFromImage(*_arg0,_arg1); | |
492 | ||
493 | wxPyEndAllowThreads(__tstate); | |
494 | if (PyErr_Occurred()) return NULL; | |
495 | } if (_result) { | |
496 | SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); | |
497 | _resultobj = Py_BuildValue("s",_ptemp); | |
498 | } else { | |
499 | Py_INCREF(Py_None); | |
500 | _resultobj = Py_None; | |
501 | } | |
502 | return _resultobj; | |
503 | } | |
504 | ||
505 | static void *SwigwxImageHandlerTowxObject(void *ptr) { | |
506 | wxImageHandler *src; | |
507 | wxObject *dest; | |
508 | src = (wxImageHandler *) ptr; | |
509 | dest = (wxObject *) src; | |
510 | return (void *) dest; | |
511 | } | |
512 | ||
513 | #define wxImageHandler_GetName(_swigobj) (_swigobj->GetName()) | |
514 | static PyObject *_wrap_wxImageHandler_GetName(PyObject *self, PyObject *args, PyObject *kwargs) { | |
515 | PyObject * _resultobj; | |
516 | wxString * _result; | |
517 | wxImageHandler * _arg0; | |
518 | PyObject * _argo0 = 0; | |
519 | char *_kwnames[] = { "self", NULL }; | |
520 | ||
521 | self = self; | |
522 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImageHandler_GetName",_kwnames,&_argo0)) | |
523 | return NULL; | |
524 | if (_argo0) { | |
525 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
526 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImageHandler_p")) { | |
527 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImageHandler_GetName. Expected _wxImageHandler_p."); | |
528 | return NULL; | |
529 | } | |
530 | } | |
531 | { | |
532 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
533 | _result = new wxString (wxImageHandler_GetName(_arg0)); | |
534 | ||
535 | wxPyEndAllowThreads(__tstate); | |
536 | if (PyErr_Occurred()) return NULL; | |
537 | }{ | |
538 | _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len()); | |
539 | } | |
540 | { | |
541 | delete _result; | |
542 | } | |
543 | return _resultobj; | |
544 | } | |
545 | ||
546 | #define wxImageHandler_GetExtension(_swigobj) (_swigobj->GetExtension()) | |
547 | static PyObject *_wrap_wxImageHandler_GetExtension(PyObject *self, PyObject *args, PyObject *kwargs) { | |
548 | PyObject * _resultobj; | |
549 | wxString * _result; | |
550 | wxImageHandler * _arg0; | |
551 | PyObject * _argo0 = 0; | |
552 | char *_kwnames[] = { "self", NULL }; | |
553 | ||
554 | self = self; | |
555 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImageHandler_GetExtension",_kwnames,&_argo0)) | |
556 | return NULL; | |
557 | if (_argo0) { | |
558 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
559 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImageHandler_p")) { | |
560 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImageHandler_GetExtension. Expected _wxImageHandler_p."); | |
561 | return NULL; | |
562 | } | |
563 | } | |
564 | { | |
565 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
566 | _result = new wxString (wxImageHandler_GetExtension(_arg0)); | |
567 | ||
568 | wxPyEndAllowThreads(__tstate); | |
569 | if (PyErr_Occurred()) return NULL; | |
570 | }{ | |
571 | _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len()); | |
572 | } | |
573 | { | |
574 | delete _result; | |
575 | } | |
576 | return _resultobj; | |
577 | } | |
578 | ||
579 | #define wxImageHandler_GetType(_swigobj) (_swigobj->GetType()) | |
580 | static PyObject *_wrap_wxImageHandler_GetType(PyObject *self, PyObject *args, PyObject *kwargs) { | |
581 | PyObject * _resultobj; | |
582 | long _result; | |
583 | wxImageHandler * _arg0; | |
584 | PyObject * _argo0 = 0; | |
585 | char *_kwnames[] = { "self", NULL }; | |
586 | ||
587 | self = self; | |
588 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImageHandler_GetType",_kwnames,&_argo0)) | |
589 | return NULL; | |
590 | if (_argo0) { | |
591 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
592 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImageHandler_p")) { | |
593 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImageHandler_GetType. Expected _wxImageHandler_p."); | |
594 | return NULL; | |
595 | } | |
596 | } | |
597 | { | |
598 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
599 | _result = (long )wxImageHandler_GetType(_arg0); | |
600 | ||
601 | wxPyEndAllowThreads(__tstate); | |
602 | if (PyErr_Occurred()) return NULL; | |
603 | } _resultobj = Py_BuildValue("l",_result); | |
604 | return _resultobj; | |
605 | } | |
606 | ||
607 | #define wxImageHandler_GetMimeType(_swigobj) (_swigobj->GetMimeType()) | |
608 | static PyObject *_wrap_wxImageHandler_GetMimeType(PyObject *self, PyObject *args, PyObject *kwargs) { | |
609 | PyObject * _resultobj; | |
610 | wxString * _result; | |
611 | wxImageHandler * _arg0; | |
612 | PyObject * _argo0 = 0; | |
613 | char *_kwnames[] = { "self", NULL }; | |
614 | ||
615 | self = self; | |
616 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImageHandler_GetMimeType",_kwnames,&_argo0)) | |
617 | return NULL; | |
618 | if (_argo0) { | |
619 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
620 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImageHandler_p")) { | |
621 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImageHandler_GetMimeType. Expected _wxImageHandler_p."); | |
622 | return NULL; | |
623 | } | |
624 | } | |
625 | { | |
626 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
627 | _result = new wxString (wxImageHandler_GetMimeType(_arg0)); | |
628 | ||
629 | wxPyEndAllowThreads(__tstate); | |
630 | if (PyErr_Occurred()) return NULL; | |
631 | }{ | |
632 | _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len()); | |
633 | } | |
634 | { | |
635 | delete _result; | |
636 | } | |
637 | return _resultobj; | |
638 | } | |
639 | ||
640 | #define wxImageHandler_CanRead(_swigobj,_swigarg0) (_swigobj->CanRead(_swigarg0)) | |
641 | static PyObject *_wrap_wxImageHandler_CanRead(PyObject *self, PyObject *args, PyObject *kwargs) { | |
642 | PyObject * _resultobj; | |
643 | bool _result; | |
644 | wxImageHandler * _arg0; | |
645 | wxString * _arg1; | |
646 | PyObject * _argo0 = 0; | |
647 | PyObject * _obj1 = 0; | |
648 | char *_kwnames[] = { "self","name", NULL }; | |
649 | ||
650 | self = self; | |
651 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxImageHandler_CanRead",_kwnames,&_argo0,&_obj1)) | |
652 | return NULL; | |
653 | if (_argo0) { | |
654 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
655 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImageHandler_p")) { | |
656 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImageHandler_CanRead. Expected _wxImageHandler_p."); | |
657 | return NULL; | |
658 | } | |
659 | } | |
660 | { | |
661 | #if PYTHON_API_VERSION >= 1009 | |
662 | char* tmpPtr; int tmpSize; | |
663 | if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) { | |
664 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
665 | return NULL; | |
666 | } | |
667 | if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1) | |
668 | return NULL; | |
669 | _arg1 = new wxString(tmpPtr, tmpSize); | |
670 | #else | |
671 | if (!PyString_Check(_obj1)) { | |
672 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
673 | return NULL; | |
674 | } | |
675 | _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1)); | |
676 | #endif | |
677 | } | |
678 | { | |
679 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
680 | _result = (bool )wxImageHandler_CanRead(_arg0,*_arg1); | |
681 | ||
682 | wxPyEndAllowThreads(__tstate); | |
683 | if (PyErr_Occurred()) return NULL; | |
684 | } _resultobj = Py_BuildValue("i",_result); | |
685 | { | |
686 | if (_obj1) | |
687 | delete _arg1; | |
688 | } | |
689 | return _resultobj; | |
690 | } | |
691 | ||
692 | #define wxImageHandler_SetName(_swigobj,_swigarg0) (_swigobj->SetName(_swigarg0)) | |
693 | static PyObject *_wrap_wxImageHandler_SetName(PyObject *self, PyObject *args, PyObject *kwargs) { | |
694 | PyObject * _resultobj; | |
695 | wxImageHandler * _arg0; | |
696 | wxString * _arg1; | |
697 | PyObject * _argo0 = 0; | |
698 | PyObject * _obj1 = 0; | |
699 | char *_kwnames[] = { "self","name", NULL }; | |
700 | ||
701 | self = self; | |
702 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxImageHandler_SetName",_kwnames,&_argo0,&_obj1)) | |
703 | return NULL; | |
704 | if (_argo0) { | |
705 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
706 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImageHandler_p")) { | |
707 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImageHandler_SetName. Expected _wxImageHandler_p."); | |
708 | return NULL; | |
709 | } | |
710 | } | |
711 | { | |
712 | #if PYTHON_API_VERSION >= 1009 | |
713 | char* tmpPtr; int tmpSize; | |
714 | if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) { | |
715 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
716 | return NULL; | |
717 | } | |
718 | if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1) | |
719 | return NULL; | |
720 | _arg1 = new wxString(tmpPtr, tmpSize); | |
721 | #else | |
722 | if (!PyString_Check(_obj1)) { | |
723 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
724 | return NULL; | |
725 | } | |
726 | _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1)); | |
727 | #endif | |
728 | } | |
729 | { | |
730 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
731 | wxImageHandler_SetName(_arg0,*_arg1); | |
732 | ||
733 | wxPyEndAllowThreads(__tstate); | |
734 | if (PyErr_Occurred()) return NULL; | |
735 | } Py_INCREF(Py_None); | |
736 | _resultobj = Py_None; | |
737 | { | |
738 | if (_obj1) | |
739 | delete _arg1; | |
740 | } | |
741 | return _resultobj; | |
742 | } | |
743 | ||
744 | #define wxImageHandler_SetExtension(_swigobj,_swigarg0) (_swigobj->SetExtension(_swigarg0)) | |
745 | static PyObject *_wrap_wxImageHandler_SetExtension(PyObject *self, PyObject *args, PyObject *kwargs) { | |
746 | PyObject * _resultobj; | |
747 | wxImageHandler * _arg0; | |
748 | wxString * _arg1; | |
749 | PyObject * _argo0 = 0; | |
750 | PyObject * _obj1 = 0; | |
751 | char *_kwnames[] = { "self","extension", NULL }; | |
752 | ||
753 | self = self; | |
754 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxImageHandler_SetExtension",_kwnames,&_argo0,&_obj1)) | |
755 | return NULL; | |
756 | if (_argo0) { | |
757 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
758 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImageHandler_p")) { | |
759 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImageHandler_SetExtension. Expected _wxImageHandler_p."); | |
760 | return NULL; | |
761 | } | |
762 | } | |
763 | { | |
764 | #if PYTHON_API_VERSION >= 1009 | |
765 | char* tmpPtr; int tmpSize; | |
766 | if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) { | |
767 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
768 | return NULL; | |
769 | } | |
770 | if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1) | |
771 | return NULL; | |
772 | _arg1 = new wxString(tmpPtr, tmpSize); | |
773 | #else | |
774 | if (!PyString_Check(_obj1)) { | |
775 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
776 | return NULL; | |
777 | } | |
778 | _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1)); | |
779 | #endif | |
780 | } | |
781 | { | |
782 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
783 | wxImageHandler_SetExtension(_arg0,*_arg1); | |
784 | ||
785 | wxPyEndAllowThreads(__tstate); | |
786 | if (PyErr_Occurred()) return NULL; | |
787 | } Py_INCREF(Py_None); | |
788 | _resultobj = Py_None; | |
789 | { | |
790 | if (_obj1) | |
791 | delete _arg1; | |
792 | } | |
793 | return _resultobj; | |
794 | } | |
795 | ||
796 | #define wxImageHandler_SetType(_swigobj,_swigarg0) (_swigobj->SetType(_swigarg0)) | |
797 | static PyObject *_wrap_wxImageHandler_SetType(PyObject *self, PyObject *args, PyObject *kwargs) { | |
798 | PyObject * _resultobj; | |
799 | wxImageHandler * _arg0; | |
800 | long _arg1; | |
801 | PyObject * _argo0 = 0; | |
802 | char *_kwnames[] = { "self","type", NULL }; | |
803 | ||
804 | self = self; | |
805 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxImageHandler_SetType",_kwnames,&_argo0,&_arg1)) | |
806 | return NULL; | |
807 | if (_argo0) { | |
808 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
809 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImageHandler_p")) { | |
810 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImageHandler_SetType. Expected _wxImageHandler_p."); | |
811 | return NULL; | |
812 | } | |
813 | } | |
814 | { | |
815 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
816 | wxImageHandler_SetType(_arg0,_arg1); | |
817 | ||
818 | wxPyEndAllowThreads(__tstate); | |
819 | if (PyErr_Occurred()) return NULL; | |
820 | } Py_INCREF(Py_None); | |
821 | _resultobj = Py_None; | |
822 | return _resultobj; | |
823 | } | |
824 | ||
825 | #define wxImageHandler_SetMimeType(_swigobj,_swigarg0) (_swigobj->SetMimeType(_swigarg0)) | |
826 | static PyObject *_wrap_wxImageHandler_SetMimeType(PyObject *self, PyObject *args, PyObject *kwargs) { | |
827 | PyObject * _resultobj; | |
828 | wxImageHandler * _arg0; | |
829 | wxString * _arg1; | |
830 | PyObject * _argo0 = 0; | |
831 | PyObject * _obj1 = 0; | |
832 | char *_kwnames[] = { "self","mimetype", NULL }; | |
833 | ||
834 | self = self; | |
835 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxImageHandler_SetMimeType",_kwnames,&_argo0,&_obj1)) | |
836 | return NULL; | |
837 | if (_argo0) { | |
838 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
839 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImageHandler_p")) { | |
840 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImageHandler_SetMimeType. Expected _wxImageHandler_p."); | |
841 | return NULL; | |
842 | } | |
843 | } | |
844 | { | |
845 | #if PYTHON_API_VERSION >= 1009 | |
846 | char* tmpPtr; int tmpSize; | |
847 | if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) { | |
848 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
849 | return NULL; | |
850 | } | |
851 | if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1) | |
852 | return NULL; | |
853 | _arg1 = new wxString(tmpPtr, tmpSize); | |
854 | #else | |
855 | if (!PyString_Check(_obj1)) { | |
856 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
857 | return NULL; | |
858 | } | |
859 | _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1)); | |
860 | #endif | |
861 | } | |
862 | { | |
863 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
864 | wxImageHandler_SetMimeType(_arg0,*_arg1); | |
865 | ||
866 | wxPyEndAllowThreads(__tstate); | |
867 | if (PyErr_Occurred()) return NULL; | |
868 | } Py_INCREF(Py_None); | |
869 | _resultobj = Py_None; | |
870 | { | |
871 | if (_obj1) | |
872 | delete _arg1; | |
873 | } | |
874 | return _resultobj; | |
875 | } | |
876 | ||
877 | static void *SwigwxPNGHandlerTowxImageHandler(void *ptr) { | |
878 | wxPNGHandler *src; | |
879 | wxImageHandler *dest; | |
880 | src = (wxPNGHandler *) ptr; | |
881 | dest = (wxImageHandler *) src; | |
882 | return (void *) dest; | |
883 | } | |
884 | ||
885 | static void *SwigwxPNGHandlerTowxObject(void *ptr) { | |
886 | wxPNGHandler *src; | |
887 | wxObject *dest; | |
888 | src = (wxPNGHandler *) ptr; | |
889 | dest = (wxObject *) src; | |
890 | return (void *) dest; | |
891 | } | |
892 | ||
893 | #define new_wxPNGHandler() (new wxPNGHandler()) | |
894 | static PyObject *_wrap_new_wxPNGHandler(PyObject *self, PyObject *args, PyObject *kwargs) { | |
895 | PyObject * _resultobj; | |
896 | wxPNGHandler * _result; | |
897 | char *_kwnames[] = { NULL }; | |
898 | char _ptemp[128]; | |
899 | ||
900 | self = self; | |
901 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPNGHandler",_kwnames)) | |
902 | return NULL; | |
903 | { | |
904 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
905 | _result = (wxPNGHandler *)new_wxPNGHandler(); | |
906 | ||
907 | wxPyEndAllowThreads(__tstate); | |
908 | if (PyErr_Occurred()) return NULL; | |
909 | } if (_result) { | |
910 | SWIG_MakePtr(_ptemp, (char *) _result,"_wxPNGHandler_p"); | |
911 | _resultobj = Py_BuildValue("s",_ptemp); | |
912 | } else { | |
913 | Py_INCREF(Py_None); | |
914 | _resultobj = Py_None; | |
915 | } | |
916 | return _resultobj; | |
917 | } | |
918 | ||
919 | static void *SwigwxJPEGHandlerTowxImageHandler(void *ptr) { | |
920 | wxJPEGHandler *src; | |
921 | wxImageHandler *dest; | |
922 | src = (wxJPEGHandler *) ptr; | |
923 | dest = (wxImageHandler *) src; | |
924 | return (void *) dest; | |
925 | } | |
926 | ||
927 | static void *SwigwxJPEGHandlerTowxObject(void *ptr) { | |
928 | wxJPEGHandler *src; | |
929 | wxObject *dest; | |
930 | src = (wxJPEGHandler *) ptr; | |
931 | dest = (wxObject *) src; | |
932 | return (void *) dest; | |
933 | } | |
934 | ||
935 | #define new_wxJPEGHandler() (new wxJPEGHandler()) | |
936 | static PyObject *_wrap_new_wxJPEGHandler(PyObject *self, PyObject *args, PyObject *kwargs) { | |
937 | PyObject * _resultobj; | |
938 | wxJPEGHandler * _result; | |
939 | char *_kwnames[] = { NULL }; | |
940 | char _ptemp[128]; | |
941 | ||
942 | self = self; | |
943 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxJPEGHandler",_kwnames)) | |
944 | return NULL; | |
945 | { | |
946 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
947 | _result = (wxJPEGHandler *)new_wxJPEGHandler(); | |
948 | ||
949 | wxPyEndAllowThreads(__tstate); | |
950 | if (PyErr_Occurred()) return NULL; | |
951 | } if (_result) { | |
952 | SWIG_MakePtr(_ptemp, (char *) _result,"_wxJPEGHandler_p"); | |
953 | _resultobj = Py_BuildValue("s",_ptemp); | |
954 | } else { | |
955 | Py_INCREF(Py_None); | |
956 | _resultobj = Py_None; | |
957 | } | |
958 | return _resultobj; | |
959 | } | |
960 | ||
961 | static void *SwigwxBMPHandlerTowxImageHandler(void *ptr) { | |
962 | wxBMPHandler *src; | |
963 | wxImageHandler *dest; | |
964 | src = (wxBMPHandler *) ptr; | |
965 | dest = (wxImageHandler *) src; | |
966 | return (void *) dest; | |
967 | } | |
968 | ||
969 | static void *SwigwxBMPHandlerTowxObject(void *ptr) { | |
970 | wxBMPHandler *src; | |
971 | wxObject *dest; | |
972 | src = (wxBMPHandler *) ptr; | |
973 | dest = (wxObject *) src; | |
974 | return (void *) dest; | |
975 | } | |
976 | ||
977 | #define new_wxBMPHandler() (new wxBMPHandler()) | |
978 | static PyObject *_wrap_new_wxBMPHandler(PyObject *self, PyObject *args, PyObject *kwargs) { | |
979 | PyObject * _resultobj; | |
980 | wxBMPHandler * _result; | |
981 | char *_kwnames[] = { NULL }; | |
982 | char _ptemp[128]; | |
983 | ||
984 | self = self; | |
985 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxBMPHandler",_kwnames)) | |
986 | return NULL; | |
987 | { | |
988 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
989 | _result = (wxBMPHandler *)new_wxBMPHandler(); | |
990 | ||
991 | wxPyEndAllowThreads(__tstate); | |
992 | if (PyErr_Occurred()) return NULL; | |
993 | } if (_result) { | |
994 | SWIG_MakePtr(_ptemp, (char *) _result,"_wxBMPHandler_p"); | |
995 | _resultobj = Py_BuildValue("s",_ptemp); | |
996 | } else { | |
997 | Py_INCREF(Py_None); | |
998 | _resultobj = Py_None; | |
999 | } | |
1000 | return _resultobj; | |
1001 | } | |
1002 | ||
1003 | static void *SwigwxICOHandlerTowxBMPHandler(void *ptr) { | |
1004 | wxICOHandler *src; | |
1005 | wxBMPHandler *dest; | |
1006 | src = (wxICOHandler *) ptr; | |
1007 | dest = (wxBMPHandler *) src; | |
1008 | return (void *) dest; | |
1009 | } | |
1010 | ||
1011 | static void *SwigwxICOHandlerTowxImageHandler(void *ptr) { | |
1012 | wxICOHandler *src; | |
1013 | wxImageHandler *dest; | |
1014 | src = (wxICOHandler *) ptr; | |
1015 | dest = (wxImageHandler *) src; | |
1016 | return (void *) dest; | |
1017 | } | |
1018 | ||
1019 | static void *SwigwxICOHandlerTowxObject(void *ptr) { | |
1020 | wxICOHandler *src; | |
1021 | wxObject *dest; | |
1022 | src = (wxICOHandler *) ptr; | |
1023 | dest = (wxObject *) src; | |
1024 | return (void *) dest; | |
1025 | } | |
1026 | ||
1027 | #define new_wxICOHandler() (new wxICOHandler()) | |
1028 | static PyObject *_wrap_new_wxICOHandler(PyObject *self, PyObject *args, PyObject *kwargs) { | |
1029 | PyObject * _resultobj; | |
1030 | wxICOHandler * _result; | |
1031 | char *_kwnames[] = { NULL }; | |
1032 | char _ptemp[128]; | |
1033 | ||
1034 | self = self; | |
1035 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxICOHandler",_kwnames)) | |
1036 | return NULL; | |
1037 | { | |
1038 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
1039 | _result = (wxICOHandler *)new_wxICOHandler(); | |
1040 | ||
1041 | wxPyEndAllowThreads(__tstate); | |
1042 | if (PyErr_Occurred()) return NULL; | |
1043 | } if (_result) { | |
1044 | SWIG_MakePtr(_ptemp, (char *) _result,"_wxICOHandler_p"); | |
1045 | _resultobj = Py_BuildValue("s",_ptemp); | |
1046 | } else { | |
1047 | Py_INCREF(Py_None); | |
1048 | _resultobj = Py_None; | |
1049 | } | |
1050 | return _resultobj; | |
1051 | } | |
1052 | ||
1053 | static void *SwigwxCURHandlerTowxICOHandler(void *ptr) { | |
1054 | wxCURHandler *src; | |
1055 | wxICOHandler *dest; | |
1056 | src = (wxCURHandler *) ptr; | |
1057 | dest = (wxICOHandler *) src; | |
1058 | return (void *) dest; | |
1059 | } | |
1060 | ||
1061 | static void *SwigwxCURHandlerTowxBMPHandler(void *ptr) { | |
1062 | wxCURHandler *src; | |
1063 | wxBMPHandler *dest; | |
1064 | src = (wxCURHandler *) ptr; | |
1065 | dest = (wxBMPHandler *) src; | |
1066 | return (void *) dest; | |
1067 | } | |
1068 | ||
1069 | static void *SwigwxCURHandlerTowxImageHandler(void *ptr) { | |
1070 | wxCURHandler *src; | |
1071 | wxImageHandler *dest; | |
1072 | src = (wxCURHandler *) ptr; | |
1073 | dest = (wxImageHandler *) src; | |
1074 | return (void *) dest; | |
1075 | } | |
1076 | ||
1077 | static void *SwigwxCURHandlerTowxObject(void *ptr) { | |
1078 | wxCURHandler *src; | |
1079 | wxObject *dest; | |
1080 | src = (wxCURHandler *) ptr; | |
1081 | dest = (wxObject *) src; | |
1082 | return (void *) dest; | |
1083 | } | |
1084 | ||
1085 | #define new_wxCURHandler() (new wxCURHandler()) | |
1086 | static PyObject *_wrap_new_wxCURHandler(PyObject *self, PyObject *args, PyObject *kwargs) { | |
1087 | PyObject * _resultobj; | |
1088 | wxCURHandler * _result; | |
1089 | char *_kwnames[] = { NULL }; | |
1090 | char _ptemp[128]; | |
1091 | ||
1092 | self = self; | |
1093 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxCURHandler",_kwnames)) | |
1094 | return NULL; | |
1095 | { | |
1096 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
1097 | _result = (wxCURHandler *)new_wxCURHandler(); | |
1098 | ||
1099 | wxPyEndAllowThreads(__tstate); | |
1100 | if (PyErr_Occurred()) return NULL; | |
1101 | } if (_result) { | |
1102 | SWIG_MakePtr(_ptemp, (char *) _result,"_wxCURHandler_p"); | |
1103 | _resultobj = Py_BuildValue("s",_ptemp); | |
1104 | } else { | |
1105 | Py_INCREF(Py_None); | |
1106 | _resultobj = Py_None; | |
1107 | } | |
1108 | return _resultobj; | |
1109 | } | |
1110 | ||
1111 | static void *SwigwxANIHandlerTowxCURHandler(void *ptr) { | |
1112 | wxANIHandler *src; | |
1113 | wxCURHandler *dest; | |
1114 | src = (wxANIHandler *) ptr; | |
1115 | dest = (wxCURHandler *) src; | |
1116 | return (void *) dest; | |
1117 | } | |
1118 | ||
1119 | static void *SwigwxANIHandlerTowxICOHandler(void *ptr) { | |
1120 | wxANIHandler *src; | |
1121 | wxICOHandler *dest; | |
1122 | src = (wxANIHandler *) ptr; | |
1123 | dest = (wxICOHandler *) src; | |
1124 | return (void *) dest; | |
1125 | } | |
1126 | ||
1127 | static void *SwigwxANIHandlerTowxBMPHandler(void *ptr) { | |
1128 | wxANIHandler *src; | |
1129 | wxBMPHandler *dest; | |
1130 | src = (wxANIHandler *) ptr; | |
1131 | dest = (wxBMPHandler *) src; | |
1132 | return (void *) dest; | |
1133 | } | |
1134 | ||
1135 | static void *SwigwxANIHandlerTowxImageHandler(void *ptr) { | |
1136 | wxANIHandler *src; | |
1137 | wxImageHandler *dest; | |
1138 | src = (wxANIHandler *) ptr; | |
1139 | dest = (wxImageHandler *) src; | |
1140 | return (void *) dest; | |
1141 | } | |
1142 | ||
1143 | static void *SwigwxANIHandlerTowxObject(void *ptr) { | |
1144 | wxANIHandler *src; | |
1145 | wxObject *dest; | |
1146 | src = (wxANIHandler *) ptr; | |
1147 | dest = (wxObject *) src; | |
1148 | return (void *) dest; | |
1149 | } | |
1150 | ||
1151 | #define new_wxANIHandler() (new wxANIHandler()) | |
1152 | static PyObject *_wrap_new_wxANIHandler(PyObject *self, PyObject *args, PyObject *kwargs) { | |
1153 | PyObject * _resultobj; | |
1154 | wxANIHandler * _result; | |
1155 | char *_kwnames[] = { NULL }; | |
1156 | char _ptemp[128]; | |
1157 | ||
1158 | self = self; | |
1159 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxANIHandler",_kwnames)) | |
1160 | return NULL; | |
1161 | { | |
1162 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
1163 | _result = (wxANIHandler *)new_wxANIHandler(); | |
1164 | ||
1165 | wxPyEndAllowThreads(__tstate); | |
1166 | if (PyErr_Occurred()) return NULL; | |
1167 | } if (_result) { | |
1168 | SWIG_MakePtr(_ptemp, (char *) _result,"_wxANIHandler_p"); | |
1169 | _resultobj = Py_BuildValue("s",_ptemp); | |
1170 | } else { | |
1171 | Py_INCREF(Py_None); | |
1172 | _resultobj = Py_None; | |
1173 | } | |
1174 | return _resultobj; | |
1175 | } | |
1176 | ||
1177 | static void *SwigwxGIFHandlerTowxImageHandler(void *ptr) { | |
1178 | wxGIFHandler *src; | |
1179 | wxImageHandler *dest; | |
1180 | src = (wxGIFHandler *) ptr; | |
1181 | dest = (wxImageHandler *) src; | |
1182 | return (void *) dest; | |
1183 | } | |
1184 | ||
1185 | static void *SwigwxGIFHandlerTowxObject(void *ptr) { | |
1186 | wxGIFHandler *src; | |
1187 | wxObject *dest; | |
1188 | src = (wxGIFHandler *) ptr; | |
1189 | dest = (wxObject *) src; | |
1190 | return (void *) dest; | |
1191 | } | |
1192 | ||
1193 | #define new_wxGIFHandler() (new wxGIFHandler()) | |
1194 | static PyObject *_wrap_new_wxGIFHandler(PyObject *self, PyObject *args, PyObject *kwargs) { | |
1195 | PyObject * _resultobj; | |
1196 | wxGIFHandler * _result; | |
1197 | char *_kwnames[] = { NULL }; | |
1198 | char _ptemp[128]; | |
1199 | ||
1200 | self = self; | |
1201 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGIFHandler",_kwnames)) | |
1202 | return NULL; | |
1203 | { | |
1204 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
1205 | _result = (wxGIFHandler *)new_wxGIFHandler(); | |
1206 | ||
1207 | wxPyEndAllowThreads(__tstate); | |
1208 | if (PyErr_Occurred()) return NULL; | |
1209 | } if (_result) { | |
1210 | SWIG_MakePtr(_ptemp, (char *) _result,"_wxGIFHandler_p"); | |
1211 | _resultobj = Py_BuildValue("s",_ptemp); | |
1212 | } else { | |
1213 | Py_INCREF(Py_None); | |
1214 | _resultobj = Py_None; | |
1215 | } | |
1216 | return _resultobj; | |
1217 | } | |
1218 | ||
1219 | static void *SwigwxPNMHandlerTowxImageHandler(void *ptr) { | |
1220 | wxPNMHandler *src; | |
1221 | wxImageHandler *dest; | |
1222 | src = (wxPNMHandler *) ptr; | |
1223 | dest = (wxImageHandler *) src; | |
1224 | return (void *) dest; | |
1225 | } | |
1226 | ||
1227 | static void *SwigwxPNMHandlerTowxObject(void *ptr) { | |
1228 | wxPNMHandler *src; | |
1229 | wxObject *dest; | |
1230 | src = (wxPNMHandler *) ptr; | |
1231 | dest = (wxObject *) src; | |
1232 | return (void *) dest; | |
1233 | } | |
1234 | ||
1235 | #define new_wxPNMHandler() (new wxPNMHandler()) | |
1236 | static PyObject *_wrap_new_wxPNMHandler(PyObject *self, PyObject *args, PyObject *kwargs) { | |
1237 | PyObject * _resultobj; | |
1238 | wxPNMHandler * _result; | |
1239 | char *_kwnames[] = { NULL }; | |
1240 | char _ptemp[128]; | |
1241 | ||
1242 | self = self; | |
1243 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPNMHandler",_kwnames)) | |
1244 | return NULL; | |
1245 | { | |
1246 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
1247 | _result = (wxPNMHandler *)new_wxPNMHandler(); | |
1248 | ||
1249 | wxPyEndAllowThreads(__tstate); | |
1250 | if (PyErr_Occurred()) return NULL; | |
1251 | } if (_result) { | |
1252 | SWIG_MakePtr(_ptemp, (char *) _result,"_wxPNMHandler_p"); | |
1253 | _resultobj = Py_BuildValue("s",_ptemp); | |
1254 | } else { | |
1255 | Py_INCREF(Py_None); | |
1256 | _resultobj = Py_None; | |
1257 | } | |
1258 | return _resultobj; | |
1259 | } | |
1260 | ||
1261 | static void *SwigwxPCXHandlerTowxImageHandler(void *ptr) { | |
1262 | wxPCXHandler *src; | |
1263 | wxImageHandler *dest; | |
1264 | src = (wxPCXHandler *) ptr; | |
1265 | dest = (wxImageHandler *) src; | |
1266 | return (void *) dest; | |
1267 | } | |
1268 | ||
1269 | static void *SwigwxPCXHandlerTowxObject(void *ptr) { | |
1270 | wxPCXHandler *src; | |
1271 | wxObject *dest; | |
1272 | src = (wxPCXHandler *) ptr; | |
1273 | dest = (wxObject *) src; | |
1274 | return (void *) dest; | |
1275 | } | |
1276 | ||
1277 | #define new_wxPCXHandler() (new wxPCXHandler()) | |
1278 | static PyObject *_wrap_new_wxPCXHandler(PyObject *self, PyObject *args, PyObject *kwargs) { | |
1279 | PyObject * _resultobj; | |
1280 | wxPCXHandler * _result; | |
1281 | char *_kwnames[] = { NULL }; | |
1282 | char _ptemp[128]; | |
1283 | ||
1284 | self = self; | |
1285 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPCXHandler",_kwnames)) | |
1286 | return NULL; | |
1287 | { | |
1288 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
1289 | _result = (wxPCXHandler *)new_wxPCXHandler(); | |
1290 | ||
1291 | wxPyEndAllowThreads(__tstate); | |
1292 | if (PyErr_Occurred()) return NULL; | |
1293 | } if (_result) { | |
1294 | SWIG_MakePtr(_ptemp, (char *) _result,"_wxPCXHandler_p"); | |
1295 | _resultobj = Py_BuildValue("s",_ptemp); | |
1296 | } else { | |
1297 | Py_INCREF(Py_None); | |
1298 | _resultobj = Py_None; | |
1299 | } | |
1300 | return _resultobj; | |
1301 | } | |
1302 | ||
1303 | static void *SwigwxTIFFHandlerTowxImageHandler(void *ptr) { | |
1304 | wxTIFFHandler *src; | |
1305 | wxImageHandler *dest; | |
1306 | src = (wxTIFFHandler *) ptr; | |
1307 | dest = (wxImageHandler *) src; | |
1308 | return (void *) dest; | |
1309 | } | |
1310 | ||
1311 | static void *SwigwxTIFFHandlerTowxObject(void *ptr) { | |
1312 | wxTIFFHandler *src; | |
1313 | wxObject *dest; | |
1314 | src = (wxTIFFHandler *) ptr; | |
1315 | dest = (wxObject *) src; | |
1316 | return (void *) dest; | |
1317 | } | |
1318 | ||
1319 | #define new_wxTIFFHandler() (new wxTIFFHandler()) | |
1320 | static PyObject *_wrap_new_wxTIFFHandler(PyObject *self, PyObject *args, PyObject *kwargs) { | |
1321 | PyObject * _resultobj; | |
1322 | wxTIFFHandler * _result; | |
1323 | char *_kwnames[] = { NULL }; | |
1324 | char _ptemp[128]; | |
1325 | ||
1326 | self = self; | |
1327 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxTIFFHandler",_kwnames)) | |
1328 | return NULL; | |
1329 | { | |
1330 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
1331 | _result = (wxTIFFHandler *)new_wxTIFFHandler(); | |
1332 | ||
1333 | wxPyEndAllowThreads(__tstate); | |
1334 | if (PyErr_Occurred()) return NULL; | |
1335 | } if (_result) { | |
1336 | SWIG_MakePtr(_ptemp, (char *) _result,"_wxTIFFHandler_p"); | |
1337 | _resultobj = Py_BuildValue("s",_ptemp); | |
1338 | } else { | |
1339 | Py_INCREF(Py_None); | |
1340 | _resultobj = Py_None; | |
1341 | } | |
1342 | return _resultobj; | |
1343 | } | |
1344 | ||
1345 | static void *SwigwxImageTowxObject(void *ptr) { | |
1346 | wxImage *src; | |
1347 | wxObject *dest; | |
1348 | src = (wxImage *) ptr; | |
1349 | dest = (wxObject *) src; | |
1350 | return (void *) dest; | |
1351 | } | |
1352 | ||
1353 | #define new_wxImage(_swigarg0,_swigarg1,_swigarg2) (new wxImage(_swigarg0,_swigarg1,_swigarg2)) | |
1354 | static PyObject *_wrap_new_wxImage(PyObject *self, PyObject *args, PyObject *kwargs) { | |
1355 | PyObject * _resultobj; | |
1356 | wxImage * _result; | |
1357 | wxString * _arg0; | |
1358 | long _arg1 = (long ) wxBITMAP_TYPE_ANY; | |
1359 | int _arg2 = (int ) -1; | |
1360 | PyObject * _obj0 = 0; | |
1361 | char *_kwnames[] = { "name","type","index", NULL }; | |
1362 | char _ptemp[128]; | |
1363 | ||
1364 | self = self; | |
1365 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|li:new_wxImage",_kwnames,&_obj0,&_arg1,&_arg2)) | |
1366 | return NULL; | |
1367 | { | |
1368 | #if PYTHON_API_VERSION >= 1009 | |
1369 | char* tmpPtr; int tmpSize; | |
1370 | if (!PyString_Check(_obj0) && !PyUnicode_Check(_obj0)) { | |
1371 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
1372 | return NULL; | |
1373 | } | |
1374 | if (PyString_AsStringAndSize(_obj0, &tmpPtr, &tmpSize) == -1) | |
1375 | return NULL; | |
1376 | _arg0 = new wxString(tmpPtr, tmpSize); | |
1377 | #else | |
1378 | if (!PyString_Check(_obj0)) { | |
1379 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
1380 | return NULL; | |
1381 | } | |
1382 | _arg0 = new wxString(PyString_AS_STRING(_obj0), PyString_GET_SIZE(_obj0)); | |
1383 | #endif | |
1384 | } | |
1385 | { | |
1386 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
1387 | _result = (wxImage *)new_wxImage(*_arg0,_arg1,_arg2); | |
1388 | ||
1389 | wxPyEndAllowThreads(__tstate); | |
1390 | if (PyErr_Occurred()) return NULL; | |
1391 | } if (_result) { | |
1392 | SWIG_MakePtr(_ptemp, (char *) _result,"_wxImage_p"); | |
1393 | _resultobj = Py_BuildValue("s",_ptemp); | |
1394 | } else { | |
1395 | Py_INCREF(Py_None); | |
1396 | _resultobj = Py_None; | |
1397 | } | |
1398 | { | |
1399 | if (_obj0) | |
1400 | delete _arg0; | |
1401 | } | |
1402 | return _resultobj; | |
1403 | } | |
1404 | ||
1405 | #define delete_wxImage(_swigobj) (delete _swigobj) | |
1406 | static PyObject *_wrap_delete_wxImage(PyObject *self, PyObject *args, PyObject *kwargs) { | |
1407 | PyObject * _resultobj; | |
1408 | wxImage * _arg0; | |
1409 | PyObject * _argo0 = 0; | |
1410 | char *_kwnames[] = { "self", NULL }; | |
1411 | ||
1412 | self = self; | |
1413 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:delete_wxImage",_kwnames,&_argo0)) | |
1414 | return NULL; | |
1415 | if (_argo0) { | |
1416 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
1417 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
1418 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxImage. Expected _wxImage_p."); | |
1419 | return NULL; | |
1420 | } | |
1421 | } | |
1422 | { | |
1423 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
1424 | delete_wxImage(_arg0); | |
1425 | ||
1426 | wxPyEndAllowThreads(__tstate); | |
1427 | if (PyErr_Occurred()) return NULL; | |
1428 | } Py_INCREF(Py_None); | |
1429 | _resultobj = Py_None; | |
1430 | return _resultobj; | |
1431 | } | |
1432 | ||
1433 | #define wxImage_ConvertToBitmap(_swigobj) (_swigobj->ConvertToBitmap()) | |
1434 | static PyObject *_wrap_wxImage_ConvertToBitmap(PyObject *self, PyObject *args, PyObject *kwargs) { | |
1435 | PyObject * _resultobj; | |
1436 | wxBitmap * _result; | |
1437 | wxImage * _arg0; | |
1438 | PyObject * _argo0 = 0; | |
1439 | char *_kwnames[] = { "self", NULL }; | |
1440 | char _ptemp[128]; | |
1441 | ||
1442 | self = self; | |
1443 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_ConvertToBitmap",_kwnames,&_argo0)) | |
1444 | return NULL; | |
1445 | if (_argo0) { | |
1446 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
1447 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
1448 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_ConvertToBitmap. Expected _wxImage_p."); | |
1449 | return NULL; | |
1450 | } | |
1451 | } | |
1452 | { | |
1453 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
1454 | _result = new wxBitmap (wxImage_ConvertToBitmap(_arg0)); | |
1455 | ||
1456 | wxPyEndAllowThreads(__tstate); | |
1457 | if (PyErr_Occurred()) return NULL; | |
1458 | } SWIG_MakePtr(_ptemp, (void *) _result,"_wxBitmap_p"); | |
1459 | _resultobj = Py_BuildValue("s",_ptemp); | |
1460 | return _resultobj; | |
1461 | } | |
1462 | ||
1463 | #define wxImage_ConvertToMonoBitmap(_swigobj,_swigarg0,_swigarg1,_swigarg2) (_swigobj->ConvertToMonoBitmap(_swigarg0,_swigarg1,_swigarg2)) | |
1464 | static PyObject *_wrap_wxImage_ConvertToMonoBitmap(PyObject *self, PyObject *args, PyObject *kwargs) { | |
1465 | PyObject * _resultobj; | |
1466 | wxBitmap * _result; | |
1467 | wxImage * _arg0; | |
1468 | unsigned char _arg1; | |
1469 | unsigned char _arg2; | |
1470 | unsigned char _arg3; | |
1471 | PyObject * _argo0 = 0; | |
1472 | char *_kwnames[] = { "self","red","green","blue", NULL }; | |
1473 | char _ptemp[128]; | |
1474 | ||
1475 | self = self; | |
1476 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Obbb:wxImage_ConvertToMonoBitmap",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3)) | |
1477 | return NULL; | |
1478 | if (_argo0) { | |
1479 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
1480 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
1481 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_ConvertToMonoBitmap. Expected _wxImage_p."); | |
1482 | return NULL; | |
1483 | } | |
1484 | } | |
1485 | { | |
1486 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
1487 | _result = new wxBitmap (wxImage_ConvertToMonoBitmap(_arg0,_arg1,_arg2,_arg3)); | |
1488 | ||
1489 | wxPyEndAllowThreads(__tstate); | |
1490 | if (PyErr_Occurred()) return NULL; | |
1491 | } SWIG_MakePtr(_ptemp, (void *) _result,"_wxBitmap_p"); | |
1492 | _resultobj = Py_BuildValue("s",_ptemp); | |
1493 | return _resultobj; | |
1494 | } | |
1495 | ||
1496 | #define wxImage_Create(_swigobj,_swigarg0,_swigarg1) (_swigobj->Create(_swigarg0,_swigarg1)) | |
1497 | static PyObject *_wrap_wxImage_Create(PyObject *self, PyObject *args, PyObject *kwargs) { | |
1498 | PyObject * _resultobj; | |
1499 | wxImage * _arg0; | |
1500 | int _arg1; | |
1501 | int _arg2; | |
1502 | PyObject * _argo0 = 0; | |
1503 | char *_kwnames[] = { "self","width","height", NULL }; | |
1504 | ||
1505 | self = self; | |
1506 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_Create",_kwnames,&_argo0,&_arg1,&_arg2)) | |
1507 | return NULL; | |
1508 | if (_argo0) { | |
1509 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
1510 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
1511 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Create. Expected _wxImage_p."); | |
1512 | return NULL; | |
1513 | } | |
1514 | } | |
1515 | { | |
1516 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
1517 | wxImage_Create(_arg0,_arg1,_arg2); | |
1518 | ||
1519 | wxPyEndAllowThreads(__tstate); | |
1520 | if (PyErr_Occurred()) return NULL; | |
1521 | } Py_INCREF(Py_None); | |
1522 | _resultobj = Py_None; | |
1523 | return _resultobj; | |
1524 | } | |
1525 | ||
1526 | #define wxImage_Destroy(_swigobj) (_swigobj->Destroy()) | |
1527 | static PyObject *_wrap_wxImage_Destroy(PyObject *self, PyObject *args, PyObject *kwargs) { | |
1528 | PyObject * _resultobj; | |
1529 | wxImage * _arg0; | |
1530 | PyObject * _argo0 = 0; | |
1531 | char *_kwnames[] = { "self", NULL }; | |
1532 | ||
1533 | self = self; | |
1534 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_Destroy",_kwnames,&_argo0)) | |
1535 | return NULL; | |
1536 | if (_argo0) { | |
1537 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
1538 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
1539 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Destroy. Expected _wxImage_p."); | |
1540 | return NULL; | |
1541 | } | |
1542 | } | |
1543 | { | |
1544 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
1545 | wxImage_Destroy(_arg0); | |
1546 | ||
1547 | wxPyEndAllowThreads(__tstate); | |
1548 | if (PyErr_Occurred()) return NULL; | |
1549 | } Py_INCREF(Py_None); | |
1550 | _resultobj = Py_None; | |
1551 | return _resultobj; | |
1552 | } | |
1553 | ||
1554 | #define wxImage_Scale(_swigobj,_swigarg0,_swigarg1) (_swigobj->Scale(_swigarg0,_swigarg1)) | |
1555 | static PyObject *_wrap_wxImage_Scale(PyObject *self, PyObject *args, PyObject *kwargs) { | |
1556 | PyObject * _resultobj; | |
1557 | wxImage * _result; | |
1558 | wxImage * _arg0; | |
1559 | int _arg1; | |
1560 | int _arg2; | |
1561 | PyObject * _argo0 = 0; | |
1562 | char *_kwnames[] = { "self","width","height", NULL }; | |
1563 | char _ptemp[128]; | |
1564 | ||
1565 | self = self; | |
1566 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_Scale",_kwnames,&_argo0,&_arg1,&_arg2)) | |
1567 | return NULL; | |
1568 | if (_argo0) { | |
1569 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
1570 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
1571 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Scale. Expected _wxImage_p."); | |
1572 | return NULL; | |
1573 | } | |
1574 | } | |
1575 | { | |
1576 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
1577 | _result = new wxImage (wxImage_Scale(_arg0,_arg1,_arg2)); | |
1578 | ||
1579 | wxPyEndAllowThreads(__tstate); | |
1580 | if (PyErr_Occurred()) return NULL; | |
1581 | } SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p"); | |
1582 | _resultobj = Py_BuildValue("s",_ptemp); | |
1583 | return _resultobj; | |
1584 | } | |
1585 | ||
1586 | #define wxImage_Rescale(_swigobj,_swigarg0,_swigarg1) (_swigobj->Rescale(_swigarg0,_swigarg1)) | |
1587 | static PyObject *_wrap_wxImage_Rescale(PyObject *self, PyObject *args, PyObject *kwargs) { | |
1588 | PyObject * _resultobj; | |
1589 | wxImage * _result; | |
1590 | wxImage * _arg0; | |
1591 | int _arg1; | |
1592 | int _arg2; | |
1593 | PyObject * _argo0 = 0; | |
1594 | char *_kwnames[] = { "self","width","height", NULL }; | |
1595 | char _ptemp[128]; | |
1596 | ||
1597 | self = self; | |
1598 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_Rescale",_kwnames,&_argo0,&_arg1,&_arg2)) | |
1599 | return NULL; | |
1600 | if (_argo0) { | |
1601 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
1602 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
1603 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Rescale. Expected _wxImage_p."); | |
1604 | return NULL; | |
1605 | } | |
1606 | } | |
1607 | { | |
1608 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
1609 | wxImage & _result_ref = wxImage_Rescale(_arg0,_arg1,_arg2); | |
1610 | _result = (wxImage *) &_result_ref; | |
1611 | ||
1612 | wxPyEndAllowThreads(__tstate); | |
1613 | if (PyErr_Occurred()) return NULL; | |
1614 | } if (_result) { | |
1615 | SWIG_MakePtr(_ptemp, (char *) _result,"_wxImage_p"); | |
1616 | _resultobj = Py_BuildValue("s",_ptemp); | |
1617 | } else { | |
1618 | Py_INCREF(Py_None); | |
1619 | _resultobj = Py_None; | |
1620 | } | |
1621 | return _resultobj; | |
1622 | } | |
1623 | ||
1624 | #define wxImage_SetRGB(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4) (_swigobj->SetRGB(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4)) | |
1625 | static PyObject *_wrap_wxImage_SetRGB(PyObject *self, PyObject *args, PyObject *kwargs) { | |
1626 | PyObject * _resultobj; | |
1627 | wxImage * _arg0; | |
1628 | int _arg1; | |
1629 | int _arg2; | |
1630 | unsigned char _arg3; | |
1631 | unsigned char _arg4; | |
1632 | unsigned char _arg5; | |
1633 | PyObject * _argo0 = 0; | |
1634 | char *_kwnames[] = { "self","x","y","r","g","b", NULL }; | |
1635 | ||
1636 | self = self; | |
1637 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiibbb:wxImage_SetRGB",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5)) | |
1638 | return NULL; | |
1639 | if (_argo0) { | |
1640 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
1641 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
1642 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetRGB. Expected _wxImage_p."); | |
1643 | return NULL; | |
1644 | } | |
1645 | } | |
1646 | { | |
1647 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
1648 | wxImage_SetRGB(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5); | |
1649 | ||
1650 | wxPyEndAllowThreads(__tstate); | |
1651 | if (PyErr_Occurred()) return NULL; | |
1652 | } Py_INCREF(Py_None); | |
1653 | _resultobj = Py_None; | |
1654 | return _resultobj; | |
1655 | } | |
1656 | ||
1657 | #define wxImage_GetRed(_swigobj,_swigarg0,_swigarg1) (_swigobj->GetRed(_swigarg0,_swigarg1)) | |
1658 | static PyObject *_wrap_wxImage_GetRed(PyObject *self, PyObject *args, PyObject *kwargs) { | |
1659 | PyObject * _resultobj; | |
1660 | unsigned char _result; | |
1661 | wxImage * _arg0; | |
1662 | int _arg1; | |
1663 | int _arg2; | |
1664 | PyObject * _argo0 = 0; | |
1665 | char *_kwnames[] = { "self","x","y", NULL }; | |
1666 | ||
1667 | self = self; | |
1668 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_GetRed",_kwnames,&_argo0,&_arg1,&_arg2)) | |
1669 | return NULL; | |
1670 | if (_argo0) { | |
1671 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
1672 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
1673 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetRed. Expected _wxImage_p."); | |
1674 | return NULL; | |
1675 | } | |
1676 | } | |
1677 | { | |
1678 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
1679 | _result = (unsigned char )wxImage_GetRed(_arg0,_arg1,_arg2); | |
1680 | ||
1681 | wxPyEndAllowThreads(__tstate); | |
1682 | if (PyErr_Occurred()) return NULL; | |
1683 | } _resultobj = Py_BuildValue("b",_result); | |
1684 | return _resultobj; | |
1685 | } | |
1686 | ||
1687 | #define wxImage_GetGreen(_swigobj,_swigarg0,_swigarg1) (_swigobj->GetGreen(_swigarg0,_swigarg1)) | |
1688 | static PyObject *_wrap_wxImage_GetGreen(PyObject *self, PyObject *args, PyObject *kwargs) { | |
1689 | PyObject * _resultobj; | |
1690 | unsigned char _result; | |
1691 | wxImage * _arg0; | |
1692 | int _arg1; | |
1693 | int _arg2; | |
1694 | PyObject * _argo0 = 0; | |
1695 | char *_kwnames[] = { "self","x","y", NULL }; | |
1696 | ||
1697 | self = self; | |
1698 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_GetGreen",_kwnames,&_argo0,&_arg1,&_arg2)) | |
1699 | return NULL; | |
1700 | if (_argo0) { | |
1701 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
1702 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
1703 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetGreen. Expected _wxImage_p."); | |
1704 | return NULL; | |
1705 | } | |
1706 | } | |
1707 | { | |
1708 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
1709 | _result = (unsigned char )wxImage_GetGreen(_arg0,_arg1,_arg2); | |
1710 | ||
1711 | wxPyEndAllowThreads(__tstate); | |
1712 | if (PyErr_Occurred()) return NULL; | |
1713 | } _resultobj = Py_BuildValue("b",_result); | |
1714 | return _resultobj; | |
1715 | } | |
1716 | ||
1717 | #define wxImage_GetBlue(_swigobj,_swigarg0,_swigarg1) (_swigobj->GetBlue(_swigarg0,_swigarg1)) | |
1718 | static PyObject *_wrap_wxImage_GetBlue(PyObject *self, PyObject *args, PyObject *kwargs) { | |
1719 | PyObject * _resultobj; | |
1720 | unsigned char _result; | |
1721 | wxImage * _arg0; | |
1722 | int _arg1; | |
1723 | int _arg2; | |
1724 | PyObject * _argo0 = 0; | |
1725 | char *_kwnames[] = { "self","x","y", NULL }; | |
1726 | ||
1727 | self = self; | |
1728 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_GetBlue",_kwnames,&_argo0,&_arg1,&_arg2)) | |
1729 | return NULL; | |
1730 | if (_argo0) { | |
1731 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
1732 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
1733 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetBlue. Expected _wxImage_p."); | |
1734 | return NULL; | |
1735 | } | |
1736 | } | |
1737 | { | |
1738 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
1739 | _result = (unsigned char )wxImage_GetBlue(_arg0,_arg1,_arg2); | |
1740 | ||
1741 | wxPyEndAllowThreads(__tstate); | |
1742 | if (PyErr_Occurred()) return NULL; | |
1743 | } _resultobj = Py_BuildValue("b",_result); | |
1744 | return _resultobj; | |
1745 | } | |
1746 | ||
1747 | static PyObject *_wrap_wxImage_CanRead(PyObject *self, PyObject *args, PyObject *kwargs) { | |
1748 | PyObject * _resultobj; | |
1749 | bool _result; | |
1750 | wxString * _arg0; | |
1751 | PyObject * _obj0 = 0; | |
1752 | char *_kwnames[] = { "name", NULL }; | |
1753 | ||
1754 | self = self; | |
1755 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_CanRead",_kwnames,&_obj0)) | |
1756 | return NULL; | |
1757 | { | |
1758 | #if PYTHON_API_VERSION >= 1009 | |
1759 | char* tmpPtr; int tmpSize; | |
1760 | if (!PyString_Check(_obj0) && !PyUnicode_Check(_obj0)) { | |
1761 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
1762 | return NULL; | |
1763 | } | |
1764 | if (PyString_AsStringAndSize(_obj0, &tmpPtr, &tmpSize) == -1) | |
1765 | return NULL; | |
1766 | _arg0 = new wxString(tmpPtr, tmpSize); | |
1767 | #else | |
1768 | if (!PyString_Check(_obj0)) { | |
1769 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
1770 | return NULL; | |
1771 | } | |
1772 | _arg0 = new wxString(PyString_AS_STRING(_obj0), PyString_GET_SIZE(_obj0)); | |
1773 | #endif | |
1774 | } | |
1775 | { | |
1776 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
1777 | _result = (bool )wxImage::CanRead(*_arg0); | |
1778 | ||
1779 | wxPyEndAllowThreads(__tstate); | |
1780 | if (PyErr_Occurred()) return NULL; | |
1781 | } _resultobj = Py_BuildValue("i",_result); | |
1782 | { | |
1783 | if (_obj0) | |
1784 | delete _arg0; | |
1785 | } | |
1786 | return _resultobj; | |
1787 | } | |
1788 | ||
1789 | static PyObject *_wrap_wxImage_GetImageCount(PyObject *self, PyObject *args, PyObject *kwargs) { | |
1790 | PyObject * _resultobj; | |
1791 | int _result; | |
1792 | wxString * _arg0; | |
1793 | long _arg1 = (long ) wxBITMAP_TYPE_ANY; | |
1794 | PyObject * _obj0 = 0; | |
1795 | char *_kwnames[] = { "name","type", NULL }; | |
1796 | ||
1797 | self = self; | |
1798 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|l:wxImage_GetImageCount",_kwnames,&_obj0,&_arg1)) | |
1799 | return NULL; | |
1800 | { | |
1801 | #if PYTHON_API_VERSION >= 1009 | |
1802 | char* tmpPtr; int tmpSize; | |
1803 | if (!PyString_Check(_obj0) && !PyUnicode_Check(_obj0)) { | |
1804 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
1805 | return NULL; | |
1806 | } | |
1807 | if (PyString_AsStringAndSize(_obj0, &tmpPtr, &tmpSize) == -1) | |
1808 | return NULL; | |
1809 | _arg0 = new wxString(tmpPtr, tmpSize); | |
1810 | #else | |
1811 | if (!PyString_Check(_obj0)) { | |
1812 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
1813 | return NULL; | |
1814 | } | |
1815 | _arg0 = new wxString(PyString_AS_STRING(_obj0), PyString_GET_SIZE(_obj0)); | |
1816 | #endif | |
1817 | } | |
1818 | { | |
1819 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
1820 | _result = (int )wxImage::GetImageCount(*_arg0,_arg1); | |
1821 | ||
1822 | wxPyEndAllowThreads(__tstate); | |
1823 | if (PyErr_Occurred()) return NULL; | |
1824 | } _resultobj = Py_BuildValue("i",_result); | |
1825 | { | |
1826 | if (_obj0) | |
1827 | delete _arg0; | |
1828 | } | |
1829 | return _resultobj; | |
1830 | } | |
1831 | ||
1832 | #define wxImage_LoadFile(_swigobj,_swigarg0,_swigarg1,_swigarg2) (_swigobj->LoadFile(_swigarg0,_swigarg1,_swigarg2)) | |
1833 | static PyObject *_wrap_wxImage_LoadFile(PyObject *self, PyObject *args, PyObject *kwargs) { | |
1834 | PyObject * _resultobj; | |
1835 | bool _result; | |
1836 | wxImage * _arg0; | |
1837 | wxString * _arg1; | |
1838 | long _arg2 = (long ) wxBITMAP_TYPE_ANY; | |
1839 | int _arg3 = (int ) -1; | |
1840 | PyObject * _argo0 = 0; | |
1841 | PyObject * _obj1 = 0; | |
1842 | char *_kwnames[] = { "self","name","type","index", NULL }; | |
1843 | ||
1844 | self = self; | |
1845 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|li:wxImage_LoadFile",_kwnames,&_argo0,&_obj1,&_arg2,&_arg3)) | |
1846 | return NULL; | |
1847 | if (_argo0) { | |
1848 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
1849 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
1850 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_LoadFile. Expected _wxImage_p."); | |
1851 | return NULL; | |
1852 | } | |
1853 | } | |
1854 | { | |
1855 | #if PYTHON_API_VERSION >= 1009 | |
1856 | char* tmpPtr; int tmpSize; | |
1857 | if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) { | |
1858 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
1859 | return NULL; | |
1860 | } | |
1861 | if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1) | |
1862 | return NULL; | |
1863 | _arg1 = new wxString(tmpPtr, tmpSize); | |
1864 | #else | |
1865 | if (!PyString_Check(_obj1)) { | |
1866 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
1867 | return NULL; | |
1868 | } | |
1869 | _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1)); | |
1870 | #endif | |
1871 | } | |
1872 | { | |
1873 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
1874 | _result = (bool )wxImage_LoadFile(_arg0,*_arg1,_arg2,_arg3); | |
1875 | ||
1876 | wxPyEndAllowThreads(__tstate); | |
1877 | if (PyErr_Occurred()) return NULL; | |
1878 | } _resultobj = Py_BuildValue("i",_result); | |
1879 | { | |
1880 | if (_obj1) | |
1881 | delete _arg1; | |
1882 | } | |
1883 | return _resultobj; | |
1884 | } | |
1885 | ||
1886 | #define wxImage_LoadMimeFile(_swigobj,_swigarg0,_swigarg1,_swigarg2) (_swigobj->LoadFile(_swigarg0,_swigarg1,_swigarg2)) | |
1887 | static PyObject *_wrap_wxImage_LoadMimeFile(PyObject *self, PyObject *args, PyObject *kwargs) { | |
1888 | PyObject * _resultobj; | |
1889 | bool _result; | |
1890 | wxImage * _arg0; | |
1891 | wxString * _arg1; | |
1892 | wxString * _arg2; | |
1893 | int _arg3 = (int ) -1; | |
1894 | PyObject * _argo0 = 0; | |
1895 | PyObject * _obj1 = 0; | |
1896 | PyObject * _obj2 = 0; | |
1897 | char *_kwnames[] = { "self","name","mimetype","index", NULL }; | |
1898 | ||
1899 | self = self; | |
1900 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO|i:wxImage_LoadMimeFile",_kwnames,&_argo0,&_obj1,&_obj2,&_arg3)) | |
1901 | return NULL; | |
1902 | if (_argo0) { | |
1903 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
1904 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
1905 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_LoadMimeFile. Expected _wxImage_p."); | |
1906 | return NULL; | |
1907 | } | |
1908 | } | |
1909 | { | |
1910 | #if PYTHON_API_VERSION >= 1009 | |
1911 | char* tmpPtr; int tmpSize; | |
1912 | if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) { | |
1913 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
1914 | return NULL; | |
1915 | } | |
1916 | if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1) | |
1917 | return NULL; | |
1918 | _arg1 = new wxString(tmpPtr, tmpSize); | |
1919 | #else | |
1920 | if (!PyString_Check(_obj1)) { | |
1921 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
1922 | return NULL; | |
1923 | } | |
1924 | _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1)); | |
1925 | #endif | |
1926 | } | |
1927 | { | |
1928 | #if PYTHON_API_VERSION >= 1009 | |
1929 | char* tmpPtr; int tmpSize; | |
1930 | if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) { | |
1931 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
1932 | return NULL; | |
1933 | } | |
1934 | if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1) | |
1935 | return NULL; | |
1936 | _arg2 = new wxString(tmpPtr, tmpSize); | |
1937 | #else | |
1938 | if (!PyString_Check(_obj2)) { | |
1939 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
1940 | return NULL; | |
1941 | } | |
1942 | _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2)); | |
1943 | #endif | |
1944 | } | |
1945 | { | |
1946 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
1947 | _result = (bool )wxImage_LoadMimeFile(_arg0,*_arg1,*_arg2,_arg3); | |
1948 | ||
1949 | wxPyEndAllowThreads(__tstate); | |
1950 | if (PyErr_Occurred()) return NULL; | |
1951 | } _resultobj = Py_BuildValue("i",_result); | |
1952 | { | |
1953 | if (_obj1) | |
1954 | delete _arg1; | |
1955 | } | |
1956 | { | |
1957 | if (_obj2) | |
1958 | delete _arg2; | |
1959 | } | |
1960 | return _resultobj; | |
1961 | } | |
1962 | ||
1963 | #define wxImage_SaveFile(_swigobj,_swigarg0,_swigarg1) (_swigobj->SaveFile(_swigarg0,_swigarg1)) | |
1964 | static PyObject *_wrap_wxImage_SaveFile(PyObject *self, PyObject *args, PyObject *kwargs) { | |
1965 | PyObject * _resultobj; | |
1966 | bool _result; | |
1967 | wxImage * _arg0; | |
1968 | wxString * _arg1; | |
1969 | int _arg2; | |
1970 | PyObject * _argo0 = 0; | |
1971 | PyObject * _obj1 = 0; | |
1972 | char *_kwnames[] = { "self","name","type", NULL }; | |
1973 | ||
1974 | self = self; | |
1975 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOi:wxImage_SaveFile",_kwnames,&_argo0,&_obj1,&_arg2)) | |
1976 | return NULL; | |
1977 | if (_argo0) { | |
1978 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
1979 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
1980 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SaveFile. Expected _wxImage_p."); | |
1981 | return NULL; | |
1982 | } | |
1983 | } | |
1984 | { | |
1985 | #if PYTHON_API_VERSION >= 1009 | |
1986 | char* tmpPtr; int tmpSize; | |
1987 | if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) { | |
1988 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
1989 | return NULL; | |
1990 | } | |
1991 | if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1) | |
1992 | return NULL; | |
1993 | _arg1 = new wxString(tmpPtr, tmpSize); | |
1994 | #else | |
1995 | if (!PyString_Check(_obj1)) { | |
1996 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
1997 | return NULL; | |
1998 | } | |
1999 | _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1)); | |
2000 | #endif | |
2001 | } | |
2002 | { | |
2003 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
2004 | _result = (bool )wxImage_SaveFile(_arg0,*_arg1,_arg2); | |
2005 | ||
2006 | wxPyEndAllowThreads(__tstate); | |
2007 | if (PyErr_Occurred()) return NULL; | |
2008 | } _resultobj = Py_BuildValue("i",_result); | |
2009 | { | |
2010 | if (_obj1) | |
2011 | delete _arg1; | |
2012 | } | |
2013 | return _resultobj; | |
2014 | } | |
2015 | ||
2016 | #define wxImage_SaveMimeFile(_swigobj,_swigarg0,_swigarg1) (_swigobj->SaveFile(_swigarg0,_swigarg1)) | |
2017 | static PyObject *_wrap_wxImage_SaveMimeFile(PyObject *self, PyObject *args, PyObject *kwargs) { | |
2018 | PyObject * _resultobj; | |
2019 | bool _result; | |
2020 | wxImage * _arg0; | |
2021 | wxString * _arg1; | |
2022 | wxString * _arg2; | |
2023 | PyObject * _argo0 = 0; | |
2024 | PyObject * _obj1 = 0; | |
2025 | PyObject * _obj2 = 0; | |
2026 | char *_kwnames[] = { "self","name","mimetype", NULL }; | |
2027 | ||
2028 | self = self; | |
2029 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxImage_SaveMimeFile",_kwnames,&_argo0,&_obj1,&_obj2)) | |
2030 | return NULL; | |
2031 | if (_argo0) { | |
2032 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
2033 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
2034 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SaveMimeFile. Expected _wxImage_p."); | |
2035 | return NULL; | |
2036 | } | |
2037 | } | |
2038 | { | |
2039 | #if PYTHON_API_VERSION >= 1009 | |
2040 | char* tmpPtr; int tmpSize; | |
2041 | if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) { | |
2042 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
2043 | return NULL; | |
2044 | } | |
2045 | if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1) | |
2046 | return NULL; | |
2047 | _arg1 = new wxString(tmpPtr, tmpSize); | |
2048 | #else | |
2049 | if (!PyString_Check(_obj1)) { | |
2050 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
2051 | return NULL; | |
2052 | } | |
2053 | _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1)); | |
2054 | #endif | |
2055 | } | |
2056 | { | |
2057 | #if PYTHON_API_VERSION >= 1009 | |
2058 | char* tmpPtr; int tmpSize; | |
2059 | if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) { | |
2060 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
2061 | return NULL; | |
2062 | } | |
2063 | if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1) | |
2064 | return NULL; | |
2065 | _arg2 = new wxString(tmpPtr, tmpSize); | |
2066 | #else | |
2067 | if (!PyString_Check(_obj2)) { | |
2068 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
2069 | return NULL; | |
2070 | } | |
2071 | _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2)); | |
2072 | #endif | |
2073 | } | |
2074 | { | |
2075 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
2076 | _result = (bool )wxImage_SaveMimeFile(_arg0,*_arg1,*_arg2); | |
2077 | ||
2078 | wxPyEndAllowThreads(__tstate); | |
2079 | if (PyErr_Occurred()) return NULL; | |
2080 | } _resultobj = Py_BuildValue("i",_result); | |
2081 | { | |
2082 | if (_obj1) | |
2083 | delete _arg1; | |
2084 | } | |
2085 | { | |
2086 | if (_obj2) | |
2087 | delete _arg2; | |
2088 | } | |
2089 | return _resultobj; | |
2090 | } | |
2091 | ||
2092 | static PyObject *_wrap_wxImage_CanReadStream(PyObject *self, PyObject *args, PyObject *kwargs) { | |
2093 | PyObject * _resultobj; | |
2094 | bool _result; | |
2095 | wxInputStream * _arg0; | |
2096 | wxPyInputStream * temp; | |
2097 | bool created; | |
2098 | PyObject * _obj0 = 0; | |
2099 | char *_kwnames[] = { "stream", NULL }; | |
2100 | ||
2101 | self = self; | |
2102 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_CanReadStream",_kwnames,&_obj0)) | |
2103 | return NULL; | |
2104 | { | |
2105 | if (SWIG_GetPtrObj(_obj0, (void **) &temp, "_wxPyInputStream_p") == 0) { | |
2106 | _arg0 = temp->m_wxis; | |
2107 | created = FALSE; | |
2108 | } else { | |
2109 | _arg0 = wxPyCBInputStream::create(_obj0, FALSE); | |
2110 | if (_arg0 == NULL) { | |
2111 | PyErr_SetString(PyExc_TypeError,"Expected _wxInputStream_p or Python file-like object."); | |
2112 | return NULL; | |
2113 | } | |
2114 | created = TRUE; | |
2115 | } | |
2116 | } | |
2117 | { | |
2118 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
2119 | _result = (bool )wxImage::CanRead(*_arg0); | |
2120 | ||
2121 | wxPyEndAllowThreads(__tstate); | |
2122 | if (PyErr_Occurred()) return NULL; | |
2123 | } _resultobj = Py_BuildValue("i",_result); | |
2124 | { | |
2125 | if (created) | |
2126 | delete _arg0; | |
2127 | } | |
2128 | return _resultobj; | |
2129 | } | |
2130 | ||
2131 | #define wxImage_LoadStream(_swigobj,_swigarg0,_swigarg1,_swigarg2) (_swigobj->LoadFile(_swigarg0,_swigarg1,_swigarg2)) | |
2132 | static PyObject *_wrap_wxImage_LoadStream(PyObject *self, PyObject *args, PyObject *kwargs) { | |
2133 | PyObject * _resultobj; | |
2134 | bool _result; | |
2135 | wxImage * _arg0; | |
2136 | wxInputStream * _arg1; | |
2137 | long _arg2 = (long ) wxBITMAP_TYPE_ANY; | |
2138 | int _arg3 = (int ) -1; | |
2139 | PyObject * _argo0 = 0; | |
2140 | wxPyInputStream * temp; | |
2141 | bool created; | |
2142 | PyObject * _obj1 = 0; | |
2143 | char *_kwnames[] = { "self","stream","type","index", NULL }; | |
2144 | ||
2145 | self = self; | |
2146 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|li:wxImage_LoadStream",_kwnames,&_argo0,&_obj1,&_arg2,&_arg3)) | |
2147 | return NULL; | |
2148 | if (_argo0) { | |
2149 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
2150 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
2151 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_LoadStream. Expected _wxImage_p."); | |
2152 | return NULL; | |
2153 | } | |
2154 | } | |
2155 | { | |
2156 | if (SWIG_GetPtrObj(_obj1, (void **) &temp, "_wxPyInputStream_p") == 0) { | |
2157 | _arg1 = temp->m_wxis; | |
2158 | created = FALSE; | |
2159 | } else { | |
2160 | _arg1 = wxPyCBInputStream::create(_obj1, FALSE); | |
2161 | if (_arg1 == NULL) { | |
2162 | PyErr_SetString(PyExc_TypeError,"Expected _wxInputStream_p or Python file-like object."); | |
2163 | return NULL; | |
2164 | } | |
2165 | created = TRUE; | |
2166 | } | |
2167 | } | |
2168 | { | |
2169 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
2170 | _result = (bool )wxImage_LoadStream(_arg0,*_arg1,_arg2,_arg3); | |
2171 | ||
2172 | wxPyEndAllowThreads(__tstate); | |
2173 | if (PyErr_Occurred()) return NULL; | |
2174 | } _resultobj = Py_BuildValue("i",_result); | |
2175 | { | |
2176 | if (created) | |
2177 | delete _arg1; | |
2178 | } | |
2179 | return _resultobj; | |
2180 | } | |
2181 | ||
2182 | #define wxImage_LoadMimeStream(_swigobj,_swigarg0,_swigarg1,_swigarg2) (_swigobj->LoadFile(_swigarg0,_swigarg1,_swigarg2)) | |
2183 | static PyObject *_wrap_wxImage_LoadMimeStream(PyObject *self, PyObject *args, PyObject *kwargs) { | |
2184 | PyObject * _resultobj; | |
2185 | bool _result; | |
2186 | wxImage * _arg0; | |
2187 | wxInputStream * _arg1; | |
2188 | wxString * _arg2; | |
2189 | int _arg3 = (int ) -1; | |
2190 | PyObject * _argo0 = 0; | |
2191 | wxPyInputStream * temp; | |
2192 | bool created; | |
2193 | PyObject * _obj1 = 0; | |
2194 | PyObject * _obj2 = 0; | |
2195 | char *_kwnames[] = { "self","stream","mimetype","index", NULL }; | |
2196 | ||
2197 | self = self; | |
2198 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO|i:wxImage_LoadMimeStream",_kwnames,&_argo0,&_obj1,&_obj2,&_arg3)) | |
2199 | return NULL; | |
2200 | if (_argo0) { | |
2201 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
2202 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
2203 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_LoadMimeStream. Expected _wxImage_p."); | |
2204 | return NULL; | |
2205 | } | |
2206 | } | |
2207 | { | |
2208 | if (SWIG_GetPtrObj(_obj1, (void **) &temp, "_wxPyInputStream_p") == 0) { | |
2209 | _arg1 = temp->m_wxis; | |
2210 | created = FALSE; | |
2211 | } else { | |
2212 | _arg1 = wxPyCBInputStream::create(_obj1, FALSE); | |
2213 | if (_arg1 == NULL) { | |
2214 | PyErr_SetString(PyExc_TypeError,"Expected _wxInputStream_p or Python file-like object."); | |
2215 | return NULL; | |
2216 | } | |
2217 | created = TRUE; | |
2218 | } | |
2219 | } | |
2220 | { | |
2221 | #if PYTHON_API_VERSION >= 1009 | |
2222 | char* tmpPtr; int tmpSize; | |
2223 | if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) { | |
2224 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
2225 | return NULL; | |
2226 | } | |
2227 | if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1) | |
2228 | return NULL; | |
2229 | _arg2 = new wxString(tmpPtr, tmpSize); | |
2230 | #else | |
2231 | if (!PyString_Check(_obj2)) { | |
2232 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
2233 | return NULL; | |
2234 | } | |
2235 | _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2)); | |
2236 | #endif | |
2237 | } | |
2238 | { | |
2239 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
2240 | _result = (bool )wxImage_LoadMimeStream(_arg0,*_arg1,*_arg2,_arg3); | |
2241 | ||
2242 | wxPyEndAllowThreads(__tstate); | |
2243 | if (PyErr_Occurred()) return NULL; | |
2244 | } _resultobj = Py_BuildValue("i",_result); | |
2245 | { | |
2246 | if (created) | |
2247 | delete _arg1; | |
2248 | } | |
2249 | { | |
2250 | if (_obj2) | |
2251 | delete _arg2; | |
2252 | } | |
2253 | return _resultobj; | |
2254 | } | |
2255 | ||
2256 | #define wxImage_Ok(_swigobj) (_swigobj->Ok()) | |
2257 | static PyObject *_wrap_wxImage_Ok(PyObject *self, PyObject *args, PyObject *kwargs) { | |
2258 | PyObject * _resultobj; | |
2259 | bool _result; | |
2260 | wxImage * _arg0; | |
2261 | PyObject * _argo0 = 0; | |
2262 | char *_kwnames[] = { "self", NULL }; | |
2263 | ||
2264 | self = self; | |
2265 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_Ok",_kwnames,&_argo0)) | |
2266 | return NULL; | |
2267 | if (_argo0) { | |
2268 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
2269 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
2270 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Ok. Expected _wxImage_p."); | |
2271 | return NULL; | |
2272 | } | |
2273 | } | |
2274 | { | |
2275 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
2276 | _result = (bool )wxImage_Ok(_arg0); | |
2277 | ||
2278 | wxPyEndAllowThreads(__tstate); | |
2279 | if (PyErr_Occurred()) return NULL; | |
2280 | } _resultobj = Py_BuildValue("i",_result); | |
2281 | return _resultobj; | |
2282 | } | |
2283 | ||
2284 | #define wxImage_GetWidth(_swigobj) (_swigobj->GetWidth()) | |
2285 | static PyObject *_wrap_wxImage_GetWidth(PyObject *self, PyObject *args, PyObject *kwargs) { | |
2286 | PyObject * _resultobj; | |
2287 | int _result; | |
2288 | wxImage * _arg0; | |
2289 | PyObject * _argo0 = 0; | |
2290 | char *_kwnames[] = { "self", NULL }; | |
2291 | ||
2292 | self = self; | |
2293 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetWidth",_kwnames,&_argo0)) | |
2294 | return NULL; | |
2295 | if (_argo0) { | |
2296 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
2297 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
2298 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetWidth. Expected _wxImage_p."); | |
2299 | return NULL; | |
2300 | } | |
2301 | } | |
2302 | { | |
2303 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
2304 | _result = (int )wxImage_GetWidth(_arg0); | |
2305 | ||
2306 | wxPyEndAllowThreads(__tstate); | |
2307 | if (PyErr_Occurred()) return NULL; | |
2308 | } _resultobj = Py_BuildValue("i",_result); | |
2309 | return _resultobj; | |
2310 | } | |
2311 | ||
2312 | #define wxImage_GetHeight(_swigobj) (_swigobj->GetHeight()) | |
2313 | static PyObject *_wrap_wxImage_GetHeight(PyObject *self, PyObject *args, PyObject *kwargs) { | |
2314 | PyObject * _resultobj; | |
2315 | int _result; | |
2316 | wxImage * _arg0; | |
2317 | PyObject * _argo0 = 0; | |
2318 | char *_kwnames[] = { "self", NULL }; | |
2319 | ||
2320 | self = self; | |
2321 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetHeight",_kwnames,&_argo0)) | |
2322 | return NULL; | |
2323 | if (_argo0) { | |
2324 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
2325 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
2326 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetHeight. Expected _wxImage_p."); | |
2327 | return NULL; | |
2328 | } | |
2329 | } | |
2330 | { | |
2331 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
2332 | _result = (int )wxImage_GetHeight(_arg0); | |
2333 | ||
2334 | wxPyEndAllowThreads(__tstate); | |
2335 | if (PyErr_Occurred()) return NULL; | |
2336 | } _resultobj = Py_BuildValue("i",_result); | |
2337 | return _resultobj; | |
2338 | } | |
2339 | ||
2340 | #define wxImage_GetSubImage(_swigobj,_swigarg0) (_swigobj->GetSubImage(_swigarg0)) | |
2341 | static PyObject *_wrap_wxImage_GetSubImage(PyObject *self, PyObject *args, PyObject *kwargs) { | |
2342 | PyObject * _resultobj; | |
2343 | wxImage * _result; | |
2344 | wxImage * _arg0; | |
2345 | wxRect * _arg1; | |
2346 | PyObject * _argo0 = 0; | |
2347 | wxRect temp; | |
2348 | PyObject * _obj1 = 0; | |
2349 | char *_kwnames[] = { "self","rect", NULL }; | |
2350 | char _ptemp[128]; | |
2351 | ||
2352 | self = self; | |
2353 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxImage_GetSubImage",_kwnames,&_argo0,&_obj1)) | |
2354 | return NULL; | |
2355 | if (_argo0) { | |
2356 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
2357 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
2358 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetSubImage. Expected _wxImage_p."); | |
2359 | return NULL; | |
2360 | } | |
2361 | } | |
2362 | { | |
2363 | _arg1 = &temp; | |
2364 | if (! wxRect_helper(_obj1, &_arg1)) | |
2365 | return NULL; | |
2366 | } | |
2367 | { | |
2368 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
2369 | _result = new wxImage (wxImage_GetSubImage(_arg0,*_arg1)); | |
2370 | ||
2371 | wxPyEndAllowThreads(__tstate); | |
2372 | if (PyErr_Occurred()) return NULL; | |
2373 | } SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p"); | |
2374 | _resultobj = Py_BuildValue("s",_ptemp); | |
2375 | return _resultobj; | |
2376 | } | |
2377 | ||
2378 | #define wxImage_Copy(_swigobj) (_swigobj->Copy()) | |
2379 | static PyObject *_wrap_wxImage_Copy(PyObject *self, PyObject *args, PyObject *kwargs) { | |
2380 | PyObject * _resultobj; | |
2381 | wxImage * _result; | |
2382 | wxImage * _arg0; | |
2383 | PyObject * _argo0 = 0; | |
2384 | char *_kwnames[] = { "self", NULL }; | |
2385 | char _ptemp[128]; | |
2386 | ||
2387 | self = self; | |
2388 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_Copy",_kwnames,&_argo0)) | |
2389 | return NULL; | |
2390 | if (_argo0) { | |
2391 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
2392 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
2393 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Copy. Expected _wxImage_p."); | |
2394 | return NULL; | |
2395 | } | |
2396 | } | |
2397 | { | |
2398 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
2399 | _result = new wxImage (wxImage_Copy(_arg0)); | |
2400 | ||
2401 | wxPyEndAllowThreads(__tstate); | |
2402 | if (PyErr_Occurred()) return NULL; | |
2403 | } SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p"); | |
2404 | _resultobj = Py_BuildValue("s",_ptemp); | |
2405 | return _resultobj; | |
2406 | } | |
2407 | ||
2408 | #define wxImage_Paste(_swigobj,_swigarg0,_swigarg1,_swigarg2) (_swigobj->Paste(_swigarg0,_swigarg1,_swigarg2)) | |
2409 | static PyObject *_wrap_wxImage_Paste(PyObject *self, PyObject *args, PyObject *kwargs) { | |
2410 | PyObject * _resultobj; | |
2411 | wxImage * _arg0; | |
2412 | wxImage * _arg1; | |
2413 | int _arg2; | |
2414 | int _arg3; | |
2415 | PyObject * _argo0 = 0; | |
2416 | PyObject * _argo1 = 0; | |
2417 | char *_kwnames[] = { "self","image","x","y", NULL }; | |
2418 | ||
2419 | self = self; | |
2420 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOii:wxImage_Paste",_kwnames,&_argo0,&_argo1,&_arg2,&_arg3)) | |
2421 | return NULL; | |
2422 | if (_argo0) { | |
2423 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
2424 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
2425 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Paste. Expected _wxImage_p."); | |
2426 | return NULL; | |
2427 | } | |
2428 | } | |
2429 | if (_argo1) { | |
2430 | if (_argo1 == Py_None) { _arg1 = NULL; } | |
2431 | else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxImage_p")) { | |
2432 | PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxImage_Paste. Expected _wxImage_p."); | |
2433 | return NULL; | |
2434 | } | |
2435 | } | |
2436 | { | |
2437 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
2438 | wxImage_Paste(_arg0,*_arg1,_arg2,_arg3); | |
2439 | ||
2440 | wxPyEndAllowThreads(__tstate); | |
2441 | if (PyErr_Occurred()) return NULL; | |
2442 | } Py_INCREF(Py_None); | |
2443 | _resultobj = Py_None; | |
2444 | return _resultobj; | |
2445 | } | |
2446 | ||
2447 | static PyObject * wxImage_GetData(wxImage *self) { | |
2448 | unsigned char* data = self->GetData(); | |
2449 | int len = self->GetWidth() * self->GetHeight() * 3; | |
2450 | return PyString_FromStringAndSize((char*)data, len); | |
2451 | } | |
2452 | static PyObject *_wrap_wxImage_GetData(PyObject *self, PyObject *args, PyObject *kwargs) { | |
2453 | PyObject * _resultobj; | |
2454 | PyObject * _result; | |
2455 | wxImage * _arg0; | |
2456 | PyObject * _argo0 = 0; | |
2457 | char *_kwnames[] = { "self", NULL }; | |
2458 | ||
2459 | self = self; | |
2460 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetData",_kwnames,&_argo0)) | |
2461 | return NULL; | |
2462 | if (_argo0) { | |
2463 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
2464 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
2465 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetData. Expected _wxImage_p."); | |
2466 | return NULL; | |
2467 | } | |
2468 | } | |
2469 | { | |
2470 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
2471 | _result = (PyObject *)wxImage_GetData(_arg0); | |
2472 | ||
2473 | wxPyEndAllowThreads(__tstate); | |
2474 | if (PyErr_Occurred()) return NULL; | |
2475 | }{ | |
2476 | _resultobj = _result; | |
2477 | } | |
2478 | return _resultobj; | |
2479 | } | |
2480 | ||
2481 | static void wxImage_SetData(wxImage *self,PyObject * data) { | |
2482 | unsigned char* dataPtr; | |
2483 | ||
2484 | if (! PyString_Check(data)) { | |
2485 | PyErr_SetString(PyExc_TypeError, "Expected string object"); | |
2486 | return /* NULL */ ; | |
2487 | } | |
2488 | ||
2489 | size_t len = self->GetWidth() * self->GetHeight() * 3; | |
2490 | dataPtr = (unsigned char*) malloc(len); | |
2491 | memcpy(dataPtr, PyString_AsString(data), len); | |
2492 | self->SetData(dataPtr); | |
2493 | } | |
2494 | static PyObject *_wrap_wxImage_SetData(PyObject *self, PyObject *args, PyObject *kwargs) { | |
2495 | PyObject * _resultobj; | |
2496 | wxImage * _arg0; | |
2497 | PyObject * _arg1; | |
2498 | PyObject * _argo0 = 0; | |
2499 | PyObject * _obj1 = 0; | |
2500 | char *_kwnames[] = { "self","data", NULL }; | |
2501 | ||
2502 | self = self; | |
2503 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxImage_SetData",_kwnames,&_argo0,&_obj1)) | |
2504 | return NULL; | |
2505 | if (_argo0) { | |
2506 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
2507 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
2508 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetData. Expected _wxImage_p."); | |
2509 | return NULL; | |
2510 | } | |
2511 | } | |
2512 | { | |
2513 | _arg1 = _obj1; | |
2514 | } | |
2515 | { | |
2516 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
2517 | wxImage_SetData(_arg0,_arg1); | |
2518 | ||
2519 | wxPyEndAllowThreads(__tstate); | |
2520 | if (PyErr_Occurred()) return NULL; | |
2521 | } Py_INCREF(Py_None); | |
2522 | _resultobj = Py_None; | |
2523 | return _resultobj; | |
2524 | } | |
2525 | ||
2526 | #define wxImage_SetMaskColour(_swigobj,_swigarg0,_swigarg1,_swigarg2) (_swigobj->SetMaskColour(_swigarg0,_swigarg1,_swigarg2)) | |
2527 | static PyObject *_wrap_wxImage_SetMaskColour(PyObject *self, PyObject *args, PyObject *kwargs) { | |
2528 | PyObject * _resultobj; | |
2529 | wxImage * _arg0; | |
2530 | unsigned char _arg1; | |
2531 | unsigned char _arg2; | |
2532 | unsigned char _arg3; | |
2533 | PyObject * _argo0 = 0; | |
2534 | char *_kwnames[] = { "self","r","g","b", NULL }; | |
2535 | ||
2536 | self = self; | |
2537 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Obbb:wxImage_SetMaskColour",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3)) | |
2538 | return NULL; | |
2539 | if (_argo0) { | |
2540 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
2541 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
2542 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetMaskColour. Expected _wxImage_p."); | |
2543 | return NULL; | |
2544 | } | |
2545 | } | |
2546 | { | |
2547 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
2548 | wxImage_SetMaskColour(_arg0,_arg1,_arg2,_arg3); | |
2549 | ||
2550 | wxPyEndAllowThreads(__tstate); | |
2551 | if (PyErr_Occurred()) return NULL; | |
2552 | } Py_INCREF(Py_None); | |
2553 | _resultobj = Py_None; | |
2554 | return _resultobj; | |
2555 | } | |
2556 | ||
2557 | #define wxImage_GetMaskRed(_swigobj) (_swigobj->GetMaskRed()) | |
2558 | static PyObject *_wrap_wxImage_GetMaskRed(PyObject *self, PyObject *args, PyObject *kwargs) { | |
2559 | PyObject * _resultobj; | |
2560 | unsigned char _result; | |
2561 | wxImage * _arg0; | |
2562 | PyObject * _argo0 = 0; | |
2563 | char *_kwnames[] = { "self", NULL }; | |
2564 | ||
2565 | self = self; | |
2566 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetMaskRed",_kwnames,&_argo0)) | |
2567 | return NULL; | |
2568 | if (_argo0) { | |
2569 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
2570 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
2571 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetMaskRed. Expected _wxImage_p."); | |
2572 | return NULL; | |
2573 | } | |
2574 | } | |
2575 | { | |
2576 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
2577 | _result = (unsigned char )wxImage_GetMaskRed(_arg0); | |
2578 | ||
2579 | wxPyEndAllowThreads(__tstate); | |
2580 | if (PyErr_Occurred()) return NULL; | |
2581 | } _resultobj = Py_BuildValue("b",_result); | |
2582 | return _resultobj; | |
2583 | } | |
2584 | ||
2585 | #define wxImage_GetMaskGreen(_swigobj) (_swigobj->GetMaskGreen()) | |
2586 | static PyObject *_wrap_wxImage_GetMaskGreen(PyObject *self, PyObject *args, PyObject *kwargs) { | |
2587 | PyObject * _resultobj; | |
2588 | unsigned char _result; | |
2589 | wxImage * _arg0; | |
2590 | PyObject * _argo0 = 0; | |
2591 | char *_kwnames[] = { "self", NULL }; | |
2592 | ||
2593 | self = self; | |
2594 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetMaskGreen",_kwnames,&_argo0)) | |
2595 | return NULL; | |
2596 | if (_argo0) { | |
2597 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
2598 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
2599 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetMaskGreen. Expected _wxImage_p."); | |
2600 | return NULL; | |
2601 | } | |
2602 | } | |
2603 | { | |
2604 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
2605 | _result = (unsigned char )wxImage_GetMaskGreen(_arg0); | |
2606 | ||
2607 | wxPyEndAllowThreads(__tstate); | |
2608 | if (PyErr_Occurred()) return NULL; | |
2609 | } _resultobj = Py_BuildValue("b",_result); | |
2610 | return _resultobj; | |
2611 | } | |
2612 | ||
2613 | #define wxImage_GetMaskBlue(_swigobj) (_swigobj->GetMaskBlue()) | |
2614 | static PyObject *_wrap_wxImage_GetMaskBlue(PyObject *self, PyObject *args, PyObject *kwargs) { | |
2615 | PyObject * _resultobj; | |
2616 | unsigned char _result; | |
2617 | wxImage * _arg0; | |
2618 | PyObject * _argo0 = 0; | |
2619 | char *_kwnames[] = { "self", NULL }; | |
2620 | ||
2621 | self = self; | |
2622 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetMaskBlue",_kwnames,&_argo0)) | |
2623 | return NULL; | |
2624 | if (_argo0) { | |
2625 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
2626 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
2627 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetMaskBlue. Expected _wxImage_p."); | |
2628 | return NULL; | |
2629 | } | |
2630 | } | |
2631 | { | |
2632 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
2633 | _result = (unsigned char )wxImage_GetMaskBlue(_arg0); | |
2634 | ||
2635 | wxPyEndAllowThreads(__tstate); | |
2636 | if (PyErr_Occurred()) return NULL; | |
2637 | } _resultobj = Py_BuildValue("b",_result); | |
2638 | return _resultobj; | |
2639 | } | |
2640 | ||
2641 | #define wxImage_SetMask(_swigobj,_swigarg0) (_swigobj->SetMask(_swigarg0)) | |
2642 | static PyObject *_wrap_wxImage_SetMask(PyObject *self, PyObject *args, PyObject *kwargs) { | |
2643 | PyObject * _resultobj; | |
2644 | wxImage * _arg0; | |
2645 | bool _arg1 = (bool ) TRUE; | |
2646 | PyObject * _argo0 = 0; | |
2647 | int tempbool1 = (int) TRUE; | |
2648 | char *_kwnames[] = { "self","mask", NULL }; | |
2649 | ||
2650 | self = self; | |
2651 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxImage_SetMask",_kwnames,&_argo0,&tempbool1)) | |
2652 | return NULL; | |
2653 | if (_argo0) { | |
2654 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
2655 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
2656 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetMask. Expected _wxImage_p."); | |
2657 | return NULL; | |
2658 | } | |
2659 | } | |
2660 | _arg1 = (bool ) tempbool1; | |
2661 | { | |
2662 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
2663 | wxImage_SetMask(_arg0,_arg1); | |
2664 | ||
2665 | wxPyEndAllowThreads(__tstate); | |
2666 | if (PyErr_Occurred()) return NULL; | |
2667 | } Py_INCREF(Py_None); | |
2668 | _resultobj = Py_None; | |
2669 | return _resultobj; | |
2670 | } | |
2671 | ||
2672 | #define wxImage_HasMask(_swigobj) (_swigobj->HasMask()) | |
2673 | static PyObject *_wrap_wxImage_HasMask(PyObject *self, PyObject *args, PyObject *kwargs) { | |
2674 | PyObject * _resultobj; | |
2675 | bool _result; | |
2676 | wxImage * _arg0; | |
2677 | PyObject * _argo0 = 0; | |
2678 | char *_kwnames[] = { "self", NULL }; | |
2679 | ||
2680 | self = self; | |
2681 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_HasMask",_kwnames,&_argo0)) | |
2682 | return NULL; | |
2683 | if (_argo0) { | |
2684 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
2685 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
2686 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_HasMask. Expected _wxImage_p."); | |
2687 | return NULL; | |
2688 | } | |
2689 | } | |
2690 | { | |
2691 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
2692 | _result = (bool )wxImage_HasMask(_arg0); | |
2693 | ||
2694 | wxPyEndAllowThreads(__tstate); | |
2695 | if (PyErr_Occurred()) return NULL; | |
2696 | } _resultobj = Py_BuildValue("i",_result); | |
2697 | return _resultobj; | |
2698 | } | |
2699 | ||
2700 | #define wxImage_Rotate(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3) (_swigobj->Rotate(_swigarg0,_swigarg1,_swigarg2,_swigarg3)) | |
2701 | static PyObject *_wrap_wxImage_Rotate(PyObject *self, PyObject *args, PyObject *kwargs) { | |
2702 | PyObject * _resultobj; | |
2703 | wxImage * _result; | |
2704 | wxImage * _arg0; | |
2705 | double _arg1; | |
2706 | wxPoint * _arg2; | |
2707 | bool _arg3 = (bool ) TRUE; | |
2708 | wxPoint * _arg4 = (wxPoint *) NULL; | |
2709 | PyObject * _argo0 = 0; | |
2710 | wxPoint temp; | |
2711 | PyObject * _obj2 = 0; | |
2712 | int tempbool3 = (int) TRUE; | |
2713 | wxPoint temp0; | |
2714 | PyObject * _obj4 = 0; | |
2715 | char *_kwnames[] = { "self","angle","centre_of_rotation","interpolating","offset_after_rotation", NULL }; | |
2716 | char _ptemp[128]; | |
2717 | ||
2718 | self = self; | |
2719 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OdO|iO:wxImage_Rotate",_kwnames,&_argo0,&_arg1,&_obj2,&tempbool3,&_obj4)) | |
2720 | return NULL; | |
2721 | if (_argo0) { | |
2722 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
2723 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
2724 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Rotate. Expected _wxImage_p."); | |
2725 | return NULL; | |
2726 | } | |
2727 | } | |
2728 | { | |
2729 | _arg2 = &temp; | |
2730 | if (! wxPoint_helper(_obj2, &_arg2)) | |
2731 | return NULL; | |
2732 | } | |
2733 | _arg3 = (bool ) tempbool3; | |
2734 | if (_obj4) | |
2735 | { | |
2736 | _arg4 = &temp0; | |
2737 | if (! wxPoint_helper(_obj4, &_arg4)) | |
2738 | return NULL; | |
2739 | } | |
2740 | { | |
2741 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
2742 | _result = new wxImage (wxImage_Rotate(_arg0,_arg1,*_arg2,_arg3,_arg4)); | |
2743 | ||
2744 | wxPyEndAllowThreads(__tstate); | |
2745 | if (PyErr_Occurred()) return NULL; | |
2746 | } SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p"); | |
2747 | _resultobj = Py_BuildValue("s",_ptemp); | |
2748 | return _resultobj; | |
2749 | } | |
2750 | ||
2751 | #define wxImage_Rotate90(_swigobj,_swigarg0) (_swigobj->Rotate90(_swigarg0)) | |
2752 | static PyObject *_wrap_wxImage_Rotate90(PyObject *self, PyObject *args, PyObject *kwargs) { | |
2753 | PyObject * _resultobj; | |
2754 | wxImage * _result; | |
2755 | wxImage * _arg0; | |
2756 | bool _arg1 = (bool ) TRUE; | |
2757 | PyObject * _argo0 = 0; | |
2758 | int tempbool1 = (int) TRUE; | |
2759 | char *_kwnames[] = { "self","clockwise", NULL }; | |
2760 | char _ptemp[128]; | |
2761 | ||
2762 | self = self; | |
2763 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxImage_Rotate90",_kwnames,&_argo0,&tempbool1)) | |
2764 | return NULL; | |
2765 | if (_argo0) { | |
2766 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
2767 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
2768 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Rotate90. Expected _wxImage_p."); | |
2769 | return NULL; | |
2770 | } | |
2771 | } | |
2772 | _arg1 = (bool ) tempbool1; | |
2773 | { | |
2774 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
2775 | _result = new wxImage (wxImage_Rotate90(_arg0,_arg1)); | |
2776 | ||
2777 | wxPyEndAllowThreads(__tstate); | |
2778 | if (PyErr_Occurred()) return NULL; | |
2779 | } SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p"); | |
2780 | _resultobj = Py_BuildValue("s",_ptemp); | |
2781 | return _resultobj; | |
2782 | } | |
2783 | ||
2784 | #define wxImage_Mirror(_swigobj,_swigarg0) (_swigobj->Mirror(_swigarg0)) | |
2785 | static PyObject *_wrap_wxImage_Mirror(PyObject *self, PyObject *args, PyObject *kwargs) { | |
2786 | PyObject * _resultobj; | |
2787 | wxImage * _result; | |
2788 | wxImage * _arg0; | |
2789 | bool _arg1 = (bool ) TRUE; | |
2790 | PyObject * _argo0 = 0; | |
2791 | int tempbool1 = (int) TRUE; | |
2792 | char *_kwnames[] = { "self","horizontally", NULL }; | |
2793 | char _ptemp[128]; | |
2794 | ||
2795 | self = self; | |
2796 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxImage_Mirror",_kwnames,&_argo0,&tempbool1)) | |
2797 | return NULL; | |
2798 | if (_argo0) { | |
2799 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
2800 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
2801 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Mirror. Expected _wxImage_p."); | |
2802 | return NULL; | |
2803 | } | |
2804 | } | |
2805 | _arg1 = (bool ) tempbool1; | |
2806 | { | |
2807 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
2808 | _result = new wxImage (wxImage_Mirror(_arg0,_arg1)); | |
2809 | ||
2810 | wxPyEndAllowThreads(__tstate); | |
2811 | if (PyErr_Occurred()) return NULL; | |
2812 | } SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p"); | |
2813 | _resultobj = Py_BuildValue("s",_ptemp); | |
2814 | return _resultobj; | |
2815 | } | |
2816 | ||
2817 | #define wxImage_Replace(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5) (_swigobj->Replace(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5)) | |
2818 | static PyObject *_wrap_wxImage_Replace(PyObject *self, PyObject *args, PyObject *kwargs) { | |
2819 | PyObject * _resultobj; | |
2820 | wxImage * _arg0; | |
2821 | unsigned char _arg1; | |
2822 | unsigned char _arg2; | |
2823 | unsigned char _arg3; | |
2824 | unsigned char _arg4; | |
2825 | unsigned char _arg5; | |
2826 | unsigned char _arg6; | |
2827 | PyObject * _argo0 = 0; | |
2828 | char *_kwnames[] = { "self","r1","g1","b1","r2","g2","b2", NULL }; | |
2829 | ||
2830 | self = self; | |
2831 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Obbbbbb:wxImage_Replace",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_arg6)) | |
2832 | return NULL; | |
2833 | if (_argo0) { | |
2834 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
2835 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
2836 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Replace. Expected _wxImage_p."); | |
2837 | return NULL; | |
2838 | } | |
2839 | } | |
2840 | { | |
2841 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
2842 | wxImage_Replace(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6); | |
2843 | ||
2844 | wxPyEndAllowThreads(__tstate); | |
2845 | if (PyErr_Occurred()) return NULL; | |
2846 | } Py_INCREF(Py_None); | |
2847 | _resultobj = Py_None; | |
2848 | return _resultobj; | |
2849 | } | |
2850 | ||
2851 | #define wxImage_ConvertToMono(_swigobj,_swigarg0,_swigarg1,_swigarg2) (_swigobj->ConvertToMono(_swigarg0,_swigarg1,_swigarg2)) | |
2852 | static PyObject *_wrap_wxImage_ConvertToMono(PyObject *self, PyObject *args, PyObject *kwargs) { | |
2853 | PyObject * _resultobj; | |
2854 | wxImage * _result; | |
2855 | wxImage * _arg0; | |
2856 | unsigned char _arg1; | |
2857 | unsigned char _arg2; | |
2858 | unsigned char _arg3; | |
2859 | PyObject * _argo0 = 0; | |
2860 | char *_kwnames[] = { "self","r","g","b", NULL }; | |
2861 | char _ptemp[128]; | |
2862 | ||
2863 | self = self; | |
2864 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Obbb:wxImage_ConvertToMono",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3)) | |
2865 | return NULL; | |
2866 | if (_argo0) { | |
2867 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
2868 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
2869 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_ConvertToMono. Expected _wxImage_p."); | |
2870 | return NULL; | |
2871 | } | |
2872 | } | |
2873 | { | |
2874 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
2875 | _result = new wxImage (wxImage_ConvertToMono(_arg0,_arg1,_arg2,_arg3)); | |
2876 | ||
2877 | wxPyEndAllowThreads(__tstate); | |
2878 | if (PyErr_Occurred()) return NULL; | |
2879 | } SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p"); | |
2880 | _resultobj = Py_BuildValue("s",_ptemp); | |
2881 | return _resultobj; | |
2882 | } | |
2883 | ||
2884 | #define wxImage_SetOption(_swigobj,_swigarg0,_swigarg1) (_swigobj->SetOption(_swigarg0,_swigarg1)) | |
2885 | static PyObject *_wrap_wxImage_SetOption(PyObject *self, PyObject *args, PyObject *kwargs) { | |
2886 | PyObject * _resultobj; | |
2887 | wxImage * _arg0; | |
2888 | wxString * _arg1; | |
2889 | wxString * _arg2; | |
2890 | PyObject * _argo0 = 0; | |
2891 | PyObject * _obj1 = 0; | |
2892 | PyObject * _obj2 = 0; | |
2893 | char *_kwnames[] = { "self","name","value", NULL }; | |
2894 | ||
2895 | self = self; | |
2896 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxImage_SetOption",_kwnames,&_argo0,&_obj1,&_obj2)) | |
2897 | return NULL; | |
2898 | if (_argo0) { | |
2899 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
2900 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
2901 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetOption. Expected _wxImage_p."); | |
2902 | return NULL; | |
2903 | } | |
2904 | } | |
2905 | { | |
2906 | #if PYTHON_API_VERSION >= 1009 | |
2907 | char* tmpPtr; int tmpSize; | |
2908 | if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) { | |
2909 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
2910 | return NULL; | |
2911 | } | |
2912 | if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1) | |
2913 | return NULL; | |
2914 | _arg1 = new wxString(tmpPtr, tmpSize); | |
2915 | #else | |
2916 | if (!PyString_Check(_obj1)) { | |
2917 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
2918 | return NULL; | |
2919 | } | |
2920 | _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1)); | |
2921 | #endif | |
2922 | } | |
2923 | { | |
2924 | #if PYTHON_API_VERSION >= 1009 | |
2925 | char* tmpPtr; int tmpSize; | |
2926 | if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) { | |
2927 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
2928 | return NULL; | |
2929 | } | |
2930 | if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1) | |
2931 | return NULL; | |
2932 | _arg2 = new wxString(tmpPtr, tmpSize); | |
2933 | #else | |
2934 | if (!PyString_Check(_obj2)) { | |
2935 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
2936 | return NULL; | |
2937 | } | |
2938 | _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2)); | |
2939 | #endif | |
2940 | } | |
2941 | { | |
2942 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
2943 | wxImage_SetOption(_arg0,*_arg1,*_arg2); | |
2944 | ||
2945 | wxPyEndAllowThreads(__tstate); | |
2946 | if (PyErr_Occurred()) return NULL; | |
2947 | } Py_INCREF(Py_None); | |
2948 | _resultobj = Py_None; | |
2949 | { | |
2950 | if (_obj1) | |
2951 | delete _arg1; | |
2952 | } | |
2953 | { | |
2954 | if (_obj2) | |
2955 | delete _arg2; | |
2956 | } | |
2957 | return _resultobj; | |
2958 | } | |
2959 | ||
2960 | #define wxImage_SetOptionInt(_swigobj,_swigarg0,_swigarg1) (_swigobj->SetOption(_swigarg0,_swigarg1)) | |
2961 | static PyObject *_wrap_wxImage_SetOptionInt(PyObject *self, PyObject *args, PyObject *kwargs) { | |
2962 | PyObject * _resultobj; | |
2963 | wxImage * _arg0; | |
2964 | wxString * _arg1; | |
2965 | int _arg2; | |
2966 | PyObject * _argo0 = 0; | |
2967 | PyObject * _obj1 = 0; | |
2968 | char *_kwnames[] = { "self","name","value", NULL }; | |
2969 | ||
2970 | self = self; | |
2971 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOi:wxImage_SetOptionInt",_kwnames,&_argo0,&_obj1,&_arg2)) | |
2972 | return NULL; | |
2973 | if (_argo0) { | |
2974 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
2975 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
2976 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetOptionInt. Expected _wxImage_p."); | |
2977 | return NULL; | |
2978 | } | |
2979 | } | |
2980 | { | |
2981 | #if PYTHON_API_VERSION >= 1009 | |
2982 | char* tmpPtr; int tmpSize; | |
2983 | if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) { | |
2984 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
2985 | return NULL; | |
2986 | } | |
2987 | if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1) | |
2988 | return NULL; | |
2989 | _arg1 = new wxString(tmpPtr, tmpSize); | |
2990 | #else | |
2991 | if (!PyString_Check(_obj1)) { | |
2992 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
2993 | return NULL; | |
2994 | } | |
2995 | _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1)); | |
2996 | #endif | |
2997 | } | |
2998 | { | |
2999 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
3000 | wxImage_SetOptionInt(_arg0,*_arg1,_arg2); | |
3001 | ||
3002 | wxPyEndAllowThreads(__tstate); | |
3003 | if (PyErr_Occurred()) return NULL; | |
3004 | } Py_INCREF(Py_None); | |
3005 | _resultobj = Py_None; | |
3006 | { | |
3007 | if (_obj1) | |
3008 | delete _arg1; | |
3009 | } | |
3010 | return _resultobj; | |
3011 | } | |
3012 | ||
3013 | #define wxImage_GetOption(_swigobj,_swigarg0) (_swigobj->GetOption(_swigarg0)) | |
3014 | static PyObject *_wrap_wxImage_GetOption(PyObject *self, PyObject *args, PyObject *kwargs) { | |
3015 | PyObject * _resultobj; | |
3016 | wxString * _result; | |
3017 | wxImage * _arg0; | |
3018 | wxString * _arg1; | |
3019 | PyObject * _argo0 = 0; | |
3020 | PyObject * _obj1 = 0; | |
3021 | char *_kwnames[] = { "self","name", NULL }; | |
3022 | ||
3023 | self = self; | |
3024 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxImage_GetOption",_kwnames,&_argo0,&_obj1)) | |
3025 | return NULL; | |
3026 | if (_argo0) { | |
3027 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
3028 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
3029 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetOption. Expected _wxImage_p."); | |
3030 | return NULL; | |
3031 | } | |
3032 | } | |
3033 | { | |
3034 | #if PYTHON_API_VERSION >= 1009 | |
3035 | char* tmpPtr; int tmpSize; | |
3036 | if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) { | |
3037 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
3038 | return NULL; | |
3039 | } | |
3040 | if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1) | |
3041 | return NULL; | |
3042 | _arg1 = new wxString(tmpPtr, tmpSize); | |
3043 | #else | |
3044 | if (!PyString_Check(_obj1)) { | |
3045 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
3046 | return NULL; | |
3047 | } | |
3048 | _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1)); | |
3049 | #endif | |
3050 | } | |
3051 | { | |
3052 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
3053 | _result = new wxString (wxImage_GetOption(_arg0,*_arg1)); | |
3054 | ||
3055 | wxPyEndAllowThreads(__tstate); | |
3056 | if (PyErr_Occurred()) return NULL; | |
3057 | }{ | |
3058 | _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len()); | |
3059 | } | |
3060 | { | |
3061 | if (_obj1) | |
3062 | delete _arg1; | |
3063 | } | |
3064 | { | |
3065 | delete _result; | |
3066 | } | |
3067 | return _resultobj; | |
3068 | } | |
3069 | ||
3070 | #define wxImage_GetOptionInt(_swigobj,_swigarg0) (_swigobj->GetOptionInt(_swigarg0)) | |
3071 | static PyObject *_wrap_wxImage_GetOptionInt(PyObject *self, PyObject *args, PyObject *kwargs) { | |
3072 | PyObject * _resultobj; | |
3073 | int _result; | |
3074 | wxImage * _arg0; | |
3075 | wxString * _arg1; | |
3076 | PyObject * _argo0 = 0; | |
3077 | PyObject * _obj1 = 0; | |
3078 | char *_kwnames[] = { "self","name", NULL }; | |
3079 | ||
3080 | self = self; | |
3081 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxImage_GetOptionInt",_kwnames,&_argo0,&_obj1)) | |
3082 | return NULL; | |
3083 | if (_argo0) { | |
3084 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
3085 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
3086 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetOptionInt. Expected _wxImage_p."); | |
3087 | return NULL; | |
3088 | } | |
3089 | } | |
3090 | { | |
3091 | #if PYTHON_API_VERSION >= 1009 | |
3092 | char* tmpPtr; int tmpSize; | |
3093 | if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) { | |
3094 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
3095 | return NULL; | |
3096 | } | |
3097 | if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1) | |
3098 | return NULL; | |
3099 | _arg1 = new wxString(tmpPtr, tmpSize); | |
3100 | #else | |
3101 | if (!PyString_Check(_obj1)) { | |
3102 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
3103 | return NULL; | |
3104 | } | |
3105 | _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1)); | |
3106 | #endif | |
3107 | } | |
3108 | { | |
3109 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
3110 | _result = (int )wxImage_GetOptionInt(_arg0,*_arg1); | |
3111 | ||
3112 | wxPyEndAllowThreads(__tstate); | |
3113 | if (PyErr_Occurred()) return NULL; | |
3114 | } _resultobj = Py_BuildValue("i",_result); | |
3115 | { | |
3116 | if (_obj1) | |
3117 | delete _arg1; | |
3118 | } | |
3119 | return _resultobj; | |
3120 | } | |
3121 | ||
3122 | #define wxImage_HasOption(_swigobj,_swigarg0) (_swigobj->HasOption(_swigarg0)) | |
3123 | static PyObject *_wrap_wxImage_HasOption(PyObject *self, PyObject *args, PyObject *kwargs) { | |
3124 | PyObject * _resultobj; | |
3125 | bool _result; | |
3126 | wxImage * _arg0; | |
3127 | wxString * _arg1; | |
3128 | PyObject * _argo0 = 0; | |
3129 | PyObject * _obj1 = 0; | |
3130 | char *_kwnames[] = { "self","name", NULL }; | |
3131 | ||
3132 | self = self; | |
3133 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxImage_HasOption",_kwnames,&_argo0,&_obj1)) | |
3134 | return NULL; | |
3135 | if (_argo0) { | |
3136 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
3137 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
3138 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_HasOption. Expected _wxImage_p."); | |
3139 | return NULL; | |
3140 | } | |
3141 | } | |
3142 | { | |
3143 | #if PYTHON_API_VERSION >= 1009 | |
3144 | char* tmpPtr; int tmpSize; | |
3145 | if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) { | |
3146 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
3147 | return NULL; | |
3148 | } | |
3149 | if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1) | |
3150 | return NULL; | |
3151 | _arg1 = new wxString(tmpPtr, tmpSize); | |
3152 | #else | |
3153 | if (!PyString_Check(_obj1)) { | |
3154 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
3155 | return NULL; | |
3156 | } | |
3157 | _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1)); | |
3158 | #endif | |
3159 | } | |
3160 | { | |
3161 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
3162 | _result = (bool )wxImage_HasOption(_arg0,*_arg1); | |
3163 | ||
3164 | wxPyEndAllowThreads(__tstate); | |
3165 | if (PyErr_Occurred()) return NULL; | |
3166 | } _resultobj = Py_BuildValue("i",_result); | |
3167 | { | |
3168 | if (_obj1) | |
3169 | delete _arg1; | |
3170 | } | |
3171 | return _resultobj; | |
3172 | } | |
3173 | ||
3174 | #define wxImage_CountColours(_swigobj,_swigarg0) (_swigobj->CountColours(_swigarg0)) | |
3175 | static PyObject *_wrap_wxImage_CountColours(PyObject *self, PyObject *args, PyObject *kwargs) { | |
3176 | PyObject * _resultobj; | |
3177 | unsigned long _result; | |
3178 | wxImage * _arg0; | |
3179 | unsigned long _arg1 = (unsigned long ) (unsigned long)-1; | |
3180 | PyObject * _argo0 = 0; | |
3181 | char *_kwnames[] = { "self","stopafter", NULL }; | |
3182 | ||
3183 | self = self; | |
3184 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|l:wxImage_CountColours",_kwnames,&_argo0,&_arg1)) | |
3185 | return NULL; | |
3186 | if (_argo0) { | |
3187 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
3188 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) { | |
3189 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_CountColours. Expected _wxImage_p."); | |
3190 | return NULL; | |
3191 | } | |
3192 | } | |
3193 | { | |
3194 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
3195 | _result = (unsigned long )wxImage_CountColours(_arg0,_arg1); | |
3196 | ||
3197 | wxPyEndAllowThreads(__tstate); | |
3198 | if (PyErr_Occurred()) return NULL; | |
3199 | } _resultobj = Py_BuildValue("l",_result); | |
3200 | return _resultobj; | |
3201 | } | |
3202 | ||
3203 | static PyObject *_wrap_wxImage_AddHandler(PyObject *self, PyObject *args, PyObject *kwargs) { | |
3204 | PyObject * _resultobj; | |
3205 | wxImageHandler * _arg0; | |
3206 | PyObject * _argo0 = 0; | |
3207 | char *_kwnames[] = { "handler", NULL }; | |
3208 | ||
3209 | self = self; | |
3210 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_AddHandler",_kwnames,&_argo0)) | |
3211 | return NULL; | |
3212 | if (_argo0) { | |
3213 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
3214 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImageHandler_p")) { | |
3215 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_AddHandler. Expected _wxImageHandler_p."); | |
3216 | return NULL; | |
3217 | } | |
3218 | } | |
3219 | { | |
3220 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
3221 | wxImage::AddHandler(_arg0); | |
3222 | ||
3223 | wxPyEndAllowThreads(__tstate); | |
3224 | if (PyErr_Occurred()) return NULL; | |
3225 | } Py_INCREF(Py_None); | |
3226 | _resultobj = Py_None; | |
3227 | return _resultobj; | |
3228 | } | |
3229 | ||
3230 | static PyObject *_wrap_wxImage_InsertHandler(PyObject *self, PyObject *args, PyObject *kwargs) { | |
3231 | PyObject * _resultobj; | |
3232 | wxImageHandler * _arg0; | |
3233 | PyObject * _argo0 = 0; | |
3234 | char *_kwnames[] = { "handler", NULL }; | |
3235 | ||
3236 | self = self; | |
3237 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_InsertHandler",_kwnames,&_argo0)) | |
3238 | return NULL; | |
3239 | if (_argo0) { | |
3240 | if (_argo0 == Py_None) { _arg0 = NULL; } | |
3241 | else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImageHandler_p")) { | |
3242 | PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_InsertHandler. Expected _wxImageHandler_p."); | |
3243 | return NULL; | |
3244 | } | |
3245 | } | |
3246 | { | |
3247 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
3248 | wxImage::InsertHandler(_arg0); | |
3249 | ||
3250 | wxPyEndAllowThreads(__tstate); | |
3251 | if (PyErr_Occurred()) return NULL; | |
3252 | } Py_INCREF(Py_None); | |
3253 | _resultobj = Py_None; | |
3254 | return _resultobj; | |
3255 | } | |
3256 | ||
3257 | static PyObject *_wrap_wxImage_RemoveHandler(PyObject *self, PyObject *args, PyObject *kwargs) { | |
3258 | PyObject * _resultobj; | |
3259 | bool _result; | |
3260 | wxString * _arg0; | |
3261 | PyObject * _obj0 = 0; | |
3262 | char *_kwnames[] = { "name", NULL }; | |
3263 | ||
3264 | self = self; | |
3265 | if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_RemoveHandler",_kwnames,&_obj0)) | |
3266 | return NULL; | |
3267 | { | |
3268 | #if PYTHON_API_VERSION >= 1009 | |
3269 | char* tmpPtr; int tmpSize; | |
3270 | if (!PyString_Check(_obj0) && !PyUnicode_Check(_obj0)) { | |
3271 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
3272 | return NULL; | |
3273 | } | |
3274 | if (PyString_AsStringAndSize(_obj0, &tmpPtr, &tmpSize) == -1) | |
3275 | return NULL; | |
3276 | _arg0 = new wxString(tmpPtr, tmpSize); | |
3277 | #else | |
3278 | if (!PyString_Check(_obj0)) { | |
3279 | PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); | |
3280 | return NULL; | |
3281 | } | |
3282 | _arg0 = new wxString(PyString_AS_STRING(_obj0), PyString_GET_SIZE(_obj0)); | |
3283 | #endif | |
3284 | } | |
3285 | { | |
3286 | PyThreadState* __tstate = wxPyBeginAllowThreads(); | |
3287 | _result = (bool )wxImage::RemoveHandler(*_arg0); | |
3288 | ||
3289 | wxPyEndAllowThreads(__tstate); | |
3290 | if (PyErr_Occurred()) return NULL; | |
3291 | } _resultobj = Py_BuildValue("i",_result); | |
3292 | { | |
3293 | if (_obj0) | |
3294 | delete _arg0; | |
3295 | } | |
3296 | return _resultobj; | |
3297 | } | |
3298 | ||
3299 | static PyMethodDef imagecMethods[] = { | |
3300 | { "wxImage_RemoveHandler", (PyCFunction) _wrap_wxImage_RemoveHandler, METH_VARARGS | METH_KEYWORDS }, | |
3301 | { "wxImage_InsertHandler", (PyCFunction) _wrap_wxImage_InsertHandler, METH_VARARGS | METH_KEYWORDS }, | |
3302 | { "wxImage_AddHandler", (PyCFunction) _wrap_wxImage_AddHandler, METH_VARARGS | METH_KEYWORDS }, | |
3303 | { "wxImage_CountColours", (PyCFunction) _wrap_wxImage_CountColours, METH_VARARGS | METH_KEYWORDS }, | |
3304 | { "wxImage_HasOption", (PyCFunction) _wrap_wxImage_HasOption, METH_VARARGS | METH_KEYWORDS }, | |
3305 | { "wxImage_GetOptionInt", (PyCFunction) _wrap_wxImage_GetOptionInt, METH_VARARGS | METH_KEYWORDS }, | |
3306 | { "wxImage_GetOption", (PyCFunction) _wrap_wxImage_GetOption, METH_VARARGS | METH_KEYWORDS }, | |
3307 | { "wxImage_SetOptionInt", (PyCFunction) _wrap_wxImage_SetOptionInt, METH_VARARGS | METH_KEYWORDS }, | |
3308 | { "wxImage_SetOption", (PyCFunction) _wrap_wxImage_SetOption, METH_VARARGS | METH_KEYWORDS }, | |
3309 | { "wxImage_ConvertToMono", (PyCFunction) _wrap_wxImage_ConvertToMono, METH_VARARGS | METH_KEYWORDS }, | |
3310 | { "wxImage_Replace", (PyCFunction) _wrap_wxImage_Replace, METH_VARARGS | METH_KEYWORDS }, | |
3311 | { "wxImage_Mirror", (PyCFunction) _wrap_wxImage_Mirror, METH_VARARGS | METH_KEYWORDS }, | |
3312 | { "wxImage_Rotate90", (PyCFunction) _wrap_wxImage_Rotate90, METH_VARARGS | METH_KEYWORDS }, | |
3313 | { "wxImage_Rotate", (PyCFunction) _wrap_wxImage_Rotate, METH_VARARGS | METH_KEYWORDS }, | |
3314 | { "wxImage_HasMask", (PyCFunction) _wrap_wxImage_HasMask, METH_VARARGS | METH_KEYWORDS }, | |
3315 | { "wxImage_SetMask", (PyCFunction) _wrap_wxImage_SetMask, METH_VARARGS | METH_KEYWORDS }, | |
3316 | { "wxImage_GetMaskBlue", (PyCFunction) _wrap_wxImage_GetMaskBlue, METH_VARARGS | METH_KEYWORDS }, | |
3317 | { "wxImage_GetMaskGreen", (PyCFunction) _wrap_wxImage_GetMaskGreen, METH_VARARGS | METH_KEYWORDS }, | |
3318 | { "wxImage_GetMaskRed", (PyCFunction) _wrap_wxImage_GetMaskRed, METH_VARARGS | METH_KEYWORDS }, | |
3319 | { "wxImage_SetMaskColour", (PyCFunction) _wrap_wxImage_SetMaskColour, METH_VARARGS | METH_KEYWORDS }, | |
3320 | { "wxImage_SetData", (PyCFunction) _wrap_wxImage_SetData, METH_VARARGS | METH_KEYWORDS }, | |
3321 | { "wxImage_GetData", (PyCFunction) _wrap_wxImage_GetData, METH_VARARGS | METH_KEYWORDS }, | |
3322 | { "wxImage_Paste", (PyCFunction) _wrap_wxImage_Paste, METH_VARARGS | METH_KEYWORDS }, | |
3323 | { "wxImage_Copy", (PyCFunction) _wrap_wxImage_Copy, METH_VARARGS | METH_KEYWORDS }, | |
3324 | { "wxImage_GetSubImage", (PyCFunction) _wrap_wxImage_GetSubImage, METH_VARARGS | METH_KEYWORDS }, | |
3325 | { "wxImage_GetHeight", (PyCFunction) _wrap_wxImage_GetHeight, METH_VARARGS | METH_KEYWORDS }, | |
3326 | { "wxImage_GetWidth", (PyCFunction) _wrap_wxImage_GetWidth, METH_VARARGS | METH_KEYWORDS }, | |
3327 | { "wxImage_Ok", (PyCFunction) _wrap_wxImage_Ok, METH_VARARGS | METH_KEYWORDS }, | |
3328 | { "wxImage_LoadMimeStream", (PyCFunction) _wrap_wxImage_LoadMimeStream, METH_VARARGS | METH_KEYWORDS }, | |
3329 | { "wxImage_LoadStream", (PyCFunction) _wrap_wxImage_LoadStream, METH_VARARGS | METH_KEYWORDS }, | |
3330 | { "wxImage_CanReadStream", (PyCFunction) _wrap_wxImage_CanReadStream, METH_VARARGS | METH_KEYWORDS }, | |
3331 | { "wxImage_SaveMimeFile", (PyCFunction) _wrap_wxImage_SaveMimeFile, METH_VARARGS | METH_KEYWORDS }, | |
3332 | { "wxImage_SaveFile", (PyCFunction) _wrap_wxImage_SaveFile, METH_VARARGS | METH_KEYWORDS }, | |
3333 | { "wxImage_LoadMimeFile", (PyCFunction) _wrap_wxImage_LoadMimeFile, METH_VARARGS | METH_KEYWORDS }, | |
3334 | { "wxImage_LoadFile", (PyCFunction) _wrap_wxImage_LoadFile, METH_VARARGS | METH_KEYWORDS }, | |
3335 | { "wxImage_GetImageCount", (PyCFunction) _wrap_wxImage_GetImageCount, METH_VARARGS | METH_KEYWORDS }, | |
3336 | { "wxImage_CanRead", (PyCFunction) _wrap_wxImage_CanRead, METH_VARARGS | METH_KEYWORDS }, | |
3337 | { "wxImage_GetBlue", (PyCFunction) _wrap_wxImage_GetBlue, METH_VARARGS | METH_KEYWORDS }, | |
3338 | { "wxImage_GetGreen", (PyCFunction) _wrap_wxImage_GetGreen, METH_VARARGS | METH_KEYWORDS }, | |
3339 | { "wxImage_GetRed", (PyCFunction) _wrap_wxImage_GetRed, METH_VARARGS | METH_KEYWORDS }, | |
3340 | { "wxImage_SetRGB", (PyCFunction) _wrap_wxImage_SetRGB, METH_VARARGS | METH_KEYWORDS }, | |
3341 | { "wxImage_Rescale", (PyCFunction) _wrap_wxImage_Rescale, METH_VARARGS | METH_KEYWORDS }, | |
3342 | { "wxImage_Scale", (PyCFunction) _wrap_wxImage_Scale, METH_VARARGS | METH_KEYWORDS }, | |
3343 | { "wxImage_Destroy", (PyCFunction) _wrap_wxImage_Destroy, METH_VARARGS | METH_KEYWORDS }, | |
3344 | { "wxImage_Create", (PyCFunction) _wrap_wxImage_Create, METH_VARARGS | METH_KEYWORDS }, | |
3345 | { "wxImage_ConvertToMonoBitmap", (PyCFunction) _wrap_wxImage_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS }, | |
3346 | { "wxImage_ConvertToBitmap", (PyCFunction) _wrap_wxImage_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS }, | |
3347 | { "delete_wxImage", (PyCFunction) _wrap_delete_wxImage, METH_VARARGS | METH_KEYWORDS }, | |
3348 | { "new_wxImage", (PyCFunction) _wrap_new_wxImage, METH_VARARGS | METH_KEYWORDS }, | |
3349 | { "new_wxTIFFHandler", (PyCFunction) _wrap_new_wxTIFFHandler, METH_VARARGS | METH_KEYWORDS }, | |
3350 | { "new_wxPCXHandler", (PyCFunction) _wrap_new_wxPCXHandler, METH_VARARGS | METH_KEYWORDS }, | |
3351 | { "new_wxPNMHandler", (PyCFunction) _wrap_new_wxPNMHandler, METH_VARARGS | METH_KEYWORDS }, | |
3352 | { "new_wxGIFHandler", (PyCFunction) _wrap_new_wxGIFHandler, METH_VARARGS | METH_KEYWORDS }, | |
3353 | { "new_wxANIHandler", (PyCFunction) _wrap_new_wxANIHandler, METH_VARARGS | METH_KEYWORDS }, | |
3354 | { "new_wxCURHandler", (PyCFunction) _wrap_new_wxCURHandler, METH_VARARGS | METH_KEYWORDS }, | |
3355 | { "new_wxICOHandler", (PyCFunction) _wrap_new_wxICOHandler, METH_VARARGS | METH_KEYWORDS }, | |
3356 | { "new_wxBMPHandler", (PyCFunction) _wrap_new_wxBMPHandler, METH_VARARGS | METH_KEYWORDS }, | |
3357 | { "new_wxJPEGHandler", (PyCFunction) _wrap_new_wxJPEGHandler, METH_VARARGS | METH_KEYWORDS }, | |
3358 | { "new_wxPNGHandler", (PyCFunction) _wrap_new_wxPNGHandler, METH_VARARGS | METH_KEYWORDS }, | |
3359 | { "wxImageHandler_SetMimeType", (PyCFunction) _wrap_wxImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS }, | |
3360 | { "wxImageHandler_SetType", (PyCFunction) _wrap_wxImageHandler_SetType, METH_VARARGS | METH_KEYWORDS }, | |
3361 | { "wxImageHandler_SetExtension", (PyCFunction) _wrap_wxImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS }, | |
3362 | { "wxImageHandler_SetName", (PyCFunction) _wrap_wxImageHandler_SetName, METH_VARARGS | METH_KEYWORDS }, | |
3363 | { "wxImageHandler_CanRead", (PyCFunction) _wrap_wxImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS }, | |
3364 | { "wxImageHandler_GetMimeType", (PyCFunction) _wrap_wxImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS }, | |
3365 | { "wxImageHandler_GetType", (PyCFunction) _wrap_wxImageHandler_GetType, METH_VARARGS | METH_KEYWORDS }, | |
3366 | { "wxImageHandler_GetExtension", (PyCFunction) _wrap_wxImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS }, | |
3367 | { "wxImageHandler_GetName", (PyCFunction) _wrap_wxImageHandler_GetName, METH_VARARGS | METH_KEYWORDS }, | |
3368 | { "wxBitmapFromImage", (PyCFunction) _wrap_wxBitmapFromImage, METH_VARARGS | METH_KEYWORDS }, | |
3369 | { "wxInitAllImageHandlers", (PyCFunction) _wrap_wxInitAllImageHandlers, METH_VARARGS | METH_KEYWORDS }, | |
3370 | { "wxImageFromStreamMime", (PyCFunction) _wrap_wxImageFromStreamMime, METH_VARARGS | METH_KEYWORDS }, | |
3371 | { "wxImageFromStream", (PyCFunction) _wrap_wxImageFromStream, METH_VARARGS | METH_KEYWORDS }, | |
3372 | { "wxImageFromData", (PyCFunction) _wrap_wxImageFromData, METH_VARARGS | METH_KEYWORDS }, | |
3373 | { "wxImageFromBitmap", (PyCFunction) _wrap_wxImageFromBitmap, METH_VARARGS | METH_KEYWORDS }, | |
3374 | { "wxImageFromMime", (PyCFunction) _wrap_wxImageFromMime, METH_VARARGS | METH_KEYWORDS }, | |
3375 | { "wxEmptyImage", (PyCFunction) _wrap_wxEmptyImage, METH_VARARGS | METH_KEYWORDS }, | |
3376 | { NULL, NULL } | |
3377 | }; | |
3378 | #ifdef __cplusplus | |
3379 | } | |
3380 | #endif | |
3381 | /* | |
3382 | * This table is used by the pointer type-checker | |
3383 | */ | |
3384 | static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = { | |
3385 | { "_signed_long","_long",0}, | |
3386 | { "_wxBMPHandler","_wxANIHandler",SwigwxANIHandlerTowxBMPHandler}, | |
3387 | { "_wxBMPHandler","_wxCURHandler",SwigwxCURHandlerTowxBMPHandler}, | |
3388 | { "_wxBMPHandler","_wxICOHandler",SwigwxICOHandlerTowxBMPHandler}, | |
3389 | { "_wxICOHandler","_wxANIHandler",SwigwxANIHandlerTowxICOHandler}, | |
3390 | { "_wxICOHandler","_wxCURHandler",SwigwxCURHandlerTowxICOHandler}, | |
3391 | { "_wxPrintQuality","_wxCoord",0}, | |
3392 | { "_wxPrintQuality","_int",0}, | |
3393 | { "_wxPrintQuality","_signed_int",0}, | |
3394 | { "_wxPrintQuality","_unsigned_int",0}, | |
3395 | { "_wxPrintQuality","_wxWindowID",0}, | |
3396 | { "_wxPrintQuality","_uint",0}, | |
3397 | { "_wxPrintQuality","_EBool",0}, | |
3398 | { "_wxPrintQuality","_size_t",0}, | |
3399 | { "_wxPrintQuality","_time_t",0}, | |
3400 | { "_wxImageHandler","_wxTIFFHandler",SwigwxTIFFHandlerTowxImageHandler}, | |
3401 | { "_wxImageHandler","_wxPCXHandler",SwigwxPCXHandlerTowxImageHandler}, | |
3402 | { "_wxImageHandler","_wxPNMHandler",SwigwxPNMHandlerTowxImageHandler}, | |
3403 | { "_wxImageHandler","_wxGIFHandler",SwigwxGIFHandlerTowxImageHandler}, | |
3404 | { "_wxImageHandler","_wxANIHandler",SwigwxANIHandlerTowxImageHandler}, | |
3405 | { "_wxImageHandler","_wxCURHandler",SwigwxCURHandlerTowxImageHandler}, | |
3406 | { "_wxImageHandler","_wxICOHandler",SwigwxICOHandlerTowxImageHandler}, | |
3407 | { "_wxImageHandler","_wxBMPHandler",SwigwxBMPHandlerTowxImageHandler}, | |
3408 | { "_wxImageHandler","_wxJPEGHandler",SwigwxJPEGHandlerTowxImageHandler}, | |
3409 | { "_wxImageHandler","_wxPNGHandler",SwigwxPNGHandlerTowxImageHandler}, | |
3410 | { "_byte","_unsigned_char",0}, | |
3411 | { "_long","_unsigned_long",0}, | |
3412 | { "_long","_signed_long",0}, | |
3413 | { "_size_t","_wxCoord",0}, | |
3414 | { "_size_t","_wxPrintQuality",0}, | |
3415 | { "_size_t","_time_t",0}, | |
3416 | { "_size_t","_unsigned_int",0}, | |
3417 | { "_size_t","_int",0}, | |
3418 | { "_size_t","_wxWindowID",0}, | |
3419 | { "_size_t","_uint",0}, | |
3420 | { "_uint","_wxCoord",0}, | |
3421 | { "_uint","_wxPrintQuality",0}, | |
3422 | { "_uint","_time_t",0}, | |
3423 | { "_uint","_size_t",0}, | |
3424 | { "_uint","_unsigned_int",0}, | |
3425 | { "_uint","_int",0}, | |
3426 | { "_uint","_wxWindowID",0}, | |
3427 | { "_wxChar","_char",0}, | |
3428 | { "_char","_wxChar",0}, | |
3429 | { "_struct_wxNativeFontInfo","_wxNativeFontInfo",0}, | |
3430 | { "_EBool","_wxCoord",0}, | |
3431 | { "_EBool","_wxPrintQuality",0}, | |
3432 | { "_EBool","_signed_int",0}, | |
3433 | { "_EBool","_int",0}, | |
3434 | { "_EBool","_wxWindowID",0}, | |
3435 | { "_unsigned_long","_long",0}, | |
3436 | { "_wxNativeFontInfo","_struct_wxNativeFontInfo",0}, | |
3437 | { "_signed_int","_wxCoord",0}, | |
3438 | { "_signed_int","_wxPrintQuality",0}, | |
3439 | { "_signed_int","_EBool",0}, | |
3440 | { "_signed_int","_wxWindowID",0}, | |
3441 | { "_signed_int","_int",0}, | |
3442 | { "_WXTYPE","_short",0}, | |
3443 | { "_WXTYPE","_signed_short",0}, | |
3444 | { "_WXTYPE","_unsigned_short",0}, | |
3445 | { "_unsigned_short","_WXTYPE",0}, | |
3446 | { "_unsigned_short","_short",0}, | |
3447 | { "_wxObject","_wxImage",SwigwxImageTowxObject}, | |
3448 | { "_wxObject","_wxTIFFHandler",SwigwxTIFFHandlerTowxObject}, | |
3449 | { "_wxObject","_wxPCXHandler",SwigwxPCXHandlerTowxObject}, | |
3450 | { "_wxObject","_wxPNMHandler",SwigwxPNMHandlerTowxObject}, | |
3451 | { "_wxObject","_wxGIFHandler",SwigwxGIFHandlerTowxObject}, | |
3452 | { "_wxObject","_wxANIHandler",SwigwxANIHandlerTowxObject}, | |
3453 | { "_wxObject","_wxCURHandler",SwigwxCURHandlerTowxObject}, | |
3454 | { "_wxObject","_wxICOHandler",SwigwxICOHandlerTowxObject}, | |
3455 | { "_wxObject","_wxBMPHandler",SwigwxBMPHandlerTowxObject}, | |
3456 | { "_wxObject","_wxJPEGHandler",SwigwxJPEGHandlerTowxObject}, | |
3457 | { "_wxObject","_wxPNGHandler",SwigwxPNGHandlerTowxObject}, | |
3458 | { "_wxObject","_wxImageHandler",SwigwxImageHandlerTowxObject}, | |
3459 | { "_signed_short","_WXTYPE",0}, | |
3460 | { "_signed_short","_short",0}, | |
3461 | { "_wxCURHandler","_wxANIHandler",SwigwxANIHandlerTowxCURHandler}, | |
3462 | { "_unsigned_char","_byte",0}, | |
3463 | { "_unsigned_int","_wxCoord",0}, | |
3464 | { "_unsigned_int","_wxPrintQuality",0}, | |
3465 | { "_unsigned_int","_time_t",0}, | |
3466 | { "_unsigned_int","_size_t",0}, | |
3467 | { "_unsigned_int","_uint",0}, | |
3468 | { "_unsigned_int","_wxWindowID",0}, | |
3469 | { "_unsigned_int","_int",0}, | |
3470 | { "_short","_WXTYPE",0}, | |
3471 | { "_short","_unsigned_short",0}, | |
3472 | { "_short","_signed_short",0}, | |
3473 | { "_wxWindowID","_wxCoord",0}, | |
3474 | { "_wxWindowID","_wxPrintQuality",0}, | |
3475 | { "_wxWindowID","_time_t",0}, | |
3476 | { "_wxWindowID","_size_t",0}, | |
3477 | { "_wxWindowID","_EBool",0}, | |
3478 | { "_wxWindowID","_uint",0}, | |
3479 | { "_wxWindowID","_int",0}, | |
3480 | { "_wxWindowID","_signed_int",0}, | |
3481 | { "_wxWindowID","_unsigned_int",0}, | |
3482 | { "_int","_wxCoord",0}, | |
3483 | { "_int","_wxPrintQuality",0}, | |
3484 | { "_int","_time_t",0}, | |
3485 | { "_int","_size_t",0}, | |
3486 | { "_int","_EBool",0}, | |
3487 | { "_int","_uint",0}, | |
3488 | { "_int","_wxWindowID",0}, | |
3489 | { "_int","_unsigned_int",0}, | |
3490 | { "_int","_signed_int",0}, | |
3491 | { "_time_t","_wxCoord",0}, | |
3492 | { "_time_t","_wxPrintQuality",0}, | |
3493 | { "_time_t","_unsigned_int",0}, | |
3494 | { "_time_t","_int",0}, | |
3495 | { "_time_t","_wxWindowID",0}, | |
3496 | { "_time_t","_uint",0}, | |
3497 | { "_time_t","_size_t",0}, | |
3498 | { "_wxCoord","_int",0}, | |
3499 | { "_wxCoord","_signed_int",0}, | |
3500 | { "_wxCoord","_unsigned_int",0}, | |
3501 | { "_wxCoord","_wxWindowID",0}, | |
3502 | { "_wxCoord","_uint",0}, | |
3503 | { "_wxCoord","_EBool",0}, | |
3504 | { "_wxCoord","_size_t",0}, | |
3505 | { "_wxCoord","_time_t",0}, | |
3506 | { "_wxCoord","_wxPrintQuality",0}, | |
3507 | {0,0,0}}; | |
3508 | ||
3509 | static PyObject *SWIG_globals; | |
3510 | #ifdef __cplusplus | |
3511 | extern "C" | |
3512 | #endif | |
3513 | SWIGEXPORT(void) initimagec() { | |
3514 | PyObject *m, *d; | |
3515 | SWIG_globals = SWIG_newvarlink(); | |
3516 | m = Py_InitModule("imagec", imagecMethods); | |
3517 | d = PyModule_GetDict(m); | |
3518 | PyDict_SetItemString(d,"cvar", SWIG_globals); | |
3519 | SWIG_addvarlink(SWIG_globals,"wxNullImage",_wrap_wxNullImage_get, _wrap_wxNullImage_set); | |
3520 | { | |
3521 | int i; | |
3522 | for (i = 0; _swig_mapping[i].n1; i++) | |
3523 | SWIG_RegisterMapping(_swig_mapping[i].n1,_swig_mapping[i].n2,_swig_mapping[i].pcnv); | |
3524 | } | |
3525 | } |