wxPython/src/gtk/image.cpp

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