wxPython/src/gtk/image.cpp

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