wxPython/src/gtk/image.cpp

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