wxPython/src/mac/image.cpp

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