wxPython/src/mac/image.cpp

   1 /*
   2  * FILE : src/mac/image.cpp
   3  *
   4  * This file was automatically generated by :
   5  * Simplified Wrapper and Interface Generator (SWIG)
   6  * Version 1.1 (Build 883)
   7  *
   8  * Portions Copyright (c) 1995-1998
   9  * The University of Utah and The Regents of the University of California.
  10  * Permission is granted to distribute this file in any manner provided
  11  * this notice remains intact.
  12  *
  13  * Do not make changes to this file--changes will be lost!
  14  *
  15  */
  16
  17
  18 #define SWIGCODE
  19 /* Implementation : PYTHON */
  20
  21 #define SWIGPYTHON
  22 #include <string.h>
  23 #include <stdlib.h>
  24 /* Definitions for Windows/Unix exporting */
  25 #if defined(__WIN32__)
  26 #   if defined(_MSC_VER)
  27 #       define SWIGEXPORT(a) __declspec(dllexport) a
  28 #   else
  29 #       if defined(__BORLANDC__)
  30 #           define SWIGEXPORT(a) a _export
  31 #       else
  32 #           define SWIGEXPORT(a) a
  33 #       endif
  34 #   endif
  35 #else
  36 #   define SWIGEXPORT(a) a
  37 #endif
  38
  39 #include "Python.h"
  40
  41 #ifdef __cplusplus
  42 extern "C" {
  43 #endif
  44
  45 extern void SWIG_MakePtr(char *, void *, char *);
  46 extern void SWIG_RegisterMapping(char *, char *, void *(*)(void *));
  47 extern char *SWIG_GetPtr(char *, void **, char *);
  48 extern char *SWIG_GetPtrObj(PyObject *, void **, char *);
  49 extern void SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
  50 extern PyObject *SWIG_newvarlink(void);
  51 #ifdef __cplusplus
  52 }
  53 #endif
  54 #define SWIG_init    initimagec
  55
  56 #define SWIG_name    "imagec"
  57
  58 #include "helpers.h"
  59 #include <wx/image.h>
  60
  61
  62 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
  63     PyObject*   o2;
  64     PyObject*   o3;
  65
  66     if (!target) {
  67         target = o;
  68     } else if (target == Py_None) {
  69         Py_DECREF(Py_None);
  70         target = o;
  71     } else {
  72         if (!PyTuple_Check(target)) {
  73             o2 = target;
  74             target = PyTuple_New(1);
  75             PyTuple_SetItem(target, 0, o2);
  76         }
  77         o3 = PyTuple_New(1);
  78         PyTuple_SetItem(o3, 0, o);
  79
  80         o2 = target;
  81         target = PySequence_Concat(o2, o3);
  82         Py_DECREF(o2);
  83         Py_DECREF(o3);
  84     }
  85     return target;
  86 }
  87
  88 #if PYTHON_API_VERSION >= 1009
  89     static char* wxStringErrorMsg = "String or Unicode type required";
  90 #else
  91     static char* wxStringErrorMsg = "String type required";
  92 #endif
  93
  94     wxImage* wxEmptyImage(int width=0, int height=0) {
  95         if (width == 0 && height == 0)
  96             return new wxImage;
  97         else
  98             return new wxImage(width, height);
  99     }
 100
 101     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_Create(_swigobj,_swigarg0,_swigarg1)  (_swigobj->Create(_swigarg0,_swigarg1))
