wxPython/src/gtk/image.cpp

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