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