wxPython/src/mac/image.cpp

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