wxPython/src/msw/image.cpp

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