wxPython/src/gtk/image.cpp

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