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 *SwigwxGIFHandlerTowxImageHandler(void *ptr) {
 920     wxGIFHandler *src;
 921     wxImageHandler *dest;
 922     src = (wxGIFHandler *) ptr;
 923     dest = (wxImageHandler *) src;
 924     return (void *) dest;
 925 }
 926
 927 static void *SwigwxGIFHandlerTowxObject(void *ptr) {
 928     wxGIFHandler *src;
 929     wxObject *dest;
 930     src = (wxGIFHandler *) ptr;
 931     dest = (wxObject *) src;
 932     return (void *) dest;
 933 }
 934
 935 #define new_wxGIFHandler() (new wxGIFHandler())
 936 static PyObject *_wrap_new_wxGIFHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
 937     PyObject * _resultobj;
 938     wxGIFHandler * _result;
 939     char *_kwnames[] = {  NULL };
 940     char _ptemp[128];
 941
 942     self = self;
 943     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGIFHandler",_kwnames))
 944         return NULL;
 945 {
 946     PyThreadState* __tstate = wxPyBeginAllowThreads();
 947         _result = (wxGIFHandler *)new_wxGIFHandler();
 948
 949     wxPyEndAllowThreads(__tstate);
 950     if (PyErr_Occurred()) return NULL;
 951 }    if (_result) {
 952         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGIFHandler_p");
 953         _resultobj = Py_BuildValue("s",_ptemp);
 954     } else {
 955         Py_INCREF(Py_None);
 956         _resultobj = Py_None;
 957     }
 958     return _resultobj;
 959 }
 960
 961 static void *SwigwxPNMHandlerTowxImageHandler(void *ptr) {
 962     wxPNMHandler *src;
 963     wxImageHandler *dest;
 964     src = (wxPNMHandler *) ptr;
 965     dest = (wxImageHandler *) src;
 966     return (void *) dest;
 967 }
 968
 969 static void *SwigwxPNMHandlerTowxObject(void *ptr) {
 970     wxPNMHandler *src;
 971     wxObject *dest;
 972     src = (wxPNMHandler *) ptr;
 973     dest = (wxObject *) src;
 974     return (void *) dest;
 975 }
 976
 977 #define new_wxPNMHandler() (new wxPNMHandler())
 978 static PyObject *_wrap_new_wxPNMHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
 979     PyObject * _resultobj;
 980     wxPNMHandler * _result;
 981     char *_kwnames[] = {  NULL };
 982     char _ptemp[128];
 983
 984     self = self;
 985     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPNMHandler",_kwnames))
 986         return NULL;
 987 {
 988     PyThreadState* __tstate = wxPyBeginAllowThreads();
 989         _result = (wxPNMHandler *)new_wxPNMHandler();
 990
 991     wxPyEndAllowThreads(__tstate);
 992     if (PyErr_Occurred()) return NULL;
 993 }    if (_result) {
 994         SWIG_MakePtr(_ptemp, (char *) _result,"_wxPNMHandler_p");
 995         _resultobj = Py_BuildValue("s",_ptemp);
 996     } else {
 997         Py_INCREF(Py_None);
 998         _resultobj = Py_None;
 999     }