1330 static PyObject *_wrap_wxImage_Create(PyObject *self, PyObject *args, PyObject *kwargs) {
1331     PyObject * _resultobj;
1332     wxImage * _arg0;
1333     int  _arg1;
1334     int  _arg2;
1335     PyObject * _argo0 = 0;
1336     char *_kwnames[] = { "self","width","height", NULL };
1337
1338     self = self;
1339     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_Create",_kwnames,&_argo0,&_arg1,&_arg2))
1340         return NULL;
1341     if (_argo0) {
1342         if (_argo0 == Py_None) { _arg0 = NULL; }
1343         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1344             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Create. Expected _wxImage_p.");
1345         return NULL;
1346         }
1347     }
1348 {
1349     PyThreadState* __tstate = wxPyBeginAllowThreads();
1350         wxImage_Create(_arg0,_arg1,_arg2);
1351
1352     wxPyEndAllowThreads(__tstate);
1353     if (PyErr_Occurred()) return NULL;
1354 }    Py_INCREF(Py_None);
1355     _resultobj = Py_None;
1356     return _resultobj;
1357 }
1358
1359 #define wxImage_Destroy(_swigobj)  (_swigobj->Destroy())
1360 static PyObject *_wrap_wxImage_Destroy(PyObject *self, PyObject *args, PyObject *kwargs) {
1361     PyObject * _resultobj;
1362     wxImage * _arg0;
1363     PyObject * _argo0 = 0;
1364     char *_kwnames[] = { "self", NULL };
1365
1366     self = self;
1367     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_Destroy",_kwnames,&_argo0))
1368         return NULL;
1369     if (_argo0) {
1370         if (_argo0 == Py_None) { _arg0 = NULL; }
1371         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1372             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Destroy. Expected _wxImage_p.");
1373         return NULL;
1374         }
1375     }
1376 {
1377     PyThreadState* __tstate = wxPyBeginAllowThreads();
1378         wxImage_Destroy(_arg0);
1379
1380     wxPyEndAllowThreads(__tstate);
1381     if (PyErr_Occurred()) return NULL;
1382 }    Py_INCREF(Py_None);
1383     _resultobj = Py_None;
1384     return _resultobj;
1385 }
1386
1387 #define wxImage_Scale(_swigobj,_swigarg0,_swigarg1)  (_swigobj->Scale(_swigarg0,_swigarg1))
1388 static PyObject *_wrap_wxImage_Scale(PyObject *self, PyObject *args, PyObject *kwargs) {
1389     PyObject * _resultobj;
1390     wxImage * _result;
1391     wxImage * _arg0;
1392     int  _arg1;
1393     int  _arg2;
1394     PyObject * _argo0 = 0;
1395     char *_kwnames[] = { "self","width","height", NULL };
1396     char _ptemp[128];
1397
1398     self = self;
1399     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_Scale",_kwnames,&_argo0,&_arg1,&_arg2))
1400         return NULL;
1401     if (_argo0) {
1402         if (_argo0 == Py_None) { _arg0 = NULL; }
1403         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1404             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Scale. Expected _wxImage_p.");
1405         return NULL;
1406         }
1407     }
1408 {
1409     PyThreadState* __tstate = wxPyBeginAllowThreads();
1410         _result = new wxImage (wxImage_Scale(_arg0,_arg1,_arg2));
1411
1412     wxPyEndAllowThreads(__tstate);
1413     if (PyErr_Occurred()) return NULL;
1414 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p");
1415     _resultobj = Py_BuildValue("s",_ptemp);
1416     return _resultobj;
1417 }
1418
1419 #define wxImage_Rescale(_swigobj,_swigarg0,_swigarg1)  (_swigobj->Rescale(_swigarg0,_swigarg1))
1420 static PyObject *_wrap_wxImage_Rescale(PyObject *self, PyObject *args, PyObject *kwargs) {
1421     PyObject * _resultobj;
1422     wxImage * _result;
1423     wxImage * _arg0;
1424     int  _arg1;
1425     int  _arg2;
1426     PyObject * _argo0 = 0;
1427     char *_kwnames[] = { "self","width","height", NULL };
1428     char _ptemp[128];
1429
1430     self = self;
1431     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_Rescale",_kwnames,&_argo0,&_arg1,&_arg2))
1432         return NULL;
1433     if (_argo0) {
1434         if (_argo0 == Py_None) { _arg0 = NULL; }
1435         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1436             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Rescale. Expected _wxImage_p.");
1437         return NULL;
1438         }
1439     }
1440 {
1441     PyThreadState* __tstate = wxPyBeginAllowThreads();
1442         wxImage & _result_ref = wxImage_Rescale(_arg0,_arg1,_arg2);
1443     _result = (wxImage *) &_result_ref;
1444
1445     wxPyEndAllowThreads(__tstate);
1446     if (PyErr_Occurred()) return NULL;
1447 }    if (_result) {
1448         SWIG_MakePtr(_ptemp, (char *) _result,"_wxImage_p");
1449         _resultobj = Py_BuildValue("s",_ptemp);
1450     } else {
1451         Py_INCREF(Py_None);
1452         _resultobj = Py_None;
1453     }
1454     return _resultobj;
1455 }
1456
1457 #define wxImage_SetRGB(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4)  (_swigobj->SetRGB(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4))
1458 static PyObject *_wrap_wxImage_SetRGB(PyObject *self, PyObject *args, PyObject *kwargs) {
1459     PyObject * _resultobj;
1460     wxImage * _arg0;
1461     int  _arg1;
1462     int  _arg2;
1463     unsigned char  _arg3;
1464     unsigned char  _arg4;
1465     unsigned char  _arg5;
1466     PyObject * _argo0 = 0;
1467     char *_kwnames[] = { "self","x","y","r","g","b", NULL };
1468
1469     self = self;
1470     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiibbb:wxImage_SetRGB",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5))
1471         return NULL;
1472     if (_argo0) {
1473         if (_argo0 == Py_None) { _arg0 = NULL; }
1474         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1475             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetRGB. Expected _wxImage_p.");
1476         return NULL;
1477         }
1478     }
1479 {
1480     PyThreadState* __tstate = wxPyBeginAllowThreads();
1481         wxImage_SetRGB(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5);
1482
1483     wxPyEndAllowThreads(__tstate);
1484     if (PyErr_Occurred()) return NULL;
1485 }    Py_INCREF(Py_None);
1486     _resultobj = Py_None;
1487     return _resultobj;
1488 }
1489
1490 #define wxImage_GetRed(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetRed(_swigarg0,_swigarg1))
1491 static PyObject *_wrap_wxImage_GetRed(PyObject *self, PyObject *args, PyObject *kwargs) {
1492     PyObject * _resultobj;
1493     unsigned char  _result;
1494     wxImage * _arg0;
1495     int  _arg1;
1496     int  _arg2;
1497     PyObject * _argo0 = 0;
1498     char *_kwnames[] = { "self","x","y", NULL };
1499
1500     self = self;
1501     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_GetRed",_kwnames,&_argo0,&_arg1,&_arg2))
1502         return NULL;
1503     if (_argo0) {
1504         if (_argo0 == Py_None) { _arg0 = NULL; }
1505         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1506             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetRed. Expected _wxImage_p.");
1507         return NULL;
1508         }
1509     }
1510 {
1511     PyThreadState* __tstate = wxPyBeginAllowThreads();
1512         _result = (unsigned char )wxImage_GetRed(_arg0,_arg1,_arg2);
1513
1514     wxPyEndAllowThreads(__tstate);
1515     if (PyErr_Occurred()) return NULL;
1516 }    _resultobj = Py_BuildValue("b",_result);
1517     return _resultobj;
1518 }
1519
1520 #define wxImage_GetGreen(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetGreen(_swigarg0,_swigarg1))
1521 static PyObject *_wrap_wxImage_GetGreen(PyObject *self, PyObject *args, PyObject *kwargs) {
1522     PyObject * _resultobj;
1523     unsigned char  _result;
1524     wxImage * _arg0;
1525     int  _arg1;
1526     int  _arg2;
1527     PyObject * _argo0 = 0;
1528     char *_kwnames[] = { "self","x","y", NULL };
1529
1530     self = self;
1531     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_GetGreen",_kwnames,&_argo0,&_arg1,&_arg2))
1532         return NULL;
1533     if (_argo0) {
1534         if (_argo0 == Py_None) { _arg0 = NULL; }
1535         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1536             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetGreen. Expected _wxImage_p.");
1537         return NULL;
1538         }
1539     }
1540 {
1541     PyThreadState* __tstate = wxPyBeginAllowThreads();
1542         _result = (unsigned char )wxImage_GetGreen(_arg0,_arg1,_arg2);
1543
1544     wxPyEndAllowThreads(__tstate);
1545     if (PyErr_Occurred()) return NULL;
1546 }    _resultobj = Py_BuildValue("b",_result);
1547     return _resultobj;
1548 }
1549
1550 #define wxImage_GetBlue(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetBlue(_swigarg0,_swigarg1))
1551 static PyObject *_wrap_wxImage_GetBlue(PyObject *self, PyObject *args, PyObject *kwargs) {
1552     PyObject * _resultobj;
1553     unsigned char  _result;
1554     wxImage * _arg0;
1555     int  _arg1;
1556     int  _arg2;
1557     PyObject * _argo0 = 0;
1558     char *_kwnames[] = { "self","x","y", NULL };
1559
1560     self = self;
1561     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_GetBlue",_kwnames,&_argo0,&_arg1,&_arg2))
1562         return NULL;
1563     if (_argo0) {
1564         if (_argo0 == Py_None) { _arg0 = NULL; }
1565         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1566             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetBlue. Expected _wxImage_p.");
1567         return NULL;
1568         }
1569     }
1570 {
1571     PyThreadState* __tstate = wxPyBeginAllowThreads();
1572         _result = (unsigned char )wxImage_GetBlue(_arg0,_arg1,_arg2);
1573
1574     wxPyEndAllowThreads(__tstate);
1575     if (PyErr_Occurred()) return NULL;
1576 }    _resultobj = Py_BuildValue("b",_result);
1577     return _resultobj;
1578 }
1579
1580 static PyObject *_wrap_wxImage_CanRead(PyObject *self, PyObject *args, PyObject *kwargs) {
1581     PyObject * _resultobj;
1582     bool  _result;
1583     wxString * _arg0;
1584     PyObject * _obj0 = 0;
1585     char *_kwnames[] = { "name", NULL };
1586
1587     self = self;
1588     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_CanRead",_kwnames,&_obj0))
1589         return NULL;
1590 {
1591 #if PYTHON_API_VERSION >= 1009
1592     char* tmpPtr; int tmpSize;
1593     if (!PyString_Check(_obj0) && !PyUnicode_Check(_obj0)) {
1594         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1595         return NULL;
1596     }
1597     if (PyString_AsStringAndSize(_obj0, &tmpPtr, &tmpSize) == -1)
1598         return NULL;
1599     _arg0 = new wxString(tmpPtr, tmpSize);
1600 #else
1601     if (!PyString_Check(_obj0)) {
1602         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1603         return NULL;
1604     }
1605     _arg0 = new wxString(PyString_AS_STRING(_obj0), PyString_GET_SIZE(_obj0));
1606 #endif
1607 }
1608 {
1609     PyThreadState* __tstate = wxPyBeginAllowThreads();
1610         _result = (bool )wxImage::CanRead(*_arg0);
1611
1612     wxPyEndAllowThreads(__tstate);
1613     if (PyErr_Occurred()) return NULL;
1614 }    _resultobj = Py_BuildValue("i",_result);
1615 {
1616     if (_obj0)
1617         delete _arg0;
1618 }
1619     return _resultobj;
1620 }
1621
1622 static PyObject *_wrap_wxImage_GetImageCount(PyObject *self, PyObject *args, PyObject *kwargs) {
1623     PyObject * _resultobj;
1624     int  _result;
1625     wxString * _arg0;
1626     long  _arg1 = (long ) wxBITMAP_TYPE_ANY;
1627     PyObject * _obj0 = 0;
1628     char *_kwnames[] = { "name","type", NULL };
1629
1630     self = self;
1631     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|l:wxImage_GetImageCount",_kwnames,&_obj0,&_arg1))
1632         return NULL;
1633 {
1634 #if PYTHON_API_VERSION >= 1009
1635     char* tmpPtr; int tmpSize;
1636     if (!PyString_Check(_obj0) && !PyUnicode_Check(_obj0)) {
1637         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1638         return NULL;
1639     }
1640     if (PyString_AsStringAndSize(_obj0, &tmpPtr, &tmpSize) == -1)
1641         return NULL;
1642     _arg0 = new wxString(tmpPtr, tmpSize);
1643 #else
1644     if (!PyString_Check(_obj0)) {
1645         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1646         return NULL;
1647     }
1648     _arg0 = new wxString(PyString_AS_STRING(_obj0), PyString_GET_SIZE(_obj0));
1649 #endif
1650 }
1651 {
1652     PyThreadState* __tstate = wxPyBeginAllowThreads();
1653         _result = (int )wxImage::GetImageCount(*_arg0,_arg1);
1654
1655     wxPyEndAllowThreads(__tstate);
1656     if (PyErr_Occurred()) return NULL;
1657 }    _resultobj = Py_BuildValue("i",_result);
1658 {
1659     if (_obj0)
1660         delete _arg0;
1661 }
1662     return _resultobj;
1663 }
1664
1665 #define wxImage_LoadFile(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->LoadFile(_swigarg0,_swigarg1,_swigarg2))
1666 static PyObject *_wrap_wxImage_LoadFile(PyObject *self, PyObject *args, PyObject *kwargs) {
1667     PyObject * _resultobj;
1668     bool  _result;
1669     wxImage * _arg0;
1670     wxString * _arg1;
1671     long  _arg2 = (long ) wxBITMAP_TYPE_ANY;
1672     int  _arg3 = (int ) -1;
1673     PyObject * _argo0 = 0;
1674     PyObject * _obj1 = 0;
1675     char *_kwnames[] = { "self","name","type","index", NULL };
1676
1677     self = self;
1678     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|li:wxImage_LoadFile",_kwnames,&_argo0,&_obj1,&_arg2,&_arg3))
1679         return NULL;
1680     if (_argo0) {
1681         if (_argo0 == Py_None) { _arg0 = NULL; }
1682         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1683             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_LoadFile. Expected _wxImage_p.");
1684         return NULL;
1685         }
1686     }
1687 {
1688 #if PYTHON_API_VERSION >= 1009
1689     char* tmpPtr; int tmpSize;
1690     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1691         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1692         return NULL;
1693     }
1694     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1695         return NULL;
1696     _arg1 = new wxString(tmpPtr, tmpSize);
1697 #else
1698     if (!PyString_Check(_obj1)) {
1699         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1700         return NULL;
1701     }
1702     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1703 #endif
1704 }
1705 {
1706     PyThreadState* __tstate = wxPyBeginAllowThreads();
1707         _result = (bool )wxImage_LoadFile(_arg0,*_arg1,_arg2,_arg3);
1708
1709     wxPyEndAllowThreads(__tstate);
1710     if (PyErr_Occurred()) return NULL;
1711 }    _resultobj = Py_BuildValue("i",_result);
1712 {
1713     if (_obj1)
1714         delete _arg1;
1715 }
1716     return _resultobj;
1717 }
1718
1719 #define wxImage_LoadMimeFile(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->LoadFile(_swigarg0,_swigarg1,_swigarg2))
1720 static PyObject *_wrap_wxImage_LoadMimeFile(PyObject *self, PyObject *args, PyObject *kwargs) {
1721     PyObject * _resultobj;
1722     bool  _result;
1723     wxImage * _arg0;
1724     wxString * _arg1;
1725     wxString * _arg2;
1726     int  _arg3 = (int ) -1;
1727     PyObject * _argo0 = 0;
1728     PyObject * _obj1 = 0;
1729     PyObject * _obj2 = 0;
1730     char *_kwnames[] = { "self","name","mimetype","index", NULL };
1731
1732     self = self;
1733     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO|i:wxImage_LoadMimeFile",_kwnames,&_argo0,&_obj1,&_obj2,&_arg3))
1734         return NULL;
1735     if (_argo0) {
1736         if (_argo0 == Py_None) { _arg0 = NULL; }
1737         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1738             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_LoadMimeFile. Expected _wxImage_p.");
1739         return NULL;
1740         }
1741     }
1742 {
1743 #if PYTHON_API_VERSION >= 1009
1744     char* tmpPtr; int tmpSize;
1745     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1746         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1747         return NULL;
1748     }
1749     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1750         return NULL;
1751     _arg1 = new wxString(tmpPtr, tmpSize);
1752 #else
1753     if (!PyString_Check(_obj1)) {
1754         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1755         return NULL;
1756     }
1757     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1758 #endif
1759 }
1760 {
1761 #if PYTHON_API_VERSION >= 1009
1762     char* tmpPtr; int tmpSize;
1763     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
1764         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1765         return NULL;
1766     }
1767     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
1768         return NULL;
1769     _arg2 = new wxString(tmpPtr, tmpSize);
1770 #else
1771     if (!PyString_Check(_obj2)) {
1772         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1773         return NULL;
1774     }
1775     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
1776 #endif
1777 }
1778 {
1779     PyThreadState* __tstate = wxPyBeginAllowThreads();
1780         _result = (bool )wxImage_LoadMimeFile(_arg0,*_arg1,*_arg2,_arg3);
1781
1782     wxPyEndAllowThreads(__tstate);
1783     if (PyErr_Occurred()) return NULL;
1784 }    _resultobj = Py_BuildValue("i",_result);
1785 {
1786     if (_obj1)
1787         delete _arg1;
1788 }
1789 {
1790     if (_obj2)
1791         delete _arg2;
1792 }
1793     return _resultobj;
1794 }
1795
1796 #define wxImage_SaveFile(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SaveFile(_swigarg0,_swigarg1))
1797 static PyObject *_wrap_wxImage_SaveFile(PyObject *self, PyObject *args, PyObject *kwargs) {
1798     PyObject * _resultobj;
1799     bool  _result;
1800     wxImage * _arg0;
1801     wxString * _arg1;
1802     int  _arg2;
1803     PyObject * _argo0 = 0;
1804     PyObject * _obj1 = 0;
1805     char *_kwnames[] = { "self","name","type", NULL };
1806
1807     self = self;
1808     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOi:wxImage_SaveFile",_kwnames,&_argo0,&_obj1,&_arg2))
1809         return NULL;
1810     if (_argo0) {
1811         if (_argo0 == Py_None) { _arg0 = NULL; }
1812         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1813             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SaveFile. Expected _wxImage_p.");
1814         return NULL;
1815         }
1816     }
1817 {
1818 #if PYTHON_API_VERSION >= 1009
1819     char* tmpPtr; int tmpSize;
1820     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1821         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1822         return NULL;
1823     }
1824     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1825         return NULL;
1826     _arg1 = new wxString(tmpPtr, tmpSize);
1827 #else
1828     if (!PyString_Check(_obj1)) {
1829         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1830         return NULL;
1831     }
1832     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1833 #endif
1834 }
1835 {
1836     PyThreadState* __tstate = wxPyBeginAllowThreads();
1837         _result = (bool )wxImage_SaveFile(_arg0,*_arg1,_arg2);
1838
1839     wxPyEndAllowThreads(__tstate);
1840     if (PyErr_Occurred()) return NULL;
1841 }    _resultobj = Py_BuildValue("i",_result);
1842 {
1843     if (_obj1)
1844         delete _arg1;
1845 }
1846     return _resultobj;
1847 }
1848
1849 #define wxImage_SaveMimeFile(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SaveFile(_swigarg0,_swigarg1))
1850 static PyObject *_wrap_wxImage_SaveMimeFile(PyObject *self, PyObject *args, PyObject *kwargs) {
1851     PyObject * _resultobj;
1852     bool  _result;
1853     wxImage * _arg0;
1854     wxString * _arg1;
1855     wxString * _arg2;
1856     PyObject * _argo0 = 0;
1857     PyObject * _obj1 = 0;
1858     PyObject * _obj2 = 0;
1859     char *_kwnames[] = { "self","name","mimetype", NULL };
1860
1861     self = self;
1862     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxImage_SaveMimeFile",_kwnames,&_argo0,&_obj1,&_obj2))
1863         return NULL;
1864     if (_argo0) {
1865         if (_argo0 == Py_None) { _arg0 = NULL; }
1866         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1867             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SaveMimeFile. Expected _wxImage_p.");
1868         return NULL;
1869         }
1870     }
1871 {
1872 #if PYTHON_API_VERSION >= 1009
1873     char* tmpPtr; int tmpSize;
1874     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1875         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1876         return NULL;
1877     }
1878     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1879         return NULL;
1880     _arg1 = new wxString(tmpPtr, tmpSize);
1881 #else
1882     if (!PyString_Check(_obj1)) {
1883         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1884         return NULL;
1885     }
1886     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1887 #endif
1888 }
1889 {
1890 #if PYTHON_API_VERSION >= 1009
1891     char* tmpPtr; int tmpSize;
1892     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
1893         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1894         return NULL;
1895     }
1896     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
1897         return NULL;
1898     _arg2 = new wxString(tmpPtr, tmpSize);
1899 #else
1900     if (!PyString_Check(_obj2)) {
1901         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1902         return NULL;
1903     }
1904     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
1905 #endif
1906 }
1907 {
1908     PyThreadState* __tstate = wxPyBeginAllowThreads();
1909         _result = (bool )wxImage_SaveMimeFile(_arg0,*_arg1,*_arg2);
1910
1911     wxPyEndAllowThreads(__tstate);
1912     if (PyErr_Occurred()) return NULL;
1913 }    _resultobj = Py_BuildValue("i",_result);
1914 {
1915     if (_obj1)
1916         delete _arg1;
1917 }
1918 {
1919     if (_obj2)
1920         delete _arg2;
1921 }
1922     return _resultobj;
1923 }
1924
1925 #define wxImage_Ok(_swigobj)  (_swigobj->Ok())
1926 static PyObject *_wrap_wxImage_Ok(PyObject *self, PyObject *args, PyObject *kwargs) {
1927     PyObject * _resultobj;
1928     bool  _result;
1929     wxImage * _arg0;
1930     PyObject * _argo0 = 0;
1931     char *_kwnames[] = { "self", NULL };
1932
1933     self = self;
1934     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_Ok",_kwnames,&_argo0))
1935         return NULL;
1936     if (_argo0) {
1937         if (_argo0 == Py_None) { _arg0 = NULL; }
1938         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1939             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Ok. Expected _wxImage_p.");
1940         return NULL;
1941         }
1942     }
1943 {
1944     PyThreadState* __tstate = wxPyBeginAllowThreads();
1945         _result = (bool )wxImage_Ok(_arg0);
1946
1947     wxPyEndAllowThreads(__tstate);
1948     if (PyErr_Occurred()) return NULL;
1949 }    _resultobj = Py_BuildValue("i",_result);
1950     return _resultobj;
1951 }
1952
1953 #define wxImage_GetWidth(_swigobj)  (_swigobj->GetWidth())
1954 static PyObject *_wrap_wxImage_GetWidth(PyObject *self, PyObject *args, PyObject *kwargs) {
1955     PyObject * _resultobj;
1956     int  _result;
1957     wxImage * _arg0;
1958     PyObject * _argo0 = 0;
1959     char *_kwnames[] = { "self", NULL };
1960
1961     self = self;
1962     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetWidth",_kwnames,&_argo0))
1963         return NULL;
1964     if (_argo0) {
1965         if (_argo0 == Py_None) { _arg0 = NULL; }
1966         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1967             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetWidth. Expected _wxImage_p.");
1968         return NULL;
1969         }
1970     }
1971 {
1972     PyThreadState* __tstate = wxPyBeginAllowThreads();
1973         _result = (int )wxImage_GetWidth(_arg0);
1974
1975     wxPyEndAllowThreads(__tstate);
1976     if (PyErr_Occurred()) return NULL;
1977 }    _resultobj = Py_BuildValue("i",_result);
1978     return _resultobj;
1979 }
1980
1981 #define wxImage_GetHeight(_swigobj)  (_swigobj->GetHeight())
1982 static PyObject *_wrap_wxImage_GetHeight(PyObject *self, PyObject *args, PyObject *kwargs) {
1983     PyObject * _resultobj;
1984     int  _result;
1985     wxImage * _arg0;
1986     PyObject * _argo0 = 0;
1987     char *_kwnames[] = { "self", NULL };
1988
1989     self = self;
1990     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetHeight",_kwnames,&_argo0))
1991         return NULL;
1992     if (_argo0) {
1993         if (_argo0 == Py_None) { _arg0 = NULL; }
1994         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1995             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetHeight. Expected _wxImage_p.");
1996         return NULL;
1997         }
1998     }
1999 {
2000     PyThreadState* __tstate = wxPyBeginAllowThreads();
2001         _result = (int )wxImage_GetHeight(_arg0);
2002
2003     wxPyEndAllowThreads(__tstate);
2004     if (PyErr_Occurred()) return NULL;
2005 }    _resultobj = Py_BuildValue("i",_result);
2006     return _resultobj;
2007 }
2008
2009 #define wxImage_GetSubImage(_swigobj,_swigarg0)  (_swigobj->GetSubImage(_swigarg0))
2010 static PyObject *_wrap_wxImage_GetSubImage(PyObject *self, PyObject *args, PyObject *kwargs) {
2011     PyObject * _resultobj;
2012     wxImage * _result;
2013     wxImage * _arg0;
2014     wxRect * _arg1;
2015     PyObject * _argo0 = 0;
2016     wxRect  temp;
2017     PyObject * _obj1 = 0;
2018     char *_kwnames[] = { "self","rect", NULL };
2019     char _ptemp[128];
2020
2021     self = self;
2022     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxImage_GetSubImage",_kwnames,&_argo0,&_obj1))
2023         return NULL;
2024     if (_argo0) {
2025         if (_argo0 == Py_None) { _arg0 = NULL; }
2026         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2027             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetSubImage. Expected _wxImage_p.");
2028         return NULL;
2029         }
2030     }
2031 {
2032     _arg1 = &temp;
2033     if (! wxRect_helper(_obj1, &_arg1))
2034         return NULL;
2035 }
2036 {
2037     PyThreadState* __tstate = wxPyBeginAllowThreads();
2038         _result = new wxImage (wxImage_GetSubImage(_arg0,*_arg1));
2039
2040     wxPyEndAllowThreads(__tstate);
2041     if (PyErr_Occurred()) return NULL;
2042 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p");
2043     _resultobj = Py_BuildValue("s",_ptemp);
2044     return _resultobj;
2045 }
2046
2047 #define wxImage_Copy(_swigobj)  (_swigobj->Copy())
2048 static PyObject *_wrap_wxImage_Copy(PyObject *self, PyObject *args, PyObject *kwargs) {
2049     PyObject * _resultobj;
2050     wxImage * _result;
2051     wxImage * _arg0;
2052     PyObject * _argo0 = 0;
2053     char *_kwnames[] = { "self", NULL };
2054     char _ptemp[128];
2055
2056     self = self;
2057     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_Copy",_kwnames,&_argo0))
2058         return NULL;
2059     if (_argo0) {
2060         if (_argo0 == Py_None) { _arg0 = NULL; }
2061         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2062             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Copy. Expected _wxImage_p.");
2063         return NULL;
2064         }
2065     }
2066 {
2067     PyThreadState* __tstate = wxPyBeginAllowThreads();
2068         _result = new wxImage (wxImage_Copy(_arg0));
2069
2070     wxPyEndAllowThreads(__tstate);
2071     if (PyErr_Occurred()) return NULL;
2072 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p");
2073     _resultobj = Py_BuildValue("s",_ptemp);
2074     return _resultobj;
2075 }
2076
2077 #define wxImage_Paste(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->Paste(_swigarg0,_swigarg1,_swigarg2))
2078 static PyObject *_wrap_wxImage_Paste(PyObject *self, PyObject *args, PyObject *kwargs) {
2079     PyObject * _resultobj;
2080     wxImage * _arg0;
2081     wxImage * _arg1;
2082     int  _arg2;
2083     int  _arg3;
2084     PyObject * _argo0 = 0;
2085     PyObject * _argo1 = 0;
2086     char *_kwnames[] = { "self","image","x","y", NULL };
2087
2088     self = self;
2089     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOii:wxImage_Paste",_kwnames,&_argo0,&_argo1,&_arg2,&_arg3))
2090         return NULL;
2091     if (_argo0) {
2092         if (_argo0 == Py_None) { _arg0 = NULL; }
2093         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2094             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Paste. Expected _wxImage_p.");
2095         return NULL;
2096         }
2097     }
2098     if (_argo1) {
2099         if (_argo1 == Py_None) { _arg1 = NULL; }
2100         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxImage_p")) {
2101             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxImage_Paste. Expected _wxImage_p.");
2102         return NULL;
2103         }
2104     }
2105 {
2106     PyThreadState* __tstate = wxPyBeginAllowThreads();
2107         wxImage_Paste(_arg0,*_arg1,_arg2,_arg3);
2108
2109     wxPyEndAllowThreads(__tstate);
2110     if (PyErr_Occurred()) return NULL;
2111 }    Py_INCREF(Py_None);
2112     _resultobj = Py_None;
2113     return _resultobj;
2114 }
2115
2116 static PyObject * wxImage_GetData(wxImage *self) {
2117             unsigned char* data = self->GetData();
2118             int len = self->GetWidth() * self->GetHeight() * 3;
2119             return PyString_FromStringAndSize((char*)data, len);
2120         }
2121 static PyObject *_wrap_wxImage_GetData(PyObject *self, PyObject *args, PyObject *kwargs) {
2122     PyObject * _resultobj;
2123     PyObject * _result;
2124     wxImage * _arg0;
2125     PyObject * _argo0 = 0;
2126     char *_kwnames[] = { "self", NULL };
2127
2128     self = self;
2129     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetData",_kwnames,&_argo0))
2130         return NULL;
2131     if (_argo0) {
2132         if (_argo0 == Py_None) { _arg0 = NULL; }
2133         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2134             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetData. Expected _wxImage_p.");
2135         return NULL;
2136         }
2137     }
2138 {
2139     PyThreadState* __tstate = wxPyBeginAllowThreads();
2140         _result = (PyObject *)wxImage_GetData(_arg0);
2141
2142     wxPyEndAllowThreads(__tstate);
2143     if (PyErr_Occurred()) return NULL;
2144 }{
2145   _resultobj = _result;
2146 }
2147     return _resultobj;
2148 }
2149
2150 static void  wxImage_SetData(wxImage *self,PyObject * data) {
2151             unsigned char* dataPtr;
2152
2153             if (! PyString_Check(data)) {
2154                 PyErr_SetString(PyExc_TypeError, "Expected string object");
2155                 return /* NULL */ ;
2156             }
2157
2158             size_t len = self->GetWidth() * self->GetHeight() * 3;
2159             dataPtr = (unsigned char*) malloc(len);
2160             memcpy(dataPtr, PyString_AsString(data), len);
2161             self->SetData(dataPtr);
2162         }
2163 static PyObject *_wrap_wxImage_SetData(PyObject *self, PyObject *args, PyObject *kwargs) {
2164     PyObject * _resultobj;
2165     wxImage * _arg0;
2166     PyObject * _arg1;
2167     PyObject * _argo0 = 0;
2168     PyObject * _obj1 = 0;
2169     char *_kwnames[] = { "self","data", NULL };
2170
2171     self = self;
2172     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxImage_SetData",_kwnames,&_argo0,&_obj1))
2173         return NULL;
2174     if (_argo0) {
2175         if (_argo0 == Py_None) { _arg0 = NULL; }
2176         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2177             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetData. Expected _wxImage_p.");
2178         return NULL;
2179         }
2180     }
2181 {
2182   _arg1 = _obj1;
2183 }
2184 {
2185     PyThreadState* __tstate = wxPyBeginAllowThreads();
2186         wxImage_SetData(_arg0,_arg1);
2187
2188     wxPyEndAllowThreads(__tstate);
2189     if (PyErr_Occurred()) return NULL;
2190 }    Py_INCREF(Py_None);
2191     _resultobj = Py_None;
2192     return _resultobj;
2193 }
2194
2195 #define wxImage_SetMaskColour(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetMaskColour(_swigarg0,_swigarg1,_swigarg2))
2196 static PyObject *_wrap_wxImage_SetMaskColour(PyObject *self, PyObject *args, PyObject *kwargs) {
2197     PyObject * _resultobj;
2198     wxImage * _arg0;
2199     unsigned char  _arg1;
2200     unsigned char  _arg2;
2201     unsigned char  _arg3;
2202     PyObject * _argo0 = 0;
2203     char *_kwnames[] = { "self","r","g","b", NULL };
2204
2205     self = self;
2206     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Obbb:wxImage_SetMaskColour",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3))
2207         return NULL;
2208     if (_argo0) {
2209         if (_argo0 == Py_None) { _arg0 = NULL; }
2210         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2211             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetMaskColour. Expected _wxImage_p.");
2212         return NULL;
2213         }
2214     }
2215 {
2216     PyThreadState* __tstate = wxPyBeginAllowThreads();
2217         wxImage_SetMaskColour(_arg0,_arg1,_arg2,_arg3);
2218
2219     wxPyEndAllowThreads(__tstate);
2220     if (PyErr_Occurred()) return NULL;
2221 }    Py_INCREF(Py_None);
2222     _resultobj = Py_None;
2223     return _resultobj;
2224 }
2225
2226 #define wxImage_GetMaskRed(_swigobj)  (_swigobj->GetMaskRed())
2227 static PyObject *_wrap_wxImage_GetMaskRed(PyObject *self, PyObject *args, PyObject *kwargs) {
2228     PyObject * _resultobj;
2229     unsigned char  _result;
2230     wxImage * _arg0;
2231     PyObject * _argo0 = 0;
2232     char *_kwnames[] = { "self", NULL };
2233
2234     self = self;
2235     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetMaskRed",_kwnames,&_argo0))
2236         return NULL;
2237     if (_argo0) {
2238         if (_argo0 == Py_None) { _arg0 = NULL; }
2239         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2240             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetMaskRed. Expected _wxImage_p.");
2241         return NULL;
2242         }
2243     }
2244 {
2245     PyThreadState* __tstate = wxPyBeginAllowThreads();
2246         _result = (unsigned char )wxImage_GetMaskRed(_arg0);
2247
2248     wxPyEndAllowThreads(__tstate);
2249     if (PyErr_Occurred()) return NULL;
2250 }    _resultobj = Py_BuildValue("b",_result);
2251     return _resultobj;
2252 }
2253
2254 #define wxImage_GetMaskGreen(_swigobj)  (_swigobj->GetMaskGreen())
2255 static PyObject *_wrap_wxImage_GetMaskGreen(PyObject *self, PyObject *args, PyObject *kwargs) {
2256     PyObject * _resultobj;
2257     unsigned char  _result;
2258     wxImage * _arg0;
2259     PyObject * _argo0 = 0;
2260     char *_kwnames[] = { "self", NULL };
2261
2262     self = self;
2263     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetMaskGreen",_kwnames,&_argo0))
2264         return NULL;
2265     if (_argo0) {
2266         if (_argo0 == Py_None) { _arg0 = NULL; }
2267         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2268             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetMaskGreen. Expected _wxImage_p.");
2269         return NULL;
2270         }
2271     }
2272 {
2273     PyThreadState* __tstate = wxPyBeginAllowThreads();
2274         _result = (unsigned char )wxImage_GetMaskGreen(_arg0);
2275
2276     wxPyEndAllowThreads(__tstate);
2277     if (PyErr_Occurred()) return NULL;
2278 }    _resultobj = Py_BuildValue("b",_result);
2279     return _resultobj;
2280 }
2281
2282 #define wxImage_GetMaskBlue(_swigobj)  (_swigobj->GetMaskBlue())
2283 static PyObject *_wrap_wxImage_GetMaskBlue(PyObject *self, PyObject *args, PyObject *kwargs) {
2284     PyObject * _resultobj;
2285     unsigned char  _result;
2286     wxImage * _arg0;
2287     PyObject * _argo0 = 0;
2288     char *_kwnames[] = { "self", NULL };
2289
2290     self = self;
2291     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetMaskBlue",_kwnames,&_argo0))
2292         return NULL;
2293     if (_argo0) {
2294         if (_argo0 == Py_None) { _arg0 = NULL; }
2295         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2296             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetMaskBlue. Expected _wxImage_p.");
2297         return NULL;
2298         }
2299     }
2300 {
2301     PyThreadState* __tstate = wxPyBeginAllowThreads();
2302         _result = (unsigned char )wxImage_GetMaskBlue(_arg0);
2303
2304     wxPyEndAllowThreads(__tstate);
2305     if (PyErr_Occurred()) return NULL;
2306 }    _resultobj = Py_BuildValue("b",_result);
2307     return _resultobj;
2308 }
2309
2310 #define wxImage_SetMask(_swigobj,_swigarg0)  (_swigobj->SetMask(_swigarg0))
2311 static PyObject *_wrap_wxImage_SetMask(PyObject *self, PyObject *args, PyObject *kwargs) {
2312     PyObject * _resultobj;
2313     wxImage * _arg0;
2314     bool  _arg1 = (bool ) TRUE;
2315     PyObject * _argo0 = 0;
2316     int tempbool1 = (int) TRUE;
2317     char *_kwnames[] = { "self","mask", NULL };
2318
2319     self = self;
2320     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxImage_SetMask",_kwnames,&_argo0,&tempbool1))
2321         return NULL;
2322     if (_argo0) {
2323         if (_argo0 == Py_None) { _arg0 = NULL; }
2324         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2325             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetMask. Expected _wxImage_p.");
2326         return NULL;
2327         }
2328     }
2329     _arg1 = (bool ) tempbool1;
2330 {
2331     PyThreadState* __tstate = wxPyBeginAllowThreads();
2332         wxImage_SetMask(_arg0,_arg1);
2333
2334     wxPyEndAllowThreads(__tstate);
2335     if (PyErr_Occurred()) return NULL;
2336 }    Py_INCREF(Py_None);
2337     _resultobj = Py_None;
2338     return _resultobj;
2339 }
2340
2341 #define wxImage_HasMask(_swigobj)  (_swigobj->HasMask())
2342 static PyObject *_wrap_wxImage_HasMask(PyObject *self, PyObject *args, PyObject *kwargs) {
2343     PyObject * _resultobj;
2344     bool  _result;
2345     wxImage * _arg0;
2346     PyObject * _argo0 = 0;
2347     char *_kwnames[] = { "self", NULL };
2348
2349     self = self;
2350     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_HasMask",_kwnames,&_argo0))
2351         return NULL;
2352     if (_argo0) {
2353         if (_argo0 == Py_None) { _arg0 = NULL; }
2354         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2355             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_HasMask. Expected _wxImage_p.");
2356         return NULL;
2357         }
2358     }
2359 {
2360     PyThreadState* __tstate = wxPyBeginAllowThreads();
2361         _result = (bool )wxImage_HasMask(_arg0);
2362
2363     wxPyEndAllowThreads(__tstate);
2364     if (PyErr_Occurred()) return NULL;
2365 }    _resultobj = Py_BuildValue("i",_result);
2366     return _resultobj;
2367 }
2368
2369 #define wxImage_Rotate(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3)  (_swigobj->Rotate(_swigarg0,_swigarg1,_swigarg2,_swigarg3))
2370 static PyObject *_wrap_wxImage_Rotate(PyObject *self, PyObject *args, PyObject *kwargs) {
2371     PyObject * _resultobj;
2372     wxImage * _result;
2373     wxImage * _arg0;
2374     double  _arg1;
2375     wxPoint * _arg2;
2376     bool  _arg3 = (bool ) TRUE;
2377     wxPoint * _arg4 = (wxPoint *) NULL;
2378     PyObject * _argo0 = 0;
2379     wxPoint  temp;
2380     PyObject * _obj2 = 0;
2381     int tempbool3 = (int) TRUE;
2382     wxPoint  temp0;
2383     PyObject * _obj4 = 0;
2384     char *_kwnames[] = { "self","angle","centre_of_rotation","interpolating","offset_after_rotation", NULL };
2385     char _ptemp[128];
2386
2387     self = self;
2388     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OdO|iO:wxImage_Rotate",_kwnames,&_argo0,&_arg1,&_obj2,&tempbool3,&_obj4))
2389         return NULL;
2390     if (_argo0) {
2391         if (_argo0 == Py_None) { _arg0 = NULL; }
2392         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2393             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Rotate. Expected _wxImage_p.");
2394         return NULL;
2395         }
2396     }
2397 {
2398     _arg2 = &temp;
2399     if (! wxPoint_helper(_obj2, &_arg2))
2400         return NULL;
2401 }
2402     _arg3 = (bool ) tempbool3;
2403     if (_obj4)
2404 {
2405     _arg4 = &temp0;
2406     if (! wxPoint_helper(_obj4, &_arg4))
2407         return NULL;
2408 }
2409 {
2410     PyThreadState* __tstate = wxPyBeginAllowThreads();
2411         _result = new wxImage (wxImage_Rotate(_arg0,_arg1,*_arg2,_arg3,_arg4));
2412
2413     wxPyEndAllowThreads(__tstate);
2414     if (PyErr_Occurred()) return NULL;
2415 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p");
2416     _resultobj = Py_BuildValue("s",_ptemp);
2417     return _resultobj;
2418 }
2419
2420 #define wxImage_Rotate90(_swigobj,_swigarg0)  (_swigobj->Rotate90(_swigarg0))
2421 static PyObject *_wrap_wxImage_Rotate90(PyObject *self, PyObject *args, PyObject *kwargs) {
2422     PyObject * _resultobj;
2423     wxImage * _result;
2424     wxImage * _arg0;
2425     bool  _arg1 = (bool ) TRUE;
2426     PyObject * _argo0 = 0;
2427     int tempbool1 = (int) TRUE;
2428     char *_kwnames[] = { "self","clockwise", NULL };
2429     char _ptemp[128];
2430
2431     self = self;
2432     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxImage_Rotate90",_kwnames,&_argo0,&tempbool1))
2433         return NULL;
2434     if (_argo0) {
2435         if (_argo0 == Py_None) { _arg0 = NULL; }
2436         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2437             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Rotate90. Expected _wxImage_p.");
2438         return NULL;
2439         }
2440     }
2441     _arg1 = (bool ) tempbool1;
2442 {
2443     PyThreadState* __tstate = wxPyBeginAllowThreads();
2444         _result = new wxImage (wxImage_Rotate90(_arg0,_arg1));
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_Mirror(_swigobj,_swigarg0)  (_swigobj->Mirror(_swigarg0))
2454 static PyObject *_wrap_wxImage_Mirror(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","horizontally", NULL };
2462     char _ptemp[128];
2463
2464     self = self;
2465     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxImage_Mirror",_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_Mirror. Expected _wxImage_p.");
2471         return NULL;
2472         }
2473     }
2474     _arg1 = (bool ) tempbool1;
2475 {
2476     PyThreadState* __tstate = wxPyBeginAllowThreads();
2477         _result = new wxImage (wxImage_Mirror(_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_Replace(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5)  (_swigobj->Replace(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5))
2487 static PyObject *_wrap_wxImage_Replace(PyObject *self, PyObject *args, PyObject *kwargs) {
2488     PyObject * _resultobj;
2489     wxImage * _arg0;
2490     unsigned char  _arg1;
2491     unsigned char  _arg2;
2492     unsigned char  _arg3;
2493     unsigned char  _arg4;
2494     unsigned char  _arg5;
2495     unsigned char  _arg6;
2496     PyObject * _argo0 = 0;
2497     char *_kwnames[] = { "self","r1","g1","b1","r2","g2","b2", NULL };
2498
2499     self = self;
2500     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Obbbbbb:wxImage_Replace",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_arg6))
2501         return NULL;
2502     if (_argo0) {
2503         if (_argo0 == Py_None) { _arg0 = NULL; }
2504         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2505             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Replace. Expected _wxImage_p.");
2506         return NULL;
2507         }
2508     }
2509 {
2510     PyThreadState* __tstate = wxPyBeginAllowThreads();
2511         wxImage_Replace(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6);
2512
2513     wxPyEndAllowThreads(__tstate);
2514     if (PyErr_Occurred()) return NULL;
2515 }    Py_INCREF(Py_None);
2516     _resultobj = Py_None;
2517     return _resultobj;
2518 }
2519
2520 #define wxImage_ConvertToMono(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->ConvertToMono(_swigarg0,_swigarg1,_swigarg2))
2521 static PyObject *_wrap_wxImage_ConvertToMono(PyObject *self, PyObject *args, PyObject *kwargs) {
2522     PyObject * _resultobj;
2523     wxImage * _result;
2524     wxImage * _arg0;
2525     unsigned char  _arg1;
2526     unsigned char  _arg2;
2527     unsigned char  _arg3;
2528     PyObject * _argo0 = 0;
2529     char *_kwnames[] = { "self","r","g","b", NULL };
2530     char _ptemp[128];
2531
2532     self = self;
2533     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Obbb:wxImage_ConvertToMono",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3))
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_ConvertToMono. Expected _wxImage_p.");
2539         return NULL;
2540         }
2541     }
2542 {
2543     PyThreadState* __tstate = wxPyBeginAllowThreads();
2544         _result = new wxImage (wxImage_ConvertToMono(_arg0,_arg1,_arg2,_arg3));
2545
2546     wxPyEndAllowThreads(__tstate);
2547     if (PyErr_Occurred()) return NULL;
2548 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p");
2549     _resultobj = Py_BuildValue("s",_ptemp);
2550     return _resultobj;
2551 }
2552
2553 #define wxImage_SetOption(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetOption(_swigarg0,_swigarg1))
2554 static PyObject *_wrap_wxImage_SetOption(PyObject *self, PyObject *args, PyObject *kwargs) {
2555     PyObject * _resultobj;
2556     wxImage * _arg0;
2557     wxString * _arg1;
2558     wxString * _arg2;
2559     PyObject * _argo0 = 0;
2560     PyObject * _obj1 = 0;
2561     PyObject * _obj2 = 0;
2562     char *_kwnames[] = { "self","name","value", NULL };
2563
2564     self = self;
2565     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxImage_SetOption",_kwnames,&_argo0,&_obj1,&_obj2))
2566         return NULL;
2567     if (_argo0) {
2568         if (_argo0 == Py_None) { _arg0 = NULL; }
2569         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2570             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetOption. Expected _wxImage_p.");
2571         return NULL;
2572         }
2573     }
2574 {
2575 #if PYTHON_API_VERSION >= 1009
2576     char* tmpPtr; int tmpSize;
2577     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
2578         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2579         return NULL;
2580     }
2581     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
2582         return NULL;
2583     _arg1 = new wxString(tmpPtr, tmpSize);
2584 #else
2585     if (!PyString_Check(_obj1)) {
2586         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2587         return NULL;
2588     }
2589     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
2590 #endif
2591 }
2592 {
2593 #if PYTHON_API_VERSION >= 1009
2594     char* tmpPtr; int tmpSize;
2595     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
2596         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2597         return NULL;
2598     }
2599     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
2600         return NULL;
2601     _arg2 = new wxString(tmpPtr, tmpSize);
2602 #else
2603     if (!PyString_Check(_obj2)) {
2604         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2605         return NULL;
2606     }
2607     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
2608 #endif
2609 }
2610 {
2611     PyThreadState* __tstate = wxPyBeginAllowThreads();
2612         wxImage_SetOption(_arg0,*_arg1,*_arg2);
2613
2614     wxPyEndAllowThreads(__tstate);
2615     if (PyErr_Occurred()) return NULL;
2616 }    Py_INCREF(Py_None);
2617     _resultobj = Py_None;
2618 {
2619     if (_obj1)
2620         delete _arg1;
2621 }
2622 {
2623     if (_obj2)
2624         delete _arg2;
2625 }
2626     return _resultobj;
2627 }
2628
2629 #define wxImage_SetOptionInt(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetOption(_swigarg0,_swigarg1))
2630 static PyObject *_wrap_wxImage_SetOptionInt(PyObject *self, PyObject *args, PyObject *kwargs) {
2631     PyObject * _resultobj;
2632     wxImage * _arg0;
2633     wxString * _arg1;
2634     int  _arg2;
2635     PyObject * _argo0 = 0;
2636     PyObject * _obj1 = 0;
2637     char *_kwnames[] = { "self","name","value", NULL };
2638
2639     self = self;
2640     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOi:wxImage_SetOptionInt",_kwnames,&_argo0,&_obj1,&_arg2))
2641         return NULL;
2642     if (_argo0) {
2643         if (_argo0 == Py_None) { _arg0 = NULL; }
2644         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2645             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetOptionInt. Expected _wxImage_p.");
2646         return NULL;
2647         }
2648     }
2649 {
2650 #if PYTHON_API_VERSION >= 1009
2651     char* tmpPtr; int tmpSize;
2652     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
2653         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2654         return NULL;
2655     }
2656     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
2657         return NULL;
2658     _arg1 = new wxString(tmpPtr, tmpSize);
2659 #else
2660     if (!PyString_Check(_obj1)) {
2661         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2662         return NULL;
2663     }
2664     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
2665 #endif
2666 }
2667 {
2668     PyThreadState* __tstate = wxPyBeginAllowThreads();
2669         wxImage_SetOptionInt(_arg0,*_arg1,_arg2);
2670
2671     wxPyEndAllowThreads(__tstate);
2672     if (PyErr_Occurred()) return NULL;
2673 }    Py_INCREF(Py_None);
2674     _resultobj = Py_None;
2675 {
2676     if (_obj1)
2677         delete _arg1;
2678 }
2679     return _resultobj;
2680 }
2681
2682 #define wxImage_GetOption(_swigobj,_swigarg0)  (_swigobj->GetOption(_swigarg0))
2683 static PyObject *_wrap_wxImage_GetOption(PyObject *self, PyObject *args, PyObject *kwargs) {
2684     PyObject * _resultobj;
2685     wxString * _result;
2686     wxImage * _arg0;
2687     wxString * _arg1;
2688     PyObject * _argo0 = 0;
2689     PyObject * _obj1 = 0;
2690     char *_kwnames[] = { "self","name", NULL };
2691
2692     self = self;
2693     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxImage_GetOption",_kwnames,&_argo0,&_obj1))
2694         return NULL;
2695     if (_argo0) {
2696         if (_argo0 == Py_None) { _arg0 = NULL; }
2697         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2698             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetOption. Expected _wxImage_p.");
2699         return NULL;
2700         }
2701     }
2702 {
2703 #if PYTHON_API_VERSION >= 1009
2704     char* tmpPtr; int tmpSize;
2705     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
2706         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2707         return NULL;
2708     }
2709     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
2710         return NULL;
2711     _arg1 = new wxString(tmpPtr, tmpSize);
2712 #else
2713     if (!PyString_Check(_obj1)) {
2714         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2715         return NULL;
2716     }
2717     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
2718 #endif
2719 }
2720 {
2721     PyThreadState* __tstate = wxPyBeginAllowThreads();
2722         _result = new wxString (wxImage_GetOption(_arg0,*_arg1));
2723
2724     wxPyEndAllowThreads(__tstate);
2725     if (PyErr_Occurred()) return NULL;
2726 }{
2727     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
2728 }
2729 {
2730     if (_obj1)
2731         delete _arg1;
2732 }
2733 {
2734     delete _result;
2735 }
2736     return _resultobj;
2737 }
2738
2739 #define wxImage_GetOptionInt(_swigobj,_swigarg0)  (_swigobj->GetOptionInt(_swigarg0))
2740 static PyObject *_wrap_wxImage_GetOptionInt(PyObject *self, PyObject *args, PyObject *kwargs) {
2741     PyObject * _resultobj;
2742     int  _result;
2743     wxImage * _arg0;
2744     wxString * _arg1;
2745     PyObject * _argo0 = 0;
2746     PyObject * _obj1 = 0;
2747     char *_kwnames[] = { "self","name", NULL };
2748
2749     self = self;
2750     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxImage_GetOptionInt",_kwnames,&_argo0,&_obj1))
2751         return NULL;
2752     if (_argo0) {
2753         if (_argo0 == Py_None) { _arg0 = NULL; }
2754         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2755             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetOptionInt. Expected _wxImage_p.");
2756         return NULL;
2757         }
2758     }
2759 {
2760 #if PYTHON_API_VERSION >= 1009
2761     char* tmpPtr; int tmpSize;
2762     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
2763         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2764         return NULL;
2765     }
2766     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
2767         return NULL;
2768     _arg1 = new wxString(tmpPtr, tmpSize);
2769 #else
2770     if (!PyString_Check(_obj1)) {
2771         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2772         return NULL;
2773     }
2774     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
2775 #endif
2776 }
2777 {
2778     PyThreadState* __tstate = wxPyBeginAllowThreads();
2779         _result = (int )wxImage_GetOptionInt(_arg0,*_arg1);
2780
2781     wxPyEndAllowThreads(__tstate);
2782     if (PyErr_Occurred()) return NULL;
2783 }    _resultobj = Py_BuildValue("i",_result);
2784 {
2785     if (_obj1)
2786         delete _arg1;
2787 }
2788     return _resultobj;
2789 }
2790
2791 #define wxImage_HasOption(_swigobj,_swigarg0)  (_swigobj->HasOption(_swigarg0))
2792 static PyObject *_wrap_wxImage_HasOption(PyObject *self, PyObject *args, PyObject *kwargs) {
2793     PyObject * _resultobj;
2794     bool  _result;
2795     wxImage * _arg0;
2796     wxString * _arg1;
2797     PyObject * _argo0 = 0;
2798     PyObject * _obj1 = 0;
2799     char *_kwnames[] = { "self","name", NULL };
2800
2801     self = self;
2802     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxImage_HasOption",_kwnames,&_argo0,&_obj1))
2803         return NULL;
2804     if (_argo0) {
2805         if (_argo0 == Py_None) { _arg0 = NULL; }
2806         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2807             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_HasOption. Expected _wxImage_p.");
2808         return NULL;
2809         }
2810     }
2811 {
2812 #if PYTHON_API_VERSION >= 1009
2813     char* tmpPtr; int tmpSize;
2814     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
2815         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2816         return NULL;
2817     }
2818     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
2819         return NULL;
2820     _arg1 = new wxString(tmpPtr, tmpSize);
2821 #else
2822     if (!PyString_Check(_obj1)) {
2823         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2824         return NULL;
2825     }
2826     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
2827 #endif
2828 }
2829 {
2830     PyThreadState* __tstate = wxPyBeginAllowThreads();
2831         _result = (bool )wxImage_HasOption(_arg0,*_arg1);
2832
2833     wxPyEndAllowThreads(__tstate);
2834     if (PyErr_Occurred()) return NULL;
2835 }    _resultobj = Py_BuildValue("i",_result);
2836 {
2837     if (_obj1)
2838         delete _arg1;
2839 }
2840     return _resultobj;
2841 }
2842
2843 #define wxImage_CountColours(_swigobj,_swigarg0)  (_swigobj->CountColours(_swigarg0))
2844 static PyObject *_wrap_wxImage_CountColours(PyObject *self, PyObject *args, PyObject *kwargs) {
2845     PyObject * _resultobj;
2846     unsigned long  _result;
2847     wxImage * _arg0;
2848     unsigned long  _arg1 = (unsigned long ) (unsigned long)-1;
2849     PyObject * _argo0 = 0;
2850     char *_kwnames[] = { "self","stopafter", NULL };
2851
2852     self = self;
2853     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|l:wxImage_CountColours",_kwnames,&_argo0,&_arg1))
2854         return NULL;
2855     if (_argo0) {
2856         if (_argo0 == Py_None) { _arg0 = NULL; }
2857         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2858             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_CountColours. Expected _wxImage_p.");
2859         return NULL;
2860         }
2861     }
2862 {
2863     PyThreadState* __tstate = wxPyBeginAllowThreads();
2864         _result = (unsigned long )wxImage_CountColours(_arg0,_arg1);
2865
2866     wxPyEndAllowThreads(__tstate);
2867     if (PyErr_Occurred()) return NULL;
2868 }    _resultobj = Py_BuildValue("l",_result);
2869     return _resultobj;
2870 }
2871
2872 static PyObject *_wrap_wxImage_AddHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
2873     PyObject * _resultobj;
2874     wxImageHandler * _arg0;
2875     PyObject * _argo0 = 0;
2876     char *_kwnames[] = { "handler", NULL };
2877
2878     self = self;
2879     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_AddHandler",_kwnames,&_argo0))
2880         return NULL;
2881     if (_argo0) {
2882         if (_argo0 == Py_None) { _arg0 = NULL; }
2883         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImageHandler_p")) {
2884             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_AddHandler. Expected _wxImageHandler_p.");
2885         return NULL;
2886         }
2887     }
2888 {
2889     PyThreadState* __tstate = wxPyBeginAllowThreads();
2890         wxImage::AddHandler(_arg0);
2891
2892     wxPyEndAllowThreads(__tstate);
2893     if (PyErr_Occurred()) return NULL;
2894 }    Py_INCREF(Py_None);
2895     _resultobj = Py_None;
2896     return _resultobj;
2897 }
2898
2899 static PyObject *_wrap_wxImage_InsertHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
2900     PyObject * _resultobj;
2901     wxImageHandler * _arg0;
2902     PyObject * _argo0 = 0;
2903     char *_kwnames[] = { "handler", NULL };
2904
2905     self = self;
2906     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_InsertHandler",_kwnames,&_argo0))
2907         return NULL;
2908     if (_argo0) {
2909         if (_argo0 == Py_None) { _arg0 = NULL; }
2910         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImageHandler_p")) {
2911             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_InsertHandler. Expected _wxImageHandler_p.");
2912         return NULL;
2913         }
2914     }
2915 {
2916     PyThreadState* __tstate = wxPyBeginAllowThreads();
2917         wxImage::InsertHandler(_arg0);
2918
2919     wxPyEndAllowThreads(__tstate);
2920     if (PyErr_Occurred()) return NULL;
2921 }    Py_INCREF(Py_None);
2922     _resultobj = Py_None;
2923     return _resultobj;
2924 }
2925
2926 static PyObject *_wrap_wxImage_RemoveHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
2927     PyObject * _resultobj;
2928     bool  _result;
2929     wxString * _arg0;
2930     PyObject * _obj0 = 0;
2931     char *_kwnames[] = { "name", NULL };
2932
2933     self = self;
2934     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_RemoveHandler",_kwnames,&_obj0))
2935         return NULL;
2936 {
2937 #if PYTHON_API_VERSION >= 1009
2938     char* tmpPtr; int tmpSize;
2939     if (!PyString_Check(_obj0) && !PyUnicode_Check(_obj0)) {
2940         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2941         return NULL;
2942     }
2943     if (PyString_AsStringAndSize(_obj0, &tmpPtr, &tmpSize) == -1)
2944         return NULL;
2945     _arg0 = new wxString(tmpPtr, tmpSize);
2946 #else
2947     if (!PyString_Check(_obj0)) {
2948         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2949         return NULL;
2950     }
2951     _arg0 = new wxString(PyString_AS_STRING(_obj0), PyString_GET_SIZE(_obj0));
2952 #endif
2953 }
2954 {
2955     PyThreadState* __tstate = wxPyBeginAllowThreads();
2956         _result = (bool )wxImage::RemoveHandler(*_arg0);
2957
2958     wxPyEndAllowThreads(__tstate);
2959     if (PyErr_Occurred()) return NULL;
2960 }    _resultobj = Py_BuildValue("i",_result);
2961 {
2962     if (_obj0)
2963         delete _arg0;
2964 }
2965     return _resultobj;
2966 }
2967
2968 static PyMethodDef imagecMethods[] = {
2969          { "wxImage_RemoveHandler", (PyCFunction) _wrap_wxImage_RemoveHandler, METH_VARARGS | METH_KEYWORDS },
2970          { "wxImage_InsertHandler", (PyCFunction) _wrap_wxImage_InsertHandler, METH_VARARGS | METH_KEYWORDS },
2971          { "wxImage_AddHandler", (PyCFunction) _wrap_wxImage_AddHandler, METH_VARARGS | METH_KEYWORDS },
2972          { "wxImage_CountColours", (PyCFunction) _wrap_wxImage_CountColours, METH_VARARGS | METH_KEYWORDS },
2973          { "wxImage_HasOption", (PyCFunction) _wrap_wxImage_HasOption, METH_VARARGS | METH_KEYWORDS },
2974          { "wxImage_GetOptionInt", (PyCFunction) _wrap_wxImage_GetOptionInt, METH_VARARGS | METH_KEYWORDS },
2975          { "wxImage_GetOption", (PyCFunction) _wrap_wxImage_GetOption, METH_VARARGS | METH_KEYWORDS },
2976          { "wxImage_SetOptionInt", (PyCFunction) _wrap_wxImage_SetOptionInt, METH_VARARGS | METH_KEYWORDS },
2977          { "wxImage_SetOption", (PyCFunction) _wrap_wxImage_SetOption, METH_VARARGS | METH_KEYWORDS },
2978          { "wxImage_ConvertToMono", (PyCFunction) _wrap_wxImage_ConvertToMono, METH_VARARGS | METH_KEYWORDS },
2979          { "wxImage_Replace", (PyCFunction) _wrap_wxImage_Replace, METH_VARARGS | METH_KEYWORDS },
2980          { "wxImage_Mirror", (PyCFunction) _wrap_wxImage_Mirror, METH_VARARGS | METH_KEYWORDS },
2981          { "wxImage_Rotate90", (PyCFunction) _wrap_wxImage_Rotate90, METH_VARARGS | METH_KEYWORDS },
2982          { "wxImage_Rotate", (PyCFunction) _wrap_wxImage_Rotate, METH_VARARGS | METH_KEYWORDS },
2983          { "wxImage_HasMask", (PyCFunction) _wrap_wxImage_HasMask, METH_VARARGS | METH_KEYWORDS },
2984          { "wxImage_SetMask", (PyCFunction) _wrap_wxImage_SetMask, METH_VARARGS | METH_KEYWORDS },
2985          { "wxImage_GetMaskBlue", (PyCFunction) _wrap_wxImage_GetMaskBlue, METH_VARARGS | METH_KEYWORDS },
2986          { "wxImage_GetMaskGreen", (PyCFunction) _wrap_wxImage_GetMaskGreen, METH_VARARGS | METH_KEYWORDS },
2987          { "wxImage_GetMaskRed", (PyCFunction) _wrap_wxImage_GetMaskRed, METH_VARARGS | METH_KEYWORDS },
2988          { "wxImage_SetMaskColour", (PyCFunction) _wrap_wxImage_SetMaskColour, METH_VARARGS | METH_KEYWORDS },
2989          { "wxImage_SetData", (PyCFunction) _wrap_wxImage_SetData, METH_VARARGS | METH_KEYWORDS },
2990          { "wxImage_GetData", (PyCFunction) _wrap_wxImage_GetData, METH_VARARGS | METH_KEYWORDS },
2991          { "wxImage_Paste", (PyCFunction) _wrap_wxImage_Paste, METH_VARARGS | METH_KEYWORDS },
2992          { "wxImage_Copy", (PyCFunction) _wrap_wxImage_Copy, METH_VARARGS | METH_KEYWORDS },
2993          { "wxImage_GetSubImage", (PyCFunction) _wrap_wxImage_GetSubImage, METH_VARARGS | METH_KEYWORDS },
2994          { "wxImage_GetHeight", (PyCFunction) _wrap_wxImage_GetHeight, METH_VARARGS | METH_KEYWORDS },
2995          { "wxImage_GetWidth", (PyCFunction) _wrap_wxImage_GetWidth, METH_VARARGS | METH_KEYWORDS },
2996          { "wxImage_Ok", (PyCFunction) _wrap_wxImage_Ok, METH_VARARGS | METH_KEYWORDS },
2997          { "wxImage_SaveMimeFile", (PyCFunction) _wrap_wxImage_SaveMimeFile, METH_VARARGS | METH_KEYWORDS },
2998          { "wxImage_SaveFile", (PyCFunction) _wrap_wxImage_SaveFile, METH_VARARGS | METH_KEYWORDS },
2999          { "wxImage_LoadMimeFile", (PyCFunction) _wrap_wxImage_LoadMimeFile, METH_VARARGS | METH_KEYWORDS },
3000          { "wxImage_LoadFile", (PyCFunction) _wrap_wxImage_LoadFile, METH_VARARGS | METH_KEYWORDS },
3001          { "wxImage_GetImageCount", (PyCFunction) _wrap_wxImage_GetImageCount, METH_VARARGS | METH_KEYWORDS },
3002          { "wxImage_CanRead", (PyCFunction) _wrap_wxImage_CanRead, METH_VARARGS | METH_KEYWORDS },
3003          { "wxImage_GetBlue", (PyCFunction) _wrap_wxImage_GetBlue, METH_VARARGS | METH_KEYWORDS },
3004          { "wxImage_GetGreen", (PyCFunction) _wrap_wxImage_GetGreen, METH_VARARGS | METH_KEYWORDS },
3005          { "wxImage_GetRed", (PyCFunction) _wrap_wxImage_GetRed, METH_VARARGS | METH_KEYWORDS },
3006          { "wxImage_SetRGB", (PyCFunction) _wrap_wxImage_SetRGB, METH_VARARGS | METH_KEYWORDS },
3007          { "wxImage_Rescale", (PyCFunction) _wrap_wxImage_Rescale, METH_VARARGS | METH_KEYWORDS },
3008          { "wxImage_Scale", (PyCFunction) _wrap_wxImage_Scale, METH_VARARGS | METH_KEYWORDS },
3009          { "wxImage_Destroy", (PyCFunction) _wrap_wxImage_Destroy, METH_VARARGS | METH_KEYWORDS },
3010          { "wxImage_Create", (PyCFunction) _wrap_wxImage_Create, METH_VARARGS | METH_KEYWORDS },
3011          { "wxImage_ConvertToBitmap", (PyCFunction) _wrap_wxImage_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS },
3012          { "delete_wxImage", (PyCFunction) _wrap_delete_wxImage, METH_VARARGS | METH_KEYWORDS },
3013          { "new_wxImage", (PyCFunction) _wrap_new_wxImage, METH_VARARGS | METH_KEYWORDS },
3014          { "new_wxTIFFHandler", (PyCFunction) _wrap_new_wxTIFFHandler, METH_VARARGS | METH_KEYWORDS },
3015          { "new_wxPCXHandler", (PyCFunction) _wrap_new_wxPCXHandler, METH_VARARGS | METH_KEYWORDS },
3016          { "new_wxPNMHandler", (PyCFunction) _wrap_new_wxPNMHandler, METH_VARARGS | METH_KEYWORDS },
3017          { "new_wxGIFHandler", (PyCFunction) _wrap_new_wxGIFHandler, METH_VARARGS | METH_KEYWORDS },
3018          { "new_wxANIHandler", (PyCFunction) _wrap_new_wxANIHandler, METH_VARARGS | METH_KEYWORDS },
3019          { "new_wxCURHandler", (PyCFunction) _wrap_new_wxCURHandler, METH_VARARGS | METH_KEYWORDS },
3020          { "new_wxICOHandler", (PyCFunction) _wrap_new_wxICOHandler, METH_VARARGS | METH_KEYWORDS },
3021          { "new_wxBMPHandler", (PyCFunction) _wrap_new_wxBMPHandler, METH_VARARGS | METH_KEYWORDS },
3022          { "new_wxJPEGHandler", (PyCFunction) _wrap_new_wxJPEGHandler, METH_VARARGS | METH_KEYWORDS },
3023          { "new_wxPNGHandler", (PyCFunction) _wrap_new_wxPNGHandler, METH_VARARGS | METH_KEYWORDS },
3024          { "wxImageHandler_SetMimeType", (PyCFunction) _wrap_wxImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS },
3025          { "wxImageHandler_SetType", (PyCFunction) _wrap_wxImageHandler_SetType, METH_VARARGS | METH_KEYWORDS },
3026          { "wxImageHandler_SetExtension", (PyCFunction) _wrap_wxImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS },
3027          { "wxImageHandler_SetName", (PyCFunction) _wrap_wxImageHandler_SetName, METH_VARARGS | METH_KEYWORDS },
3028          { "wxImageHandler_CanRead", (PyCFunction) _wrap_wxImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS },
3029          { "wxImageHandler_GetMimeType", (PyCFunction) _wrap_wxImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS },
3030          { "wxImageHandler_GetType", (PyCFunction) _wrap_wxImageHandler_GetType, METH_VARARGS | METH_KEYWORDS },
3031          { "wxImageHandler_GetExtension", (PyCFunction) _wrap_wxImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS },
3032          { "wxImageHandler_GetName", (PyCFunction) _wrap_wxImageHandler_GetName, METH_VARARGS | METH_KEYWORDS },
3033          { "wxBitmapFromImage", (PyCFunction) _wrap_wxBitmapFromImage, METH_VARARGS | METH_KEYWORDS },
3034          { "wxInitAllImageHandlers", (PyCFunction) _wrap_wxInitAllImageHandlers, METH_VARARGS | METH_KEYWORDS },
3035          { "wxImageFromData", (PyCFunction) _wrap_wxImageFromData, METH_VARARGS | METH_KEYWORDS },
3036          { "wxImageFromBitmap", (PyCFunction) _wrap_wxImageFromBitmap, METH_VARARGS | METH_KEYWORDS },
3037          { "wxImageFromMime", (PyCFunction) _wrap_wxImageFromMime, METH_VARARGS | METH_KEYWORDS },
3038          { "wxEmptyImage", (PyCFunction) _wrap_wxEmptyImage, METH_VARARGS | METH_KEYWORDS },
3039          { NULL, NULL }
3040 };
3041 #ifdef __cplusplus
3042 }
3043 #endif
3044 /*
3045  * This table is used by the pointer type-checker
3046  */
3047 static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {
3048     { "_signed_long","_long",0},
3049     { "_wxBMPHandler","_wxANIHandler",SwigwxANIHandlerTowxBMPHandler},
3050     { "_wxBMPHandler","_wxCURHandler",SwigwxCURHandlerTowxBMPHandler},
3051     { "_wxBMPHandler","_wxICOHandler",SwigwxICOHandlerTowxBMPHandler},
3052     { "_wxICOHandler","_wxANIHandler",SwigwxANIHandlerTowxICOHandler},
3053     { "_wxICOHandler","_wxCURHandler",SwigwxCURHandlerTowxICOHandler},
3054     { "_wxPrintQuality","_wxCoord",0},
3055     { "_wxPrintQuality","_int",0},
3056     { "_wxPrintQuality","_signed_int",0},
3057     { "_wxPrintQuality","_unsigned_int",0},
3058     { "_wxPrintQuality","_wxWindowID",0},
3059     { "_wxPrintQuality","_uint",0},
3060     { "_wxPrintQuality","_EBool",0},
3061     { "_wxPrintQuality","_size_t",0},
3062     { "_wxPrintQuality","_time_t",0},
3063     { "_wxImageHandler","_wxTIFFHandler",SwigwxTIFFHandlerTowxImageHandler},
3064     { "_wxImageHandler","_wxPCXHandler",SwigwxPCXHandlerTowxImageHandler},
3065     { "_wxImageHandler","_wxPNMHandler",SwigwxPNMHandlerTowxImageHandler},
3066     { "_wxImageHandler","_wxGIFHandler",SwigwxGIFHandlerTowxImageHandler},
3067     { "_wxImageHandler","_wxANIHandler",SwigwxANIHandlerTowxImageHandler},
3068     { "_wxImageHandler","_wxCURHandler",SwigwxCURHandlerTowxImageHandler},
3069     { "_wxImageHandler","_wxICOHandler",SwigwxICOHandlerTowxImageHandler},
3070     { "_wxImageHandler","_wxBMPHandler",SwigwxBMPHandlerTowxImageHandler},
3071     { "_wxImageHandler","_wxJPEGHandler",SwigwxJPEGHandlerTowxImageHandler},
3072     { "_wxImageHandler","_wxPNGHandler",SwigwxPNGHandlerTowxImageHandler},
3073     { "_byte","_unsigned_char",0},
3074     { "_long","_unsigned_long",0},
3075     { "_long","_signed_long",0},
3076     { "_size_t","_wxCoord",0},
3077     { "_size_t","_wxPrintQuality",0},
3078     { "_size_t","_time_t",0},
3079     { "_size_t","_unsigned_int",0},
3080     { "_size_t","_int",0},
3081     { "_size_t","_wxWindowID",0},
3082     { "_size_t","_uint",0},
3083     { "_uint","_wxCoord",0},
3084     { "_uint","_wxPrintQuality",0},
3085     { "_uint","_time_t",0},
3086     { "_uint","_size_t",0},
3087     { "_uint","_unsigned_int",0},
3088     { "_uint","_int",0},
3089     { "_uint","_wxWindowID",0},
3090     { "_wxChar","_char",0},
3091     { "_char","_wxChar",0},
3092     { "_struct_wxNativeFontInfo","_wxNativeFontInfo",0},
3093     { "_EBool","_wxCoord",0},
3094     { "_EBool","_wxPrintQuality",0},
3095     { "_EBool","_signed_int",0},
3096     { "_EBool","_int",0},
3097     { "_EBool","_wxWindowID",0},
3098     { "_unsigned_long","_long",0},
3099     { "_wxNativeFontInfo","_struct_wxNativeFontInfo",0},
3100     { "_signed_int","_wxCoord",0},
3101     { "_signed_int","_wxPrintQuality",0},
3102     { "_signed_int","_EBool",0},
3103     { "_signed_int","_wxWindowID",0},
3104     { "_signed_int","_int",0},
3105     { "_WXTYPE","_short",0},
3106     { "_WXTYPE","_signed_short",0},
3107     { "_WXTYPE","_unsigned_short",0},
3108     { "_unsigned_short","_WXTYPE",0},
3109     { "_unsigned_short","_short",0},
3110     { "_wxObject","_wxImage",SwigwxImageTowxObject},
3111     { "_wxObject","_wxTIFFHandler",SwigwxTIFFHandlerTowxObject},
3112     { "_wxObject","_wxPCXHandler",SwigwxPCXHandlerTowxObject},
3113     { "_wxObject","_wxPNMHandler",SwigwxPNMHandlerTowxObject},
3114     { "_wxObject","_wxGIFHandler",SwigwxGIFHandlerTowxObject},
3115     { "_wxObject","_wxANIHandler",SwigwxANIHandlerTowxObject},
3116     { "_wxObject","_wxCURHandler",SwigwxCURHandlerTowxObject},
3117     { "_wxObject","_wxICOHandler",SwigwxICOHandlerTowxObject},
3118     { "_wxObject","_wxBMPHandler",SwigwxBMPHandlerTowxObject},
3119     { "_wxObject","_wxJPEGHandler",SwigwxJPEGHandlerTowxObject},
3120     { "_wxObject","_wxPNGHandler",SwigwxPNGHandlerTowxObject},
3121     { "_wxObject","_wxImageHandler",SwigwxImageHandlerTowxObject},
3122     { "_signed_short","_WXTYPE",0},
3123     { "_signed_short","_short",0},
3124     { "_wxCURHandler","_wxANIHandler",SwigwxANIHandlerTowxCURHandler},
3125     { "_unsigned_char","_byte",0},
3126     { "_unsigned_int","_wxCoord",0},
3127     { "_unsigned_int","_wxPrintQuality",0},
3128     { "_unsigned_int","_time_t",0},
3129     { "_unsigned_int","_size_t",0},
3130     { "_unsigned_int","_uint",0},
3131     { "_unsigned_int","_wxWindowID",0},
3132     { "_unsigned_int","_int",0},
3133     { "_short","_WXTYPE",0},
3134     { "_short","_unsigned_short",0},
3135     { "_short","_signed_short",0},
3136     { "_wxWindowID","_wxCoord",0},
3137     { "_wxWindowID","_wxPrintQuality",0},
3138     { "_wxWindowID","_time_t",0},
3139     { "_wxWindowID","_size_t",0},
3140     { "_wxWindowID","_EBool",0},
3141     { "_wxWindowID","_uint",0},
3142     { "_wxWindowID","_int",0},
3143     { "_wxWindowID","_signed_int",0},
3144     { "_wxWindowID","_unsigned_int",0},
3145     { "_int","_wxCoord",0},
3146     { "_int","_wxPrintQuality",0},
3147     { "_int","_time_t",0},
3148     { "_int","_size_t",0},
3149     { "_int","_EBool",0},
3150     { "_int","_uint",0},
3151     { "_int","_wxWindowID",0},
3152     { "_int","_unsigned_int",0},
3153     { "_int","_signed_int",0},
3154     { "_time_t","_wxCoord",0},
3155     { "_time_t","_wxPrintQuality",0},
3156     { "_time_t","_unsigned_int",0},
3157     { "_time_t","_int",0},
3158     { "_time_t","_wxWindowID",0},
3159     { "_time_t","_uint",0},
3160     { "_time_t","_size_t",0},
3161     { "_wxCoord","_int",0},
3162     { "_wxCoord","_signed_int",0},
3163     { "_wxCoord","_unsigned_int",0},
3164     { "_wxCoord","_wxWindowID",0},
3165     { "_wxCoord","_uint",0},
3166     { "_wxCoord","_EBool",0},
3167     { "_wxCoord","_size_t",0},
3168     { "_wxCoord","_time_t",0},
3169     { "_wxCoord","_wxPrintQuality",0},
3170 {0,0,0}};
3171
3172 static PyObject *SWIG_globals;
3173 #ifdef __cplusplus
3174 extern "C"
3175 #endif
3176 SWIGEXPORT(void) initimagec() {
3177          PyObject *m, *d;
3178          SWIG_globals = SWIG_newvarlink();
3179          m = Py_InitModule("imagec", imagecMethods);
3180          d = PyModule_GetDict(m);
3181          PyDict_SetItemString(d,"cvar", SWIG_globals);
3182          SWIG_addvarlink(SWIG_globals,"wxNullImage",_wrap_wxNullImage_get, _wrap_wxNullImage_set);
3183 {
3184    int i;
3185    for (i = 0; _swig_mapping[i].n1; i++)
3186         SWIG_RegisterMapping(_swig_mapping[i].n1,_swig_mapping[i].n2,_swig_mapping[i].pcnv);
3187 }
3188 }