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