1000     return _resultobj;
1001 }
1002
1003 static void *SwigwxPCXHandlerTowxImageHandler(void *ptr) {
1004     wxPCXHandler *src;
1005     wxImageHandler *dest;
1006     src = (wxPCXHandler *) ptr;
1007     dest = (wxImageHandler *) src;
1008     return (void *) dest;
1009 }
1010
1011 static void *SwigwxPCXHandlerTowxObject(void *ptr) {
1012     wxPCXHandler *src;
1013     wxObject *dest;
1014     src = (wxPCXHandler *) ptr;
1015     dest = (wxObject *) src;
1016     return (void *) dest;
1017 }
1018
1019 #define new_wxPCXHandler() (new wxPCXHandler())
1020 static PyObject *_wrap_new_wxPCXHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
1021     PyObject * _resultobj;
1022     wxPCXHandler * _result;
1023     char *_kwnames[] = {  NULL };
1024     char _ptemp[128];
1025
1026     self = self;
1027     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPCXHandler",_kwnames))
1028         return NULL;
1029 {
1030     PyThreadState* __tstate = wxPyBeginAllowThreads();
1031         _result = (wxPCXHandler *)new_wxPCXHandler();
1032
1033     wxPyEndAllowThreads(__tstate);
1034     if (PyErr_Occurred()) return NULL;
1035 }    if (_result) {
1036         SWIG_MakePtr(_ptemp, (char *) _result,"_wxPCXHandler_p");
1037         _resultobj = Py_BuildValue("s",_ptemp);
1038     } else {
1039         Py_INCREF(Py_None);
1040         _resultobj = Py_None;
1041     }
1042     return _resultobj;
1043 }
1044
1045 static void *SwigwxTIFFHandlerTowxImageHandler(void *ptr) {
1046     wxTIFFHandler *src;
1047     wxImageHandler *dest;
1048     src = (wxTIFFHandler *) ptr;
1049     dest = (wxImageHandler *) src;
1050     return (void *) dest;
1051 }
1052
1053 static void *SwigwxTIFFHandlerTowxObject(void *ptr) {
1054     wxTIFFHandler *src;
1055     wxObject *dest;
1056     src = (wxTIFFHandler *) ptr;
1057     dest = (wxObject *) src;
1058     return (void *) dest;
1059 }
1060
1061 #define new_wxTIFFHandler() (new wxTIFFHandler())
1062 static PyObject *_wrap_new_wxTIFFHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
1063     PyObject * _resultobj;
1064     wxTIFFHandler * _result;
1065     char *_kwnames[] = {  NULL };
1066     char _ptemp[128];
1067
1068     self = self;
1069     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxTIFFHandler",_kwnames))
1070         return NULL;
1071 {
1072     PyThreadState* __tstate = wxPyBeginAllowThreads();
1073         _result = (wxTIFFHandler *)new_wxTIFFHandler();
1074
1075     wxPyEndAllowThreads(__tstate);
1076     if (PyErr_Occurred()) return NULL;
1077 }    if (_result) {
1078         SWIG_MakePtr(_ptemp, (char *) _result,"_wxTIFFHandler_p");
1079         _resultobj = Py_BuildValue("s",_ptemp);
1080     } else {
1081         Py_INCREF(Py_None);
1082         _resultobj = Py_None;
1083     }
1084     return _resultobj;
1085 }
1086
1087 static void *SwigwxImageTowxObject(void *ptr) {
1088     wxImage *src;
1089     wxObject *dest;
1090     src = (wxImage *) ptr;
1091     dest = (wxObject *) src;
1092     return (void *) dest;
1093 }
1094
1095 #define new_wxImage(_swigarg0,_swigarg1,_swigarg2) (new wxImage(_swigarg0,_swigarg1,_swigarg2))
1096 static PyObject *_wrap_new_wxImage(PyObject *self, PyObject *args, PyObject *kwargs) {
1097     PyObject * _resultobj;
1098     wxImage * _result;
1099     wxString * _arg0;
1100     long  _arg1 = (long ) wxBITMAP_TYPE_ANY;
1101     int  _arg2 = (int ) -1;
1102     PyObject * _obj0 = 0;
1103     char *_kwnames[] = { "name","type","index", NULL };
1104     char _ptemp[128];
1105
1106     self = self;
1107     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|li:new_wxImage",_kwnames,&_obj0,&_arg1,&_arg2))
1108         return NULL;
1109 {
1110 #if PYTHON_API_VERSION >= 1009
1111     char* tmpPtr; int tmpSize;
1112     if (!PyString_Check(_obj0) && !PyUnicode_Check(_obj0)) {
1113         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1114         return NULL;
1115     }
1116     if (PyString_AsStringAndSize(_obj0, &tmpPtr, &tmpSize) == -1)
1117         return NULL;
1118     _arg0 = new wxString(tmpPtr, tmpSize);
1119 #else
1120     if (!PyString_Check(_obj0)) {
1121         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1122         return NULL;
1123     }
1124     _arg0 = new wxString(PyString_AS_STRING(_obj0), PyString_GET_SIZE(_obj0));
1125 #endif
1126 }
1127 {
1128     PyThreadState* __tstate = wxPyBeginAllowThreads();
1129         _result = (wxImage *)new_wxImage(*_arg0,_arg1,_arg2);
1130
1131     wxPyEndAllowThreads(__tstate);
1132     if (PyErr_Occurred()) return NULL;
1133 }    if (_result) {
1134         SWIG_MakePtr(_ptemp, (char *) _result,"_wxImage_p");
1135         _resultobj = Py_BuildValue("s",_ptemp);
1136     } else {
1137         Py_INCREF(Py_None);
1138         _resultobj = Py_None;
1139     }
1140 {
1141     if (_obj0)
1142         delete _arg0;
1143 }
1144     return _resultobj;
1145 }
1146
1147 #define delete_wxImage(_swigobj) (delete _swigobj)
1148 static PyObject *_wrap_delete_wxImage(PyObject *self, PyObject *args, PyObject *kwargs) {
1149     PyObject * _resultobj;
1150     wxImage * _arg0;
1151     PyObject * _argo0 = 0;
1152     char *_kwnames[] = { "self", NULL };
1153
1154     self = self;
1155     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:delete_wxImage",_kwnames,&_argo0))
1156         return NULL;
1157     if (_argo0) {
1158         if (_argo0 == Py_None) { _arg0 = NULL; }
1159         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1160             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxImage. Expected _wxImage_p.");
1161         return NULL;
1162         }
1163     }
1164 {
1165     PyThreadState* __tstate = wxPyBeginAllowThreads();
1166         delete_wxImage(_arg0);
1167
1168     wxPyEndAllowThreads(__tstate);
1169     if (PyErr_Occurred()) return NULL;
1170 }    Py_INCREF(Py_None);
1171     _resultobj = Py_None;
1172     return _resultobj;
1173 }
1174
1175 #define wxImage_ConvertToBitmap(_swigobj)  (_swigobj->ConvertToBitmap())
1176 static PyObject *_wrap_wxImage_ConvertToBitmap(PyObject *self, PyObject *args, PyObject *kwargs) {
1177     PyObject * _resultobj;
1178     wxBitmap * _result;
1179     wxImage * _arg0;
1180     PyObject * _argo0 = 0;
1181     char *_kwnames[] = { "self", NULL };
1182     char _ptemp[128];
1183
1184     self = self;
1185     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_ConvertToBitmap",_kwnames,&_argo0))
1186         return NULL;
1187     if (_argo0) {
1188         if (_argo0 == Py_None) { _arg0 = NULL; }
1189         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1190             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_ConvertToBitmap. Expected _wxImage_p.");
1191         return NULL;
1192         }
1193     }
1194 {
1195     PyThreadState* __tstate = wxPyBeginAllowThreads();
1196         _result = new wxBitmap (wxImage_ConvertToBitmap(_arg0));
1197
1198     wxPyEndAllowThreads(__tstate);
1199     if (PyErr_Occurred()) return NULL;
1200 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxBitmap_p");
1201     _resultobj = Py_BuildValue("s",_ptemp);
1202     return _resultobj;
1203 }
1204
1205 #define wxImage_Create(_swigobj,_swigarg0,_swigarg1)  (_swigobj->Create(_swigarg0,_swigarg1))
1206 static PyObject *_wrap_wxImage_Create(PyObject *self, PyObject *args, PyObject *kwargs) {
1207     PyObject * _resultobj;
1208     wxImage * _arg0;
1209     int  _arg1;
1210     int  _arg2;
1211     PyObject * _argo0 = 0;
1212     char *_kwnames[] = { "self","width","height", NULL };
1213
1214     self = self;
1215     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_Create",_kwnames,&_argo0,&_arg1,&_arg2))
1216         return NULL;
1217     if (_argo0) {
1218         if (_argo0 == Py_None) { _arg0 = NULL; }
1219         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1220             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Create. Expected _wxImage_p.");
1221         return NULL;
1222         }
1223     }
1224 {
1225     PyThreadState* __tstate = wxPyBeginAllowThreads();
1226         wxImage_Create(_arg0,_arg1,_arg2);
1227
1228     wxPyEndAllowThreads(__tstate);
1229     if (PyErr_Occurred()) return NULL;
1230 }    Py_INCREF(Py_None);
1231     _resultobj = Py_None;
1232     return _resultobj;
1233 }
1234
1235 #define wxImage_Destroy(_swigobj)  (_swigobj->Destroy())
1236 static PyObject *_wrap_wxImage_Destroy(PyObject *self, PyObject *args, PyObject *kwargs) {
1237     PyObject * _resultobj;
1238     wxImage * _arg0;
1239     PyObject * _argo0 = 0;
1240     char *_kwnames[] = { "self", NULL };
1241
1242     self = self;
1243     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_Destroy",_kwnames,&_argo0))
1244         return NULL;
1245     if (_argo0) {
1246         if (_argo0 == Py_None) { _arg0 = NULL; }
1247         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1248             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Destroy. Expected _wxImage_p.");
1249         return NULL;
1250         }
1251     }
1252 {
1253     PyThreadState* __tstate = wxPyBeginAllowThreads();
1254         wxImage_Destroy(_arg0);
1255
1256     wxPyEndAllowThreads(__tstate);
1257     if (PyErr_Occurred()) return NULL;
1258 }    Py_INCREF(Py_None);
1259     _resultobj = Py_None;
1260     return _resultobj;
1261 }
1262
1263 #define wxImage_Scale(_swigobj,_swigarg0,_swigarg1)  (_swigobj->Scale(_swigarg0,_swigarg1))
1264 static PyObject *_wrap_wxImage_Scale(PyObject *self, PyObject *args, PyObject *kwargs) {
1265     PyObject * _resultobj;
1266     wxImage * _result;
1267     wxImage * _arg0;
1268     int  _arg1;
1269     int  _arg2;
1270     PyObject * _argo0 = 0;
1271     char *_kwnames[] = { "self","width","height", NULL };
1272     char _ptemp[128];
1273
1274     self = self;
1275     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_Scale",_kwnames,&_argo0,&_arg1,&_arg2))
1276         return NULL;
1277     if (_argo0) {
1278         if (_argo0 == Py_None) { _arg0 = NULL; }
1279         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1280             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Scale. Expected _wxImage_p.");
1281         return NULL;
1282         }
1283     }
1284 {
1285     PyThreadState* __tstate = wxPyBeginAllowThreads();
1286         _result = new wxImage (wxImage_Scale(_arg0,_arg1,_arg2));
1287
1288     wxPyEndAllowThreads(__tstate);
1289     if (PyErr_Occurred()) return NULL;
1290 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p");
1291     _resultobj = Py_BuildValue("s",_ptemp);
1292     return _resultobj;
1293 }
1294
1295 #define wxImage_Rescale(_swigobj,_swigarg0,_swigarg1)  (_swigobj->Rescale(_swigarg0,_swigarg1))
1296 static PyObject *_wrap_wxImage_Rescale(PyObject *self, PyObject *args, PyObject *kwargs) {
1297     PyObject * _resultobj;
1298     wxImage * _result;
1299     wxImage * _arg0;
1300     int  _arg1;
1301     int  _arg2;
1302     PyObject * _argo0 = 0;
1303     char *_kwnames[] = { "self","width","height", NULL };
1304     char _ptemp[128];
1305
1306     self = self;
1307     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_Rescale",_kwnames,&_argo0,&_arg1,&_arg2))
1308         return NULL;
1309     if (_argo0) {
1310         if (_argo0 == Py_None) { _arg0 = NULL; }
1311         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1312             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Rescale. Expected _wxImage_p.");
1313         return NULL;
1314         }
1315     }
1316 {
1317     PyThreadState* __tstate = wxPyBeginAllowThreads();
1318         wxImage & _result_ref = wxImage_Rescale(_arg0,_arg1,_arg2);
1319     _result = (wxImage *) &_result_ref;
1320
1321     wxPyEndAllowThreads(__tstate);
1322     if (PyErr_Occurred()) return NULL;
1323 }    if (_result) {
1324         SWIG_MakePtr(_ptemp, (char *) _result,"_wxImage_p");
1325         _resultobj = Py_BuildValue("s",_ptemp);
1326     } else {
1327         Py_INCREF(Py_None);
1328         _resultobj = Py_None;
1329     }
1330     return _resultobj;
1331 }
1332
1333 #define wxImage_SetRGB(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4)  (_swigobj->SetRGB(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4))
1334 static PyObject *_wrap_wxImage_SetRGB(PyObject *self, PyObject *args, PyObject *kwargs) {
1335     PyObject * _resultobj;
1336     wxImage * _arg0;
1337     int  _arg1;
1338     int  _arg2;
1339     unsigned char  _arg3;
1340     unsigned char  _arg4;
1341     unsigned char  _arg5;
1342     PyObject * _argo0 = 0;
1343     char *_kwnames[] = { "self","x","y","r","g","b", NULL };
1344
1345     self = self;
1346     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiibbb:wxImage_SetRGB",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5))
1347         return NULL;
1348     if (_argo0) {
1349         if (_argo0 == Py_None) { _arg0 = NULL; }
1350         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1351             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetRGB. Expected _wxImage_p.");
1352         return NULL;
1353         }
1354     }
1355 {
1356     PyThreadState* __tstate = wxPyBeginAllowThreads();
1357         wxImage_SetRGB(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5);
1358
1359     wxPyEndAllowThreads(__tstate);
1360     if (PyErr_Occurred()) return NULL;
1361 }    Py_INCREF(Py_None);
1362     _resultobj = Py_None;
1363     return _resultobj;
1364 }
1365
1366 #define wxImage_GetRed(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetRed(_swigarg0,_swigarg1))
1367 static PyObject *_wrap_wxImage_GetRed(PyObject *self, PyObject *args, PyObject *kwargs) {
1368     PyObject * _resultobj;
1369     unsigned char  _result;
1370     wxImage * _arg0;
1371     int  _arg1;
1372     int  _arg2;
1373     PyObject * _argo0 = 0;
1374     char *_kwnames[] = { "self","x","y", NULL };
1375
1376     self = self;
1377     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_GetRed",_kwnames,&_argo0,&_arg1,&_arg2))
1378         return NULL;
1379     if (_argo0) {
1380         if (_argo0 == Py_None) { _arg0 = NULL; }
1381         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1382             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetRed. Expected _wxImage_p.");
1383         return NULL;
1384         }
1385     }
1386 {
1387     PyThreadState* __tstate = wxPyBeginAllowThreads();
1388         _result = (unsigned char )wxImage_GetRed(_arg0,_arg1,_arg2);
1389
1390     wxPyEndAllowThreads(__tstate);
1391     if (PyErr_Occurred()) return NULL;
1392 }    _resultobj = Py_BuildValue("b",_result);
1393     return _resultobj;
1394 }
1395
1396 #define wxImage_GetGreen(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetGreen(_swigarg0,_swigarg1))
1397 static PyObject *_wrap_wxImage_GetGreen(PyObject *self, PyObject *args, PyObject *kwargs) {
1398     PyObject * _resultobj;
1399     unsigned char  _result;
1400     wxImage * _arg0;
1401     int  _arg1;
1402     int  _arg2;
1403     PyObject * _argo0 = 0;
1404     char *_kwnames[] = { "self","x","y", NULL };
1405
1406     self = self;
1407     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_GetGreen",_kwnames,&_argo0,&_arg1,&_arg2))
1408         return NULL;
1409     if (_argo0) {
1410         if (_argo0 == Py_None) { _arg0 = NULL; }
1411         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1412             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetGreen. Expected _wxImage_p.");
1413         return NULL;
1414         }
1415     }
1416 {
1417     PyThreadState* __tstate = wxPyBeginAllowThreads();
1418         _result = (unsigned char )wxImage_GetGreen(_arg0,_arg1,_arg2);
1419
1420     wxPyEndAllowThreads(__tstate);
1421     if (PyErr_Occurred()) return NULL;
1422 }    _resultobj = Py_BuildValue("b",_result);
1423     return _resultobj;
1424 }
1425
1426 #define wxImage_GetBlue(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetBlue(_swigarg0,_swigarg1))
1427 static PyObject *_wrap_wxImage_GetBlue(PyObject *self, PyObject *args, PyObject *kwargs) {
1428     PyObject * _resultobj;
1429     unsigned char  _result;
1430     wxImage * _arg0;
1431     int  _arg1;
1432     int  _arg2;
1433     PyObject * _argo0 = 0;
1434     char *_kwnames[] = { "self","x","y", NULL };
1435
1436     self = self;
1437     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_GetBlue",_kwnames,&_argo0,&_arg1,&_arg2))
1438         return NULL;
1439     if (_argo0) {
1440         if (_argo0 == Py_None) { _arg0 = NULL; }
1441         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1442             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetBlue. Expected _wxImage_p.");
1443         return NULL;
1444         }
1445     }
1446 {
1447     PyThreadState* __tstate = wxPyBeginAllowThreads();
1448         _result = (unsigned char )wxImage_GetBlue(_arg0,_arg1,_arg2);
1449
1450     wxPyEndAllowThreads(__tstate);
1451     if (PyErr_Occurred()) return NULL;
1452 }    _resultobj = Py_BuildValue("b",_result);
1453     return _resultobj;
1454 }
1455
1456 static PyObject *_wrap_wxImage_CanRead(PyObject *self, PyObject *args, PyObject *kwargs) {
1457     PyObject * _resultobj;
1458     bool  _result;
1459     wxString * _arg0;
1460     PyObject * _obj0 = 0;
1461     char *_kwnames[] = { "name", NULL };
1462
1463     self = self;
1464     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_CanRead",_kwnames,&_obj0))
1465         return NULL;
1466 {
1467 #if PYTHON_API_VERSION >= 1009
1468     char* tmpPtr; int tmpSize;
1469     if (!PyString_Check(_obj0) && !PyUnicode_Check(_obj0)) {
1470         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1471         return NULL;
1472     }
1473     if (PyString_AsStringAndSize(_obj0, &tmpPtr, &tmpSize) == -1)
1474         return NULL;
1475     _arg0 = new wxString(tmpPtr, tmpSize);
1476 #else
1477     if (!PyString_Check(_obj0)) {
1478         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1479         return NULL;
1480     }
1481     _arg0 = new wxString(PyString_AS_STRING(_obj0), PyString_GET_SIZE(_obj0));
1482 #endif
1483 }
1484 {
1485     PyThreadState* __tstate = wxPyBeginAllowThreads();
1486         _result = (bool )wxImage::CanRead(*_arg0);
1487
1488     wxPyEndAllowThreads(__tstate);
1489     if (PyErr_Occurred()) return NULL;
1490 }    _resultobj = Py_BuildValue("i",_result);
1491 {
1492     if (_obj0)
1493         delete _arg0;
1494 }
1495     return _resultobj;
1496 }
1497
1498 static PyObject *_wrap_wxImage_GetImageCount(PyObject *self, PyObject *args, PyObject *kwargs) {
1499     PyObject * _resultobj;
1500     int  _result;
1501     wxString * _arg0;
1502     long  _arg1 = (long ) wxBITMAP_TYPE_ANY;
1503     PyObject * _obj0 = 0;
1504     char *_kwnames[] = { "name","type", NULL };
1505
1506     self = self;
1507     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|l:wxImage_GetImageCount",_kwnames,&_obj0,&_arg1))
1508         return NULL;
1509 {
1510 #if PYTHON_API_VERSION >= 1009
1511     char* tmpPtr; int tmpSize;
1512     if (!PyString_Check(_obj0) && !PyUnicode_Check(_obj0)) {
1513         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1514         return NULL;
1515     }
1516     if (PyString_AsStringAndSize(_obj0, &tmpPtr, &tmpSize) == -1)
1517         return NULL;
1518     _arg0 = new wxString(tmpPtr, tmpSize);
1519 #else
1520     if (!PyString_Check(_obj0)) {
1521         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1522         return NULL;
1523     }
1524     _arg0 = new wxString(PyString_AS_STRING(_obj0), PyString_GET_SIZE(_obj0));
1525 #endif
1526 }
1527 {
1528     PyThreadState* __tstate = wxPyBeginAllowThreads();
1529         _result = (int )wxImage::GetImageCount(*_arg0,_arg1);
1530
1531     wxPyEndAllowThreads(__tstate);
1532     if (PyErr_Occurred()) return NULL;
1533 }    _resultobj = Py_BuildValue("i",_result);
1534 {
1535     if (_obj0)
1536         delete _arg0;
1537 }
1538     return _resultobj;
1539 }
1540
1541 #define wxImage_LoadFile(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->LoadFile(_swigarg0,_swigarg1,_swigarg2))
1542 static PyObject *_wrap_wxImage_LoadFile(PyObject *self, PyObject *args, PyObject *kwargs) {
1543     PyObject * _resultobj;
1544     bool  _result;
1545     wxImage * _arg0;
1546     wxString * _arg1;
1547     long  _arg2 = (long ) wxBITMAP_TYPE_ANY;
1548     int  _arg3 = (int ) -1;
1549     PyObject * _argo0 = 0;
1550     PyObject * _obj1 = 0;
1551     char *_kwnames[] = { "self","name","type","index", NULL };
1552
1553     self = self;
1554     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|li:wxImage_LoadFile",_kwnames,&_argo0,&_obj1,&_arg2,&_arg3))
1555         return NULL;
1556     if (_argo0) {
1557         if (_argo0 == Py_None) { _arg0 = NULL; }
1558         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1559             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_LoadFile. Expected _wxImage_p.");
1560         return NULL;
1561         }
1562     }
1563 {
1564 #if PYTHON_API_VERSION >= 1009
1565     char* tmpPtr; int tmpSize;
1566     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1567         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1568         return NULL;
1569     }
1570     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1571         return NULL;
1572     _arg1 = new wxString(tmpPtr, tmpSize);
1573 #else
1574     if (!PyString_Check(_obj1)) {
1575         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1576         return NULL;
1577     }
1578     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1579 #endif
1580 }
1581 {
1582     PyThreadState* __tstate = wxPyBeginAllowThreads();
1583         _result = (bool )wxImage_LoadFile(_arg0,*_arg1,_arg2,_arg3);
1584
1585     wxPyEndAllowThreads(__tstate);
1586     if (PyErr_Occurred()) return NULL;
1587 }    _resultobj = Py_BuildValue("i",_result);
1588 {
1589     if (_obj1)
1590         delete _arg1;
1591 }
1592     return _resultobj;
1593 }
1594
1595 #define wxImage_LoadMimeFile(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->LoadFile(_swigarg0,_swigarg1,_swigarg2))
1596 static PyObject *_wrap_wxImage_LoadMimeFile(PyObject *self, PyObject *args, PyObject *kwargs) {
1597     PyObject * _resultobj;
1598     bool  _result;
1599     wxImage * _arg0;
1600     wxString * _arg1;
1601     wxString * _arg2;
1602     int  _arg3 = (int ) -1;
1603     PyObject * _argo0 = 0;
1604     PyObject * _obj1 = 0;
1605     PyObject * _obj2 = 0;
1606     char *_kwnames[] = { "self","name","mimetype","index", NULL };
1607
1608     self = self;
1609     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO|i:wxImage_LoadMimeFile",_kwnames,&_argo0,&_obj1,&_obj2,&_arg3))
1610         return NULL;
1611     if (_argo0) {
1612         if (_argo0 == Py_None) { _arg0 = NULL; }
1613         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1614             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_LoadMimeFile. Expected _wxImage_p.");
1615         return NULL;
1616         }
1617     }
1618 {
1619 #if PYTHON_API_VERSION >= 1009
1620     char* tmpPtr; int tmpSize;
1621     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1622         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1623         return NULL;
1624     }
1625     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1626         return NULL;
1627     _arg1 = new wxString(tmpPtr, tmpSize);
1628 #else
1629     if (!PyString_Check(_obj1)) {
1630         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1631         return NULL;
1632     }
1633     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1634 #endif
1635 }
1636 {
1637 #if PYTHON_API_VERSION >= 1009
1638     char* tmpPtr; int tmpSize;
1639     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
1640         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1641         return NULL;
1642     }
1643     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
1644         return NULL;
1645     _arg2 = new wxString(tmpPtr, tmpSize);
1646 #else
1647     if (!PyString_Check(_obj2)) {
1648         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1649         return NULL;
1650     }
1651     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
1652 #endif
1653 }
1654 {
1655     PyThreadState* __tstate = wxPyBeginAllowThreads();
1656         _result = (bool )wxImage_LoadMimeFile(_arg0,*_arg1,*_arg2,_arg3);
1657
1658     wxPyEndAllowThreads(__tstate);
1659     if (PyErr_Occurred()) return NULL;
1660 }    _resultobj = Py_BuildValue("i",_result);
1661 {
1662     if (_obj1)
1663         delete _arg1;
1664 }
1665 {
1666     if (_obj2)
1667         delete _arg2;
1668 }
1669     return _resultobj;
1670 }
1671
1672 #define wxImage_SaveFile(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SaveFile(_swigarg0,_swigarg1))
1673 static PyObject *_wrap_wxImage_SaveFile(PyObject *self, PyObject *args, PyObject *kwargs) {
1674     PyObject * _resultobj;
1675     bool  _result;
1676     wxImage * _arg0;
1677     wxString * _arg1;
1678     int  _arg2;
1679     PyObject * _argo0 = 0;
1680     PyObject * _obj1 = 0;
1681     char *_kwnames[] = { "self","name","type", NULL };
1682
1683     self = self;
1684     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOi:wxImage_SaveFile",_kwnames,&_argo0,&_obj1,&_arg2))
1685         return NULL;
1686     if (_argo0) {
1687         if (_argo0 == Py_None) { _arg0 = NULL; }
1688         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1689             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SaveFile. Expected _wxImage_p.");
1690         return NULL;
1691         }
1692     }
1693 {
1694 #if PYTHON_API_VERSION >= 1009
1695     char* tmpPtr; int tmpSize;
1696     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1697         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1698         return NULL;
1699     }
1700     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1701         return NULL;
1702     _arg1 = new wxString(tmpPtr, tmpSize);
1703 #else
1704     if (!PyString_Check(_obj1)) {
1705         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1706         return NULL;
1707     }
1708     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1709 #endif
1710 }
1711 {
1712     PyThreadState* __tstate = wxPyBeginAllowThreads();
1713         _result = (bool )wxImage_SaveFile(_arg0,*_arg1,_arg2);
1714
1715     wxPyEndAllowThreads(__tstate);
1716     if (PyErr_Occurred()) return NULL;
1717 }    _resultobj = Py_BuildValue("i",_result);
1718 {
1719     if (_obj1)
1720         delete _arg1;
1721 }
1722     return _resultobj;
1723 }
1724
1725 #define wxImage_SaveMimeFile(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SaveFile(_swigarg0,_swigarg1))
1726 static PyObject *_wrap_wxImage_SaveMimeFile(PyObject *self, PyObject *args, PyObject *kwargs) {
1727     PyObject * _resultobj;
1728     bool  _result;
1729     wxImage * _arg0;
1730     wxString * _arg1;
1731     wxString * _arg2;
1732     PyObject * _argo0 = 0;
1733     PyObject * _obj1 = 0;
1734     PyObject * _obj2 = 0;
1735     char *_kwnames[] = { "self","name","mimetype", NULL };
1736
1737     self = self;
1738     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxImage_SaveMimeFile",_kwnames,&_argo0,&_obj1,&_obj2))
1739         return NULL;
1740     if (_argo0) {
1741         if (_argo0 == Py_None) { _arg0 = NULL; }
1742         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1743             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SaveMimeFile. Expected _wxImage_p.");
1744         return NULL;
1745         }
1746     }
1747 {
1748 #if PYTHON_API_VERSION >= 1009
1749     char* tmpPtr; int tmpSize;
1750     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1751         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1752         return NULL;
1753     }
1754     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1755         return NULL;
1756     _arg1 = new wxString(tmpPtr, tmpSize);
1757 #else
1758     if (!PyString_Check(_obj1)) {
1759         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1760         return NULL;
1761     }
1762     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1763 #endif
1764 }
1765 {
1766 #if PYTHON_API_VERSION >= 1009
1767     char* tmpPtr; int tmpSize;
1768     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
1769         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1770         return NULL;
1771     }
1772     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
1773         return NULL;
1774     _arg2 = new wxString(tmpPtr, tmpSize);
1775 #else
1776     if (!PyString_Check(_obj2)) {
1777         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1778         return NULL;
1779     }
1780     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
1781 #endif
1782 }
1783 {
1784     PyThreadState* __tstate = wxPyBeginAllowThreads();
1785         _result = (bool )wxImage_SaveMimeFile(_arg0,*_arg1,*_arg2);
1786
1787     wxPyEndAllowThreads(__tstate);
1788     if (PyErr_Occurred()) return NULL;
1789 }    _resultobj = Py_BuildValue("i",_result);
1790 {
1791     if (_obj1)
1792         delete _arg1;
1793 }
1794 {
1795     if (_obj2)
1796         delete _arg2;
1797 }
1798     return _resultobj;
1799 }
1800
1801 #define wxImage_Ok(_swigobj)  (_swigobj->Ok())
1802 static PyObject *_wrap_wxImage_Ok(PyObject *self, PyObject *args, PyObject *kwargs) {
1803     PyObject * _resultobj;
1804     bool  _result;
1805     wxImage * _arg0;
1806     PyObject * _argo0 = 0;
1807     char *_kwnames[] = { "self", NULL };
1808
1809     self = self;
1810     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_Ok",_kwnames,&_argo0))
1811         return NULL;
1812     if (_argo0) {
1813         if (_argo0 == Py_None) { _arg0 = NULL; }
1814         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1815             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Ok. Expected _wxImage_p.");
1816         return NULL;
1817         }
1818     }
1819 {
1820     PyThreadState* __tstate = wxPyBeginAllowThreads();
1821         _result = (bool )wxImage_Ok(_arg0);
1822
1823     wxPyEndAllowThreads(__tstate);
1824     if (PyErr_Occurred()) return NULL;
1825 }    _resultobj = Py_BuildValue("i",_result);
1826     return _resultobj;
1827 }
1828
1829 #define wxImage_GetWidth(_swigobj)  (_swigobj->GetWidth())
1830 static PyObject *_wrap_wxImage_GetWidth(PyObject *self, PyObject *args, PyObject *kwargs) {
1831     PyObject * _resultobj;
1832     int  _result;
1833     wxImage * _arg0;
1834     PyObject * _argo0 = 0;
1835     char *_kwnames[] = { "self", NULL };
1836
1837     self = self;
1838     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetWidth",_kwnames,&_argo0))
1839         return NULL;
1840     if (_argo0) {
1841         if (_argo0 == Py_None) { _arg0 = NULL; }
1842         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1843             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetWidth. Expected _wxImage_p.");
1844         return NULL;
1845         }
1846     }
1847 {
1848     PyThreadState* __tstate = wxPyBeginAllowThreads();
1849         _result = (int )wxImage_GetWidth(_arg0);
1850
1851     wxPyEndAllowThreads(__tstate);
1852     if (PyErr_Occurred()) return NULL;
1853 }    _resultobj = Py_BuildValue("i",_result);
1854     return _resultobj;
1855 }
1856
1857 #define wxImage_GetHeight(_swigobj)  (_swigobj->GetHeight())
1858 static PyObject *_wrap_wxImage_GetHeight(PyObject *self, PyObject *args, PyObject *kwargs) {
1859     PyObject * _resultobj;
1860     int  _result;
1861     wxImage * _arg0;
1862     PyObject * _argo0 = 0;
1863     char *_kwnames[] = { "self", NULL };
1864
1865     self = self;
1866     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetHeight",_kwnames,&_argo0))
1867         return NULL;
1868     if (_argo0) {
1869         if (_argo0 == Py_None) { _arg0 = NULL; }
1870         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1871             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetHeight. Expected _wxImage_p.");
1872         return NULL;
1873         }
1874     }
1875 {
1876     PyThreadState* __tstate = wxPyBeginAllowThreads();
1877         _result = (int )wxImage_GetHeight(_arg0);
1878
1879     wxPyEndAllowThreads(__tstate);
1880     if (PyErr_Occurred()) return NULL;
1881 }    _resultobj = Py_BuildValue("i",_result);
1882     return _resultobj;
1883 }
1884
1885 #define wxImage_GetSubImage(_swigobj,_swigarg0)  (_swigobj->GetSubImage(_swigarg0))
1886 static PyObject *_wrap_wxImage_GetSubImage(PyObject *self, PyObject *args, PyObject *kwargs) {
1887     PyObject * _resultobj;
1888     wxImage * _result;
1889     wxImage * _arg0;
1890     wxRect * _arg1;
1891     PyObject * _argo0 = 0;
1892     wxRect  temp;
1893     PyObject * _obj1 = 0;
1894     char *_kwnames[] = { "self","rect", NULL };
1895     char _ptemp[128];
1896
1897     self = self;
1898     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxImage_GetSubImage",_kwnames,&_argo0,&_obj1))
1899         return NULL;
1900     if (_argo0) {
1901         if (_argo0 == Py_None) { _arg0 = NULL; }
1902         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1903             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetSubImage. Expected _wxImage_p.");
1904         return NULL;
1905         }
1906     }
1907 {
1908     _arg1 = &temp;
1909     if (! wxRect_helper(_obj1, &_arg1))
1910         return NULL;
1911 }
1912 {
1913     PyThreadState* __tstate = wxPyBeginAllowThreads();
1914         _result = new wxImage (wxImage_GetSubImage(_arg0,*_arg1));
1915
1916     wxPyEndAllowThreads(__tstate);
1917     if (PyErr_Occurred()) return NULL;
1918 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p");
1919     _resultobj = Py_BuildValue("s",_ptemp);
1920     return _resultobj;
1921 }
1922
1923 #define wxImage_Copy(_swigobj)  (_swigobj->Copy())
1924 static PyObject *_wrap_wxImage_Copy(PyObject *self, PyObject *args, PyObject *kwargs) {
1925     PyObject * _resultobj;
1926     wxImage * _result;
1927     wxImage * _arg0;
1928     PyObject * _argo0 = 0;
1929     char *_kwnames[] = { "self", NULL };
1930     char _ptemp[128];
1931
1932     self = self;
1933     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_Copy",_kwnames,&_argo0))
1934         return NULL;
1935     if (_argo0) {
1936         if (_argo0 == Py_None) { _arg0 = NULL; }
1937         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1938             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Copy. Expected _wxImage_p.");
1939         return NULL;
1940         }
1941     }
1942 {
1943     PyThreadState* __tstate = wxPyBeginAllowThreads();
1944         _result = new wxImage (wxImage_Copy(_arg0));
1945
1946     wxPyEndAllowThreads(__tstate);
1947     if (PyErr_Occurred()) return NULL;
1948 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p");
1949     _resultobj = Py_BuildValue("s",_ptemp);
1950     return _resultobj;
1951 }
1952
1953 #define wxImage_Paste(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->Paste(_swigarg0,_swigarg1,_swigarg2))
1954 static PyObject *_wrap_wxImage_Paste(PyObject *self, PyObject *args, PyObject *kwargs) {
1955     PyObject * _resultobj;
1956     wxImage * _arg0;
1957     wxImage * _arg1;
1958     int  _arg2;
1959     int  _arg3;
1960     PyObject * _argo0 = 0;
1961     PyObject * _argo1 = 0;
1962     char *_kwnames[] = { "self","image","x","y", NULL };
1963
1964     self = self;
1965     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOii:wxImage_Paste",_kwnames,&_argo0,&_argo1,&_arg2,&_arg3))
1966         return NULL;
1967     if (_argo0) {
1968         if (_argo0 == Py_None) { _arg0 = NULL; }
1969         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1970             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Paste. Expected _wxImage_p.");
1971         return NULL;
1972         }
1973     }
1974     if (_argo1) {
1975         if (_argo1 == Py_None) { _arg1 = NULL; }
1976         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxImage_p")) {
1977             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxImage_Paste. Expected _wxImage_p.");
1978         return NULL;
1979         }
1980     }
1981 {
1982     PyThreadState* __tstate = wxPyBeginAllowThreads();
1983         wxImage_Paste(_arg0,*_arg1,_arg2,_arg3);
1984
1985     wxPyEndAllowThreads(__tstate);
1986     if (PyErr_Occurred()) return NULL;
1987 }    Py_INCREF(Py_None);
1988     _resultobj = Py_None;
1989     return _resultobj;
1990 }
1991
1992 static PyObject * wxImage_GetData(wxImage *self) {
1993             unsigned char* data = self->GetData();
1994             int len = self->GetWidth() * self->GetHeight() * 3;
1995             return PyString_FromStringAndSize((char*)data, len);
1996         }
1997 static PyObject *_wrap_wxImage_GetData(PyObject *self, PyObject *args, PyObject *kwargs) {
1998     PyObject * _resultobj;
1999     PyObject * _result;
2000     wxImage * _arg0;
2001     PyObject * _argo0 = 0;
2002     char *_kwnames[] = { "self", NULL };
2003
2004     self = self;
2005     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetData",_kwnames,&_argo0))
2006         return NULL;
2007     if (_argo0) {
2008         if (_argo0 == Py_None) { _arg0 = NULL; }
2009         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2010             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetData. Expected _wxImage_p.");
2011         return NULL;
2012         }
2013     }
2014 {
2015     PyThreadState* __tstate = wxPyBeginAllowThreads();
2016         _result = (PyObject *)wxImage_GetData(_arg0);
2017
2018     wxPyEndAllowThreads(__tstate);
2019     if (PyErr_Occurred()) return NULL;
2020 }{
2021   _resultobj = _result;
2022 }
2023     return _resultobj;
2024 }
2025
2026 static void  wxImage_SetData(wxImage *self,PyObject * data) {
2027             unsigned char* dataPtr;
2028
2029             if (! PyString_Check(data)) {
2030                 PyErr_SetString(PyExc_TypeError, "Expected string object");
2031                 return /* NULL */ ;
2032             }
2033
2034             size_t len = self->GetWidth() * self->GetHeight() * 3;
2035             dataPtr = (unsigned char*) malloc(len);
2036             memcpy(dataPtr, PyString_AsString(data), len);
2037             self->SetData(dataPtr);
2038         }
2039 static PyObject *_wrap_wxImage_SetData(PyObject *self, PyObject *args, PyObject *kwargs) {
2040     PyObject * _resultobj;
2041     wxImage * _arg0;
2042     PyObject * _arg1;
2043     PyObject * _argo0 = 0;
2044     PyObject * _obj1 = 0;
2045     char *_kwnames[] = { "self","data", NULL };
2046
2047     self = self;
2048     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxImage_SetData",_kwnames,&_argo0,&_obj1))
2049         return NULL;
2050     if (_argo0) {
2051         if (_argo0 == Py_None) { _arg0 = NULL; }
2052         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2053             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetData. Expected _wxImage_p.");
2054         return NULL;
2055         }
2056     }
2057 {
2058   _arg1 = _obj1;
2059 }
2060 {
2061     PyThreadState* __tstate = wxPyBeginAllowThreads();
2062         wxImage_SetData(_arg0,_arg1);
2063
2064     wxPyEndAllowThreads(__tstate);
2065     if (PyErr_Occurred()) return NULL;
2066 }    Py_INCREF(Py_None);
2067     _resultobj = Py_None;
2068     return _resultobj;
2069 }
2070
2071 #define wxImage_SetMaskColour(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetMaskColour(_swigarg0,_swigarg1,_swigarg2))
2072 static PyObject *_wrap_wxImage_SetMaskColour(PyObject *self, PyObject *args, PyObject *kwargs) {
2073     PyObject * _resultobj;
2074     wxImage * _arg0;
2075     unsigned char  _arg1;
2076     unsigned char  _arg2;
2077     unsigned char  _arg3;
2078     PyObject * _argo0 = 0;
2079     char *_kwnames[] = { "self","r","g","b", NULL };
2080
2081     self = self;
2082     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Obbb:wxImage_SetMaskColour",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3))
2083         return NULL;
2084     if (_argo0) {
2085         if (_argo0 == Py_None) { _arg0 = NULL; }
2086         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2087             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetMaskColour. Expected _wxImage_p.");
2088         return NULL;
2089         }
2090     }
2091 {
2092     PyThreadState* __tstate = wxPyBeginAllowThreads();
2093         wxImage_SetMaskColour(_arg0,_arg1,_arg2,_arg3);
2094
2095     wxPyEndAllowThreads(__tstate);
2096     if (PyErr_Occurred()) return NULL;
2097 }    Py_INCREF(Py_None);
2098     _resultobj = Py_None;
2099     return _resultobj;
2100 }
2101
2102 #define wxImage_GetMaskRed(_swigobj)  (_swigobj->GetMaskRed())
2103 static PyObject *_wrap_wxImage_GetMaskRed(PyObject *self, PyObject *args, PyObject *kwargs) {
2104     PyObject * _resultobj;
2105     unsigned char  _result;
2106     wxImage * _arg0;
2107     PyObject * _argo0 = 0;
2108     char *_kwnames[] = { "self", NULL };
2109
2110     self = self;
2111     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetMaskRed",_kwnames,&_argo0))
2112         return NULL;
2113     if (_argo0) {
2114         if (_argo0 == Py_None) { _arg0 = NULL; }
2115         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2116             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetMaskRed. Expected _wxImage_p.");
2117         return NULL;
2118         }
2119     }
2120 {
2121     PyThreadState* __tstate = wxPyBeginAllowThreads();
2122         _result = (unsigned char )wxImage_GetMaskRed(_arg0);
2123
2124     wxPyEndAllowThreads(__tstate);
2125     if (PyErr_Occurred()) return NULL;
2126 }    _resultobj = Py_BuildValue("b",_result);
2127     return _resultobj;
2128 }
2129
2130 #define wxImage_GetMaskGreen(_swigobj)  (_swigobj->GetMaskGreen())
2131 static PyObject *_wrap_wxImage_GetMaskGreen(PyObject *self, PyObject *args, PyObject *kwargs) {
2132     PyObject * _resultobj;
2133     unsigned char  _result;
2134     wxImage * _arg0;
2135     PyObject * _argo0 = 0;
2136     char *_kwnames[] = { "self", NULL };
2137
2138     self = self;
2139     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetMaskGreen",_kwnames,&_argo0))
2140         return NULL;
2141     if (_argo0) {
2142         if (_argo0 == Py_None) { _arg0 = NULL; }
2143         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2144             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetMaskGreen. Expected _wxImage_p.");
2145         return NULL;
2146         }
2147     }
2148 {
2149     PyThreadState* __tstate = wxPyBeginAllowThreads();
2150         _result = (unsigned char )wxImage_GetMaskGreen(_arg0);
2151
2152     wxPyEndAllowThreads(__tstate);
2153     if (PyErr_Occurred()) return NULL;
2154 }    _resultobj = Py_BuildValue("b",_result);
2155     return _resultobj;
2156 }
2157
2158 #define wxImage_GetMaskBlue(_swigobj)  (_swigobj->GetMaskBlue())
2159 static PyObject *_wrap_wxImage_GetMaskBlue(PyObject *self, PyObject *args, PyObject *kwargs) {
2160     PyObject * _resultobj;
2161     unsigned char  _result;
2162     wxImage * _arg0;
2163     PyObject * _argo0 = 0;
2164     char *_kwnames[] = { "self", NULL };
2165
2166     self = self;
2167     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetMaskBlue",_kwnames,&_argo0))
2168         return NULL;
2169     if (_argo0) {
2170         if (_argo0 == Py_None) { _arg0 = NULL; }
2171         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2172             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetMaskBlue. Expected _wxImage_p.");
2173         return NULL;
2174         }
2175     }
2176 {
2177     PyThreadState* __tstate = wxPyBeginAllowThreads();
2178         _result = (unsigned char )wxImage_GetMaskBlue(_arg0);
2179
2180     wxPyEndAllowThreads(__tstate);
2181     if (PyErr_Occurred()) return NULL;
2182 }    _resultobj = Py_BuildValue("b",_result);
2183     return _resultobj;
2184 }
2185
2186 #define wxImage_SetMask(_swigobj,_swigarg0)  (_swigobj->SetMask(_swigarg0))
2187 static PyObject *_wrap_wxImage_SetMask(PyObject *self, PyObject *args, PyObject *kwargs) {
2188     PyObject * _resultobj;
2189     wxImage * _arg0;
2190     bool  _arg1 = (bool ) TRUE;
2191     PyObject * _argo0 = 0;
2192     int tempbool1 = (int) TRUE;
2193     char *_kwnames[] = { "self","mask", NULL };
2194
2195     self = self;
2196     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxImage_SetMask",_kwnames,&_argo0,&tempbool1))
2197         return NULL;
2198     if (_argo0) {
2199         if (_argo0 == Py_None) { _arg0 = NULL; }
2200         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2201             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetMask. Expected _wxImage_p.");
2202         return NULL;
2203         }
2204     }
2205     _arg1 = (bool ) tempbool1;
2206 {
2207     PyThreadState* __tstate = wxPyBeginAllowThreads();
2208         wxImage_SetMask(_arg0,_arg1);
2209
2210     wxPyEndAllowThreads(__tstate);
2211     if (PyErr_Occurred()) return NULL;
2212 }    Py_INCREF(Py_None);
2213     _resultobj = Py_None;
2214     return _resultobj;
2215 }
2216
2217 #define wxImage_HasMask(_swigobj)  (_swigobj->HasMask())
2218 static PyObject *_wrap_wxImage_HasMask(PyObject *self, PyObject *args, PyObject *kwargs) {
2219     PyObject * _resultobj;
2220     bool  _result;
2221     wxImage * _arg0;
2222     PyObject * _argo0 = 0;
2223     char *_kwnames[] = { "self", NULL };
2224
2225     self = self;
2226     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_HasMask",_kwnames,&_argo0))
2227         return NULL;
2228     if (_argo0) {
2229         if (_argo0 == Py_None) { _arg0 = NULL; }
2230         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2231             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_HasMask. Expected _wxImage_p.");
2232         return NULL;
2233         }
2234     }
2235 {
2236     PyThreadState* __tstate = wxPyBeginAllowThreads();
2237         _result = (bool )wxImage_HasMask(_arg0);
2238
2239     wxPyEndAllowThreads(__tstate);
2240     if (PyErr_Occurred()) return NULL;
2241 }    _resultobj = Py_BuildValue("i",_result);
2242     return _resultobj;
2243 }
2244
2245 #define wxImage_Rotate(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3)  (_swigobj->Rotate(_swigarg0,_swigarg1,_swigarg2,_swigarg3))
2246 static PyObject *_wrap_wxImage_Rotate(PyObject *self, PyObject *args, PyObject *kwargs) {
2247     PyObject * _resultobj;
2248     wxImage * _result;
2249     wxImage * _arg0;
2250     double  _arg1;
2251     wxPoint * _arg2;
2252     bool  _arg3 = (bool ) TRUE;
2253     wxPoint * _arg4 = (wxPoint *) NULL;
2254     PyObject * _argo0 = 0;
2255     wxPoint  temp;
2256     PyObject * _obj2 = 0;
2257     int tempbool3 = (int) TRUE;
2258     wxPoint  temp0;
2259     PyObject * _obj4 = 0;
2260     char *_kwnames[] = { "self","angle","centre_of_rotation","interpolating","offset_after_rotation", NULL };
2261     char _ptemp[128];
2262
2263     self = self;
2264     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OdO|iO:wxImage_Rotate",_kwnames,&_argo0,&_arg1,&_obj2,&tempbool3,&_obj4))
2265         return NULL;
2266     if (_argo0) {
2267         if (_argo0 == Py_None) { _arg0 = NULL; }
2268         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2269             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Rotate. Expected _wxImage_p.");
2270         return NULL;
2271         }
2272     }
2273 {
2274     _arg2 = &temp;
2275     if (! wxPoint_helper(_obj2, &_arg2))
2276         return NULL;
2277 }
2278     _arg3 = (bool ) tempbool3;
2279     if (_obj4)
2280 {
2281     _arg4 = &temp0;
2282     if (! wxPoint_helper(_obj4, &_arg4))
2283         return NULL;
2284 }
2285 {
2286     PyThreadState* __tstate = wxPyBeginAllowThreads();
2287         _result = new wxImage (wxImage_Rotate(_arg0,_arg1,*_arg2,_arg3,_arg4));
2288
2289     wxPyEndAllowThreads(__tstate);
2290     if (PyErr_Occurred()) return NULL;
2291 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p");
2292     _resultobj = Py_BuildValue("s",_ptemp);
2293     return _resultobj;
2294 }
2295
2296 #define wxImage_Rotate90(_swigobj,_swigarg0)  (_swigobj->Rotate90(_swigarg0))
2297 static PyObject *_wrap_wxImage_Rotate90(PyObject *self, PyObject *args, PyObject *kwargs) {
2298     PyObject * _resultobj;
2299     wxImage * _result;
2300     wxImage * _arg0;
2301     bool  _arg1 = (bool ) TRUE;
2302     PyObject * _argo0 = 0;
2303     int tempbool1 = (int) TRUE;
2304     char *_kwnames[] = { "self","clockwise", NULL };
2305     char _ptemp[128];
2306
2307     self = self;
2308     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxImage_Rotate90",_kwnames,&_argo0,&tempbool1))
2309         return NULL;
2310     if (_argo0) {
2311         if (_argo0 == Py_None) { _arg0 = NULL; }
2312         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2313             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Rotate90. Expected _wxImage_p.");
2314         return NULL;
2315         }
2316     }
2317     _arg1 = (bool ) tempbool1;
2318 {
2319     PyThreadState* __tstate = wxPyBeginAllowThreads();
2320         _result = new wxImage (wxImage_Rotate90(_arg0,_arg1));
2321
2322     wxPyEndAllowThreads(__tstate);
2323     if (PyErr_Occurred()) return NULL;
2324 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p");
2325     _resultobj = Py_BuildValue("s",_ptemp);
2326     return _resultobj;
2327 }
2328
2329 #define wxImage_Mirror(_swigobj,_swigarg0)  (_swigobj->Mirror(_swigarg0))
2330 static PyObject *_wrap_wxImage_Mirror(PyObject *self, PyObject *args, PyObject *kwargs) {
2331     PyObject * _resultobj;
2332     wxImage * _result;
2333     wxImage * _arg0;
2334     bool  _arg1 = (bool ) TRUE;
2335     PyObject * _argo0 = 0;
2336     int tempbool1 = (int) TRUE;
2337     char *_kwnames[] = { "self","horizontally", NULL };
2338     char _ptemp[128];
2339
2340     self = self;
2341     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxImage_Mirror",_kwnames,&_argo0,&tempbool1))
2342         return NULL;
2343     if (_argo0) {
2344         if (_argo0 == Py_None) { _arg0 = NULL; }
2345         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2346             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Mirror. Expected _wxImage_p.");
2347         return NULL;
2348         }
2349     }
2350     _arg1 = (bool ) tempbool1;
2351 {
2352     PyThreadState* __tstate = wxPyBeginAllowThreads();
2353         _result = new wxImage (wxImage_Mirror(_arg0,_arg1));
2354
2355     wxPyEndAllowThreads(__tstate);
2356     if (PyErr_Occurred()) return NULL;
2357 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p");
2358     _resultobj = Py_BuildValue("s",_ptemp);
2359     return _resultobj;
2360 }
2361
2362 #define wxImage_Replace(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5)  (_swigobj->Replace(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5))
2363 static PyObject *_wrap_wxImage_Replace(PyObject *self, PyObject *args, PyObject *kwargs) {
2364     PyObject * _resultobj;
2365     wxImage * _arg0;
2366     unsigned char  _arg1;
2367     unsigned char  _arg2;
2368     unsigned char  _arg3;
2369     unsigned char  _arg4;
2370     unsigned char  _arg5;
2371     unsigned char  _arg6;
2372     PyObject * _argo0 = 0;
2373     char *_kwnames[] = { "self","r1","g1","b1","r2","g2","b2", NULL };
2374
2375     self = self;
2376     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Obbbbbb:wxImage_Replace",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_arg6))
2377         return NULL;
2378     if (_argo0) {
2379         if (_argo0 == Py_None) { _arg0 = NULL; }
2380         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2381             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Replace. Expected _wxImage_p.");
2382         return NULL;
2383         }
2384     }
2385 {
2386     PyThreadState* __tstate = wxPyBeginAllowThreads();
2387         wxImage_Replace(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6);
2388
2389     wxPyEndAllowThreads(__tstate);
2390     if (PyErr_Occurred()) return NULL;
2391 }    Py_INCREF(Py_None);
2392     _resultobj = Py_None;
2393     return _resultobj;
2394 }
2395
2396 #define wxImage_ConvertToMono(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->ConvertToMono(_swigarg0,_swigarg1,_swigarg2))
2397 static PyObject *_wrap_wxImage_ConvertToMono(PyObject *self, PyObject *args, PyObject *kwargs) {
2398     PyObject * _resultobj;
2399     wxImage * _result;
2400     wxImage * _arg0;
2401     unsigned char  _arg1;
2402     unsigned char  _arg2;
2403     unsigned char  _arg3;
2404     PyObject * _argo0 = 0;
2405     char *_kwnames[] = { "self","r","g","b", NULL };
2406     char _ptemp[128];
2407
2408     self = self;
2409     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Obbb:wxImage_ConvertToMono",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3))
2410         return NULL;
2411     if (_argo0) {
2412         if (_argo0 == Py_None) { _arg0 = NULL; }
2413         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2414             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_ConvertToMono. Expected _wxImage_p.");
2415         return NULL;
2416         }
2417     }
2418 {
2419     PyThreadState* __tstate = wxPyBeginAllowThreads();
2420         _result = new wxImage (wxImage_ConvertToMono(_arg0,_arg1,_arg2,_arg3));
2421
2422     wxPyEndAllowThreads(__tstate);
2423     if (PyErr_Occurred()) return NULL;
2424 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p");
2425     _resultobj = Py_BuildValue("s",_ptemp);
2426     return _resultobj;
2427 }
2428
2429 #define wxImage_SetOption(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetOption(_swigarg0,_swigarg1))
2430 static PyObject *_wrap_wxImage_SetOption(PyObject *self, PyObject *args, PyObject *kwargs) {
2431     PyObject * _resultobj;
2432     wxImage * _arg0;
2433     wxString * _arg1;
2434     wxString * _arg2;
2435     PyObject * _argo0 = 0;
2436     PyObject * _obj1 = 0;
2437     PyObject * _obj2 = 0;
2438     char *_kwnames[] = { "self","name","value", NULL };
2439
2440     self = self;
2441     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxImage_SetOption",_kwnames,&_argo0,&_obj1,&_obj2))
2442         return NULL;
2443     if (_argo0) {
2444         if (_argo0 == Py_None) { _arg0 = NULL; }
2445         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2446             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetOption. Expected _wxImage_p.");
2447         return NULL;
2448         }
2449     }
2450 {
2451 #if PYTHON_API_VERSION >= 1009
2452     char* tmpPtr; int tmpSize;
2453     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
2454         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2455         return NULL;
2456     }
2457     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
2458         return NULL;
2459     _arg1 = new wxString(tmpPtr, tmpSize);
2460 #else
2461     if (!PyString_Check(_obj1)) {
2462         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2463         return NULL;
2464     }
2465     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
2466 #endif
2467 }
2468 {
2469 #if PYTHON_API_VERSION >= 1009
2470     char* tmpPtr; int tmpSize;
2471     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
2472         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2473         return NULL;
2474     }
2475     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
2476         return NULL;
2477     _arg2 = new wxString(tmpPtr, tmpSize);
2478 #else
2479     if (!PyString_Check(_obj2)) {
2480         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2481         return NULL;
2482     }
2483     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
2484 #endif
2485 }
2486 {
2487     PyThreadState* __tstate = wxPyBeginAllowThreads();
2488         wxImage_SetOption(_arg0,*_arg1,*_arg2);
2489
2490     wxPyEndAllowThreads(__tstate);
2491     if (PyErr_Occurred()) return NULL;
2492 }    Py_INCREF(Py_None);
2493     _resultobj = Py_None;
2494 {
2495     if (_obj1)
2496         delete _arg1;
2497 }
2498 {
2499     if (_obj2)
2500         delete _arg2;
2501 }
2502     return _resultobj;
2503 }
2504
2505 #define wxImage_SetOptionInt(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetOption(_swigarg0,_swigarg1))
2506 static PyObject *_wrap_wxImage_SetOptionInt(PyObject *self, PyObject *args, PyObject *kwargs) {
2507     PyObject * _resultobj;
2508     wxImage * _arg0;
2509     wxString * _arg1;
2510     int  _arg2;
2511     PyObject * _argo0 = 0;
2512     PyObject * _obj1 = 0;
2513     char *_kwnames[] = { "self","name","value", NULL };
2514
2515     self = self;
2516     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOi:wxImage_SetOptionInt",_kwnames,&_argo0,&_obj1,&_arg2))
2517         return NULL;
2518     if (_argo0) {
2519         if (_argo0 == Py_None) { _arg0 = NULL; }
2520         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2521             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetOptionInt. Expected _wxImage_p.");
2522         return NULL;
2523         }
2524     }
2525 {
2526 #if PYTHON_API_VERSION >= 1009
2527     char* tmpPtr; int tmpSize;
2528     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
2529         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2530         return NULL;
2531     }
2532     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
2533         return NULL;
2534     _arg1 = new wxString(tmpPtr, tmpSize);
2535 #else
2536     if (!PyString_Check(_obj1)) {
2537         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2538         return NULL;
2539     }
2540     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
2541 #endif
2542 }
2543 {
2544     PyThreadState* __tstate = wxPyBeginAllowThreads();
2545         wxImage_SetOptionInt(_arg0,*_arg1,_arg2);
2546
2547     wxPyEndAllowThreads(__tstate);
2548     if (PyErr_Occurred()) return NULL;
2549 }    Py_INCREF(Py_None);
2550     _resultobj = Py_None;
2551 {
2552     if (_obj1)
2553         delete _arg1;
2554 }
2555     return _resultobj;
2556 }
2557
2558 #define wxImage_GetOption(_swigobj,_swigarg0)  (_swigobj->GetOption(_swigarg0))
2559 static PyObject *_wrap_wxImage_GetOption(PyObject *self, PyObject *args, PyObject *kwargs) {
2560     PyObject * _resultobj;
2561     wxString * _result;
2562     wxImage * _arg0;
2563     wxString * _arg1;
2564     PyObject * _argo0 = 0;
2565     PyObject * _obj1 = 0;
2566     char *_kwnames[] = { "self","name", NULL };
2567
2568     self = self;
2569     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxImage_GetOption",_kwnames,&_argo0,&_obj1))
2570         return NULL;
2571     if (_argo0) {
2572         if (_argo0 == Py_None) { _arg0 = NULL; }
2573         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2574             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetOption. Expected _wxImage_p.");
2575         return NULL;
2576         }
2577     }
2578 {
2579 #if PYTHON_API_VERSION >= 1009
2580     char* tmpPtr; int tmpSize;
2581     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
2582         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2583         return NULL;
2584     }
2585     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
2586         return NULL;
2587     _arg1 = new wxString(tmpPtr, tmpSize);
2588 #else
2589     if (!PyString_Check(_obj1)) {
2590         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2591         return NULL;
2592     }
2593     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
2594 #endif
2595 }
2596 {
2597     PyThreadState* __tstate = wxPyBeginAllowThreads();
2598         _result = new wxString (wxImage_GetOption(_arg0,*_arg1));
2599
2600     wxPyEndAllowThreads(__tstate);
2601     if (PyErr_Occurred()) return NULL;
2602 }{
2603     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
2604 }
2605 {
2606     if (_obj1)
2607         delete _arg1;
2608 }
2609 {
2610     delete _result;
2611 }
2612     return _resultobj;
2613 }
2614
2615 #define wxImage_GetOptionInt(_swigobj,_swigarg0)  (_swigobj->GetOptionInt(_swigarg0))
2616 static PyObject *_wrap_wxImage_GetOptionInt(PyObject *self, PyObject *args, PyObject *kwargs) {
2617     PyObject * _resultobj;
2618     int  _result;
2619     wxImage * _arg0;
2620     wxString * _arg1;
2621     PyObject * _argo0 = 0;
2622     PyObject * _obj1 = 0;
2623     char *_kwnames[] = { "self","name", NULL };
2624
2625     self = self;
2626     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxImage_GetOptionInt",_kwnames,&_argo0,&_obj1))
2627         return NULL;
2628     if (_argo0) {
2629         if (_argo0 == Py_None) { _arg0 = NULL; }
2630         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2631             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetOptionInt. Expected _wxImage_p.");
2632         return NULL;
2633         }
2634     }
2635 {
2636 #if PYTHON_API_VERSION >= 1009
2637     char* tmpPtr; int tmpSize;
2638     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
2639         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2640         return NULL;
2641     }
2642     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
2643         return NULL;
2644     _arg1 = new wxString(tmpPtr, tmpSize);
2645 #else
2646     if (!PyString_Check(_obj1)) {
2647         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2648         return NULL;
2649     }
2650     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
2651 #endif
2652 }
2653 {
2654     PyThreadState* __tstate = wxPyBeginAllowThreads();
2655         _result = (int )wxImage_GetOptionInt(_arg0,*_arg1);
2656
2657     wxPyEndAllowThreads(__tstate);
2658     if (PyErr_Occurred()) return NULL;
2659 }    _resultobj = Py_BuildValue("i",_result);
2660 {
2661     if (_obj1)
2662         delete _arg1;
2663 }
2664     return _resultobj;
2665 }
2666
2667 #define wxImage_HasOption(_swigobj,_swigarg0)  (_swigobj->HasOption(_swigarg0))
2668 static PyObject *_wrap_wxImage_HasOption(PyObject *self, PyObject *args, PyObject *kwargs) {
2669     PyObject * _resultobj;
2670     bool  _result;
2671     wxImage * _arg0;
2672     wxString * _arg1;
2673     PyObject * _argo0 = 0;
2674     PyObject * _obj1 = 0;
2675     char *_kwnames[] = { "self","name", NULL };
2676
2677     self = self;
2678     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxImage_HasOption",_kwnames,&_argo0,&_obj1))
2679         return NULL;
2680     if (_argo0) {
2681         if (_argo0 == Py_None) { _arg0 = NULL; }
2682         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2683             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_HasOption. Expected _wxImage_p.");
2684         return NULL;
2685         }
2686     }
2687 {
2688 #if PYTHON_API_VERSION >= 1009
2689     char* tmpPtr; int tmpSize;
2690     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
2691         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2692         return NULL;
2693     }
2694     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
2695         return NULL;
2696     _arg1 = new wxString(tmpPtr, tmpSize);
2697 #else
2698     if (!PyString_Check(_obj1)) {
2699         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2700         return NULL;
2701     }
2702     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
2703 #endif
2704 }
2705 {
2706     PyThreadState* __tstate = wxPyBeginAllowThreads();
2707         _result = (bool )wxImage_HasOption(_arg0,*_arg1);
2708
2709     wxPyEndAllowThreads(__tstate);
2710     if (PyErr_Occurred()) return NULL;
2711 }    _resultobj = Py_BuildValue("i",_result);
2712 {
2713     if (_obj1)
2714         delete _arg1;
2715 }
2716     return _resultobj;
2717 }
2718
2719 #define wxImage_CountColours(_swigobj,_swigarg0)  (_swigobj->CountColours(_swigarg0))
2720 static PyObject *_wrap_wxImage_CountColours(PyObject *self, PyObject *args, PyObject *kwargs) {
2721     PyObject * _resultobj;
2722     unsigned long  _result;
2723     wxImage * _arg0;
2724     unsigned long  _arg1 = (unsigned long ) (unsigned long)-1;
2725     PyObject * _argo0 = 0;
2726     char *_kwnames[] = { "self","stopafter", NULL };
2727
2728     self = self;
2729     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|l:wxImage_CountColours",_kwnames,&_argo0,&_arg1))
2730         return NULL;
2731     if (_argo0) {
2732         if (_argo0 == Py_None) { _arg0 = NULL; }
2733         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2734             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_CountColours. Expected _wxImage_p.");
2735         return NULL;
2736         }
2737     }
2738 {
2739     PyThreadState* __tstate = wxPyBeginAllowThreads();
2740         _result = (unsigned long )wxImage_CountColours(_arg0,_arg1);
2741
2742     wxPyEndAllowThreads(__tstate);
2743     if (PyErr_Occurred()) return NULL;
2744 }    _resultobj = Py_BuildValue("l",_result);
2745     return _resultobj;
2746 }
2747
2748 static PyObject *_wrap_wxImage_AddHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
2749     PyObject * _resultobj;
2750     wxImageHandler * _arg0;
2751     PyObject * _argo0 = 0;
2752     char *_kwnames[] = { "handler", NULL };
2753
2754     self = self;
2755     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_AddHandler",_kwnames,&_argo0))
2756         return NULL;
2757     if (_argo0) {
2758         if (_argo0 == Py_None) { _arg0 = NULL; }
2759         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImageHandler_p")) {
2760             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_AddHandler. Expected _wxImageHandler_p.");
2761         return NULL;
2762         }
2763     }
2764 {
2765     PyThreadState* __tstate = wxPyBeginAllowThreads();
2766         wxImage::AddHandler(_arg0);
2767
2768     wxPyEndAllowThreads(__tstate);
2769     if (PyErr_Occurred()) return NULL;
2770 }    Py_INCREF(Py_None);
2771     _resultobj = Py_None;
2772     return _resultobj;
2773 }
2774
2775 static PyObject *_wrap_wxImage_InsertHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
2776     PyObject * _resultobj;
2777     wxImageHandler * _arg0;
2778     PyObject * _argo0 = 0;
2779     char *_kwnames[] = { "handler", NULL };
2780
2781     self = self;
2782     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_InsertHandler",_kwnames,&_argo0))
2783         return NULL;
2784     if (_argo0) {
2785         if (_argo0 == Py_None) { _arg0 = NULL; }
2786         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImageHandler_p")) {
2787             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_InsertHandler. Expected _wxImageHandler_p.");
2788         return NULL;
2789         }
2790     }
2791 {
2792     PyThreadState* __tstate = wxPyBeginAllowThreads();
2793         wxImage::InsertHandler(_arg0);
2794
2795     wxPyEndAllowThreads(__tstate);
2796     if (PyErr_Occurred()) return NULL;
2797 }    Py_INCREF(Py_None);
2798     _resultobj = Py_None;
2799     return _resultobj;
2800 }
2801
2802 static PyObject *_wrap_wxImage_RemoveHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
2803     PyObject * _resultobj;
2804     bool  _result;
2805     wxString * _arg0;
2806     PyObject * _obj0 = 0;
2807     char *_kwnames[] = { "name", NULL };
2808
2809     self = self;
2810     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_RemoveHandler",_kwnames,&_obj0))
2811         return NULL;
2812 {
2813 #if PYTHON_API_VERSION >= 1009
2814     char* tmpPtr; int tmpSize;
2815     if (!PyString_Check(_obj0) && !PyUnicode_Check(_obj0)) {
2816         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2817         return NULL;
2818     }
2819     if (PyString_AsStringAndSize(_obj0, &tmpPtr, &tmpSize) == -1)
2820         return NULL;
2821     _arg0 = new wxString(tmpPtr, tmpSize);
2822 #else
2823     if (!PyString_Check(_obj0)) {
2824         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2825         return NULL;
2826     }
2827     _arg0 = new wxString(PyString_AS_STRING(_obj0), PyString_GET_SIZE(_obj0));
2828 #endif
2829 }
2830 {
2831     PyThreadState* __tstate = wxPyBeginAllowThreads();
2832         _result = (bool )wxImage::RemoveHandler(*_arg0);
2833
2834     wxPyEndAllowThreads(__tstate);
2835     if (PyErr_Occurred()) return NULL;
2836 }    _resultobj = Py_BuildValue("i",_result);
2837 {
2838     if (_obj0)
2839         delete _arg0;
2840 }
2841     return _resultobj;
2842 }
2843
2844 static PyMethodDef imagecMethods[] = {
2845          { "wxImage_RemoveHandler", (PyCFunction) _wrap_wxImage_RemoveHandler, METH_VARARGS | METH_KEYWORDS },
2846          { "wxImage_InsertHandler", (PyCFunction) _wrap_wxImage_InsertHandler, METH_VARARGS | METH_KEYWORDS },
2847          { "wxImage_AddHandler", (PyCFunction) _wrap_wxImage_AddHandler, METH_VARARGS | METH_KEYWORDS },
2848          { "wxImage_CountColours", (PyCFunction) _wrap_wxImage_CountColours, METH_VARARGS | METH_KEYWORDS },
2849          { "wxImage_HasOption", (PyCFunction) _wrap_wxImage_HasOption, METH_VARARGS | METH_KEYWORDS },
2850          { "wxImage_GetOptionInt", (PyCFunction) _wrap_wxImage_GetOptionInt, METH_VARARGS | METH_KEYWORDS },
2851          { "wxImage_GetOption", (PyCFunction) _wrap_wxImage_GetOption, METH_VARARGS | METH_KEYWORDS },
2852          { "wxImage_SetOptionInt", (PyCFunction) _wrap_wxImage_SetOptionInt, METH_VARARGS | METH_KEYWORDS },
2853          { "wxImage_SetOption", (PyCFunction) _wrap_wxImage_SetOption, METH_VARARGS | METH_KEYWORDS },
2854          { "wxImage_ConvertToMono", (PyCFunction) _wrap_wxImage_ConvertToMono, METH_VARARGS | METH_KEYWORDS },
2855          { "wxImage_Replace", (PyCFunction) _wrap_wxImage_Replace, METH_VARARGS | METH_KEYWORDS },
2856          { "wxImage_Mirror", (PyCFunction) _wrap_wxImage_Mirror, METH_VARARGS | METH_KEYWORDS },
2857          { "wxImage_Rotate90", (PyCFunction) _wrap_wxImage_Rotate90, METH_VARARGS | METH_KEYWORDS },
2858          { "wxImage_Rotate", (PyCFunction) _wrap_wxImage_Rotate, METH_VARARGS | METH_KEYWORDS },
2859          { "wxImage_HasMask", (PyCFunction) _wrap_wxImage_HasMask, METH_VARARGS | METH_KEYWORDS },
2860          { "wxImage_SetMask", (PyCFunction) _wrap_wxImage_SetMask, METH_VARARGS | METH_KEYWORDS },
2861          { "wxImage_GetMaskBlue", (PyCFunction) _wrap_wxImage_GetMaskBlue, METH_VARARGS | METH_KEYWORDS },
2862          { "wxImage_GetMaskGreen", (PyCFunction) _wrap_wxImage_GetMaskGreen, METH_VARARGS | METH_KEYWORDS },
2863          { "wxImage_GetMaskRed", (PyCFunction) _wrap_wxImage_GetMaskRed, METH_VARARGS | METH_KEYWORDS },
2864          { "wxImage_SetMaskColour", (PyCFunction) _wrap_wxImage_SetMaskColour, METH_VARARGS | METH_KEYWORDS },
2865          { "wxImage_SetData", (PyCFunction) _wrap_wxImage_SetData, METH_VARARGS | METH_KEYWORDS },
2866          { "wxImage_GetData", (PyCFunction) _wrap_wxImage_GetData, METH_VARARGS | METH_KEYWORDS },
2867          { "wxImage_Paste", (PyCFunction) _wrap_wxImage_Paste, METH_VARARGS | METH_KEYWORDS },
2868          { "wxImage_Copy", (PyCFunction) _wrap_wxImage_Copy, METH_VARARGS | METH_KEYWORDS },
2869          { "wxImage_GetSubImage", (PyCFunction) _wrap_wxImage_GetSubImage, METH_VARARGS | METH_KEYWORDS },
2870          { "wxImage_GetHeight", (PyCFunction) _wrap_wxImage_GetHeight, METH_VARARGS | METH_KEYWORDS },
2871          { "wxImage_GetWidth", (PyCFunction) _wrap_wxImage_GetWidth, METH_VARARGS | METH_KEYWORDS },
2872          { "wxImage_Ok", (PyCFunction) _wrap_wxImage_Ok, METH_VARARGS | METH_KEYWORDS },
2873          { "wxImage_SaveMimeFile", (PyCFunction) _wrap_wxImage_SaveMimeFile, METH_VARARGS | METH_KEYWORDS },
2874          { "wxImage_SaveFile", (PyCFunction) _wrap_wxImage_SaveFile, METH_VARARGS | METH_KEYWORDS },
2875          { "wxImage_LoadMimeFile", (PyCFunction) _wrap_wxImage_LoadMimeFile, METH_VARARGS | METH_KEYWORDS },
2876          { "wxImage_LoadFile", (PyCFunction) _wrap_wxImage_LoadFile, METH_VARARGS | METH_KEYWORDS },
2877          { "wxImage_GetImageCount", (PyCFunction) _wrap_wxImage_GetImageCount, METH_VARARGS | METH_KEYWORDS },
2878          { "wxImage_CanRead", (PyCFunction) _wrap_wxImage_CanRead, METH_VARARGS | METH_KEYWORDS },
2879          { "wxImage_GetBlue", (PyCFunction) _wrap_wxImage_GetBlue, METH_VARARGS | METH_KEYWORDS },
2880          { "wxImage_GetGreen", (PyCFunction) _wrap_wxImage_GetGreen, METH_VARARGS | METH_KEYWORDS },
2881          { "wxImage_GetRed", (PyCFunction) _wrap_wxImage_GetRed, METH_VARARGS | METH_KEYWORDS },
2882          { "wxImage_SetRGB", (PyCFunction) _wrap_wxImage_SetRGB, METH_VARARGS | METH_KEYWORDS },
2883          { "wxImage_Rescale", (PyCFunction) _wrap_wxImage_Rescale, METH_VARARGS | METH_KEYWORDS },
2884          { "wxImage_Scale", (PyCFunction) _wrap_wxImage_Scale, METH_VARARGS | METH_KEYWORDS },
2885          { "wxImage_Destroy", (PyCFunction) _wrap_wxImage_Destroy, METH_VARARGS | METH_KEYWORDS },
2886          { "wxImage_Create", (PyCFunction) _wrap_wxImage_Create, METH_VARARGS | METH_KEYWORDS },
2887          { "wxImage_ConvertToBitmap", (PyCFunction) _wrap_wxImage_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS },
2888          { "delete_wxImage", (PyCFunction) _wrap_delete_wxImage, METH_VARARGS | METH_KEYWORDS },
2889          { "new_wxImage", (PyCFunction) _wrap_new_wxImage, METH_VARARGS | METH_KEYWORDS },
2890          { "new_wxTIFFHandler", (PyCFunction) _wrap_new_wxTIFFHandler, METH_VARARGS | METH_KEYWORDS },
2891          { "new_wxPCXHandler", (PyCFunction) _wrap_new_wxPCXHandler, METH_VARARGS | METH_KEYWORDS },
2892          { "new_wxPNMHandler", (PyCFunction) _wrap_new_wxPNMHandler, METH_VARARGS | METH_KEYWORDS },
2893          { "new_wxGIFHandler", (PyCFunction) _wrap_new_wxGIFHandler, METH_VARARGS | METH_KEYWORDS },
2894          { "new_wxICOHandler", (PyCFunction) _wrap_new_wxICOHandler, METH_VARARGS | METH_KEYWORDS },
2895          { "new_wxBMPHandler", (PyCFunction) _wrap_new_wxBMPHandler, METH_VARARGS | METH_KEYWORDS },
2896          { "new_wxJPEGHandler", (PyCFunction) _wrap_new_wxJPEGHandler, METH_VARARGS | METH_KEYWORDS },
2897          { "new_wxPNGHandler", (PyCFunction) _wrap_new_wxPNGHandler, METH_VARARGS | METH_KEYWORDS },
2898          { "wxImageHandler_SetMimeType", (PyCFunction) _wrap_wxImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS },
2899          { "wxImageHandler_SetType", (PyCFunction) _wrap_wxImageHandler_SetType, METH_VARARGS | METH_KEYWORDS },
2900          { "wxImageHandler_SetExtension", (PyCFunction) _wrap_wxImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS },
2901          { "wxImageHandler_SetName", (PyCFunction) _wrap_wxImageHandler_SetName, METH_VARARGS | METH_KEYWORDS },
2902          { "wxImageHandler_CanRead", (PyCFunction) _wrap_wxImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS },
2903          { "wxImageHandler_GetMimeType", (PyCFunction) _wrap_wxImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS },
2904          { "wxImageHandler_GetType", (PyCFunction) _wrap_wxImageHandler_GetType, METH_VARARGS | METH_KEYWORDS },
2905          { "wxImageHandler_GetExtension", (PyCFunction) _wrap_wxImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS },
2906          { "wxImageHandler_GetName", (PyCFunction) _wrap_wxImageHandler_GetName, METH_VARARGS | METH_KEYWORDS },
2907          { "wxBitmapFromImage", (PyCFunction) _wrap_wxBitmapFromImage, METH_VARARGS | METH_KEYWORDS },
2908          { "wxInitAllImageHandlers", (PyCFunction) _wrap_wxInitAllImageHandlers, METH_VARARGS | METH_KEYWORDS },
2909          { "wxImageFromData", (PyCFunction) _wrap_wxImageFromData, METH_VARARGS | METH_KEYWORDS },
2910          { "wxImageFromBitmap", (PyCFunction) _wrap_wxImageFromBitmap, METH_VARARGS | METH_KEYWORDS },
2911          { "wxImageFromMime", (PyCFunction) _wrap_wxImageFromMime, METH_VARARGS | METH_KEYWORDS },
2912          { "wxEmptyImage", (PyCFunction) _wrap_wxEmptyImage, METH_VARARGS | METH_KEYWORDS },
2913          { NULL, NULL }
2914 };
2915 #ifdef __cplusplus
2916 }
2917 #endif
2918 /*
2919  * This table is used by the pointer type-checker
2920  */
2921 static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {
2922     { "_signed_long","_long",0},
2923     { "_wxBMPHandler","_wxICOHandler",SwigwxICOHandlerTowxBMPHandler},
2924     { "_wxPrintQuality","_wxCoord",0},
2925     { "_wxPrintQuality","_int",0},
2926     { "_wxPrintQuality","_signed_int",0},
2927     { "_wxPrintQuality","_unsigned_int",0},
2928     { "_wxPrintQuality","_wxWindowID",0},
2929     { "_wxPrintQuality","_uint",0},
2930     { "_wxPrintQuality","_EBool",0},
2931     { "_wxPrintQuality","_size_t",0},
2932     { "_wxPrintQuality","_time_t",0},
2933     { "_wxImageHandler","_wxTIFFHandler",SwigwxTIFFHandlerTowxImageHandler},
2934     { "_wxImageHandler","_wxPCXHandler",SwigwxPCXHandlerTowxImageHandler},
2935     { "_wxImageHandler","_wxPNMHandler",SwigwxPNMHandlerTowxImageHandler},
2936     { "_wxImageHandler","_wxGIFHandler",SwigwxGIFHandlerTowxImageHandler},
2937     { "_wxImageHandler","_wxICOHandler",SwigwxICOHandlerTowxImageHandler},
2938     { "_wxImageHandler","_wxBMPHandler",SwigwxBMPHandlerTowxImageHandler},
2939     { "_wxImageHandler","_wxJPEGHandler",SwigwxJPEGHandlerTowxImageHandler},
2940     { "_wxImageHandler","_wxPNGHandler",SwigwxPNGHandlerTowxImageHandler},
2941     { "_byte","_unsigned_char",0},
2942     { "_long","_unsigned_long",0},
2943     { "_long","_signed_long",0},
2944     { "_size_t","_wxCoord",0},
2945     { "_size_t","_wxPrintQuality",0},
2946     { "_size_t","_time_t",0},
2947     { "_size_t","_unsigned_int",0},
2948     { "_size_t","_int",0},
2949     { "_size_t","_wxWindowID",0},
2950     { "_size_t","_uint",0},
2951     { "_uint","_wxCoord",0},
2952     { "_uint","_wxPrintQuality",0},
2953     { "_uint","_time_t",0},
2954     { "_uint","_size_t",0},
2955     { "_uint","_unsigned_int",0},
2956     { "_uint","_int",0},
2957     { "_uint","_wxWindowID",0},
2958     { "_wxChar","_char",0},
2959     { "_char","_wxChar",0},
2960     { "_struct_wxNativeFontInfo","_wxNativeFontInfo",0},
2961     { "_EBool","_wxCoord",0},
2962     { "_EBool","_wxPrintQuality",0},
2963     { "_EBool","_signed_int",0},
2964     { "_EBool","_int",0},
2965     { "_EBool","_wxWindowID",0},
2966     { "_unsigned_long","_long",0},
2967     { "_wxNativeFontInfo","_struct_wxNativeFontInfo",0},
2968     { "_signed_int","_wxCoord",0},
2969     { "_signed_int","_wxPrintQuality",0},
2970     { "_signed_int","_EBool",0},
2971     { "_signed_int","_wxWindowID",0},
2972     { "_signed_int","_int",0},
2973     { "_WXTYPE","_short",0},
2974     { "_WXTYPE","_signed_short",0},
2975     { "_WXTYPE","_unsigned_short",0},
2976     { "_unsigned_short","_WXTYPE",0},
2977     { "_unsigned_short","_short",0},
2978     { "_wxObject","_wxImage",SwigwxImageTowxObject},
2979     { "_wxObject","_wxTIFFHandler",SwigwxTIFFHandlerTowxObject},
2980     { "_wxObject","_wxPCXHandler",SwigwxPCXHandlerTowxObject},
2981     { "_wxObject","_wxPNMHandler",SwigwxPNMHandlerTowxObject},
2982     { "_wxObject","_wxGIFHandler",SwigwxGIFHandlerTowxObject},
2983     { "_wxObject","_wxICOHandler",SwigwxICOHandlerTowxObject},
2984     { "_wxObject","_wxBMPHandler",SwigwxBMPHandlerTowxObject},
2985     { "_wxObject","_wxJPEGHandler",SwigwxJPEGHandlerTowxObject},
2986     { "_wxObject","_wxPNGHandler",SwigwxPNGHandlerTowxObject},
2987     { "_wxObject","_wxImageHandler",SwigwxImageHandlerTowxObject},
2988     { "_signed_short","_WXTYPE",0},
2989     { "_signed_short","_short",0},
2990     { "_unsigned_char","_byte",0},
2991     { "_unsigned_int","_wxCoord",0},
2992     { "_unsigned_int","_wxPrintQuality",0},
2993     { "_unsigned_int","_time_t",0},
2994     { "_unsigned_int","_size_t",0},
2995     { "_unsigned_int","_uint",0},
2996     { "_unsigned_int","_wxWindowID",0},
2997     { "_unsigned_int","_int",0},
2998     { "_short","_WXTYPE",0},
2999     { "_short","_unsigned_short",0},
3000     { "_short","_signed_short",0},
3001     { "_wxWindowID","_wxCoord",0},
3002     { "_wxWindowID","_wxPrintQuality",0},
3003     { "_wxWindowID","_time_t",0},
3004     { "_wxWindowID","_size_t",0},
3005     { "_wxWindowID","_EBool",0},
3006     { "_wxWindowID","_uint",0},
3007     { "_wxWindowID","_int",0},
3008     { "_wxWindowID","_signed_int",0},
3009     { "_wxWindowID","_unsigned_int",0},
3010     { "_int","_wxCoord",0},
3011     { "_int","_wxPrintQuality",0},
3012     { "_int","_time_t",0},
3013     { "_int","_size_t",0},
3014     { "_int","_EBool",0},
3015     { "_int","_uint",0},
3016     { "_int","_wxWindowID",0},
3017     { "_int","_unsigned_int",0},
3018     { "_int","_signed_int",0},
3019     { "_time_t","_wxCoord",0},
3020     { "_time_t","_wxPrintQuality",0},
3021     { "_time_t","_unsigned_int",0},
3022     { "_time_t","_int",0},
3023     { "_time_t","_wxWindowID",0},
3024     { "_time_t","_uint",0},
3025     { "_time_t","_size_t",0},
3026     { "_wxCoord","_int",0},
3027     { "_wxCoord","_signed_int",0},
3028     { "_wxCoord","_unsigned_int",0},
3029     { "_wxCoord","_wxWindowID",0},
3030     { "_wxCoord","_uint",0},
3031     { "_wxCoord","_EBool",0},
3032     { "_wxCoord","_size_t",0},
3033     { "_wxCoord","_time_t",0},
3034     { "_wxCoord","_wxPrintQuality",0},
3035 {0,0,0}};
3036
3037 static PyObject *SWIG_globals;
3038 #ifdef __cplusplus
3039 extern "C"
3040 #endif
3041 SWIGEXPORT(void) initimagec() {
3042          PyObject *m, *d;
3043          SWIG_globals = SWIG_newvarlink();
3044          m = Py_InitModule("imagec", imagecMethods);
3045          d = PyModule_GetDict(m);
3046          PyDict_SetItemString(d,"cvar", SWIG_globals);
3047          SWIG_addvarlink(SWIG_globals,"wxNullImage",_wrap_wxNullImage_get, _wrap_wxNullImage_set);
3048 {
3049    int i;
3050    for (i = 0; _swig_mapping[i].n1; i++)
3051         SWIG_RegisterMapping(_swig_mapping[i].n1,_swig_mapping[i].n2,_swig_mapping[i].pcnv);
3052 }
3053 }