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