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