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