wxPython/src/mac/image.cpp

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