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